/*> interp.c <*/
|
/*> interp.c <*/
|
/* Simulator for the MIPS architecture.
|
/* Simulator for the MIPS architecture.
|
|
|
This file is part of the MIPS sim
|
This file is part of the MIPS sim
|
|
|
THIS SOFTWARE IS NOT COPYRIGHTED
|
THIS SOFTWARE IS NOT COPYRIGHTED
|
|
|
Cygnus offers the following for use in the public domain. Cygnus
|
Cygnus offers the following for use in the public domain. Cygnus
|
makes no warranty with regard to the software or it's performance
|
makes no warranty with regard to the software or it's performance
|
and the user accepts the software "AS IS" with all faults.
|
and the user accepts the software "AS IS" with all faults.
|
|
|
CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
|
CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
|
THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
$Revision: 1.1.1.1 $
|
$Revision: 1.1.1.1 $
|
$Date: 2001-05-18 11:25:18 $
|
$Date: 2001-05-18 11:25:18 $
|
|
|
NOTEs:
|
NOTEs:
|
|
|
The IDT monitor (found on the VR4300 board), seems to lie about
|
The IDT monitor (found on the VR4300 board), seems to lie about
|
register contents. It seems to treat the registers as sign-extended
|
register contents. It seems to treat the registers as sign-extended
|
32-bit values. This cause *REAL* problems when single-stepping 64-bit
|
32-bit values. This cause *REAL* problems when single-stepping 64-bit
|
code on the hardware.
|
code on the hardware.
|
|
|
*/
|
*/
|
|
|
/* The TRACE manifests enable the provision of extra features. If they
|
/* The TRACE manifests enable the provision of extra features. If they
|
are not defined then a simpler (quicker) simulator is constructed
|
are not defined then a simpler (quicker) simulator is constructed
|
without the required run-time checks, etc. */
|
without the required run-time checks, etc. */
|
#if 1 /* 0 to allow user build selection, 1 to force inclusion */
|
#if 1 /* 0 to allow user build selection, 1 to force inclusion */
|
#define TRACE (1)
|
#define TRACE (1)
|
#endif
|
#endif
|
|
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "sim-main.h"
|
#include "sim-main.h"
|
#include "sim-utils.h"
|
#include "sim-utils.h"
|
#include "sim-options.h"
|
#include "sim-options.h"
|
#include "sim-assert.h"
|
#include "sim-assert.h"
|
#include "sim-hw.h"
|
#include "sim-hw.h"
|
|
|
#include "itable.h"
|
#include "itable.h"
|
|
|
|
|
#include "config.h"
|
#include "config.h"
|
|
|
#include <stdio.h>
|
#include <stdio.h>
|
#include <stdarg.h>
|
#include <stdarg.h>
|
#include <ansidecl.h>
|
#include <ansidecl.h>
|
#include <ctype.h>
|
#include <ctype.h>
|
#include <limits.h>
|
#include <limits.h>
|
#include <math.h>
|
#include <math.h>
|
#ifdef HAVE_STDLIB_H
|
#ifdef HAVE_STDLIB_H
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#endif
|
#endif
|
#ifdef HAVE_STRING_H
|
#ifdef HAVE_STRING_H
|
#include <string.h>
|
#include <string.h>
|
#else
|
#else
|
#ifdef HAVE_STRINGS_H
|
#ifdef HAVE_STRINGS_H
|
#include <strings.h>
|
#include <strings.h>
|
#endif
|
#endif
|
#endif
|
#endif
|
|
|
#include "getopt.h"
|
#include "getopt.h"
|
#include "libiberty.h"
|
#include "libiberty.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "callback.h" /* GDB simulator callback interface */
|
#include "callback.h" /* GDB simulator callback interface */
|
#include "remote-sim.h" /* GDB simulator interface */
|
#include "remote-sim.h" /* GDB simulator interface */
|
|
|
#include "sysdep.h"
|
#include "sysdep.h"
|
|
|
#ifndef PARAMS
|
#ifndef PARAMS
|
#define PARAMS(x)
|
#define PARAMS(x)
|
#endif
|
#endif
|
|
|
char* pr_addr PARAMS ((SIM_ADDR addr));
|
char* pr_addr PARAMS ((SIM_ADDR addr));
|
char* pr_uword64 PARAMS ((uword64 addr));
|
char* pr_uword64 PARAMS ((uword64 addr));
|
|
|
|
|
/* Within interp.c we refer to the sim_state and sim_cpu directly. */
|
/* Within interp.c we refer to the sim_state and sim_cpu directly. */
|
#define CPU cpu
|
#define CPU cpu
|
#define SD sd
|
#define SD sd
|
|
|
|
|
/* The following reserved instruction value is used when a simulator
|
/* The following reserved instruction value is used when a simulator
|
trap is required. NOTE: Care must be taken, since this value may be
|
trap is required. NOTE: Care must be taken, since this value may be
|
used in later revisions of the MIPS ISA. */
|
used in later revisions of the MIPS ISA. */
|
|
|
#define RSVD_INSTRUCTION (0x00000005)
|
#define RSVD_INSTRUCTION (0x00000005)
|
#define RSVD_INSTRUCTION_MASK (0xFC00003F)
|
#define RSVD_INSTRUCTION_MASK (0xFC00003F)
|
|
|
#define RSVD_INSTRUCTION_ARG_SHIFT 6
|
#define RSVD_INSTRUCTION_ARG_SHIFT 6
|
#define RSVD_INSTRUCTION_ARG_MASK 0xFFFFF
|
#define RSVD_INSTRUCTION_ARG_MASK 0xFFFFF
|
|
|
|
|
/* Bits in the Debug register */
|
/* Bits in the Debug register */
|
#define Debug_DBD 0x80000000 /* Debug Branch Delay */
|
#define Debug_DBD 0x80000000 /* Debug Branch Delay */
|
#define Debug_DM 0x40000000 /* Debug Mode */
|
#define Debug_DM 0x40000000 /* Debug Mode */
|
#define Debug_DBp 0x00000002 /* Debug Breakpoint indicator */
|
#define Debug_DBp 0x00000002 /* Debug Breakpoint indicator */
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*-- GDB simulator interface ------------------------------------------------*/
|
/*-- GDB simulator interface ------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
|
|
static void ColdReset PARAMS((SIM_DESC sd));
|
static void ColdReset PARAMS((SIM_DESC sd));
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
|
|
|
|
|
|
#define DELAYSLOT() {\
|
#define DELAYSLOT() {\
|
if (STATE & simDELAYSLOT)\
|
if (STATE & simDELAYSLOT)\
|
sim_io_eprintf(sd,"Delay slot already activated (branch in delay slot?)\n");\
|
sim_io_eprintf(sd,"Delay slot already activated (branch in delay slot?)\n");\
|
STATE |= simDELAYSLOT;\
|
STATE |= simDELAYSLOT;\
|
}
|
}
|
|
|
#define JALDELAYSLOT() {\
|
#define JALDELAYSLOT() {\
|
DELAYSLOT ();\
|
DELAYSLOT ();\
|
STATE |= simJALDELAYSLOT;\
|
STATE |= simJALDELAYSLOT;\
|
}
|
}
|
|
|
#define NULLIFY() {\
|
#define NULLIFY() {\
|
STATE &= ~simDELAYSLOT;\
|
STATE &= ~simDELAYSLOT;\
|
STATE |= simSKIPNEXT;\
|
STATE |= simSKIPNEXT;\
|
}
|
}
|
|
|
#define CANCELDELAYSLOT() {\
|
#define CANCELDELAYSLOT() {\
|
DSSTATE = 0;\
|
DSSTATE = 0;\
|
STATE &= ~(simDELAYSLOT | simJALDELAYSLOT);\
|
STATE &= ~(simDELAYSLOT | simJALDELAYSLOT);\
|
}
|
}
|
|
|
#define INDELAYSLOT() ((STATE & simDELAYSLOT) != 0)
|
#define INDELAYSLOT() ((STATE & simDELAYSLOT) != 0)
|
#define INJALDELAYSLOT() ((STATE & simJALDELAYSLOT) != 0)
|
#define INJALDELAYSLOT() ((STATE & simJALDELAYSLOT) != 0)
|
|
|
/* Note that the monitor code essentially assumes this layout of memory.
|
/* Note that the monitor code essentially assumes this layout of memory.
|
If you change these, change the monitor code, too. */
|
If you change these, change the monitor code, too. */
|
#define K0BASE (0x80000000)
|
#define K0BASE (0x80000000)
|
#define K0SIZE (0x20000000)
|
#define K0SIZE (0x20000000)
|
#define K1BASE (0xA0000000)
|
#define K1BASE (0xA0000000)
|
#define K1SIZE (0x20000000)
|
#define K1SIZE (0x20000000)
|
|
|
/* Simple run-time monitor support.
|
/* Simple run-time monitor support.
|
|
|
We emulate the monitor by placing magic reserved instructions at
|
We emulate the monitor by placing magic reserved instructions at
|
the monitor's entry points; when we hit these instructions, instead
|
the monitor's entry points; when we hit these instructions, instead
|
of raising an exception (as we would normally), we look at the
|
of raising an exception (as we would normally), we look at the
|
instruction and perform the appropriate monitory operation.
|
instruction and perform the appropriate monitory operation.
|
|
|
`*_monitor_base' are the physical addresses at which the corresponding
|
`*_monitor_base' are the physical addresses at which the corresponding
|
monitor vectors are located. `0' means none. By default,
|
monitor vectors are located. `0' means none. By default,
|
install all three.
|
install all three.
|
The RSVD_INSTRUCTION... macros specify the magic instructions we
|
The RSVD_INSTRUCTION... macros specify the magic instructions we
|
use at the monitor entry points. */
|
use at the monitor entry points. */
|
static int firmware_option_p = 0;
|
static int firmware_option_p = 0;
|
static SIM_ADDR idt_monitor_base = 0xBFC00000;
|
static SIM_ADDR idt_monitor_base = 0xBFC00000;
|
static SIM_ADDR pmon_monitor_base = 0xBFC00500;
|
static SIM_ADDR pmon_monitor_base = 0xBFC00500;
|
static SIM_ADDR lsipmon_monitor_base = 0xBFC00200;
|
static SIM_ADDR lsipmon_monitor_base = 0xBFC00200;
|
|
|
static SIM_RC sim_firmware_command (SIM_DESC sd, char* arg);
|
static SIM_RC sim_firmware_command (SIM_DESC sd, char* arg);
|
|
|
|
|
#define MEM_SIZE (2 << 20)
|
#define MEM_SIZE (2 << 20)
|
|
|
|
|
#if defined(TRACE)
|
#if defined(TRACE)
|
static char *tracefile = "trace.din"; /* default filename for trace log */
|
static char *tracefile = "trace.din"; /* default filename for trace log */
|
FILE *tracefh = NULL;
|
FILE *tracefh = NULL;
|
static void open_trace PARAMS((SIM_DESC sd));
|
static void open_trace PARAMS((SIM_DESC sd));
|
#endif /* TRACE */
|
#endif /* TRACE */
|
|
|
static const char * get_insn_name (sim_cpu *, int);
|
static const char * get_insn_name (sim_cpu *, int);
|
|
|
/* simulation target board. NULL=canonical */
|
/* simulation target board. NULL=canonical */
|
static char* board = NULL;
|
static char* board = NULL;
|
|
|
|
|
static DECLARE_OPTION_HANDLER (mips_option_handler);
|
static DECLARE_OPTION_HANDLER (mips_option_handler);
|
|
|
enum {
|
enum {
|
OPTION_DINERO_TRACE = OPTION_START,
|
OPTION_DINERO_TRACE = OPTION_START,
|
OPTION_DINERO_FILE,
|
OPTION_DINERO_FILE,
|
OPTION_FIRMWARE,
|
OPTION_FIRMWARE,
|
OPTION_BOARD
|
OPTION_BOARD
|
};
|
};
|
|
|
|
|
static SIM_RC
|
static SIM_RC
|
mips_option_handler (sd, cpu, opt, arg, is_command)
|
mips_option_handler (sd, cpu, opt, arg, is_command)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
sim_cpu *cpu;
|
sim_cpu *cpu;
|
int opt;
|
int opt;
|
char *arg;
|
char *arg;
|
int is_command;
|
int is_command;
|
{
|
{
|
int cpu_nr;
|
int cpu_nr;
|
switch (opt)
|
switch (opt)
|
{
|
{
|
case OPTION_DINERO_TRACE: /* ??? */
|
case OPTION_DINERO_TRACE: /* ??? */
|
#if defined(TRACE)
|
#if defined(TRACE)
|
/* Eventually the simTRACE flag could be treated as a toggle, to
|
/* Eventually the simTRACE flag could be treated as a toggle, to
|
allow external control of the program points being traced
|
allow external control of the program points being traced
|
(i.e. only from main onwards, excluding the run-time setup,
|
(i.e. only from main onwards, excluding the run-time setup,
|
etc.). */
|
etc.). */
|
for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
|
for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
|
{
|
{
|
sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
|
sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
|
if (arg == NULL)
|
if (arg == NULL)
|
STATE |= simTRACE;
|
STATE |= simTRACE;
|
else if (strcmp (arg, "yes") == 0)
|
else if (strcmp (arg, "yes") == 0)
|
STATE |= simTRACE;
|
STATE |= simTRACE;
|
else if (strcmp (arg, "no") == 0)
|
else if (strcmp (arg, "no") == 0)
|
STATE &= ~simTRACE;
|
STATE &= ~simTRACE;
|
else if (strcmp (arg, "on") == 0)
|
else if (strcmp (arg, "on") == 0)
|
STATE |= simTRACE;
|
STATE |= simTRACE;
|
else if (strcmp (arg, "off") == 0)
|
else if (strcmp (arg, "off") == 0)
|
STATE &= ~simTRACE;
|
STATE &= ~simTRACE;
|
else
|
else
|
{
|
{
|
fprintf (stderr, "Unrecognized dinero-trace option `%s'\n", arg);
|
fprintf (stderr, "Unrecognized dinero-trace option `%s'\n", arg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
}
|
}
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
#else /* !TRACE */
|
#else /* !TRACE */
|
fprintf(stderr,"\
|
fprintf(stderr,"\
|
Simulator constructed without dinero tracing support (for performance).\n\
|
Simulator constructed without dinero tracing support (for performance).\n\
|
Re-compile simulator with \"-DTRACE\" to enable this option.\n");
|
Re-compile simulator with \"-DTRACE\" to enable this option.\n");
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
#endif /* !TRACE */
|
#endif /* !TRACE */
|
|
|
case OPTION_DINERO_FILE:
|
case OPTION_DINERO_FILE:
|
#if defined(TRACE)
|
#if defined(TRACE)
|
if (optarg != NULL) {
|
if (optarg != NULL) {
|
char *tmp;
|
char *tmp;
|
tmp = (char *)malloc(strlen(optarg) + 1);
|
tmp = (char *)malloc(strlen(optarg) + 1);
|
if (tmp == NULL)
|
if (tmp == NULL)
|
{
|
{
|
sim_io_printf(sd,"Failed to allocate buffer for tracefile name \"%s\"\n",optarg);
|
sim_io_printf(sd,"Failed to allocate buffer for tracefile name \"%s\"\n",optarg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
else {
|
else {
|
strcpy(tmp,optarg);
|
strcpy(tmp,optarg);
|
tracefile = tmp;
|
tracefile = tmp;
|
sim_io_printf(sd,"Placing trace information into file \"%s\"\n",tracefile);
|
sim_io_printf(sd,"Placing trace information into file \"%s\"\n",tracefile);
|
}
|
}
|
}
|
}
|
#endif /* TRACE */
|
#endif /* TRACE */
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
|
|
case OPTION_FIRMWARE:
|
case OPTION_FIRMWARE:
|
return sim_firmware_command (sd, arg);
|
return sim_firmware_command (sd, arg);
|
|
|
case OPTION_BOARD:
|
case OPTION_BOARD:
|
{
|
{
|
if (arg)
|
if (arg)
|
{
|
{
|
board = zalloc(strlen(arg) + 1);
|
board = zalloc(strlen(arg) + 1);
|
strcpy(board, arg);
|
strcpy(board, arg);
|
}
|
}
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
}
|
}
|
}
|
}
|
|
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
}
|
}
|
|
|
|
|
static const OPTION mips_options[] =
|
static const OPTION mips_options[] =
|
{
|
{
|
{ {"dinero-trace", optional_argument, NULL, OPTION_DINERO_TRACE},
|
{ {"dinero-trace", optional_argument, NULL, OPTION_DINERO_TRACE},
|
'\0', "on|off", "Enable dinero tracing",
|
'\0', "on|off", "Enable dinero tracing",
|
mips_option_handler },
|
mips_option_handler },
|
{ {"dinero-file", required_argument, NULL, OPTION_DINERO_FILE},
|
{ {"dinero-file", required_argument, NULL, OPTION_DINERO_FILE},
|
'\0', "FILE", "Write dinero trace to FILE",
|
'\0', "FILE", "Write dinero trace to FILE",
|
mips_option_handler },
|
mips_option_handler },
|
{ {"firmware", required_argument, NULL, OPTION_FIRMWARE},
|
{ {"firmware", required_argument, NULL, OPTION_FIRMWARE},
|
'\0', "[idt|pmon|lsipmon|none][@ADDRESS]", "Emulate ROM monitor",
|
'\0', "[idt|pmon|lsipmon|none][@ADDRESS]", "Emulate ROM monitor",
|
mips_option_handler },
|
mips_option_handler },
|
{ {"board", required_argument, NULL, OPTION_BOARD},
|
{ {"board", required_argument, NULL, OPTION_BOARD},
|
'\0', "none" /* rely on compile-time string concatenation for other options */
|
'\0', "none" /* rely on compile-time string concatenation for other options */
|
|
|
#define BOARD_JMR3904 "jmr3904"
|
#define BOARD_JMR3904 "jmr3904"
|
"|" BOARD_JMR3904
|
"|" BOARD_JMR3904
|
#define BOARD_JMR3904_PAL "jmr3904pal"
|
#define BOARD_JMR3904_PAL "jmr3904pal"
|
"|" BOARD_JMR3904_PAL
|
"|" BOARD_JMR3904_PAL
|
#define BOARD_JMR3904_DEBUG "jmr3904debug"
|
#define BOARD_JMR3904_DEBUG "jmr3904debug"
|
"|" BOARD_JMR3904_DEBUG
|
"|" BOARD_JMR3904_DEBUG
|
#define BOARD_BSP "bsp"
|
#define BOARD_BSP "bsp"
|
"|" BOARD_BSP
|
"|" BOARD_BSP
|
|
|
, "Customize simulation for a particular board.", mips_option_handler },
|
, "Customize simulation for a particular board.", mips_option_handler },
|
|
|
{ {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
|
{ {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
|
};
|
};
|
|
|
|
|
int interrupt_pending;
|
int interrupt_pending;
|
|
|
void
|
void
|
interrupt_event (SIM_DESC sd, void *data)
|
interrupt_event (SIM_DESC sd, void *data)
|
{
|
{
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
address_word cia = CIA_GET (cpu);
|
address_word cia = CIA_GET (cpu);
|
if (SR & status_IE)
|
if (SR & status_IE)
|
{
|
{
|
interrupt_pending = 0;
|
interrupt_pending = 0;
|
SignalExceptionInterrupt (1); /* interrupt "1" */
|
SignalExceptionInterrupt (1); /* interrupt "1" */
|
}
|
}
|
else if (!interrupt_pending)
|
else if (!interrupt_pending)
|
sim_events_schedule (sd, 1, interrupt_event, data);
|
sim_events_schedule (sd, 1, interrupt_event, data);
|
}
|
}
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*-- Device registration hook -----------------------------------------------*/
|
/*-- Device registration hook -----------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
static void device_init(SIM_DESC sd) {
|
static void device_init(SIM_DESC sd) {
|
#ifdef DEVICE_INIT
|
#ifdef DEVICE_INIT
|
extern void register_devices(SIM_DESC);
|
extern void register_devices(SIM_DESC);
|
register_devices(sd);
|
register_devices(sd);
|
#endif
|
#endif
|
}
|
}
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*-- GDB simulator interface ------------------------------------------------*/
|
/*-- GDB simulator interface ------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
|
|
SIM_DESC
|
SIM_DESC
|
sim_open (kind, cb, abfd, argv)
|
sim_open (kind, cb, abfd, argv)
|
SIM_OPEN_KIND kind;
|
SIM_OPEN_KIND kind;
|
host_callback *cb;
|
host_callback *cb;
|
struct _bfd *abfd;
|
struct _bfd *abfd;
|
char **argv;
|
char **argv;
|
{
|
{
|
SIM_DESC sd = sim_state_alloc (kind, cb);
|
SIM_DESC sd = sim_state_alloc (kind, cb);
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
|
|
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
|
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
|
|
|
/* FIXME: watchpoints code shouldn't need this */
|
/* FIXME: watchpoints code shouldn't need this */
|
STATE_WATCHPOINTS (sd)->pc = &(PC);
|
STATE_WATCHPOINTS (sd)->pc = &(PC);
|
STATE_WATCHPOINTS (sd)->sizeof_pc = sizeof (PC);
|
STATE_WATCHPOINTS (sd)->sizeof_pc = sizeof (PC);
|
STATE_WATCHPOINTS (sd)->interrupt_handler = interrupt_event;
|
STATE_WATCHPOINTS (sd)->interrupt_handler = interrupt_event;
|
|
|
/* Initialize the mechanism for doing insn profiling. */
|
/* Initialize the mechanism for doing insn profiling. */
|
CPU_INSN_NAME (cpu) = get_insn_name;
|
CPU_INSN_NAME (cpu) = get_insn_name;
|
CPU_MAX_INSNS (cpu) = nr_itable_entries;
|
CPU_MAX_INSNS (cpu) = nr_itable_entries;
|
|
|
STATE = 0;
|
STATE = 0;
|
|
|
if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
|
if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK)
|
return 0;
|
return 0;
|
sim_add_option_table (sd, NULL, mips_options);
|
sim_add_option_table (sd, NULL, mips_options);
|
|
|
|
|
/* getopt will print the error message so we just have to exit if this fails.
|
/* getopt will print the error message so we just have to exit if this fails.
|
FIXME: Hmmm... in the case of gdb we need getopt to call
|
FIXME: Hmmm... in the case of gdb we need getopt to call
|
print_filtered. */
|
print_filtered. */
|
if (sim_parse_args (sd, argv) != SIM_RC_OK)
|
if (sim_parse_args (sd, argv) != SIM_RC_OK)
|
{
|
{
|
/* Uninstall the modules to avoid memory leaks,
|
/* Uninstall the modules to avoid memory leaks,
|
file descriptor leaks, etc. */
|
file descriptor leaks, etc. */
|
sim_module_uninstall (sd);
|
sim_module_uninstall (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* handle board-specific memory maps */
|
/* handle board-specific memory maps */
|
if (board == NULL)
|
if (board == NULL)
|
{
|
{
|
/* Allocate core managed memory */
|
/* Allocate core managed memory */
|
|
|
|
|
/* For compatibility with the old code - under this (at level one)
|
/* For compatibility with the old code - under this (at level one)
|
are the kernel spaces K0 & K1. Both of these map to a single
|
are the kernel spaces K0 & K1. Both of these map to a single
|
smaller sub region */
|
smaller sub region */
|
sim_do_command(sd," memory region 0x7fff8000,0x8000") ; /* MTZ- 32 k stack */
|
sim_do_command(sd," memory region 0x7fff8000,0x8000") ; /* MTZ- 32 k stack */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx%%0x%lx,0x%0x",
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx%%0x%lx,0x%0x",
|
K1BASE, K0SIZE,
|
K1BASE, K0SIZE,
|
MEM_SIZE, /* actual size */
|
MEM_SIZE, /* actual size */
|
K0BASE);
|
K0BASE);
|
|
|
device_init(sd);
|
device_init(sd);
|
}
|
}
|
else if (board != NULL
|
else if (board != NULL
|
&& (strcmp(board, BOARD_BSP) == 0))
|
&& (strcmp(board, BOARD_BSP) == 0))
|
{
|
{
|
int i;
|
int i;
|
|
|
STATE_ENVIRONMENT (sd) = OPERATING_ENVIRONMENT;
|
STATE_ENVIRONMENT (sd) = OPERATING_ENVIRONMENT;
|
|
|
/* ROM: 0x9FC0_0000 - 0x9FFF_FFFF and 0xBFC0_0000 - 0xBFFF_FFFF */
|
/* ROM: 0x9FC0_0000 - 0x9FFF_FFFF and 0xBFC0_0000 - 0xBFFF_FFFF */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
0x9FC00000,
|
0x9FC00000,
|
4 * 1024 * 1024, /* 4 MB */
|
4 * 1024 * 1024, /* 4 MB */
|
0xBFC00000);
|
0xBFC00000);
|
|
|
/* SRAM: 0x8000_0000 - 0x803F_FFFF and 0xA000_0000 - 0xA03F_FFFF */
|
/* SRAM: 0x8000_0000 - 0x803F_FFFF and 0xA000_0000 - 0xA03F_FFFF */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
0x80000000,
|
0x80000000,
|
4 * 1024 * 1024, /* 4 MB */
|
4 * 1024 * 1024, /* 4 MB */
|
0xA0000000);
|
0xA0000000);
|
|
|
/* DRAM: 0x8800_0000 - 0x89FF_FFFF and 0xA800_0000 - 0xA9FF_FFFF */
|
/* DRAM: 0x8800_0000 - 0x89FF_FFFF and 0xA800_0000 - 0xA9FF_FFFF */
|
for (i=0; i<8; i++) /* 32 MB total */
|
for (i=0; i<8; i++) /* 32 MB total */
|
{
|
{
|
unsigned size = 4 * 1024 * 1024; /* 4 MB */
|
unsigned size = 4 * 1024 * 1024; /* 4 MB */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
0x88000000 + (i * size),
|
0x88000000 + (i * size),
|
size,
|
size,
|
0xA8000000 + (i * size));
|
0xA8000000 + (i * size));
|
}
|
}
|
}
|
}
|
#if (WITH_HW)
|
#if (WITH_HW)
|
else if (board != NULL
|
else if (board != NULL
|
&& (strcmp(board, BOARD_JMR3904) == 0 ||
|
&& (strcmp(board, BOARD_JMR3904) == 0 ||
|
strcmp(board, BOARD_JMR3904_PAL) == 0 ||
|
strcmp(board, BOARD_JMR3904_PAL) == 0 ||
|
strcmp(board, BOARD_JMR3904_DEBUG) == 0))
|
strcmp(board, BOARD_JMR3904_DEBUG) == 0))
|
{
|
{
|
/* match VIRTUAL memory layout of JMR-TX3904 board */
|
/* match VIRTUAL memory layout of JMR-TX3904 board */
|
int i;
|
int i;
|
|
|
/* --- disable monitor unless forced on by user --- */
|
/* --- disable monitor unless forced on by user --- */
|
|
|
if (! firmware_option_p)
|
if (! firmware_option_p)
|
{
|
{
|
idt_monitor_base = 0;
|
idt_monitor_base = 0;
|
pmon_monitor_base = 0;
|
pmon_monitor_base = 0;
|
lsipmon_monitor_base = 0;
|
lsipmon_monitor_base = 0;
|
}
|
}
|
|
|
/* --- environment --- */
|
/* --- environment --- */
|
|
|
STATE_ENVIRONMENT (sd) = OPERATING_ENVIRONMENT;
|
STATE_ENVIRONMENT (sd) = OPERATING_ENVIRONMENT;
|
|
|
/* --- memory --- */
|
/* --- memory --- */
|
|
|
/* ROM: 0x9FC0_0000 - 0x9FFF_FFFF and 0xBFC0_0000 - 0xBFFF_FFFF */
|
/* ROM: 0x9FC0_0000 - 0x9FFF_FFFF and 0xBFC0_0000 - 0xBFFF_FFFF */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
0x9FC00000,
|
0x9FC00000,
|
4 * 1024 * 1024, /* 4 MB */
|
4 * 1024 * 1024, /* 4 MB */
|
0xBFC00000);
|
0xBFC00000);
|
|
|
/* SRAM: 0x8000_0000 - 0x803F_FFFF and 0xA000_0000 - 0xA03F_FFFF */
|
/* SRAM: 0x8000_0000 - 0x803F_FFFF and 0xA000_0000 - 0xA03F_FFFF */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
0x80000000,
|
0x80000000,
|
4 * 1024 * 1024, /* 4 MB */
|
4 * 1024 * 1024, /* 4 MB */
|
0xA0000000);
|
0xA0000000);
|
|
|
/* DRAM: 0x8800_0000 - 0x89FF_FFFF and 0xA800_0000 - 0xA9FF_FFFF */
|
/* DRAM: 0x8800_0000 - 0x89FF_FFFF and 0xA800_0000 - 0xA9FF_FFFF */
|
for (i=0; i<8; i++) /* 32 MB total */
|
for (i=0; i<8; i++) /* 32 MB total */
|
{
|
{
|
unsigned size = 4 * 1024 * 1024; /* 4 MB */
|
unsigned size = 4 * 1024 * 1024; /* 4 MB */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx,0x%0x",
|
0x88000000 + (i * size),
|
0x88000000 + (i * size),
|
size,
|
size,
|
0xA8000000 + (i * size));
|
0xA8000000 + (i * size));
|
}
|
}
|
|
|
/* Dummy memory regions for unsimulated devices - sorted by address */
|
/* Dummy memory regions for unsimulated devices - sorted by address */
|
|
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB1000000, 0x400); /* ISA I/O */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB1000000, 0x400); /* ISA I/O */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2100000, 0x004); /* ISA ctl */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2100000, 0x004); /* ISA ctl */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2500000, 0x004); /* LED/switch */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2500000, 0x004); /* LED/switch */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2700000, 0x004); /* RTC */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB2700000, 0x004); /* RTC */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB3C00000, 0x004); /* RTC */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xB3C00000, 0x004); /* RTC */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFF8000, 0x900); /* DRAMC */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFF8000, 0x900); /* DRAMC */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFF9000, 0x200); /* EBIF */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFF9000, 0x200); /* EBIF */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFFE000, 0x01c); /* EBIF */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFFE000, 0x01c); /* EBIF */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFFF500, 0x300); /* PIO */
|
sim_do_commandf (sd, "memory alias 0x%lx@1,0x%lx", 0xFFFFF500, 0x300); /* PIO */
|
|
|
|
|
/* --- simulated devices --- */
|
/* --- simulated devices --- */
|
sim_hw_parse (sd, "/tx3904irc@0xffffc000/reg 0xffffc000 0x20");
|
sim_hw_parse (sd, "/tx3904irc@0xffffc000/reg 0xffffc000 0x20");
|
sim_hw_parse (sd, "/tx3904cpu");
|
sim_hw_parse (sd, "/tx3904cpu");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff000/reg 0xfffff000 0x100");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff000/reg 0xfffff000 0x100");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff100/reg 0xfffff100 0x100");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff100/reg 0xfffff100 0x100");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff200/reg 0xfffff200 0x100");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff200/reg 0xfffff200 0x100");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff300/reg 0xfffff300 0x100");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff300/reg 0xfffff300 0x100");
|
{
|
{
|
/* FIXME: poking at dv-sockser internals, use tcp backend if
|
/* FIXME: poking at dv-sockser internals, use tcp backend if
|
--sockser_addr option was given.*/
|
--sockser_addr option was given.*/
|
extern char* sockser_addr;
|
extern char* sockser_addr;
|
if(sockser_addr == NULL)
|
if(sockser_addr == NULL)
|
sim_hw_parse (sd, "/tx3904sio@0xfffff300/backend stdio");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff300/backend stdio");
|
else
|
else
|
sim_hw_parse (sd, "/tx3904sio@0xfffff300/backend tcp");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff300/backend tcp");
|
}
|
}
|
sim_hw_parse (sd, "/tx3904sio@0xfffff400/reg 0xfffff400 0x100");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff400/reg 0xfffff400 0x100");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff400/backend stdio");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff400/backend stdio");
|
|
|
/* -- device connections --- */
|
/* -- device connections --- */
|
sim_hw_parse (sd, "/tx3904irc > ip level /tx3904cpu");
|
sim_hw_parse (sd, "/tx3904irc > ip level /tx3904cpu");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff000 > int tmr0 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff000 > int tmr0 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff100 > int tmr1 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff100 > int tmr1 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff200 > int tmr2 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904tmr@0xfffff200 > int tmr2 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff300 > int sio0 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff300 > int sio0 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff400 > int sio1 /tx3904irc");
|
sim_hw_parse (sd, "/tx3904sio@0xfffff400 > int sio1 /tx3904irc");
|
|
|
/* add PAL timer & I/O module */
|
/* add PAL timer & I/O module */
|
if(! strcmp(board, BOARD_JMR3904_PAL))
|
if(! strcmp(board, BOARD_JMR3904_PAL))
|
{
|
{
|
/* the device */
|
/* the device */
|
sim_hw_parse (sd, "/pal@0xffff0000");
|
sim_hw_parse (sd, "/pal@0xffff0000");
|
sim_hw_parse (sd, "/pal@0xffff0000/reg 0xffff0000 64");
|
sim_hw_parse (sd, "/pal@0xffff0000/reg 0xffff0000 64");
|
|
|
/* wire up interrupt ports to irc */
|
/* wire up interrupt ports to irc */
|
sim_hw_parse (sd, "/pal@0x31000000 > countdown tmr0 /tx3904irc");
|
sim_hw_parse (sd, "/pal@0x31000000 > countdown tmr0 /tx3904irc");
|
sim_hw_parse (sd, "/pal@0x31000000 > timer tmr1 /tx3904irc");
|
sim_hw_parse (sd, "/pal@0x31000000 > timer tmr1 /tx3904irc");
|
sim_hw_parse (sd, "/pal@0x31000000 > int int0 /tx3904irc");
|
sim_hw_parse (sd, "/pal@0x31000000 > int int0 /tx3904irc");
|
}
|
}
|
|
|
if(! strcmp(board, BOARD_JMR3904_DEBUG))
|
if(! strcmp(board, BOARD_JMR3904_DEBUG))
|
{
|
{
|
/* -- DEBUG: glue interrupt generators --- */
|
/* -- DEBUG: glue interrupt generators --- */
|
sim_hw_parse (sd, "/glue@0xffff0000/reg 0xffff0000 0x50");
|
sim_hw_parse (sd, "/glue@0xffff0000/reg 0xffff0000 0x50");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int0 int0 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int0 int0 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int1 int1 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int1 int1 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int2 int2 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int2 int2 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int3 int3 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int3 int3 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int4 int4 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int4 int4 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int5 int5 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int5 int5 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int6 int6 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int6 int6 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int7 int7 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int7 int7 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int8 dmac0 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int8 dmac0 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int9 dmac1 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int9 dmac1 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int10 dmac2 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int10 dmac2 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int11 dmac3 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int11 dmac3 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int12 sio0 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int12 sio0 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int13 sio1 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int13 sio1 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int14 tmr0 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int14 tmr0 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int15 tmr1 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int15 tmr1 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int16 tmr2 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int16 tmr2 /tx3904irc");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int17 nmi /tx3904cpu");
|
sim_hw_parse (sd, "/glue@0xffff0000 > int17 nmi /tx3904cpu");
|
}
|
}
|
|
|
device_init(sd);
|
device_init(sd);
|
}
|
}
|
#endif
|
#endif
|
|
|
|
|
/* check for/establish the a reference program image */
|
/* check for/establish the a reference program image */
|
if (sim_analyze_program (sd,
|
if (sim_analyze_program (sd,
|
(STATE_PROG_ARGV (sd) != NULL
|
(STATE_PROG_ARGV (sd) != NULL
|
? *STATE_PROG_ARGV (sd)
|
? *STATE_PROG_ARGV (sd)
|
: NULL),
|
: NULL),
|
abfd) != SIM_RC_OK)
|
abfd) != SIM_RC_OK)
|
{
|
{
|
sim_module_uninstall (sd);
|
sim_module_uninstall (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Configure/verify the target byte order and other runtime
|
/* Configure/verify the target byte order and other runtime
|
configuration options */
|
configuration options */
|
if (sim_config (sd) != SIM_RC_OK)
|
if (sim_config (sd) != SIM_RC_OK)
|
{
|
{
|
sim_module_uninstall (sd);
|
sim_module_uninstall (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (sim_post_argv_init (sd) != SIM_RC_OK)
|
if (sim_post_argv_init (sd) != SIM_RC_OK)
|
{
|
{
|
/* Uninstall the modules to avoid memory leaks,
|
/* Uninstall the modules to avoid memory leaks,
|
file descriptor leaks, etc. */
|
file descriptor leaks, etc. */
|
sim_module_uninstall (sd);
|
sim_module_uninstall (sd);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* verify assumptions the simulator made about the host type system.
|
/* verify assumptions the simulator made about the host type system.
|
This macro does not return if there is a problem */
|
This macro does not return if there is a problem */
|
SIM_ASSERT (sizeof(int) == (4 * sizeof(char)));
|
SIM_ASSERT (sizeof(int) == (4 * sizeof(char)));
|
SIM_ASSERT (sizeof(word64) == (8 * sizeof(char)));
|
SIM_ASSERT (sizeof(word64) == (8 * sizeof(char)));
|
|
|
/* This is NASTY, in that we are assuming the size of specific
|
/* This is NASTY, in that we are assuming the size of specific
|
registers: */
|
registers: */
|
{
|
{
|
int rn;
|
int rn;
|
for (rn = 0; (rn < (LAST_EMBED_REGNUM + 1)); rn++)
|
for (rn = 0; (rn < (LAST_EMBED_REGNUM + 1)); rn++)
|
{
|
{
|
if (rn < 32)
|
if (rn < 32)
|
cpu->register_widths[rn] = WITH_TARGET_WORD_BITSIZE;
|
cpu->register_widths[rn] = WITH_TARGET_WORD_BITSIZE;
|
else if ((rn >= FGRIDX) && (rn < (FGRIDX + NR_FGR)))
|
else if ((rn >= FGRIDX) && (rn < (FGRIDX + NR_FGR)))
|
cpu->register_widths[rn] = WITH_TARGET_FLOATING_POINT_BITSIZE;
|
cpu->register_widths[rn] = WITH_TARGET_FLOATING_POINT_BITSIZE;
|
else if ((rn >= 33) && (rn <= 37))
|
else if ((rn >= 33) && (rn <= 37))
|
cpu->register_widths[rn] = WITH_TARGET_WORD_BITSIZE;
|
cpu->register_widths[rn] = WITH_TARGET_WORD_BITSIZE;
|
else if ((rn == SRIDX)
|
else if ((rn == SRIDX)
|
|| (rn == FCR0IDX)
|
|| (rn == FCR0IDX)
|
|| (rn == FCR31IDX)
|
|| (rn == FCR31IDX)
|
|| ((rn >= 72) && (rn <= 89)))
|
|| ((rn >= 72) && (rn <= 89)))
|
cpu->register_widths[rn] = 32;
|
cpu->register_widths[rn] = 32;
|
else
|
else
|
cpu->register_widths[rn] = 0;
|
cpu->register_widths[rn] = 0;
|
}
|
}
|
|
|
|
|
}
|
}
|
|
|
#if defined(TRACE)
|
#if defined(TRACE)
|
if (STATE & simTRACE)
|
if (STATE & simTRACE)
|
open_trace(sd);
|
open_trace(sd);
|
#endif /* TRACE */
|
#endif /* TRACE */
|
|
|
/*
|
/*
|
sim_io_eprintf (sd, "idt@%x pmon@%x lsipmon@%x\n",
|
sim_io_eprintf (sd, "idt@%x pmon@%x lsipmon@%x\n",
|
idt_monitor_base,
|
idt_monitor_base,
|
pmon_monitor_base,
|
pmon_monitor_base,
|
lsipmon_monitor_base);
|
lsipmon_monitor_base);
|
*/
|
*/
|
|
|
/* Write the monitor trap address handlers into the monitor (eeprom)
|
/* Write the monitor trap address handlers into the monitor (eeprom)
|
address space. This can only be done once the target endianness
|
address space. This can only be done once the target endianness
|
has been determined. */
|
has been determined. */
|
if (idt_monitor_base != 0)
|
if (idt_monitor_base != 0)
|
{
|
{
|
unsigned loop;
|
unsigned loop;
|
unsigned idt_monitor_size = 1 << 11;
|
unsigned idt_monitor_size = 1 << 11;
|
|
|
/* the default monitor region */
|
/* the default monitor region */
|
sim_do_commandf (sd, "memory region 0x%x,0x%x",
|
sim_do_commandf (sd, "memory region 0x%x,0x%x",
|
idt_monitor_base, idt_monitor_size);
|
idt_monitor_base, idt_monitor_size);
|
|
|
/* Entry into the IDT monitor is via fixed address vectors, and
|
/* Entry into the IDT monitor is via fixed address vectors, and
|
not using machine instructions. To avoid clashing with use of
|
not using machine instructions. To avoid clashing with use of
|
the MIPS TRAP system, we place our own (simulator specific)
|
the MIPS TRAP system, we place our own (simulator specific)
|
"undefined" instructions into the relevant vector slots. */
|
"undefined" instructions into the relevant vector slots. */
|
for (loop = 0; (loop < idt_monitor_size); loop += 4)
|
for (loop = 0; (loop < idt_monitor_size); loop += 4)
|
{
|
{
|
address_word vaddr = (idt_monitor_base + loop);
|
address_word vaddr = (idt_monitor_base + loop);
|
unsigned32 insn = (RSVD_INSTRUCTION |
|
unsigned32 insn = (RSVD_INSTRUCTION |
|
(((loop >> 2) & RSVD_INSTRUCTION_ARG_MASK)
|
(((loop >> 2) & RSVD_INSTRUCTION_ARG_MASK)
|
<< RSVD_INSTRUCTION_ARG_SHIFT));
|
<< RSVD_INSTRUCTION_ARG_SHIFT));
|
H2T (insn);
|
H2T (insn);
|
sim_write (sd, vaddr, (char *)&insn, sizeof (insn));
|
sim_write (sd, vaddr, (char *)&insn, sizeof (insn));
|
}
|
}
|
}
|
}
|
|
|
if ((pmon_monitor_base != 0) || (lsipmon_monitor_base != 0))
|
if ((pmon_monitor_base != 0) || (lsipmon_monitor_base != 0))
|
{
|
{
|
/* The PMON monitor uses the same address space, but rather than
|
/* The PMON monitor uses the same address space, but rather than
|
branching into it the address of a routine is loaded. We can
|
branching into it the address of a routine is loaded. We can
|
cheat for the moment, and direct the PMON routine to IDT style
|
cheat for the moment, and direct the PMON routine to IDT style
|
instructions within the monitor space. This relies on the IDT
|
instructions within the monitor space. This relies on the IDT
|
monitor not using the locations from 0xBFC00500 onwards as its
|
monitor not using the locations from 0xBFC00500 onwards as its
|
entry points.*/
|
entry points.*/
|
unsigned loop;
|
unsigned loop;
|
for (loop = 0; (loop < 24); loop++)
|
for (loop = 0; (loop < 24); loop++)
|
{
|
{
|
unsigned32 value = ((0x500 - 8) / 8); /* default UNDEFINED reason code */
|
unsigned32 value = ((0x500 - 8) / 8); /* default UNDEFINED reason code */
|
switch (loop)
|
switch (loop)
|
{
|
{
|
case 0: /* read */
|
case 0: /* read */
|
value = 7;
|
value = 7;
|
break;
|
break;
|
case 1: /* write */
|
case 1: /* write */
|
value = 8;
|
value = 8;
|
break;
|
break;
|
case 2: /* open */
|
case 2: /* open */
|
value = 6;
|
value = 6;
|
break;
|
break;
|
case 3: /* close */
|
case 3: /* close */
|
value = 10;
|
value = 10;
|
break;
|
break;
|
case 5: /* printf */
|
case 5: /* printf */
|
value = ((0x500 - 16) / 8); /* not an IDT reason code */
|
value = ((0x500 - 16) / 8); /* not an IDT reason code */
|
break;
|
break;
|
case 8: /* cliexit */
|
case 8: /* cliexit */
|
value = 17;
|
value = 17;
|
break;
|
break;
|
case 11: /* flush_cache */
|
case 11: /* flush_cache */
|
value = 28;
|
value = 28;
|
break;
|
break;
|
}
|
}
|
|
|
SIM_ASSERT (idt_monitor_base != 0);
|
SIM_ASSERT (idt_monitor_base != 0);
|
value = ((unsigned int) idt_monitor_base + (value * 8));
|
value = ((unsigned int) idt_monitor_base + (value * 8));
|
H2T (value);
|
H2T (value);
|
|
|
if (pmon_monitor_base != 0)
|
if (pmon_monitor_base != 0)
|
{
|
{
|
address_word vaddr = (pmon_monitor_base + (loop * 4));
|
address_word vaddr = (pmon_monitor_base + (loop * 4));
|
sim_write (sd, vaddr, (char *)&value, sizeof (value));
|
sim_write (sd, vaddr, (char *)&value, sizeof (value));
|
}
|
}
|
|
|
if (lsipmon_monitor_base != 0)
|
if (lsipmon_monitor_base != 0)
|
{
|
{
|
address_word vaddr = (lsipmon_monitor_base + (loop * 4));
|
address_word vaddr = (lsipmon_monitor_base + (loop * 4));
|
sim_write (sd, vaddr, (char *)&value, sizeof (value));
|
sim_write (sd, vaddr, (char *)&value, sizeof (value));
|
}
|
}
|
}
|
}
|
|
|
/* Write an abort sequence into the TRAP (common) exception vector
|
/* Write an abort sequence into the TRAP (common) exception vector
|
addresses. This is to catch code executing a TRAP (et.al.)
|
addresses. This is to catch code executing a TRAP (et.al.)
|
instruction without installing a trap handler. */
|
instruction without installing a trap handler. */
|
if ((idt_monitor_base != 0) ||
|
if ((idt_monitor_base != 0) ||
|
(pmon_monitor_base != 0) ||
|
(pmon_monitor_base != 0) ||
|
(lsipmon_monitor_base != 0))
|
(lsipmon_monitor_base != 0))
|
{
|
{
|
unsigned32 halt[2] = { 0x2404002f /* addiu r4, r0, 47 */,
|
unsigned32 halt[2] = { 0x2404002f /* addiu r4, r0, 47 */,
|
HALT_INSTRUCTION /* BREAK */ };
|
HALT_INSTRUCTION /* BREAK */ };
|
H2T (halt[0]);
|
H2T (halt[0]);
|
H2T (halt[1]);
|
H2T (halt[1]);
|
sim_write (sd, 0x80000000, (char *) halt, sizeof (halt));
|
sim_write (sd, 0x80000000, (char *) halt, sizeof (halt));
|
sim_write (sd, 0x80000180, (char *) halt, sizeof (halt));
|
sim_write (sd, 0x80000180, (char *) halt, sizeof (halt));
|
sim_write (sd, 0x80000200, (char *) halt, sizeof (halt));
|
sim_write (sd, 0x80000200, (char *) halt, sizeof (halt));
|
/* XXX: Write here unconditionally? */
|
/* XXX: Write here unconditionally? */
|
sim_write (sd, 0xBFC00200, (char *) halt, sizeof (halt));
|
sim_write (sd, 0xBFC00200, (char *) halt, sizeof (halt));
|
sim_write (sd, 0xBFC00380, (char *) halt, sizeof (halt));
|
sim_write (sd, 0xBFC00380, (char *) halt, sizeof (halt));
|
sim_write (sd, 0xBFC00400, (char *) halt, sizeof (halt));
|
sim_write (sd, 0xBFC00400, (char *) halt, sizeof (halt));
|
}
|
}
|
}
|
}
|
|
|
|
|
|
|
return sd;
|
return sd;
|
}
|
}
|
|
|
#if defined(TRACE)
|
#if defined(TRACE)
|
static void
|
static void
|
open_trace(sd)
|
open_trace(sd)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
{
|
{
|
tracefh = fopen(tracefile,"wb+");
|
tracefh = fopen(tracefile,"wb+");
|
if (tracefh == NULL)
|
if (tracefh == NULL)
|
{
|
{
|
sim_io_eprintf(sd,"Failed to create file \"%s\", writing trace information to stderr.\n",tracefile);
|
sim_io_eprintf(sd,"Failed to create file \"%s\", writing trace information to stderr.\n",tracefile);
|
tracefh = stderr;
|
tracefh = stderr;
|
}
|
}
|
}
|
}
|
#endif /* TRACE */
|
#endif /* TRACE */
|
|
|
/* Return name of an insn, used by insn profiling. */
|
/* Return name of an insn, used by insn profiling. */
|
static const char *
|
static const char *
|
get_insn_name (sim_cpu *cpu, int i)
|
get_insn_name (sim_cpu *cpu, int i)
|
{
|
{
|
return itable[i].name;
|
return itable[i].name;
|
}
|
}
|
|
|
void
|
void
|
sim_close (sd, quitting)
|
sim_close (sd, quitting)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
int quitting;
|
int quitting;
|
{
|
{
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: sim_close: entered (quitting = %d)\n",quitting);
|
printf("DBG: sim_close: entered (quitting = %d)\n",quitting);
|
#endif
|
#endif
|
|
|
|
|
/* "quitting" is non-zero if we cannot hang on errors */
|
/* "quitting" is non-zero if we cannot hang on errors */
|
|
|
/* shut down modules */
|
/* shut down modules */
|
sim_module_uninstall (sd);
|
sim_module_uninstall (sd);
|
|
|
/* Ensure that any resources allocated through the callback
|
/* Ensure that any resources allocated through the callback
|
mechanism are released: */
|
mechanism are released: */
|
sim_io_shutdown (sd);
|
sim_io_shutdown (sd);
|
|
|
#if defined(TRACE)
|
#if defined(TRACE)
|
if (tracefh != NULL && tracefh != stderr)
|
if (tracefh != NULL && tracefh != stderr)
|
fclose(tracefh);
|
fclose(tracefh);
|
tracefh = NULL;
|
tracefh = NULL;
|
#endif /* TRACE */
|
#endif /* TRACE */
|
|
|
/* FIXME - free SD */
|
/* FIXME - free SD */
|
|
|
return;
|
return;
|
}
|
}
|
|
|
|
|
int
|
int
|
sim_write (sd,addr,buffer,size)
|
sim_write (sd,addr,buffer,size)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
SIM_ADDR addr;
|
SIM_ADDR addr;
|
unsigned char *buffer;
|
unsigned char *buffer;
|
int size;
|
int size;
|
{
|
{
|
int index;
|
int index;
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
|
|
/* Return the number of bytes written, or zero if error. */
|
/* Return the number of bytes written, or zero if error. */
|
#ifdef DEBUG
|
#ifdef DEBUG
|
sim_io_printf(sd,"sim_write(0x%s,buffer,%d);\n",pr_addr(addr),size);
|
sim_io_printf(sd,"sim_write(0x%s,buffer,%d);\n",pr_addr(addr),size);
|
#endif
|
#endif
|
|
|
/* We use raw read and write routines, since we do not want to count
|
/* We use raw read and write routines, since we do not want to count
|
the GDB memory accesses in our statistics gathering. */
|
the GDB memory accesses in our statistics gathering. */
|
|
|
for (index = 0; index < size; index++)
|
for (index = 0; index < size; index++)
|
{
|
{
|
address_word vaddr = (address_word)addr + index;
|
address_word vaddr = (address_word)addr + index;
|
address_word paddr;
|
address_word paddr;
|
int cca;
|
int cca;
|
if (!address_translation (SD, CPU, NULL_CIA, vaddr, isDATA, isSTORE, &paddr, &cca, isRAW))
|
if (!address_translation (SD, CPU, NULL_CIA, vaddr, isDATA, isSTORE, &paddr, &cca, isRAW))
|
break;
|
break;
|
if (sim_core_write_buffer (SD, CPU, read_map, buffer + index, paddr, 1) != 1)
|
if (sim_core_write_buffer (SD, CPU, read_map, buffer + index, paddr, 1) != 1)
|
break;
|
break;
|
}
|
}
|
|
|
return(index);
|
return(index);
|
}
|
}
|
|
|
int
|
int
|
sim_read (sd,addr,buffer,size)
|
sim_read (sd,addr,buffer,size)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
SIM_ADDR addr;
|
SIM_ADDR addr;
|
unsigned char *buffer;
|
unsigned char *buffer;
|
int size;
|
int size;
|
{
|
{
|
int index;
|
int index;
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
|
|
/* Return the number of bytes read, or zero if error. */
|
/* Return the number of bytes read, or zero if error. */
|
#ifdef DEBUG
|
#ifdef DEBUG
|
sim_io_printf(sd,"sim_read(0x%s,buffer,%d);\n",pr_addr(addr),size);
|
sim_io_printf(sd,"sim_read(0x%s,buffer,%d);\n",pr_addr(addr),size);
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
for (index = 0; (index < size); index++)
|
for (index = 0; (index < size); index++)
|
{
|
{
|
address_word vaddr = (address_word)addr + index;
|
address_word vaddr = (address_word)addr + index;
|
address_word paddr;
|
address_word paddr;
|
int cca;
|
int cca;
|
if (!address_translation (SD, CPU, NULL_CIA, vaddr, isDATA, isLOAD, &paddr, &cca, isRAW))
|
if (!address_translation (SD, CPU, NULL_CIA, vaddr, isDATA, isLOAD, &paddr, &cca, isRAW))
|
break;
|
break;
|
if (sim_core_read_buffer (SD, CPU, read_map, buffer + index, paddr, 1) != 1)
|
if (sim_core_read_buffer (SD, CPU, read_map, buffer + index, paddr, 1) != 1)
|
break;
|
break;
|
}
|
}
|
|
|
return(index);
|
return(index);
|
}
|
}
|
|
|
int
|
int
|
sim_store_register (sd,rn,memory,length)
|
sim_store_register (sd,rn,memory,length)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
int rn;
|
int rn;
|
unsigned char *memory;
|
unsigned char *memory;
|
int length;
|
int length;
|
{
|
{
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
/* NOTE: gdb (the client) stores registers in target byte order
|
/* NOTE: gdb (the client) stores registers in target byte order
|
while the simulator uses host byte order */
|
while the simulator uses host byte order */
|
#ifdef DEBUG
|
#ifdef DEBUG
|
sim_io_printf(sd,"sim_store_register(%d,*memory=0x%s);\n",rn,pr_addr(*((SIM_ADDR *)memory)));
|
sim_io_printf(sd,"sim_store_register(%d,*memory=0x%s);\n",rn,pr_addr(*((SIM_ADDR *)memory)));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* Unfortunately this suffers from the same problem as the register
|
/* Unfortunately this suffers from the same problem as the register
|
numbering one. We need to know what the width of each logical
|
numbering one. We need to know what the width of each logical
|
register number is for the architecture being simulated. */
|
register number is for the architecture being simulated. */
|
|
|
if (cpu->register_widths[rn] == 0)
|
if (cpu->register_widths[rn] == 0)
|
{
|
{
|
sim_io_eprintf(sd,"Invalid register width for %d (register store ignored)\n",rn);
|
sim_io_eprintf(sd,"Invalid register width for %d (register store ignored)\n",rn);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
|
|
if (rn >= FGRIDX && rn < FGRIDX + NR_FGR)
|
if (rn >= FGRIDX && rn < FGRIDX + NR_FGR)
|
{
|
{
|
cpu->fpr_state[rn - FGRIDX] = fmt_uninterpreted;
|
cpu->fpr_state[rn - FGRIDX] = fmt_uninterpreted;
|
if (cpu->register_widths[rn] == 32)
|
if (cpu->register_widths[rn] == 32)
|
{
|
{
|
if (length == 8)
|
if (length == 8)
|
{
|
{
|
cpu->fgr[rn - FGRIDX] =
|
cpu->fgr[rn - FGRIDX] =
|
(unsigned32) T2H_8 (*(unsigned64*)memory);
|
(unsigned32) T2H_8 (*(unsigned64*)memory);
|
return 8;
|
return 8;
|
}
|
}
|
else
|
else
|
{
|
{
|
cpu->fgr[rn - FGRIDX] = T2H_4 (*(unsigned32*)memory);
|
cpu->fgr[rn - FGRIDX] = T2H_4 (*(unsigned32*)memory);
|
return 4;
|
return 4;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
cpu->fgr[rn - FGRIDX] = T2H_8 (*(unsigned64*)memory);
|
cpu->fgr[rn - FGRIDX] = T2H_8 (*(unsigned64*)memory);
|
return 8;
|
return 8;
|
}
|
}
|
}
|
}
|
|
|
if (cpu->register_widths[rn] == 32)
|
if (cpu->register_widths[rn] == 32)
|
{
|
{
|
if (length == 8)
|
if (length == 8)
|
{
|
{
|
cpu->registers[rn] =
|
cpu->registers[rn] =
|
(unsigned32) T2H_8 (*(unsigned64*)memory);
|
(unsigned32) T2H_8 (*(unsigned64*)memory);
|
return 8;
|
return 8;
|
}
|
}
|
else
|
else
|
{
|
{
|
cpu->registers[rn] = T2H_4 (*(unsigned32*)memory);
|
cpu->registers[rn] = T2H_4 (*(unsigned32*)memory);
|
return 4;
|
return 4;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
cpu->registers[rn] = T2H_8 (*(unsigned64*)memory);
|
cpu->registers[rn] = T2H_8 (*(unsigned64*)memory);
|
return 8;
|
return 8;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
sim_fetch_register (sd,rn,memory,length)
|
sim_fetch_register (sd,rn,memory,length)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
int rn;
|
int rn;
|
unsigned char *memory;
|
unsigned char *memory;
|
int length;
|
int length;
|
{
|
{
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
sim_cpu *cpu = STATE_CPU (sd, 0); /* FIXME */
|
/* NOTE: gdb (the client) stores registers in target byte order
|
/* NOTE: gdb (the client) stores registers in target byte order
|
while the simulator uses host byte order */
|
while the simulator uses host byte order */
|
#ifdef DEBUG
|
#ifdef DEBUG
|
#if 0 /* FIXME: doesn't compile */
|
#if 0 /* FIXME: doesn't compile */
|
sim_io_printf(sd,"sim_fetch_register(%d=0x%s,mem) : place simulator registers into memory\n",rn,pr_addr(registers[rn]));
|
sim_io_printf(sd,"sim_fetch_register(%d=0x%s,mem) : place simulator registers into memory\n",rn,pr_addr(registers[rn]));
|
#endif
|
#endif
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
if (cpu->register_widths[rn] == 0)
|
if (cpu->register_widths[rn] == 0)
|
{
|
{
|
sim_io_eprintf (sd, "Invalid register width for %d (register fetch ignored)\n",rn);
|
sim_io_eprintf (sd, "Invalid register width for %d (register fetch ignored)\n",rn);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
|
|
/* Any floating point register */
|
/* Any floating point register */
|
if (rn >= FGRIDX && rn < FGRIDX + NR_FGR)
|
if (rn >= FGRIDX && rn < FGRIDX + NR_FGR)
|
{
|
{
|
if (cpu->register_widths[rn] == 32)
|
if (cpu->register_widths[rn] == 32)
|
{
|
{
|
if (length == 8)
|
if (length == 8)
|
{
|
{
|
*(unsigned64*)memory =
|
*(unsigned64*)memory =
|
H2T_8 ((unsigned32) (cpu->fgr[rn - FGRIDX]));
|
H2T_8 ((unsigned32) (cpu->fgr[rn - FGRIDX]));
|
return 8;
|
return 8;
|
}
|
}
|
else
|
else
|
{
|
{
|
*(unsigned32*)memory = H2T_4 (cpu->fgr[rn - FGRIDX]);
|
*(unsigned32*)memory = H2T_4 (cpu->fgr[rn - FGRIDX]);
|
return 4;
|
return 4;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
*(unsigned64*)memory = H2T_8 (cpu->fgr[rn - FGRIDX]);
|
*(unsigned64*)memory = H2T_8 (cpu->fgr[rn - FGRIDX]);
|
return 8;
|
return 8;
|
}
|
}
|
}
|
}
|
|
|
if (cpu->register_widths[rn] == 32)
|
if (cpu->register_widths[rn] == 32)
|
{
|
{
|
if (length == 8)
|
if (length == 8)
|
{
|
{
|
*(unsigned64*)memory =
|
*(unsigned64*)memory =
|
H2T_8 ((unsigned32) (cpu->registers[rn]));
|
H2T_8 ((unsigned32) (cpu->registers[rn]));
|
return 8;
|
return 8;
|
}
|
}
|
else
|
else
|
{
|
{
|
*(unsigned32*)memory = H2T_4 ((unsigned32)(cpu->registers[rn]));
|
*(unsigned32*)memory = H2T_4 ((unsigned32)(cpu->registers[rn]));
|
return 4;
|
return 4;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
*(unsigned64*)memory = H2T_8 ((unsigned64)(cpu->registers[rn]));
|
*(unsigned64*)memory = H2T_8 ((unsigned64)(cpu->registers[rn]));
|
return 8;
|
return 8;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
SIM_RC
|
SIM_RC
|
sim_create_inferior (sd, abfd, argv,env)
|
sim_create_inferior (sd, abfd, argv,env)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
struct _bfd *abfd;
|
struct _bfd *abfd;
|
char **argv;
|
char **argv;
|
char **env;
|
char **env;
|
{
|
{
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
#if 0 /* FIXME: doesn't compile */
|
#if 0 /* FIXME: doesn't compile */
|
printf("DBG: sim_create_inferior entered: start_address = 0x%s\n",
|
printf("DBG: sim_create_inferior entered: start_address = 0x%s\n",
|
pr_addr(PC));
|
pr_addr(PC));
|
#endif
|
#endif
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
ColdReset(sd);
|
ColdReset(sd);
|
|
|
if (abfd != NULL)
|
if (abfd != NULL)
|
{
|
{
|
/* override PC value set by ColdReset () */
|
/* override PC value set by ColdReset () */
|
int cpu_nr;
|
int cpu_nr;
|
for (cpu_nr = 0; cpu_nr < sim_engine_nr_cpus (sd); cpu_nr++)
|
for (cpu_nr = 0; cpu_nr < sim_engine_nr_cpus (sd); cpu_nr++)
|
{
|
{
|
sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
|
sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
|
CIA_SET (cpu, (unsigned64) bfd_get_start_address (abfd));
|
CIA_SET (cpu, (unsigned64) bfd_get_start_address (abfd));
|
}
|
}
|
}
|
}
|
|
|
#if 0 /* def DEBUG */
|
#if 0 /* def DEBUG */
|
if (argv || env)
|
if (argv || env)
|
{
|
{
|
/* We should really place the argv slot values into the argument
|
/* We should really place the argv slot values into the argument
|
registers, and onto the stack as required. However, this
|
registers, and onto the stack as required. However, this
|
assumes that we have a stack defined, which is not
|
assumes that we have a stack defined, which is not
|
necessarily true at the moment. */
|
necessarily true at the moment. */
|
char **cptr;
|
char **cptr;
|
sim_io_printf(sd,"sim_create_inferior() : passed arguments ignored\n");
|
sim_io_printf(sd,"sim_create_inferior() : passed arguments ignored\n");
|
for (cptr = argv; (cptr && *cptr); cptr++)
|
for (cptr = argv; (cptr && *cptr); cptr++)
|
printf("DBG: arg \"%s\"\n",*cptr);
|
printf("DBG: arg \"%s\"\n",*cptr);
|
}
|
}
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
}
|
}
|
|
|
void
|
void
|
sim_do_command (sd,cmd)
|
sim_do_command (sd,cmd)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
char *cmd;
|
char *cmd;
|
{
|
{
|
if (sim_args_command (sd, cmd) != SIM_RC_OK)
|
if (sim_args_command (sd, cmd) != SIM_RC_OK)
|
sim_io_printf (sd, "Error: \"%s\" is not a valid MIPS simulator command.\n",
|
sim_io_printf (sd, "Error: \"%s\" is not a valid MIPS simulator command.\n",
|
cmd);
|
cmd);
|
}
|
}
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*-- Private simulator support interface ------------------------------------*/
|
/*-- Private simulator support interface ------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
|
|
/* Read a null terminated string from memory, return in a buffer */
|
/* Read a null terminated string from memory, return in a buffer */
|
static char *
|
static char *
|
fetch_str (SIM_DESC sd,
|
fetch_str (SIM_DESC sd,
|
address_word addr)
|
address_word addr)
|
{
|
{
|
char *buf;
|
char *buf;
|
int nr = 0;
|
int nr = 0;
|
char null;
|
char null;
|
while (sim_read (sd, addr + nr, &null, 1) == 1 && null != 0)
|
while (sim_read (sd, addr + nr, &null, 1) == 1 && null != 0)
|
nr++;
|
nr++;
|
buf = NZALLOC (char, nr + 1);
|
buf = NZALLOC (char, nr + 1);
|
sim_read (sd, addr, buf, nr);
|
sim_read (sd, addr, buf, nr);
|
return buf;
|
return buf;
|
}
|
}
|
|
|
|
|
/* Implements the "sim firmware" command:
|
/* Implements the "sim firmware" command:
|
sim firmware NAME[@ADDRESS] --- emulate ROM monitor named NAME.
|
sim firmware NAME[@ADDRESS] --- emulate ROM monitor named NAME.
|
NAME can be idt, pmon, or lsipmon. If omitted, ADDRESS
|
NAME can be idt, pmon, or lsipmon. If omitted, ADDRESS
|
defaults to the normal address for that monitor.
|
defaults to the normal address for that monitor.
|
sim firmware none --- don't emulate any ROM monitor. Useful
|
sim firmware none --- don't emulate any ROM monitor. Useful
|
if you need a clean address space. */
|
if you need a clean address space. */
|
static SIM_RC
|
static SIM_RC
|
sim_firmware_command (SIM_DESC sd, char *arg)
|
sim_firmware_command (SIM_DESC sd, char *arg)
|
{
|
{
|
int address_present = 0;
|
int address_present = 0;
|
SIM_ADDR address;
|
SIM_ADDR address;
|
|
|
/* Signal occurrence of this option. */
|
/* Signal occurrence of this option. */
|
firmware_option_p = 1;
|
firmware_option_p = 1;
|
|
|
/* Parse out the address, if present. */
|
/* Parse out the address, if present. */
|
{
|
{
|
char *p = strchr (arg, '@');
|
char *p = strchr (arg, '@');
|
if (p)
|
if (p)
|
{
|
{
|
char *q;
|
char *q;
|
address_present = 1;
|
address_present = 1;
|
p ++; /* skip over @ */
|
p ++; /* skip over @ */
|
|
|
address = strtoul (p, &q, 0);
|
address = strtoul (p, &q, 0);
|
if (*q != '\0')
|
if (*q != '\0')
|
{
|
{
|
sim_io_printf (sd, "Invalid address given to the"
|
sim_io_printf (sd, "Invalid address given to the"
|
"`sim firmware NAME@ADDRESS' command: %s\n",
|
"`sim firmware NAME@ADDRESS' command: %s\n",
|
p);
|
p);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
}
|
}
|
else
|
else
|
address_present = 0;
|
address_present = 0;
|
}
|
}
|
|
|
if (! strncmp (arg, "idt", 3))
|
if (! strncmp (arg, "idt", 3))
|
{
|
{
|
idt_monitor_base = address_present ? address : 0xBFC00000;
|
idt_monitor_base = address_present ? address : 0xBFC00000;
|
pmon_monitor_base = 0;
|
pmon_monitor_base = 0;
|
lsipmon_monitor_base = 0;
|
lsipmon_monitor_base = 0;
|
}
|
}
|
else if (! strncmp (arg, "pmon", 4))
|
else if (! strncmp (arg, "pmon", 4))
|
{
|
{
|
/* pmon uses indirect calls. Hook into implied idt. */
|
/* pmon uses indirect calls. Hook into implied idt. */
|
pmon_monitor_base = address_present ? address : 0xBFC00500;
|
pmon_monitor_base = address_present ? address : 0xBFC00500;
|
idt_monitor_base = pmon_monitor_base - 0x500;
|
idt_monitor_base = pmon_monitor_base - 0x500;
|
lsipmon_monitor_base = 0;
|
lsipmon_monitor_base = 0;
|
}
|
}
|
else if (! strncmp (arg, "lsipmon", 7))
|
else if (! strncmp (arg, "lsipmon", 7))
|
{
|
{
|
/* lsipmon uses indirect calls. Hook into implied idt. */
|
/* lsipmon uses indirect calls. Hook into implied idt. */
|
pmon_monitor_base = 0;
|
pmon_monitor_base = 0;
|
lsipmon_monitor_base = address_present ? address : 0xBFC00200;
|
lsipmon_monitor_base = address_present ? address : 0xBFC00200;
|
idt_monitor_base = lsipmon_monitor_base - 0x200;
|
idt_monitor_base = lsipmon_monitor_base - 0x200;
|
}
|
}
|
else if (! strncmp (arg, "none", 4))
|
else if (! strncmp (arg, "none", 4))
|
{
|
{
|
if (address_present)
|
if (address_present)
|
{
|
{
|
sim_io_printf (sd,
|
sim_io_printf (sd,
|
"The `sim firmware none' command does "
|
"The `sim firmware none' command does "
|
"not take an `ADDRESS' argument.\n");
|
"not take an `ADDRESS' argument.\n");
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
idt_monitor_base = 0;
|
idt_monitor_base = 0;
|
pmon_monitor_base = 0;
|
pmon_monitor_base = 0;
|
lsipmon_monitor_base = 0;
|
lsipmon_monitor_base = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
sim_io_printf (sd, "\
|
sim_io_printf (sd, "\
|
Unrecognized name given to the `sim firmware NAME' command: %s\n\
|
Unrecognized name given to the `sim firmware NAME' command: %s\n\
|
Recognized firmware names are: `idt', `pmon', `lsipmon', and `none'.\n",
|
Recognized firmware names are: `idt', `pmon', `lsipmon', and `none'.\n",
|
arg);
|
arg);
|
return SIM_RC_FAIL;
|
return SIM_RC_FAIL;
|
}
|
}
|
|
|
return SIM_RC_OK;
|
return SIM_RC_OK;
|
}
|
}
|
|
|
|
|
|
|
/* Simple monitor interface (currently setup for the IDT and PMON monitors) */
|
/* Simple monitor interface (currently setup for the IDT and PMON monitors) */
|
void
|
void
|
sim_monitor (SIM_DESC sd,
|
sim_monitor (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
unsigned int reason)
|
unsigned int reason)
|
{
|
{
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: sim_monitor: entered (reason = %d)\n",reason);
|
printf("DBG: sim_monitor: entered (reason = %d)\n",reason);
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The IDT monitor actually allows two instructions per vector
|
/* The IDT monitor actually allows two instructions per vector
|
slot. However, the simulator currently causes a trap on each
|
slot. However, the simulator currently causes a trap on each
|
individual instruction. We cheat, and lose the bottom bit. */
|
individual instruction. We cheat, and lose the bottom bit. */
|
reason >>= 1;
|
reason >>= 1;
|
|
|
/* The following callback functions are available, however the
|
/* The following callback functions are available, however the
|
monitor we are simulating does not make use of them: get_errno,
|
monitor we are simulating does not make use of them: get_errno,
|
isatty, lseek, rename, system, time and unlink */
|
isatty, lseek, rename, system, time and unlink */
|
switch (reason)
|
switch (reason)
|
{
|
{
|
|
|
case 6: /* int open(char *path,int flags) */
|
case 6: /* int open(char *path,int flags) */
|
{
|
{
|
char *path = fetch_str (sd, A0);
|
char *path = fetch_str (sd, A0);
|
V0 = sim_io_open (sd, path, (int)A1);
|
V0 = sim_io_open (sd, path, (int)A1);
|
zfree (path);
|
zfree (path);
|
break;
|
break;
|
}
|
}
|
|
|
case 7: /* int read(int file,char *ptr,int len) */
|
case 7: /* int read(int file,char *ptr,int len) */
|
{
|
{
|
int fd = A0;
|
int fd = A0;
|
int nr = A2;
|
int nr = A2;
|
char *buf = zalloc (nr);
|
char *buf = zalloc (nr);
|
V0 = sim_io_read (sd, fd, buf, nr);
|
V0 = sim_io_read (sd, fd, buf, nr);
|
sim_write (sd, A1, buf, nr);
|
sim_write (sd, A1, buf, nr);
|
zfree (buf);
|
zfree (buf);
|
}
|
}
|
break;
|
break;
|
|
|
case 8: /* int write(int file,char *ptr,int len) */
|
case 8: /* int write(int file,char *ptr,int len) */
|
{
|
{
|
int fd = A0;
|
int fd = A0;
|
int nr = A2;
|
int nr = A2;
|
char *buf = zalloc (nr);
|
char *buf = zalloc (nr);
|
sim_read (sd, A1, buf, nr);
|
sim_read (sd, A1, buf, nr);
|
V0 = sim_io_write (sd, fd, buf, nr);
|
V0 = sim_io_write (sd, fd, buf, nr);
|
zfree (buf);
|
zfree (buf);
|
break;
|
break;
|
}
|
}
|
|
|
case 10: /* int close(int file) */
|
case 10: /* int close(int file) */
|
{
|
{
|
V0 = sim_io_close (sd, (int)A0);
|
V0 = sim_io_close (sd, (int)A0);
|
break;
|
break;
|
}
|
}
|
|
|
case 2: /* Densan monitor: char inbyte(int waitflag) */
|
case 2: /* Densan monitor: char inbyte(int waitflag) */
|
{
|
{
|
if (A0 == 0) /* waitflag == NOWAIT */
|
if (A0 == 0) /* waitflag == NOWAIT */
|
V0 = (unsigned_word)-1;
|
V0 = (unsigned_word)-1;
|
}
|
}
|
/* Drop through to case 11 */
|
/* Drop through to case 11 */
|
|
|
case 11: /* char inbyte(void) */
|
case 11: /* char inbyte(void) */
|
{
|
{
|
char tmp;
|
char tmp;
|
/* ensure that all output has gone... */
|
/* ensure that all output has gone... */
|
sim_io_flush_stdout (sd);
|
sim_io_flush_stdout (sd);
|
if (sim_io_read_stdin (sd, &tmp, sizeof(char)) != sizeof(char))
|
if (sim_io_read_stdin (sd, &tmp, sizeof(char)) != sizeof(char))
|
{
|
{
|
sim_io_error(sd,"Invalid return from character read");
|
sim_io_error(sd,"Invalid return from character read");
|
V0 = (unsigned_word)-1;
|
V0 = (unsigned_word)-1;
|
}
|
}
|
else
|
else
|
V0 = (unsigned_word)tmp;
|
V0 = (unsigned_word)tmp;
|
break;
|
break;
|
}
|
}
|
|
|
case 3: /* Densan monitor: void co(char chr) */
|
case 3: /* Densan monitor: void co(char chr) */
|
case 12: /* void outbyte(char chr) : write a byte to "stdout" */
|
case 12: /* void outbyte(char chr) : write a byte to "stdout" */
|
{
|
{
|
char tmp = (char)(A0 & 0xFF);
|
char tmp = (char)(A0 & 0xFF);
|
sim_io_write_stdout (sd, &tmp, sizeof(char));
|
sim_io_write_stdout (sd, &tmp, sizeof(char));
|
break;
|
break;
|
}
|
}
|
|
|
case 17: /* void _exit() */
|
case 17: /* void _exit() */
|
{
|
{
|
sim_io_eprintf (sd, "sim_monitor(17): _exit(int reason) to be coded\n");
|
sim_io_eprintf (sd, "sim_monitor(17): _exit(int reason) to be coded\n");
|
sim_engine_halt (SD, CPU, NULL, NULL_CIA, sim_exited,
|
sim_engine_halt (SD, CPU, NULL, NULL_CIA, sim_exited,
|
(unsigned int)(A0 & 0xFFFFFFFF));
|
(unsigned int)(A0 & 0xFFFFFFFF));
|
break;
|
break;
|
}
|
}
|
|
|
case 28 : /* PMON flush_cache */
|
case 28 : /* PMON flush_cache */
|
break;
|
break;
|
|
|
case 55: /* void get_mem_info(unsigned int *ptr) */
|
case 55: /* void get_mem_info(unsigned int *ptr) */
|
/* in: A0 = pointer to three word memory location */
|
/* in: A0 = pointer to three word memory location */
|
/* out: [A0 + 0] = size */
|
/* out: [A0 + 0] = size */
|
/* [A0 + 4] = instruction cache size */
|
/* [A0 + 4] = instruction cache size */
|
/* [A0 + 8] = data cache size */
|
/* [A0 + 8] = data cache size */
|
{
|
{
|
unsigned_4 value = MEM_SIZE /* FIXME STATE_MEM_SIZE (sd) */;
|
unsigned_4 value = MEM_SIZE /* FIXME STATE_MEM_SIZE (sd) */;
|
unsigned_4 zero = 0;
|
unsigned_4 zero = 0;
|
H2T (value);
|
H2T (value);
|
sim_write (sd, A0 + 0, (char *)&value, 4);
|
sim_write (sd, A0 + 0, (char *)&value, 4);
|
sim_write (sd, A0 + 4, (char *)&zero, 4);
|
sim_write (sd, A0 + 4, (char *)&zero, 4);
|
sim_write (sd, A0 + 8, (char *)&zero, 4);
|
sim_write (sd, A0 + 8, (char *)&zero, 4);
|
/* sim_io_eprintf (sd, "sim: get_mem_info() depreciated\n"); */
|
/* sim_io_eprintf (sd, "sim: get_mem_info() depreciated\n"); */
|
break;
|
break;
|
}
|
}
|
|
|
case 158 : /* PMON printf */
|
case 158 : /* PMON printf */
|
/* in: A0 = pointer to format string */
|
/* in: A0 = pointer to format string */
|
/* A1 = optional argument 1 */
|
/* A1 = optional argument 1 */
|
/* A2 = optional argument 2 */
|
/* A2 = optional argument 2 */
|
/* A3 = optional argument 3 */
|
/* A3 = optional argument 3 */
|
/* out: void */
|
/* out: void */
|
/* The following is based on the PMON printf source */
|
/* The following is based on the PMON printf source */
|
{
|
{
|
address_word s = A0;
|
address_word s = A0;
|
char c;
|
char c;
|
signed_word *ap = &A1; /* 1st argument */
|
signed_word *ap = &A1; /* 1st argument */
|
/* This isn't the quickest way, since we call the host print
|
/* This isn't the quickest way, since we call the host print
|
routine for every character almost. But it does avoid
|
routine for every character almost. But it does avoid
|
having to allocate and manage a temporary string buffer. */
|
having to allocate and manage a temporary string buffer. */
|
/* TODO: Include check that we only use three arguments (A1,
|
/* TODO: Include check that we only use three arguments (A1,
|
A2 and A3) */
|
A2 and A3) */
|
while (sim_read (sd, s++, &c, 1) && c != '\0')
|
while (sim_read (sd, s++, &c, 1) && c != '\0')
|
{
|
{
|
if (c == '%')
|
if (c == '%')
|
{
|
{
|
char tmp[40];
|
char tmp[40];
|
enum {FMT_RJUST, FMT_LJUST, FMT_RJUST0, FMT_CENTER} fmt = FMT_RJUST;
|
enum {FMT_RJUST, FMT_LJUST, FMT_RJUST0, FMT_CENTER} fmt = FMT_RJUST;
|
int width = 0, trunc = 0, haddot = 0, longlong = 0;
|
int width = 0, trunc = 0, haddot = 0, longlong = 0;
|
while (sim_read (sd, s++, &c, 1) && c != '\0')
|
while (sim_read (sd, s++, &c, 1) && c != '\0')
|
{
|
{
|
if (strchr ("dobxXulscefg%", c))
|
if (strchr ("dobxXulscefg%", c))
|
break;
|
break;
|
else if (c == '-')
|
else if (c == '-')
|
fmt = FMT_LJUST;
|
fmt = FMT_LJUST;
|
else if (c == '0')
|
else if (c == '0')
|
fmt = FMT_RJUST0;
|
fmt = FMT_RJUST0;
|
else if (c == '~')
|
else if (c == '~')
|
fmt = FMT_CENTER;
|
fmt = FMT_CENTER;
|
else if (c == '*')
|
else if (c == '*')
|
{
|
{
|
if (haddot)
|
if (haddot)
|
trunc = (int)*ap++;
|
trunc = (int)*ap++;
|
else
|
else
|
width = (int)*ap++;
|
width = (int)*ap++;
|
}
|
}
|
else if (c >= '1' && c <= '9')
|
else if (c >= '1' && c <= '9')
|
{
|
{
|
address_word t = s;
|
address_word t = s;
|
unsigned int n;
|
unsigned int n;
|
while (sim_read (sd, s++, &c, 1) == 1 && isdigit (c))
|
while (sim_read (sd, s++, &c, 1) == 1 && isdigit (c))
|
tmp[s - t] = c;
|
tmp[s - t] = c;
|
tmp[s - t] = '\0';
|
tmp[s - t] = '\0';
|
n = (unsigned int)strtol(tmp,NULL,10);
|
n = (unsigned int)strtol(tmp,NULL,10);
|
if (haddot)
|
if (haddot)
|
trunc = n;
|
trunc = n;
|
else
|
else
|
width = n;
|
width = n;
|
s--;
|
s--;
|
}
|
}
|
else if (c == '.')
|
else if (c == '.')
|
haddot = 1;
|
haddot = 1;
|
}
|
}
|
switch (c)
|
switch (c)
|
{
|
{
|
case '%':
|
case '%':
|
sim_io_printf (sd, "%%");
|
sim_io_printf (sd, "%%");
|
break;
|
break;
|
case 's':
|
case 's':
|
if ((int)*ap != 0)
|
if ((int)*ap != 0)
|
{
|
{
|
address_word p = *ap++;
|
address_word p = *ap++;
|
char ch;
|
char ch;
|
while (sim_read (sd, p++, &ch, 1) == 1 && ch != '\0')
|
while (sim_read (sd, p++, &ch, 1) == 1 && ch != '\0')
|
sim_io_printf(sd, "%c", ch);
|
sim_io_printf(sd, "%c", ch);
|
}
|
}
|
else
|
else
|
sim_io_printf(sd,"(null)");
|
sim_io_printf(sd,"(null)");
|
break;
|
break;
|
case 'c':
|
case 'c':
|
sim_io_printf (sd, "%c", (int)*ap++);
|
sim_io_printf (sd, "%c", (int)*ap++);
|
break;
|
break;
|
default:
|
default:
|
if (c == 'l')
|
if (c == 'l')
|
{
|
{
|
sim_read (sd, s++, &c, 1);
|
sim_read (sd, s++, &c, 1);
|
if (c == 'l')
|
if (c == 'l')
|
{
|
{
|
longlong = 1;
|
longlong = 1;
|
sim_read (sd, s++, &c, 1);
|
sim_read (sd, s++, &c, 1);
|
}
|
}
|
}
|
}
|
if (strchr ("dobxXu", c))
|
if (strchr ("dobxXu", c))
|
{
|
{
|
word64 lv = (word64) *ap++;
|
word64 lv = (word64) *ap++;
|
if (c == 'b')
|
if (c == 'b')
|
sim_io_printf(sd,"<binary not supported>");
|
sim_io_printf(sd,"<binary not supported>");
|
else
|
else
|
{
|
{
|
sprintf (tmp, "%%%s%c", longlong ? "ll" : "", c);
|
sprintf (tmp, "%%%s%c", longlong ? "ll" : "", c);
|
if (longlong)
|
if (longlong)
|
sim_io_printf(sd, tmp, lv);
|
sim_io_printf(sd, tmp, lv);
|
else
|
else
|
sim_io_printf(sd, tmp, (int)lv);
|
sim_io_printf(sd, tmp, (int)lv);
|
}
|
}
|
}
|
}
|
else if (strchr ("eEfgG", c))
|
else if (strchr ("eEfgG", c))
|
{
|
{
|
double dbl = *(double*)(ap++);
|
double dbl = *(double*)(ap++);
|
sprintf (tmp, "%%%d.%d%c", width, trunc, c);
|
sprintf (tmp, "%%%d.%d%c", width, trunc, c);
|
sim_io_printf (sd, tmp, dbl);
|
sim_io_printf (sd, tmp, dbl);
|
trunc = 0;
|
trunc = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
sim_io_printf(sd, "%c", c);
|
sim_io_printf(sd, "%c", c);
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
default:
|
default:
|
sim_io_error (sd, "TODO: sim_monitor(%d) : PC = 0x%s\n",
|
sim_io_error (sd, "TODO: sim_monitor(%d) : PC = 0x%s\n",
|
reason, pr_addr(cia));
|
reason, pr_addr(cia));
|
break;
|
break;
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
/* Store a word into memory. */
|
/* Store a word into memory. */
|
|
|
static void
|
static void
|
store_word (SIM_DESC sd,
|
store_word (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
uword64 vaddr,
|
uword64 vaddr,
|
signed_word val)
|
signed_word val)
|
{
|
{
|
address_word paddr;
|
address_word paddr;
|
int uncached;
|
int uncached;
|
|
|
if ((vaddr & 3) != 0)
|
if ((vaddr & 3) != 0)
|
SignalExceptionAddressStore ();
|
SignalExceptionAddressStore ();
|
else
|
else
|
{
|
{
|
if (AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached,
|
if (AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached,
|
isTARGET, isREAL))
|
isTARGET, isREAL))
|
{
|
{
|
const uword64 mask = 7;
|
const uword64 mask = 7;
|
uword64 memval;
|
uword64 memval;
|
unsigned int byte;
|
unsigned int byte;
|
|
|
paddr = (paddr & ~mask) | ((paddr & mask) ^ (ReverseEndian << 2));
|
paddr = (paddr & ~mask) | ((paddr & mask) ^ (ReverseEndian << 2));
|
byte = (vaddr & mask) ^ (BigEndianCPU << 2);
|
byte = (vaddr & mask) ^ (BigEndianCPU << 2);
|
memval = ((uword64) val) << (8 * byte);
|
memval = ((uword64) val) << (8 * byte);
|
StoreMemory (uncached, AccessLength_WORD, memval, 0, paddr, vaddr,
|
StoreMemory (uncached, AccessLength_WORD, memval, 0, paddr, vaddr,
|
isREAL);
|
isREAL);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Load a word from memory. */
|
/* Load a word from memory. */
|
|
|
static signed_word
|
static signed_word
|
load_word (SIM_DESC sd,
|
load_word (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
uword64 vaddr)
|
uword64 vaddr)
|
{
|
{
|
if ((vaddr & 3) != 0)
|
if ((vaddr & 3) != 0)
|
{
|
{
|
SIM_CORE_SIGNAL (SD, cpu, cia, read_map, AccessLength_WORD+1, vaddr, read_transfer, sim_core_unaligned_signal);
|
SIM_CORE_SIGNAL (SD, cpu, cia, read_map, AccessLength_WORD+1, vaddr, read_transfer, sim_core_unaligned_signal);
|
}
|
}
|
else
|
else
|
{
|
{
|
address_word paddr;
|
address_word paddr;
|
int uncached;
|
int uncached;
|
|
|
if (AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached,
|
if (AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached,
|
isTARGET, isREAL))
|
isTARGET, isREAL))
|
{
|
{
|
const uword64 mask = 0x7;
|
const uword64 mask = 0x7;
|
const unsigned int reverse = ReverseEndian ? 1 : 0;
|
const unsigned int reverse = ReverseEndian ? 1 : 0;
|
const unsigned int bigend = BigEndianCPU ? 1 : 0;
|
const unsigned int bigend = BigEndianCPU ? 1 : 0;
|
uword64 memval;
|
uword64 memval;
|
unsigned int byte;
|
unsigned int byte;
|
|
|
paddr = (paddr & ~mask) | ((paddr & mask) ^ (reverse << 2));
|
paddr = (paddr & ~mask) | ((paddr & mask) ^ (reverse << 2));
|
LoadMemory (&memval,NULL,uncached, AccessLength_WORD, paddr, vaddr,
|
LoadMemory (&memval,NULL,uncached, AccessLength_WORD, paddr, vaddr,
|
isDATA, isREAL);
|
isDATA, isREAL);
|
byte = (vaddr & mask) ^ (bigend << 2);
|
byte = (vaddr & mask) ^ (bigend << 2);
|
return SIGNEXTEND (((memval >> (8 * byte)) & 0xffffffff), 32);
|
return SIGNEXTEND (((memval >> (8 * byte)) & 0xffffffff), 32);
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Simulate the mips16 entry and exit pseudo-instructions. These
|
/* Simulate the mips16 entry and exit pseudo-instructions. These
|
would normally be handled by the reserved instruction exception
|
would normally be handled by the reserved instruction exception
|
code, but for ease of simulation we just handle them directly. */
|
code, but for ease of simulation we just handle them directly. */
|
|
|
static void
|
static void
|
mips16_entry (SIM_DESC sd,
|
mips16_entry (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
unsigned int insn)
|
unsigned int insn)
|
{
|
{
|
int aregs, sregs, rreg;
|
int aregs, sregs, rreg;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: mips16_entry: entered (insn = 0x%08X)\n",insn);
|
printf("DBG: mips16_entry: entered (insn = 0x%08X)\n",insn);
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
aregs = (insn & 0x700) >> 8;
|
aregs = (insn & 0x700) >> 8;
|
sregs = (insn & 0x0c0) >> 6;
|
sregs = (insn & 0x0c0) >> 6;
|
rreg = (insn & 0x020) >> 5;
|
rreg = (insn & 0x020) >> 5;
|
|
|
/* This should be checked by the caller. */
|
/* This should be checked by the caller. */
|
if (sregs == 3)
|
if (sregs == 3)
|
abort ();
|
abort ();
|
|
|
if (aregs < 5)
|
if (aregs < 5)
|
{
|
{
|
int i;
|
int i;
|
signed_word tsp;
|
signed_word tsp;
|
|
|
/* This is the entry pseudo-instruction. */
|
/* This is the entry pseudo-instruction. */
|
|
|
for (i = 0; i < aregs; i++)
|
for (i = 0; i < aregs; i++)
|
store_word (SD, CPU, cia, (uword64) (SP + 4 * i), GPR[i + 4]);
|
store_word (SD, CPU, cia, (uword64) (SP + 4 * i), GPR[i + 4]);
|
|
|
tsp = SP;
|
tsp = SP;
|
SP -= 32;
|
SP -= 32;
|
|
|
if (rreg)
|
if (rreg)
|
{
|
{
|
tsp -= 4;
|
tsp -= 4;
|
store_word (SD, CPU, cia, (uword64) tsp, RA);
|
store_word (SD, CPU, cia, (uword64) tsp, RA);
|
}
|
}
|
|
|
for (i = 0; i < sregs; i++)
|
for (i = 0; i < sregs; i++)
|
{
|
{
|
tsp -= 4;
|
tsp -= 4;
|
store_word (SD, CPU, cia, (uword64) tsp, GPR[16 + i]);
|
store_word (SD, CPU, cia, (uword64) tsp, GPR[16 + i]);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
int i;
|
int i;
|
signed_word tsp;
|
signed_word tsp;
|
|
|
/* This is the exit pseudo-instruction. */
|
/* This is the exit pseudo-instruction. */
|
|
|
tsp = SP + 32;
|
tsp = SP + 32;
|
|
|
if (rreg)
|
if (rreg)
|
{
|
{
|
tsp -= 4;
|
tsp -= 4;
|
RA = load_word (SD, CPU, cia, (uword64) tsp);
|
RA = load_word (SD, CPU, cia, (uword64) tsp);
|
}
|
}
|
|
|
for (i = 0; i < sregs; i++)
|
for (i = 0; i < sregs; i++)
|
{
|
{
|
tsp -= 4;
|
tsp -= 4;
|
GPR[i + 16] = load_word (SD, CPU, cia, (uword64) tsp);
|
GPR[i + 16] = load_word (SD, CPU, cia, (uword64) tsp);
|
}
|
}
|
|
|
SP += 32;
|
SP += 32;
|
|
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
{
|
{
|
if (aregs == 5)
|
if (aregs == 5)
|
{
|
{
|
FGR[0] = WORD64LO (GPR[4]);
|
FGR[0] = WORD64LO (GPR[4]);
|
FPR_STATE[0] = fmt_uninterpreted;
|
FPR_STATE[0] = fmt_uninterpreted;
|
}
|
}
|
else if (aregs == 6)
|
else if (aregs == 6)
|
{
|
{
|
FGR[0] = WORD64LO (GPR[5]);
|
FGR[0] = WORD64LO (GPR[5]);
|
FGR[1] = WORD64LO (GPR[4]);
|
FGR[1] = WORD64LO (GPR[4]);
|
FPR_STATE[0] = fmt_uninterpreted;
|
FPR_STATE[0] = fmt_uninterpreted;
|
FPR_STATE[1] = fmt_uninterpreted;
|
FPR_STATE[1] = fmt_uninterpreted;
|
}
|
}
|
}
|
}
|
|
|
PC = RA;
|
PC = RA;
|
}
|
}
|
|
|
}
|
}
|
|
|
/*-- trace support ----------------------------------------------------------*/
|
/*-- trace support ----------------------------------------------------------*/
|
|
|
/* The TRACE support is provided (if required) in the memory accessing
|
/* The TRACE support is provided (if required) in the memory accessing
|
routines. Since we are also providing the architecture specific
|
routines. Since we are also providing the architecture specific
|
features, the architecture simulation code can also deal with
|
features, the architecture simulation code can also deal with
|
notifying the TRACE world of cache flushes, etc. Similarly we do
|
notifying the TRACE world of cache flushes, etc. Similarly we do
|
not need to provide profiling support in the simulator engine,
|
not need to provide profiling support in the simulator engine,
|
since we can sample in the instruction fetch control loop. By
|
since we can sample in the instruction fetch control loop. By
|
defining the TRACE manifest, we add tracing as a run-time
|
defining the TRACE manifest, we add tracing as a run-time
|
option. */
|
option. */
|
|
|
#if defined(TRACE)
|
#if defined(TRACE)
|
/* Tracing by default produces "din" format (as required by
|
/* Tracing by default produces "din" format (as required by
|
dineroIII). Each line of such a trace file *MUST* have a din label
|
dineroIII). Each line of such a trace file *MUST* have a din label
|
and address field. The rest of the line is ignored, so comments can
|
and address field. The rest of the line is ignored, so comments can
|
be included if desired. The first field is the label which must be
|
be included if desired. The first field is the label which must be
|
one of the following values:
|
one of the following values:
|
|
|
0 read data
|
0 read data
|
1 write data
|
1 write data
|
2 instruction fetch
|
2 instruction fetch
|
3 escape record (treated as unknown access type)
|
3 escape record (treated as unknown access type)
|
4 escape record (causes cache flush)
|
4 escape record (causes cache flush)
|
|
|
The address field is a 32bit (lower-case) hexadecimal address
|
The address field is a 32bit (lower-case) hexadecimal address
|
value. The address should *NOT* be preceded by "0x".
|
value. The address should *NOT* be preceded by "0x".
|
|
|
The size of the memory transfer is not important when dealing with
|
The size of the memory transfer is not important when dealing with
|
cache lines (as long as no more than a cache line can be
|
cache lines (as long as no more than a cache line can be
|
transferred in a single operation :-), however more information
|
transferred in a single operation :-), however more information
|
could be given following the dineroIII requirement to allow more
|
could be given following the dineroIII requirement to allow more
|
complete memory and cache simulators to provide better
|
complete memory and cache simulators to provide better
|
results. i.e. the University of Pisa has a cache simulator that can
|
results. i.e. the University of Pisa has a cache simulator that can
|
also take bus size and speed as (variable) inputs to calculate
|
also take bus size and speed as (variable) inputs to calculate
|
complete system performance (a much more useful ability when trying
|
complete system performance (a much more useful ability when trying
|
to construct an end product, rather than a processor). They
|
to construct an end product, rather than a processor). They
|
currently have an ARM version of their tool called ChARM. */
|
currently have an ARM version of their tool called ChARM. */
|
|
|
|
|
void
|
void
|
dotrace (SIM_DESC sd,
|
dotrace (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
FILE *tracefh,
|
FILE *tracefh,
|
int type,
|
int type,
|
SIM_ADDR address,
|
SIM_ADDR address,
|
int width,
|
int width,
|
char *comment,...)
|
char *comment,...)
|
{
|
{
|
if (STATE & simTRACE) {
|
if (STATE & simTRACE) {
|
va_list ap;
|
va_list ap;
|
fprintf(tracefh,"%d %s ; width %d ; ",
|
fprintf(tracefh,"%d %s ; width %d ; ",
|
type,
|
type,
|
pr_addr(address),
|
pr_addr(address),
|
width);
|
width);
|
va_start(ap,comment);
|
va_start(ap,comment);
|
vfprintf(tracefh,comment,ap);
|
vfprintf(tracefh,comment,ap);
|
va_end(ap);
|
va_end(ap);
|
fprintf(tracefh,"\n");
|
fprintf(tracefh,"\n");
|
}
|
}
|
/* NOTE: Since the "din" format will only accept 32bit addresses, and
|
/* NOTE: Since the "din" format will only accept 32bit addresses, and
|
we may be generating 64bit ones, we should put the hi-32bits of the
|
we may be generating 64bit ones, we should put the hi-32bits of the
|
address into the comment field. */
|
address into the comment field. */
|
|
|
/* TODO: Provide a buffer for the trace lines. We can then avoid
|
/* TODO: Provide a buffer for the trace lines. We can then avoid
|
performing writes until the buffer is filled, or the file is
|
performing writes until the buffer is filled, or the file is
|
being closed. */
|
being closed. */
|
|
|
/* NOTE: We could consider adding a comment field to the "din" file
|
/* NOTE: We could consider adding a comment field to the "din" file
|
produced using type 3 markers (unknown access). This would then
|
produced using type 3 markers (unknown access). This would then
|
allow information about the program that the "din" is for, and
|
allow information about the program that the "din" is for, and
|
the MIPs world that was being simulated, to be placed into the
|
the MIPs world that was being simulated, to be placed into the
|
trace file. */
|
trace file. */
|
|
|
return;
|
return;
|
}
|
}
|
#endif /* TRACE */
|
#endif /* TRACE */
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*-- simulator engine -------------------------------------------------------*/
|
/*-- simulator engine -------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
|
|
static void
|
static void
|
ColdReset (SIM_DESC sd)
|
ColdReset (SIM_DESC sd)
|
{
|
{
|
int cpu_nr;
|
int cpu_nr;
|
for (cpu_nr = 0; cpu_nr < sim_engine_nr_cpus (sd); cpu_nr++)
|
for (cpu_nr = 0; cpu_nr < sim_engine_nr_cpus (sd); cpu_nr++)
|
{
|
{
|
sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
|
sim_cpu *cpu = STATE_CPU (sd, cpu_nr);
|
/* RESET: Fixed PC address: */
|
/* RESET: Fixed PC address: */
|
PC = (unsigned_word) UNSIGNED64 (0xFFFFFFFFBFC00000);
|
PC = (unsigned_word) UNSIGNED64 (0xFFFFFFFFBFC00000);
|
/* The reset vector address is in the unmapped, uncached memory space. */
|
/* The reset vector address is in the unmapped, uncached memory space. */
|
|
|
SR &= ~(status_SR | status_TS | status_RP);
|
SR &= ~(status_SR | status_TS | status_RP);
|
SR |= (status_ERL | status_BEV);
|
SR |= (status_ERL | status_BEV);
|
|
|
/* Cheat and allow access to the complete register set immediately */
|
/* Cheat and allow access to the complete register set immediately */
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT
|
&& WITH_TARGET_WORD_BITSIZE == 64)
|
&& WITH_TARGET_WORD_BITSIZE == 64)
|
SR |= status_FR; /* 64bit registers */
|
SR |= status_FR; /* 64bit registers */
|
|
|
/* Ensure that any instructions with pending register updates are
|
/* Ensure that any instructions with pending register updates are
|
cleared: */
|
cleared: */
|
PENDING_INVALIDATE();
|
PENDING_INVALIDATE();
|
|
|
/* Initialise the FPU registers to the unknown state */
|
/* Initialise the FPU registers to the unknown state */
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
{
|
{
|
int rn;
|
int rn;
|
for (rn = 0; (rn < 32); rn++)
|
for (rn = 0; (rn < 32); rn++)
|
FPR_STATE[rn] = fmt_uninterpreted;
|
FPR_STATE[rn] = fmt_uninterpreted;
|
}
|
}
|
|
|
}
|
}
|
}
|
}
|
|
|
|
|
|
|
|
|
/* Description from page A-26 of the "MIPS IV Instruction Set" manual (revision 3.1) */
|
/* Description from page A-26 of the "MIPS IV Instruction Set" manual (revision 3.1) */
|
/* Signal an exception condition. This will result in an exception
|
/* Signal an exception condition. This will result in an exception
|
that aborts the instruction. The instruction operation pseudocode
|
that aborts the instruction. The instruction operation pseudocode
|
will never see a return from this function call. */
|
will never see a return from this function call. */
|
|
|
void
|
void
|
signal_exception (SIM_DESC sd,
|
signal_exception (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
int exception,...)
|
int exception,...)
|
{
|
{
|
/* int vector; */
|
/* int vector; */
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
sim_io_printf(sd,"DBG: SignalException(%d) PC = 0x%s\n",exception,pr_addr(cia));
|
sim_io_printf(sd,"DBG: SignalException(%d) PC = 0x%s\n",exception,pr_addr(cia));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* Ensure that any active atomic read/modify/write operation will fail: */
|
/* Ensure that any active atomic read/modify/write operation will fail: */
|
LLBIT = 0;
|
LLBIT = 0;
|
|
|
/* Save registers before interrupt dispatching */
|
/* Save registers before interrupt dispatching */
|
#ifdef SIM_CPU_EXCEPTION_TRIGGER
|
#ifdef SIM_CPU_EXCEPTION_TRIGGER
|
SIM_CPU_EXCEPTION_TRIGGER(sd, cpu, cia);
|
SIM_CPU_EXCEPTION_TRIGGER(sd, cpu, cia);
|
#endif
|
#endif
|
|
|
switch (exception) {
|
switch (exception) {
|
|
|
case DebugBreakPoint :
|
case DebugBreakPoint :
|
if (! (Debug & Debug_DM))
|
if (! (Debug & Debug_DM))
|
{
|
{
|
if (INDELAYSLOT())
|
if (INDELAYSLOT())
|
{
|
{
|
CANCELDELAYSLOT();
|
CANCELDELAYSLOT();
|
|
|
Debug |= Debug_DBD; /* signaled from within in delay slot */
|
Debug |= Debug_DBD; /* signaled from within in delay slot */
|
DEPC = cia - 4; /* reference the branch instruction */
|
DEPC = cia - 4; /* reference the branch instruction */
|
}
|
}
|
else
|
else
|
{
|
{
|
Debug &= ~Debug_DBD; /* not signaled from within a delay slot */
|
Debug &= ~Debug_DBD; /* not signaled from within a delay slot */
|
DEPC = cia;
|
DEPC = cia;
|
}
|
}
|
|
|
Debug |= Debug_DM; /* in debugging mode */
|
Debug |= Debug_DM; /* in debugging mode */
|
Debug |= Debug_DBp; /* raising a DBp exception */
|
Debug |= Debug_DBp; /* raising a DBp exception */
|
PC = 0xBFC00200;
|
PC = 0xBFC00200;
|
sim_engine_restart (SD, CPU, NULL, NULL_CIA);
|
sim_engine_restart (SD, CPU, NULL, NULL_CIA);
|
}
|
}
|
break;
|
break;
|
|
|
case ReservedInstruction :
|
case ReservedInstruction :
|
{
|
{
|
va_list ap;
|
va_list ap;
|
unsigned int instruction;
|
unsigned int instruction;
|
va_start(ap,exception);
|
va_start(ap,exception);
|
instruction = va_arg(ap,unsigned int);
|
instruction = va_arg(ap,unsigned int);
|
va_end(ap);
|
va_end(ap);
|
/* Provide simple monitor support using ReservedInstruction
|
/* Provide simple monitor support using ReservedInstruction
|
exceptions. The following code simulates the fixed vector
|
exceptions. The following code simulates the fixed vector
|
entry points into the IDT monitor by causing a simulator
|
entry points into the IDT monitor by causing a simulator
|
trap, performing the monitor operation, and returning to
|
trap, performing the monitor operation, and returning to
|
the address held in the $ra register (standard PCS return
|
the address held in the $ra register (standard PCS return
|
address). This means we only need to pre-load the vector
|
address). This means we only need to pre-load the vector
|
space with suitable instruction values. For systems were
|
space with suitable instruction values. For systems were
|
actual trap instructions are used, we would not need to
|
actual trap instructions are used, we would not need to
|
perform this magic. */
|
perform this magic. */
|
if ((instruction & RSVD_INSTRUCTION_MASK) == RSVD_INSTRUCTION)
|
if ((instruction & RSVD_INSTRUCTION_MASK) == RSVD_INSTRUCTION)
|
{
|
{
|
sim_monitor (SD, CPU, cia, ((instruction >> RSVD_INSTRUCTION_ARG_SHIFT) & RSVD_INSTRUCTION_ARG_MASK) );
|
sim_monitor (SD, CPU, cia, ((instruction >> RSVD_INSTRUCTION_ARG_SHIFT) & RSVD_INSTRUCTION_ARG_MASK) );
|
/* NOTE: This assumes that a branch-and-link style
|
/* NOTE: This assumes that a branch-and-link style
|
instruction was used to enter the vector (which is the
|
instruction was used to enter the vector (which is the
|
case with the current IDT monitor). */
|
case with the current IDT monitor). */
|
sim_engine_restart (SD, CPU, NULL, RA);
|
sim_engine_restart (SD, CPU, NULL, RA);
|
}
|
}
|
/* Look for the mips16 entry and exit instructions, and
|
/* Look for the mips16 entry and exit instructions, and
|
simulate a handler for them. */
|
simulate a handler for them. */
|
else if ((cia & 1) != 0
|
else if ((cia & 1) != 0
|
&& (instruction & 0xf81f) == 0xe809
|
&& (instruction & 0xf81f) == 0xe809
|
&& (instruction & 0x0c0) != 0x0c0)
|
&& (instruction & 0x0c0) != 0x0c0)
|
{
|
{
|
mips16_entry (SD, CPU, cia, instruction);
|
mips16_entry (SD, CPU, cia, instruction);
|
sim_engine_restart (sd, NULL, NULL, NULL_CIA);
|
sim_engine_restart (sd, NULL, NULL, NULL_CIA);
|
}
|
}
|
/* else fall through to normal exception processing */
|
/* else fall through to normal exception processing */
|
sim_io_eprintf(sd,"ReservedInstruction at PC = 0x%s\n", pr_addr (cia));
|
sim_io_eprintf(sd,"ReservedInstruction at PC = 0x%s\n", pr_addr (cia));
|
}
|
}
|
|
|
default:
|
default:
|
/* Store exception code into current exception id variable (used
|
/* Store exception code into current exception id variable (used
|
by exit code): */
|
by exit code): */
|
|
|
/* TODO: If not simulating exceptions then stop the simulator
|
/* TODO: If not simulating exceptions then stop the simulator
|
execution. At the moment we always stop the simulation. */
|
execution. At the moment we always stop the simulation. */
|
|
|
#ifdef SUBTARGET_R3900
|
#ifdef SUBTARGET_R3900
|
/* update interrupt-related registers */
|
/* update interrupt-related registers */
|
|
|
/* insert exception code in bits 6:2 */
|
/* insert exception code in bits 6:2 */
|
CAUSE = LSMASKED32(CAUSE, 31, 7) | LSINSERTED32(exception, 6, 2);
|
CAUSE = LSMASKED32(CAUSE, 31, 7) | LSINSERTED32(exception, 6, 2);
|
/* shift IE/KU history bits left */
|
/* shift IE/KU history bits left */
|
SR = LSMASKED32(SR, 31, 4) | LSINSERTED32(LSEXTRACTED32(SR, 3, 0), 5, 2);
|
SR = LSMASKED32(SR, 31, 4) | LSINSERTED32(LSEXTRACTED32(SR, 3, 0), 5, 2);
|
|
|
if (STATE & simDELAYSLOT)
|
if (STATE & simDELAYSLOT)
|
{
|
{
|
STATE &= ~simDELAYSLOT;
|
STATE &= ~simDELAYSLOT;
|
CAUSE |= cause_BD;
|
CAUSE |= cause_BD;
|
EPC = (cia - 4); /* reference the branch instruction */
|
EPC = (cia - 4); /* reference the branch instruction */
|
}
|
}
|
else
|
else
|
EPC = cia;
|
EPC = cia;
|
|
|
if (SR & status_BEV)
|
if (SR & status_BEV)
|
PC = (signed)0xBFC00000 + 0x180;
|
PC = (signed)0xBFC00000 + 0x180;
|
else
|
else
|
PC = (signed)0x80000000 + 0x080;
|
PC = (signed)0x80000000 + 0x080;
|
#else
|
#else
|
/* See figure 5-17 for an outline of the code below */
|
/* See figure 5-17 for an outline of the code below */
|
if (! (SR & status_EXL))
|
if (! (SR & status_EXL))
|
{
|
{
|
CAUSE = (exception << 2);
|
CAUSE = (exception << 2);
|
if (STATE & simDELAYSLOT)
|
if (STATE & simDELAYSLOT)
|
{
|
{
|
STATE &= ~simDELAYSLOT;
|
STATE &= ~simDELAYSLOT;
|
CAUSE |= cause_BD;
|
CAUSE |= cause_BD;
|
EPC = (cia - 4); /* reference the branch instruction */
|
EPC = (cia - 4); /* reference the branch instruction */
|
}
|
}
|
else
|
else
|
EPC = cia;
|
EPC = cia;
|
/* FIXME: TLB et.al. */
|
/* FIXME: TLB et.al. */
|
/* vector = 0x180; */
|
/* vector = 0x180; */
|
}
|
}
|
else
|
else
|
{
|
{
|
CAUSE = (exception << 2);
|
CAUSE = (exception << 2);
|
/* vector = 0x180; */
|
/* vector = 0x180; */
|
}
|
}
|
SR |= status_EXL;
|
SR |= status_EXL;
|
/* Store exception code into current exception id variable (used
|
/* Store exception code into current exception id variable (used
|
by exit code): */
|
by exit code): */
|
|
|
if (SR & status_BEV)
|
if (SR & status_BEV)
|
PC = (signed)0xBFC00200 + 0x180;
|
PC = (signed)0xBFC00200 + 0x180;
|
else
|
else
|
PC = (signed)0x80000000 + 0x180;
|
PC = (signed)0x80000000 + 0x180;
|
#endif
|
#endif
|
|
|
switch ((CAUSE >> 2) & 0x1F)
|
switch ((CAUSE >> 2) & 0x1F)
|
{
|
{
|
case Interrupt:
|
case Interrupt:
|
/* Interrupts arrive during event processing, no need to
|
/* Interrupts arrive during event processing, no need to
|
restart */
|
restart */
|
return;
|
return;
|
|
|
case NMIReset:
|
case NMIReset:
|
/* Ditto */
|
/* Ditto */
|
#ifdef SUBTARGET_3900
|
#ifdef SUBTARGET_3900
|
/* Exception vector: BEV=0 BFC00000 / BEF=1 BFC00000 */
|
/* Exception vector: BEV=0 BFC00000 / BEF=1 BFC00000 */
|
PC = (signed)0xBFC00000;
|
PC = (signed)0xBFC00000;
|
#endif SUBTARGET_3900
|
#endif SUBTARGET_3900
|
return;
|
return;
|
|
|
case TLBModification:
|
case TLBModification:
|
case TLBLoad:
|
case TLBLoad:
|
case TLBStore:
|
case TLBStore:
|
case AddressLoad:
|
case AddressLoad:
|
case AddressStore:
|
case AddressStore:
|
case InstructionFetch:
|
case InstructionFetch:
|
case DataReference:
|
case DataReference:
|
/* The following is so that the simulator will continue from the
|
/* The following is so that the simulator will continue from the
|
exception handler address. */
|
exception handler address. */
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_stopped, SIM_SIGBUS);
|
sim_stopped, SIM_SIGBUS);
|
|
|
case ReservedInstruction:
|
case ReservedInstruction:
|
case CoProcessorUnusable:
|
case CoProcessorUnusable:
|
PC = EPC;
|
PC = EPC;
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_stopped, SIM_SIGILL);
|
sim_stopped, SIM_SIGILL);
|
|
|
case IntegerOverflow:
|
case IntegerOverflow:
|
case FPE:
|
case FPE:
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_stopped, SIM_SIGFPE);
|
sim_stopped, SIM_SIGFPE);
|
|
|
case BreakPoint:
|
case BreakPoint:
|
sim_engine_halt (SD, CPU, NULL, PC, sim_stopped, SIM_SIGTRAP);
|
sim_engine_halt (SD, CPU, NULL, PC, sim_stopped, SIM_SIGTRAP);
|
break;
|
break;
|
|
|
case SystemCall:
|
case SystemCall:
|
case Trap:
|
case Trap:
|
sim_engine_restart (SD, CPU, NULL, PC);
|
sim_engine_restart (SD, CPU, NULL, PC);
|
break;
|
break;
|
|
|
case Watch:
|
case Watch:
|
PC = EPC;
|
PC = EPC;
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_stopped, SIM_SIGTRAP);
|
sim_stopped, SIM_SIGTRAP);
|
|
|
default : /* Unknown internal exception */
|
default : /* Unknown internal exception */
|
PC = EPC;
|
PC = EPC;
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_engine_halt (SD, CPU, NULL, PC,
|
sim_stopped, SIM_SIGABRT);
|
sim_stopped, SIM_SIGABRT);
|
|
|
}
|
}
|
|
|
case SimulatorFault:
|
case SimulatorFault:
|
{
|
{
|
va_list ap;
|
va_list ap;
|
char *msg;
|
char *msg;
|
va_start(ap,exception);
|
va_start(ap,exception);
|
msg = va_arg(ap,char *);
|
msg = va_arg(ap,char *);
|
va_end(ap);
|
va_end(ap);
|
sim_engine_abort (SD, CPU, NULL_CIA,
|
sim_engine_abort (SD, CPU, NULL_CIA,
|
"FATAL: Simulator error \"%s\"\n",msg);
|
"FATAL: Simulator error \"%s\"\n",msg);
|
}
|
}
|
}
|
}
|
|
|
return;
|
return;
|
}
|
}
|
|
|
|
|
|
|
#if defined(WARN_RESULT)
|
#if defined(WARN_RESULT)
|
/* Description from page A-26 of the "MIPS IV Instruction Set" manual (revision 3.1) */
|
/* Description from page A-26 of the "MIPS IV Instruction Set" manual (revision 3.1) */
|
/* This function indicates that the result of the operation is
|
/* This function indicates that the result of the operation is
|
undefined. However, this should not affect the instruction
|
undefined. However, this should not affect the instruction
|
stream. All that is meant to happen is that the destination
|
stream. All that is meant to happen is that the destination
|
register is set to an undefined result. To keep the simulator
|
register is set to an undefined result. To keep the simulator
|
simple, we just don't bother updating the destination register, so
|
simple, we just don't bother updating the destination register, so
|
the overall result will be undefined. If desired we can stop the
|
the overall result will be undefined. If desired we can stop the
|
simulator by raising a pseudo-exception. */
|
simulator by raising a pseudo-exception. */
|
#define UndefinedResult() undefined_result (sd,cia)
|
#define UndefinedResult() undefined_result (sd,cia)
|
static void
|
static void
|
undefined_result(sd,cia)
|
undefined_result(sd,cia)
|
SIM_DESC sd;
|
SIM_DESC sd;
|
address_word cia;
|
address_word cia;
|
{
|
{
|
sim_io_eprintf(sd,"UndefinedResult: PC = 0x%s\n",pr_addr(cia));
|
sim_io_eprintf(sd,"UndefinedResult: PC = 0x%s\n",pr_addr(cia));
|
#if 0 /* Disabled for the moment, since it actually happens a lot at the moment. */
|
#if 0 /* Disabled for the moment, since it actually happens a lot at the moment. */
|
state |= simSTOP;
|
state |= simSTOP;
|
#endif
|
#endif
|
return;
|
return;
|
}
|
}
|
#endif /* WARN_RESULT */
|
#endif /* WARN_RESULT */
|
|
|
/*-- FPU support routines ---------------------------------------------------*/
|
/*-- FPU support routines ---------------------------------------------------*/
|
|
|
/* Numbers are held in normalized form. The SINGLE and DOUBLE binary
|
/* Numbers are held in normalized form. The SINGLE and DOUBLE binary
|
formats conform to ANSI/IEEE Std 754-1985. */
|
formats conform to ANSI/IEEE Std 754-1985. */
|
/* SINGLE precision floating:
|
/* SINGLE precision floating:
|
* seeeeeeeefffffffffffffffffffffff
|
* seeeeeeeefffffffffffffffffffffff
|
* s = 1bit = sign
|
* s = 1bit = sign
|
* e = 8bits = exponent
|
* e = 8bits = exponent
|
* f = 23bits = fraction
|
* f = 23bits = fraction
|
*/
|
*/
|
/* SINGLE precision fixed:
|
/* SINGLE precision fixed:
|
* siiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
|
* siiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
|
* s = 1bit = sign
|
* s = 1bit = sign
|
* i = 31bits = integer
|
* i = 31bits = integer
|
*/
|
*/
|
/* DOUBLE precision floating:
|
/* DOUBLE precision floating:
|
* seeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffff
|
* seeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffff
|
* s = 1bit = sign
|
* s = 1bit = sign
|
* e = 11bits = exponent
|
* e = 11bits = exponent
|
* f = 52bits = fraction
|
* f = 52bits = fraction
|
*/
|
*/
|
/* DOUBLE precision fixed:
|
/* DOUBLE precision fixed:
|
* siiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
|
* siiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
|
* s = 1bit = sign
|
* s = 1bit = sign
|
* i = 63bits = integer
|
* i = 63bits = integer
|
*/
|
*/
|
|
|
/* Extract sign-bit: */
|
/* Extract sign-bit: */
|
#define FP_S_s(v) (((v) & ((unsigned)1 << 31)) ? 1 : 0)
|
#define FP_S_s(v) (((v) & ((unsigned)1 << 31)) ? 1 : 0)
|
#define FP_D_s(v) (((v) & ((uword64)1 << 63)) ? 1 : 0)
|
#define FP_D_s(v) (((v) & ((uword64)1 << 63)) ? 1 : 0)
|
/* Extract biased exponent: */
|
/* Extract biased exponent: */
|
#define FP_S_be(v) (((v) >> 23) & 0xFF)
|
#define FP_S_be(v) (((v) >> 23) & 0xFF)
|
#define FP_D_be(v) (((v) >> 52) & 0x7FF)
|
#define FP_D_be(v) (((v) >> 52) & 0x7FF)
|
/* Extract unbiased Exponent: */
|
/* Extract unbiased Exponent: */
|
#define FP_S_e(v) (FP_S_be(v) - 0x7F)
|
#define FP_S_e(v) (FP_S_be(v) - 0x7F)
|
#define FP_D_e(v) (FP_D_be(v) - 0x3FF)
|
#define FP_D_e(v) (FP_D_be(v) - 0x3FF)
|
/* Extract complete fraction field: */
|
/* Extract complete fraction field: */
|
#define FP_S_f(v) ((v) & ~((unsigned)0x1FF << 23))
|
#define FP_S_f(v) ((v) & ~((unsigned)0x1FF << 23))
|
#define FP_D_f(v) ((v) & ~((uword64)0xFFF << 52))
|
#define FP_D_f(v) ((v) & ~((uword64)0xFFF << 52))
|
/* Extract numbered fraction bit: */
|
/* Extract numbered fraction bit: */
|
#define FP_S_fb(b,v) (((v) & (1 << (23 - (b)))) ? 1 : 0)
|
#define FP_S_fb(b,v) (((v) & (1 << (23 - (b)))) ? 1 : 0)
|
#define FP_D_fb(b,v) (((v) & (1 << (52 - (b)))) ? 1 : 0)
|
#define FP_D_fb(b,v) (((v) & (1 << (52 - (b)))) ? 1 : 0)
|
|
|
/* Explicit QNaN values used when value required: */
|
/* Explicit QNaN values used when value required: */
|
#define FPQNaN_SINGLE (0x7FBFFFFF)
|
#define FPQNaN_SINGLE (0x7FBFFFFF)
|
#define FPQNaN_WORD (0x7FFFFFFF)
|
#define FPQNaN_WORD (0x7FFFFFFF)
|
#define FPQNaN_DOUBLE (((uword64)0x7FF7FFFF << 32) | 0xFFFFFFFF)
|
#define FPQNaN_DOUBLE (((uword64)0x7FF7FFFF << 32) | 0xFFFFFFFF)
|
#define FPQNaN_LONG (((uword64)0x7FFFFFFF << 32) | 0xFFFFFFFF)
|
#define FPQNaN_LONG (((uword64)0x7FFFFFFF << 32) | 0xFFFFFFFF)
|
|
|
/* Explicit Infinity values used when required: */
|
/* Explicit Infinity values used when required: */
|
#define FPINF_SINGLE (0x7F800000)
|
#define FPINF_SINGLE (0x7F800000)
|
#define FPINF_DOUBLE (((uword64)0x7FF00000 << 32) | 0x00000000)
|
#define FPINF_DOUBLE (((uword64)0x7FF00000 << 32) | 0x00000000)
|
|
|
#define RMMODE(v) (((v) == FP_RM_NEAREST) ? "Round" : (((v) == FP_RM_TOZERO) ? "Trunc" : (((v) == FP_RM_TOPINF) ? "Ceil" : "Floor")))
|
#define RMMODE(v) (((v) == FP_RM_NEAREST) ? "Round" : (((v) == FP_RM_TOZERO) ? "Trunc" : (((v) == FP_RM_TOPINF) ? "Ceil" : "Floor")))
|
#define DOFMT(v) (((v) == fmt_single) ? "single" : (((v) == fmt_double) ? "double" : (((v) == fmt_word) ? "word" : (((v) == fmt_long) ? "long" : (((v) == fmt_unknown) ? "<unknown>" : (((v) == fmt_uninterpreted) ? "<uninterpreted>" : (((v) == fmt_uninterpreted_32) ? "<uninterpreted_32>" : (((v) == fmt_uninterpreted_64) ? "<uninterpreted_64>" : "<format error>"))))))))
|
#define DOFMT(v) (((v) == fmt_single) ? "single" : (((v) == fmt_double) ? "double" : (((v) == fmt_word) ? "word" : (((v) == fmt_long) ? "long" : (((v) == fmt_unknown) ? "<unknown>" : (((v) == fmt_uninterpreted) ? "<uninterpreted>" : (((v) == fmt_uninterpreted_32) ? "<uninterpreted_32>" : (((v) == fmt_uninterpreted_64) ? "<uninterpreted_64>" : "<format error>"))))))))
|
|
|
uword64
|
uword64
|
value_fpr (SIM_DESC sd,
|
value_fpr (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
int fpr,
|
int fpr,
|
FP_formats fmt)
|
FP_formats fmt)
|
{
|
{
|
uword64 value = 0;
|
uword64 value = 0;
|
int err = 0;
|
int err = 0;
|
|
|
/* Treat unused register values, as fixed-point 64bit values: */
|
/* Treat unused register values, as fixed-point 64bit values: */
|
if ((fmt == fmt_uninterpreted) || (fmt == fmt_unknown))
|
if ((fmt == fmt_uninterpreted) || (fmt == fmt_unknown))
|
#if 1
|
#if 1
|
/* If request to read data as "uninterpreted", then use the current
|
/* If request to read data as "uninterpreted", then use the current
|
encoding: */
|
encoding: */
|
fmt = FPR_STATE[fpr];
|
fmt = FPR_STATE[fpr];
|
#else
|
#else
|
fmt = fmt_long;
|
fmt = fmt_long;
|
#endif
|
#endif
|
|
|
/* For values not yet accessed, set to the desired format: */
|
/* For values not yet accessed, set to the desired format: */
|
if (FPR_STATE[fpr] == fmt_uninterpreted) {
|
if (FPR_STATE[fpr] == fmt_uninterpreted) {
|
FPR_STATE[fpr] = fmt;
|
FPR_STATE[fpr] = fmt;
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Register %d was fmt_uninterpreted. Now %s\n",fpr,DOFMT(fmt));
|
printf("DBG: Register %d was fmt_uninterpreted. Now %s\n",fpr,DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
}
|
}
|
if (fmt != FPR_STATE[fpr]) {
|
if (fmt != FPR_STATE[fpr]) {
|
sim_io_eprintf(sd,"FPR %d (format %s) being accessed with format %s - setting to unknown (PC = 0x%s)\n",fpr,DOFMT(FPR_STATE[fpr]),DOFMT(fmt),pr_addr(cia));
|
sim_io_eprintf(sd,"FPR %d (format %s) being accessed with format %s - setting to unknown (PC = 0x%s)\n",fpr,DOFMT(FPR_STATE[fpr]),DOFMT(fmt),pr_addr(cia));
|
FPR_STATE[fpr] = fmt_unknown;
|
FPR_STATE[fpr] = fmt_unknown;
|
}
|
}
|
|
|
if (FPR_STATE[fpr] == fmt_unknown) {
|
if (FPR_STATE[fpr] == fmt_unknown) {
|
/* Set QNaN value: */
|
/* Set QNaN value: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
value = FPQNaN_SINGLE;
|
value = FPQNaN_SINGLE;
|
break;
|
break;
|
|
|
case fmt_double:
|
case fmt_double:
|
value = FPQNaN_DOUBLE;
|
value = FPQNaN_DOUBLE;
|
break;
|
break;
|
|
|
case fmt_word:
|
case fmt_word:
|
value = FPQNaN_WORD;
|
value = FPQNaN_WORD;
|
break;
|
break;
|
|
|
case fmt_long:
|
case fmt_long:
|
value = FPQNaN_LONG;
|
value = FPQNaN_LONG;
|
break;
|
break;
|
|
|
default:
|
default:
|
err = -1;
|
err = -1;
|
break;
|
break;
|
}
|
}
|
} else if (SizeFGR() == 64) {
|
} else if (SizeFGR() == 64) {
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
case fmt_word:
|
case fmt_word:
|
value = (FGR[fpr] & 0xFFFFFFFF);
|
value = (FGR[fpr] & 0xFFFFFFFF);
|
break;
|
break;
|
|
|
case fmt_uninterpreted:
|
case fmt_uninterpreted:
|
case fmt_double:
|
case fmt_double:
|
case fmt_long:
|
case fmt_long:
|
value = FGR[fpr];
|
value = FGR[fpr];
|
break;
|
break;
|
|
|
default :
|
default :
|
err = -1;
|
err = -1;
|
break;
|
break;
|
}
|
}
|
} else {
|
} else {
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
case fmt_word:
|
case fmt_word:
|
value = (FGR[fpr] & 0xFFFFFFFF);
|
value = (FGR[fpr] & 0xFFFFFFFF);
|
break;
|
break;
|
|
|
case fmt_uninterpreted:
|
case fmt_uninterpreted:
|
case fmt_double:
|
case fmt_double:
|
case fmt_long:
|
case fmt_long:
|
if ((fpr & 1) == 0) { /* even registers only */
|
if ((fpr & 1) == 0) { /* even registers only */
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: ValueFPR: FGR[%d] = %s, FGR[%d] = %s\n",
|
printf("DBG: ValueFPR: FGR[%d] = %s, FGR[%d] = %s\n",
|
fpr+1, pr_uword64( (uword64) FGR[fpr+1] ),
|
fpr+1, pr_uword64( (uword64) FGR[fpr+1] ),
|
fpr, pr_uword64( (uword64) FGR[fpr] ));
|
fpr, pr_uword64( (uword64) FGR[fpr] ));
|
#endif
|
#endif
|
value = ((((uword64)FGR[fpr+1]) << 32) | (FGR[fpr] & 0xFFFFFFFF));
|
value = ((((uword64)FGR[fpr+1]) << 32) | (FGR[fpr] & 0xFFFFFFFF));
|
} else {
|
} else {
|
SignalException(ReservedInstruction,0);
|
SignalException(ReservedInstruction,0);
|
}
|
}
|
break;
|
break;
|
|
|
default :
|
default :
|
err = -1;
|
err = -1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (err)
|
if (err)
|
SignalExceptionSimulatorFault ("Unrecognised FP format in ValueFPR()");
|
SignalExceptionSimulatorFault ("Unrecognised FP format in ValueFPR()");
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: ValueFPR: fpr = %d, fmt = %s, value = 0x%s : PC = 0x%s : SizeFGR() = %d\n",fpr,DOFMT(fmt),pr_uword64(value),pr_addr(cia),SizeFGR());
|
printf("DBG: ValueFPR: fpr = %d, fmt = %s, value = 0x%s : PC = 0x%s : SizeFGR() = %d\n",fpr,DOFMT(fmt),pr_uword64(value),pr_addr(cia),SizeFGR());
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(value);
|
return(value);
|
}
|
}
|
|
|
void
|
void
|
store_fpr (SIM_DESC sd,
|
store_fpr (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
int fpr,
|
int fpr,
|
FP_formats fmt,
|
FP_formats fmt,
|
uword64 value)
|
uword64 value)
|
{
|
{
|
int err = 0;
|
int err = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: StoreFPR: fpr = %d, fmt = %s, value = 0x%s : PC = 0x%s : SizeFGR() = %d,\n",fpr,DOFMT(fmt),pr_uword64(value),pr_addr(cia),SizeFGR());
|
printf("DBG: StoreFPR: fpr = %d, fmt = %s, value = 0x%s : PC = 0x%s : SizeFGR() = %d,\n",fpr,DOFMT(fmt),pr_uword64(value),pr_addr(cia),SizeFGR());
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
if (SizeFGR() == 64) {
|
if (SizeFGR() == 64) {
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_uninterpreted_32:
|
case fmt_uninterpreted_32:
|
fmt = fmt_uninterpreted;
|
fmt = fmt_uninterpreted;
|
case fmt_single :
|
case fmt_single :
|
case fmt_word :
|
case fmt_word :
|
if (STATE_VERBOSE_P(SD))
|
if (STATE_VERBOSE_P(SD))
|
sim_io_eprintf (SD, "Warning: PC 0x%s: interp.c store_fpr DEADCODE\n",
|
sim_io_eprintf (SD, "Warning: PC 0x%s: interp.c store_fpr DEADCODE\n",
|
pr_addr(cia));
|
pr_addr(cia));
|
FGR[fpr] = (((uword64)0xDEADC0DE << 32) | (value & 0xFFFFFFFF));
|
FGR[fpr] = (((uword64)0xDEADC0DE << 32) | (value & 0xFFFFFFFF));
|
FPR_STATE[fpr] = fmt;
|
FPR_STATE[fpr] = fmt;
|
break;
|
break;
|
|
|
case fmt_uninterpreted_64:
|
case fmt_uninterpreted_64:
|
fmt = fmt_uninterpreted;
|
fmt = fmt_uninterpreted;
|
case fmt_uninterpreted:
|
case fmt_uninterpreted:
|
case fmt_double :
|
case fmt_double :
|
case fmt_long :
|
case fmt_long :
|
FGR[fpr] = value;
|
FGR[fpr] = value;
|
FPR_STATE[fpr] = fmt;
|
FPR_STATE[fpr] = fmt;
|
break;
|
break;
|
|
|
default :
|
default :
|
FPR_STATE[fpr] = fmt_unknown;
|
FPR_STATE[fpr] = fmt_unknown;
|
err = -1;
|
err = -1;
|
break;
|
break;
|
}
|
}
|
} else {
|
} else {
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_uninterpreted_32:
|
case fmt_uninterpreted_32:
|
fmt = fmt_uninterpreted;
|
fmt = fmt_uninterpreted;
|
case fmt_single :
|
case fmt_single :
|
case fmt_word :
|
case fmt_word :
|
FGR[fpr] = (value & 0xFFFFFFFF);
|
FGR[fpr] = (value & 0xFFFFFFFF);
|
FPR_STATE[fpr] = fmt;
|
FPR_STATE[fpr] = fmt;
|
break;
|
break;
|
|
|
case fmt_uninterpreted_64:
|
case fmt_uninterpreted_64:
|
fmt = fmt_uninterpreted;
|
fmt = fmt_uninterpreted;
|
case fmt_uninterpreted:
|
case fmt_uninterpreted:
|
case fmt_double :
|
case fmt_double :
|
case fmt_long :
|
case fmt_long :
|
if ((fpr & 1) == 0) { /* even register number only */
|
if ((fpr & 1) == 0) { /* even register number only */
|
FGR[fpr+1] = (value >> 32);
|
FGR[fpr+1] = (value >> 32);
|
FGR[fpr] = (value & 0xFFFFFFFF);
|
FGR[fpr] = (value & 0xFFFFFFFF);
|
FPR_STATE[fpr + 1] = fmt;
|
FPR_STATE[fpr + 1] = fmt;
|
FPR_STATE[fpr] = fmt;
|
FPR_STATE[fpr] = fmt;
|
} else {
|
} else {
|
FPR_STATE[fpr] = fmt_unknown;
|
FPR_STATE[fpr] = fmt_unknown;
|
FPR_STATE[fpr + 1] = fmt_unknown;
|
FPR_STATE[fpr + 1] = fmt_unknown;
|
SignalException(ReservedInstruction,0);
|
SignalException(ReservedInstruction,0);
|
}
|
}
|
break;
|
break;
|
|
|
default :
|
default :
|
FPR_STATE[fpr] = fmt_unknown;
|
FPR_STATE[fpr] = fmt_unknown;
|
err = -1;
|
err = -1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
#if defined(WARN_RESULT)
|
#if defined(WARN_RESULT)
|
else
|
else
|
UndefinedResult();
|
UndefinedResult();
|
#endif /* WARN_RESULT */
|
#endif /* WARN_RESULT */
|
|
|
if (err)
|
if (err)
|
SignalExceptionSimulatorFault ("Unrecognised FP format in StoreFPR()");
|
SignalExceptionSimulatorFault ("Unrecognised FP format in StoreFPR()");
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: StoreFPR: fpr[%d] = 0x%s (format %s)\n",fpr,pr_uword64(FGR[fpr]),DOFMT(fmt));
|
printf("DBG: StoreFPR: fpr[%d] = 0x%s (format %s)\n",fpr,pr_uword64(FGR[fpr]),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return;
|
return;
|
}
|
}
|
|
|
int
|
int
|
NaN(op,fmt)
|
NaN(op,fmt)
|
uword64 op;
|
uword64 op;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
int boolean = 0;
|
int boolean = 0;
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
case fmt_word:
|
case fmt_word:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu_32to (&wop, op);
|
sim_fpu_32to (&wop, op);
|
boolean = sim_fpu_is_nan (&wop);
|
boolean = sim_fpu_is_nan (&wop);
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
case fmt_long:
|
case fmt_long:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu_64to (&wop, op);
|
sim_fpu_64to (&wop, op);
|
boolean = sim_fpu_is_nan (&wop);
|
boolean = sim_fpu_is_nan (&wop);
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: NaN: returning %d for 0x%s (format = %s)\n",boolean,pr_addr(op),DOFMT(fmt));
|
printf("DBG: NaN: returning %d for 0x%s (format = %s)\n",boolean,pr_addr(op),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(boolean);
|
return(boolean);
|
}
|
}
|
|
|
int
|
int
|
Infinity(op,fmt)
|
Infinity(op,fmt)
|
uword64 op;
|
uword64 op;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
int boolean = 0;
|
int boolean = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Infinity: format %s 0x%s\n",DOFMT(fmt),pr_addr(op));
|
printf("DBG: Infinity: format %s 0x%s\n",DOFMT(fmt),pr_addr(op));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu_32to (&wop, op);
|
sim_fpu_32to (&wop, op);
|
boolean = sim_fpu_is_infinity (&wop);
|
boolean = sim_fpu_is_infinity (&wop);
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu_64to (&wop, op);
|
sim_fpu_64to (&wop, op);
|
boolean = sim_fpu_is_infinity (&wop);
|
boolean = sim_fpu_is_infinity (&wop);
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
printf("DBG: TODO: unrecognised format (%s) for Infinity check\n",DOFMT(fmt));
|
printf("DBG: TODO: unrecognised format (%s) for Infinity check\n",DOFMT(fmt));
|
break;
|
break;
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Infinity: returning %d for 0x%s (format = %s)\n",boolean,pr_addr(op),DOFMT(fmt));
|
printf("DBG: Infinity: returning %d for 0x%s (format = %s)\n",boolean,pr_addr(op),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(boolean);
|
return(boolean);
|
}
|
}
|
|
|
int
|
int
|
Less(op1,op2,fmt)
|
Less(op1,op2,fmt)
|
uword64 op1;
|
uword64 op1;
|
uword64 op2;
|
uword64 op2;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
int boolean = 0;
|
int boolean = 0;
|
|
|
/* Argument checking already performed by the FPCOMPARE code */
|
/* Argument checking already performed by the FPCOMPARE code */
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Less: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
printf("DBG: Less: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_32to (&wop2, op2);
|
boolean = sim_fpu_is_lt (&wop1, &wop2);
|
boolean = sim_fpu_is_lt (&wop1, &wop2);
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_64to (&wop2, op2);
|
boolean = sim_fpu_is_lt (&wop1, &wop2);
|
boolean = sim_fpu_is_lt (&wop1, &wop2);
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Less: returning %d (format = %s)\n",boolean,DOFMT(fmt));
|
printf("DBG: Less: returning %d (format = %s)\n",boolean,DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(boolean);
|
return(boolean);
|
}
|
}
|
|
|
int
|
int
|
Equal(op1,op2,fmt)
|
Equal(op1,op2,fmt)
|
uword64 op1;
|
uword64 op1;
|
uword64 op2;
|
uword64 op2;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
int boolean = 0;
|
int boolean = 0;
|
|
|
/* Argument checking already performed by the FPCOMPARE code */
|
/* Argument checking already performed by the FPCOMPARE code */
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Equal: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
printf("DBG: Equal: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_32to (&wop2, op2);
|
boolean = sim_fpu_is_eq (&wop1, &wop2);
|
boolean = sim_fpu_is_eq (&wop1, &wop2);
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_64to (&wop2, op2);
|
boolean = sim_fpu_is_eq (&wop1, &wop2);
|
boolean = sim_fpu_is_eq (&wop1, &wop2);
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Equal: returning %d (format = %s)\n",boolean,DOFMT(fmt));
|
printf("DBG: Equal: returning %d (format = %s)\n",boolean,DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(boolean);
|
return(boolean);
|
}
|
}
|
|
|
uword64
|
uword64
|
AbsoluteValue(op,fmt)
|
AbsoluteValue(op,fmt)
|
uword64 op;
|
uword64 op;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
uword64 result = 0;
|
uword64 result = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: AbsoluteValue: %s: op = 0x%s\n",DOFMT(fmt),pr_addr(op));
|
printf("DBG: AbsoluteValue: %s: op = 0x%s\n",DOFMT(fmt),pr_addr(op));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
unsigned32 ans;
|
unsigned32 ans;
|
sim_fpu_32to (&wop, op);
|
sim_fpu_32to (&wop, op);
|
sim_fpu_abs (&wop, &wop);
|
sim_fpu_abs (&wop, &wop);
|
sim_fpu_to32 (&ans, &wop);
|
sim_fpu_to32 (&ans, &wop);
|
result = ans;
|
result = ans;
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
unsigned64 ans;
|
unsigned64 ans;
|
sim_fpu_64to (&wop, op);
|
sim_fpu_64to (&wop, op);
|
sim_fpu_abs (&wop, &wop);
|
sim_fpu_abs (&wop, &wop);
|
sim_fpu_to64 (&ans, &wop);
|
sim_fpu_to64 (&ans, &wop);
|
result = ans;
|
result = ans;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
return(result);
|
return(result);
|
}
|
}
|
|
|
uword64
|
uword64
|
Negate(op,fmt)
|
Negate(op,fmt)
|
uword64 op;
|
uword64 op;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
uword64 result = 0;
|
uword64 result = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Negate: %s: op = 0x%s\n",DOFMT(fmt),pr_addr(op));
|
printf("DBG: Negate: %s: op = 0x%s\n",DOFMT(fmt),pr_addr(op));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
unsigned32 ans;
|
unsigned32 ans;
|
sim_fpu_32to (&wop, op);
|
sim_fpu_32to (&wop, op);
|
sim_fpu_neg (&wop, &wop);
|
sim_fpu_neg (&wop, &wop);
|
sim_fpu_to32 (&ans, &wop);
|
sim_fpu_to32 (&ans, &wop);
|
result = ans;
|
result = ans;
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
unsigned64 ans;
|
unsigned64 ans;
|
sim_fpu_64to (&wop, op);
|
sim_fpu_64to (&wop, op);
|
sim_fpu_neg (&wop, &wop);
|
sim_fpu_neg (&wop, &wop);
|
sim_fpu_to64 (&ans, &wop);
|
sim_fpu_to64 (&ans, &wop);
|
result = ans;
|
result = ans;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
return(result);
|
return(result);
|
}
|
}
|
|
|
uword64
|
uword64
|
Add(op1,op2,fmt)
|
Add(op1,op2,fmt)
|
uword64 op1;
|
uword64 op1;
|
uword64 op2;
|
uword64 op2;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
uword64 result = 0;
|
uword64 result = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Add: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
printf("DBG: Add: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The registers must specify FPRs valid for operands of type
|
/* The registers must specify FPRs valid for operands of type
|
"fmt". If they are not valid, the result is undefined. */
|
"fmt". If they are not valid, the result is undefined. */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned32 res;
|
unsigned32 res;
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_add (&ans, &wop1, &wop2);
|
sim_fpu_add (&ans, &wop1, &wop2);
|
sim_fpu_to32 (&res, &ans);
|
sim_fpu_to32 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned64 res;
|
unsigned64 res;
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_add (&ans, &wop1, &wop2);
|
sim_fpu_add (&ans, &wop1, &wop2);
|
sim_fpu_to64 (&res, &ans);
|
sim_fpu_to64 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Add: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
printf("DBG: Add: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result);
|
return(result);
|
}
|
}
|
|
|
uword64
|
uword64
|
Sub(op1,op2,fmt)
|
Sub(op1,op2,fmt)
|
uword64 op1;
|
uword64 op1;
|
uword64 op2;
|
uword64 op2;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
uword64 result = 0;
|
uword64 result = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Sub: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
printf("DBG: Sub: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The registers must specify FPRs valid for operands of type
|
/* The registers must specify FPRs valid for operands of type
|
"fmt". If they are not valid, the result is undefined. */
|
"fmt". If they are not valid, the result is undefined. */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned32 res;
|
unsigned32 res;
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_sub (&ans, &wop1, &wop2);
|
sim_fpu_sub (&ans, &wop1, &wop2);
|
sim_fpu_to32 (&res, &ans);
|
sim_fpu_to32 (&res, &ans);
|
result = res;
|
result = res;
|
}
|
}
|
break;
|
break;
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned64 res;
|
unsigned64 res;
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_sub (&ans, &wop1, &wop2);
|
sim_fpu_sub (&ans, &wop1, &wop2);
|
sim_fpu_to64 (&res, &ans);
|
sim_fpu_to64 (&res, &ans);
|
result = res;
|
result = res;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Sub: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
printf("DBG: Sub: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result);
|
return(result);
|
}
|
}
|
|
|
uword64
|
uword64
|
Multiply(op1,op2,fmt)
|
Multiply(op1,op2,fmt)
|
uword64 op1;
|
uword64 op1;
|
uword64 op2;
|
uword64 op2;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
uword64 result = 0;
|
uword64 result = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Multiply: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
printf("DBG: Multiply: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The registers must specify FPRs valid for operands of type
|
/* The registers must specify FPRs valid for operands of type
|
"fmt". If they are not valid, the result is undefined. */
|
"fmt". If they are not valid, the result is undefined. */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned32 res;
|
unsigned32 res;
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_mul (&ans, &wop1, &wop2);
|
sim_fpu_mul (&ans, &wop1, &wop2);
|
sim_fpu_to32 (&res, &ans);
|
sim_fpu_to32 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned64 res;
|
unsigned64 res;
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_mul (&ans, &wop1, &wop2);
|
sim_fpu_mul (&ans, &wop1, &wop2);
|
sim_fpu_to64 (&res, &ans);
|
sim_fpu_to64 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Multiply: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
printf("DBG: Multiply: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result);
|
return(result);
|
}
|
}
|
|
|
uword64
|
uword64
|
Divide(op1,op2,fmt)
|
Divide(op1,op2,fmt)
|
uword64 op1;
|
uword64 op1;
|
uword64 op2;
|
uword64 op2;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
uword64 result = 0;
|
uword64 result = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Divide: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
printf("DBG: Divide: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The registers must specify FPRs valid for operands of type
|
/* The registers must specify FPRs valid for operands of type
|
"fmt". If they are not valid, the result is undefined. */
|
"fmt". If they are not valid, the result is undefined. */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned32 res;
|
unsigned32 res;
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_div (&ans, &wop1, &wop2);
|
sim_fpu_div (&ans, &wop1, &wop2);
|
sim_fpu_to32 (&res, &ans);
|
sim_fpu_to32 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned64 res;
|
unsigned64 res;
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_div (&ans, &wop1, &wop2);
|
sim_fpu_div (&ans, &wop1, &wop2);
|
sim_fpu_to64 (&res, &ans);
|
sim_fpu_to64 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Divide: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
printf("DBG: Divide: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result);
|
return(result);
|
}
|
}
|
|
|
uword64 UNUSED
|
uword64 UNUSED
|
Recip(op,fmt)
|
Recip(op,fmt)
|
uword64 op;
|
uword64 op;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
uword64 result = 0;
|
uword64 result = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Recip: %s: op = 0x%s\n",DOFMT(fmt),pr_addr(op));
|
printf("DBG: Recip: %s: op = 0x%s\n",DOFMT(fmt),pr_addr(op));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The registers must specify FPRs valid for operands of type
|
/* The registers must specify FPRs valid for operands of type
|
"fmt". If they are not valid, the result is undefined. */
|
"fmt". If they are not valid, the result is undefined. */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned32 res;
|
unsigned32 res;
|
sim_fpu_32to (&wop, op);
|
sim_fpu_32to (&wop, op);
|
sim_fpu_inv (&ans, &wop);
|
sim_fpu_inv (&ans, &wop);
|
sim_fpu_to32 (&res, &ans);
|
sim_fpu_to32 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned64 res;
|
unsigned64 res;
|
sim_fpu_64to (&wop, op);
|
sim_fpu_64to (&wop, op);
|
sim_fpu_inv (&ans, &wop);
|
sim_fpu_inv (&ans, &wop);
|
sim_fpu_to64 (&res, &ans);
|
sim_fpu_to64 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Recip: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
printf("DBG: Recip: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result);
|
return(result);
|
}
|
}
|
|
|
uword64
|
uword64
|
SquareRoot(op,fmt)
|
SquareRoot(op,fmt)
|
uword64 op;
|
uword64 op;
|
FP_formats fmt;
|
FP_formats fmt;
|
{
|
{
|
uword64 result = 0;
|
uword64 result = 0;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: SquareRoot: %s: op = 0x%s\n",DOFMT(fmt),pr_addr(op));
|
printf("DBG: SquareRoot: %s: op = 0x%s\n",DOFMT(fmt),pr_addr(op));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The registers must specify FPRs valid for operands of type
|
/* The registers must specify FPRs valid for operands of type
|
"fmt". If they are not valid, the result is undefined. */
|
"fmt". If they are not valid, the result is undefined. */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt) {
|
switch (fmt) {
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned32 res;
|
unsigned32 res;
|
sim_fpu_32to (&wop, op);
|
sim_fpu_32to (&wop, op);
|
sim_fpu_sqrt (&ans, &wop);
|
sim_fpu_sqrt (&ans, &wop);
|
sim_fpu_to32 (&res, &ans);
|
sim_fpu_to32 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu ans;
|
sim_fpu ans;
|
unsigned64 res;
|
unsigned64 res;
|
sim_fpu_64to (&wop, op);
|
sim_fpu_64to (&wop, op);
|
sim_fpu_sqrt (&ans, &wop);
|
sim_fpu_sqrt (&ans, &wop);
|
sim_fpu_to64 (&res, &ans);
|
sim_fpu_to64 (&res, &ans);
|
result = res;
|
result = res;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: SquareRoot: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
printf("DBG: SquareRoot: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result);
|
return(result);
|
}
|
}
|
|
|
#if 0
|
#if 0
|
uword64
|
uword64
|
Max (uword64 op1,
|
Max (uword64 op1,
|
uword64 op2,
|
uword64 op2,
|
FP_formats fmt)
|
FP_formats fmt)
|
{
|
{
|
int cmp;
|
int cmp;
|
unsigned64 result;
|
unsigned64 result;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Max: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
printf("DBG: Max: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The registers must specify FPRs valid for operands of type
|
/* The registers must specify FPRs valid for operands of type
|
"fmt". If they are not valid, the result is undefined. */
|
"fmt". If they are not valid, the result is undefined. */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt)
|
switch (fmt)
|
{
|
{
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_32to (&wop2, op2);
|
cmp = sim_fpu_cmp (&wop1, &wop2);
|
cmp = sim_fpu_cmp (&wop1, &wop2);
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_64to (&wop2, op2);
|
cmp = sim_fpu_cmp (&wop1, &wop2);
|
cmp = sim_fpu_cmp (&wop1, &wop2);
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
switch (cmp)
|
switch (cmp)
|
{
|
{
|
case SIM_FPU_IS_SNAN:
|
case SIM_FPU_IS_SNAN:
|
case SIM_FPU_IS_QNAN:
|
case SIM_FPU_IS_QNAN:
|
result = op1;
|
result = op1;
|
case SIM_FPU_IS_NINF:
|
case SIM_FPU_IS_NINF:
|
case SIM_FPU_IS_NNUMBER:
|
case SIM_FPU_IS_NNUMBER:
|
case SIM_FPU_IS_NDENORM:
|
case SIM_FPU_IS_NDENORM:
|
case SIM_FPU_IS_NZERO:
|
case SIM_FPU_IS_NZERO:
|
result = op2; /* op1 - op2 < 0 */
|
result = op2; /* op1 - op2 < 0 */
|
case SIM_FPU_IS_PINF:
|
case SIM_FPU_IS_PINF:
|
case SIM_FPU_IS_PNUMBER:
|
case SIM_FPU_IS_PNUMBER:
|
case SIM_FPU_IS_PDENORM:
|
case SIM_FPU_IS_PDENORM:
|
case SIM_FPU_IS_PZERO:
|
case SIM_FPU_IS_PZERO:
|
result = op1; /* op1 - op2 > 0 */
|
result = op1; /* op1 - op2 > 0 */
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Max: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
printf("DBG: Max: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result);
|
return(result);
|
}
|
}
|
#endif
|
#endif
|
|
|
#if 0
|
#if 0
|
uword64
|
uword64
|
Min (uword64 op1,
|
Min (uword64 op1,
|
uword64 op2,
|
uword64 op2,
|
FP_formats fmt)
|
FP_formats fmt)
|
{
|
{
|
int cmp;
|
int cmp;
|
unsigned64 result;
|
unsigned64 result;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Min: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
printf("DBG: Min: %s: op1 = 0x%s : op2 = 0x%s\n",DOFMT(fmt),pr_addr(op1),pr_addr(op2));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* The registers must specify FPRs valid for operands of type
|
/* The registers must specify FPRs valid for operands of type
|
"fmt". If they are not valid, the result is undefined. */
|
"fmt". If they are not valid, the result is undefined. */
|
|
|
/* The format type should already have been checked: */
|
/* The format type should already have been checked: */
|
switch (fmt)
|
switch (fmt)
|
{
|
{
|
case fmt_single:
|
case fmt_single:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop1, op1);
|
sim_fpu_32to (&wop2, op2);
|
sim_fpu_32to (&wop2, op2);
|
cmp = sim_fpu_cmp (&wop1, &wop2);
|
cmp = sim_fpu_cmp (&wop1, &wop2);
|
break;
|
break;
|
}
|
}
|
case fmt_double:
|
case fmt_double:
|
{
|
{
|
sim_fpu wop1;
|
sim_fpu wop1;
|
sim_fpu wop2;
|
sim_fpu wop2;
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop1, op1);
|
sim_fpu_64to (&wop2, op2);
|
sim_fpu_64to (&wop2, op2);
|
cmp = sim_fpu_cmp (&wop1, &wop2);
|
cmp = sim_fpu_cmp (&wop1, &wop2);
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
switch (cmp)
|
switch (cmp)
|
{
|
{
|
case SIM_FPU_IS_SNAN:
|
case SIM_FPU_IS_SNAN:
|
case SIM_FPU_IS_QNAN:
|
case SIM_FPU_IS_QNAN:
|
result = op1;
|
result = op1;
|
case SIM_FPU_IS_NINF:
|
case SIM_FPU_IS_NINF:
|
case SIM_FPU_IS_NNUMBER:
|
case SIM_FPU_IS_NNUMBER:
|
case SIM_FPU_IS_NDENORM:
|
case SIM_FPU_IS_NDENORM:
|
case SIM_FPU_IS_NZERO:
|
case SIM_FPU_IS_NZERO:
|
result = op1; /* op1 - op2 < 0 */
|
result = op1; /* op1 - op2 < 0 */
|
case SIM_FPU_IS_PINF:
|
case SIM_FPU_IS_PINF:
|
case SIM_FPU_IS_PNUMBER:
|
case SIM_FPU_IS_PNUMBER:
|
case SIM_FPU_IS_PDENORM:
|
case SIM_FPU_IS_PDENORM:
|
case SIM_FPU_IS_PZERO:
|
case SIM_FPU_IS_PZERO:
|
result = op2; /* op1 - op2 > 0 */
|
result = op2; /* op1 - op2 > 0 */
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Min: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
printf("DBG: Min: returning 0x%s (format = %s)\n",pr_addr(result),DOFMT(fmt));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result);
|
return(result);
|
}
|
}
|
#endif
|
#endif
|
|
|
uword64
|
uword64
|
convert (SIM_DESC sd,
|
convert (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
int rm,
|
int rm,
|
uword64 op,
|
uword64 op,
|
FP_formats from,
|
FP_formats from,
|
FP_formats to)
|
FP_formats to)
|
{
|
{
|
sim_fpu wop;
|
sim_fpu wop;
|
sim_fpu_round round;
|
sim_fpu_round round;
|
unsigned32 result32;
|
unsigned32 result32;
|
unsigned64 result64;
|
unsigned64 result64;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
#if 0 /* FIXME: doesn't compile */
|
#if 0 /* FIXME: doesn't compile */
|
printf("DBG: Convert: mode %s : op 0x%s : from %s : to %s : (PC = 0x%s)\n",RMMODE(rm),pr_addr(op),DOFMT(from),DOFMT(to),pr_addr(IPC));
|
printf("DBG: Convert: mode %s : op 0x%s : from %s : to %s : (PC = 0x%s)\n",RMMODE(rm),pr_addr(op),DOFMT(from),DOFMT(to),pr_addr(IPC));
|
#endif
|
#endif
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
switch (rm)
|
switch (rm)
|
{
|
{
|
case FP_RM_NEAREST:
|
case FP_RM_NEAREST:
|
/* Round result to nearest representable value. When two
|
/* Round result to nearest representable value. When two
|
representable values are equally near, round to the value
|
representable values are equally near, round to the value
|
that has a least significant bit of zero (i.e. is even). */
|
that has a least significant bit of zero (i.e. is even). */
|
round = sim_fpu_round_near;
|
round = sim_fpu_round_near;
|
break;
|
break;
|
case FP_RM_TOZERO:
|
case FP_RM_TOZERO:
|
/* Round result to the value closest to, and not greater in
|
/* Round result to the value closest to, and not greater in
|
magnitude than, the result. */
|
magnitude than, the result. */
|
round = sim_fpu_round_zero;
|
round = sim_fpu_round_zero;
|
break;
|
break;
|
case FP_RM_TOPINF:
|
case FP_RM_TOPINF:
|
/* Round result to the value closest to, and not less than,
|
/* Round result to the value closest to, and not less than,
|
the result. */
|
the result. */
|
round = sim_fpu_round_up;
|
round = sim_fpu_round_up;
|
break;
|
break;
|
|
|
case FP_RM_TOMINF:
|
case FP_RM_TOMINF:
|
/* Round result to the value closest to, and not greater than,
|
/* Round result to the value closest to, and not greater than,
|
the result. */
|
the result. */
|
round = sim_fpu_round_down;
|
round = sim_fpu_round_down;
|
break;
|
break;
|
default:
|
default:
|
round = 0;
|
round = 0;
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
/* Convert the input to sim_fpu internal format */
|
/* Convert the input to sim_fpu internal format */
|
switch (from)
|
switch (from)
|
{
|
{
|
case fmt_double:
|
case fmt_double:
|
sim_fpu_64to (&wop, op);
|
sim_fpu_64to (&wop, op);
|
break;
|
break;
|
case fmt_single:
|
case fmt_single:
|
sim_fpu_32to (&wop, op);
|
sim_fpu_32to (&wop, op);
|
break;
|
break;
|
case fmt_word:
|
case fmt_word:
|
sim_fpu_i32to (&wop, op, round);
|
sim_fpu_i32to (&wop, op, round);
|
break;
|
break;
|
case fmt_long:
|
case fmt_long:
|
sim_fpu_i64to (&wop, op, round);
|
sim_fpu_i64to (&wop, op, round);
|
break;
|
break;
|
default:
|
default:
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
/* Convert sim_fpu format into the output */
|
/* Convert sim_fpu format into the output */
|
/* The value WOP is converted to the destination format, rounding
|
/* The value WOP is converted to the destination format, rounding
|
using mode RM. When the destination is a fixed-point format, then
|
using mode RM. When the destination is a fixed-point format, then
|
a source value of Infinity, NaN or one which would round to an
|
a source value of Infinity, NaN or one which would round to an
|
integer outside the fixed point range then an IEEE Invalid
|
integer outside the fixed point range then an IEEE Invalid
|
Operation condition is raised. */
|
Operation condition is raised. */
|
switch (to)
|
switch (to)
|
{
|
{
|
case fmt_single:
|
case fmt_single:
|
sim_fpu_round_32 (&wop, round, 0);
|
sim_fpu_round_32 (&wop, round, 0);
|
sim_fpu_to32 (&result32, &wop);
|
sim_fpu_to32 (&result32, &wop);
|
result64 = result32;
|
result64 = result32;
|
break;
|
break;
|
case fmt_double:
|
case fmt_double:
|
sim_fpu_round_64 (&wop, round, 0);
|
sim_fpu_round_64 (&wop, round, 0);
|
sim_fpu_to64 (&result64, &wop);
|
sim_fpu_to64 (&result64, &wop);
|
break;
|
break;
|
case fmt_word:
|
case fmt_word:
|
sim_fpu_to32i (&result32, &wop, round);
|
sim_fpu_to32i (&result32, &wop, round);
|
result64 = result32;
|
result64 = result32;
|
break;
|
break;
|
case fmt_long:
|
case fmt_long:
|
sim_fpu_to64i (&result64, &wop, round);
|
sim_fpu_to64i (&result64, &wop, round);
|
break;
|
break;
|
default:
|
default:
|
result64 = 0;
|
result64 = 0;
|
fprintf (stderr, "Bad switch\n");
|
fprintf (stderr, "Bad switch\n");
|
abort ();
|
abort ();
|
}
|
}
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: Convert: returning 0x%s (to format = %s)\n",pr_addr(result64),DOFMT(to));
|
printf("DBG: Convert: returning 0x%s (to format = %s)\n",pr_addr(result64),DOFMT(to));
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
return(result64);
|
return(result64);
|
}
|
}
|
|
|
|
|
/*-- co-processor support routines ------------------------------------------*/
|
/*-- co-processor support routines ------------------------------------------*/
|
|
|
static int UNUSED
|
static int UNUSED
|
CoProcPresent(unsigned int coproc_number)
|
CoProcPresent(unsigned int coproc_number)
|
{
|
{
|
/* Return TRUE if simulator provides a model for the given co-processor number */
|
/* Return TRUE if simulator provides a model for the given co-processor number */
|
return(0);
|
return(0);
|
}
|
}
|
|
|
void
|
void
|
cop_lw (SIM_DESC sd,
|
cop_lw (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
int coproc_num,
|
int coproc_num,
|
int coproc_reg,
|
int coproc_reg,
|
unsigned int memword)
|
unsigned int memword)
|
{
|
{
|
switch (coproc_num)
|
switch (coproc_num)
|
{
|
{
|
case 1:
|
case 1:
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
{
|
{
|
#ifdef DEBUG
|
#ifdef DEBUG
|
printf("DBG: COP_LW: memword = 0x%08X (uword64)memword = 0x%s\n",memword,pr_addr(memword));
|
printf("DBG: COP_LW: memword = 0x%08X (uword64)memword = 0x%s\n",memword,pr_addr(memword));
|
#endif
|
#endif
|
StoreFPR(coproc_reg,fmt_word,(uword64)memword);
|
StoreFPR(coproc_reg,fmt_word,(uword64)memword);
|
FPR_STATE[coproc_reg] = fmt_uninterpreted;
|
FPR_STATE[coproc_reg] = fmt_uninterpreted;
|
break;
|
break;
|
}
|
}
|
|
|
default:
|
default:
|
#if 0 /* this should be controlled by a configuration option */
|
#if 0 /* this should be controlled by a configuration option */
|
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));
|
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));
|
#endif
|
#endif
|
break;
|
break;
|
}
|
}
|
|
|
return;
|
return;
|
}
|
}
|
|
|
void
|
void
|
cop_ld (SIM_DESC sd,
|
cop_ld (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
int coproc_num,
|
int coproc_num,
|
int coproc_reg,
|
int coproc_reg,
|
uword64 memword)
|
uword64 memword)
|
{
|
{
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
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) );
|
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) );
|
#endif
|
#endif
|
|
|
switch (coproc_num) {
|
switch (coproc_num) {
|
case 1:
|
case 1:
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
{
|
{
|
StoreFPR(coproc_reg,fmt_uninterpreted,memword);
|
StoreFPR(coproc_reg,fmt_uninterpreted,memword);
|
break;
|
break;
|
}
|
}
|
|
|
default:
|
default:
|
#if 0 /* this message should be controlled by a configuration option */
|
#if 0 /* this message should be controlled by a configuration option */
|
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));
|
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));
|
#endif
|
#endif
|
break;
|
break;
|
}
|
}
|
|
|
return;
|
return;
|
}
|
}
|
|
|
|
|
|
|
|
|
unsigned int
|
unsigned int
|
cop_sw (SIM_DESC sd,
|
cop_sw (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
int coproc_num,
|
int coproc_num,
|
int coproc_reg)
|
int coproc_reg)
|
{
|
{
|
unsigned int value = 0;
|
unsigned int value = 0;
|
|
|
switch (coproc_num)
|
switch (coproc_num)
|
{
|
{
|
case 1:
|
case 1:
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
{
|
{
|
FP_formats hold;
|
FP_formats hold;
|
hold = FPR_STATE[coproc_reg];
|
hold = FPR_STATE[coproc_reg];
|
FPR_STATE[coproc_reg] = fmt_word;
|
FPR_STATE[coproc_reg] = fmt_word;
|
value = (unsigned int)ValueFPR(coproc_reg,fmt_uninterpreted);
|
value = (unsigned int)ValueFPR(coproc_reg,fmt_uninterpreted);
|
FPR_STATE[coproc_reg] = hold;
|
FPR_STATE[coproc_reg] = hold;
|
break;
|
break;
|
}
|
}
|
|
|
default:
|
default:
|
#if 0 /* should be controlled by configuration option */
|
#if 0 /* should be controlled by configuration option */
|
sim_io_printf(sd,"COP_SW(%d,%d) at PC = 0x%s : TODO (architecture specific)\n",coproc_num,coproc_reg,pr_addr(cia));
|
sim_io_printf(sd,"COP_SW(%d,%d) at PC = 0x%s : TODO (architecture specific)\n",coproc_num,coproc_reg,pr_addr(cia));
|
#endif
|
#endif
|
break;
|
break;
|
}
|
}
|
|
|
return(value);
|
return(value);
|
}
|
}
|
|
|
uword64
|
uword64
|
cop_sd (SIM_DESC sd,
|
cop_sd (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
int coproc_num,
|
int coproc_num,
|
int coproc_reg)
|
int coproc_reg)
|
{
|
{
|
uword64 value = 0;
|
uword64 value = 0;
|
switch (coproc_num)
|
switch (coproc_num)
|
{
|
{
|
case 1:
|
case 1:
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
if (CURRENT_FLOATING_POINT == HARD_FLOATING_POINT)
|
{
|
{
|
value = ValueFPR(coproc_reg,fmt_uninterpreted);
|
value = ValueFPR(coproc_reg,fmt_uninterpreted);
|
break;
|
break;
|
}
|
}
|
|
|
default:
|
default:
|
#if 0 /* should be controlled by configuration option */
|
#if 0 /* should be controlled by configuration option */
|
sim_io_printf(sd,"COP_SD(%d,%d) at PC = 0x%s : TODO (architecture specific)\n",coproc_num,coproc_reg,pr_addr(cia));
|
sim_io_printf(sd,"COP_SD(%d,%d) at PC = 0x%s : TODO (architecture specific)\n",coproc_num,coproc_reg,pr_addr(cia));
|
#endif
|
#endif
|
break;
|
break;
|
}
|
}
|
|
|
return(value);
|
return(value);
|
}
|
}
|
|
|
|
|
|
|
|
|
void
|
void
|
decode_coproc (SIM_DESC sd,
|
decode_coproc (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
address_word cia,
|
address_word cia,
|
unsigned int instruction)
|
unsigned int instruction)
|
{
|
{
|
int coprocnum = ((instruction >> 26) & 3);
|
int coprocnum = ((instruction >> 26) & 3);
|
|
|
switch (coprocnum)
|
switch (coprocnum)
|
{
|
{
|
case 0: /* standard CPU control and cache registers */
|
case 0: /* standard CPU control and cache registers */
|
{
|
{
|
int code = ((instruction >> 21) & 0x1F);
|
int code = ((instruction >> 21) & 0x1F);
|
int rt = ((instruction >> 16) & 0x1F);
|
int rt = ((instruction >> 16) & 0x1F);
|
int rd = ((instruction >> 11) & 0x1F);
|
int rd = ((instruction >> 11) & 0x1F);
|
int tail = instruction & 0x3ff;
|
int tail = instruction & 0x3ff;
|
/* R4000 Users Manual (second edition) lists the following CP0
|
/* R4000 Users Manual (second edition) lists the following CP0
|
instructions:
|
instructions:
|
CODE><-RT><RD-><--TAIL--->
|
CODE><-RT><RD-><--TAIL--->
|
DMFC0 Doubleword Move From CP0 (VR4100 = 01000000001tttttddddd00000000000)
|
DMFC0 Doubleword Move From CP0 (VR4100 = 01000000001tttttddddd00000000000)
|
DMTC0 Doubleword Move To CP0 (VR4100 = 01000000101tttttddddd00000000000)
|
DMTC0 Doubleword Move To CP0 (VR4100 = 01000000101tttttddddd00000000000)
|
MFC0 word Move From CP0 (VR4100 = 01000000000tttttddddd00000000000)
|
MFC0 word Move From CP0 (VR4100 = 01000000000tttttddddd00000000000)
|
MTC0 word Move To CP0 (VR4100 = 01000000100tttttddddd00000000000)
|
MTC0 word Move To CP0 (VR4100 = 01000000100tttttddddd00000000000)
|
TLBR Read Indexed TLB Entry (VR4100 = 01000010000000000000000000000001)
|
TLBR Read Indexed TLB Entry (VR4100 = 01000010000000000000000000000001)
|
TLBWI Write Indexed TLB Entry (VR4100 = 01000010000000000000000000000010)
|
TLBWI Write Indexed TLB Entry (VR4100 = 01000010000000000000000000000010)
|
TLBWR Write Random TLB Entry (VR4100 = 01000010000000000000000000000110)
|
TLBWR Write Random TLB Entry (VR4100 = 01000010000000000000000000000110)
|
TLBP Probe TLB for Matching Entry (VR4100 = 01000010000000000000000000001000)
|
TLBP Probe TLB for Matching Entry (VR4100 = 01000010000000000000000000001000)
|
CACHE Cache operation (VR4100 = 101111bbbbbpppppiiiiiiiiiiiiiiii)
|
CACHE Cache operation (VR4100 = 101111bbbbbpppppiiiiiiiiiiiiiiii)
|
ERET Exception return (VR4100 = 01000010000000000000000000011000)
|
ERET Exception return (VR4100 = 01000010000000000000000000011000)
|
*/
|
*/
|
if (((code == 0x00) || (code == 0x04) /* MFC0 / MTC0 */
|
if (((code == 0x00) || (code == 0x04) /* MFC0 / MTC0 */
|
|| (code == 0x01) || (code == 0x05)) /* DMFC0 / DMTC0 */
|
|| (code == 0x01) || (code == 0x05)) /* DMFC0 / DMTC0 */
|
&& tail == 0)
|
&& tail == 0)
|
{
|
{
|
/* Clear double/single coprocessor move bit. */
|
/* Clear double/single coprocessor move bit. */
|
code &= ~1;
|
code &= ~1;
|
|
|
/* M[TF]C0 (32 bits) | DM[TF]C0 (64 bits) */
|
/* M[TF]C0 (32 bits) | DM[TF]C0 (64 bits) */
|
|
|
switch (rd) /* NOTEs: Standard CP0 registers */
|
switch (rd) /* NOTEs: Standard CP0 registers */
|
{
|
{
|
/* 0 = Index R4000 VR4100 VR4300 */
|
/* 0 = Index R4000 VR4100 VR4300 */
|
/* 1 = Random R4000 VR4100 VR4300 */
|
/* 1 = Random R4000 VR4100 VR4300 */
|
/* 2 = EntryLo0 R4000 VR4100 VR4300 */
|
/* 2 = EntryLo0 R4000 VR4100 VR4300 */
|
/* 3 = EntryLo1 R4000 VR4100 VR4300 */
|
/* 3 = EntryLo1 R4000 VR4100 VR4300 */
|
/* 4 = Context R4000 VR4100 VR4300 */
|
/* 4 = Context R4000 VR4100 VR4300 */
|
/* 5 = PageMask R4000 VR4100 VR4300 */
|
/* 5 = PageMask R4000 VR4100 VR4300 */
|
/* 6 = Wired R4000 VR4100 VR4300 */
|
/* 6 = Wired R4000 VR4100 VR4300 */
|
/* 8 = BadVAddr R4000 VR4100 VR4300 */
|
/* 8 = BadVAddr R4000 VR4100 VR4300 */
|
/* 9 = Count R4000 VR4100 VR4300 */
|
/* 9 = Count R4000 VR4100 VR4300 */
|
/* 10 = EntryHi R4000 VR4100 VR4300 */
|
/* 10 = EntryHi R4000 VR4100 VR4300 */
|
/* 11 = Compare R4000 VR4100 VR4300 */
|
/* 11 = Compare R4000 VR4100 VR4300 */
|
/* 12 = SR R4000 VR4100 VR4300 */
|
/* 12 = SR R4000 VR4100 VR4300 */
|
#ifdef SUBTARGET_R3900
|
#ifdef SUBTARGET_R3900
|
case 3:
|
case 3:
|
/* 3 = Config R3900 */
|
/* 3 = Config R3900 */
|
case 7:
|
case 7:
|
/* 7 = Cache R3900 */
|
/* 7 = Cache R3900 */
|
case 15:
|
case 15:
|
/* 15 = PRID R3900 */
|
/* 15 = PRID R3900 */
|
|
|
/* ignore */
|
/* ignore */
|
break;
|
break;
|
|
|
case 8:
|
case 8:
|
/* 8 = BadVAddr R4000 VR4100 VR4300 */
|
/* 8 = BadVAddr R4000 VR4100 VR4300 */
|
if (code == 0x00)
|
if (code == 0x00)
|
GPR[rt] = COP0_BADVADDR;
|
GPR[rt] = COP0_BADVADDR;
|
else
|
else
|
COP0_BADVADDR = GPR[rt];
|
COP0_BADVADDR = GPR[rt];
|
break;
|
break;
|
|
|
#endif /* SUBTARGET_R3900 */
|
#endif /* SUBTARGET_R3900 */
|
case 12:
|
case 12:
|
if (code == 0x00)
|
if (code == 0x00)
|
GPR[rt] = SR;
|
GPR[rt] = SR;
|
else
|
else
|
SR = GPR[rt];
|
SR = GPR[rt];
|
break;
|
break;
|
/* 13 = Cause R4000 VR4100 VR4300 */
|
/* 13 = Cause R4000 VR4100 VR4300 */
|
case 13:
|
case 13:
|
if (code == 0x00)
|
if (code == 0x00)
|
GPR[rt] = CAUSE;
|
GPR[rt] = CAUSE;
|
else
|
else
|
CAUSE = GPR[rt];
|
CAUSE = GPR[rt];
|
break;
|
break;
|
/* 14 = EPC R4000 VR4100 VR4300 */
|
/* 14 = EPC R4000 VR4100 VR4300 */
|
case 14:
|
case 14:
|
if (code == 0x00)
|
if (code == 0x00)
|
GPR[rt] = (signed_word) (signed_address) EPC;
|
GPR[rt] = (signed_word) (signed_address) EPC;
|
else
|
else
|
EPC = GPR[rt];
|
EPC = GPR[rt];
|
break;
|
break;
|
/* 15 = PRId R4000 VR4100 VR4300 */
|
/* 15 = PRId R4000 VR4100 VR4300 */
|
#ifdef SUBTARGET_R3900
|
#ifdef SUBTARGET_R3900
|
/* 16 = Debug */
|
/* 16 = Debug */
|
case 16:
|
case 16:
|
if (code == 0x00)
|
if (code == 0x00)
|
GPR[rt] = Debug;
|
GPR[rt] = Debug;
|
else
|
else
|
Debug = GPR[rt];
|
Debug = GPR[rt];
|
break;
|
break;
|
#else
|
#else
|
/* 16 = Config R4000 VR4100 VR4300 */
|
/* 16 = Config R4000 VR4100 VR4300 */
|
case 16:
|
case 16:
|
if (code == 0x00)
|
if (code == 0x00)
|
GPR[rt] = C0_CONFIG;
|
GPR[rt] = C0_CONFIG;
|
else
|
else
|
C0_CONFIG = GPR[rt];
|
C0_CONFIG = GPR[rt];
|
break;
|
break;
|
#endif
|
#endif
|
#ifdef SUBTARGET_R3900
|
#ifdef SUBTARGET_R3900
|
/* 17 = Debug */
|
/* 17 = Debug */
|
case 17:
|
case 17:
|
if (code == 0x00)
|
if (code == 0x00)
|
GPR[rt] = DEPC;
|
GPR[rt] = DEPC;
|
else
|
else
|
DEPC = GPR[rt];
|
DEPC = GPR[rt];
|
break;
|
break;
|
#else
|
#else
|
/* 17 = LLAddr R4000 VR4100 VR4300 */
|
/* 17 = LLAddr R4000 VR4100 VR4300 */
|
#endif
|
#endif
|
/* 18 = WatchLo R4000 VR4100 VR4300 */
|
/* 18 = WatchLo R4000 VR4100 VR4300 */
|
/* 19 = WatchHi R4000 VR4100 VR4300 */
|
/* 19 = WatchHi R4000 VR4100 VR4300 */
|
/* 20 = XContext R4000 VR4100 VR4300 */
|
/* 20 = XContext R4000 VR4100 VR4300 */
|
/* 26 = PErr or ECC R4000 VR4100 VR4300 */
|
/* 26 = PErr or ECC R4000 VR4100 VR4300 */
|
/* 27 = CacheErr R4000 VR4100 */
|
/* 27 = CacheErr R4000 VR4100 */
|
/* 28 = TagLo R4000 VR4100 VR4300 */
|
/* 28 = TagLo R4000 VR4100 VR4300 */
|
/* 29 = TagHi R4000 VR4100 VR4300 */
|
/* 29 = TagHi R4000 VR4100 VR4300 */
|
/* 30 = ErrorEPC R4000 VR4100 VR4300 */
|
/* 30 = ErrorEPC R4000 VR4100 VR4300 */
|
if (STATE_VERBOSE_P(SD))
|
if (STATE_VERBOSE_P(SD))
|
sim_io_eprintf (SD,
|
sim_io_eprintf (SD,
|
"Warning: PC 0x%lx:interp.c decode_coproc DEADC0DE\n",
|
"Warning: PC 0x%lx:interp.c decode_coproc DEADC0DE\n",
|
(unsigned long)cia);
|
(unsigned long)cia);
|
GPR[rt] = 0xDEADC0DE; /* CPR[0,rd] */
|
GPR[rt] = 0xDEADC0DE; /* CPR[0,rd] */
|
/* CPR[0,rd] = GPR[rt]; */
|
/* CPR[0,rd] = GPR[rt]; */
|
default:
|
default:
|
if (code == 0x00)
|
if (code == 0x00)
|
GPR[rt] = (signed_word) (signed32) COP0_GPR[rd];
|
GPR[rt] = (signed_word) (signed32) COP0_GPR[rd];
|
else
|
else
|
COP0_GPR[rd] = GPR[rt];
|
COP0_GPR[rd] = GPR[rt];
|
#if 0
|
#if 0
|
if (code == 0x00)
|
if (code == 0x00)
|
sim_io_printf(sd,"Warning: MFC0 %d,%d ignored, PC=%08x (architecture specific)\n",rt,rd, (unsigned)cia);
|
sim_io_printf(sd,"Warning: MFC0 %d,%d ignored, PC=%08x (architecture specific)\n",rt,rd, (unsigned)cia);
|
else
|
else
|
sim_io_printf(sd,"Warning: MTC0 %d,%d ignored, PC=%08x (architecture specific)\n",rt,rd, (unsigned)cia);
|
sim_io_printf(sd,"Warning: MTC0 %d,%d ignored, PC=%08x (architecture specific)\n",rt,rd, (unsigned)cia);
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
else if (code == 0x10 && (tail & 0x3f) == 0x18)
|
else if (code == 0x10 && (tail & 0x3f) == 0x18)
|
{
|
{
|
/* ERET */
|
/* ERET */
|
if (SR & status_ERL)
|
if (SR & status_ERL)
|
{
|
{
|
/* Oops, not yet available */
|
/* Oops, not yet available */
|
sim_io_printf(sd,"Warning: ERET when SR[ERL] set not handled yet");
|
sim_io_printf(sd,"Warning: ERET when SR[ERL] set not handled yet");
|
PC = EPC;
|
PC = EPC;
|
SR &= ~status_ERL;
|
SR &= ~status_ERL;
|
}
|
}
|
else
|
else
|
{
|
{
|
PC = EPC;
|
PC = EPC;
|
SR &= ~status_EXL;
|
SR &= ~status_EXL;
|
}
|
}
|
}
|
}
|
else if (code == 0x10 && (tail & 0x3f) == 0x10)
|
else if (code == 0x10 && (tail & 0x3f) == 0x10)
|
{
|
{
|
/* RFE */
|
/* RFE */
|
#ifdef SUBTARGET_R3900
|
#ifdef SUBTARGET_R3900
|
/* TX39: Copy IEp/KUp -> IEc/KUc, and IEo/KUo -> IEp/KUp */
|
/* TX39: Copy IEp/KUp -> IEc/KUc, and IEo/KUo -> IEp/KUp */
|
|
|
/* shift IE/KU history bits right */
|
/* shift IE/KU history bits right */
|
SR = LSMASKED32(SR, 31, 4) | LSINSERTED32(LSEXTRACTED32(SR, 5, 2), 3, 0);
|
SR = LSMASKED32(SR, 31, 4) | LSINSERTED32(LSEXTRACTED32(SR, 5, 2), 3, 0);
|
|
|
/* TODO: CACHE register */
|
/* TODO: CACHE register */
|
#endif /* SUBTARGET_R3900 */
|
#endif /* SUBTARGET_R3900 */
|
}
|
}
|
else if (code == 0x10 && (tail & 0x3f) == 0x1F)
|
else if (code == 0x10 && (tail & 0x3f) == 0x1F)
|
{
|
{
|
/* DERET */
|
/* DERET */
|
Debug &= ~Debug_DM;
|
Debug &= ~Debug_DM;
|
DELAYSLOT();
|
DELAYSLOT();
|
DSPC = DEPC;
|
DSPC = DEPC;
|
}
|
}
|
else
|
else
|
sim_io_eprintf(sd,"Unrecognised COP0 instruction 0x%08X at PC = 0x%s : No handler present\n",instruction,pr_addr(cia));
|
sim_io_eprintf(sd,"Unrecognised COP0 instruction 0x%08X at PC = 0x%s : No handler present\n",instruction,pr_addr(cia));
|
/* TODO: When executing an ERET or RFE instruction we should
|
/* TODO: When executing an ERET or RFE instruction we should
|
clear LLBIT, to ensure that any out-standing atomic
|
clear LLBIT, to ensure that any out-standing atomic
|
read/modify/write sequence fails. */
|
read/modify/write sequence fails. */
|
}
|
}
|
break;
|
break;
|
|
|
case 2: /* co-processor 2 */
|
case 2: /* co-processor 2 */
|
{
|
{
|
int handle = 0;
|
int handle = 0;
|
|
|
|
|
if(! handle)
|
if(! handle)
|
{
|
{
|
sim_io_eprintf(sd, "COP2 instruction 0x%08X at PC = 0x%s : No handler present\n",
|
sim_io_eprintf(sd, "COP2 instruction 0x%08X at PC = 0x%s : No handler present\n",
|
instruction,pr_addr(cia));
|
instruction,pr_addr(cia));
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case 1: /* should not occur (FPU co-processor) */
|
case 1: /* should not occur (FPU co-processor) */
|
case 3: /* should not occur (FPU co-processor) */
|
case 3: /* should not occur (FPU co-processor) */
|
SignalException(ReservedInstruction,instruction);
|
SignalException(ReservedInstruction,instruction);
|
break;
|
break;
|
}
|
}
|
|
|
return;
|
return;
|
}
|
}
|
|
|
|
|
/* This code copied from gdb's utils.c. Would like to share this code,
|
/* This code copied from gdb's utils.c. Would like to share this code,
|
but don't know of a common place where both could get to it. */
|
but don't know of a common place where both could get to it. */
|
|
|
/* Temporary storage using circular buffer */
|
/* Temporary storage using circular buffer */
|
#define NUMCELLS 16
|
#define NUMCELLS 16
|
#define CELLSIZE 32
|
#define CELLSIZE 32
|
static char*
|
static char*
|
get_cell (void)
|
get_cell (void)
|
{
|
{
|
static char buf[NUMCELLS][CELLSIZE];
|
static char buf[NUMCELLS][CELLSIZE];
|
static int cell=0;
|
static int cell=0;
|
if (++cell>=NUMCELLS) cell=0;
|
if (++cell>=NUMCELLS) cell=0;
|
return buf[cell];
|
return buf[cell];
|
}
|
}
|
|
|
/* Print routines to handle variable size regs, etc */
|
/* Print routines to handle variable size regs, etc */
|
|
|
/* Eliminate warning from compiler on 32-bit systems */
|
/* Eliminate warning from compiler on 32-bit systems */
|
static int thirty_two = 32;
|
static int thirty_two = 32;
|
|
|
char*
|
char*
|
pr_addr(addr)
|
pr_addr(addr)
|
SIM_ADDR addr;
|
SIM_ADDR addr;
|
{
|
{
|
char *paddr_str=get_cell();
|
char *paddr_str=get_cell();
|
switch (sizeof(addr))
|
switch (sizeof(addr))
|
{
|
{
|
case 8:
|
case 8:
|
sprintf(paddr_str,"%08lx%08lx",
|
sprintf(paddr_str,"%08lx%08lx",
|
(unsigned long)(addr>>thirty_two),(unsigned long)(addr&0xffffffff));
|
(unsigned long)(addr>>thirty_two),(unsigned long)(addr&0xffffffff));
|
break;
|
break;
|
case 4:
|
case 4:
|
sprintf(paddr_str,"%08lx",(unsigned long)addr);
|
sprintf(paddr_str,"%08lx",(unsigned long)addr);
|
break;
|
break;
|
case 2:
|
case 2:
|
sprintf(paddr_str,"%04x",(unsigned short)(addr&0xffff));
|
sprintf(paddr_str,"%04x",(unsigned short)(addr&0xffff));
|
break;
|
break;
|
default:
|
default:
|
sprintf(paddr_str,"%x",addr);
|
sprintf(paddr_str,"%x",addr);
|
}
|
}
|
return paddr_str;
|
return paddr_str;
|
}
|
}
|
|
|
char*
|
char*
|
pr_uword64(addr)
|
pr_uword64(addr)
|
uword64 addr;
|
uword64 addr;
|
{
|
{
|
char *paddr_str=get_cell();
|
char *paddr_str=get_cell();
|
sprintf(paddr_str,"%08lx%08lx",
|
sprintf(paddr_str,"%08lx%08lx",
|
(unsigned long)(addr>>thirty_two),(unsigned long)(addr&0xffffffff));
|
(unsigned long)(addr>>thirty_two),(unsigned long)(addr&0xffffffff));
|
return paddr_str;
|
return paddr_str;
|
}
|
}
|
|
|
|
|
void
|
void
|
mips_core_signal (SIM_DESC sd,
|
mips_core_signal (SIM_DESC sd,
|
sim_cpu *cpu,
|
sim_cpu *cpu,
|
sim_cia cia,
|
sim_cia cia,
|
unsigned map,
|
unsigned map,
|
int nr_bytes,
|
int nr_bytes,
|
address_word addr,
|
address_word addr,
|
transfer_type transfer,
|
transfer_type transfer,
|
sim_core_signals sig)
|
sim_core_signals sig)
|
{
|
{
|
const char *copy = (transfer == read_transfer ? "read" : "write");
|
const char *copy = (transfer == read_transfer ? "read" : "write");
|
address_word ip = CIA_ADDR (cia);
|
address_word ip = CIA_ADDR (cia);
|
|
|
switch (sig)
|
switch (sig)
|
{
|
{
|
case sim_core_unmapped_signal:
|
case sim_core_unmapped_signal:
|
sim_io_eprintf (sd, "mips-core: %d byte %s to unmapped address 0x%lx at 0x%lx\n",
|
sim_io_eprintf (sd, "mips-core: %d byte %s to unmapped address 0x%lx at 0x%lx\n",
|
nr_bytes, copy,
|
nr_bytes, copy,
|
(unsigned long) addr, (unsigned long) ip);
|
(unsigned long) addr, (unsigned long) ip);
|
COP0_BADVADDR = addr;
|
COP0_BADVADDR = addr;
|
SignalExceptionDataReference();
|
SignalExceptionDataReference();
|
break;
|
break;
|
|
|
case sim_core_unaligned_signal:
|
case sim_core_unaligned_signal:
|
sim_io_eprintf (sd, "mips-core: %d byte %s to unaligned address 0x%lx at 0x%lx\n",
|
sim_io_eprintf (sd, "mips-core: %d byte %s to unaligned address 0x%lx at 0x%lx\n",
|
nr_bytes, copy,
|
nr_bytes, copy,
|
(unsigned long) addr, (unsigned long) ip);
|
(unsigned long) addr, (unsigned long) ip);
|
COP0_BADVADDR = addr;
|
COP0_BADVADDR = addr;
|
if(transfer == read_transfer)
|
if(transfer == read_transfer)
|
SignalExceptionAddressLoad();
|
SignalExceptionAddressLoad();
|
else
|
else
|
SignalExceptionAddressStore();
|
SignalExceptionAddressStore();
|
break;
|
break;
|
|
|
default:
|
default:
|
sim_engine_abort (sd, cpu, cia,
|
sim_engine_abort (sd, cpu, cia,
|
"mips_core_signal - internal error - bad switch");
|
"mips_core_signal - internal error - bad switch");
|
}
|
}
|
}
|
}
|
|
|
|
|
void
|
void
|
mips_cpu_exception_trigger(SIM_DESC sd, sim_cpu* cpu, address_word cia)
|
mips_cpu_exception_trigger(SIM_DESC sd, sim_cpu* cpu, address_word cia)
|
{
|
{
|
ASSERT(cpu != NULL);
|
ASSERT(cpu != NULL);
|
|
|
if(cpu->exc_suspended > 0)
|
if(cpu->exc_suspended > 0)
|
sim_io_eprintf(sd, "Warning, nested exception triggered (%d)\n", cpu->exc_suspended);
|
sim_io_eprintf(sd, "Warning, nested exception triggered (%d)\n", cpu->exc_suspended);
|
|
|
PC = cia;
|
PC = cia;
|
memcpy(cpu->exc_trigger_registers, cpu->registers, sizeof(cpu->exc_trigger_registers));
|
memcpy(cpu->exc_trigger_registers, cpu->registers, sizeof(cpu->exc_trigger_registers));
|
cpu->exc_suspended = 0;
|
cpu->exc_suspended = 0;
|
}
|
}
|
|
|
void
|
void
|
mips_cpu_exception_suspend(SIM_DESC sd, sim_cpu* cpu, int exception)
|
mips_cpu_exception_suspend(SIM_DESC sd, sim_cpu* cpu, int exception)
|
{
|
{
|
ASSERT(cpu != NULL);
|
ASSERT(cpu != NULL);
|
|
|
if(cpu->exc_suspended > 0)
|
if(cpu->exc_suspended > 0)
|
sim_io_eprintf(sd, "Warning, nested exception signal (%d then %d)\n",
|
sim_io_eprintf(sd, "Warning, nested exception signal (%d then %d)\n",
|
cpu->exc_suspended, exception);
|
cpu->exc_suspended, exception);
|
|
|
memcpy(cpu->exc_suspend_registers, cpu->registers, sizeof(cpu->exc_suspend_registers));
|
memcpy(cpu->exc_suspend_registers, cpu->registers, sizeof(cpu->exc_suspend_registers));
|
memcpy(cpu->registers, cpu->exc_trigger_registers, sizeof(cpu->registers));
|
memcpy(cpu->registers, cpu->exc_trigger_registers, sizeof(cpu->registers));
|
cpu->exc_suspended = exception;
|
cpu->exc_suspended = exception;
|
}
|
}
|
|
|
void
|
void
|
mips_cpu_exception_resume(SIM_DESC sd, sim_cpu* cpu, int exception)
|
mips_cpu_exception_resume(SIM_DESC sd, sim_cpu* cpu, int exception)
|
{
|
{
|
ASSERT(cpu != NULL);
|
ASSERT(cpu != NULL);
|
|
|
if(exception == 0 && cpu->exc_suspended > 0)
|
if(exception == 0 && cpu->exc_suspended > 0)
|
{
|
{
|
/* warn not for breakpoints */
|
/* warn not for breakpoints */
|
if(cpu->exc_suspended != sim_signal_to_host(sd, SIM_SIGTRAP))
|
if(cpu->exc_suspended != sim_signal_to_host(sd, SIM_SIGTRAP))
|
sim_io_eprintf(sd, "Warning, resuming but ignoring pending exception signal (%d)\n",
|
sim_io_eprintf(sd, "Warning, resuming but ignoring pending exception signal (%d)\n",
|
cpu->exc_suspended);
|
cpu->exc_suspended);
|
}
|
}
|
else if(exception != 0 && cpu->exc_suspended > 0)
|
else if(exception != 0 && cpu->exc_suspended > 0)
|
{
|
{
|
if(exception != cpu->exc_suspended)
|
if(exception != cpu->exc_suspended)
|
sim_io_eprintf(sd, "Warning, resuming with mismatched exception signal (%d vs %d)\n",
|
sim_io_eprintf(sd, "Warning, resuming with mismatched exception signal (%d vs %d)\n",
|
cpu->exc_suspended, exception);
|
cpu->exc_suspended, exception);
|
|
|
memcpy(cpu->registers, cpu->exc_suspend_registers, sizeof(cpu->registers));
|
memcpy(cpu->registers, cpu->exc_suspend_registers, sizeof(cpu->registers));
|
}
|
}
|
else if(exception != 0 && cpu->exc_suspended == 0)
|
else if(exception != 0 && cpu->exc_suspended == 0)
|
{
|
{
|
sim_io_eprintf(sd, "Warning, ignoring spontanous exception signal (%d)\n", exception);
|
sim_io_eprintf(sd, "Warning, ignoring spontanous exception signal (%d)\n", exception);
|
}
|
}
|
cpu->exc_suspended = 0;
|
cpu->exc_suspended = 0;
|
}
|
}
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
/*---------------------------------------------------------------------------*/
|
/*> EOF interp.c <*/
|
/*> EOF interp.c <*/
|
|
|
