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