URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [sim/] [m32c/] [mem.c] - Blame information for rev 300

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


/* mem.c --- memory for M32C simulator.
 
Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
 
This file is part of the GNU simulators.
 
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 <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "mem.h"
#include "cpu.h"
#include "syscalls.h"
#include "misc.h"
 
#define L1_BITS  (10)
#define L2_BITS  (10)
#define OFF_BITS (12)
 
#define L1_LEN  (1 << L1_BITS)
#define L2_LEN  (1 << L2_BITS)
#define OFF_LEN (1 << OFF_BITS)
 
static unsigned char **pt[L1_LEN];
 
/* [ get=0/put=1 ][ byte size ] */
static unsigned int mem_counters[2][4];
 
#define COUNT(isput,bytes)                                      \
  if (verbose && enable_counting) mem_counters[isput][bytes]++
 
void
init_mem (void)
{
  int i, j;
 
  for (i = 0; i < L1_LEN; i++)
    if (pt[i])
      {
        for (j = 0; j < L2_LEN; j++)
          if (pt[i][j])
            free (pt[i][j]);
        free (pt[i]);
      }
  memset (pt, 0, sizeof (pt));
  memset (mem_counters, 0, sizeof (mem_counters));
}
 
static unsigned char *
mem_ptr (address)
{
  int pt1 = (address >> (L2_BITS + OFF_BITS)) & ((1 << L1_BITS) - 1);
  int pt2 = (address >> OFF_BITS) & ((1 << L2_BITS) - 1);
  int pto = address & ((1 << OFF_BITS) - 1);
 
  if (address == 0)
    {
      printf ("NULL pointer dereference\n");
      exit (1);
    }
 
  if (pt[pt1] == 0)
    pt[pt1] = (unsigned char **) calloc (L2_LEN, sizeof (char **));
  if (pt[pt1][pt2] == 0)
    {
      pt[pt1][pt2] = (unsigned char *) malloc (OFF_LEN);
      memset (pt[pt1][pt2], 0, OFF_LEN);
    }
 
  return pt[pt1][pt2] + pto;
}
 
static void
used (int rstart, int i, int j)
{
  int rend = i << (L2_BITS + OFF_BITS);
  rend += j << OFF_BITS;
  if (rstart == 0xe0000 && rend == 0xe1000)
    return;
  printf ("mem:   %08x - %08x (%dk bytes)\n", rstart, rend - 1,
          (rend - rstart) / 1024);
}
 
static char *
mcs (int isput, int bytes)
{
  return comma (mem_counters[isput][bytes]);
}
 
void
mem_usage_stats ()
{
  int i, j;
  int rstart = 0;
  int pending = 0;
 
  for (i = 0; i < L1_LEN; i++)
    if (pt[i])
      {
        for (j = 0; j < L2_LEN; j++)
          if (pt[i][j])
            {
              if (!pending)
                {
                  pending = 1;
                  rstart = (i << (L2_BITS + OFF_BITS)) + (j << OFF_BITS);
                }
            }
          else if (pending)
            {
              pending = 0;
              used (rstart, i, j);
            }
      }
    else
      {
        if (pending)
          {
            pending = 0;
            used (rstart, i, 0);
          }
      }
  /*       mem foo: 123456789012 123456789012 123456789012 123456789012
            123456789012 */
  printf ("                 byte        short      pointer         long"
          "        fetch\n");
  printf ("mem get: %12s %12s %12s %12s %12s\n", mcs (0, 1), mcs (0, 2),
          mcs (0, 3), mcs (0, 4), mcs (0, 0));
  printf ("mem put: %12s %12s %12s %12s\n", mcs (1, 1), mcs (1, 2),
          mcs (1, 3), mcs (1, 4));
}
 
static int tpr = 0;
static void
s (int address, char *dir)
{
  if (tpr == 0)
    printf ("MEM[%0*x] %s", membus_mask == 0xfffff ? 5 : 6, address, dir);
  tpr++;
}
 
#define S(d) if (trace) s(address, d)
static void
e ()
{
  if (!trace)
    return;
  tpr--;
  if (tpr == 0)
    printf ("\n");
}
 
#define E() if (trace) e()
 
void
mem_put_byte (int address, unsigned char value)
{
  unsigned char *m;
  address &= membus_mask;
  m = mem_ptr (address);
  if (trace)
    printf (" %02x", value);
  *m = value;
  switch (address)
    {
    case 0x00e1:
      {
        static int old_led = -1;
        static char *led_on[] =
          { "\033[31m O ", "\033[32m O ", "\033[34m O " };
        static char *led_off[] = { "\033[0m � ", "\033[0m � ", "\033[0m � " };
        int i;
        if (old_led != value)
          {
            fputs ("  ", stdout);
            for (i = 0; i < 3; i++)
              if (value & (1 << i))
                fputs (led_off[i], stdout);
              else
                fputs (led_on[i], stdout);
            fputs ("\033[0m\r", stdout);
            fflush (stdout);
            old_led = value;
          }
      }
      break;
 
    case 0x3aa: /* uart1tx */
      {
        static int pending_exit = 0;
        if (value == 0)
          {
            if (pending_exit)
              {
                step_result = M32C_MAKE_EXITED(value);
                return;
              }
            pending_exit = 1;
          }
        else
          putchar(value);
      }
      break;
 
    case 0x400:
      m32c_syscall (value);
      break;
 
    case 0x401:
      putchar (value);
      break;
 
    case 0x402:
      printf ("SimTrace: %06lx %02x\n", regs.r_pc, value);
      break;
 
    case 0x403:
      printf ("SimTrap: %06lx %02x\n", regs.r_pc, value);
      abort ();
    }
}
 
void
mem_put_qi (int address, unsigned char value)
{
  S ("<=");
  mem_put_byte (address, value & 0xff);
  E ();
  COUNT (1, 1);
}
 
void
mem_put_hi (int address, unsigned short value)
{
  if (address == 0x402)
    {
      printf ("SimTrace: %06lx %04x\n", regs.r_pc, value);
      return;
    }
  S ("<=");
  mem_put_byte (address, value & 0xff);
  mem_put_byte (address + 1, value >> 8);
  E ();
  COUNT (1, 2);
}
 
void
mem_put_psi (int address, unsigned long value)
{
  S ("<=");
  mem_put_byte (address, value & 0xff);
  mem_put_byte (address + 1, (value >> 8) & 0xff);
  mem_put_byte (address + 2, value >> 16);
  E ();
  COUNT (1, 3);
}
 
void
mem_put_si (int address, unsigned long value)
{
  S ("<=");
  mem_put_byte (address, value & 0xff);
  mem_put_byte (address + 1, (value >> 8) & 0xff);
  mem_put_byte (address + 2, (value >> 16) & 0xff);
  mem_put_byte (address + 3, (value >> 24) & 0xff);
  E ();
  COUNT (1, 4);
}
 
void
mem_put_blk (int address, void *bufptr, int nbytes)
{
  S ("<=");
  if (enable_counting)
    mem_counters[1][1] += nbytes;
  while (nbytes--)
    mem_put_byte (address++, *(unsigned char *) bufptr++);
  E ();
}
 
unsigned char
mem_get_pc ()
{
  unsigned char *m = mem_ptr (regs.r_pc & membus_mask);
  COUNT (0, 0);
  return *m;
}
 
static unsigned char
mem_get_byte (int address)
{
  unsigned char *m;
  address &= membus_mask;
  S ("=>");
  m = mem_ptr (address);
  switch (address)
    {
    case 0x3ad: /* uart1c1 */
      E();
      return 2; /* transmitter empty */
      break;
    default:
      if (trace)
        printf (" %02x", *m);
      break;
    }
  E ();
  return *m;
}
 
unsigned char
mem_get_qi (int address)
{
  unsigned char rv;
  S ("=>");
  rv = mem_get_byte (address);
  COUNT (0, 1);
  E ();
  return rv;
}
 
unsigned short
mem_get_hi (int address)
{
  unsigned short rv;
  S ("=>");
  rv = mem_get_byte (address);
  rv |= mem_get_byte (address + 1) * 256;
  COUNT (0, 2);
  E ();
  return rv;
}
 
unsigned long
mem_get_psi (int address)
{
  unsigned long rv;
  S ("=>");
  rv = mem_get_byte (address);
  rv |= mem_get_byte (address + 1) * 256;
  rv |= mem_get_byte (address + 2) * 65536;
  COUNT (0, 3);
  E ();
  return rv;
}
 
unsigned long
mem_get_si (int address)
{
  unsigned long rv;
  S ("=>");
  rv = mem_get_byte (address);
  rv |= mem_get_byte (address + 1) << 8;
  rv |= mem_get_byte (address + 2) << 16;
  rv |= mem_get_byte (address + 3) << 24;
  COUNT (0, 4);
  E ();
  return rv;
}
 
void
mem_get_blk (int address, void *bufptr, int nbytes)
{
  S ("=>");
  if (enable_counting)
    mem_counters[0][1] += nbytes;
  while (nbytes--)
    *(char *) bufptr++ = mem_get_byte (address++);
  E ();
}
 
int
sign_ext (int v, int bits)
{
  if (bits < 32)
    {
      v &= (1 << bits) - 1;
      if (v & (1 << (bits - 1)))
        v -= (1 << bits);
    }
  return v;
}

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [sim/] [m32c/] [mem.c] - Blame information for rev 300

Line No.	Rev	Author	Line
1	24	jeremybenn	`/* mem.c --- memory for M32C simulator.`
2
3			`Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.`
4			`Contributed by Red Hat, Inc.`
5
6			`This file is part of the GNU simulators.`
7
8			`This program is free software; you can redistribute it and/or modify`
9			`it under the terms of the GNU General Public License as published by`
10			`the Free Software Foundation; either version 3 of the License, or`
11			`(at your option) any later version.`
12
13			`This program is distributed in the hope that it will be useful,`
14			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`GNU General Public License for more details.`
17
18			`You should have received a copy of the GNU General Public License`
19			`along with this program. If not, see <http://www.gnu.org/licenses/>. */`
20
21
22			`#include <stdio.h>`
23			`#include <stdlib.h>`
24			`#include <string.h>`
25
26			`#include "mem.h"`
27			`#include "cpu.h"`
28			`#include "syscalls.h"`
29			`#include "misc.h"`
30
31			`#define L1_BITS (10)`
32			`#define L2_BITS (10)`
33			`#define OFF_BITS (12)`
34
35			`#define L1_LEN (1 << L1_BITS)`
36			`#define L2_LEN (1 << L2_BITS)`
37			`#define OFF_LEN (1 << OFF_BITS)`
38
39			`static unsigned char **pt[L1_LEN];`
40
41			`/* [ get=0/put=1 ][ byte size ] */`
42			`static unsigned int mem_counters[2][4];`
43
44			`#define COUNT(isput,bytes) \`
45			`if (verbose && enable_counting) mem_counters[isput][bytes]++`
46
47			`void`
48			`init_mem (void)`
49			`{`
50			`int i, j;`
51
52			`for (i = 0; i < L1_LEN; i++)`
53			`if (pt[i])`
54			`{`
55			`for (j = 0; j < L2_LEN; j++)`
56			`if (pt[i][j])`
57			`free (pt[i][j]);`
58			`free (pt[i]);`
59			`}`
60			`memset (pt, 0, sizeof (pt));`
61			`memset (mem_counters, 0, sizeof (mem_counters));`
62			`}`
63
64			`static unsigned char *`
65			`mem_ptr (address)`
66			`{`
67			`int pt1 = (address >> (L2_BITS + OFF_BITS)) & ((1 << L1_BITS) - 1);`
68			`int pt2 = (address >> OFF_BITS) & ((1 << L2_BITS) - 1);`
69			`int pto = address & ((1 << OFF_BITS) - 1);`
70
71			`if (address == 0)`
72			`{`
73			`printf ("NULL pointer dereference\n");`
74			`exit (1);`
75			`}`
76
77			`if (pt[pt1] == 0)`
78			`pt[pt1] = (unsigned char ) calloc (L2_LEN, sizeof (char ));`
79			`if (pt[pt1][pt2] == 0)`
80			`{`
81			`pt[pt1][pt2] = (unsigned char *) malloc (OFF_LEN);`
82			`memset (pt[pt1][pt2], 0, OFF_LEN);`
83			`}`
84
85			`return pt[pt1][pt2] + pto;`
86			`}`
87
88			`static void`
89			`used (int rstart, int i, int j)`
90			`{`
91			`int rend = i << (L2_BITS + OFF_BITS);`
92			`rend += j << OFF_BITS;`
93			`if (rstart == 0xe0000 && rend == 0xe1000)`
94			`return;`
95			`printf ("mem: %08x - %08x (%dk bytes)\n", rstart, rend - 1,`
96			`(rend - rstart) / 1024);`
97			`}`
98
99			`static char *`
100			`mcs (int isput, int bytes)`
101			`{`
102			`return comma (mem_counters[isput][bytes]);`
103			`}`
104
105			`void`
106			`mem_usage_stats ()`
107			`{`
108			`int i, j;`
109			`int rstart = 0;`
110			`int pending = 0;`
111
112			`for (i = 0; i < L1_LEN; i++)`
113			`if (pt[i])`
114			`{`
115			`for (j = 0; j < L2_LEN; j++)`
116			`if (pt[i][j])`
117			`{`
118			`if (!pending)`
119			`{`
120			`pending = 1;`
121			`rstart = (i << (L2_BITS + OFF_BITS)) + (j << OFF_BITS);`
122			`}`
123			`}`
124			`else if (pending)`
125			`{`
126			`pending = 0;`
127			`used (rstart, i, j);`
128			`}`
129			`}`
130			`else`
131			`{`
132			`if (pending)`
133			`{`
134			`pending = 0;`
135			`used (rstart, i, 0);`
136			`}`
137			`}`
138			`/* mem foo: 123456789012 123456789012 123456789012 123456789012`
139			`123456789012 */`
140			`printf (" byte short pointer long"`
141			`" fetch\n");`
142			`printf ("mem get: %12s %12s %12s %12s %12s\n", mcs (0, 1), mcs (0, 2),`
143			`mcs (0, 3), mcs (0, 4), mcs (0, 0));`
144			`printf ("mem put: %12s %12s %12s %12s\n", mcs (1, 1), mcs (1, 2),`
145			`mcs (1, 3), mcs (1, 4));`
146			`}`
147
148			`static int tpr = 0;`
149			`static void`
150			`s (int address, char *dir)`
151			`{`
152			`if (tpr == 0)`
153			`printf ("MEM[%0*x] %s", membus_mask == 0xfffff ? 5 : 6, address, dir);`
154			`tpr++;`
155			`}`
156
157			`#define S(d) if (trace) s(address, d)`
158			`static void`
159			`e ()`
160			`{`
161			`if (!trace)`
162			`return;`
163			`tpr--;`
164			`if (tpr == 0)`
165			`printf ("\n");`
166			`}`
167
168			`#define E() if (trace) e()`
169
170			`void`
171			`mem_put_byte (int address, unsigned char value)`
172			`{`
173			`unsigned char *m;`
174			`address &= membus_mask;`
175			`m = mem_ptr (address);`
176			`if (trace)`
177			`printf (" %02x", value);`
178			`*m = value;`
179			`switch (address)`
180			`{`
181			`case 0x00e1:`
182			`{`
183			`static int old_led = -1;`
184			`static char *led_on[] =`
185			`{ "\033[31m O ", "\033[32m O ", "\033[34m O " };`
186			`static char *led_off[] = { "\033[0m � ", "\033[0m � ", "\033[0m � " };`
187			`int i;`
188			`if (old_led != value)`
189			`{`
190			`fputs (" ", stdout);`
191			`for (i = 0; i < 3; i++)`
192			`if (value & (1 << i))`
193			`fputs (led_off[i], stdout);`
194			`else`
195			`fputs (led_on[i], stdout);`
196			`fputs ("\033[0m\r", stdout);`
197			`fflush (stdout);`
198			`old_led = value;`
199			`}`
200			`}`
201			`break;`
202
203			`case 0x3aa: /* uart1tx */`
204			`{`
205			`static int pending_exit = 0;`
206			`if (value == 0)`
207			`{`
208			`if (pending_exit)`
209			`{`
210			`step_result = M32C_MAKE_EXITED(value);`
211			`return;`
212			`}`
213			`pending_exit = 1;`
214			`}`
215			`else`
216			`putchar(value);`
217			`}`
218			`break;`
219
220			`case 0x400:`
221			`m32c_syscall (value);`
222			`break;`
223
224			`case 0x401:`
225			`putchar (value);`
226			`break;`
227
228			`case 0x402:`
229			`printf ("SimTrace: %06lx %02x\n", regs.r_pc, value);`
230			`break;`
231
232			`case 0x403:`
233			`printf ("SimTrap: %06lx %02x\n", regs.r_pc, value);`
234			`abort ();`
235			`}`
236			`}`
237
238			`void`
239			`mem_put_qi (int address, unsigned char value)`
240			`{`
241			`S ("<=");`
242			`mem_put_byte (address, value & 0xff);`
243			`E ();`
244			`COUNT (1, 1);`
245			`}`
246
247			`void`
248			`mem_put_hi (int address, unsigned short value)`
249			`{`
250			`if (address == 0x402)`
251			`{`
252			`printf ("SimTrace: %06lx %04x\n", regs.r_pc, value);`
253			`return;`
254			`}`
255			`S ("<=");`
256			`mem_put_byte (address, value & 0xff);`
257			`mem_put_byte (address + 1, value >> 8);`
258			`E ();`
259			`COUNT (1, 2);`
260			`}`
261
262			`void`
263			`mem_put_psi (int address, unsigned long value)`
264			`{`
265			`S ("<=");`
266			`mem_put_byte (address, value & 0xff);`
267			`mem_put_byte (address + 1, (value >> 8) & 0xff);`
268			`mem_put_byte (address + 2, value >> 16);`
269			`E ();`
270			`COUNT (1, 3);`
271			`}`
272
273			`void`
274			`mem_put_si (int address, unsigned long value)`
275			`{`
276			`S ("<=");`
277			`mem_put_byte (address, value & 0xff);`
278			`mem_put_byte (address + 1, (value >> 8) & 0xff);`
279			`mem_put_byte (address + 2, (value >> 16) & 0xff);`
280			`mem_put_byte (address + 3, (value >> 24) & 0xff);`
281			`E ();`
282			`COUNT (1, 4);`
283			`}`
284
285			`void`
286			`mem_put_blk (int address, void *bufptr, int nbytes)`
287			`{`
288			`S ("<=");`
289			`if (enable_counting)`
290			`mem_counters[1][1] += nbytes;`
291			`while (nbytes--)`
292			`mem_put_byte (address++, (unsigned char ) bufptr++);`
293			`E ();`
294			`}`
295
296			`unsigned char`
297			`mem_get_pc ()`
298			`{`
299			`unsigned char *m = mem_ptr (regs.r_pc & membus_mask);`
300			`COUNT (0, 0);`
301			`return *m;`
302			`}`
303
304			`static unsigned char`
305			`mem_get_byte (int address)`
306			`{`
307			`unsigned char *m;`
308			`address &= membus_mask;`
309			`S ("=>");`
310			`m = mem_ptr (address);`
311			`switch (address)`
312			`{`
313			`case 0x3ad: /* uart1c1 */`
314			`E();`
315			`return 2; /* transmitter empty */`
316			`break;`
317			`default:`
318			`if (trace)`
319			`printf (" %02x", *m);`
320			`break;`
321			`}`
322			`E ();`
323			`return *m;`
324			`}`
325
326			`unsigned char`
327			`mem_get_qi (int address)`
328			`{`
329			`unsigned char rv;`
330			`S ("=>");`
331			`rv = mem_get_byte (address);`
332			`COUNT (0, 1);`
333			`E ();`
334			`return rv;`
335			`}`
336
337			`unsigned short`
338			`mem_get_hi (int address)`
339			`{`
340			`unsigned short rv;`
341			`S ("=>");`
342			`rv = mem_get_byte (address);`
343			`rv \|= mem_get_byte (address + 1) * 256;`
344			`COUNT (0, 2);`
345			`E ();`
346			`return rv;`
347			`}`
348
349			`unsigned long`
350			`mem_get_psi (int address)`
351			`{`
352			`unsigned long rv;`
353			`S ("=>");`
354			`rv = mem_get_byte (address);`
355			`rv \|= mem_get_byte (address + 1) * 256;`
356			`rv \|= mem_get_byte (address + 2) * 65536;`
357			`COUNT (0, 3);`
358			`E ();`
359			`return rv;`
360			`}`
361
362			`unsigned long`
363			`mem_get_si (int address)`
364			`{`
365			`unsigned long rv;`
366			`S ("=>");`
367			`rv = mem_get_byte (address);`
368			`rv \|= mem_get_byte (address + 1) << 8;`
369			`rv \|= mem_get_byte (address + 2) << 16;`
370			`rv \|= mem_get_byte (address + 3) << 24;`
371			`COUNT (0, 4);`
372			`E ();`
373			`return rv;`
374			`}`
375
376			`void`
377			`mem_get_blk (int address, void *bufptr, int nbytes)`
378			`{`
379			`S ("=>");`
380			`if (enable_counting)`
381			`mem_counters[0][1] += nbytes;`
382			`while (nbytes--)`
383			`(char ) bufptr++ = mem_get_byte (address++);`
384			`E ();`
385			`}`
386
387			`int`
388			`sign_ext (int v, int bits)`
389			`{`
390			`if (bits < 32)`
391			`{`
392			`v &= (1 << bits) - 1;`
393			`if (v & (1 << (bits - 1)))`
394			`v -= (1 << bits);`
395			`}`
396			`return v;`
397			`}`