sim/common/sim-module.c

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