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