[thirdparty/binutils-gdb.git] / sim / common / hw-instances.c

/*  This file is part of the program psim.

    Copyright (C) 1994-1998, Andrew Cagney <cagney@highland.com.au>

    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 2 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, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    */


#include "hw-main.h"
#include "hw-base.h"

#include "sim-io.h"
#include "sim-assert.h"

struct hw_instance_data {
  hw_finish_instance_method *to_finish;
  struct hw_instance *instances;
};

static hw_finish_instance_method abort_hw_finish_instance;

void
create_hw_instance_data (struct hw *me)
{
  me->instances_of_hw = HW_ZALLOC (me, struct hw_instance_data);
  set_hw_finish_instance (me, abort_hw_finish_instance);
}

void
delete_hw_instance_data (struct hw *me)
{
  /* NOP */
}


static void
abort_hw_finish_instance (struct hw *hw,
			  struct hw_instance *instance)
{
  hw_abort (hw, "no instance finish method");
}

void
set_hw_finish_instance (struct hw *me,
			hw_finish_instance_method *finish)
{
  me->instances_of_hw->to_finish = finish;
}


#if 0
void
clean_hw_instances (struct hw *me)
{
  struct hw_instance **instance = &me->instances;
  while (*instance != NULL)
    {
      struct hw_instance *old_instance = *instance;
      hw_instance_delete (old_instance);
      instance = &me->instances;
    }
}
#endif


void
hw_instance_delete (struct hw_instance *instance)
{
#if 1
  hw_abort (hw_instance_hw (instance), "not implemented");
#else
  struct hw *me = hw_instance_hw (instance);
  if (instance->to_instance_delete == NULL)
    hw_abort (me, "no delete method");
  instance->method->delete(instance);
  if (instance->args != NULL)
    zfree (instance->args);
  if (instance->path != NULL)
    zfree (instance->path);
  if (instance->child == NULL)
    {
      /* only remove leaf nodes */
      struct hw_instance **curr = &me->instances;
      while (*curr != instance)
	{
	  ASSERT (*curr != NULL);
	  curr = &(*curr)->next;
	}
      *curr = instance->next;
    }
  else
    {
      /* check it isn't in the instance list */
      struct hw_instance *curr = me->instances;
      while (curr != NULL)
	{
	  ASSERT(curr != instance);
	  curr = curr->next;
	}
      /* unlink the child */
      ASSERT (instance->child->parent == instance);
      instance->child->parent = NULL;
    }
  cap_remove (me->ihandles, instance);
  zfree (instance);
#endif
}


static int
panic_hw_instance_read (struct hw_instance *instance,
			void *addr,
			unsigned_word len)
{
  hw_abort (hw_instance_hw (instance), "no read method");
  return -1;
}


static int
panic_hw_instance_write (struct hw_instance *instance,
			 const void *addr,
			 unsigned_word len)
{
  hw_abort (hw_instance_hw (instance), "no write method");
  return -1;
}


static int
panic_hw_instance_seek (struct hw_instance *instance,
			unsigned_word pos_hi,
			unsigned_word pos_lo)
{
  hw_abort (hw_instance_hw (instance), "no seek method");
  return -1;
}


int
hw_instance_call_method (struct hw_instance *instance,
			 const char *method_name,
			 int n_stack_args,
			 unsigned_cell stack_args[/*n_stack_args*/],	
			 int n_stack_returns,
			 unsigned_cell stack_returns[/*n_stack_args*/])
{
#if 1
  hw_abort (hw_instance_hw (instance), "not implemented");
  return -1;
#else
  struct hw *me = instance->owner;
  const hw_instance_methods *method = instance->method->methods;
  if (method == NULL)
    {
      hw_abort (me, "no methods (want %s)", method_name);
    }
  while (method->name != NULL)
    {
      if (strcmp(method->name, method_name) == 0)
	{
	  return method->method (instance,
				 n_stack_args, stack_args,
				 n_stack_returns, stack_returns);
	}
      method++;
    }
  hw_abort (me, "no %s method", method_name);
  return 0;
#endif
}


#define set_hw_instance_read(instance, method)\
((instance)->to_instance_read = (method))

#define set_hw_instance_write(instance, method)\
((instance)->to_instance_write = (method))

#define set_hw_instance_seek(instance, method)\
((instance)->to_instance_seek = (method))


#if 0
static void
set_hw_instance_finish (struct hw *me,
			hw_instance_finish_method *method)
{
  if (me->instances_of_hw == NULL)
    me->instances_of_hw = HW_ZALLOC (me, struct hw_instance_data);
  me->instances_of_hw->to_finish = method;
}
#endif


struct hw_instance *
hw_instance_create (struct hw *me,
		    struct hw_instance *parent,
		    const char *path,
		    const char *args)
{
  struct hw_instance *instance = ZALLOC (struct hw_instance);
  /*instance->unit*/
  /* link this instance into the devices list */
  instance->hw_of_instance = me;
  instance->parent_of_instance = NULL;
  /* link this instance into the front of the devices instance list */
  instance->sibling_of_instance = me->instances_of_hw->instances;
  me->instances_of_hw->instances = instance;
  if (parent != NULL)
    {
      ASSERT (parent->child_of_instance == NULL);
      parent->child_of_instance = instance;
      instance->parent_of_instance = parent;
    }
  instance->args_of_instance = hw_strdup (me, args);
  instance->path_of_instance = hw_strdup (me, path);
  set_hw_instance_read (instance, panic_hw_instance_read);
  set_hw_instance_write (instance, panic_hw_instance_write);
  set_hw_instance_seek (instance, panic_hw_instance_seek);
  hw_handle_add_ihandle (me, instance);
  me->instances_of_hw->to_finish (me, instance);
  return instance;
}


struct hw_instance *
hw_instance_interceed (struct hw_instance *parent,
		       const char *path,
		       const char *args)
{
#if 1
  return NULL;
#else
  struct hw_instance *instance = ZALLOC (struct hw_instance);
  /*instance->unit*/
  /* link this instance into the devices list */
  if (me != NULL)
    {
      ASSERT (parent == NULL);
      instance->hw_of_instance = me;
      instance->parent_of_instance = NULL;
      /* link this instance into the front of the devices instance list */
      instance->sibling_of_instance = me->instances_of_hw->instances;
      me->instances_of_hw->instances = instance;
    }
  if (parent != NULL)
    {
      struct hw_instance **previous;
      ASSERT (parent->child_of_instance == NULL);
      parent->child_of_instance = instance;
      instance->owner = parent->owner;
      instance->parent_of_instance = parent;
      /* in the devices instance list replace the parent instance with
	 this one */
      instance->next = parent->next;
      /* replace parent with this new node */
      previous = &instance->owner->instances;
      while (*previous != parent)
	{
	  ASSERT (*previous != NULL);
	  previous = &(*previous)->next;
	}
      *previous = instance;
    }
  instance->data = data;
  instance->args = (args == NULL ? NULL : (char *) strdup(args));
  instance->path = (path == NULL ? NULL : (char *) strdup(path));
  cap_add (instance->owner->ihandles, instance);
  return instance;
#endif
}
Commit	Line	Data
c906108c SS	1	/* This file is part of the program psim.
	2
	3	Copyright (C) 1994-1998, Andrew Cagney <cagney@highland.com.au>
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	18
	19	*/
	20
	21
	22	#include "hw-main.h"
	23	#include "hw-base.h"
	24
c2c6d25f	25	#include "sim-io.h"
c906108c SS	26	#include "sim-assert.h"
	27
	28	struct hw_instance_data {
	29	hw_finish_instance_method *to_finish;
	30	struct hw_instance *instances;
	31	};
	32
	33	static hw_finish_instance_method abort_hw_finish_instance;
	34
	35	void
	36	create_hw_instance_data (struct hw *me)
	37	{
	38	me->instances_of_hw = HW_ZALLOC (me, struct hw_instance_data);
	39	set_hw_finish_instance (me, abort_hw_finish_instance);
	40	}
	41
	42	void
	43	delete_hw_instance_data (struct hw *me)
	44	{
	45	/* NOP */
	46	}
	47
	48
	49	static void
	50	abort_hw_finish_instance (struct hw *hw,
	51	struct hw_instance *instance)
	52	{
	53	hw_abort (hw, "no instance finish method");
	54	}
	55
	56	void
	57	set_hw_finish_instance (struct hw *me,
	58	hw_finish_instance_method *finish)
	59	{
	60	me->instances_of_hw->to_finish = finish;
	61	}
	62
	63
	64	#if 0
	65	void
	66	clean_hw_instances (struct hw *me)
	67	{
	68	struct hw_instance **instance = &me->instances;
	69	while (*instance != NULL)
	70	{
	71	struct hw_instance old_instance = instance;
	72	hw_instance_delete (old_instance);
	73	instance = &me->instances;
	74	}
	75	}
	76	#endif
	77
	78
	79	void
	80	hw_instance_delete (struct hw_instance *instance)
	81	{
	82	#if 1
	83	hw_abort (hw_instance_hw (instance), "not implemented");
	84	#else
	85	struct hw *me = hw_instance_hw (instance);
	86	if (instance->to_instance_delete == NULL)
	87	hw_abort (me, "no delete method");
	88	instance->method->delete(instance);
	89	if (instance->args != NULL)
90	zfree (instance->args);
91	if (instance->path != NULL)
92	zfree (instance->path);
93	if (instance->child == NULL)
94	{
95	/* only remove leaf nodes */
96	struct hw_instance **curr = &me->instances;
97	while (*curr != instance)
98	{
99	ASSERT (*curr != NULL);
100	curr = &(*curr)->next;
101	}
102	*curr = instance->next;
103	}
104	else
105	{
106	/* check it isn't in the instance list */
107	struct hw_instance *curr = me->instances;
108	while (curr != NULL)
109	{
110	ASSERT(curr != instance);
111	curr = curr->next;
112	}
113	/* unlink the child */
114	ASSERT (instance->child->parent == instance);
115	instance->child->parent = NULL;
116	}
117	cap_remove (me->ihandles, instance);
118	zfree (instance);
119	#endif
120	}
121
122
123	static int
124	panic_hw_instance_read (struct hw_instance *instance,
125	void *addr,
126	unsigned_word len)
127	{
128	hw_abort (hw_instance_hw (instance), "no read method");
129	return -1;
130	}
131
132
133
134	static int
135	panic_hw_instance_write (struct hw_instance *instance,
136	const void *addr,
137	unsigned_word len)
138	{
139	hw_abort (hw_instance_hw (instance), "no write method");
140	return -1;
141	}
142
143
144	static int
145	panic_hw_instance_seek (struct hw_instance *instance,
146	unsigned_word pos_hi,
147	unsigned_word pos_lo)
148	{
149	hw_abort (hw_instance_hw (instance), "no seek method");
150	return -1;
151	}
152
153
154	int
155	hw_instance_call_method (struct hw_instance *instance,
156	const char *method_name,
157	int n_stack_args,
158	unsigned_cell stack_args[/n_stack_args/],
159	int n_stack_returns,
160	unsigned_cell stack_returns[/n_stack_args/])
161	{
162	#if 1
163	hw_abort (hw_instance_hw (instance), "not implemented");
164	return -1;
165	#else
166	struct hw *me = instance->owner;
167	const hw_instance_methods *method = instance->method->methods;
168	if (method == NULL)
169	{
170	hw_abort (me, "no methods (want %s)", method_name);
171	}
172	while (method->name != NULL)
173	{
174	if (strcmp(method->name, method_name) == 0)
175	{
176	return method->method (instance,
177	n_stack_args, stack_args,
178	n_stack_returns, stack_returns);
179	}
180	method++;
181	}
182	hw_abort (me, "no %s method", method_name);
183	return 0;
184	#endif
185	}
186
187
188	#define set_hw_instance_read(instance, method)\
189	((instance)->to_instance_read = (method))
190
191	#define set_hw_instance_write(instance, method)\
192	((instance)->to_instance_write = (method))
193
194	#define set_hw_instance_seek(instance, method)\
195	((instance)->to_instance_seek = (method))
196
197
198	#if 0
199	static void
200	set_hw_instance_finish (struct hw *me,
201	hw_instance_finish_method *method)
202	{
203	if (me->instances_of_hw == NULL)
204	me->instances_of_hw = HW_ZALLOC (me, struct hw_instance_data);
205	me->instances_of_hw->to_finish = method;
206	}
207	#endif
208
209
210	struct hw_instance *
211	hw_instance_create (struct hw *me,
212	struct hw_instance *parent,
213	const char *path,
214	const char *args)
215	{
216	struct hw_instance *instance = ZALLOC (struct hw_instance);
217	/instance->unit/
218	/* link this instance into the devices list */
219	instance->hw_of_instance = me;
220	instance->parent_of_instance = NULL;
221	/* link this instance into the front of the devices instance list */
222	instance->sibling_of_instance = me->instances_of_hw->instances;
223	me->instances_of_hw->instances = instance;
224	if (parent != NULL)
225	{
226	ASSERT (parent->child_of_instance == NULL);
227	parent->child_of_instance = instance;
228	instance->parent_of_instance = parent;
229	}
230	instance->args_of_instance = hw_strdup (me, args);
231	instance->path_of_instance = hw_strdup (me, path);
232	set_hw_instance_read (instance, panic_hw_instance_read);
233	set_hw_instance_write (instance, panic_hw_instance_write);
234	set_hw_instance_seek (instance, panic_hw_instance_seek);
235	hw_handle_add_ihandle (me, instance);
236	me->instances_of_hw->to_finish (me, instance);
237	return instance;
238	}
239
240
241	struct hw_instance *
242	hw_instance_interceed (struct hw_instance *parent,
243	const char *path,
244	const char *args)
245	{
246	#if 1
247	return NULL;
248	#else
249	struct hw_instance *instance = ZALLOC (struct hw_instance);
250	/instance->unit/
251	/* link this instance into the devices list */
252	if (me != NULL)
253	{
254	ASSERT (parent == NULL);
255	instance->hw_of_instance = me;
256	instance->parent_of_instance = NULL;
257	/* link this instance into the front of the devices instance list */
258	instance->sibling_of_instance = me->instances_of_hw->instances;
259	me->instances_of_hw->instances = instance;
260	}
261	if (parent != NULL)
262	{
263	struct hw_instance **previous;
264	ASSERT (parent->child_of_instance == NULL);
265	parent->child_of_instance = instance;
266	instance->owner = parent->owner;
267	instance->parent_of_instance = parent;
268	/* in the devices instance list replace the parent instance with
269	this one */
270	instance->next = parent->next;
271	/* replace parent with this new node */
272	previous = &instance->owner->instances;
273	while (*previous != parent)
274	{
275	ASSERT (*previous != NULL);
276	previous = &(*previous)->next;
277	}
278	*previous = instance;
279	}
280	instance->data = data;
281	instance->args = (args == NULL ? NULL : (char *) strdup(args));
282	instance->path = (path == NULL ? NULL : (char *) strdup(path));
283	cap_add (instance->owner->ihandles, instance);
284	return instance;
285	#endif
286	}