xref: /netbsd-src/external/gpl3/gdb/dist/sim/common/sim-module.c (revision 88241920d21b339bf319c0e979ffda80c49a2936)
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