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 #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 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 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 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 } 409