projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gdb: add target_ops::supports_displaced_step
[deliverable/binutils-gdb.git] / sim / mips / interp.c
1 /*> interp.c <*/
2 /* Simulator for the MIPS architecture.
3
4 This file is part of the MIPS sim
5
6 THIS SOFTWARE IS NOT COPYRIGHTED
7
8 Cygnus offers the following for use in the public domain. Cygnus
9 makes no warranty with regard to the software or it's performance
10 and the user accepts the software "AS IS" with all faults.
11
12 CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
13 THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
14 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
15
16 NOTEs:
17
18 The IDT monitor (found on the VR4300 board), seems to lie about
19 register contents. It seems to treat the registers as sign-extended
20 32-bit values. This cause *REAL* problems when single-stepping 64-bit
21 code on the hardware.
22
23 */
24
25 #include "config.h"
26 #include "bfd.h"
27 #include "sim-main.h"
28 #include "sim-utils.h"
29 #include "sim-options.h"
30 #include "sim-assert.h"
31 #include "sim-hw.h"
32
33 #include "itable.h"
34
35
36 #include "config.h"
37
38 #include <stdio.h>
39 #include <stdarg.h>
40 #include <ansidecl.h>
41 #include <ctype.h>
42 #include <limits.h>
43 #include <math.h>
44 #ifdef HAVE_STDLIB_H
45 #include <stdlib.h>
46 #endif
47 #ifdef HAVE_STRING_H
48 #include <string.h>
49 #else
50 #ifdef HAVE_STRINGS_H
51 #include <strings.h>
52 #endif
53 #endif
54
55 #include "getopt.h"
56 #include "libiberty.h"
57 #include "bfd.h"
58 #include "elf-bfd.h"
59 #include "gdb/callback.h" /* GDB simulator callback interface */
60 #include "gdb/remote-sim.h" /* GDB simulator interface */
61
62 char* pr_addr (SIM_ADDR addr);
63 char* pr_uword64 (uword64 addr);
64
65
66 /* Within interp.c we refer to the sim_state and sim_cpu directly. */
67 #define CPU cpu
68 #define SD sd
69
70
71 /* The following reserved instruction value is used when a simulator
72 trap is required. NOTE: Care must be taken, since this value may be
73 used in later revisions of the MIPS ISA. */
74
75 #define RSVD_INSTRUCTION (0x00000039)
76 #define RSVD_INSTRUCTION_MASK (0xFC00003F)
77
78 #define RSVD_INSTRUCTION_ARG_SHIFT 6
79 #define RSVD_INSTRUCTION_ARG_MASK 0xFFFFF
80
81
82 /* Bits in the Debug register */
83 #define Debug_DBD 0x80000000 /* Debug Branch Delay */
84 #define Debug_DM 0x40000000 /* Debug Mode */
85 #define Debug_DBp 0x00000002 /* Debug Breakpoint indicator */
86
87 /*---------------------------------------------------------------------------*/
88 /*-- GDB simulator interface ------------------------------------------------*/
89 /*---------------------------------------------------------------------------*/
90
91 static void ColdReset (SIM_DESC sd);
92
93 /*---------------------------------------------------------------------------*/
94
95
96
97 #define DELAYSLOT() {\
98 if (STATE & simDELAYSLOT)\
99 sim_io_eprintf(sd,"Delay slot already activated (branch in delay slot?)\n");\
100 STATE |= simDELAYSLOT;\
101 }
102
103 #define JALDELAYSLOT() {\
104 DELAYSLOT ();\
105 STATE |= simJALDELAYSLOT;\
106 }
107
108 #define NULLIFY() {\
109 STATE &= ~simDELAYSLOT;\
110 STATE |= simSKIPNEXT;\
111 }
112
113 #define CANCELDELAYSLOT() {\
114 DSSTATE = 0;\
115 STATE &= ~(simDELAYSLOT | simJALDELAYSLOT);\
116 }
117
118 #define INDELAYSLOT() ((STATE & simDELAYSLOT) != 0)
119 #define INJALDELAYSLOT() ((STATE & simJALDELAYSLOT) != 0)
120
121 /* Note that the monitor code essentially assumes this layout of memory.
122 If you change these, change the monitor code, too. */
123 /* FIXME Currently addresses are truncated to 32-bits, see
124 mips/sim-main.c:address_translation(). If that changes, then these
125 values will need to be extended, and tested for more carefully. */
126 #define K0BASE (0x80000000)
127 #define K0SIZE (0x20000000)
128 #define K1BASE (0xA0000000)
129 #define K1SIZE (0x20000000)
130
131 /* Simple run-time monitor support.
132
133 We emulate the monitor by placing magic reserved instructions at
134 the monitor's entry points; when we hit these instructions, instead
135 of raising an exception (as we would normally), we look at the
136 instruction and perform the appropriate monitory operation.
137
138 `*_monitor_base' are the physical addresses at which the corresponding
139 monitor vectors are located. `0' means none. By default,
140 install all three.
141 The RSVD_INSTRUCTION... macros specify the magic instructions we
142 use at the monitor entry points. */
143 static int firmware_option_p = 0;
144 static SIM_ADDR idt_monitor_base = 0xBFC00000;
145 static SIM_ADDR pmon_monitor_base = 0xBFC00500;
146 static SIM_ADDR lsipmon_monitor_base = 0xBFC00200;
147
148 static SIM_RC sim_firmware_command (SIM_DESC sd, char* arg);
149
150 #define MEM_SIZE (8 << 20) /* 8 MBytes */
151
152
153 #if WITH_TRACE_ANY_P
154 static char *tracefile = "trace.din"; /* default filename for trace log */
155 FILE *tracefh = NULL;
156 static void open_trace (SIM_DESC sd);
157 #else
158 #define open_trace(sd)
159 #endif
160
161 static const char * get_insn_name (sim_cpu *, int);
162
163 /* simulation target board. NULL=canonical */
164 static char* board = NULL;
165
166
167 static DECLARE_OPTION_HANDLER (mips_option_handler);
168
169 enum {
170 OPTION_DINERO_TRACE = OPTION_START,
171 OPTION_DINERO_FILE,
172 OPTION_FIRMWARE,
173 OPTION_INFO_MEMORY,
174 OPTION_BOARD
175 };
176
177 static int display_mem_info = 0;
178
179 static SIM_RC
180 mips_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt, char *arg,
181 int is_command)
182 {
183 int cpu_nr;
184 switch (opt)
185 {
186 case OPTION_DINERO_TRACE: /* ??? */
187 #if WITH_TRACE_ANY_P
188 /* Eventually the simTRACE flag could be treated as a toggle, to
189 allow external control of the program points being traced
190 (i.e. only from main onwards, excluding the run-time setup,
191 etc.). */
192 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
193 {
194 sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
195 if (arg == NULL)
196 STATE |= simTRACE;
197 else if (strcmp (arg, "yes") == 0)
198 STATE |= simTRACE;
199 else if (strcmp (arg, "no") == 0)
200 STATE &= ~simTRACE;
201 else if (strcmp (arg, "on") == 0)
202 STATE |= simTRACE;
203 else if (strcmp (arg, "off") == 0)
204 STATE &= ~simTRACE;
205 else
206 {
207 fprintf (stderr, "Unrecognized dinero-trace option `%s'\n", arg);
208 return SIM_RC_FAIL;
209 }
210 }
211 return SIM_RC_OK;
212 #else /* !WITH_TRACE_ANY_P */
213 fprintf(stderr,"\
214 Simulator constructed without dinero tracing support (for performance).\n\
215 Re-compile simulator with \"-DWITH_TRACE_ANY_P\" to enable this option.\n");
216 return SIM_RC_FAIL;
217 #endif /* !WITH_TRACE_ANY_P */
218
219 case OPTION_DINERO_FILE:
220 #if WITH_TRACE_ANY_P
221 if (optarg != NULL) {
222 char *tmp;
223 tmp = (char *)malloc(strlen(optarg) + 1);
224 if (tmp == NULL)
225 {
226 sim_io_printf(sd,"Failed to allocate buffer for tracefile name \"%s\"\n",optarg);
227 return SIM_RC_FAIL;
228 }
229 else {
230 strcpy(tmp,optarg);
231 tracefile = tmp;
232 sim_io_printf(sd,"Placing trace information into file \"%s\"\n",tracefile);
233 }
234 }
235 #endif /* WITH_TRACE_ANY_P */
236 return SIM_RC_OK;
237
238 case OPTION_FIRMWARE:
239 return sim_firmware_command (sd, arg);
240
241 case OPTION_BOARD:
242 {
243 if (arg)
244 {
245 board = zalloc(strlen(arg) + 1);
246 strcpy(board, arg);
247 }
248 return SIM_RC_OK;
249 }
250
251 case OPTION_INFO_MEMORY:
252 display_mem_info = 1;
253 break;
254 }
255
256 return SIM_RC_OK;
257 }
258
259
260 static const OPTION mips_options[] =
261 {
262 { {"dinero-trace", optional_argument, NULL, OPTION_DINERO_TRACE},
263 '\0', "on|off", "Enable dinero tracing",
264 mips_option_handler },
265 { {"dinero-file", required_argument, NULL, OPTION_DINERO_FILE},
266 '\0', "FILE", "Write dinero trace to FILE",
267 mips_option_handler },
268 { {"firmware", required_argument, NULL, OPTION_FIRMWARE},
269 '\0', "[idt|pmon|lsipmon|none][@ADDRESS]", "Emulate ROM monitor",
270 mips_option_handler },
271 { {"board", required_argument, NULL, OPTION_BOARD},
272 '\0', "none" /* rely on compile-time string concatenation for other options */
273
274 #define BOARD_JMR3904 "jmr3904"
275 "|" BOARD_JMR3904
276 #define BOARD_JMR3904_PAL "jmr3904pal"
277 "|" BOARD_JMR3904_PAL
278 #define BOARD_JMR3904_DEBUG "jmr3904debug"
279 "|" BOARD_JMR3904_DEBUG
280 #define BOARD_BSP "bsp"
281 "|" BOARD_BSP
282
283 , "Customize simulation for a particular board.", mips_option_handler },
284
285 /* These next two options have the same names as ones found in the
286 memory_options[] array in common/sim-memopt.c. This is because
287 the intention is to provide an alternative handler for those two
288 options. We need an alternative handler because the memory
289 regions are not set up until after the command line arguments
290 have been parsed, and so we cannot display the memory info whilst
291 processing the command line. There is a hack in sim_open to
292 remove these handlers when we want the real --memory-info option
293 to work. */
294 { { "info-memory", no_argument, NULL, OPTION_INFO_MEMORY },
295 '\0', NULL, "List configured memory regions", mips_option_handler },
296 { { "memory-info", no_argument, NULL, OPTION_INFO_MEMORY },
297 '\0', NULL, NULL, mips_option_handler },
298
299 { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
300 };
301
302
303 int interrupt_pending;
304
305 void
306 interrupt_event (SIM_DESC sd, void *data)
307 {
308 sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
309 address_word cia = CPU_PC_GET (cpu);
310 if (SR & status_IE)
311 {
312 interrupt_pending = 0;
313 SignalExceptionInterrupt (1); /* interrupt "1" */
314 }
315 else if (!interrupt_pending)
316 sim_events_schedule (sd, 1, interrupt_event, data);
317 }
318
319
320 /*---------------------------------------------------------------------------*/
321 /*-- Device registration hook -----------------------------------------------*/
322 /*---------------------------------------------------------------------------*/
323 static void device_init(SIM_DESC sd) {
324 #ifdef DEVICE_INIT
325 extern void register_devices(SIM_DESC);
326 register_devices(sd);
327 #endif
328 }
329
330 /*---------------------------------------------------------------------------*/
331 /*-- GDB simulator interface ------------------------------------------------*/
332 /*---------------------------------------------------------------------------*/
333
334 static sim_cia
335 mips_pc_get (sim_cpu *cpu)
336 {
337 return PC;
338 }
339
340 static void
341 mips_pc_set (sim_cpu *cpu, sim_cia pc)
342 {
343 PC = pc;
344 }
345
346 static int mips_reg_fetch (SIM_CPU *, int, unsigned char *, int);
347 static int mips_reg_store (SIM_CPU *, int, unsigned char *, int);
348
349 SIM_DESC
350 sim_open (SIM_OPEN_KIND kind, host_callback *cb,
351 struct bfd *abfd, char * const *argv)
352 {
353 int i;
354 SIM_DESC sd = sim_state_alloc (kind, cb);
355 sim_cpu *cpu;
356
357 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
358
359 /* The cpu data is kept in a separately allocated chunk of memory. */
360 if (sim_cpu_alloc_all (sd, 1, /*cgen_cpu_max_extra_bytes ()*/0) != SIM_RC_OK)
361 return 0;
362
363 cpu = STATE_CPU (sd, 0); /* FIXME */
364
365 /* FIXME: watchpoints code shouldn't need this */
366 STATE_WATCHPOINTS (sd)->pc = &(PC);
367 STATE_WATCHPOINTS (sd)->sizeof_pc = sizeof (PC);
368 STATE_WATCHPOINTS (sd)->interrupt_handler = interrupt_event;
369
370 /* Initialize the mechanism for doing insn profiling. */
371 CPU_INSN_NAME (cpu) = get_insn_name;
372 CPU_MAX_INSNS (cpu) = nr_itable_entries;
373
374 STATE = 0;
375
376 if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
377 return 0;
378 sim_add_option_table (sd, NULL, mips_options);
379
380
381 /* The parser will print an error message for us, so we silently return. */
382 if (sim_parse_args (sd, argv) != SIM_RC_OK)
383 {
384 /* Uninstall the modules to avoid memory leaks,
385 file descriptor leaks, etc. */
386 sim_module_uninstall (sd);
387 return 0;
388 }
389
390 /* handle board-specific memory maps */
391 if (board == NULL)
392 {
393 /* Allocate core managed memory */
394 sim_memopt *entry, *match = NULL;
395 address_word mem_size = 0;
396 int mapped = 0;
397
398 /* For compatibility with the old code - under this (at level one)
399 are the kernel spaces K0 & K1. Both of these map to a single
400 smaller sub region */
401 sim_do_command(sd," memory region 0x7fff8000,0x8000") ; /* MTZ- 32 k stack */
402
403 /* Look for largest memory region defined on command-line at
404 phys address 0. */
405 for (entry = STATE_MEMOPT (sd); entry != NULL; entry = entry->next)
406 {
407 /* If we find an entry at address 0, then we will end up
408 allocating a new buffer in the "memory alias" command
409 below. The region at address 0 will be deleted. */
410 address_word size = (entry->modulo != 0
411 ? entry->modulo : entry->nr_bytes);
412 if (entry->addr == 0
413 && (!match || entry->level < match->level))
414 match = entry;
415 else if (entry->addr == K0BASE || entry->addr == K1BASE)
416 mapped = 1;
417 else
418 {
419 sim_memopt *alias;
420 for (alias = entry->alias; alias != NULL; alias = alias->next)
421 {
422 if (alias->addr == 0
423 && (!match || entry->level < match->level))
424 match = entry;
425 else if (alias->addr == K0BASE || alias->addr == K1BASE)
426 mapped = 1;
427 }
428 }
429 }
430
431 if (!mapped)
432 {
433 if (match)
434 {
435 /* Get existing memory region size. */
436 mem_size = (match->modulo != 0
437 ? match->modulo : match->nr_bytes);
438 /* Delete old region. */
439 sim_do_commandf (sd, "memory delete %d:0x%lx@%d",
440 match->space, match->addr, match->level);
441 }
442 else if (mem_size == 0)
443 mem_size = MEM_SIZE;
444 /* Limit to KSEG1 size (512MB) */
445 if (mem_size > K1SIZE)
446 mem_size = K1SIZE;
447 /* memory alias K1BASE@1,K1SIZE%MEMSIZE,K0BASE */
448 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx%%0x%lx,0x%0x",
449 K1BASE, K1SIZE, (long)mem_size, K0BASE);
450 }
451
452 device_init(sd);
453 }
454 else if (board != NULL
455 && (strcmp(board, BOARD_BSP) == 0))
456 {
457 int i;
458
459 STATE_ENVIRONMENT (sd) = OPERATING_ENVIRONMENT;
460
461 /* ROM: 0x9FC0_0000 - 0x9FFF_FFFF and 0xBFC0_0000 - 0xBFFF_FFFF */
462 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
463 0x9FC00000,
464 4 * 1024 * 1024, /* 4 MB */
465 0xBFC00000);
466
467 /* SRAM: 0x8000_0000 - 0x803F_FFFF and 0xA000_0000 - 0xA03F_FFFF */
468 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
469 0x80000000,
470 4 * 1024 * 1024, /* 4 MB */
471 0xA0000000);
472
473 /* DRAM: 0x8800_0000 - 0x89FF_FFFF and 0xA800_0000 - 0xA9FF_FFFF */
474 for (i=0; i<8; i++) /* 32 MB total */
475 {
476 unsigned size = 4 * 1024 * 1024; /* 4 MB */
477 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
478 0x88000000 + (i * size),
479 size,
480 0xA8000000 + (i * size));
481 }
482 }
483 #if (WITH_HW)
484 else if (board != NULL
485 && (strcmp(board, BOARD_JMR3904) == 0 ||
486 strcmp(board, BOARD_JMR3904_PAL) == 0 ||
487 strcmp(board, BOARD_JMR3904_DEBUG) == 0))
488 {
489 /* match VIRTUAL memory layout of JMR-TX3904 board */
490 int i;
491
492 /* --- disable monitor unless forced on by user --- */
493
494 if (! firmware_option_p)
495 {
496 idt_monitor_base = 0;
497 pmon_monitor_base = 0;
498 lsipmon_monitor_base = 0;
499 }
500
501 /* --- environment --- */
502
503 STATE_ENVIRONMENT (sd) = OPERATING_ENVIRONMENT;
504
505 /* --- memory --- */
506
507 /* ROM: 0x9FC0_0000 - 0x9FFF_FFFF and 0xBFC0_0000 - 0xBFFF_FFFF */
508 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
509 0x9FC00000,
510 4 * 1024 * 1024, /* 4 MB */
511 0xBFC00000);
512
513 /* SRAM: 0x8000_0000 - 0x803F_FFFF and 0xA000_0000 - 0xA03F_FFFF */
514 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
515 0x80000000,
516 4 * 1024 * 1024, /* 4 MB */
517 0xA0000000);
518
519 /* DRAM: 0x8800_0000 - 0x89FF_FFFF and 0xA800_0000 - 0xA9FF_FFFF */
520 for (i=0; i<8; i++) /* 32 MB total */
521 {
522 unsigned size = 4 * 1024 * 1024; /* 4 MB */
523 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
524 0x88000000 + (i * size),
525 size,
526 0xA8000000 + (i * size));
527 }
528
529 /* Dummy memory regions for unsimulated devices - sorted by address */
530
531 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB1000000, 0x400); /* ISA I/O */
532 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2100000, 0x004); /* ISA ctl */
533 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2500000, 0x004); /* LED/switch */
534 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2700000, 0x004); /* RTC */
535 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB3C00000, 0x004); /* RTC */
536 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFF8000, 0x900); /* DRAMC */
537 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFF9000, 0x200); /* EBIF */
538 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFFE000, 0x01c); /* EBIF */
539 sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFFF500, 0x300); /* PIO */
540
541
542 /* --- simulated devices --- */
543 sim_hw_parse (sd, "/tx3904irc@0xffffc000/reg 0xffffc000 0x20");
544 sim_hw_parse (sd, "/tx3904cpu");
545 sim_hw_parse (sd, "/tx3904tmr@0xfffff000/reg 0xfffff000 0x100");
546 sim_hw_parse (sd, "/tx3904tmr@0xfffff100/reg 0xfffff100 0x100");
547 sim_hw_parse (sd, "/tx3904tmr@0xfffff200/reg 0xfffff200 0x100");
548 sim_hw_parse (sd, "/tx3904sio@0xfffff300/reg 0xfffff300 0x100");
549 {
550 /* FIXME: poking at dv-sockser internals, use tcp backend if
551 --sockser_addr option was given.*/
552 extern char* sockser_addr;
553 if(sockser_addr == NULL)
554 sim_hw_parse (sd, "/tx3904sio@0xfffff300/backend stdio");
555 else
556 sim_hw_parse (sd, "/tx3904sio@0xfffff300/backend tcp");
557 }
558 sim_hw_parse (sd, "/tx3904sio@0xfffff400/reg 0xfffff400 0x100");
559 sim_hw_parse (sd, "/tx3904sio@0xfffff400/backend stdio");
560
561 /* -- device connections --- */
562 sim_hw_parse (sd, "/tx3904irc > ip level /tx3904cpu");
563 sim_hw_parse (sd, "/tx3904tmr@0xfffff000 > int tmr0 /tx3904irc");
564 sim_hw_parse (sd, "/tx3904tmr@0xfffff100 > int tmr1 /tx3904irc");
565 sim_hw_parse (sd, "/tx3904tmr@0xfffff200 > int tmr2 /tx3904irc");
566 sim_hw_parse (sd, "/tx3904sio@0xfffff300 > int sio0 /tx3904irc");
567 sim_hw_parse (sd, "/tx3904sio@0xfffff400 > int sio1 /tx3904irc");
568
569 /* add PAL timer & I/O module */
570 if(! strcmp(board, BOARD_JMR3904_PAL))
571 {
572 /* the device */
573 sim_hw_parse (sd, "/pal@0xffff0000");
574 sim_hw_parse (sd, "/pal@0xffff0000/reg 0xffff0000 64");
575
576 /* wire up interrupt ports to irc */
577 sim_hw_parse (sd, "/pal@0x31000000 > countdown tmr0 /tx3904irc");
578 sim_hw_parse (sd, "/pal@0x31000000 > timer tmr1 /tx3904irc");
579 sim_hw_parse (sd, "/pal@0x31000000 > int int0 /tx3904irc");
580 }
581
582 if(! strcmp(board, BOARD_JMR3904_DEBUG))
583 {
584 /* -- DEBUG: glue interrupt generators --- */
585 sim_hw_parse (sd, "/glue@0xffff0000/reg 0xffff0000 0x50");
586 sim_hw_parse (sd, "/glue@0xffff0000 > int0 int0 /tx3904irc");
587 sim_hw_parse (sd, "/glue@0xffff0000 > int1 int1 /tx3904irc");
588 sim_hw_parse (sd, "/glue@0xffff0000 > int2 int2 /tx3904irc");
589 sim_hw_parse (sd, "/glue@0xffff0000 > int3 int3 /tx3904irc");
590 sim_hw_parse (sd, "/glue@0xffff0000 > int4 int4 /tx3904irc");
591 sim_hw_parse (sd, "/glue@0xffff0000 > int5 int5 /tx3904irc");
592 sim_hw_parse (sd, "/glue@0xffff0000 > int6 int6 /tx3904irc");
593 sim_hw_parse (sd, "/glue@0xffff0000 > int7 int7 /tx3904irc");
594 sim_hw_parse (sd, "/glue@0xffff0000 > int8 dmac0 /tx3904irc");
595 sim_hw_parse (sd, "/glue@0xffff0000 > int9 dmac1 /tx3904irc");
596 sim_hw_parse (sd, "/glue@0xffff0000 > int10 dmac2 /tx3904irc");
597 sim_hw_parse (sd, "/glue@0xffff0000 > int11 dmac3 /tx3904irc");
598 sim_hw_parse (sd, "/glue@0xffff0000 > int12 sio0 /tx3904irc");
599 sim_hw_parse (sd, "/glue@0xffff0000 > int13 sio1 /tx3904irc");
600 sim_hw_parse (sd, "/glue@0xffff0000 > int14 tmr0 /tx3904irc");
601 sim_hw_parse (sd, "/glue@0xffff0000 > int15 tmr1 /tx3904irc");
602 sim_hw_parse (sd, "/glue@0xffff0000 > int16 tmr2 /tx3904irc");
603 sim_hw_parse (sd, "/glue@0xffff0000 > int17 nmi /tx3904cpu");
604 }
605
606 device_init(sd);
607 }
608 #endif
609
610 if (display_mem_info)
611 {
612 struct option_list * ol;
613 struct option_list * prev;
614
615 /* This is a hack. We want to execute the real --memory-info command
616 line switch which is handled in common/sim-memopts.c, not the
617 override we have defined in this file. So we remove the
618 mips_options array from the state options list. This is safe
619 because we have now processed all of the command line. */
620 for (ol = STATE_OPTIONS (sd), prev = NULL;
621 ol != NULL;
622 prev = ol, ol = ol->next)
623 if (ol->options == mips_options)
624 break;
625
626 SIM_ASSERT (ol != NULL);
627
628 if (prev == NULL)
629 STATE_OPTIONS (sd) = ol->next;
630 else
631 prev->next = ol->next;
632
633 sim_do_commandf (sd, "memory-info");
634 }
635
636 /* check for/establish the a reference program image */
637 if (sim_analyze_program (sd,
638 (STATE_PROG_ARGV (sd) != NULL
639 ? *STATE_PROG_ARGV (sd)
640 : NULL),
641 abfd) != SIM_RC_OK)
642 {
643 sim_module_uninstall (sd);
644 return 0;
645 }
646
647 /* Configure/verify the target byte order and other runtime
648 configuration options */
649 if (sim_config (sd) != SIM_RC_OK)
650 {
651 sim_module_uninstall (sd);
652 return 0;
653 }
654
655 if (sim_post_argv_init (sd) != SIM_RC_OK)
656 {
657 /* Uninstall the modules to avoid memory leaks,
658 file descriptor leaks, etc. */
659 sim_module_uninstall (sd);
660 return 0;
661 }
662
663 /* verify assumptions the simulator made about the host type system.
664 This macro does not return if there is a problem */
665 SIM_ASSERT (sizeof(int) == (4 * sizeof(char)));
666 SIM_ASSERT (sizeof(word64) == (8 * sizeof(char)));
667
668 /* This is NASTY, in that we are assuming the size of specific
669 registers: */
670 {
671 int rn;
672 for (rn = 0; (rn < (LAST_EMBED_REGNUM + 1)); rn++)
673 {
674 if (rn < 32)
675 cpu->register_widths[rn] = WITH_TARGET_WORD_BITSIZE;
676 else if ((rn >= FGR_BASE) && (rn < (FGR_BASE + NR_FGR)))
677 cpu->register_widths[rn] = WITH_TARGET_FLOATING_POINT_BITSIZE;
678 else if ((rn >= 33) && (rn <= 37))
679 cpu->register_widths[rn] = WITH_TARGET_WORD_BITSIZE;
680 else if ((rn == SRIDX)
681 || (rn == FCR0IDX)
682 || (rn == FCR31IDX)
683 || ((rn >= 72) && (rn <= 89)))
684 cpu->register_widths[rn] = 32;
685 else
686 cpu->register_widths[rn] = 0;
687 }
688
689
690 }
691
692 if (STATE & simTRACE)
693 open_trace(sd);
694
695 /*
696 sim_io_eprintf (sd, "idt@%x pmon@%x lsipmon@%x\n",
697 idt_monitor_base,
698 pmon_monitor_base,
699 lsipmon_monitor_base);
700 */
701
702 /* Write the monitor trap address handlers into the monitor (eeprom)
703 address space. This can only be done once the target endianness
704 has been determined. */
705 if (idt_monitor_base != 0)
706 {
707 unsigned loop;
708 unsigned idt_monitor_size = 1 << 11;
709
710 /* the default monitor region */
711 sim_do_commandf (sd, "memory region 0x%x,0x%x",
712 idt_monitor_base, idt_monitor_size);
713
714 /* Entry into the IDT monitor is via fixed address vectors, and
715 not using machine instructions. To avoid clashing with use of
716 the MIPS TRAP system, we place our own (simulator specific)
717 "undefined" instructions into the relevant vector slots. */
718 for (loop = 0; (loop < idt_monitor_size); loop += 4)
719 {
720 address_word vaddr = (idt_monitor_base + loop);
721 unsigned32 insn = (RSVD_INSTRUCTION |
722 (((loop >> 2) & RSVD_INSTRUCTION_ARG_MASK)
723 << RSVD_INSTRUCTION_ARG_SHIFT));
724 H2T (insn);
725 sim_write (sd, vaddr, (unsigned char *)&insn, sizeof (insn));
726 }
727 }
728
729 if ((pmon_monitor_base != 0) || (lsipmon_monitor_base != 0))
730 {
731 /* The PMON monitor uses the same address space, but rather than
732 branching into it the address of a routine is loaded. We can
733 cheat for the moment, and direct the PMON routine to IDT style
734 instructions within the monitor space. This relies on the IDT
735 monitor not using the locations from 0xBFC00500 onwards as its
736 entry points.*/
737 unsigned loop;
738 for (loop = 0; (loop < 24); loop++)
739 {
740 unsigned32 value = ((0x500 - 8) / 8); /* default UNDEFINED reason code */
741 switch (loop)
742 {
743 case 0: /* read */
744 value = 7;
745 break;
746 case 1: /* write */
747 value = 8;
748 break;
749 case 2: /* open */
750 value = 6;
751 break;
752 case 3: /* close */
753 value = 10;
754 break;
755 case 5: /* printf */
756 value = ((0x500 - 16) / 8); /* not an IDT reason code */
757 break;
758 case 8: /* cliexit */
759 value = 17;
760 break;
761 case 11: /* flush_cache */
762 value = 28;
763 break;
764 }
765
766 SIM_ASSERT (idt_monitor_base != 0);
767 value = ((unsigned int) idt_monitor_base + (value * 8));
768 H2T (value);
769
770 if (pmon_monitor_base != 0)
771 {
772 address_word vaddr = (pmon_monitor_base + (loop * 4));
773 sim_write (sd, vaddr, (unsigned char *)&value, sizeof (value));
774 }
775
776 if (lsipmon_monitor_base != 0)
777 {
778 address_word vaddr = (lsipmon_monitor_base + (loop * 4));
779 sim_write (sd, vaddr, (unsigned char *)&value, sizeof (value));
780 }
781 }
782
783 /* Write an abort sequence into the TRAP (common) exception vector
784 addresses. This is to catch code executing a TRAP (et.al.)
785 instruction without installing a trap handler. */
786 if ((idt_monitor_base != 0) ||
787 (pmon_monitor_base != 0) ||
788 (lsipmon_monitor_base != 0))
789 {
790 unsigned32 halt[2] = { 0x2404002f /* addiu r4, r0, 47 */,
791 HALT_INSTRUCTION /* BREAK */ };
792 H2T (halt[0]);
793 H2T (halt[1]);
794 sim_write (sd, 0x80000000, (unsigned char *) halt, sizeof (halt));
795 sim_write (sd, 0x80000180, (unsigned char *) halt, sizeof (halt));
796 sim_write (sd, 0x80000200, (unsigned char *) halt, sizeof (halt));
797 /* XXX: Write here unconditionally? */
798 sim_write (sd, 0xBFC00200, (unsigned char *) halt, sizeof (halt));
799 sim_write (sd, 0xBFC00380, (unsigned char *) halt, sizeof (halt));
800 sim_write (sd, 0xBFC00400, (unsigned char *) halt, sizeof (halt));
801 }
802 }
803
804 /* CPU specific initialization. */
805 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
806 {
807 SIM_CPU *cpu = STATE_CPU (sd, i);
808
809 CPU_REG_FETCH (cpu) = mips_reg_fetch;
810 CPU_REG_STORE (cpu) = mips_reg_store;
811 CPU_PC_FETCH (cpu) = mips_pc_get;
812 CPU_PC_STORE (cpu) = mips_pc_set;
813 }
814
815 return sd;
816 }
817
818 #if WITH_TRACE_ANY_P
819 static void
820 open_trace (SIM_DESC sd)
821 {
822 tracefh = fopen(tracefile,"wb+");
823 if (tracefh == NULL)
824 {
825 sim_io_eprintf(sd,"Failed to create file \"%s\", writing trace information to stderr.\n",tracefile);
826 tracefh = stderr;
827 }
828 }
829 #endif
830
831 /* Return name of an insn, used by insn profiling. */
832 static const char *
833 get_insn_name (sim_cpu *cpu, int i)
834 {
835 return itable[i].name;
836 }
837
838 void
839 mips_sim_close (SIM_DESC sd, int quitting)
840 {
841 #if WITH_TRACE_ANY_P
842 if (tracefh != NULL && tracefh != stderr)
843 fclose(tracefh);
844 tracefh = NULL;
845 #endif
846 }
847
848 static int
849 mips_reg_store (SIM_CPU *cpu, int rn, unsigned char *memory, int length)
850 {
851 /* NOTE: gdb (the client) stores registers in target byte order
852 while the simulator uses host byte order */
853
854 /* Unfortunately this suffers from the same problem as the register
855 numbering one. We need to know what the width of each logical
856 register number is for the architecture being simulated. */
857
858 if (cpu->register_widths[rn] == 0)
859 {
860 sim_io_eprintf (CPU_STATE (cpu), "Invalid register width for %d (register store ignored)\n", rn);
861 return 0;
862 }
863
864 if (rn >= FGR_BASE && rn < FGR_BASE + NR_FGR)
865 {
866 cpu->fpr_state[rn - FGR_BASE] = fmt_uninterpreted;
867 if (cpu->register_widths[rn] == 32)
868 {
869 if (length == 8)
870 {
871 cpu->fgr[rn - FGR_BASE] =
872 (unsigned32) T2H_8 (*(unsigned64*)memory);
873 return 8;
874 }
875 else
876 {
877 cpu->fgr[rn - FGR_BASE] = T2H_4 (*(unsigned32*)memory);
878 return 4;
879 }
880 }
881 else
882 {
883 if (length == 8)
884 {
885 cpu->fgr[rn - FGR_BASE] = T2H_8 (*(unsigned64*)memory);
886 return 8;
887 }
888 else
889 {
890 cpu->fgr[rn - FGR_BASE] = T2H_4 (*(unsigned32*)memory);
891 return 4;
892 }
893 }
894 }
895
896 if (cpu->register_widths[rn] == 32)
897 {
898 if (length == 8)
899 {
900 cpu->registers[rn] =
901 (unsigned32) T2H_8 (*(unsigned64*)memory);
902 return 8;
903 }
904 else
905 {
906 cpu->registers[rn] = T2H_4 (*(unsigned32*)memory);
907 return 4;
908 }
909 }
910 else
911 {
912 if (length == 8)
913 {
914 cpu->registers[rn] = T2H_8 (*(unsigned64*)memory);
915 return 8;
916 }
917 else
918 {
919 cpu->registers[rn] = (signed32) T2H_4(*(unsigned32*)memory);
920 return 4;
921 }
922 }
923
924 return 0;
925 }
926
927 static int
928 mips_reg_fetch (SIM_CPU *cpu, int rn, unsigned char *memory, int length)
929 {
930 /* NOTE: gdb (the client) stores registers in target byte order
931 while the simulator uses host byte order */
932
933 if (cpu->register_widths[rn] == 0)
934 {
935 sim_io_eprintf (CPU_STATE (cpu), "Invalid register width for %d (register fetch ignored)\n", rn);
936 return 0;
937 }
938
939 /* Any floating point register */
940 if (rn >= FGR_BASE && rn < FGR_BASE + NR_FGR)
941 {
942 if (cpu->register_widths[rn] == 32)
943 {
944 if (length == 8)
945 {
946 *(unsigned64*)memory =
947 H2T_8 ((unsigned32) (cpu->fgr[rn - FGR_BASE]));
948 return 8;
949 }
950 else
951 {
952 *(unsigned32*)memory = H2T_4 (cpu->fgr[rn - FGR_BASE]);
953 return 4;
954 }
955 }
956 else
957 {
958 if (length == 8)
959 {
960 *(unsigned64*)memory = H2T_8 (cpu->fgr[rn - FGR_BASE]);
961 return 8;
962 }
963 else
964 {
965 *(unsigned32*)memory = H2T_4 ((unsigned32)(cpu->fgr[rn - FGR_BASE]));
966 return 4;
967 }
968 }
969 }
970
971 if (cpu->register_widths[rn] == 32)
972 {
973 if (length == 8)
974 {
975 *(unsigned64*)memory =
976 H2T_8 ((unsigned32) (cpu->registers[rn]));
977 return 8;
978 }
979 else
980 {
981 *(unsigned32*)memory = H2T_4 ((unsigned32)(cpu->registers[rn]));
982 return 4;
983 }
984 }
985 else
986 {
987 if (length == 8)
988 {
989 *(unsigned64*)memory =
990 H2T_8 ((unsigned64) (cpu->registers[rn]));
991 return 8;
992 }
993 else
994 {
995 *(unsigned32*)memory = H2T_4 ((unsigned32)(cpu->registers[rn]));
996 return 4;
997 }
998 }
999
1000 return 0;
1001 }
1002
1003 SIM_RC
1004 sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
1005 char * const *argv, char * const *env)
1006 {
1007
1008 #ifdef DEBUG
1009 #if 0 /* FIXME: doesn't compile */
1010 printf("DBG: sim_create_inferior entered: start_address = 0x%s\n",
1011 pr_addr(PC));
1012 #endif
1013 #endif /* DEBUG */
1014
1015 ColdReset(sd);
1016
1017 if (abfd != NULL)
1018 {
1019 /* override PC value set by ColdReset () */
1020 int cpu_nr;
1021 for (cpu_nr = 0; cpu_nr < sim_engine_nr_cpus (sd); cpu_nr++)
1022 {
1023 sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
1024 sim_cia pc = bfd_get_start_address (abfd);
1025
1026 /* We need to undo brain-dead bfd behavior where it sign-extends
1027 addresses that are supposed to be unsigned. See the mips bfd
1028 sign_extend_vma setting. We have to check the ELF data itself
1029 in order to handle o32 & n32 ABIs. */
1030 if (abfd->tdata.elf_obj_data->elf_header->e_ident[EI_CLASS] ==
1031 ELFCLASS32)
1032 pc = (unsigned32) pc;
1033
1034 CPU_PC_SET (cpu, pc);
1035 }
1036 }
1037
1038 #if 0 /* def DEBUG */
1039 if (argv || env)
1040 {
1041 /* We should really place the argv slot values into the argument
1042 registers, and onto the stack as required. However, this
1043 assumes that we have a stack defined, which is not
1044 necessarily true at the moment. */
1045 char **cptr;
1046 sim_io_printf(sd,"sim_create_inferior() : passed arguments ignored\n");
1047 for (cptr = argv; (cptr && *cptr); cptr++)
1048 printf("DBG: arg \"%s\"\n",*cptr);
1049 }
1050 #endif /* DEBUG */
1051
1052 return SIM_RC_OK;
1053 }
1054
1055 /*---------------------------------------------------------------------------*/
1056 /*-- Private simulator support interface ------------------------------------*/
1057 /*---------------------------------------------------------------------------*/
1058
1059 /* Read a null terminated string from memory, return in a buffer */
1060 static char *
1061 fetch_str (SIM_DESC sd,
1062 address_word addr)
1063 {
1064 char *buf;
1065 int nr = 0;
1066 unsigned char null;
1067 while (sim_read (sd, addr + nr, &null, 1) == 1 && null != 0)
1068 nr++;
1069 buf = NZALLOC (char, nr + 1);
1070 sim_read (sd, addr, (unsigned char *)buf, nr);
1071 return buf;
1072 }
1073
1074
1075 /* Implements the "sim firmware" command:
1076 sim firmware NAME[@ADDRESS] --- emulate ROM monitor named NAME.
1077 NAME can be idt, pmon, or lsipmon. If omitted, ADDRESS
1078 defaults to the normal address for that monitor.
1079 sim firmware none --- don't emulate any ROM monitor. Useful
1080 if you need a clean address space. */
1081 static SIM_RC
1082 sim_firmware_command (SIM_DESC sd, char *arg)
1083 {
1084 int address_present = 0;
1085 SIM_ADDR address;
1086
1087 /* Signal occurrence of this option. */
1088 firmware_option_p = 1;
1089
1090 /* Parse out the address, if present. */
1091 {
1092 char *p = strchr (arg, '@');
1093 if (p)
1094 {
1095 char *q;
1096 address_present = 1;
1097 p ++; /* skip over @ */
1098
1099 address = strtoul (p, &q, 0);
1100 if (*q != '\0')
1101 {
1102 sim_io_printf (sd, "Invalid address given to the"
1103 "`sim firmware NAME@ADDRESS' command: %s\n",
1104 p);
1105 return SIM_RC_FAIL;
1106 }
1107 }
1108 else
1109 {
1110 address_present = 0;
1111 address = -1; /* Dummy value. */
1112 }
1113 }
1114
1115 if (! strncmp (arg, "idt", 3))
1116 {
1117 idt_monitor_base = address_present ? address : 0xBFC00000;
1118 pmon_monitor_base = 0;
1119 lsipmon_monitor_base = 0;
1120 }
1121 else if (! strncmp (arg, "pmon", 4))
1122 {
1123 /* pmon uses indirect calls. Hook into implied idt. */
1124 pmon_monitor_base = address_present ? address : 0xBFC00500;
1125 idt_monitor_base = pmon_monitor_base - 0x500;
1126 lsipmon_monitor_base = 0;
1127 }
1128 else if (! strncmp (arg, "lsipmon", 7))
1129 {
1130 /* lsipmon uses indirect calls. Hook into implied idt. */
1131 pmon_monitor_base = 0;
1132 lsipmon_monitor_base = address_present ? address : 0xBFC00200;
1133 idt_monitor_base = lsipmon_monitor_base - 0x200;
1134 }
1135 else if (! strncmp (arg, "none", 4))
1136 {
1137 if (address_present)
1138 {
1139 sim_io_printf (sd,
1140 "The `sim firmware none' command does "
1141 "not take an `ADDRESS' argument.\n");
1142 return SIM_RC_FAIL;
1143 }
1144 idt_monitor_base = 0;
1145 pmon_monitor_base = 0;
1146 lsipmon_monitor_base = 0;
1147 }
1148 else
1149 {
1150 sim_io_printf (sd, "\
1151 Unrecognized name given to the `sim firmware NAME' command: %s\n\
1152 Recognized firmware names are: `idt', `pmon', `lsipmon', and `none'.\n",
1153 arg);
1154 return SIM_RC_FAIL;
1155 }
1156
1157 return SIM_RC_OK;
1158 }
1159
1160
1161
1162 /* Simple monitor interface (currently setup for the IDT and PMON monitors) */
1163 int
1164 sim_monitor (SIM_DESC sd,
1165 sim_cpu *cpu,
1166 address_word cia,
1167 unsigned int reason)
1168 {
1169 #ifdef DEBUG
1170 printf("DBG: sim_monitor: entered (reason = %d)\n",reason);
1171 #endif /* DEBUG */
1172
1173 /* The IDT monitor actually allows two instructions per vector
1174 slot. However, the simulator currently causes a trap on each
1175 individual instruction. We cheat, and lose the bottom bit. */
1176 reason >>= 1;
1177
1178 /* The following callback functions are available, however the
1179 monitor we are simulating does not make use of them: get_errno,
1180 isatty, lseek, rename, system, time and unlink */
1181 switch (reason)
1182 {
1183
1184 case 6: /* int open(char *path,int flags) */
1185 {
1186 char *path = fetch_str (sd, A0);
1187 V0 = sim_io_open (sd, path, (int)A1);
1188 free (path);
1189 break;
1190 }
1191
1192 case 7: /* int read(int file,char *ptr,int len) */
1193 {
1194 int fd = A0;
1195 int nr = A2;
1196 char *buf = zalloc (nr);
1197 V0 = sim_io_read (sd, fd, buf, nr);
1198 sim_write (sd, A1, (unsigned char *)buf, nr);
1199 free (buf);
1200 }
1201 break;
1202
1203 case 8: /* int write(int file,char *ptr,int len) */
1204 {
1205 int fd = A0;
1206 int nr = A2;
1207 char *buf = zalloc (nr);
1208 sim_read (sd, A1, (unsigned char *)buf, nr);
1209 V0 = sim_io_write (sd, fd, buf, nr);
1210 if (fd == 1)
1211 sim_io_flush_stdout (sd);
1212 else if (fd == 2)
1213 sim_io_flush_stderr (sd);
1214 free (buf);
1215 break;
1216 }
1217
1218 case 10: /* int close(int file) */
1219 {
1220 V0 = sim_io_close (sd, (int)A0);
1221 break;
1222 }
1223
1224 case 2: /* Densan monitor: char inbyte(int waitflag) */
1225 {
1226 if (A0 == 0) /* waitflag == NOWAIT */
1227 V0 = (unsigned_word)-1;
1228 }
1229 /* Drop through to case 11 */
1230
1231 case 11: /* char inbyte(void) */
1232 {
1233 char tmp;
1234 /* ensure that all output has gone... */
1235 sim_io_flush_stdout (sd);
1236 if (sim_io_read_stdin (sd, &tmp, sizeof(char)) != sizeof(char))
1237 {
1238 sim_io_error(sd,"Invalid return from character read");
1239 V0 = (unsigned_word)-1;
1240 }
1241 else
1242 V0 = (unsigned_word)tmp;
1243 break;
1244 }
1245
1246 case 3: /* Densan monitor: void co(char chr) */
1247 case 12: /* void outbyte(char chr) : write a byte to "stdout" */
1248 {
1249 char tmp = (char)(A0 & 0xFF);
1250 sim_io_write_stdout (sd, &tmp, sizeof(char));
1251 break;
1252 }
1253
1254 case 17: /* void _exit() */
1255 {
1256 sim_io_eprintf (sd, "sim_monitor(17): _exit(int reason) to be coded\n");
1257 sim_engine_halt (SD, CPU, NULL, NULL_CIA, sim_exited,
1258 (unsigned int)(A0 & 0xFFFFFFFF));
1259 break;
1260 }
1261
1262 case 28: /* PMON flush_cache */
1263 break;
1264
1265 case 55: /* void get_mem_info(unsigned int *ptr) */
1266 /* in: A0 = pointer to three word memory location */
1267 /* out: [A0 + 0] = size */
1268 /* [A0 + 4] = instruction cache size */
1269 /* [A0 + 8] = data cache size */
1270 {
1271 unsigned_4 value;
1272 unsigned_4 zero = 0;
1273 address_word mem_size;
1274 sim_memopt *entry, *match = NULL;
1275
1276 /* Search for memory region mapped to KSEG0 or KSEG1. */
1277 for (entry = STATE_MEMOPT (sd);
1278 entry != NULL;
1279 entry = entry->next)
1280 {
1281 if ((entry->addr == K0BASE || entry->addr == K1BASE)
1282 && (!match || entry->level < match->level))
1283 match = entry;
1284 else
1285 {
1286 sim_memopt *alias;
1287 for (alias = entry->alias;
1288 alias != NULL;
1289 alias = alias->next)
1290 if ((alias->addr == K0BASE || alias->addr == K1BASE)
1291 && (!match || entry->level < match->level))
1292 match = entry;
1293 }
1294 }
1295
1296 /* Get region size, limit to KSEG1 size (512MB). */
1297 SIM_ASSERT (match != NULL);
1298 mem_size = (match->modulo != 0
1299 ? match->modulo : match->nr_bytes);
1300 if (mem_size > K1SIZE)
1301 mem_size = K1SIZE;
1302
1303 value = mem_size;
1304 H2T (value);
1305 sim_write (sd, A0 + 0, (unsigned char *)&value, 4);
1306 sim_write (sd, A0 + 4, (unsigned char *)&zero, 4);
1307 sim_write (sd, A0 + 8, (unsigned char *)&zero, 4);
1308 /* sim_io_eprintf (sd, "sim: get_mem_info() deprecated\n"); */
1309 break;
1310 }
1311
1312 case 158: /* PMON printf */
1313 /* in: A0 = pointer to format string */
1314 /* A1 = optional argument 1 */
1315 /* A2 = optional argument 2 */
1316 /* A3 = optional argument 3 */
1317 /* out: void */
1318 /* The following is based on the PMON printf source */
1319 {
1320 address_word s = A0;
1321 unsigned char c;
1322 signed_word *ap = &A1; /* 1st argument */
1323 /* This isn't the quickest way, since we call the host print
1324 routine for every character almost. But it does avoid
1325 having to allocate and manage a temporary string buffer. */
1326 /* TODO: Include check that we only use three arguments (A1,
1327 A2 and A3) */
1328 while (sim_read (sd, s++, &c, 1) && c != '\0')
1329 {
1330 if (c == '%')
1331 {
1332 char tmp[40];
1333 enum {FMT_RJUST, FMT_LJUST, FMT_RJUST0, FMT_CENTER} fmt = FMT_RJUST;
1334 int width = 0, trunc = 0, haddot = 0, longlong = 0;
1335 while (sim_read (sd, s++, &c, 1) && c != '\0')
1336 {
1337 if (strchr ("dobxXulscefg%", c))
1338 break;
1339 else if (c == '-')
1340 fmt = FMT_LJUST;
1341 else if (c == '0')
1342 fmt = FMT_RJUST0;
1343 else if (c == '~')
1344 fmt = FMT_CENTER;
1345 else if (c == '*')
1346 {
1347 if (haddot)
1348 trunc = (int)*ap++;
1349 else
1350 width = (int)*ap++;
1351 }
1352 else if (c >= '1' && c <= '9')
1353 {
1354 address_word t = s;
1355 unsigned int n;
1356 while (sim_read (sd, s++, &c, 1) == 1 && isdigit (c))
1357 tmp[s - t] = c;
1358 tmp[s - t] = '\0';
1359 n = (unsigned int)strtol(tmp,NULL,10);
1360 if (haddot)
1361 trunc = n;
1362 else
1363 width = n;
1364 s--;
1365 }
1366 else if (c == '.')
1367 haddot = 1;
1368 }
1369 switch (c)
1370 {
1371 case '%':
1372 sim_io_printf (sd, "%%");
1373 break;
1374 case 's':
1375 if ((int)*ap != 0)
1376 {
1377 address_word p = *ap++;
1378 unsigned char ch;
1379 while (sim_read (sd, p++, &ch, 1) == 1 && ch != '\0')
1380 sim_io_printf(sd, "%c", ch);
1381 }
1382 else
1383 sim_io_printf(sd,"(null)");
1384 break;
1385 case 'c':
1386 sim_io_printf (sd, "%c", (int)*ap++);
1387 break;
1388 default:
1389 if (c == 'l')
1390 {
1391 sim_read (sd, s++, &c, 1);
1392 if (c == 'l')
1393 {
1394 longlong = 1;
1395 sim_read (sd, s++, &c, 1);
1396 }
1397 }
1398 if (strchr ("dobxXu", c))
1399 {
1400 word64 lv = (word64) *ap++;
1401 if (c == 'b')
1402 sim_io_printf(sd,"<binary not supported>");
1403 else
1404 {
1405 sprintf (tmp, "%%%s%c", longlong ? "ll" : "", c);
1406 if (longlong)
1407 sim_io_printf(sd, tmp, lv);
1408 else
1409 sim_io_printf(sd, tmp, (int)lv);
1410 }
1411 }
1412 else if (strchr ("eEfgG", c))
1413 {
1414 double dbl = *(double*)(ap++);
1415 sprintf (tmp, "%%%d.%d%c", width, trunc, c);
1416 sim_io_printf (sd, tmp, dbl);
1417 trunc = 0;
1418 }
1419 }
1420 }
1421 else
1422 sim_io_printf(sd, "%c", c);
1423 }
1424 break;
1425 }
1426
1427 default:
1428 /* Unknown reason. */
1429 return 0;
1430 }
1431 return 1;
1432 }
1433
1434 /* Store a word into memory. */
1435
1436 static void
1437 store_word (SIM_DESC sd,
1438 sim_cpu *cpu,
1439 address_word cia,
1440 uword64 vaddr,
1441 signed_word val)
1442 {
1443 address_word paddr = vaddr;
1444
1445 if ((vaddr & 3) != 0)
1446 SignalExceptionAddressStore ();
1447 else
1448 {
1449 const uword64 mask = 7;
1450 uword64 memval;
1451 unsigned int byte;
1452
1453 paddr = (paddr & ~mask) | ((paddr & mask) ^ (ReverseEndian << 2));
1454 byte = (vaddr & mask) ^ (BigEndianCPU << 2);
1455 memval = ((uword64) val) << (8 * byte);
1456 StoreMemory (AccessLength_WORD, memval, 0, paddr, vaddr,
1457 isREAL);
1458 }
1459 }
1460
1461 /* Load a word from memory. */
1462
1463 static signed_word
1464 load_word (SIM_DESC sd,
1465 sim_cpu *cpu,
1466 address_word cia,
1467 uword64 vaddr)
1468 {
1469 if ((vaddr & 3) != 0)
1470 {
1471 SIM_CORE_SIGNAL (SD, cpu, cia, read_map, AccessLength_WORD+1, vaddr, read_transfer, sim_core_unaligned_signal);
1472 }
1473 else
1474 {
1475 address_word paddr = vaddr;
1476 const uword64 mask = 0x7;
1477 const unsigned int reverse = ReverseEndian ? 1 : 0;
1478 const unsigned int bigend = BigEndianCPU ? 1 : 0;
1479 uword64 memval;
1480 unsigned int byte;
1481
1482 paddr = (paddr & ~mask) | ((paddr & mask) ^ (reverse << 2));
1483 LoadMemory (&memval, NULL, AccessLength_WORD, paddr, vaddr, isDATA,
1484 isREAL);
1485 byte = (vaddr & mask) ^ (bigend << 2);
1486 return EXTEND32 (memval >> (8 * byte));
1487 }
1488
1489 return 0;
1490 }
1491
1492 /* Simulate the mips16 entry and exit pseudo-instructions. These
1493 would normally be handled by the reserved instruction exception
1494 code, but for ease of simulation we just handle them directly. */
1495
1496 static void
1497 mips16_entry (SIM_DESC sd,
1498 sim_cpu *cpu,
1499 address_word cia,
1500 unsigned int insn)
1501 {
1502 int aregs, sregs, rreg;
1503
1504 #ifdef DEBUG
1505 printf("DBG: mips16_entry: entered (insn = 0x%08X)\n",insn);
1506 #endif /* DEBUG */
1507
1508 aregs = (insn & 0x700) >> 8;
1509 sregs = (insn & 0x0c0) >> 6;
1510 rreg = (insn & 0x020) >> 5;
1511
1512 /* This should be checked by the caller. */
1513 if (sregs == 3)
1514 abort ();
1515
1516 if (aregs < 5)
1517 {
1518 int i;
1519 signed_word tsp;
1520
1521 /* This is the entry pseudo-instruction. */
1522
1523 for (i = 0; i < aregs; i++)
1524 store_word (SD, CPU, cia, (uword64) (SP + 4 * i), GPR[i + 4]);
1525
1526 tsp = SP;
1527 SP -= 32;
1528
1529 if (rreg)
1530 {
1531 tsp -= 4;
1532 store_word (SD, CPU, cia, (uword64) tsp, RA);
1533 }
1534
1535 for (i = 0; i < sregs; i++)
1536 {
1537 tsp -= 4;
1538 store_word (SD, CPU, cia, (uword64) tsp, GPR[16 + i]);
1539 }
1540 }
1541 else
1542 {
1543 int i;
1544 signed_word tsp;
1545
1546 /* This is the exit pseudo-instruction. */
1547
1548 tsp = SP + 32;
1549
1550 if (rreg)
1551 {
1552 tsp -= 4;
1553 RA = load_word (SD, CPU, cia, (uword64) tsp);
1554 }
1555
1556 for (i = 0; i < sregs; i++)
1557 {
1558 tsp -= 4;
1559 GPR[i + 16] = load_word (SD, CPU, cia, (uword64) tsp);
1560 }
1561
1562 SP += 32;
1563
1564 if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
1565 {
1566 if (aregs == 5)
1567 {
1568 FGR[0] = WORD64LO (GPR[4]);
1569 FPR_STATE[0] = fmt_uninterpreted;
1570 }
1571 else if (aregs == 6)
1572 {
1573 FGR[0] = WORD64LO (GPR[5]);
1574 FGR[1] = WORD64LO (GPR[4]);
1575 FPR_STATE[0] = fmt_uninterpreted;
1576 FPR_STATE[1] = fmt_uninterpreted;
1577 }
1578 }
1579
1580 PC = RA;
1581 }
1582
1583 }
1584
1585 /*-- trace support ----------------------------------------------------------*/
1586
1587 /* The trace support is provided (if required) in the memory accessing
1588 routines. Since we are also providing the architecture specific
1589 features, the architecture simulation code can also deal with
1590 notifying the trace world of cache flushes, etc. Similarly we do
1591 not need to provide profiling support in the simulator engine,
1592 since we can sample in the instruction fetch control loop. By
1593 defining the trace manifest, we add tracing as a run-time
1594 option. */
1595
1596 #if WITH_TRACE_ANY_P
1597 /* Tracing by default produces "din" format (as required by
1598 dineroIII). Each line of such a trace file *MUST* have a din label
1599 and address field. The rest of the line is ignored, so comments can
1600 be included if desired. The first field is the label which must be
1601 one of the following values:
1602
1603 0 read data
1604 1 write data
1605 2 instruction fetch
1606 3 escape record (treated as unknown access type)
1607 4 escape record (causes cache flush)
1608
1609 The address field is a 32bit (lower-case) hexadecimal address
1610 value. The address should *NOT* be preceded by "0x".
1611
1612 The size of the memory transfer is not important when dealing with
1613 cache lines (as long as no more than a cache line can be
1614 transferred in a single operation :-), however more information
1615 could be given following the dineroIII requirement to allow more
1616 complete memory and cache simulators to provide better
1617 results. i.e. the University of Pisa has a cache simulator that can
1618 also take bus size and speed as (variable) inputs to calculate
1619 complete system performance (a much more useful ability when trying
1620 to construct an end product, rather than a processor). They
1621 currently have an ARM version of their tool called ChARM. */
1622
1623
1624 void
1625 dotrace (SIM_DESC sd,
1626 sim_cpu *cpu,
1627 FILE *tracefh,
1628 int type,
1629 SIM_ADDR address,
1630 int width,
1631 char *comment,...)
1632 {
1633 if (STATE & simTRACE) {
1634 va_list ap;
1635 fprintf(tracefh,"%d %s ; width %d ; ",
1636 type,
1637 pr_addr(address),
1638 width);
1639 va_start(ap,comment);
1640 vfprintf(tracefh,comment,ap);
1641 va_end(ap);
1642 fprintf(tracefh,"\n");
1643 }
1644 /* NOTE: Since the "din" format will only accept 32bit addresses, and
1645 we may be generating 64bit ones, we should put the hi-32bits of the
1646 address into the comment field. */
1647
1648 /* TODO: Provide a buffer for the trace lines. We can then avoid
1649 performing writes until the buffer is filled, or the file is
1650 being closed. */
1651
1652 /* NOTE: We could consider adding a comment field to the "din" file
1653 produced using type 3 markers (unknown access). This would then
1654 allow information about the program that the "din" is for, and
1655 the MIPs world that was being simulated, to be placed into the
1656 trace file. */
1657
1658 return;
1659 }
1660 #endif /* WITH_TRACE_ANY_P */
1661
1662 /*---------------------------------------------------------------------------*/
1663 /*-- simulator engine -------------------------------------------------------*/
1664 /*---------------------------------------------------------------------------*/
1665
1666 static void
1667 ColdReset (SIM_DESC sd)
1668 {
1669 int cpu_nr;
1670 for (cpu_nr = 0; cpu_nr < sim_engine_nr_cpus (sd); cpu_nr++)
1671 {
1672 sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
1673 /* RESET: Fixed PC address: */
1674 PC = (unsigned_word) UNSIGNED64 (0xFFFFFFFFBFC00000);
1675 /* The reset vector address is in the unmapped, uncached memory space. */
1676
1677 SR &= ~(status_SR | status_TS | status_RP);
1678 SR |= (status_ERL | status_BEV);
1679
1680 /* Cheat and allow access to the complete register set immediately */
1681 if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT
1682 && WITH_TARGET_WORD_BITSIZE == 64)
1683 SR |= status_FR; /* 64bit registers */
1684
1685 /* Ensure that any instructions with pending register updates are
1686 cleared: */
1687 PENDING_INVALIDATE();
1688
1689 /* Initialise the FPU registers to the unknown state */
1690 if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
1691 {
1692 int rn;
1693 for (rn = 0; (rn < 32); rn++)
1694 FPR_STATE[rn] = fmt_uninterpreted;
1695 }
1696
1697 /* Initialise the Config0 register. */
1698 C0_CONFIG = 0x80000000 /* Config1 present */
1699 | 2; /* KSEG0 uncached */
1700 if (WITH_TARGET_WORD_BITSIZE == 64)
1701 {
1702 /* FIXME Currently mips/sim-main.c:address_translation()
1703 truncates all addresses to 32-bits. */
1704 if (0 && WITH_TARGET_ADDRESS_BITSIZE == 64)
1705 C0_CONFIG |= (2 << 13); /* MIPS64, 64-bit addresses */
1706 else
1707 C0_CONFIG |= (1 << 13); /* MIPS64, 32-bit addresses */
1708 }
1709 if (BigEndianMem)
1710 C0_CONFIG |= 0x00008000; /* Big Endian */
1711 }
1712 }
1713
1714
1715
1716
1717 /* Description from page A-26 of the "MIPS IV Instruction Set" manual (revision 3.1) */
1718 /* Signal an exception condition. This will result in an exception
1719 that aborts the instruction. The instruction operation pseudocode
1720 will never see a return from this function call. */
1721
1722 void
1723 signal_exception (SIM_DESC sd,
1724 sim_cpu *cpu,
1725 address_word cia,
1726 int exception,...)
1727 {
1728 /* int vector; */
1729
1730 #ifdef DEBUG
1731 sim_io_printf(sd,"DBG: SignalException(%d) PC = 0x%s\n",exception,pr_addr(cia));
1732 #endif /* DEBUG */
1733
1734 /* Ensure that any active atomic read/modify/write operation will fail: */
1735 LLBIT = 0;
1736
1737 /* Save registers before interrupt dispatching */
1738 #ifdef SIM_CPU_EXCEPTION_TRIGGER
1739 SIM_CPU_EXCEPTION_TRIGGER(sd, cpu, cia);
1740 #endif
1741
1742 switch (exception) {
1743
1744 case DebugBreakPoint:
1745 if (! (Debug & Debug_DM))
1746 {
1747 if (INDELAYSLOT())
1748 {
1749 CANCELDELAYSLOT();
1750
1751 Debug |= Debug_DBD; /* signaled from within in delay slot */
1752 DEPC = cia - 4; /* reference the branch instruction */
1753 }
1754 else
1755 {
1756 Debug &= ~Debug_DBD; /* not signaled from within a delay slot */
1757 DEPC = cia;
1758 }
1759
1760 Debug |= Debug_DM; /* in debugging mode */
1761 Debug |= Debug_DBp; /* raising a DBp exception */
1762 PC = 0xBFC00200;
1763 sim_engine_restart (SD, CPU, NULL, NULL_CIA);
1764 }
1765 break;
1766
1767 case ReservedInstruction:
1768 {
1769 va_list ap;
1770 unsigned int instruction;
1771 va_start(ap,exception);
1772 instruction = va_arg(ap,unsigned int);
1773 va_end(ap);
1774 /* Provide simple monitor support using ReservedInstruction
1775 exceptions. The following code simulates the fixed vector
1776 entry points into the IDT monitor by causing a simulator
1777 trap, performing the monitor operation, and returning to
1778 the address held in the $ra register (standard PCS return
1779 address). This means we only need to pre-load the vector
1780 space with suitable instruction values. For systems were
1781 actual trap instructions are used, we would not need to
1782 perform this magic. */
1783 if ((instruction & RSVD_INSTRUCTION_MASK) == RSVD_INSTRUCTION)
1784 {
1785 int reason = (instruction >> RSVD_INSTRUCTION_ARG_SHIFT) & RSVD_INSTRUCTION_ARG_MASK;
1786 if (!sim_monitor (SD, CPU, cia, reason))
1787 sim_io_error (sd, "sim_monitor: unhandled reason = %d, pc = 0x%s\n", reason, pr_addr (cia));
1788
1789 /* NOTE: This assumes that a branch-and-link style
1790 instruction was used to enter the vector (which is the
1791 case with the current IDT monitor). */
1792 sim_engine_restart (SD, CPU, NULL, RA);
1793 }
1794 /* Look for the mips16 entry and exit instructions, and
1795 simulate a handler for them. */
1796 else if ((cia & 1) != 0
1797 && (instruction & 0xf81f) == 0xe809
1798 && (instruction & 0x0c0) != 0x0c0)
1799 {
1800 mips16_entry (SD, CPU, cia, instruction);
1801 sim_engine_restart (sd, NULL, NULL, NULL_CIA);
1802 }
1803 /* else fall through to normal exception processing */
1804 sim_io_eprintf(sd,"ReservedInstruction at PC = 0x%s\n", pr_addr (cia));
1805 }
1806
1807 default:
1808 /* Store exception code into current exception id variable (used
1809 by exit code): */
1810
1811 /* TODO: If not simulating exceptions then stop the simulator
1812 execution. At the moment we always stop the simulation. */
1813
1814 #ifdef SUBTARGET_R3900
1815 /* update interrupt-related registers */
1816
1817 /* insert exception code in bits 6:2 */
1818 CAUSE = LSMASKED32(CAUSE, 31, 7) | LSINSERTED32(exception, 6, 2);
1819 /* shift IE/KU history bits left */
1820 SR = LSMASKED32(SR, 31, 4) | LSINSERTED32(LSEXTRACTED32(SR, 3, 0), 5, 2);
1821
1822 if (STATE & simDELAYSLOT)
1823 {
1824 STATE &= ~simDELAYSLOT;
1825 CAUSE |= cause_BD;
1826 EPC = (cia - 4); /* reference the branch instruction */
1827 }
1828 else
1829 EPC = cia;
1830
1831 if (SR & status_BEV)
1832 PC = (signed)0xBFC00000 + 0x180;
1833 else
1834 PC = (signed)0x80000000 + 0x080;
1835 #else
1836 /* See figure 5-17 for an outline of the code below */
1837 if (! (SR & status_EXL))
1838 {
1839 CAUSE = (exception << 2);
1840 if (STATE & simDELAYSLOT)
1841 {
1842 STATE &= ~simDELAYSLOT;
1843 CAUSE |= cause_BD;
1844 EPC = (cia - 4); /* reference the branch instruction */
1845 }
1846 else
1847 EPC = cia;
1848 /* FIXME: TLB et.al. */
1849 /* vector = 0x180; */
1850 }
1851 else
1852 {
1853 CAUSE = (exception << 2);
1854 /* vector = 0x180; */
1855 }
1856 SR |= status_EXL;
1857 /* Store exception code into current exception id variable (used
1858 by exit code): */
1859
1860 if (SR & status_BEV)
1861 PC = (signed)0xBFC00200 + 0x180;
1862 else
1863 PC = (signed)0x80000000 + 0x180;
1864 #endif
1865
1866 switch ((CAUSE >> 2) & 0x1F)
1867 {
1868 case Interrupt:
1869 /* Interrupts arrive during event processing, no need to
1870 restart */
1871 return;
1872
1873 case NMIReset:
1874 /* Ditto */
1875 #ifdef SUBTARGET_3900
1876 /* Exception vector: BEV=0 BFC00000 / BEF=1 BFC00000 */
1877 PC = (signed)0xBFC00000;
1878 #endif /* SUBTARGET_3900 */
1879 return;
1880
1881 case TLBModification:
1882 case TLBLoad:
1883 case TLBStore:
1884 case AddressLoad:
1885 case AddressStore:
1886 case InstructionFetch:
1887 case DataReference:
1888 /* The following is so that the simulator will continue from the
1889 exception handler address. */
1890 sim_engine_halt (SD, CPU, NULL, PC,
1891 sim_stopped, SIM_SIGBUS);
1892
1893 case ReservedInstruction:
1894 case CoProcessorUnusable:
1895 PC = EPC;
1896 sim_engine_halt (SD, CPU, NULL, PC,
1897 sim_stopped, SIM_SIGILL);
1898
1899 case IntegerOverflow:
1900 case FPE:
1901 sim_engine_halt (SD, CPU, NULL, PC,
1902 sim_stopped, SIM_SIGFPE);
1903
1904 case BreakPoint:
1905 sim_engine_halt (SD, CPU, NULL, PC, sim_stopped, SIM_SIGTRAP);
1906 break;
1907
1908 case SystemCall:
1909 case Trap:
1910 sim_engine_restart (SD, CPU, NULL, PC);
1911 break;
1912
1913 case Watch:
1914 PC = EPC;
1915 sim_engine_halt (SD, CPU, NULL, PC,
1916 sim_stopped, SIM_SIGTRAP);
1917
1918 default: /* Unknown internal exception */
1919 PC = EPC;
1920 sim_engine_halt (SD, CPU, NULL, PC,
1921 sim_stopped, SIM_SIGABRT);
1922
1923 }
1924
1925 case SimulatorFault:
1926 {
1927 va_list ap;
1928 char *msg;
1929 va_start(ap,exception);
1930 msg = va_arg(ap,char *);
1931 va_end(ap);
1932 sim_engine_abort (SD, CPU, NULL_CIA,
1933 "FATAL: Simulator error \"%s\"\n",msg);
1934 }
1935 }
1936
1937 return;
1938 }
1939
1940
1941
1942 /* This function implements what the MIPS32 and MIPS64 ISAs define as
1943 "UNPREDICTABLE" behaviour.
1944
1945 About UNPREDICTABLE behaviour they say: "UNPREDICTABLE results
1946 may vary from processor implementation to processor implementation,
1947 instruction to instruction, or as a function of time on the same
1948 implementation or instruction. Software can never depend on results
1949 that are UNPREDICTABLE. ..." (MIPS64 Architecture for Programmers
1950 Volume II, The MIPS64 Instruction Set. MIPS Document MD00087 revision
1951 0.95, page 2.)
1952
1953 For UNPREDICTABLE behaviour, we print a message, if possible print
1954 the offending instructions mips.igen instruction name (provided by
1955 the caller), and stop the simulator.
1956
1957 XXX FIXME: eventually, stopping the simulator should be made conditional
1958 on a command-line option. */
1959 void
1960 unpredictable_action(sim_cpu *cpu, address_word cia)
1961 {
1962 SIM_DESC sd = CPU_STATE(cpu);
1963
1964 sim_io_eprintf(sd, "UNPREDICTABLE: PC = 0x%s\n", pr_addr (cia));
1965 sim_engine_halt (SD, CPU, NULL, cia, sim_stopped, SIM_SIGABRT);
1966 }
1967
1968
1969 /*-- co-processor support routines ------------------------------------------*/
1970
1971 static int UNUSED
1972 CoProcPresent(unsigned int coproc_number)
1973 {
1974 /* Return TRUE if simulator provides a model for the given co-processor number */
1975 return(0);
1976 }
1977
1978 void
1979 cop_lw (SIM_DESC sd,
1980 sim_cpu *cpu,
1981 address_word cia,
1982 int coproc_num,
1983 int coproc_reg,
1984 unsigned int memword)
1985 {
1986 switch (coproc_num)
1987 {
1988 case 1:
1989 if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
1990 {
1991 #ifdef DEBUG
1992 printf("DBG: COP_LW: memword = 0x%08X (uword64)memword = 0x%s\n",memword,pr_addr(memword));
1993 #endif
1994 StoreFPR(coproc_reg,fmt_uninterpreted_32,(uword64)memword);
1995 break;
1996 }
1997
1998 default:
1999 #if 0 /* this should be controlled by a configuration option */
2000 sim_io_printf(sd,"COP_LW(%d,%d,0x%08X) at PC = 0x%s : TODO (architecture specific)\n",coproc_num,coproc_reg,memword,pr_addr(cia));
2001 #endif
2002 break;
2003 }
2004
2005 return;
2006 }
2007
2008 void
2009 cop_ld (SIM_DESC sd,
2010 sim_cpu *cpu,
2011 address_word cia,
2012 int coproc_num,
2013 int coproc_reg,
2014 uword64 memword)
2015 {
2016
2017 #ifdef DEBUG
2018 printf("DBG: COP_LD: coproc_num = %d, coproc_reg = %d, value = 0x%s : PC = 0x%s\n", coproc_num, coproc_reg, pr_uword64(memword), pr_addr(cia) );
2019 #endif
2020
2021 switch (coproc_num) {
2022 case 1:
2023 if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
2024 {
2025 StoreFPR(coproc_reg,fmt_uninterpreted_64,memword);
2026 break;
2027 }
2028
2029 default:
2030 #if 0 /* this message should be controlled by a configuration option */
2031 sim_io_printf(sd,"COP_LD(%d,%d,0x%s) at PC = 0x%s : TODO (architecture specific)\n",coproc_num,coproc_reg,pr_addr(memword),pr_addr(cia));
2032 #endif
2033 break;
2034 }
2035
2036 return;
2037 }
2038
2039
2040
2041
2042 unsigned int
2043 cop_sw (SIM_DESC sd,
2044 sim_cpu *cpu,
2045 address_word cia,
2046 int coproc_num,
2047 int coproc_reg)
2048 {
2049 unsigned int value = 0;
2050
2051 switch (coproc_num)
2052 {
2053 case 1:
2054 if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
2055 {
2056 value = (unsigned int)ValueFPR(coproc_reg,fmt_uninterpreted_32);
2057 break;
2058 }
2059
2060 default:
2061 #if 0 /* should be controlled by configuration option */
2062 sim_io_printf(sd,"COP_SW(%d,%d) at PC = 0x%s : TODO (architecture specific)\n",coproc_num,coproc_reg,pr_addr(cia));
2063 #endif
2064 break;
2065 }
2066
2067 return(value);
2068 }
2069
2070 uword64
2071 cop_sd (SIM_DESC sd,
2072 sim_cpu *cpu,
2073 address_word cia,
2074 int coproc_num,
2075 int coproc_reg)
2076 {
2077 uword64 value = 0;
2078 switch (coproc_num)
2079 {
2080 case 1:
2081 if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
2082 {
2083 value = ValueFPR(coproc_reg,fmt_uninterpreted_64);
2084 break;
2085 }
2086
2087 default:
2088 #if 0 /* should be controlled by configuration option */
2089 sim_io_printf(sd,"COP_SD(%d,%d) at PC = 0x%s : TODO (architecture specific)\n",coproc_num,coproc_reg,pr_addr(cia));
2090 #endif
2091 break;
2092 }
2093
2094 return(value);
2095 }
2096
2097
2098
2099
2100 void
2101 decode_coproc (SIM_DESC sd,
2102 sim_cpu *cpu,
2103 address_word cia,
2104 unsigned int instruction,
2105 int coprocnum,
2106 CP0_operation op,
2107 int rt,
2108 int rd,
2109 int sel)
2110 {
2111 switch (coprocnum)
2112 {
2113 case 0: /* standard CPU control and cache registers */
2114 {
2115 /* R4000 Users Manual (second edition) lists the following CP0
2116 instructions:
2117 CODE><-RT><RD-><--TAIL--->
2118 DMFC0 Doubleword Move From CP0 (VR4100 = 01000000001tttttddddd00000000000)
2119 DMTC0 Doubleword Move To CP0 (VR4100 = 01000000101tttttddddd00000000000)
2120 MFC0 word Move From CP0 (VR4100 = 01000000000tttttddddd00000000000)
2121 MTC0 word Move To CP0 (VR4100 = 01000000100tttttddddd00000000000)
2122 TLBR Read Indexed TLB Entry (VR4100 = 01000010000000000000000000000001)
2123 TLBWI Write Indexed TLB Entry (VR4100 = 01000010000000000000000000000010)
2124 TLBWR Write Random TLB Entry (VR4100 = 01000010000000000000000000000110)
2125 TLBP Probe TLB for Matching Entry (VR4100 = 01000010000000000000000000001000)
2126 CACHE Cache operation (VR4100 = 101111bbbbbpppppiiiiiiiiiiiiiiii)
2127 ERET Exception return (VR4100 = 01000010000000000000000000011000)
2128 */
2129 if (((op == cp0_mfc0) || (op == cp0_mtc0) /* MFC0 / MTC0 */
2130 || (op == cp0_dmfc0) || (op == cp0_dmtc0)) /* DMFC0 / DMTC0 */
2131 && sel == 0)
2132 {
2133 switch (rd) /* NOTEs: Standard CP0 registers */
2134 {
2135 /* 0 = Index R4000 VR4100 VR4300 */
2136 /* 1 = Random R4000 VR4100 VR4300 */
2137 /* 2 = EntryLo0 R4000 VR4100 VR4300 */
2138 /* 3 = EntryLo1 R4000 VR4100 VR4300 */
2139 /* 4 = Context R4000 VR4100 VR4300 */
2140 /* 5 = PageMask R4000 VR4100 VR4300 */
2141 /* 6 = Wired R4000 VR4100 VR4300 */
2142 /* 8 = BadVAddr R4000 VR4100 VR4300 */
2143 /* 9 = Count R4000 VR4100 VR4300 */
2144 /* 10 = EntryHi R4000 VR4100 VR4300 */
2145 /* 11 = Compare R4000 VR4100 VR4300 */
2146 /* 12 = SR R4000 VR4100 VR4300 */
2147 #ifdef SUBTARGET_R3900
2148 case 3:
2149 /* 3 = Config R3900 */
2150 case 7:
2151 /* 7 = Cache R3900 */
2152 case 15:
2153 /* 15 = PRID R3900 */
2154
2155 /* ignore */
2156 break;
2157
2158 case 8:
2159 /* 8 = BadVAddr R4000 VR4100 VR4300 */
2160 if (op == cp0_mfc0 || op == cp0_dmfc0)
2161 GPR[rt] = (signed_word) (signed_address) COP0_BADVADDR;
2162 else
2163 COP0_BADVADDR = GPR[rt];
2164 break;
2165
2166 #endif /* SUBTARGET_R3900 */
2167 case 12:
2168 if (op == cp0_mfc0 || op == cp0_dmfc0)
2169 GPR[rt] = SR;
2170 else
2171 SR = GPR[rt];
2172 break;
2173 /* 13 = Cause R4000 VR4100 VR4300 */
2174 case 13:
2175 if (op == cp0_mfc0 || op == cp0_dmfc0)
2176 GPR[rt] = CAUSE;
2177 else
2178 CAUSE = GPR[rt];
2179 break;
2180 /* 14 = EPC R4000 VR4100 VR4300 */
2181 case 14:
2182 if (op == cp0_mfc0 || op == cp0_dmfc0)
2183 GPR[rt] = (signed_word) (signed_address) EPC;
2184 else
2185 EPC = GPR[rt];
2186 break;
2187 /* 15 = PRId R4000 VR4100 VR4300 */
2188 #ifdef SUBTARGET_R3900
2189 /* 16 = Debug */
2190 case 16:
2191 if (op == cp0_mfc0 || op == cp0_dmfc0)
2192 GPR[rt] = Debug;
2193 else
2194 Debug = GPR[rt];
2195 break;
2196 #else
2197 /* 16 = Config R4000 VR4100 VR4300 */
2198 case 16:
2199 if (op == cp0_mfc0 || op == cp0_dmfc0)
2200 GPR[rt] = C0_CONFIG;
2201 else
2202 /* only bottom three bits are writable */
2203 C0_CONFIG = (C0_CONFIG & ~0x7) | (GPR[rt] & 0x7);
2204 break;
2205 #endif
2206 #ifdef SUBTARGET_R3900
2207 /* 17 = Debug */
2208 case 17:
2209 if (op == cp0_mfc0 || op == cp0_dmfc0)
2210 GPR[rt] = DEPC;
2211 else
2212 DEPC = GPR[rt];
2213 break;
2214 #else
2215 /* 17 = LLAddr R4000 VR4100 VR4300 */
2216 #endif
2217 /* 18 = WatchLo R4000 VR4100 VR4300 */
2218 /* 19 = WatchHi R4000 VR4100 VR4300 */
2219 /* 20 = XContext R4000 VR4100 VR4300 */
2220 /* 26 = PErr or ECC R4000 VR4100 VR4300 */
2221 /* 27 = CacheErr R4000 VR4100 */
2222 /* 28 = TagLo R4000 VR4100 VR4300 */
2223 /* 29 = TagHi R4000 VR4100 VR4300 */
2224 /* 30 = ErrorEPC R4000 VR4100 VR4300 */
2225 if (STATE_VERBOSE_P(SD))
2226 sim_io_eprintf (SD,
2227 "Warning: PC 0x%lx:interp.c decode_coproc DEADC0DE\n",
2228 (unsigned long)cia);
2229 GPR[rt] = 0xDEADC0DE; /* CPR[0,rd] */
2230 /* CPR[0,rd] = GPR[rt]; */
2231 default:
2232 if (op == cp0_mfc0 || op == cp0_dmfc0)
2233 GPR[rt] = (signed_word) (signed32) COP0_GPR[rd];
2234 else
2235 COP0_GPR[rd] = GPR[rt];
2236 #if 0
2237 if (code == 0x00)
2238 sim_io_printf(sd,"Warning: MFC0 %d,%d ignored, PC=%08x (architecture specific)\n",rt,rd, (unsigned)cia);
2239 else
2240 sim_io_printf(sd,"Warning: MTC0 %d,%d ignored, PC=%08x (architecture specific)\n",rt,rd, (unsigned)cia);
2241 #endif
2242 }
2243 }
2244 else if ((op == cp0_mfc0 || op == cp0_dmfc0)
2245 && rd == 16)
2246 {
2247 /* [D]MFC0 RT,C0_CONFIG,SEL */
2248 signed32 cfg = 0;
2249 switch (sel)
2250 {
2251 case 0:
2252 cfg = C0_CONFIG;
2253 break;
2254 case 1:
2255 /* MIPS32 r/o Config1:
2256 Config2 present */
2257 cfg = 0x80000000;
2258 /* MIPS16 implemented.
2259 XXX How to check configuration? */
2260 cfg |= 0x0000004;
2261 if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
2262 /* MDMX & FPU implemented */
2263 cfg |= 0x00000021;
2264 break;
2265 case 2:
2266 /* MIPS32 r/o Config2:
2267 Config3 present. */
2268 cfg = 0x80000000;
2269 break;
2270 case 3:
2271 /* MIPS32 r/o Config3:
2272 SmartMIPS implemented. */
2273 cfg = 0x00000002;
2274 break;
2275 }
2276 GPR[rt] = cfg;
2277 }
2278 else if (op == cp0_eret && sel == 0x18)
2279 {
2280 /* ERET */
2281 if (SR & status_ERL)
2282 {
2283 /* Oops, not yet available */
2284 sim_io_printf(sd,"Warning: ERET when SR[ERL] set not handled yet");
2285 PC = EPC;
2286 SR &= ~status_ERL;
2287 }
2288 else
2289 {
2290 PC = EPC;
2291 SR &= ~status_EXL;
2292 }
2293 }
2294 else if (op == cp0_rfe && sel == 0x10)
2295 {
2296 /* RFE */
2297 #ifdef SUBTARGET_R3900
2298 /* TX39: Copy IEp/KUp -> IEc/KUc, and IEo/KUo -> IEp/KUp */
2299
2300 /* shift IE/KU history bits right */
2301 SR = LSMASKED32(SR, 31, 4) | LSINSERTED32(LSEXTRACTED32(SR, 5, 2), 3, 0);
2302
2303 /* TODO: CACHE register */
2304 #endif /* SUBTARGET_R3900 */
2305 }
2306 else if (op == cp0_deret && sel == 0x1F)
2307 {
2308 /* DERET */
2309 Debug &= ~Debug_DM;
2310 DELAYSLOT();
2311 DSPC = DEPC;
2312 }
2313 else
2314 sim_io_eprintf(sd,"Unrecognised COP0 instruction 0x%08X at PC = 0x%s : No handler present\n",instruction,pr_addr(cia));
2315 /* TODO: When executing an ERET or RFE instruction we should
2316 clear LLBIT, to ensure that any out-standing atomic
2317 read/modify/write sequence fails. */
2318 }
2319 break;
2320
2321 case 2: /* co-processor 2 */
2322 {
2323 int handle = 0;
2324
2325
2326 if(! handle)
2327 {
2328 sim_io_eprintf(sd, "COP2 instruction 0x%08X at PC = 0x%s : No handler present\n",
2329 instruction,pr_addr(cia));
2330 }
2331 }
2332 break;
2333
2334 case 1: /* should not occur (FPU co-processor) */
2335 case 3: /* should not occur (FPU co-processor) */
2336 SignalException(ReservedInstruction,instruction);
2337 break;
2338 }
2339
2340 return;
2341 }
2342
2343
2344 /* This code copied from gdb's utils.c. Would like to share this code,
2345 but don't know of a common place where both could get to it. */
2346
2347 /* Temporary storage using circular buffer */
2348 #define NUMCELLS 16
2349 #define CELLSIZE 32
2350 static char*
2351 get_cell (void)
2352 {
2353 static char buf[NUMCELLS][CELLSIZE];
2354 static int cell=0;
2355 if (++cell>=NUMCELLS) cell=0;
2356 return buf[cell];
2357 }
2358
2359 /* Print routines to handle variable size regs, etc */
2360
2361 /* Eliminate warning from compiler on 32-bit systems */
2362 static int thirty_two = 32;
2363
2364 char*
2365 pr_addr (SIM_ADDR addr)
2366 {
2367 char *paddr_str=get_cell();
2368 switch (sizeof(addr))
2369 {
2370 case 8:
2371 sprintf(paddr_str,"%08lx%08lx",
2372 (unsigned long)(addr>>thirty_two),(unsigned long)(addr&0xffffffff));
2373 break;
2374 case 4:
2375 sprintf(paddr_str,"%08lx",(unsigned long)addr);
2376 break;
2377 case 2:
2378 sprintf(paddr_str,"%04x",(unsigned short)(addr&0xffff));
2379 break;
2380 default:
2381 sprintf(paddr_str,"%x",addr);
2382 }
2383 return paddr_str;
2384 }
2385
2386 char*
2387 pr_uword64 (uword64 addr)
2388 {
2389 char *paddr_str=get_cell();
2390 sprintf(paddr_str,"%08lx%08lx",
2391 (unsigned long)(addr>>thirty_two),(unsigned long)(addr&0xffffffff));
2392 return paddr_str;
2393 }
2394
2395
2396 void
2397 mips_core_signal (SIM_DESC sd,
2398 sim_cpu *cpu,
2399 sim_cia cia,
2400 unsigned map,
2401 int nr_bytes,
2402 address_word addr,
2403 transfer_type transfer,
2404 sim_core_signals sig)
2405 {
2406 const char *copy = (transfer == read_transfer ? "read" : "write");
2407 address_word ip = CIA_ADDR (cia);
2408
2409 switch (sig)
2410 {
2411 case sim_core_unmapped_signal:
2412 sim_io_eprintf (sd, "mips-core: %d byte %s to unmapped address 0x%lx at 0x%lx\n",
2413 nr_bytes, copy,
2414 (unsigned long) addr, (unsigned long) ip);
2415 COP0_BADVADDR = addr;
2416 SignalExceptionDataReference();
2417 break;
2418
2419 case sim_core_unaligned_signal:
2420 sim_io_eprintf (sd, "mips-core: %d byte %s to unaligned address 0x%lx at 0x%lx\n",
2421 nr_bytes, copy,
2422 (unsigned long) addr, (unsigned long) ip);
2423 COP0_BADVADDR = addr;
2424 if(transfer == read_transfer)
2425 SignalExceptionAddressLoad();
2426 else
2427 SignalExceptionAddressStore();
2428 break;
2429
2430 default:
2431 sim_engine_abort (sd, cpu, cia,
2432 "mips_core_signal - internal error - bad switch");
2433 }
2434 }
2435
2436
2437 void
2438 mips_cpu_exception_trigger(SIM_DESC sd, sim_cpu* cpu, address_word cia)
2439 {
2440 ASSERT(cpu != NULL);
2441
2442 if(cpu->exc_suspended > 0)
2443 sim_io_eprintf(sd, "Warning, nested exception triggered (%d)\n", cpu->exc_suspended);
2444
2445 PC = cia;
2446 memcpy(cpu->exc_trigger_registers, cpu->registers, sizeof(cpu->exc_trigger_registers));
2447 cpu->exc_suspended = 0;
2448 }
2449
2450 void
2451 mips_cpu_exception_suspend(SIM_DESC sd, sim_cpu* cpu, int exception)
2452 {
2453 ASSERT(cpu != NULL);
2454
2455 if(cpu->exc_suspended > 0)
2456 sim_io_eprintf(sd, "Warning, nested exception signal (%d then %d)\n",
2457 cpu->exc_suspended, exception);
2458
2459 memcpy(cpu->exc_suspend_registers, cpu->registers, sizeof(cpu->exc_suspend_registers));
2460 memcpy(cpu->registers, cpu->exc_trigger_registers, sizeof(cpu->registers));
2461 cpu->exc_suspended = exception;
2462 }
2463
2464 void
2465 mips_cpu_exception_resume(SIM_DESC sd, sim_cpu* cpu, int exception)
2466 {
2467 ASSERT(cpu != NULL);
2468
2469 if(exception == 0 && cpu->exc_suspended > 0)
2470 {
2471 /* warn not for breakpoints */
2472 if(cpu->exc_suspended != sim_signal_to_host(sd, SIM_SIGTRAP))
2473 sim_io_eprintf(sd, "Warning, resuming but ignoring pending exception signal (%d)\n",
2474 cpu->exc_suspended);
2475 }
2476 else if(exception != 0 && cpu->exc_suspended > 0)
2477 {
2478 if(exception != cpu->exc_suspended)
2479 sim_io_eprintf(sd, "Warning, resuming with mismatched exception signal (%d vs %d)\n",
2480 cpu->exc_suspended, exception);
2481
2482 memcpy(cpu->registers, cpu->exc_suspend_registers, sizeof(cpu->registers));
2483 }
2484 else if(exception != 0 && cpu->exc_suspended == 0)
2485 {
2486 sim_io_eprintf(sd, "Warning, ignoring spontanous exception signal (%d)\n", exception);
2487 }
2488 cpu->exc_suspended = 0;
2489 }
2490
2491
2492 /*---------------------------------------------------------------------------*/
2493 /*> EOF interp.c <*/
GDB Binutils - Deliverables
This page took 0.104272 seconds and 4 git commands to generate.