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

/* The common simulator framework for GDB, the GNU Debugger.

   Copyright 2002, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.

   Contributed by Andrew Cagney and Red Hat.

   This file is part of GDB.

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