[deliverable/binutils-gdb.git] / sim / common / sim-module.c

/* Module support.

   Copyright 1996-2020 Free Software Foundation, Inc.

   Contributed by Cygnus Support.

This file is part of GDB, the GNU debugger.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "sim-main.h"
#include "sim-io.h"
#include "sim-options.h"
#include "sim-assert.h"

#if WITH_HW
#include "sim-hw.h"
#endif

#ifdef HAVE_DV_SOCKSER
/* TODO: Shouldn't have device models here.  */
#include "dv-sockser.h"
#endif

#include "libiberty.h"

#include <stdlib.h>

/* List of all modules.  */
static MODULE_INSTALL_FN * const modules[] = {
  standard_install,
  sim_events_install,
  sim_model_install,
  sim_engine_install,
#if WITH_TRACE_ANY_P
  trace_install,
#endif
#if WITH_PROFILE
  profile_install,
#endif
  sim_core_install,
  sim_memopt_install,
  sim_watchpoint_install,
#if WITH_SCACHE
  scache_install,
#endif
#if WITH_HW
  sim_hw_install,
#endif
#ifdef HAVE_DV_SOCKSER
  /* TODO: Shouldn't have device models here.  */
  dv_sockser_install,
#endif
  0
};
\f
/* Functions called from sim_open.  */

/* Initialize common parts before argument processing.  */

SIM_RC
sim_pre_argv_init (SIM_DESC sd, const char *myname)
{
  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) == NULL);

  STATE_MY_NAME (sd) = lbasename (myname);

  /* Set the cpu names to default values.  */
  {
    int i;
    for (i = 0; i < MAX_NR_PROCESSORS; ++i)
      {
	char *name;
	if (asprintf (&name, "cpu%d", i) < 0)
	  return SIM_RC_FAIL;
	CPU_NAME (STATE_CPU (sd, i)) = name;
      }
  }

  sim_config_default (sd);

  /* Install all configured in modules.  */
  if (sim_module_install (sd) != SIM_RC_OK)
    return SIM_RC_FAIL;

  return SIM_RC_OK;
}

/* Initialize common parts after argument processing.  */

SIM_RC
sim_post_argv_init (SIM_DESC sd)
{
  int i;
  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  /* Set the cpu->state backlinks for each cpu.  */
  for (i = 0; i < MAX_NR_PROCESSORS; ++i)
    {
      CPU_STATE (STATE_CPU (sd, i)) = sd;
      CPU_INDEX (STATE_CPU (sd, i)) = i;
    }

  if (sim_module_init (sd) != SIM_RC_OK)
    return SIM_RC_FAIL;

  return SIM_RC_OK;
}
\f
/* Install all modules.
   If this fails, no modules are left installed.  */

SIM_RC
sim_module_install (SIM_DESC sd)
{
  MODULE_INSTALL_FN * const *modp;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) == NULL);

  STATE_MODULES (sd) = ZALLOC (struct module_list);
  for (modp = modules; *modp != NULL; ++modp)
    {
      if ((*modp) (sd) != SIM_RC_OK)
	{
	  sim_module_uninstall (sd);
	  SIM_ASSERT (STATE_MODULES (sd) == NULL);
	  return SIM_RC_FAIL;
	}
    }
  return SIM_RC_OK;
}

/* Called after all modules have been installed and after argv
   has been processed.  */

SIM_RC
sim_module_init (SIM_DESC sd)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_INIT_LIST *modp;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  for (modp = modules->init_list; modp != NULL; modp = modp->next)
    {
      if ((*modp->fn) (sd) != SIM_RC_OK)
	return SIM_RC_FAIL;
    }
  return SIM_RC_OK;
}

/* Called when ever the simulator is resumed */

SIM_RC
sim_module_resume (SIM_DESC sd)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_RESUME_LIST *modp;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  for (modp = modules->resume_list; modp != NULL; modp = modp->next)
    {
      if ((*modp->fn) (sd) != SIM_RC_OK)
	return SIM_RC_FAIL;
    }
  return SIM_RC_OK;
}

/* Called when ever the simulator is suspended */

SIM_RC
sim_module_suspend (SIM_DESC sd)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_SUSPEND_LIST *modp;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  for (modp = modules->suspend_list; modp != NULL; modp = modp->next)
    {
      if ((*modp->fn) (sd) != SIM_RC_OK)
	return SIM_RC_FAIL;
    }
  return SIM_RC_OK;
}

/* Uninstall installed modules, called by sim_close.  */

void
sim_module_uninstall (SIM_DESC sd)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_UNINSTALL_LIST *modp;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  /* Uninstall the modules.  */
  for (modp = modules->uninstall_list; modp != NULL; modp = modp->next)
    (*modp->fn) (sd);

  /* clean-up init list */
  {
    MODULE_INIT_LIST *n, *d;
    for (d = modules->init_list; d != NULL; d = n)
      {
	n = d->next;
	free (d);
      }
  }

  /* clean-up resume list */
  {
    MODULE_RESUME_LIST *n, *d;
    for (d = modules->resume_list; d != NULL; d = n)
      {
	n = d->next;
	free (d);
      }
  }

  /* clean-up suspend list */
  {
    MODULE_SUSPEND_LIST *n, *d;
    for (d = modules->suspend_list; d != NULL; d = n)
      {
	n = d->next;
	free (d);
      }
  }

  /* clean-up uninstall list */
  {
    MODULE_UNINSTALL_LIST *n, *d;
    for (d = modules->uninstall_list; d != NULL; d = n)
      {
	n = d->next;
	free (d);
      }
  }

  /* clean-up info list */
  {
    MODULE_INFO_LIST *n, *d;
    for (d = modules->info_list; d != NULL; d = n)
      {
	n = d->next;
	free (d);
      }
  }

  free (modules);
  STATE_MODULES (sd) = NULL;
}

/* Called when ever simulator info is needed */

void
sim_module_info (SIM_DESC sd, int verbose)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_INFO_LIST *modp;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  for (modp = modules->info_list; modp != NULL; modp = modp->next)
    {
      (*modp->fn) (sd, verbose);
    }
}
\f
/* Add FN to the init handler list.
   init in the same order as the install. */

void
sim_module_add_init_fn (SIM_DESC sd, MODULE_INIT_FN fn)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_INIT_LIST *l = ZALLOC (MODULE_INIT_LIST);
  MODULE_INIT_LIST **last;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  last = &modules->init_list;
  while (*last != NULL)
    last = &((*last)->next);

  l->fn = fn;
  l->next = NULL;
  *last = l;
}

/* Add FN to the resume handler list.
   resume in the same order as the install. */

void
sim_module_add_resume_fn (SIM_DESC sd, MODULE_RESUME_FN fn)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_RESUME_LIST *l = ZALLOC (MODULE_RESUME_LIST);
  MODULE_RESUME_LIST **last;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  last = &modules->resume_list;
  while (*last != NULL)
    last = &((*last)->next);

  l->fn = fn;
  l->next = NULL;
  *last = l;
}

/* Add FN to the init handler list.
   suspend in the reverse order to install. */

void
sim_module_add_suspend_fn (SIM_DESC sd, MODULE_SUSPEND_FN fn)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_SUSPEND_LIST *l = ZALLOC (MODULE_SUSPEND_LIST);
  MODULE_SUSPEND_LIST **last;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  last = &modules->suspend_list;
  while (*last != NULL)
    last = &((*last)->next);

  l->fn = fn;
  l->next = modules->suspend_list;
  modules->suspend_list = l;
}

/* Add FN to the uninstall handler list.
   Uninstall in reverse order to install.  */

void
sim_module_add_uninstall_fn (SIM_DESC sd, MODULE_UNINSTALL_FN fn)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_UNINSTALL_LIST *l = ZALLOC (MODULE_UNINSTALL_LIST);

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  l->fn = fn;
  l->next = modules->uninstall_list;
  modules->uninstall_list = l;
}

/* Add FN to the info handler list.
   Report info in the same order as the install. */

void
sim_module_add_info_fn (SIM_DESC sd, MODULE_INFO_FN fn)
{
  struct module_list *modules = STATE_MODULES (sd);
  MODULE_INFO_LIST *l = ZALLOC (MODULE_INFO_LIST);
  MODULE_INFO_LIST **last;

  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  SIM_ASSERT (STATE_MODULES (sd) != NULL);

  last = &modules->info_list;
  while (*last != NULL)
    last = &((*last)->next);

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