URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [sim/] [ppc/] [corefile.c] - Blame information for rev 252

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


/*  This file is part of the program psim.
 
    Copyright (C) 1994-1996, 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.
 
    */
 
 
#ifndef _CORE_C_
#define _CORE_C_
 
#include "basics.h"
#include "device_table.h"
#include "corefile.h"
 
typedef struct _core_mapping core_mapping;
struct _core_mapping {
  /* common */
  int level;
  int space;
  unsigned_word base;
  unsigned_word bound;
  unsigned nr_bytes;
  /* memory map */
  void *free_buffer;
  void *buffer;
  /* callback map */
  device *device;
  /* growth */
  core_mapping *next;
};
 
struct _core_map {
  core_mapping *first;
};
 
typedef enum {
  core_read_map,
  core_write_map,
  core_execute_map,
  nr_core_map_types,
} core_map_types;
 
struct _core {
  core_map map[nr_core_map_types];
};
 
 
INLINE_CORE\
(core *)
core_create(void)
{
  return ZALLOC(core);
}
 
 
INLINE_CORE\
(core *)
core_from_device(device *root)
{
  root = device_root(root);
  ASSERT(strcmp(device_name(root), "core") == 0);
  return device_data(root);
}
 
 
INLINE_CORE\
(void)
core_init(core *memory)
{
  core_map_types access_type;
  for (access_type = 0;
       access_type < nr_core_map_types;
       access_type++) {
    core_map *map = memory->map + access_type;
    /* blow away old mappings */
    core_mapping *curr = map->first;
    while (curr != NULL) {
      core_mapping *tbd = curr;
      curr = curr->next;
      if (tbd->free_buffer != NULL) {
        ASSERT(tbd->buffer != NULL);
        zfree(tbd->free_buffer);
      }
      zfree(tbd);
    }
    map->first = NULL;
  }
}
 
 
 
/* the core has three sub mappings that the more efficient
   read/write fixed quantity functions use */
 
INLINE_CORE\
(core_map *)
core_readable(core *memory)
{
  return memory->map + core_read_map;
}
 
INLINE_CORE\
(core_map *)
core_writeable(core *memory)
{
  return memory->map + core_write_map;
}
 
INLINE_CORE\
(core_map *)
core_executable(core *memory)
{
  return memory->map + core_execute_map;
}
 
 
 
STATIC_INLINE_CORE\
(core_mapping *)
new_core_mapping(attach_type attach,
                 int space,
                 unsigned_word addr,
                 unsigned nr_bytes,
                 device *device,
                 void *buffer,
                 void *free_buffer)
{
  core_mapping *new_mapping = ZALLOC(core_mapping);
  /* common */
  new_mapping->level = attach;
  new_mapping->space = space;
  new_mapping->base = addr;
  new_mapping->nr_bytes = nr_bytes;
  new_mapping->bound = addr + (nr_bytes - 1);
  if (attach == attach_raw_memory) {
    new_mapping->buffer = buffer;
    new_mapping->free_buffer = free_buffer;
  }
  else if (attach >= attach_callback) {
    new_mapping->device = device;
  }
  else {
    error("new_core_mapping() - internal error - unknown attach type %d\n",
          attach);
  }
  return new_mapping;
}
 
 
STATIC_INLINE_CORE\
(void)
core_map_attach(core_map *access_map,
                attach_type attach,
                int space,
                unsigned_word addr,
                unsigned nr_bytes, /* host limited */
                device *client, /*callback/default*/
                void *buffer, /*raw_memory*/
                void *free_buffer) /*raw_memory*/
{
  /* find the insertion point for this additional mapping and insert */
  core_mapping *next_mapping;
  core_mapping **last_mapping;
 
  /* actually do occasionally get a zero size map */
  if (nr_bytes == 0) {
    device_error(client, "called on core_map_attach() with size zero");
  }
 
  /* find the insertion point (between last/next) */
  next_mapping = access_map->first;
  last_mapping = &access_map->first;
  while(next_mapping != NULL
        && (next_mapping->level < attach
            || (next_mapping->level == attach
                && next_mapping->bound < addr))) {
    /* provided levels are the same */
    /* assert: next_mapping->base > all bases before next_mapping */
    /* assert: next_mapping->bound >= all bounds before next_mapping */
    last_mapping = &next_mapping->next;
    next_mapping = next_mapping->next;
  }
 
  /* check insertion point correct */
  ASSERT(next_mapping == NULL || next_mapping->level >= attach);
  if (next_mapping != NULL && next_mapping->level == attach
      && next_mapping->base < (addr + (nr_bytes - 1))) {
    device_error(client, "map overlap when attaching %d:0x%lx (%ld)",
                 space, (long)addr, (long)nr_bytes);
  }
 
  /* create/insert the new mapping */
  *last_mapping = new_core_mapping(attach,
                                   space, addr, nr_bytes,
                                   client, buffer, free_buffer);
  (*last_mapping)->next = next_mapping;
}
 
 
INLINE_CORE\
(void)
core_attach(core *memory,
            attach_type attach,
            int space,
            access_type access,
            unsigned_word addr,
            unsigned nr_bytes, /* host limited */
            device *client) /*callback/default*/
{
  core_map_types access_map;
  void *buffer;
  void *free_buffer;
  if (attach == attach_raw_memory) {
    /* Padd out the raw buffer to ensure that ADDR starts on a
       correctly aligned boundary */
    int padding = (addr % sizeof (unsigned64));
    free_buffer = zalloc(nr_bytes + padding);
    buffer = (char*)free_buffer + padding;
  }
  else {
    buffer = NULL;
    free_buffer = &buffer; /* marker for assertion */
  }
  for (access_map = 0;
       access_map < nr_core_map_types;
       access_map++) {
    switch (access_map) {
    case core_read_map:
      if (access & access_read)
        core_map_attach(memory->map + access_map,
                        attach,
                        space, addr, nr_bytes,
                        client, buffer, free_buffer);
      free_buffer = NULL;
      break;
    case core_write_map:
      if (access & access_write)
        core_map_attach(memory->map + access_map,
                        attach,
                        space, addr, nr_bytes,
                        client, buffer, free_buffer);
      free_buffer = NULL;
      break;
    case core_execute_map:
      if (access & access_exec)
        core_map_attach(memory->map + access_map,
                        attach,
                        space, addr, nr_bytes,
                        client, buffer, free_buffer);
      free_buffer = NULL;
      break;
    default:
      error("core_attach() internal error\n");
      break;
    }
  }
  /* allocated buffer must attach to at least one thing */
  ASSERT(free_buffer == NULL);
}
 
 
STATIC_INLINE_CORE\
(core_mapping *)
core_map_find_mapping(core_map *map,
                      unsigned_word addr,
                      unsigned nr_bytes,
                      cpu *processor,
                      unsigned_word cia,
                      int abort) /*either 0 or 1 - helps inline */
{
  core_mapping *mapping = map->first;
  ASSERT((addr & (nr_bytes - 1)) == 0); /* must be aligned */
  ASSERT((addr + (nr_bytes - 1)) >= addr); /* must not wrap */
  while (mapping != NULL) {
    if (addr >= mapping->base
        && (addr + (nr_bytes - 1)) <= mapping->bound)
      return mapping;
    mapping = mapping->next;
  }
  if (abort)
    error("core_find_mapping() - access to unmaped address, attach a default map to handle this - addr=0x%x nr_bytes=0x%x processor=0x%x cia=0x%x\n",
          addr, nr_bytes, processor, cia);
  return NULL;
}
 
 
STATIC_INLINE_CORE\
(void *)
core_translate(core_mapping *mapping,
               unsigned_word addr)
{
  return (void *)(((char *)mapping->buffer) + addr - mapping->base);
}
 
 
INLINE_CORE\
(unsigned)
core_map_read_buffer(core_map *map,
                     void *buffer,
                     unsigned_word addr,
                     unsigned len)
{
  unsigned count = 0;
  while (count < len) {
    unsigned_word raddr = addr + count;
    core_mapping *mapping =
      core_map_find_mapping(map,
                            raddr, 1,
                            NULL, /*processor*/
                            0, /*cia*/
                            0); /*dont-abort*/
    if (mapping == NULL)
      break;
    if (mapping->device != NULL) {
      int nr_bytes = len - count;
      if (raddr + nr_bytes - 1> mapping->bound)
        nr_bytes = mapping->bound - raddr + 1;
      if (device_io_read_buffer(mapping->device,
                                (unsigned_1*)buffer + count,
                                mapping->space,
                                raddr,
                                nr_bytes,
                                0, /*processor*/
 
        break;
      count += nr_bytes;
    }
    else {
      ((unsigned_1*)buffer)[count] =
        *(unsigned_1*)core_translate(mapping, raddr);
      count += 1;
    }
  }
  return count;
}
 
 
INLINE_CORE\
(unsigned)
core_map_write_buffer(core_map *map,
                      const void *buffer,
                      unsigned_word addr,
                      unsigned len)
{
  unsigned count = 0;
  while (count < len) {
    unsigned_word raddr = addr + count;
    core_mapping *mapping = core_map_find_mapping(map,
                                                  raddr, 1,
                                                  NULL, /*processor*/
                                                  0, /*cia*/
                                                  0); /*dont-abort*/
    if (mapping == NULL)
      break;
    if (mapping->device != NULL) {
      int nr_bytes = len - count;
      if (raddr + nr_bytes - 1 > mapping->bound)
        nr_bytes = mapping->bound - raddr + 1;
      if (device_io_write_buffer(mapping->device,
                                 (unsigned_1*)buffer + count,
                                 mapping->space,
                                 raddr,
                                 nr_bytes,
                                 0, /*processor*/
 
        break;
      count += nr_bytes;
    }
    else {
      *(unsigned_1*)core_translate(mapping, raddr) =
        ((unsigned_1*)buffer)[count];
      count += 1;
    }
  }
  return count;
}
 
 
/* define the read/write 1/2/4/8/word functions */
 
#define N 1
#include "corefile-n.h"
#undef N
 
#define N 2
#include "corefile-n.h"
#undef N
 
#define N 4
#include "corefile-n.h"
#undef N
 
#define N 8
#include "corefile-n.h"
#undef N
 
#define N word
#include "corefile-n.h"
#undef N
 
#endif /* _CORE_C_ */

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [sim/] [ppc/] [corefile.c] - Blame information for rev 252

Line No.	Rev	Author	Line
1	227	jeremybenn	`/* This file is part of the program psim.`
2
3			`Copyright (C) 1994-1996, 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			`#ifndef _CORE_C_`
23			`#define _CORE_C_`
24
25			`#include "basics.h"`
26			`#include "device_table.h"`
27			`#include "corefile.h"`
28
29			`typedef struct _core_mapping core_mapping;`
30			`struct _core_mapping {`
31			`/* common */`
32			`int level;`
33			`int space;`
34			`unsigned_word base;`
35			`unsigned_word bound;`
36			`unsigned nr_bytes;`
37			`/* memory map */`
38			`void *free_buffer;`
39			`void *buffer;`
40			`/* callback map */`
41			`device *device;`
42			`/* growth */`
43			`core_mapping *next;`
44			`};`
45
46			`struct _core_map {`
47			`core_mapping *first;`
48			`};`
49
50			`typedef enum {`
51			`core_read_map,`
52			`core_write_map,`
53			`core_execute_map,`
54			`nr_core_map_types,`
55			`} core_map_types;`
56
57			`struct _core {`
58			`core_map map[nr_core_map_types];`
59			`};`
60
61
62			`INLINE_CORE\`
63			`(core *)`
64			`core_create(void)`
65			`{`
66			`return ZALLOC(core);`
67			`}`
68
69
70			`INLINE_CORE\`
71			`(core *)`
72			`core_from_device(device *root)`
73			`{`
74			`root = device_root(root);`
75			`ASSERT(strcmp(device_name(root), "core") == 0);`
76			`return device_data(root);`
77			`}`
78
79
80			`INLINE_CORE\`
81			`(void)`
82			`core_init(core *memory)`
83			`{`
84			`core_map_types access_type;`
85			`for (access_type = 0;`
86			`access_type < nr_core_map_types;`
87			`access_type++) {`
88			`core_map *map = memory->map + access_type;`
89			`/* blow away old mappings */`
90			`core_mapping *curr = map->first;`
91			`while (curr != NULL) {`
92			`core_mapping *tbd = curr;`
93			`curr = curr->next;`
94			`if (tbd->free_buffer != NULL) {`
95			`ASSERT(tbd->buffer != NULL);`
96			`zfree(tbd->free_buffer);`
97			`}`
98			`zfree(tbd);`
99			`}`
100			`map->first = NULL;`
101			`}`
102			`}`
103
104
105
106			`/* the core has three sub mappings that the more efficient`
107			`read/write fixed quantity functions use */`
108
109			`INLINE_CORE\`
110			`(core_map *)`
111			`core_readable(core *memory)`
112			`{`
113			`return memory->map + core_read_map;`
114			`}`
115
116			`INLINE_CORE\`
117			`(core_map *)`
118			`core_writeable(core *memory)`
119			`{`
120			`return memory->map + core_write_map;`
121			`}`
122
123			`INLINE_CORE\`
124			`(core_map *)`
125			`core_executable(core *memory)`
126			`{`
127			`return memory->map + core_execute_map;`
128			`}`
129
130
131
132			`STATIC_INLINE_CORE\`
133			`(core_mapping *)`
134			`new_core_mapping(attach_type attach,`
135			`int space,`
136			`unsigned_word addr,`
137			`unsigned nr_bytes,`
138			`device *device,`
139			`void *buffer,`
140			`void *free_buffer)`
141			`{`
142			`core_mapping *new_mapping = ZALLOC(core_mapping);`
143			`/* common */`
144			`new_mapping->level = attach;`
145			`new_mapping->space = space;`
146			`new_mapping->base = addr;`
147			`new_mapping->nr_bytes = nr_bytes;`
148			`new_mapping->bound = addr + (nr_bytes - 1);`
149			`if (attach == attach_raw_memory) {`
150			`new_mapping->buffer = buffer;`
151			`new_mapping->free_buffer = free_buffer;`
152			`}`
153			`else if (attach >= attach_callback) {`
154			`new_mapping->device = device;`
155			`}`
156			`else {`
157			`error("new_core_mapping() - internal error - unknown attach type %d\n",`
158			`attach);`
159			`}`
160			`return new_mapping;`
161			`}`
162
163
164			`STATIC_INLINE_CORE\`
165			`(void)`
166			`core_map_attach(core_map *access_map,`
167			`attach_type attach,`
168			`int space,`
169			`unsigned_word addr,`
170			`unsigned nr_bytes, /* host limited */`
171			`device client, /callback/default*/`
172			`void buffer, /raw_memory*/`
173			`void free_buffer) /raw_memory*/`
174			`{`
175			`/* find the insertion point for this additional mapping and insert */`
176			`core_mapping *next_mapping;`
177			`core_mapping **last_mapping;`
178
179			`/* actually do occasionally get a zero size map */`
180			`if (nr_bytes == 0) {`
181			`device_error(client, "called on core_map_attach() with size zero");`
182			`}`
183
184			`/* find the insertion point (between last/next) */`
185			`next_mapping = access_map->first;`
186			`last_mapping = &access_map->first;`
187			`while(next_mapping != NULL`
188			`&& (next_mapping->level < attach`
189			`\|\| (next_mapping->level == attach`
190			`&& next_mapping->bound < addr))) {`
191			`/* provided levels are the same */`
192			`/* assert: next_mapping->base > all bases before next_mapping */`
193			`/* assert: next_mapping->bound >= all bounds before next_mapping */`
194			`last_mapping = &next_mapping->next;`
195			`next_mapping = next_mapping->next;`
196			`}`
197
198			`/* check insertion point correct */`
199			`ASSERT(next_mapping == NULL \|\| next_mapping->level >= attach);`
200			`if (next_mapping != NULL && next_mapping->level == attach`
201			`&& next_mapping->base < (addr + (nr_bytes - 1))) {`
202			`device_error(client, "map overlap when attaching %d:0x%lx (%ld)",`
203			`space, (long)addr, (long)nr_bytes);`
204			`}`
205
206			`/* create/insert the new mapping */`
207			`*last_mapping = new_core_mapping(attach,`
208			`space, addr, nr_bytes,`
209			`client, buffer, free_buffer);`
210			`(*last_mapping)->next = next_mapping;`
211			`}`
212
213
214			`INLINE_CORE\`
215			`(void)`
216			`core_attach(core *memory,`
217			`attach_type attach,`
218			`int space,`
219			`access_type access,`
220			`unsigned_word addr,`
221			`unsigned nr_bytes, /* host limited */`
222			`device client) /callback/default*/`
223			`{`
224			`core_map_types access_map;`
225			`void *buffer;`
226			`void *free_buffer;`
227			`if (attach == attach_raw_memory) {`
228			`/* Padd out the raw buffer to ensure that ADDR starts on a`
229			`correctly aligned boundary */`
230			`int padding = (addr % sizeof (unsigned64));`
231			`free_buffer = zalloc(nr_bytes + padding);`
232			`buffer = (char*)free_buffer + padding;`
233			`}`
234			`else {`
235			`buffer = NULL;`
236			`free_buffer = &buffer; /* marker for assertion */`
237			`}`
238			`for (access_map = 0;`
239			`access_map < nr_core_map_types;`
240			`access_map++) {`
241			`switch (access_map) {`
242			`case core_read_map:`
243			`if (access & access_read)`
244			`core_map_attach(memory->map + access_map,`
245			`attach,`
246			`space, addr, nr_bytes,`
247			`client, buffer, free_buffer);`
248			`free_buffer = NULL;`
249			`break;`
250			`case core_write_map:`
251			`if (access & access_write)`
252			`core_map_attach(memory->map + access_map,`
253			`attach,`
254			`space, addr, nr_bytes,`
255			`client, buffer, free_buffer);`
256			`free_buffer = NULL;`
257			`break;`
258			`case core_execute_map:`
259			`if (access & access_exec)`
260			`core_map_attach(memory->map + access_map,`
261			`attach,`
262			`space, addr, nr_bytes,`
263			`client, buffer, free_buffer);`
264			`free_buffer = NULL;`
265			`break;`
266			`default:`
267			`error("core_attach() internal error\n");`
268			`break;`
269			`}`
270			`}`
271			`/* allocated buffer must attach to at least one thing */`
272			`ASSERT(free_buffer == NULL);`
273			`}`
274
275
276			`STATIC_INLINE_CORE\`
277			`(core_mapping *)`
278			`core_map_find_mapping(core_map *map,`
279			`unsigned_word addr,`
280			`unsigned nr_bytes,`
281			`cpu *processor,`
282			`unsigned_word cia,`
283			`int abort) /either 0 or 1 - helps inline /`
284			`{`
285			`core_mapping *mapping = map->first;`
286			`ASSERT((addr & (nr_bytes - 1)) == 0); /* must be aligned */`
287			`ASSERT((addr + (nr_bytes - 1)) >= addr); /* must not wrap */`
288			`while (mapping != NULL) {`
289			`if (addr >= mapping->base`
290			`&& (addr + (nr_bytes - 1)) <= mapping->bound)`
291			`return mapping;`
292			`mapping = mapping->next;`
293			`}`
294			`if (abort)`
295			`error("core_find_mapping() - access to unmaped address, attach a default map to handle this - addr=0x%x nr_bytes=0x%x processor=0x%x cia=0x%x\n",`
296			`addr, nr_bytes, processor, cia);`
297			`return NULL;`
298			`}`
299
300
301			`STATIC_INLINE_CORE\`
302			`(void *)`
303			`core_translate(core_mapping *mapping,`
304			`unsigned_word addr)`
305			`{`
306			`return (void )(((char )mapping->buffer) + addr - mapping->base);`
307			`}`
308
309
310			`INLINE_CORE\`
311			`(unsigned)`
312			`core_map_read_buffer(core_map *map,`
313			`void *buffer,`
314			`unsigned_word addr,`
315			`unsigned len)`
316			`{`
317			`unsigned count = 0;`
318			`while (count < len) {`
319			`unsigned_word raddr = addr + count;`
320			`core_mapping *mapping =`
321			`core_map_find_mapping(map,`
322			`raddr, 1,`
323			`NULL, /processor/`
324			`0, /cia/`
325			`0); /dont-abort/`
326			`if (mapping == NULL)`
327			`break;`
328			`if (mapping->device != NULL) {`
329			`int nr_bytes = len - count;`
330			`if (raddr + nr_bytes - 1> mapping->bound)`
331			`nr_bytes = mapping->bound - raddr + 1;`
332			`if (device_io_read_buffer(mapping->device,`
333			`(unsigned_1*)buffer + count,`
334			`mapping->space,`
335			`raddr,`
336			`nr_bytes,`
337			`0, /processor/`
338
339			`break;`
340			`count += nr_bytes;`
341			`}`
342			`else {`
343			`((unsigned_1*)buffer)[count] =`
344			`(unsigned_1)core_translate(mapping, raddr);`
345			`count += 1;`
346			`}`
347			`}`
348			`return count;`
349			`}`
350
351
352			`INLINE_CORE\`
353			`(unsigned)`
354			`core_map_write_buffer(core_map *map,`
355			`const void *buffer,`
356			`unsigned_word addr,`
357			`unsigned len)`
358			`{`
359			`unsigned count = 0;`
360			`while (count < len) {`
361			`unsigned_word raddr = addr + count;`
362			`core_mapping *mapping = core_map_find_mapping(map,`
363			`raddr, 1,`
364			`NULL, /processor/`
365			`0, /cia/`
366			`0); /dont-abort/`
367			`if (mapping == NULL)`
368			`break;`
369			`if (mapping->device != NULL) {`
370			`int nr_bytes = len - count;`
371			`if (raddr + nr_bytes - 1 > mapping->bound)`
372			`nr_bytes = mapping->bound - raddr + 1;`
373			`if (device_io_write_buffer(mapping->device,`
374			`(unsigned_1*)buffer + count,`
375			`mapping->space,`
376			`raddr,`
377			`nr_bytes,`
378			`0, /processor/`
379
380			`break;`
381			`count += nr_bytes;`
382			`}`
383			`else {`
384			`(unsigned_1)core_translate(mapping, raddr) =`
385			`((unsigned_1*)buffer)[count];`
386			`count += 1;`
387			`}`
388			`}`
389			`return count;`
390			`}`
391
392
393			`/* define the read/write 1/2/4/8/word functions */`
394
395			`#define N 1`
396			`#include "corefile-n.h"`
397			`#undef N`
398
399			`#define N 2`
400			`#include "corefile-n.h"`
401			`#undef N`
402
403			`#define N 4`
404			`#include "corefile-n.h"`
405			`#undef N`
406
407			`#define N 8`
408			`#include "corefile-n.h"`
409			`#undef N`
410
411			`#define N word`
412			`#include "corefile-n.h"`
413			`#undef N`
414
415			`#endif /* _CORE_C_ */`