oops - omitted from previous delta
[platform/upstream/binutils.git] / sim / rx / mem.c
1 /* mem.c --- memory for RX simulator.
2
3 Copyright (C) 2005, 2007, 2008, 2009, 2010 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 /* This slows down the simulator and we get some false negatives from
22    gcc, like when it uses a long-sized hole to hold a byte-sized
23    variable, knowing that it doesn't care about the other bits.  But,
24    if you need to track down a read-from-unitialized bug, set this to
25    1.  */
26 #define RDCHECK 0
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "mem.h"
33 #include "cpu.h"
34 #include "syscalls.h"
35 #include "misc.h"
36 #include "err.h"
37
38 #define L1_BITS  (10)
39 #define L2_BITS  (10)
40 #define OFF_BITS (12)
41
42 #define L1_LEN  (1 << L1_BITS)
43 #define L2_LEN  (1 << L2_BITS)
44 #define OFF_LEN (1 << OFF_BITS)
45
46 static unsigned char **pt[L1_LEN];
47 static unsigned char **ptr[L1_LEN];
48
49 /* [ get=0/put=1 ][ byte size ] */
50 static unsigned int mem_counters[2][5];
51
52 #define COUNT(isput,bytes)                                      \
53   if (verbose && enable_counting) mem_counters[isput][bytes]++
54
55 void
56 init_mem (void)
57 {
58   int i, j;
59
60   for (i = 0; i < L1_LEN; i++)
61     if (pt[i])
62       {
63         for (j = 0; j < L2_LEN; j++)
64           if (pt[i][j])
65             free (pt[i][j]);
66         free (pt[i]);
67       }
68   memset (pt, 0, sizeof (pt));
69   memset (ptr, 0, sizeof (ptr));
70   memset (mem_counters, 0, sizeof (mem_counters));
71 }
72
73 enum mem_ptr_action
74 {
75   MPA_WRITING,
76   MPA_READING,
77   MPA_CONTENT_TYPE
78 };
79
80 static unsigned char *
81 mem_ptr (unsigned long address, enum mem_ptr_action action)
82 {
83   int pt1 = (address >> (L2_BITS + OFF_BITS)) & ((1 << L1_BITS) - 1);
84   int pt2 = (address >> OFF_BITS) & ((1 << L2_BITS) - 1);
85   int pto = address & ((1 << OFF_BITS) - 1);
86
87   if (address == 0)
88     execution_error (SIM_ERR_NULL_POINTER_DEREFERENCE, 0);
89
90   if (pt[pt1] == 0)
91     {
92       pt[pt1] = (unsigned char **) calloc (L2_LEN, sizeof (char **));
93       ptr[pt1] = (unsigned char **) calloc (L2_LEN, sizeof (char **));
94     }
95   if (pt[pt1][pt2] == 0)
96     {
97       if (action == MPA_READING)
98         execution_error (SIM_ERR_READ_UNWRITTEN_PAGES, address);
99
100       pt[pt1][pt2] = (unsigned char *) malloc (OFF_LEN);
101       memset (pt[pt1][pt2], 0, OFF_LEN);
102       ptr[pt1][pt2] = (unsigned char *) malloc (OFF_LEN);
103       memset (ptr[pt1][pt2], MC_UNINIT, OFF_LEN);
104     }
105   else if (action == MPA_READING
106            && ptr[pt1][pt2][pto] == MC_UNINIT)
107     execution_error (SIM_ERR_READ_UNWRITTEN_BYTES, address);
108
109   if (action == MPA_WRITING)
110     {
111       if (ptr[pt1][pt2][pto] == MC_PUSHED_PC)
112         execution_error (SIM_ERR_CORRUPT_STACK, address);
113       ptr[pt1][pt2][pto] = MC_DATA;
114     }
115
116   if (action == MPA_CONTENT_TYPE)
117     return ptr[pt1][pt2] + pto;
118
119   return pt[pt1][pt2] + pto;
120 }
121
122 static inline int
123 is_reserved_address (unsigned int address)
124 {
125   return (address >= 0x00020000 && address < 0x00080000)
126     ||   (address >= 0x00100000 && address < 0x01000000)
127     ||   (address >= 0x08000000 && address < 0xff000000);
128 }
129
130 static void
131 used (int rstart, int i, int j)
132 {
133   int rend = i << (L2_BITS + OFF_BITS);
134   rend += j << OFF_BITS;
135   if (rstart == 0xe0000 && rend == 0xe1000)
136     return;
137   printf ("mem:   %08x - %08x (%dk bytes)\n", rstart, rend - 1,
138           (rend - rstart) / 1024);
139 }
140
141 static char *
142 mcs (int isput, int bytes)
143 {
144   return comma (mem_counters[isput][bytes]);
145 }
146
147 void
148 mem_usage_stats ()
149 {
150   int i, j;
151   int rstart = 0;
152   int pending = 0;
153
154   for (i = 0; i < L1_LEN; i++)
155     if (pt[i])
156       {
157         for (j = 0; j < L2_LEN; j++)
158           if (pt[i][j])
159             {
160               if (!pending)
161                 {
162                   pending = 1;
163                   rstart = (i << (L2_BITS + OFF_BITS)) + (j << OFF_BITS);
164                 }
165             }
166           else if (pending)
167             {
168               pending = 0;
169               used (rstart, i, j);
170             }
171       }
172     else
173       {
174         if (pending)
175           {
176             pending = 0;
177             used (rstart, i, 0);
178           }
179       }
180   /*       mem foo: 123456789012 123456789012 123456789012 123456789012
181             123456789012 */
182   printf ("                 byte        short        3byte         long"
183           "       opcode\n");
184   if (verbose > 1)
185     {
186       /* Only use comma separated numbers when being very verbose.
187          Comma separated numbers are hard to parse in awk scripts.  */
188       printf ("mem get: %12s %12s %12s %12s %12s\n", mcs (0, 1), mcs (0, 2),
189               mcs (0, 3), mcs (0, 4), mcs (0, 0));
190       printf ("mem put: %12s %12s %12s %12s\n", mcs (1, 1), mcs (1, 2),
191               mcs (1, 3), mcs (1, 4));
192     }
193   else
194     {
195       printf ("mem get: %12u %12u %12u %12u %12u\n",
196               mem_counters[0][1], mem_counters[0][2],
197               mem_counters[0][3], mem_counters[0][4],
198               mem_counters[0][0]);
199       printf ("mem put: %12u %12u %12u %12u\n",
200               mem_counters [1][1], mem_counters [1][2],
201               mem_counters [1][3], mem_counters [1][4]);
202     }
203 }
204
205 unsigned long
206 mem_usage_cycles (void)
207 {
208   unsigned long rv = mem_counters[0][0];
209   rv += mem_counters[0][1] * 1;
210   rv += mem_counters[0][2] * 2;
211   rv += mem_counters[0][3] * 3;
212   rv += mem_counters[0][4] * 4;
213   rv += mem_counters[1][1] * 1;
214   rv += mem_counters[1][2] * 2;
215   rv += mem_counters[1][3] * 3;
216   rv += mem_counters[1][4] * 4;
217   return rv;
218 }
219
220 static int tpr = 0;
221 static void
222 s (int address, char *dir)
223 {
224   if (tpr == 0)
225     printf ("MEM[%08x] %s", address, dir);
226   tpr++;
227 }
228
229 #define S(d) if (trace) s(address, d)
230 static void
231 e ()
232 {
233   if (!trace)
234     return;
235   tpr--;
236   if (tpr == 0)
237     printf ("\n");
238 }
239
240 static char
241 mtypec (int address)
242 {
243   unsigned char *cp = mem_ptr (address, MPA_CONTENT_TYPE);
244   return "udp"[*cp];
245 }
246
247 #define E() if (trace) e()
248
249 void
250 mem_put_byte (unsigned int address, unsigned char value)
251 {
252   unsigned char *m;
253   char tc = ' ';
254
255   if (trace)
256     tc = mtypec (address);
257   m = mem_ptr (address, MPA_WRITING);
258   if (trace)
259     printf (" %02x%c", value, tc);
260   *m = value;
261   switch (address)
262     {
263     case 0x00e1:
264       {
265         static int old_led = -1;
266         static char *led_on[] =
267           { "\033[31m O ", "\033[32m O ", "\033[34m O " };
268         static char *led_off[] = { "\033[0m Â· ", "\033[0m Â· ", "\033[0m Â· " };
269         int i;
270         if (old_led != value)
271           {
272             fputs ("  ", stdout);
273             for (i = 0; i < 3; i++)
274               if (value & (1 << i))
275                 fputs (led_off[i], stdout);
276               else
277                 fputs (led_on[i], stdout);
278             fputs ("\033[0m\r", stdout);
279             fflush (stdout);
280             old_led = value;
281           }
282       }
283       break;
284
285     case 0x3aa: /* uart1tx */
286       {
287         static int pending_exit = 0;
288         if (value == 0)
289           {
290             if (pending_exit)
291               {
292                 step_result = RX_MAKE_EXITED(value);
293                 return;
294               }
295             pending_exit = 1;
296           }
297         else
298           putchar(value);
299       }
300       break;
301
302     default:
303       if (is_reserved_address (address))
304         generate_access_exception ();
305     }
306 }
307
308 void
309 mem_put_qi (int address, unsigned char value)
310 {
311   S ("<=");
312   mem_put_byte (address, value & 0xff);
313   E ();
314   COUNT (1, 1);
315 }
316
317 void
318 mem_put_hi (int address, unsigned short value)
319 {
320   S ("<=");
321   if (rx_big_endian)
322     {
323       mem_put_byte (address, value >> 8);
324       mem_put_byte (address + 1, value & 0xff);
325     }
326   else
327     {
328       mem_put_byte (address, value & 0xff);
329       mem_put_byte (address + 1, value >> 8);
330     }
331   E ();
332   COUNT (1, 2);
333 }
334
335 void
336 mem_put_psi (int address, unsigned long value)
337 {
338   S ("<=");
339   if (rx_big_endian)
340     {
341       mem_put_byte (address, value >> 16);
342       mem_put_byte (address + 1, (value >> 8) & 0xff);
343       mem_put_byte (address + 2, value & 0xff);
344     }
345   else
346     {
347       mem_put_byte (address, value & 0xff);
348       mem_put_byte (address + 1, (value >> 8) & 0xff);
349       mem_put_byte (address + 2, value >> 16);
350     }
351   E ();
352   COUNT (1, 3);
353 }
354
355 void
356 mem_put_si (int address, unsigned long value)
357 {
358   S ("<=");
359   if (rx_big_endian)
360     {
361       mem_put_byte (address + 0, (value >> 24) & 0xff);
362       mem_put_byte (address + 1, (value >> 16) & 0xff);
363       mem_put_byte (address + 2, (value >> 8) & 0xff);
364       mem_put_byte (address + 3, value & 0xff);
365     }
366   else
367     {
368       mem_put_byte (address + 0, value & 0xff);
369       mem_put_byte (address + 1, (value >> 8) & 0xff);
370       mem_put_byte (address + 2, (value >> 16) & 0xff);
371       mem_put_byte (address + 3, (value >> 24) & 0xff);
372     }
373   E ();
374   COUNT (1, 4);
375 }
376
377 void
378 mem_put_blk (int address, void *bufptr, int nbytes)
379 {
380   S ("<=");
381   if (enable_counting)
382     mem_counters[1][1] += nbytes;
383   while (nbytes--)
384     mem_put_byte (address++, *(unsigned char *) bufptr++);
385   E ();
386 }
387
388 unsigned char
389 mem_get_pc (int address)
390 {
391   unsigned char *m = mem_ptr (address, MPA_READING);
392   COUNT (0, 0);
393   return *m;
394 }
395
396 static unsigned char
397 mem_get_byte (unsigned int address)
398 {
399   unsigned char *m;
400
401   S ("=>");
402   m = mem_ptr (address, MPA_READING);
403   switch (address)
404     {
405     case 0x3ad: /* uart1c1 */
406       E();
407       return 2; /* transmitter empty */
408       break;
409     default: 
410       if (trace)
411         printf (" %02x%c", *m, mtypec (address));
412       if (is_reserved_address (address))
413         generate_access_exception ();
414       break;
415     }
416   E ();
417   return *m;
418 }
419
420 unsigned char
421 mem_get_qi (int address)
422 {
423   unsigned char rv;
424   S ("=>");
425   rv = mem_get_byte (address);
426   COUNT (0, 1);
427   E ();
428   return rv;
429 }
430
431 unsigned short
432 mem_get_hi (int address)
433 {
434   unsigned short rv;
435   S ("=>");
436   if (rx_big_endian)
437     {
438       rv = mem_get_byte (address) << 8;
439       rv |= mem_get_byte (address + 1);
440     }
441   else
442     {
443       rv = mem_get_byte (address);
444       rv |= mem_get_byte (address + 1) << 8;
445     }
446   COUNT (0, 2);
447   E ();
448   return rv;
449 }
450
451 unsigned long
452 mem_get_psi (int address)
453 {
454   unsigned long rv;
455   S ("=>");
456   if (rx_big_endian)
457     {
458       rv = mem_get_byte (address + 2);
459       rv |= mem_get_byte (address + 1) << 8;
460       rv |= mem_get_byte (address) << 16;
461     }
462   else
463     {
464       rv = mem_get_byte (address);
465       rv |= mem_get_byte (address + 1) << 8;
466       rv |= mem_get_byte (address + 2) << 16;
467     }
468   COUNT (0, 3);
469   E ();
470   return rv;
471 }
472
473 unsigned long
474 mem_get_si (int address)
475 {
476   unsigned long rv;
477   S ("=>");
478   if (rx_big_endian)
479     {
480       rv = mem_get_byte (address + 3);
481       rv |= mem_get_byte (address + 2) << 8;
482       rv |= mem_get_byte (address + 1) << 16;
483       rv |= mem_get_byte (address) << 24;
484     }
485   else
486     {
487       rv = mem_get_byte (address);
488       rv |= mem_get_byte (address + 1) << 8;
489       rv |= mem_get_byte (address + 2) << 16;
490       rv |= mem_get_byte (address + 3) << 24;
491     }
492   COUNT (0, 4);
493   E ();
494   return rv;
495 }
496
497 void
498 mem_get_blk (int address, void *bufptr, int nbytes)
499 {
500   S ("=>");
501   if (enable_counting)
502     mem_counters[0][1] += nbytes;
503   while (nbytes--)
504     *(char *) bufptr++ = mem_get_byte (address++);
505   E ();
506 }
507
508 int
509 sign_ext (int v, int bits)
510 {
511   if (bits < 32)
512     {
513       v &= (1 << bits) - 1;
514       if (v & (1 << (bits - 1)))
515         v -= (1 << bits);
516     }
517   return v;
518 }
519
520 void
521 mem_set_content_type (int address, enum mem_content_type type)
522 {
523   unsigned char *mt = mem_ptr (address, MPA_CONTENT_TYPE);
524   *mt = type;
525 }
526
527 void
528 mem_set_content_range (int start_address, int end_address, enum mem_content_type type)
529 {
530   while (start_address < end_address)
531     {
532       int sz, ofs;
533       unsigned char *mt;
534
535       sz = end_address - start_address;
536       ofs = start_address % L1_LEN;
537       if (sz + ofs > L1_LEN)
538         sz = L1_LEN - ofs;
539
540       mt = mem_ptr (start_address, MPA_CONTENT_TYPE);
541       memset (mt, type, sz);
542
543       start_address += sz;
544     }
545 }
546
547 enum mem_content_type
548 mem_get_content_type (int address)
549 {
550   unsigned char *mt = mem_ptr (address, MPA_CONTENT_TYPE);
551   return *mt;
552 }