1/* Module support.
2
3   Copyright 1996, 1997, 1998, 2003, 2007 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#include "sim-main.h"
23#include "sim-io.h"
24#include "sim-options.h"
25#include "sim-assert.h"
26
27#if WITH_HW
28#include "sim-hw.h"
29#endif
30
31#include "libiberty.h"
32
33/* List of all modules.  */
34static MODULE_INSTALL_FN * const modules[] = {
35  standard_install,
36  sim_events_install,
37#ifdef SIM_HAVE_MODEL
38  sim_model_install,
39#endif
40#if WITH_ENGINE
41  sim_engine_install,
42#endif
43#if WITH_TRACE
44  trace_install,
45#endif
46#if WITH_PROFILE
47  profile_install,
48#endif
49  sim_core_install,
50#ifndef SIM_HAVE_FLATMEM
51  /* FIXME: should handle flatmem as well FLATMEM */
52  sim_memopt_install,
53#endif
54#if WITH_WATCHPOINTS
55  sim_watchpoint_install,
56#endif
57#if WITH_SCACHE
58  scache_install,
59#endif
60#if WITH_HW
61  sim_hw_install,
62#endif
63  /* Configured in [simulator specific] additional modules.  */
64#ifdef MODULE_LIST
65  MODULE_LIST
66#endif
67  0
68};
69
70/* Functions called from sim_open.  */
71
72/* Initialize common parts before argument processing.  */
73
74SIM_RC
75sim_pre_argv_init (SIM_DESC sd, const char *myname)
76{
77  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
78  SIM_ASSERT (STATE_MODULES (sd) == NULL);
79
80  STATE_MY_NAME (sd) = myname + strlen (myname);
81  while (STATE_MY_NAME (sd) > myname && STATE_MY_NAME (sd)[-1] != '/')
82    --STATE_MY_NAME (sd);
83
84  /* Set the cpu names to default values.  */
85  {
86    int i;
87    for (i = 0; i < MAX_NR_PROCESSORS; ++i)
88      {
89	char *name;
90	asprintf (&name, "cpu%d", i);
91	CPU_NAME (STATE_CPU (sd, i)) = name;
92      }
93  }
94
95  sim_config_default (sd);
96
97  /* Install all configured in modules.  */
98  if (sim_module_install (sd) != SIM_RC_OK)
99    return SIM_RC_FAIL;
100
101  return SIM_RC_OK;
102}
103
104/* Initialize common parts after argument processing.  */
105
106SIM_RC
107sim_post_argv_init (SIM_DESC sd)
108{
109  int i;
110  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
111  SIM_ASSERT (STATE_MODULES (sd) != NULL);
112
113  /* Set the cpu->state backlinks for each cpu.  */
114  for (i = 0; i < MAX_NR_PROCESSORS; ++i)
115    {
116      CPU_STATE (STATE_CPU (sd, i)) = sd;
117      CPU_INDEX (STATE_CPU (sd, i)) = i;
118    }
119
120  if (sim_module_init (sd) != SIM_RC_OK)
121    return SIM_RC_FAIL;
122
123  return SIM_RC_OK;
124}
125
126/* Install all modules.
127   If this fails, no modules are left installed.  */
128
129SIM_RC
130sim_module_install (SIM_DESC sd)
131{
132  MODULE_INSTALL_FN * const *modp;
133
134  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
135  SIM_ASSERT (STATE_MODULES (sd) == NULL);
136
137  STATE_MODULES (sd) = ZALLOC (struct module_list);
138  for (modp = modules; *modp != NULL; ++modp)
139    {
140      if ((*modp) (sd) != SIM_RC_OK)
141	{
142	  sim_module_uninstall (sd);
143	  SIM_ASSERT (STATE_MODULES (sd) == NULL);
144	  return SIM_RC_FAIL;
145	}
146    }
147  return SIM_RC_OK;
148}
149
150/* Called after all modules have been installed and after argv
151   has been processed.  */
152
153SIM_RC
154sim_module_init (SIM_DESC sd)
155{
156  struct module_list *modules = STATE_MODULES (sd);
157  MODULE_INIT_LIST *modp;
158
159  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
160  SIM_ASSERT (STATE_MODULES (sd) != NULL);
161
162  for (modp = modules->init_list; modp != NULL; modp = modp->next)
163    {
164      if ((*modp->fn) (sd) != SIM_RC_OK)
165	return SIM_RC_FAIL;
166    }
167  return SIM_RC_OK;
168}
169
170/* Called when ever the simulator is resumed */
171
172SIM_RC
173sim_module_resume (SIM_DESC sd)
174{
175  struct module_list *modules = STATE_MODULES (sd);
176  MODULE_RESUME_LIST *modp;
177
178  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
179  SIM_ASSERT (STATE_MODULES (sd) != NULL);
180
181  for (modp = modules->resume_list; modp != NULL; modp = modp->next)
182    {
183      if ((*modp->fn) (sd) != SIM_RC_OK)
184	return SIM_RC_FAIL;
185    }
186  return SIM_RC_OK;
187}
188
189/* Called when ever the simulator is suspended */
190
191SIM_RC
192sim_module_suspend (SIM_DESC sd)
193{
194  struct module_list *modules = STATE_MODULES (sd);
195  MODULE_SUSPEND_LIST *modp;
196
197  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
198  SIM_ASSERT (STATE_MODULES (sd) != NULL);
199
200  for (modp = modules->suspend_list; modp != NULL; modp = modp->next)
201    {
202      if ((*modp->fn) (sd) != SIM_RC_OK)
203	return SIM_RC_FAIL;
204    }
205  return SIM_RC_OK;
206}
207
208/* Uninstall installed modules, called by sim_close.  */
209
210void
211sim_module_uninstall (SIM_DESC sd)
212{
213  struct module_list *modules = STATE_MODULES (sd);
214  MODULE_UNINSTALL_LIST *modp;
215
216  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
217  SIM_ASSERT (STATE_MODULES (sd) != NULL);
218
219  /* Uninstall the modules.  */
220  for (modp = modules->uninstall_list; modp != NULL; modp = modp->next)
221    (*modp->fn) (sd);
222
223  /* clean-up init list */
224  {
225    MODULE_INIT_LIST *n, *d;
226    for (d = modules->init_list; d != NULL; d = n)
227      {
228	n = d->next;
229	zfree (d);
230      }
231  }
232
233  /* clean-up resume list */
234  {
235    MODULE_RESUME_LIST *n, *d;
236    for (d = modules->resume_list; d != NULL; d = n)
237      {
238	n = d->next;
239	zfree (d);
240      }
241  }
242
243  /* clean-up suspend list */
244  {
245    MODULE_SUSPEND_LIST *n, *d;
246    for (d = modules->suspend_list; d != NULL; d = n)
247      {
248	n = d->next;
249	zfree (d);
250      }
251  }
252
253  /* clean-up uninstall list */
254  {
255    MODULE_UNINSTALL_LIST *n, *d;
256    for (d = modules->uninstall_list; d != NULL; d = n)
257      {
258	n = d->next;
259	zfree (d);
260      }
261  }
262
263  /* clean-up info list */
264  {
265    MODULE_INFO_LIST *n, *d;
266    for (d = modules->info_list; d != NULL; d = n)
267      {
268	n = d->next;
269	zfree (d);
270      }
271  }
272
273  zfree (modules);
274  STATE_MODULES (sd) = NULL;
275}
276
277/* Called when ever simulator info is needed */
278
279void
280sim_module_info (SIM_DESC sd, int verbose)
281{
282  struct module_list *modules = STATE_MODULES (sd);
283  MODULE_INFO_LIST *modp;
284
285  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
286  SIM_ASSERT (STATE_MODULES (sd) != NULL);
287
288  for (modp = modules->info_list; modp != NULL; modp = modp->next)
289    {
290      (*modp->fn) (sd, verbose);
291    }
292}
293
294/* Add FN to the init handler list.
295   init in the same order as the install. */
296
297void
298sim_module_add_init_fn (SIM_DESC sd, MODULE_INIT_FN fn)
299{
300  struct module_list *modules = STATE_MODULES (sd);
301  MODULE_INIT_LIST *l = ZALLOC (MODULE_INIT_LIST);
302  MODULE_INIT_LIST **last;
303
304  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
305  SIM_ASSERT (STATE_MODULES (sd) != NULL);
306
307  last = &modules->init_list;
308  while (*last != NULL)
309    last = &((*last)->next);
310
311  l->fn = fn;
312  l->next = NULL;
313  *last = l;
314}
315
316/* Add FN to the resume handler list.
317   resume in the same order as the install. */
318
319void
320sim_module_add_resume_fn (SIM_DESC sd, MODULE_RESUME_FN fn)
321{
322  struct module_list *modules = STATE_MODULES (sd);
323  MODULE_RESUME_LIST *l = ZALLOC (MODULE_RESUME_LIST);
324  MODULE_RESUME_LIST **last;
325
326  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
327  SIM_ASSERT (STATE_MODULES (sd) != NULL);
328
329  last = &modules->resume_list;
330  while (*last != NULL)
331    last = &((*last)->next);
332
333  l->fn = fn;
334  l->next = NULL;
335  *last = l;
336}
337
338/* Add FN to the init handler list.
339   suspend in the reverse order to install. */
340
341void
342sim_module_add_suspend_fn (SIM_DESC sd, MODULE_SUSPEND_FN fn)
343{
344  struct module_list *modules = STATE_MODULES (sd);
345  MODULE_SUSPEND_LIST *l = ZALLOC (MODULE_SUSPEND_LIST);
346  MODULE_SUSPEND_LIST **last;
347
348  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
349  SIM_ASSERT (STATE_MODULES (sd) != NULL);
350
351  last = &modules->suspend_list;
352  while (*last != NULL)
353    last = &((*last)->next);
354
355  l->fn = fn;
356  l->next = modules->suspend_list;
357  modules->suspend_list = l;
358}
359
360/* Add FN to the uninstall handler list.
361   Uninstall in reverse order to install.  */
362
363void
364sim_module_add_uninstall_fn (SIM_DESC sd, MODULE_UNINSTALL_FN fn)
365{
366  struct module_list *modules = STATE_MODULES (sd);
367  MODULE_UNINSTALL_LIST *l = ZALLOC (MODULE_UNINSTALL_LIST);
368
369  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
370  SIM_ASSERT (STATE_MODULES (sd) != NULL);
371
372  l->fn = fn;
373  l->next = modules->uninstall_list;
374  modules->uninstall_list = l;
375}
376
377/* Add FN to the info handler list.
378   Report info in the same order as the install. */
379
380void
381sim_module_add_info_fn (SIM_DESC sd, MODULE_INFO_FN fn)
382{
383  struct module_list *modules = STATE_MODULES (sd);
384  MODULE_INFO_LIST *l = ZALLOC (MODULE_INFO_LIST);
385  MODULE_INFO_LIST **last;
386
387  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
388  SIM_ASSERT (STATE_MODULES (sd) != NULL);
389
390  last = &modules->info_list;
391  while (*last != NULL)
392    last = &((*last)->next);
393
394  l->fn = fn;
395  l->next = NULL;
396  *last = l;
397}
398