sim/common/sim-module.c

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