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