OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [sim/] [common/] [hw-instances.c] - Blame information for rev 856

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* The common simulator framework for GDB, the GNU Debugger.
2
 
3
   Copyright 2002, 2007, 2008 Free Software Foundation, Inc.
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
11
   the Free Software Foundation; either version 3 of the License, or
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
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
 
23
#include "hw-main.h"
24
#include "hw-base.h"
25
 
26
#include "sim-io.h"
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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.