sim/common/sim-module.c

   1 /* Module support.
   2
   3    Copyright 1996-2024 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   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 137   SIM_ASSERT (STATE_MODULES (sd) == NULL);
 138
 139   STATE_MODULES (sd) = ZALLOC (struct module_list);
 140   return sim_module_install_list (sd, early_modules, early_modules_len);
 141 }
 142
 143 /* Called after all modules have been installed and after argv
 144    has been processed.  */
 145
 146 SIM_RC
 147 sim_module_init (SIM_DESC sd)
 148 {
 149   struct module_list *modules = STATE_MODULES (sd);
 150   MODULE_INIT_LIST *modp;
 151
 152   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 153   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 154
 155   for (modp = modules->init_list; modp != NULL; modp = modp->next)
 156     {
 157       if ((*modp->fn) (sd) != SIM_RC_OK)
 158         return SIM_RC_FAIL;
 159     }
 160   return SIM_RC_OK;
 161 }
 162
 163 /* Called when ever the simulator is resumed */
 164
 165 SIM_RC
 166 sim_module_resume (SIM_DESC sd)
 167 {
 168   struct module_list *modules = STATE_MODULES (sd);
 169   MODULE_RESUME_LIST *modp;
 170
 171   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 172   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 173
 174   for (modp = modules->resume_list; modp != NULL; modp = modp->next)
 175     {
 176       if ((*modp->fn) (sd) != SIM_RC_OK)
 177         return SIM_RC_FAIL;
 178     }
 179   return SIM_RC_OK;
 180 }
 181
 182 /* Called when ever the simulator is suspended */
 183
 184 SIM_RC
 185 sim_module_suspend (SIM_DESC sd)
 186 {
 187   struct module_list *modules = STATE_MODULES (sd);
 188   MODULE_SUSPEND_LIST *modp;
 189
 190   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 191   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 192
 193   for (modp = modules->suspend_list; modp != NULL; modp = modp->next)
 194     {
 195       if ((*modp->fn) (sd) != SIM_RC_OK)
 196         return SIM_RC_FAIL;
 197     }
 198   return SIM_RC_OK;
 199 }
 200
 201 /* Uninstall installed modules, called by sim_close.  */
 202
 203 void
 204 sim_module_uninstall (SIM_DESC sd)
 205 {
 206   struct module_list *modules = STATE_MODULES (sd);
 207   MODULE_UNINSTALL_LIST *modp;
 208
 209   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 210   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 211
 212   /* Uninstall the modules.  */
 213   for (modp = modules->uninstall_list; modp != NULL; modp = modp->next)
 214     (*modp->fn) (sd);
 215
 216   /* clean-up init list */
 217   {
 218     MODULE_INIT_LIST *n, *d;
 219     for (d = modules->init_list; d != NULL; d = n)
 220       {
 221         n = d->next;
 222         free (d);
 223       }
 224   }
 225
 226   /* clean-up resume list */
 227   {
 228     MODULE_RESUME_LIST *n, *d;
 229     for (d = modules->resume_list; d != NULL; d = n)
 230       {
 231         n = d->next;
 232         free (d);
 233       }
 234   }
 235
 236   /* clean-up suspend list */
 237   {
 238     MODULE_SUSPEND_LIST *n, *d;
 239     for (d = modules->suspend_list; d != NULL; d = n)
 240       {
 241         n = d->next;
 242         free (d);
 243       }
 244   }
 245
 246   /* clean-up uninstall list */
 247   {
 248     MODULE_UNINSTALL_LIST *n, *d;
 249     for (d = modules->uninstall_list; d != NULL; d = n)
 250       {
 251         n = d->next;
 252         free (d);
 253       }
 254   }
 255
 256   /* clean-up info list */
 257   {
 258     MODULE_INFO_LIST *n, *d;
 259     for (d = modules->info_list; d != NULL; d = n)
 260       {
 261         n = d->next;
 262         free (d);
 263       }
 264   }
 265
 266   free (modules);
 267   STATE_MODULES (sd) = NULL;
 268 }
 269
 270 /* Called when ever simulator info is needed */
 271
 272 void
 273 sim_module_info (SIM_DESC sd, bool verbose)
 274 {
 275   struct module_list *modules = STATE_MODULES (sd);
 276   MODULE_INFO_LIST *modp;
 277
 278   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 279   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 280
 281   for (modp = modules->info_list; modp != NULL; modp = modp->next)
 282     {
 283       (*modp->fn) (sd, verbose);
 284     }
 285 }
 286 \f
 287 /* Add FN to the init handler list.
 288    init in the same order as the install. */
 289
 290 void
 291 sim_module_add_init_fn (SIM_DESC sd, MODULE_INIT_FN fn)
 292 {
 293   struct module_list *modules = STATE_MODULES (sd);
 294   MODULE_INIT_LIST *l = ZALLOC (MODULE_INIT_LIST);
 295   MODULE_INIT_LIST **last;
 296
 297   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 298   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 299
 300   last = &modules->init_list;
 301   while (*last != NULL)
 302     last = &((*last)->next);
 303
 304   l->fn = fn;
 305   l->next = NULL;
 306   *last = l;
 307 }
 308
 309 /* Add FN to the resume handler list.
 310    resume in the same order as the install. */
 311
 312 void
 313 sim_module_add_resume_fn (SIM_DESC sd, MODULE_RESUME_FN fn)
 314 {
 315   struct module_list *modules = STATE_MODULES (sd);
 316   MODULE_RESUME_LIST *l = ZALLOC (MODULE_RESUME_LIST);
 317   MODULE_RESUME_LIST **last;
 318
 319   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 320   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 321
 322   last = &modules->resume_list;
 323   while (*last != NULL)
 324     last = &((*last)->next);
 325
 326   l->fn = fn;
 327   l->next = NULL;
 328   *last = l;
 329 }
 330
 331 /* Add FN to the init handler list.
 332    suspend in the reverse order to install. */
 333
 334 void
 335 sim_module_add_suspend_fn (SIM_DESC sd, MODULE_SUSPEND_FN fn)
 336 {
 337   struct module_list *modules = STATE_MODULES (sd);
 338   MODULE_SUSPEND_LIST *l = ZALLOC (MODULE_SUSPEND_LIST);
 339   MODULE_SUSPEND_LIST **last;
 340
 341   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 342   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 343
 344   last = &modules->suspend_list;
 345   while (*last != NULL)
 346     last = &((*last)->next);
 347
 348   l->fn = fn;
 349   l->next = modules->suspend_list;
 350   modules->suspend_list = l;
 351 }
 352
 353 /* Add FN to the uninstall handler list.
 354    Uninstall in reverse order to install.  */
 355
 356 void
 357 sim_module_add_uninstall_fn (SIM_DESC sd, MODULE_UNINSTALL_FN fn)
 358 {
 359   struct module_list *modules = STATE_MODULES (sd);
 360   MODULE_UNINSTALL_LIST *l = ZALLOC (MODULE_UNINSTALL_LIST);
 361
 362   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 363   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 364
 365   l->fn = fn;
 366   l->next = modules->uninstall_list;
 367   modules->uninstall_list = l;
 368 }
 369
 370 /* Add FN to the info handler list.
 371    Report info in the same order as the install. */
 372
 373 void
 374 sim_module_add_info_fn (SIM_DESC sd, MODULE_INFO_FN fn)
 375 {
 376   struct module_list *modules = STATE_MODULES (sd);
 377   MODULE_INFO_LIST *l = ZALLOC (MODULE_INFO_LIST);
 378   MODULE_INFO_LIST **last;
 379
 380   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 381   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 382
 383   last = &modules->info_list;
 384   while (*last != NULL)
 385     last = &((*last)->next);
 386
 387   l->fn = fn;
 388   l->next = NULL;
 389   *last = l;
 390 }