sim/common/sim-module.c

   1 /* Module support.
   2    Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 This file is part of GDB, the GNU debugger.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License along
  18 with this program; if not, write to the Free Software Foundation, Inc.,
  19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "sim-main.h"
  22 #include "sim-io.h"
  23 #include "sim-options.h"
  24 #include "sim-assert.h"
  25
  26 #include "libiberty.h"
  27
  28 /* List of all modules.  */
  29 static MODULE_INSTALL_FN * const modules[] = {
  30   standard_install,
  31   sim_events_install,
  32 #if WITH_ENGINE
  33   sim_engine_install,
  34 #endif
  35 #if WITH_TRACE
  36   trace_install,
  37 #endif
  38 #if WITH_PROFILE
  39   profile_install,
  40 #endif
  41   sim_core_install,
  42 #ifndef SIM_HAVE_FLATMEM
  43   /* FIXME: should handle flatmem as well FLATMEM */
  44   sim_memopt_install,
  45 #endif
  46 #if WITH_WATCHPOINTS
  47   sim_watchpoint_install,
  48 #endif
  49 #if WITH_SCACHE
  50   scache_install,
  51 #endif
  52 #ifdef SIM_HAVE_MODEL
  53   model_install,
  54 #endif
  55 #ifdef SIM_HAVE_BREAKPOINTS
  56   sim_break_install,
  57 #endif
  58   /* Configured in [simulator specific] additional modules.  */
  59 #ifdef MODULE_LIST
  60   MODULE_LIST
  61 #endif
  62   0
  63 };
  64 \f
  65 /* Functions called from sim_open.  */
  66
  67 /* Initialize common parts before argument processing.  */
  68
  69 SIM_RC
  70 sim_pre_argv_init (SIM_DESC sd, const char *myname)
  71 {
  72   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  73   SIM_ASSERT (STATE_MODULES (sd) == NULL);
  74
  75   STATE_MY_NAME (sd) = myname + strlen (myname);
  76   while (STATE_MY_NAME (sd) > myname && STATE_MY_NAME (sd)[-1] != '/')
  77     --STATE_MY_NAME (sd);
  78
  79   /* Set the cpu names to default values.  */
  80   {
  81     int i;
  82     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
  83       {
  84         char *name;
  85         asprintf (&name, "cpu%d", i);
  86         CPU_NAME (STATE_CPU (sd, i)) = name;
  87       }
  88   }
  89
  90   sim_config_default (sd);
  91
  92   /* Install all configured in modules.  */
  93   if (sim_module_install (sd) != SIM_RC_OK)
  94     return SIM_RC_FAIL;
  95
  96   return SIM_RC_OK;
  97 }
  98
  99 /* Initialize common parts after argument processing.  */
 100
 101 SIM_RC
 102 sim_post_argv_init (SIM_DESC sd)
 103 {
 104   int i;
 105   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 106   SIM_ASSERT (STATE_MODULES (sd) != NULL);
 107
 108   if (sim_module_init (sd) != SIM_RC_OK)
 109     return SIM_RC_FAIL;
 110
 111   /* Set the cpu->state backlinks for each cpu.  */
 112   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
 113     {
 114       CPU_STATE (STATE_CPU (sd, i)) = sd;
 115       CPU_INDEX (STATE_CPU (sd, i)) = i;
 116     }
 117
 118   return SIM_RC_OK;
 119 }
 120 \f
 121 /* Install all modules.
 122    If this fails, no modules are left installed.  */
 123
 124 SIM_RC
 125 sim_module_install (SIM_DESC sd)
 126 {
 127   MODULE_INSTALL_FN * const *modp;
 128
 129   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 130   SIM_ASSERT (STATE_MODULES (sd) == NULL);
 131
 132   STATE_MODULES (sd) = ZALLOC (struct module_list);
 133   for (modp = modules; *modp != NULL; ++modp)
 134     {
 135       if ((*modp) (sd) != SIM_RC_OK)
 136         {
 137           sim_module_uninstall (sd);
 138           SIM_ASSERT (STATE_MODULES (sd) == NULL);
 139           return SIM_RC_FAIL;
 140         }
 141     }
 142   return SIM_RC_OK;
 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         zfree (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         zfree (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         zfree (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         zfree (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         zfree (d);
 265       }
 266   }
 267
 268   zfree (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 }