1 /* reg.c --- register set model for RX simulator.
2
3 Copyright (C) 2005-2020 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 "config.h"
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "cpu.h"
28 #include "bfd.h"
29 #include "trace.h"
30
31 int verbose = 0;
32 int trace = 0;
33 int enable_counting = 0;
34
35 int rx_in_gdb = 1;
36
37 int rx_flagmask;
38 int rx_flagand;
39 int rx_flagor;
40
41 int rx_big_endian;
42 regs_type regs;
43 int step_result;
44 unsigned int heapbottom = 0;
45 unsigned int heaptop = 0;
46
47 char *reg_names[] = {
48 /* general registers */
49 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
50 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
51 /* control register */
52 "psw", "pc", "usp", "fpsw", "RES", "RES", "RES", "RES",
53 "bpsw", "bpc", "isp", "fintv", "intb", "RES", "RES", "RES",
54 "RES", "RES", "RES", "RES", "RES", "RES", "RES", "RES",
55 "RES", "RES", "RES", "RES", "RES", "RES", "RES", "RES",
56 "temp", "acc", "acchi", "accmi", "acclo"
57 };
58
59 unsigned int b2mask[] = { 0, 0xff, 0xffff, 0xffffff, 0xffffffff };
60 unsigned int b2signbit[] = { 0, (1 << 7), (1 << 15), (1 << 24), (1 << 31) };
61 int b2maxsigned[] = { 0, 0x7f, 0x7fff, 0x7fffff, 0x7fffffff };
62 int b2minsigned[] = { 0, -128, -32768, -8388608, -2147483647 - 1 };
63
64 static regs_type oldregs;
65
66 void
init_regs(void)67 init_regs (void)
68 {
69 memset (®s, 0, sizeof (regs));
70 memset (&oldregs, 0, sizeof (oldregs));
71
72 #ifdef CYCLE_ACCURATE
73 regs.rt = -1;
74 oldregs.rt = -1;
75 #endif
76 }
77
78 static unsigned int
get_reg_i(int id)79 get_reg_i (int id)
80 {
81 if (id == 0)
82 return regs.r_psw & FLAGBIT_U ? regs.r_usp : regs.r_isp;
83
84 if (id >= 1 && id <= 15)
85 return regs.r[id];
86
87 switch (id)
88 {
89 case psw:
90 return regs.r_psw;
91 case fpsw:
92 return regs.r_fpsw;
93 case isp:
94 return regs.r_isp;
95 case usp:
96 return regs.r_usp;
97 case bpc:
98 return regs.r_bpc;
99 case bpsw:
100 return regs.r_bpsw;
101 case fintv:
102 return regs.r_fintv;
103 case intb:
104 return regs.r_intb;
105 case pc:
106 return regs.r_pc;
107 case r_temp_idx:
108 return regs.r_temp;
109 case acchi:
110 return (SI)(regs.r_acc >> 32);
111 case accmi:
112 return (SI)(regs.r_acc >> 16);
113 case acclo:
114 return (SI)regs.r_acc;
115 }
116 abort();
117 }
118
119 unsigned int
get_reg(int id)120 get_reg (int id)
121 {
122 unsigned int rv = get_reg_i (id);
123 if (trace > ((id != pc && id != sp) ? 0 : 1))
124 printf ("get_reg (%s) = %08x\n", reg_names[id], rv);
125 return rv;
126 }
127
128 static unsigned long long
get_reg64_i(int id)129 get_reg64_i (int id)
130 {
131 switch (id)
132 {
133 case acc64:
134 return regs.r_acc;
135 default:
136 abort ();
137 }
138 }
139
140 unsigned long long
get_reg64(int id)141 get_reg64 (int id)
142 {
143 unsigned long long rv = get_reg64_i (id);
144 if (trace > ((id != pc && id != sp) ? 0 : 1))
145 printf ("get_reg (%s) = %016llx\n", reg_names[id], rv);
146 return rv;
147 }
148
149 static int highest_sp = 0, lowest_sp = 0xffffff;
150
151 void
stack_heap_stats()152 stack_heap_stats ()
153 {
154 if (heapbottom < heaptop)
155 printf ("heap: %08x - %08x (%d bytes)\n", heapbottom, heaptop,
156 heaptop - heapbottom);
157 if (lowest_sp < highest_sp)
158 printf ("stack: %08x - %08x (%d bytes)\n", lowest_sp, highest_sp,
159 highest_sp - lowest_sp);
160 }
161
162 void
put_reg(int id,unsigned int v)163 put_reg (int id, unsigned int v)
164 {
165 if (trace > ((id != pc) ? 0 : 1))
166 printf ("put_reg (%s) = %08x\n", reg_names[id], v);
167
168
169 switch (id)
170 {
171 case psw:
172 regs.r_psw = v;
173 break;
174 case fpsw:
175 {
176 SI anded;
177 /* This is an odd one - The Cx flags are AND'd, and the FS flag
178 is synthetic. */
179 anded = regs.r_fpsw & v;
180 anded |= ~ FPSWBITS_CMASK;
181 regs.r_fpsw = v & anded;
182 if (regs.r_fpsw & FPSWBITS_FMASK)
183 regs.r_fpsw |= FPSWBITS_FSUM;
184 else
185 regs.r_fpsw &= ~FPSWBITS_FSUM;
186 }
187 break;
188 case isp:
189 regs.r_isp = v;
190 break;
191 case usp:
192 regs.r_usp = v;
193 break;
194 case bpc:
195 regs.r_bpc = v;
196 break;
197 case bpsw:
198 regs.r_bpsw = v;
199 break;
200 case fintv:
201 regs.r_fintv = v;
202 break;
203 case intb:
204 regs.r_intb = v;
205 break;
206 case pc:
207 regs.r_pc = v;
208 break;
209
210 case acchi:
211 regs.r_acc = (regs.r_acc & 0xffffffffULL) | ((DI)v << 32);
212 break;
213 case accmi:
214 regs.r_acc = (regs.r_acc & ~0xffffffff0000ULL) | ((DI)v << 16);
215 break;
216 case acclo:
217 regs.r_acc = (regs.r_acc & ~0xffffffffULL) | ((DI)v);
218 break;
219
220 case 0: /* Stack pointer is "in" R0. */
221 {
222 if (v < heaptop)
223 {
224 unsigned int line;
225 const char * dummy;
226 const char * fname = NULL;
227
228 sim_get_current_source_location (& dummy, & fname, &line);
229
230 /* The setjmp and longjmp functions play tricks with the stack pointer. */
231 if (fname == NULL
232 || (strcmp (fname, "_setjmp") != 0
233 && strcmp (fname, "_longjmp") != 0))
234 {
235 printf ("collision in %s: pc %08x heap %08x stack %08x\n",
236 fname, (unsigned int) regs.r_pc, heaptop, v);
237 exit (1);
238 }
239 }
240 else
241 {
242 if (v < lowest_sp)
243 lowest_sp = v;
244 if (v > highest_sp)
245 highest_sp = v;
246 }
247
248 if (regs.r_psw & FLAGBIT_U)
249 regs.r_usp = v;
250 else
251 regs.r_isp = v;
252 break;
253 }
254
255 default:
256 if (id >= 1 && id <= 15)
257 regs.r[id] = v;
258 else
259 abort ();
260 }
261 }
262
263 void
put_reg64(int id,unsigned long long v)264 put_reg64 (int id, unsigned long long v)
265 {
266 if (trace > ((id != pc) ? 0 : 1))
267 printf ("put_reg (%s) = %016llx\n", reg_names[id], v);
268
269 switch (id)
270 {
271 case acc64:
272 regs.r_acc = v;
273 break;
274 default:
275 abort ();
276 }
277 }
278
279 int
condition_true(int cond_id)280 condition_true (int cond_id)
281 {
282 int f;
283
284 static const char *cond_name[] = {
285 "Z",
286 "!Z",
287 "C",
288 "!C",
289 "C&!Z",
290 "!(C&!Z)",
291 "!S",
292 "S",
293 "!(S^O)",
294 "S^O",
295 "!((S^O)|Z)",
296 "(S^O)|Z",
297 "O",
298 "!O",
299 "always",
300 "never"
301 };
302 switch (cond_id & 15)
303 {
304 case 0:
305 f = FLAG_Z;
306 break; /* EQ/Z */
307 case 1:
308 f = !FLAG_Z;
309 break; /* NE/NZ */
310 case 2:
311 f = FLAG_C;
312 break; /* GEU/C */
313 case 3:
314 f = !FLAG_C;
315 break; /* LTU/NC */
316 case 4:
317 f = FLAG_C & !FLAG_Z;
318 break; /* GTU */
319 case 5:
320 f = !(FLAG_C & !FLAG_Z);
321 break; /* LEU */
322 case 6:
323 f = !FLAG_S;
324 break; /* PZ */
325 case 7:
326 f = FLAG_S;
327 break; /* N */
328
329 case 8:
330 f = !(FLAG_S ^ FLAG_O);
331 break; /* GE */
332 case 9:
333 f = FLAG_S ^ FLAG_O;
334 break; /* LT */
335 case 10:
336 f = !((FLAG_S ^ FLAG_O) | FLAG_Z);
337 break; /* GT */
338 case 11:
339 f = (FLAG_S ^ FLAG_O) | FLAG_Z;
340 break; /* LE */
341 case 12:
342 f = FLAG_O;
343 break; /* O */
344 case 13:
345 f = !FLAG_O;
346 break; /* NO */
347 case 14:
348 f = 1; /* always */
349 break;
350 default:
351 f = 0; /* never */
352 break;
353 }
354 if (trace && ((cond_id & 15) != 14))
355 printf ("cond[%d] %s = %s\n", cond_id, cond_name[cond_id & 15],
356 f ? "true" : "false");
357 return f;
358 }
359
360 void
set_flags(int mask,int newbits)361 set_flags (int mask, int newbits)
362 {
363 regs.r_psw &= rx_flagand;
364 regs.r_psw |= rx_flagor;
365 regs.r_psw |= (newbits & mask & rx_flagmask);
366
367 if (trace)
368 {
369 int i;
370 printf ("flags now \033[32m %d", (int)((regs.r_psw >> 24) & 7));
371 for (i = 17; i >= 0; i--)
372 if (0x3000f & (1 << i))
373 {
374 if (regs.r_psw & (1 << i))
375 putchar ("CZSO------------IU"[i]);
376 else
377 putchar ('-');
378 }
379 printf ("\033[0m\n");
380 }
381 }
382
383 void
set_oszc(long long value,int b,int c)384 set_oszc (long long value, int b, int c)
385 {
386 unsigned int mask = b2mask[b];
387 int f = 0;
388
389 if (c)
390 f |= FLAGBIT_C;
391 if ((value & mask) == 0)
392 f |= FLAGBIT_Z;
393 if (value & b2signbit[b])
394 f |= FLAGBIT_S;
395 if ((value > b2maxsigned[b]) || (value < b2minsigned[b]))
396 f |= FLAGBIT_O;
397 set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O | FLAGBIT_C, f);
398 }
399
400 void
set_szc(long long value,int b,int c)401 set_szc (long long value, int b, int c)
402 {
403 unsigned int mask = b2mask[b];
404 int f = 0;
405
406 if (c)
407 f |= FLAGBIT_C;
408 if ((value & mask) == 0)
409 f |= FLAGBIT_Z;
410 if (value & b2signbit[b])
411 f |= FLAGBIT_S;
412 set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_C, f);
413 }
414
415 void
set_osz(long long value,int b)416 set_osz (long long value, int b)
417 {
418 unsigned int mask = b2mask[b];
419 int f = 0;
420
421 if ((value & mask) == 0)
422 f |= FLAGBIT_Z;
423 if (value & b2signbit[b])
424 f |= FLAGBIT_S;
425 if ((value > b2maxsigned[b]) || (value < b2minsigned[b]))
426 f |= FLAGBIT_O;
427 set_flags (FLAGBIT_Z | FLAGBIT_S | FLAGBIT_O, f);
428 }
429
430 void
set_sz(long long value,int b)431 set_sz (long long value, int b)
432 {
433 unsigned int mask = b2mask[b];
434 int f = 0;
435
436 if ((value & mask) == 0)
437 f |= FLAGBIT_Z;
438 if (value & b2signbit[b])
439 f |= FLAGBIT_S;
440 set_flags (FLAGBIT_Z | FLAGBIT_S, f);
441 }
442
443 void
set_zc(int z,int c)444 set_zc (int z, int c)
445 {
446 set_flags (FLAGBIT_C | FLAGBIT_Z,
447 (c ? FLAGBIT_C : 0) | (z ? FLAGBIT_Z : 0));
448 }
449
450 void
set_c(int c)451 set_c (int c)
452 {
453 set_flags (FLAGBIT_C, c ? FLAGBIT_C : 0);
454 }
455
456 static char *
psw2str(int rpsw)457 psw2str(int rpsw)
458 {
459 static char buf[10];
460 char *bp = buf;
461 int i, ipl;
462
463 ipl = (rpsw & FLAGBITS_IPL) >> FLAGSHIFT_IPL;
464 if (ipl > 9)
465 {
466 *bp++ = (ipl / 10) + '0';
467 ipl %= 10;
468 }
469 *bp++ = ipl + '0';
470 for (i = 20; i >= 0; i--)
471 if (0x13000f & (1 << i))
472 {
473 if (rpsw & (1 << i))
474 *bp++ = "CZSO------------IU--P"[i];
475 else
476 *bp++ = '-';
477 }
478 *bp = 0;
479 return buf;
480 }
481
482 static char *
fpsw2str(int rpsw)483 fpsw2str(int rpsw)
484 {
485 static char buf[100];
486 char *bp = buf;
487 int i; /* ---+---+---+---+---+---+---+---+ */
488 const char s1[] = "FFFFFF-----------EEEEE-DCCCCCCRR";
489 const char s2[] = "SXUZOV-----------XUZOV-NEXUZOV01";
490 const char rm[4][3] = { "RC", "RZ", "RP", "RN" };
491
492 for (i = 31; i >= 0; i--)
493 if (0xfc007dfc & (1 << i))
494 {
495 if (rpsw & (1 << i))
496 {
497 if (bp > buf)
498 *bp++ = '.';
499 *bp++ = s1[31-i];
500 *bp++ = s2[31-i];
501 }
502 }
503 if (bp > buf)
504 *bp++ = '.';
505 strcpy (bp, rm[rpsw&3]);
506 return buf;
507 }
508
509 #define TRC(f,n) \
510 if (oldregs.f != regs.f) \
511 { \
512 if (tag) { printf (tag); tag = 0; } \
513 printf(" %s %08x:%08x", n, \
514 (unsigned int)oldregs.f, \
515 (unsigned int)regs.f); \
516 oldregs.f = regs.f; \
517 }
518
519 void
trace_register_changes(void)520 trace_register_changes (void)
521 {
522 char *tag = "\033[36mREGS:";
523 int i;
524
525 if (!trace)
526 return;
527 for (i=1; i<16; i++)
528 TRC (r[i], reg_names[i]);
529 TRC (r_intb, "intb");
530 TRC (r_usp, "usp");
531 TRC (r_isp, "isp");
532 if (oldregs.r_psw != regs.r_psw)
533 {
534 if (tag) { printf (tag); tag = 0; }
535 printf(" psw %s:", psw2str(oldregs.r_psw));
536 printf("%s", psw2str(regs.r_psw));
537 oldregs.r_psw = regs.r_psw;
538 }
539
540 if (oldregs.r_fpsw != regs.r_fpsw)
541 {
542 if (tag) { printf (tag); tag = 0; }
543 printf(" fpsw %s:", fpsw2str(oldregs.r_fpsw));
544 printf("%s", fpsw2str(regs.r_fpsw));
545 oldregs.r_fpsw = regs.r_fpsw;
546 }
547
548 if (oldregs.r_acc != regs.r_acc)
549 {
550 if (tag) { printf (tag); tag = 0; }
551 printf(" acc %016llx:", oldregs.r_acc);
552 printf("%016llx", regs.r_acc);
553 oldregs.r_acc = regs.r_acc;
554 }
555
556 if (tag == 0)
557 printf ("\033[0m\n");
558 }
559