1/* Module support. 2 3 Copyright 1996-2023 Free Software Foundation, Inc. 4 5 Contributed by Cygnus Support. 6 7This file is part of GDB, the GNU debugger. 8 9This program is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 3 of the License, or 12(at your option) any later version. 13 14This program is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22/* This must come before any other includes. */ 23#include "defs.h" 24 25#include <stdlib.h> 26 27#include "libiberty.h" 28 29#include "sim-main.h" 30#include "sim-io.h" 31#include "sim-options.h" 32#include "sim-assert.h" 33 34/* List of all early/core modules. 35 TODO: Should trim this list by converting to sim_install_* framework. */ 36static MODULE_INSTALL_FN * const early_modules[] = { 37 standard_install, 38 sim_events_install, 39 sim_model_install, 40 sim_core_install, 41 sim_memopt_install, 42 sim_watchpoint_install, 43}; 44static int early_modules_len = ARRAY_SIZE (early_modules); 45 46/* List of dynamically detected modules. Declared in generated modules.c. */ 47extern MODULE_INSTALL_FN * const sim_modules_detected[]; 48extern const int sim_modules_detected_len; 49 50/* Functions called from sim_open. */ 51 52/* Initialize common parts before argument processing. */ 53 54SIM_RC 55sim_pre_argv_init (SIM_DESC sd, const char *myname) 56{ 57 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 58 SIM_ASSERT (STATE_MODULES (sd) == NULL); 59 60 STATE_MY_NAME (sd) = lbasename (myname); 61 62 /* Set the cpu names to default values. */ 63 { 64 int i; 65 for (i = 0; i < MAX_NR_PROCESSORS; ++i) 66 { 67 char *name; 68 if (asprintf (&name, "cpu%d", i) < 0) 69 return SIM_RC_FAIL; 70 CPU_NAME (STATE_CPU (sd, i)) = name; 71 } 72 } 73 74 sim_config_default (sd); 75 76 /* Install all early configured-in modules. */ 77 if (sim_module_install (sd) != SIM_RC_OK) 78 return SIM_RC_FAIL; 79 80 /* Install all remaining dynamically detected modules. */ 81 return sim_module_install_list (sd, sim_modules_detected, 82 sim_modules_detected_len); 83} 84 85/* Initialize common parts after argument processing. */ 86 87SIM_RC 88sim_post_argv_init (SIM_DESC sd) 89{ 90 int i; 91 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 92 SIM_ASSERT (STATE_MODULES (sd) != NULL); 93 94 /* Set the cpu->state backlinks for each cpu. */ 95 for (i = 0; i < MAX_NR_PROCESSORS; ++i) 96 { 97 CPU_STATE (STATE_CPU (sd, i)) = sd; 98 CPU_INDEX (STATE_CPU (sd, i)) = i; 99 } 100 101 if (sim_module_init (sd) != SIM_RC_OK) 102 return SIM_RC_FAIL; 103 104 return SIM_RC_OK; 105} 106 107/* Install a list of modules. 108 If this fails, no modules are left installed. */ 109SIM_RC 110sim_module_install_list (SIM_DESC sd, MODULE_INSTALL_FN * const *modules, 111 size_t modules_len) 112{ 113 size_t i; 114 115 for (i = 0; i < modules_len; ++i) 116 { 117 MODULE_INSTALL_FN *modp = modules[i]; 118 119 if (modp != NULL && modp (sd) != SIM_RC_OK) 120 { 121 sim_module_uninstall (sd); 122 SIM_ASSERT (STATE_MODULES (sd) == NULL); 123 return SIM_RC_FAIL; 124 } 125 } 126 127 return SIM_RC_OK; 128} 129 130/* Install all modules. 131 If this fails, no modules are left installed. */ 132 133SIM_RC 134sim_module_install (SIM_DESC sd) 135{ 136 MODULE_INSTALL_FN * const *modp; 137 138 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 139 SIM_ASSERT (STATE_MODULES (sd) == NULL); 140 141 STATE_MODULES (sd) = ZALLOC (struct module_list); 142 return sim_module_install_list (sd, early_modules, early_modules_len); 143} 144 145/* Called after all modules have been installed and after argv 146 has been processed. */ 147 148SIM_RC 149sim_module_init (SIM_DESC sd) 150{ 151 struct module_list *modules = STATE_MODULES (sd); 152 MODULE_INIT_LIST *modp; 153 154 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 155 SIM_ASSERT (STATE_MODULES (sd) != NULL); 156 157 for (modp = modules->init_list; modp != NULL; modp = modp->next) 158 { 159 if ((*modp->fn) (sd) != SIM_RC_OK) 160 return SIM_RC_FAIL; 161 } 162 return SIM_RC_OK; 163} 164 165/* Called when ever the simulator is resumed */ 166 167SIM_RC 168sim_module_resume (SIM_DESC sd) 169{ 170 struct module_list *modules = STATE_MODULES (sd); 171 MODULE_RESUME_LIST *modp; 172 173 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 174 SIM_ASSERT (STATE_MODULES (sd) != NULL); 175 176 for (modp = modules->resume_list; modp != NULL; modp = modp->next) 177 { 178 if ((*modp->fn) (sd) != SIM_RC_OK) 179 return SIM_RC_FAIL; 180 } 181 return SIM_RC_OK; 182} 183 184/* Called when ever the simulator is suspended */ 185 186SIM_RC 187sim_module_suspend (SIM_DESC sd) 188{ 189 struct module_list *modules = STATE_MODULES (sd); 190 MODULE_SUSPEND_LIST *modp; 191 192 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 193 SIM_ASSERT (STATE_MODULES (sd) != NULL); 194 195 for (modp = modules->suspend_list; modp != NULL; modp = modp->next) 196 { 197 if ((*modp->fn) (sd) != SIM_RC_OK) 198 return SIM_RC_FAIL; 199 } 200 return SIM_RC_OK; 201} 202 203/* Uninstall installed modules, called by sim_close. */ 204 205void 206sim_module_uninstall (SIM_DESC sd) 207{ 208 struct module_list *modules = STATE_MODULES (sd); 209 MODULE_UNINSTALL_LIST *modp; 210 211 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 212 SIM_ASSERT (STATE_MODULES (sd) != NULL); 213 214 /* Uninstall the modules. */ 215 for (modp = modules->uninstall_list; modp != NULL; modp = modp->next) 216 (*modp->fn) (sd); 217 218 /* clean-up init list */ 219 { 220 MODULE_INIT_LIST *n, *d; 221 for (d = modules->init_list; d != NULL; d = n) 222 { 223 n = d->next; 224 free (d); 225 } 226 } 227 228 /* clean-up resume list */ 229 { 230 MODULE_RESUME_LIST *n, *d; 231 for (d = modules->resume_list; d != NULL; d = n) 232 { 233 n = d->next; 234 free (d); 235 } 236 } 237 238 /* clean-up suspend list */ 239 { 240 MODULE_SUSPEND_LIST *n, *d; 241 for (d = modules->suspend_list; d != NULL; d = n) 242 { 243 n = d->next; 244 free (d); 245 } 246 } 247 248 /* clean-up uninstall list */ 249 { 250 MODULE_UNINSTALL_LIST *n, *d; 251 for (d = modules->uninstall_list; d != NULL; d = n) 252 { 253 n = d->next; 254 free (d); 255 } 256 } 257 258 /* clean-up info list */ 259 { 260 MODULE_INFO_LIST *n, *d; 261 for (d = modules->info_list; d != NULL; d = n) 262 { 263 n = d->next; 264 free (d); 265 } 266 } 267 268 free (modules); 269 STATE_MODULES (sd) = NULL; 270} 271 272/* Called when ever simulator info is needed */ 273 274void 275sim_module_info (SIM_DESC sd, int verbose) 276{ 277 struct module_list *modules = STATE_MODULES (sd); 278 MODULE_INFO_LIST *modp; 279 280 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 281 SIM_ASSERT (STATE_MODULES (sd) != NULL); 282 283 for (modp = modules->info_list; modp != NULL; modp = modp->next) 284 { 285 (*modp->fn) (sd, verbose); 286 } 287} 288 289/* Add FN to the init handler list. 290 init in the same order as the install. */ 291 292void 293sim_module_add_init_fn (SIM_DESC sd, MODULE_INIT_FN fn) 294{ 295 struct module_list *modules = STATE_MODULES (sd); 296 MODULE_INIT_LIST *l = ZALLOC (MODULE_INIT_LIST); 297 MODULE_INIT_LIST **last; 298 299 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 300 SIM_ASSERT (STATE_MODULES (sd) != NULL); 301 302 last = &modules->init_list; 303 while (*last != NULL) 304 last = &((*last)->next); 305 306 l->fn = fn; 307 l->next = NULL; 308 *last = l; 309} 310 311/* Add FN to the resume handler list. 312 resume in the same order as the install. */ 313 314void 315sim_module_add_resume_fn (SIM_DESC sd, MODULE_RESUME_FN fn) 316{ 317 struct module_list *modules = STATE_MODULES (sd); 318 MODULE_RESUME_LIST *l = ZALLOC (MODULE_RESUME_LIST); 319 MODULE_RESUME_LIST **last; 320 321 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 322 SIM_ASSERT (STATE_MODULES (sd) != NULL); 323 324 last = &modules->resume_list; 325 while (*last != NULL) 326 last = &((*last)->next); 327 328 l->fn = fn; 329 l->next = NULL; 330 *last = l; 331} 332 333/* Add FN to the init handler list. 334 suspend in the reverse order to install. */ 335 336void 337sim_module_add_suspend_fn (SIM_DESC sd, MODULE_SUSPEND_FN fn) 338{ 339 struct module_list *modules = STATE_MODULES (sd); 340 MODULE_SUSPEND_LIST *l = ZALLOC (MODULE_SUSPEND_LIST); 341 MODULE_SUSPEND_LIST **last; 342 343 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 344 SIM_ASSERT (STATE_MODULES (sd) != NULL); 345 346 last = &modules->suspend_list; 347 while (*last != NULL) 348 last = &((*last)->next); 349 350 l->fn = fn; 351 l->next = modules->suspend_list; 352 modules->suspend_list = l; 353} 354 355/* Add FN to the uninstall handler list. 356 Uninstall in reverse order to install. */ 357 358void 359sim_module_add_uninstall_fn (SIM_DESC sd, MODULE_UNINSTALL_FN fn) 360{ 361 struct module_list *modules = STATE_MODULES (sd); 362 MODULE_UNINSTALL_LIST *l = ZALLOC (MODULE_UNINSTALL_LIST); 363 364 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 365 SIM_ASSERT (STATE_MODULES (sd) != NULL); 366 367 l->fn = fn; 368 l->next = modules->uninstall_list; 369 modules->uninstall_list = l; 370} 371 372/* Add FN to the info handler list. 373 Report info in the same order as the install. */ 374 375void 376sim_module_add_info_fn (SIM_DESC sd, MODULE_INFO_FN fn) 377{ 378 struct module_list *modules = STATE_MODULES (sd); 379 MODULE_INFO_LIST *l = ZALLOC (MODULE_INFO_LIST); 380 MODULE_INFO_LIST **last; 381 382 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 383 SIM_ASSERT (STATE_MODULES (sd) != NULL); 384 385 last = &modules->info_list; 386 while (*last != NULL) 387 last = &((*last)->next); 388 389 l->fn = fn; 390 l->next = NULL; 391 *last = l; 392} 393