sim/common/sim-module.c

   1 /* Module support.
   2
   3    Copyright 1996-2023 Free Software Foundation, Inc.
   4
   5    Contributed by Cygnus Support.
   6
   7 This file is part of GDB, the GNU debugger.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 /* This must come before any other includes.  */
  23 #include "defs.h"
  24
  25 #include <stdlib.h>
  26
  27 #include "libiberty.h"
  28
  29 #include "sim-main.h"
  30 #include "sim-io.h"
  31 #include "sim-options.h"
  32 #include "sim-assert.h"
  33
  34 /* List of all early/core modules.
  35    TODO: Should trim this list by converting to sim_install_* framework.  */
  36 static MODULE_INSTALL_FN * const early_modules[] = {
  37   standard_install,
  38   sim_events_install,
  39   sim_model_install,
  40   sim_core_install,
  41   sim_memopt_install,
  42   sim_watchpoint_install,
  43 };
  44 static int early_modules_len = ARRAY_SIZE (early_modules);
  45
  46 /* List of dynamically detected modules.  Declared in generated modules.c.  */
  47 extern MODULE_INSTALL_FN * const sim_modules_detected[];
  48 extern const int sim_modules_detected_len;
  49 \f
  50 /* Functions called from sim_open.  */
  51
  52 /* Initialize common parts before argument processing.  */
  53
  54 SIM_RC
  55 sim_pre_argv_init (SIM_DESC sd, const char *myname)
  56 {
  57   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  58   SIM_ASSERT (STATE_MODULES (sd) == NULL);
  59
  60   STATE_MY_NAME (sd) = lbasename (myname);
  61
  62   /* Set the cpu names to default values.  */
  63   {
  64     int i;
  65     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
  66       {
  67         char *name;
  68         if (asprintf (&name, "cpu%d", i) < 0)
  69           return SIM_RC_FAIL;
  70         CPU_NAME (STATE_CPU (sd, i)) = name;
  71       }
  72   }
  73
  74   sim_config_default (sd);
  75
  76   /* Install all early configured-in modules.  */
  77   if (sim_module_install (sd) != SIM_RC_OK)
  78     return SIM_RC_FAIL;
  79
  80   /* Install all remaining dynamically detected modules.  */
  81   return sim_module_install_list (sd, sim_modules_detected,
  82                                   sim_modules_detected_len);
  83 }
  84
  85 /* Initialize common parts after argument processing.  */
  86
  87 SIM_RC
  88 sim_post_argv_init (SIM_DESC sd)
  89 {
  90   int i;
  91   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  92   SIM_ASSERT (STATE_MODULES (sd) != NULL);
  93
  94   /* Set the cpu->state backlinks for each cpu.  */
  95   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
  96     {
  97       CPU_STATE (STATE_CPU (sd, i)) = sd;
  98       CPU_INDEX (STATE_CPU (sd, i)) = i;
  99     }
 100
 101   if (sim_module_init (sd) != SIM_RC_OK)
 102     return SIM_RC_FAIL;
 103
 104   return SIM_RC_OK;
 105 }
 106 \f
 107 /* Install a list of modules.
 108    If this fails, no modules are left installed.  */
 109 SIM_RC
 110 sim_module_install_list (SIM_DESC sd, MODULE_INSTALL_FN * const *modules,
 111                          size_t modules_len)
 112 {
 113   size_t i;
 114
 115   for (i = 0; i < modules_len; ++i)
 116     {
 117       MODULE_INSTALL_FN *modp = modules[i];
 118
 119       if (modp != NULL && modp (sd) != SIM_RC_OK)
 120         {
 121           sim_module_uninstall (sd);
 122           SIM_ASSERT (STATE_MODULES (sd) == NULL);
 123           return SIM_RC_FAIL;
 124         }
 125     }
 126
 127   return SIM_RC_OK;
 128 }
 129
 130 /* Install all modules.
 131    If this fails, no modules are left installed.  */
 132
 133 SIM_RC
 134 sim_module_install (SIM_DESC sd)
 135 {
 136   MODULE_INSTALL_FN * const *modp;
 137
 138   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 139   SIM_ASSERT (STATE_MODULES (sd) == NULL);
 140
 141   STATE_MODULES (sd) = ZALLOC (struct module_list);
 142   return sim_module_install_list (sd, early_modules, early_modules_len);
 143 }
 144
 145 /* Called after all modules have been installed and after argv
 146    has been processed.  */
 147
 148 SIM_RC
 149 sim_module_init (SIM_DESC sd)
 150 {
 151   struct module_list *modules = STATE_MODULES (sd);
 152   MODULE_INIT_LIST *modp;
 153
 154   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 155   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 156
 157   for (modp = modules->init_list; modp != NULL; modp = modp->next)
 158     {
 159       if ((*modp->fn) (sd) != SIM_RC_OK)
 160         return SIM_RC_FAIL;
 161     }
 162   return SIM_RC_OK;
 163 }
 164
 165 /* Called when ever the simulator is resumed */
 166
 167 SIM_RC
 168 sim_module_resume (SIM_DESC sd)
 169 {
 170   struct module_list *modules = STATE_MODULES (sd);
 171   MODULE_RESUME_LIST *modp;
 172
 173   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 174   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 175
 176   for (modp = modules->resume_list; modp != NULL; modp = modp->next)
 177     {
 178       if ((*modp->fn) (sd) != SIM_RC_OK)
 179         return SIM_RC_FAIL;
 180     }
 181   return SIM_RC_OK;
 182 }
 183
 184 /* Called when ever the simulator is suspended */
 185
 186 SIM_RC
 187 sim_module_suspend (SIM_DESC sd)
 188 {
 189   struct module_list *modules = STATE_MODULES (sd);
 190   MODULE_SUSPEND_LIST *modp;
 191
 192   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 193   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 194
 195   for (modp = modules->suspend_list; modp != NULL; modp = modp->next)
 196     {
 197       if ((*modp->fn) (sd) != SIM_RC_OK)
 198         return SIM_RC_FAIL;
 199     }
 200   return SIM_RC_OK;
 201 }
 202
 203 /* Uninstall installed modules, called by sim_close.  */
 204
 205 void
 206 sim_module_uninstall (SIM_DESC sd)
 207 {
 208   struct module_list *modules = STATE_MODULES (sd);
 209   MODULE_UNINSTALL_LIST *modp;
 210
 211   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 212   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 213
 214   /* Uninstall the modules.  */
 215   for (modp = modules->uninstall_list; modp != NULL; modp = modp->next)
 216     (*modp->fn) (sd);
 217
 218   /* clean-up init list */
 219   {
 220     MODULE_INIT_LIST *n, *d;
 221     for (d = modules->init_list; d != NULL; d = n)
 222       {
 223         n = d->next;
 224         free (d);
 225       }
 226   }
 227
 228   /* clean-up resume list */
 229   {
 230     MODULE_RESUME_LIST *n, *d;
 231     for (d = modules->resume_list; d != NULL; d = n)
 232       {
 233         n = d->next;
 234         free (d);
 235       }
 236   }
 237
 238   /* clean-up suspend list */
 239   {
 240     MODULE_SUSPEND_LIST *n, *d;
 241     for (d = modules->suspend_list; d != NULL; d = n)
 242       {
 243         n = d->next;
 244         free (d);
 245       }
 246   }
 247
 248   /* clean-up uninstall list */
 249   {
 250     MODULE_UNINSTALL_LIST *n, *d;
 251     for (d = modules->uninstall_list; d != NULL; d = n)
 252       {
 253         n = d->next;
 254         free (d);
 255       }
 256   }
 257
 258   /* clean-up info list */
 259   {
 260     MODULE_INFO_LIST *n, *d;
 261     for (d = modules->info_list; d != NULL; d = n)
 262       {
 263         n = d->next;
 264         free (d);
 265       }
 266   }
 267
 268   free (modules);
 269   STATE_MODULES (sd) = NULL;
 270 }
 271
 272 /* Called when ever simulator info is needed */
 273
 274 void
 275 sim_module_info (SIM_DESC sd, int verbose)
 276 {
 277   struct module_list *modules = STATE_MODULES (sd);
 278   MODULE_INFO_LIST *modp;
 279
 280   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 281   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 282
 283   for (modp = modules->info_list; modp != NULL; modp = modp->next)
 284     {
 285       (*modp->fn) (sd, verbose);
 286     }
 287 }
 288 \f
 289 /* Add FN to the init handler list.
 290    init in the same order as the install. */
 291
 292 void
 293 sim_module_add_init_fn (SIM_DESC sd, MODULE_INIT_FN fn)
 294 {
 295   struct module_list *modules = STATE_MODULES (sd);
 296   MODULE_INIT_LIST *l = ZALLOC (MODULE_INIT_LIST);
 297   MODULE_INIT_LIST **last;
 298
 299   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 300   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 301
 302   last = &modules->init_list;
 303   while (*last != NULL)
 304     last = &((*last)->next);
 305
 306   l->fn = fn;
 307   l->next = NULL;
 308   *last = l;
 309 }
 310
 311 /* Add FN to the resume handler list.
 312    resume in the same order as the install. */
 313
 314 void
 315 sim_module_add_resume_fn (SIM_DESC sd, MODULE_RESUME_FN fn)
 316 {
 317   struct module_list *modules = STATE_MODULES (sd);
 318   MODULE_RESUME_LIST *l = ZALLOC (MODULE_RESUME_LIST);
 319   MODULE_RESUME_LIST **last;
 320
 321   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 322   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 323
 324   last = &modules->resume_list;
 325   while (*last != NULL)
 326     last = &((*last)->next);
 327
 328   l->fn = fn;
 329   l->next = NULL;
 330   *last = l;
 331 }
 332
 333 /* Add FN to the init handler list.
 334    suspend in the reverse order to install. */
 335
 336 void
 337 sim_module_add_suspend_fn (SIM_DESC sd, MODULE_SUSPEND_FN fn)
 338 {
 339   struct module_list *modules = STATE_MODULES (sd);
 340   MODULE_SUSPEND_LIST *l = ZALLOC (MODULE_SUSPEND_LIST);
 341   MODULE_SUSPEND_LIST **last;
 342
 343   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 344   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 345
 346   last = &modules->suspend_list;
 347   while (*last != NULL)
 348     last = &((*last)->next);
 349
 350   l->fn = fn;
 351   l->next = modules->suspend_list;
 352   modules->suspend_list = l;
 353 }
 354
 355 /* Add FN to the uninstall handler list.
 356    Uninstall in reverse order to install.  */
 357
 358 void
 359 sim_module_add_uninstall_fn (SIM_DESC sd, MODULE_UNINSTALL_FN fn)
 360 {
 361   struct module_list *modules = STATE_MODULES (sd);
 362   MODULE_UNINSTALL_LIST *l = ZALLOC (MODULE_UNINSTALL_LIST);
 363
 364   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 365   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 366
 367   l->fn = fn;
 368   l->next = modules->uninstall_list;
 369   modules->uninstall_list = l;
 370 }
 371
 372 /* Add FN to the info handler list.
 373    Report info in the same order as the install. */
 374
 375 void
 376 sim_module_add_info_fn (SIM_DESC sd, MODULE_INFO_FN fn)
 377 {
 378   struct module_list *modules = STATE_MODULES (sd);
 379   MODULE_INFO_LIST *l = ZALLOC (MODULE_INFO_LIST);
 380   MODULE_INFO_LIST **last;
 381
 382   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 383   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 384
 385   last = &modules->info_list;
 386   while (*last != NULL)
 387     last = &((*last)->next);
 388
 389   l->fn = fn;
 390   l->next = NULL;
 391   *last = l;
 392 }