sim/common/sim-module.c

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