1 /* Module support. 2 3 Copyright 1996-2024 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 /* 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. */ 36 static 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 }; 44 static int early_modules_len = ARRAY_SIZE (early_modules); 45 46 /* List of dynamically detected modules. Declared in generated modules.c. */ 47 extern MODULE_INSTALL_FN * const sim_modules_detected[]; 48 extern const int sim_modules_detected_len; 49 50 /* Functions called from sim_open. */ 51 52 /* Initialize common parts before argument processing. */ 53 54 SIM_RC 55 sim_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 87 SIM_RC 88 sim_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. */ 109 SIM_RC 110 sim_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 133 SIM_RC 134 sim_module_install (SIM_DESC sd) 135 { 136 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 137 SIM_ASSERT (STATE_MODULES (sd) == NULL); 138 139 STATE_MODULES (sd) = ZALLOC (struct module_list); 140 return sim_module_install_list (sd, early_modules, early_modules_len); 141 } 142 143 /* Called after all modules have been installed and after argv 144 has been processed. */ 145 146 SIM_RC 147 sim_module_init (SIM_DESC sd) 148 { 149 struct module_list *modules = STATE_MODULES (sd); 150 MODULE_INIT_LIST *modp; 151 152 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 153 SIM_ASSERT (STATE_MODULES (sd) != NULL); 154 155 for (modp = modules->init_list; modp != NULL; modp = modp->next) 156 { 157 if ((*modp->fn) (sd) != SIM_RC_OK) 158 return SIM_RC_FAIL; 159 } 160 return SIM_RC_OK; 161 } 162 163 /* Called when ever the simulator is resumed */ 164 165 SIM_RC 166 sim_module_resume (SIM_DESC sd) 167 { 168 struct module_list *modules = STATE_MODULES (sd); 169 MODULE_RESUME_LIST *modp; 170 171 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 172 SIM_ASSERT (STATE_MODULES (sd) != NULL); 173 174 for (modp = modules->resume_list; modp != NULL; modp = modp->next) 175 { 176 if ((*modp->fn) (sd) != SIM_RC_OK) 177 return SIM_RC_FAIL; 178 } 179 return SIM_RC_OK; 180 } 181 182 /* Called when ever the simulator is suspended */ 183 184 SIM_RC 185 sim_module_suspend (SIM_DESC sd) 186 { 187 struct module_list *modules = STATE_MODULES (sd); 188 MODULE_SUSPEND_LIST *modp; 189 190 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 191 SIM_ASSERT (STATE_MODULES (sd) != NULL); 192 193 for (modp = modules->suspend_list; modp != NULL; modp = modp->next) 194 { 195 if ((*modp->fn) (sd) != SIM_RC_OK) 196 return SIM_RC_FAIL; 197 } 198 return SIM_RC_OK; 199 } 200 201 /* Uninstall installed modules, called by sim_close. */ 202 203 void 204 sim_module_uninstall (SIM_DESC sd) 205 { 206 struct module_list *modules = STATE_MODULES (sd); 207 MODULE_UNINSTALL_LIST *modp; 208 209 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 210 SIM_ASSERT (STATE_MODULES (sd) != NULL); 211 212 /* Uninstall the modules. */ 213 for (modp = modules->uninstall_list; modp != NULL; modp = modp->next) 214 (*modp->fn) (sd); 215 216 /* clean-up init list */ 217 { 218 MODULE_INIT_LIST *n, *d; 219 for (d = modules->init_list; d != NULL; d = n) 220 { 221 n = d->next; 222 free (d); 223 } 224 } 225 226 /* clean-up resume list */ 227 { 228 MODULE_RESUME_LIST *n, *d; 229 for (d = modules->resume_list; d != NULL; d = n) 230 { 231 n = d->next; 232 free (d); 233 } 234 } 235 236 /* clean-up suspend list */ 237 { 238 MODULE_SUSPEND_LIST *n, *d; 239 for (d = modules->suspend_list; d != NULL; d = n) 240 { 241 n = d->next; 242 free (d); 243 } 244 } 245 246 /* clean-up uninstall list */ 247 { 248 MODULE_UNINSTALL_LIST *n, *d; 249 for (d = modules->uninstall_list; d != NULL; d = n) 250 { 251 n = d->next; 252 free (d); 253 } 254 } 255 256 /* clean-up info list */ 257 { 258 MODULE_INFO_LIST *n, *d; 259 for (d = modules->info_list; d != NULL; d = n) 260 { 261 n = d->next; 262 free (d); 263 } 264 } 265 266 free (modules); 267 STATE_MODULES (sd) = NULL; 268 } 269 270 /* Called when ever simulator info is needed */ 271 272 void 273 sim_module_info (SIM_DESC sd, bool verbose) 274 { 275 struct module_list *modules = STATE_MODULES (sd); 276 MODULE_INFO_LIST *modp; 277 278 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 279 SIM_ASSERT (STATE_MODULES (sd) != NULL); 280 281 for (modp = modules->info_list; modp != NULL; modp = modp->next) 282 { 283 (*modp->fn) (sd, verbose); 284 } 285 } 286 287 /* Add FN to the init handler list. 288 init in the same order as the install. */ 289 290 void 291 sim_module_add_init_fn (SIM_DESC sd, MODULE_INIT_FN fn) 292 { 293 struct module_list *modules = STATE_MODULES (sd); 294 MODULE_INIT_LIST *l = ZALLOC (MODULE_INIT_LIST); 295 MODULE_INIT_LIST **last; 296 297 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 298 SIM_ASSERT (STATE_MODULES (sd) != NULL); 299 300 last = &modules->init_list; 301 while (*last != NULL) 302 last = &((*last)->next); 303 304 l->fn = fn; 305 l->next = NULL; 306 *last = l; 307 } 308 309 /* Add FN to the resume handler list. 310 resume in the same order as the install. */ 311 312 void 313 sim_module_add_resume_fn (SIM_DESC sd, MODULE_RESUME_FN fn) 314 { 315 struct module_list *modules = STATE_MODULES (sd); 316 MODULE_RESUME_LIST *l = ZALLOC (MODULE_RESUME_LIST); 317 MODULE_RESUME_LIST **last; 318 319 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 320 SIM_ASSERT (STATE_MODULES (sd) != NULL); 321 322 last = &modules->resume_list; 323 while (*last != NULL) 324 last = &((*last)->next); 325 326 l->fn = fn; 327 l->next = NULL; 328 *last = l; 329 } 330 331 /* Add FN to the init handler list. 332 suspend in the reverse order to install. */ 333 334 void 335 sim_module_add_suspend_fn (SIM_DESC sd, MODULE_SUSPEND_FN fn) 336 { 337 struct module_list *modules = STATE_MODULES (sd); 338 MODULE_SUSPEND_LIST *l = ZALLOC (MODULE_SUSPEND_LIST); 339 MODULE_SUSPEND_LIST **last; 340 341 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 342 SIM_ASSERT (STATE_MODULES (sd) != NULL); 343 344 last = &modules->suspend_list; 345 while (*last != NULL) 346 last = &((*last)->next); 347 348 l->fn = fn; 349 l->next = modules->suspend_list; 350 modules->suspend_list = l; 351 } 352 353 /* Add FN to the uninstall handler list. 354 Uninstall in reverse order to install. */ 355 356 void 357 sim_module_add_uninstall_fn (SIM_DESC sd, MODULE_UNINSTALL_FN fn) 358 { 359 struct module_list *modules = STATE_MODULES (sd); 360 MODULE_UNINSTALL_LIST *l = ZALLOC (MODULE_UNINSTALL_LIST); 361 362 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 363 SIM_ASSERT (STATE_MODULES (sd) != NULL); 364 365 l->fn = fn; 366 l->next = modules->uninstall_list; 367 modules->uninstall_list = l; 368 } 369 370 /* Add FN to the info handler list. 371 Report info in the same order as the install. */ 372 373 void 374 sim_module_add_info_fn (SIM_DESC sd, MODULE_INFO_FN fn) 375 { 376 struct module_list *modules = STATE_MODULES (sd); 377 MODULE_INFO_LIST *l = ZALLOC (MODULE_INFO_LIST); 378 MODULE_INFO_LIST **last; 379 380 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 381 SIM_ASSERT (STATE_MODULES (sd) != NULL); 382 383 last = &modules->info_list; 384 while (*last != NULL) 385 last = &((*last)->next); 386 387 l->fn = fn; 388 l->next = NULL; 389 *last = l; 390 } 391