From 4fef0ea3f6e3bf03ac410a8afe485af5a0f859b8 Mon Sep 17 00:00:00 2001 From: Michael Snyder Date: Tue, 3 Jun 2003 21:38:27 +0000 Subject: 2003-06-03 Michael Snyder * h8300/compile.c: Add h8300sx insns and addressing modes. * h8300/sim-main.h: Replaces h8300/inst.h. * h8300/Makefile.in: Tweak to bring in some sim/common stuff. --- sim/h8300/ChangeLog | 6 + sim/h8300/Makefile.in | 18 +- sim/h8300/compile.c | 5912 +++++++++++++++++++++++++++++++++---------------- sim/h8300/sim-main.h | 170 ++ 4 files changed, 4242 insertions(+), 1864 deletions(-) create mode 100644 sim/h8300/sim-main.h (limited to 'sim/h8300') diff --git a/sim/h8300/ChangeLog b/sim/h8300/ChangeLog index 600e9cc08a9..34577d8cc89 100644 --- a/sim/h8300/ChangeLog +++ b/sim/h8300/ChangeLog @@ -1,3 +1,9 @@ +2003-06-03 Michael Snyder + + * h8300/compile.c: Add h8300sx insns and addressing modes. + * h8300/sim-main.h: Replaces h8300/inst.h. + * h8300/Makefile.in: Tweak to bring in some sim/common stuff. + 2003-04-13 Michael Snyder * compile.c (sim_resume): Implement 'daa' and 'das' instructions. diff --git a/sim/h8300/Makefile.in b/sim/h8300/Makefile.in index 55dc3db7310..1d1f9d3db76 100644 --- a/sim/h8300/Makefile.in +++ b/sim/h8300/Makefile.in @@ -18,10 +18,20 @@ ## COMMON_PRE_CONFIG_FRAG -SIM_OBJS = compile.o sim-load.o +# List of main object files for `run'. +SIM_RUN_OBJS = nrun.o + +SIM_OBJS = compile.o \ + $(SIM_NEW_COMMON_OBJS) \ + sim-cpu.o \ + sim-engine.o \ + sim-load.o \ + $(SIM_EXTRA_OBJS) + ## COMMON_POST_CONFIG_FRAG compile.o: compile.c inst.h config.h \ - $(srcdir)/../../include/gdb/sim-h8300.h \ - $(srcdir)/../../include/gdb/remote-sim.h \ - $(srcdir)/../../include/gdb/callback.h + $(srcdir)/../../include/gdb/sim-h8300.h \ + $(srcdir)/../../include/opcode/h8300.h \ + $(srcdir)/../../include/gdb/remote-sim.h \ + $(srcdir)/../../include/gdb/callback.h diff --git a/sim/h8300/compile.c b/sim/h8300/compile.c index 0e4b6d2b291..a21cd65b8bb 100644 --- a/sim/h8300/compile.c +++ b/sim/h8300/compile.c @@ -17,9 +17,6 @@ * AND FITNESS FOR A PARTICULAR PURPOSE. */ -#include "config.h" - -#include #include #ifdef HAVE_TIME_H #include @@ -30,10 +27,9 @@ #ifdef HAVE_SYS_PARAM_H #include #endif -#include "ansidecl.h" + #include "bfd.h" -#include "gdb/callback.h" -#include "gdb/remote-sim.h" +#include "sim-main.h" #include "gdb/sim-h8300.h" #include "sys/stat.h" #include "sys/types.h" @@ -53,1954 +49,3856 @@ static char *myname; This header should also include the things in remote-sim.h. One could move this to remote-sim.h but this function isn't needed by gdb. */ -void sim_set_simcache_size PARAMS ((int)); +static void set_simcache_size (SIM_DESC, int); -#define X(op, size) op * 4 + size +#define X(op, size) (op * 4 + size) #define SP (h8300hmode ? SL : SW) -#define SB 0 -#define SW 1 -#define SL 2 -#define OP_REG 1 -#define OP_DEC 2 -#define OP_DISP 3 -#define OP_INC 4 -#define OP_PCREL 5 -#define OP_MEM 6 -#define OP_CCR 7 -#define OP_IMM 8 -#define OP_ABS 10 -#define OP_EXR 11 + #define h8_opcodes ops #define DEFINE_TABLE #include "opcode/h8300.h" -#include "inst.h" +/* CPU data object: */ -/* The rate at which to call the host's poll_quit callback. */ +static int +sim_state_initialize (SIM_DESC sd, sim_cpu *cpu) +{ + /* FIXME: not really necessary, since sim_cpu_alloc calls zalloc. */ + + memset (&cpu->regs, 0, sizeof(cpu->regs)); + cpu->regs[SBR_REGNUM] = 0xFFFFFF00; + cpu->pc = 0; + cpu->delayed_branch = 0; + cpu->memory = NULL; + cpu->eightbit = NULL; + cpu->mask = 0; + + /* Initialize local simulator state. */ + sd->sim_cache = NULL; + sd->sim_cache_size = 0; + sd->cache_idx = NULL; + sd->cache_top = 0; + sd->memory_size = 0; + sd->compiles = 0; +#ifdef ADEBUG + memset (&cpu->stats, 0, sizeof (cpu->stats)); +#endif + return 0; +} -#define POLL_QUIT_INTERVAL 0x80000 +static unsigned int +h8_get_pc (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> pc; +} -#define LOW_BYTE(x) ((x) & 0xff) -#define HIGH_BYTE(x) (((x) >> 8) & 0xff) -#define P(X,Y) ((X << 8) | Y) - -#define BUILDSR() \ - cpu.ccr = ((I << 7) | (UI << 6) | (H << 5) | (U << 4) \ - | (N << 3) | (Z << 2) | (V << 1) | C); - -#define BUILDEXR() \ - if (h8300smode) cpu.exr = (trace<<7) | intMask; - -#define GETSR() \ - c = (cpu.ccr >> 0) & 1;\ - v = (cpu.ccr >> 1) & 1;\ - nz = !((cpu.ccr >> 2) & 1);\ - n = (cpu.ccr >> 3) & 1;\ - u = (cpu.ccr >> 4) & 1;\ - h = (cpu.ccr >> 5) & 1;\ - ui = ((cpu.ccr >> 6) & 1);\ - intMaskBit = (cpu.ccr >> 7) & 1; - -#define GETEXR() \ - if (h8300smode) \ - { \ - trace = (cpu.exr >> 7) & 1; \ - intMask = cpu.exr & 7; \ - } +static void +h8_set_pc (SIM_DESC sd, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> pc = val; +} -#ifdef __CHAR_IS_SIGNED__ -#define SEXTCHAR(x) ((char) (x)) -#endif +static unsigned int +h8_get_ccr (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> regs[CCR_REGNUM]; +} -#ifndef SEXTCHAR -#define SEXTCHAR(x) ((x & 0x80) ? (x | ~0xff) : x & 0xff) -#endif +static void +h8_set_ccr (SIM_DESC sd, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> regs[CCR_REGNUM] = val; +} -#define UEXTCHAR(x) ((x) & 0xff) -#define UEXTSHORT(x) ((x) & 0xffff) -#define SEXTSHORT(x) ((short) (x)) +static unsigned int +h8_get_exr (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> regs[EXR_REGNUM]; +} -static cpu_state_type cpu; +static void +h8_set_exr (SIM_DESC sd, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> regs[EXR_REGNUM] = val; +} -int h8300hmode = 0; -int h8300smode = 0; +static int +h8_get_sbr (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> regs[SBR_REGNUM]; +} -static int memory_size; +static void +h8_set_sbr (SIM_DESC sd, int val) +{ + (STATE_CPU (sd, 0)) -> regs[SBR_REGNUM] = val; +} static int -get_now (void) +h8_get_vbr (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> regs[VBR_REGNUM]; +} + +static void +h8_set_vbr (SIM_DESC sd, int val) { - return time (0); /* WinXX HAS UNIX like 'time', so why not using it? */ + (STATE_CPU (sd, 0)) -> regs[VBR_REGNUM] = val; } static int -now_persec (void) +h8_get_cache_top (SIM_DESC sd) { - return 1; + return sd -> cache_top; +} + +static void +h8_set_cache_top (SIM_DESC sd, int val) +{ + sd -> cache_top = val; } static int -bitfrom (int x) +h8_get_mask (SIM_DESC sd) { - switch (x & SIZE) - { - case L_8: - return SB; - case L_16: - return SW; - case L_32: - return SL; - case L_P: - return h8300hmode ? SL : SW; - } + return (STATE_CPU (sd, 0)) -> mask; } -static unsigned int -lvalue (int x, int rn) +static void +h8_set_mask (SIM_DESC sd, int val) { - switch (x / 4) - { - case OP_DISP: - if (rn == 8) - { - return X (OP_IMM, SP); - } - return X (OP_REG, SP); + (STATE_CPU (sd, 0)) -> mask = val; +} +#if 0 +static int +h8_get_exception (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> exception; +} - case OP_MEM: - return X (OP_MEM, SP); +static void +h8_set_exception (SIM_DESC sd, int val) +{ + (STATE_CPU (sd, 0)) -> exception = val; +} - default: - abort (); /* ?? May be something more usefull? */ - } +static enum h8300_sim_state +h8_get_state (SIM_DESC sd) +{ + return sd -> state; } -static int -cmdline_location() +static void +h8_set_state (SIM_DESC sd, enum h8300_sim_state val) { - if (h8300smode) - return 0xffff00L; - else if (h8300hmode) - return 0x2ff00L; - else - return 0xff00L; + sd -> state = val; +} +#endif +static unsigned int +h8_get_cycles (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> regs[CYCLE_REGNUM]; +} + +static void +h8_set_cycles (SIM_DESC sd, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> regs[CYCLE_REGNUM] = val; } static unsigned int -decode (int addr, unsigned char *data, decoded_inst *dst) +h8_get_insts (SIM_DESC sd) { - int rs = 0; - int rd = 0; - int rdisp = 0; - int abs = 0; - int bit = 0; - int plen = 0; - struct h8_opcode *q; - int size = 0; + return (STATE_CPU (sd, 0)) -> regs[INST_REGNUM]; +} - dst->dst.type = -1; - dst->src.type = -1; +static void +h8_set_insts (SIM_DESC sd, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> regs[INST_REGNUM] = val; +} - /* Find the exact opcode/arg combo. */ - for (q = h8_opcodes; q->name; q++) - { - op_type *nib = q->data.nib; - unsigned int len = 0; +static unsigned int +h8_get_ticks (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> regs[TICK_REGNUM]; +} - while (1) - { - op_type looking_for = *nib; - int thisnib = data[len >> 1]; +static void +h8_set_ticks (SIM_DESC sd, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> regs[TICK_REGNUM] = val; +} - thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf); +static unsigned int +h8_get_mach (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> regs[MACH_REGNUM]; +} - if (looking_for < 16 && looking_for >= 0) - { - if (looking_for != thisnib) - goto fail; - } - else - { - if ((int) looking_for & (int) B31) - { - if (!(((int) thisnib & 0x8) != 0)) - goto fail; +static void +h8_set_mach (SIM_DESC sd, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> regs[MACH_REGNUM] = val; +} - looking_for = (op_type) ((int) looking_for & ~(int) B31); - thisnib &= 0x7; - } +static unsigned int +h8_get_macl (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> regs[MACL_REGNUM]; +} - if ((int) looking_for & (int) B30) - { - if (!(((int) thisnib & 0x8) == 0)) - goto fail; +static void +h8_set_macl (SIM_DESC sd, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> regs[MACL_REGNUM] = val; +} - looking_for = (op_type) ((int) looking_for & ~(int) B30); - } +static int +h8_get_compiles (SIM_DESC sd) +{ + return sd -> compiles; +} - if (looking_for & DBIT) - { - /* Exclude adds/subs by looking at bit 0 and 2, and - make sure the operand size, either w or l, - matches by looking at bit 1. */ - if ((looking_for & 7) != (thisnib & 7)) - goto fail; +static void +h8_increment_compiles (SIM_DESC sd) +{ + sd -> compiles ++; +} - abs = (thisnib & 0x8) ? 2 : 1; - } - else if (looking_for & (REG | IND | INC | DEC)) - { - if (looking_for & REG) - { - /* Can work out size from the register. */ - size = bitfrom (looking_for); - } - if (looking_for & SRC) - rs = thisnib; - else - rd = thisnib; - } - else if (looking_for & L_16) - { - abs = (data[len >> 1]) * 256 + data[(len + 2) >> 1]; - plen = 16; - if (looking_for & (PCREL | DISP)) - { - abs = (short) (abs); - } - } - else if (looking_for & ABSJMP) - { - abs = (data[1] << 16) | (data[2] << 8) | (data[3]); - } - else if (looking_for & MEMIND) - { - abs = data[1]; - } - else if (looking_for & L_32) - { - int i = len >> 1; +static unsigned int * +h8_get_reg_buf (SIM_DESC sd) +{ + return &(((STATE_CPU (sd, 0)) -> regs)[0]); +} - abs = (data[i] << 24) - | (data[i + 1] << 16) - | (data[i + 2] << 8) - | (data[i + 3]); +static unsigned int +h8_get_reg (SIM_DESC sd, int regnum) +{ + return (STATE_CPU (sd, 0)) -> regs[regnum]; +} - plen = 32; - } - else if (looking_for & L_24) - { - int i = len >> 1; +static void +h8_set_reg (SIM_DESC sd, int regnum, int val) +{ + (STATE_CPU (sd, 0)) -> regs[regnum] = val; +} - abs = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]); - plen = 24; - } - else if (looking_for & IGNORE) - { - ; - } - else if (looking_for & DISPREG) - { - rdisp = thisnib & 0x7; - } - else if (looking_for & KBIT) - { - switch (thisnib) - { - case 9: - abs = 4; - break; - case 8: - abs = 2; - break; - case 0: - abs = 1; - break; - default: - goto fail; - } - } - else if (looking_for & L_8) - { - plen = 8; +#ifdef ADEBUG +static int +h8_get_stats (SIM_DESC sd, int idx) +{ + return sd -> stats[idx]; +} - if (looking_for & PCREL) - { - abs = SEXTCHAR (data[len >> 1]); - } - else if (looking_for & ABS8MEM) - { - plen = 8; - abs = h8300hmode ? ~0xff0000ff : ~0xffff00ff; - abs |= data[len >> 1] & 0xff; - } - else - { - abs = data[len >> 1] & 0xff; - } - } - else if (looking_for & L_3) - { - plen = 3; +static void +h8_increment_stats (SIM_DESC sd, int idx) +{ + sd -> stats[idx] ++; +} +#endif /* ADEBUG */ - bit = thisnib; - } - else if (looking_for == E) - { - dst->op = q; +static unsigned short * +h8_get_cache_idx_buf (SIM_DESC sd) +{ + return sd -> cache_idx; +} - /* Fill in the args. */ - { - op_type *args = q->args.nib; - int hadone = 0; +static void +h8_set_cache_idx_buf (SIM_DESC sd, unsigned short *ptr) +{ + sd -> cache_idx = ptr; +} - while (*args != E) - { - int x = *args; - int rn = (x & DST) ? rd : rs; - ea_type *p; +static unsigned short +h8_get_cache_idx (SIM_DESC sd, unsigned int idx) +{ + if (idx > sd->memory_size) + return (unsigned short) -1; + return sd -> cache_idx[idx]; +} - if (x & DST) - p = &(dst->dst); - else - p = &(dst->src); +static void +h8_set_cache_idx (SIM_DESC sd, int idx, unsigned int val) +{ + sd -> cache_idx[idx] = (unsigned short) val; +} - if (x & L_3) - { - p->type = X (OP_IMM, size); - p->literal = bit; - } - else if (x & (IMM | KBIT | DBIT)) - { - p->type = X (OP_IMM, size); - p->literal = abs; - } - else if (x & REG) - { - /* Reset the size. - Some ops (like mul) have two sizes. */ +static unsigned char * +h8_get_memory_buf (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> memory; +} - size = bitfrom (x); - p->type = X (OP_REG, size); - p->reg = rn; - } - else if (x & INC) - { - p->type = X (OP_INC, size); - p->reg = rn & 0x7; - } - else if (x & DEC) - { - p->type = X (OP_DEC, size); - p->reg = rn & 0x7; - } - else if (x & IND) - { - p->type = X (OP_DISP, size); - p->reg = rn & 0x7; - p->literal = 0; - } - else if (x & (ABS | ABSJMP | ABS8MEM)) - { - p->type = X (OP_DISP, size); - p->literal = abs; - p->reg = 8; - } - else if (x & MEMIND) - { - p->type = X (OP_MEM, size); - p->literal = abs; - } - else if (x & PCREL) - { - p->type = X (OP_PCREL, size); - p->literal = abs + addr + 2; - if (x & L_16) - p->literal += 2; - } - else if (x & ABSJMP) - { - p->type = X (OP_IMM, SP); - p->literal = abs; - } - else if (x & DISP) - { - p->type = X (OP_DISP, size); - p->literal = abs; - p->reg = rdisp & 0x7; - } - else if (x & CCR) - { - p->type = OP_CCR; - } - else if (x & EXR) - { - p->type = OP_EXR; - } - else - printf ("Hmmmm %x", x); - - args++; - } - } - - /* But a jmp or a jsr gets automagically lvalued, - since we branch to their address not their - contents. */ - if (q->how == O (O_JSR, SB) - || q->how == O (O_JMP, SB)) - { - dst->src.type = lvalue (dst->src.type, dst->src.reg); - } - - if (dst->dst.type == -1) - dst->dst = dst->src; +static void +h8_set_memory_buf (SIM_DESC sd, unsigned char *ptr) +{ + (STATE_CPU (sd, 0)) -> memory = ptr; +} - dst->opcode = q->how; - dst->cycles = q->time; +static unsigned char +h8_get_memory (SIM_DESC sd, int idx) +{ + return (STATE_CPU (sd, 0)) -> memory[idx]; +} - /* And a jsr to these locations are turned into magic - traps. */ +static void +h8_set_memory (SIM_DESC sd, int idx, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> memory[idx] = (unsigned char) val; +} - if (dst->opcode == O (O_JSR, SB)) - { - switch (dst->src.literal) - { - case 0xc5: - dst->opcode = O (O_SYS_OPEN, SB); - break; - case 0xc6: - dst->opcode = O (O_SYS_READ, SB); - break; - case 0xc7: - dst->opcode = O (O_SYS_WRITE, SB); - break; - case 0xc8: - dst->opcode = O (O_SYS_LSEEK, SB); - break; - case 0xc9: - dst->opcode = O (O_SYS_CLOSE, SB); - break; - case 0xca: - dst->opcode = O (O_SYS_STAT, SB); - break; - case 0xcb: - dst->opcode = O (O_SYS_FSTAT, SB); - break; - case 0xcc: - dst->opcode = O (O_SYS_CMDLINE, SB); - break; - } - /* End of Processing for system calls. */ - } +static unsigned char * +h8_get_eightbit_buf (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> eightbit; +} - dst->next_pc = addr + len / 2; - return; - } - else - printf ("Don't understand %x \n", looking_for); - } +static void +h8_set_eightbit_buf (SIM_DESC sd, unsigned char *ptr) +{ + (STATE_CPU (sd, 0)) -> eightbit = ptr; +} - len++; - nib++; - } +static unsigned char +h8_get_eightbit (SIM_DESC sd, int idx) +{ + return (STATE_CPU (sd, 0)) -> eightbit[idx]; +} - fail: - ; - } +static void +h8_set_eightbit (SIM_DESC sd, int idx, unsigned int val) +{ + (STATE_CPU (sd, 0)) -> eightbit[idx] = (unsigned char) val; +} - /* Fell off the end. */ - dst->opcode = O (O_ILL, SB); +static unsigned int +h8_get_delayed_branch (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> delayed_branch; } static void -compile (int pc) +h8_set_delayed_branch (SIM_DESC sd, unsigned int dest) { - int idx; + (STATE_CPU (sd, 0)) -> delayed_branch = dest; +} - /* Find the next cache entry to use. */ - idx = cpu.cache_top + 1; - cpu.compiles++; - if (idx >= cpu.csize) - { - idx = 1; - } - cpu.cache_top = idx; +static char ** +h8_get_command_line (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> command_line; +} - /* Throw away its old meaning. */ - cpu.cache_idx[cpu.cache[idx].oldpc] = 0; +static void +h8_set_command_line (SIM_DESC sd, char ** val) +{ + (STATE_CPU (sd, 0)) -> command_line = val; +} - /* Set to new address. */ - cpu.cache[idx].oldpc = pc; +static char * +h8_get_cmdline_arg (SIM_DESC sd, int index) +{ + return (STATE_CPU (sd, 0)) -> command_line[index]; +} - /* Fill in instruction info. */ - decode (pc, cpu.memory + pc, cpu.cache + idx); +static void +h8_set_cmdline_arg (SIM_DESC sd, int index, char * val) +{ + (STATE_CPU (sd, 0)) -> command_line[index] = val; +} - /* Point to new cache entry. */ - cpu.cache_idx[pc] = idx; +/* MAC Saturation Mode */ +static int +h8_get_macS (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> macS; } +static void +h8_set_macS (SIM_DESC sd, int val) +{ + (STATE_CPU (sd, 0)) -> macS = (val != 0); +} -static unsigned char *breg[18]; -static unsigned short *wreg[18]; -static unsigned int *lreg[18]; +/* MAC Zero Flag */ +static int +h8_get_macZ (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> macZ; +} -#define GET_B_REG(x) *(breg[x]) -#define SET_B_REG(x,y) (*(breg[x])) = (y) -#define GET_W_REG(x) *(wreg[x]) -#define SET_W_REG(x,y) (*(wreg[x])) = (y) +static void +h8_set_macZ (SIM_DESC sd, int val) +{ + (STATE_CPU (sd, 0)) -> macZ = (val != 0); +} -#define GET_L_REG(x) *(lreg[x]) -#define SET_L_REG(x,y) (*(lreg[x])) = (y) +/* MAC Negative Flag */ +static int +h8_get_macN (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> macN; +} -#define GET_MEMORY_L(x) \ - (x < memory_size \ - ? ((cpu.memory[x+0] << 24) | (cpu.memory[x+1] << 16) \ - | (cpu.memory[x+2] << 8) | cpu.memory[x+3]) \ - : ((cpu.eightbit[(x+0) & 0xff] << 24) | (cpu.eightbit[(x+1) & 0xff] << 16) \ - | (cpu.eightbit[(x+2) & 0xff] << 8) | cpu.eightbit[(x+3) & 0xff])) +static void +h8_set_macN (SIM_DESC sd, int val) +{ + (STATE_CPU (sd, 0)) -> macN = (val != 0); +} -#define GET_MEMORY_W(x) \ - (x < memory_size \ - ? ((cpu.memory[x+0] << 8) | (cpu.memory[x+1] << 0)) \ - : ((cpu.eightbit[(x+0) & 0xff] << 8) | (cpu.eightbit[(x+1) & 0xff] << 0))) +/* MAC Overflow Flag */ +static int +h8_get_macV (SIM_DESC sd) +{ + return (STATE_CPU (sd, 0)) -> macV; +} +static void +h8_set_macV (SIM_DESC sd, int val) +{ + (STATE_CPU (sd, 0)) -> macV = (val != 0); +} -#define GET_MEMORY_B(x) \ - (x < memory_size ? (cpu.memory[x]) : (cpu.eightbit[x & 0xff])) +/* End CPU data object. */ -#define SET_MEMORY_L(x,y) \ -{ register unsigned char *_p; register int __y = y; \ - _p = (x < memory_size ? cpu.memory+x : cpu.eightbit + (x & 0xff)); \ - _p[0] = (__y)>>24; _p[1] = (__y)>>16; \ - _p[2] = (__y)>>8; _p[3] = (__y)>>0;} +/* The rate at which to call the host's poll_quit callback. */ -#define SET_MEMORY_W(x,y) \ -{ register unsigned char *_p; register int __y = y; \ - _p = (x < memory_size ? cpu.memory+x : cpu.eightbit + (x & 0xff)); \ - _p[0] = (__y)>>8; _p[1] =(__y);} +enum { POLL_QUIT_INTERVAL = 0x80000 }; -#define SET_MEMORY_B(x,y) \ - (x < memory_size ? (cpu.memory[(x)] = y) : (cpu.eightbit[x & 0xff] = y)) +#define LOW_BYTE(x) ((x) & 0xff) +#define HIGH_BYTE(x) (((x) >> 8) & 0xff) +#define P(X, Y) ((X << 8) | Y) -static int -fetch (ea_type *arg) -{ - int rn = arg->reg; - int abs = arg->literal; - int r; - int t; +#define C (c != 0) +#define Z (nz == 0) +#define V (v != 0) +#define N (n != 0) +#define U (u != 0) +#define H (h != 0) +#define UI (ui != 0) +#define I (intMaskBit != 0) - switch (arg->type) - { - case X (OP_REG, SB): - return GET_B_REG (rn); - case X (OP_REG, SW): - return GET_W_REG (rn); - case X (OP_REG, SL): - return GET_L_REG (rn); - case X (OP_IMM, SB): - case X (OP_IMM, SW): - case X (OP_IMM, SL): - return abs; - case X (OP_DEC, SB): - abort (); - - case X (OP_INC, SB): - t = GET_L_REG (rn); - t &= cpu.mask; - r = GET_MEMORY_B (t); - t++; - t = t & cpu.mask; - SET_L_REG (rn, t); - return r; - break; - case X (OP_INC, SW): - t = GET_L_REG (rn); - t &= cpu.mask; - r = GET_MEMORY_W (t); - t += 2; - t = t & cpu.mask; - SET_L_REG (rn, t); - return r; - case X (OP_INC, SL): - t = GET_L_REG (rn); - t &= cpu.mask; - r = GET_MEMORY_L (t); +#define BUILDSR(SD) \ + h8_set_ccr (SD, (I << 7) | (UI << 6) | (H << 5) | (U << 4) \ + | (N << 3) | (Z << 2) | (V << 1) | C) - t += 4; - t = t & cpu.mask; - SET_L_REG (rn, t); - return r; +#ifdef __CHAR_IS_SIGNED__ +#define SEXTCHAR(x) ((char) (x)) +#endif - case X (OP_DISP, SB): - t = GET_L_REG (rn) + abs; - t &= cpu.mask; - return GET_MEMORY_B (t); +#ifndef SEXTCHAR +#define SEXTCHAR(x) ((x & 0x80) ? (x | ~0xff) : x & 0xff) +#endif - case X (OP_DISP, SW): - t = GET_L_REG (rn) + abs; - t &= cpu.mask; - return GET_MEMORY_W (t); +#define UEXTCHAR(x) ((x) & 0xff) +#define UEXTSHORT(x) ((x) & 0xffff) +#define SEXTSHORT(x) ((short) (x)) - case X (OP_DISP, SL): - t = GET_L_REG (rn) + abs; - t &= cpu.mask; - return GET_MEMORY_L (t); +int h8300hmode = 0; +int h8300smode = 0; +int h8300sxmode = 0; - case X (OP_MEM, SL): - t = GET_MEMORY_L (abs); - t &= cpu.mask; - return t; +static int memory_size; - case X (OP_MEM, SW): - t = GET_MEMORY_W (abs); - t &= cpu.mask; - return t; +static int +get_now (void) +{ + return time (0); /* WinXX HAS UNIX like 'time', so why not use it? */ +} - default: - abort (); /* ?? May be something more usefull? */ +static int +now_persec (void) +{ + return 1; +} +static int +bitfrom (int x) +{ + switch (x & SIZE) + { + case L_8: + return SB; + case L_16: + case L_16U: + return SW; + case L_32: + return SL; + case L_P: + return h8300hmode ? SL : SW; } + return 0; } +/* Simulate an indirection / dereference. + return 0 for success, -1 for failure. +*/ -static void -store (ea_type *arg, int n) +static unsigned int +lvalue (SIM_DESC sd, int x, int rn, unsigned int *val) { - int rn = arg->reg; - int abs = arg->literal; - int t; + if (val == NULL) /* Paranoia. */ + return -1; - switch (arg->type) + switch (x / 4) { - case X (OP_REG, SB): - SET_B_REG (rn, n); - break; - case X (OP_REG, SW): - SET_W_REG (rn, n); - break; - case X (OP_REG, SL): - SET_L_REG (rn, n); - break; - - case X (OP_DEC, SB): - t = GET_L_REG (rn) - 1; - t &= cpu.mask; - SET_L_REG (rn, t); - SET_MEMORY_B (t, n); - - break; - case X (OP_DEC, SW): - t = (GET_L_REG (rn) - 2) & cpu.mask; - SET_L_REG (rn, t); - SET_MEMORY_W (t, n); - break; - - case X (OP_DEC, SL): - t = (GET_L_REG (rn) - 4) & cpu.mask; - SET_L_REG (rn, t); - SET_MEMORY_L (t, n); - break; - - case X (OP_DISP, SB): - t = GET_L_REG (rn) + abs; - t &= cpu.mask; - SET_MEMORY_B (t, n); - break; - - case X (OP_DISP, SW): - t = GET_L_REG (rn) + abs; - t &= cpu.mask; - SET_MEMORY_W (t, n); + case OP_DISP: + if (rn == ZERO_REGNUM) + *val = X (OP_IMM, SP); + else + *val = X (OP_REG, SP); break; - - case X (OP_DISP, SL): - t = GET_L_REG (rn) + abs; - t &= cpu.mask; - SET_MEMORY_L (t, n); + case OP_MEM: + *val = X (OP_MEM, SP); break; default: - abort (); + sim_engine_set_run_state (sd, sim_stopped, SIGSEGV); + return -1; } + return 0; } - -static union +static int +cmdline_location() { - short int i; - struct - { - char low; - char high; - } - u; + if (h8300smode) + return 0xffff00L; + else if (h8300hmode) + return 0x2ff00L; + else + return 0xff00L; } -littleendian; - static void -init_pointers (void) +decode (SIM_DESC sd, int addr, unsigned char *data, decoded_inst *dst) { - static int init; - - if (!init) - { - int i; + int cst[3] = {0, 0, 0}; + int reg[3] = {0, 0, 0}; + int rdisp[3] = {0, 0, 0}; + int opnum; + const struct h8_opcode *q; - init = 1; - littleendian.i = 1; + dst->dst.type = -1; + dst->src.type = -1; - if (h8300smode) - memory_size = H8300S_MSIZE; - else if (h8300hmode) - memory_size = H8300H_MSIZE; - else - memory_size = H8300_MSIZE; - cpu.memory = (unsigned char *) calloc (sizeof (char), memory_size); - cpu.cache_idx = (unsigned short *) calloc (sizeof (short), memory_size); - cpu.eightbit = (unsigned char *) calloc (sizeof (char), 256); + /* Find the exact opcode/arg combo. */ + for (q = h8_opcodes; q->name; q++) + { + op_type *nib = q->data.nib; + unsigned int len = 0; - /* `msize' must be a power of two. */ - if ((memory_size & (memory_size - 1)) != 0) - abort (); - cpu.mask = memory_size - 1; + if ((q->available == AV_H8SX && !h8300sxmode) || + (q->available == AV_H8H && !h8300hmode)) + continue; - for (i = 0; i < 9; i++) + while (1) { - cpu.regs[i] = 0; - } + op_type looking_for = *nib; + int thisnib = data[len / 2]; - for (i = 0; i < 8; i++) - { - unsigned char *p = (unsigned char *) (cpu.regs + i); - unsigned char *e = (unsigned char *) (cpu.regs + i + 1); - unsigned short *q = (unsigned short *) (cpu.regs + i); - unsigned short *u = (unsigned short *) (cpu.regs + i + 1); - cpu.regs[i] = 0x00112233; - while (p < e) + thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf); + opnum = ((looking_for & OP3) ? 2 : + (looking_for & DST) ? 1 : 0); + + if (looking_for < 16 && looking_for >= 0) { - if (*p == 0x22) - { - breg[i] = p; - } - if (*p == 0x33) - { - breg[i + 8] = p; - } - p++; + if (looking_for != thisnib) + goto fail; } - wreg[i] = wreg[i + 8] = 0; - while (q < u) + else { - if (*q == 0x2233) + if (looking_for & B31) { - wreg[i] = q; + if (!((thisnib & 0x8) != 0)) + goto fail; + + looking_for = (op_type) (looking_for & ~B31); + thisnib &= 0x7; } - if (*q == 0x0011) + else if (looking_for & B30) { - wreg[i + 8] = q; + if (!((thisnib & 0x8) == 0)) + goto fail; + + looking_for = (op_type) (looking_for & ~B30); } - q++; - } - if (wreg[i] == 0 || wreg[i + 8] == 0) - abort (); - cpu.regs[i] = 0; - lreg[i] = &cpu.regs[i]; - } - lreg[8] = &cpu.regs[8]; + if (looking_for & B21) + { + if (!((thisnib & 0x4) != 0)) + goto fail; - /* Initialize the seg registers. */ - if (!cpu.cache) - sim_set_simcache_size (CSIZE); - } -} + looking_for = (op_type) (looking_for & ~B21); + thisnib &= 0xb; + } + else if (looking_for & B20) + { + if (!((thisnib & 0x4) == 0)) + goto fail; -static void -control_c (int sig) -{ - cpu.state = SIM_STATE_STOPPED; - cpu.exception = SIGINT; -} + looking_for = (op_type) (looking_for & ~B20); + } -#define C (c != 0) -#define Z (nz == 0) -#define V (v != 0) -#define N (n != 0) -#define U (u != 0) -#define H (h != 0) -#define UI (ui != 0) -#define I (intMaskBit != 0) + if (looking_for & B11) + { + if (!((thisnib & 0x2) != 0)) + goto fail; -static int -mop (decoded_inst *code, int bsize, int sign) -{ - int multiplier; - int multiplicand; - int result; - int n, nz; + looking_for = (op_type) (looking_for & ~B11); + thisnib &= 0xd; + } + else if (looking_for & B10) + { + if (!((thisnib & 0x2) == 0)) + goto fail; - if (sign) - { - multiplicand = - bsize ? SEXTCHAR (GET_W_REG (code->dst.reg)) : - SEXTSHORT (GET_W_REG (code->dst.reg)); - multiplier = - bsize ? SEXTCHAR (GET_B_REG (code->src.reg)) : - SEXTSHORT (GET_W_REG (code->src.reg)); - } - else - { - multiplicand = bsize ? UEXTCHAR (GET_W_REG (code->dst.reg)) : - UEXTSHORT (GET_W_REG (code->dst.reg)); - multiplier = - bsize ? UEXTCHAR (GET_B_REG (code->src.reg)) : - UEXTSHORT (GET_W_REG (code->src.reg)); + looking_for = (op_type) (looking_for & ~B10); + } - } - result = multiplier * multiplicand; + if (looking_for & B01) + { + if (!((thisnib & 0x1) != 0)) + goto fail; - if (sign) - { - n = result & (bsize ? 0x8000 : 0x80000000); - nz = result & (bsize ? 0xffff : 0xffffffff); - } - if (bsize) - { - SET_W_REG (code->dst.reg, result); - } - else - { - SET_L_REG (code->dst.reg, result); - } -#if 0 - return ((n == 1) << 1) | (nz == 1); -#endif -} + looking_for = (op_type) (looking_for & ~B01); + thisnib &= 0xe; + } + else if (looking_for & B00) + { + if (!((thisnib & 0x1) == 0)) + goto fail; -#define ONOT(name, how) \ -case O (name, SB): \ -{ \ - int t; \ - int hm = 0x80; \ - rd = GET_B_REG (code->src.reg); \ - how; \ - goto shift8; \ -} \ -case O (name, SW): \ -{ \ - int t; \ - int hm = 0x8000; \ - rd = GET_W_REG (code->src.reg); \ - how; \ - goto shift16; \ -} \ -case O (name, SL): \ -{ \ - int t; \ - int hm = 0x80000000; \ - rd = GET_L_REG (code->src.reg); \ - how; \ - goto shift32; \ -} + looking_for = (op_type) (looking_for & ~B00); + } -#define OSHIFTS(name, how1, how2) \ -case O (name, SB): \ -{ \ - int t; \ - int hm = 0x80; \ - rd = GET_B_REG (code->src.reg); \ - if ((GET_MEMORY_B (pc + 1) & 0x40) == 0) \ - { \ - how1; \ - } \ - else \ - { \ - how2; \ - } \ - goto shift8; \ -} \ -case O (name, SW): \ -{ \ - int t; \ - int hm = 0x8000; \ - rd = GET_W_REG (code->src.reg); \ - if ((GET_MEMORY_B (pc + 1) & 0x40) == 0) \ - { \ - how1; \ - } \ - else \ - { \ - how2; \ - } \ - goto shift16; \ -} \ -case O (name, SL): \ -{ \ - int t; \ - int hm = 0x80000000; \ - rd = GET_L_REG (code->src.reg); \ - if ((GET_MEMORY_B (pc + 1) & 0x40) == 0) \ - { \ - how1; \ - } \ - else \ - { \ - how2; \ - } \ - goto shift32; \ -} - -#define OBITOP(name,f, s, op) \ -case O (name, SB): \ -{ \ - int m; \ - int b; \ - if (f) ea = fetch (&code->dst); \ - m=1<< fetch (&code->src); \ - op; \ - if (s) store (&code->dst,ea); goto next; \ -} + if (looking_for & IGNORE) + { + /* Hitachi has declared that IGNORE must be zero. */ + if (thisnib != 0) + goto fail; + } + else if ((looking_for & MODE) == DATA) + { + ; /* Skip embedded data. */ + } + else if ((looking_for & MODE) == DBIT) + { + /* Exclude adds/subs by looking at bit 0 and 2, and + make sure the operand size, either w or l, + matches by looking at bit 1. */ + if ((looking_for & 7) != (thisnib & 7)) + goto fail; -int -sim_stop (SIM_DESC sd) -{ - cpu.state = SIM_STATE_STOPPED; - cpu.exception = SIGINT; - return 1; -} + cst[opnum] = (thisnib & 0x8) ? 2 : 1; + } + else if ((looking_for & MODE) == REG || + (looking_for & MODE) == LOWREG || + (looking_for & MODE) == IND || + (looking_for & MODE) == PREINC || + (looking_for & MODE) == POSTINC || + (looking_for & MODE) == PREDEC || + (looking_for & MODE) == POSTDEC) + { + reg[opnum] = thisnib; + } + else if (looking_for & CTRL) + { + thisnib &= 7; + if (((looking_for & MODE) == CCR && (thisnib != C_CCR)) || + ((looking_for & MODE) == EXR && (thisnib != C_EXR)) || + ((looking_for & MODE) == MACH && (thisnib != C_MACH)) || + ((looking_for & MODE) == MACL && (thisnib != C_MACL)) || + ((looking_for & MODE) == VBR && (thisnib != C_VBR)) || + ((looking_for & MODE) == SBR && (thisnib != C_SBR))) + goto fail; + if (((looking_for & MODE) == CCR_EXR && + (thisnib != C_CCR && thisnib != C_EXR)) || + ((looking_for & MODE) == VBR_SBR && + (thisnib != C_VBR && thisnib != C_SBR)) || + ((looking_for & MODE) == MACREG && + (thisnib != C_MACH && thisnib != C_MACL))) + goto fail; + if (((looking_for & MODE) == CC_EX_VB_SB && + (thisnib != C_CCR && thisnib != C_EXR && + thisnib != C_VBR && thisnib != C_SBR))) + goto fail; -#define R0_REGNUM 0 -#define R1_REGNUM 1 -#define R2_REGNUM 2 -#define R3_REGNUM 3 -#define R4_REGNUM 4 -#define R5_REGNUM 5 -#define R6_REGNUM 6 -#define R7_REGNUM 7 + reg[opnum] = thisnib; + } + else if ((looking_for & MODE) == ABS) + { + /* Absolute addresses are unsigned. */ + switch (looking_for & SIZE) + { + case L_8: + cst[opnum] = UEXTCHAR (data[len / 2]); + break; + case L_16: + case L_16U: + cst[opnum] = (data[len / 2] << 8) + data[len / 2 + 1]; + break; + case L_32: + cst[opnum] = + (data[len / 2 + 0] << 24) + + (data[len / 2 + 1] << 16) + + (data[len / 2 + 2] << 8) + + (data[len / 2 + 3]); + break; + default: + printf ("decode: bad size ABS: %d\n", + (looking_for & SIZE)); + goto end; + } + } + else if ((looking_for & MODE) == DISP || + (looking_for & MODE) == PCREL || + (looking_for & MODE) == INDEXB || + (looking_for & MODE) == INDEXW || + (looking_for & MODE) == INDEXL) -#define SP_REGNUM R7_REGNUM /* Contains address of top of stack */ -#define FP_REGNUM R6_REGNUM /* Contains address of executing - * stack frame */ + { + switch (looking_for & SIZE) + { + case L_2: + cst[opnum] = thisnib & 3; -#define CCR_REGNUM 8 /* Contains processor status */ -#define PC_REGNUM 9 /* Contains program counter */ + /* DISP2 special treatment. */ + if ((looking_for & MODE) == DISP) + { + switch (OP_SIZE (q->how)) { + default: break; + case SW: + cst[opnum] *= 2; + break; + case SL: + cst[opnum] *= 4; + break; + } + } + break; + case L_8: + cst[opnum] = SEXTCHAR (data[len / 2]); + break; + case L_16: + cst[opnum] = (data[len / 2] << 8) + data[len / 2 + 1]; + cst[opnum] = (short) cst[opnum]; /* Sign extend. */ + break; + case L_16U: + cst[opnum] = (data[len / 2] << 8) + data[len / 2 + 1]; + break; + case L_32: + cst[opnum] = + (data[len / 2 + 0] << 24) + + (data[len / 2 + 1] << 16) + + (data[len / 2 + 2] << 8) + + (data[len / 2 + 3]); + break; + default: + printf ("decode: bad size DISP/PCREL/INDEX: %d\n", + (looking_for & SIZE)); + goto end; + } + } + else if ((looking_for & SIZE) == L_16 || + (looking_for & SIZE) == L_16U) + { + cst[opnum] = (data[len / 2] << 8) + data[len / 2 + 1]; + if ((looking_for & SIZE) != L_16U) + cst[opnum] = (short) cst[opnum]; /* Sign extend. */ + } + else if (looking_for & ABSJMP) + { + switch (looking_for & SIZE) { + case L_24: + cst[opnum] = (data[1] << 16) | (data[2] << 8) | (data[3]); + break; + case L_32: + cst[opnum] = + (data[len / 2 + 0] << 24) + + (data[len / 2 + 1] << 16) + + (data[len / 2 + 2] << 8) + + (data[len / 2 + 3]); + break; + default: + printf ("decode: bad size ABSJMP: %d\n", + (looking_for & SIZE)); + goto end; + } + } + else if ((looking_for & MODE) == MEMIND) + { + cst[opnum] = data[1]; + } + else if ((looking_for & SIZE) == L_32) + { + int i = len / 2; -#define CYCLE_REGNUM 10 + cst[opnum] = + (data[i + 0] << 24) | + (data[i + 1] << 16) | + (data[i + 2] << 8) | + (data[i + 3]); + } + else if ((looking_for & SIZE) == L_24) + { + int i = len / 2; -#define EXR_REGNUM 11 -#define INST_REGNUM 12 -#define TICK_REGNUM 13 + cst[opnum] = + (data[i + 0] << 16) | + (data[i + 1] << 8) | + (data[i + 2]); + } + else if (looking_for & DISPREG) + { + rdisp[opnum] = thisnib & 0x7; + } + else if ((looking_for & MODE) == KBIT) + { + switch (thisnib) + { + case 9: + cst[opnum] = 4; + break; + case 8: + cst[opnum] = 2; + break; + case 0: + cst[opnum] = 1; + break; + default: + goto fail; + } + } + else if ((looking_for & SIZE) == L_8) + { + if ((looking_for & MODE) == ABS) + { + /* Will be combined with contents of SBR_REGNUM + by fetch (). For all modes except h8sx, this + will always contain the value 0xFFFFFF00. */ + cst[opnum] = data[len / 2] & 0xff; + } + else + { + cst[opnum] = data[len / 2] & 0xff; + } + } + else if ((looking_for & SIZE) == L_3 || + (looking_for & SIZE) == L_3NZ) + { + cst[opnum] = thisnib & 7; + if (cst[opnum] == 0 && (looking_for & SIZE) == L_3NZ) + goto fail; + } + else if ((looking_for & SIZE) == L_4) + { + cst[opnum] = thisnib & 15; + } + else if ((looking_for & SIZE) == L_5) + { + cst[opnum] = data[len / 2] & 0x1f; + } + else if (looking_for == E) + { +#ifdef ADEBUG + dst->op = q; +#endif + /* Fill in the args. */ + { + op_type *args = q->args.nib; + int hadone = 0; + int nargs; -void -sim_resume (SIM_DESC sd, int step, int siggnal) -{ - static int init1; - int cycles = 0; - int insts = 0; - int tick_start = get_now (); - void (*prev) (); - int poll_count = 0; - int res; - int tmp; - int rd; - int ea; - int bit; - int pc; - int c, nz, v, n, u, h, ui, intMaskBit; - int trace, intMask; - int oldmask; - init_pointers (); + for (nargs = 0; + nargs < 3 && *args != E; + nargs++) + { + int x = *args; + ea_type *p; - prev = signal (SIGINT, control_c); + opnum = ((x & OP3) ? 2 : + (x & DST) ? 1 : 0); + if (x & DST) + p = &dst->dst; + else if (x & OP3) + p = &dst->op3; + else + p = &dst->src; - if (step) - { - cpu.state = SIM_STATE_STOPPED; - cpu.exception = SIGTRAP; - } - else - { - cpu.state = SIM_STATE_RUNNING; - cpu.exception = 0; - } + if ((x & MODE) == IMM || + (x & MODE) == KBIT || + (x & MODE) == DBIT) + { + /* Use the instruction to determine + the operand size. */ + p->type = X (OP_IMM, OP_SIZE (q->how)); + p->literal = cst[opnum]; + } + else if ((x & MODE) == CONST_2 || + (x & MODE) == CONST_4 || + (x & MODE) == CONST_8 || + (x & MODE) == CONST_16) + { + /* Use the instruction to determine + the operand size. */ + p->type = X (OP_IMM, OP_SIZE (q->how)); + switch (x & MODE) { + case CONST_2: p->literal = 2; break; + case CONST_4: p->literal = 4; break; + case CONST_8: p->literal = 8; break; + case CONST_16: p->literal = 16; break; + } + } + else if ((x & MODE) == REG) + { + p->type = X (OP_REG, bitfrom (x)); + p->reg = reg[opnum]; + } + else if ((x & MODE) == LOWREG) + { + p->type = X (OP_LOWREG, bitfrom (x)); + p->reg = reg[opnum]; + } + else if ((x & MODE) == PREINC) + { + /* Use the instruction to determine + the operand size. */ + p->type = X (OP_PREINC, OP_SIZE (q->how)); + p->reg = reg[opnum] & 0x7; + } + else if ((x & MODE) == POSTINC) + { + /* Use the instruction to determine + the operand size. */ + p->type = X (OP_POSTINC, OP_SIZE (q->how)); + p->reg = reg[opnum] & 0x7; + } + else if ((x & MODE) == PREDEC) + { + /* Use the instruction to determine + the operand size. */ + p->type = X (OP_PREDEC, OP_SIZE (q->how)); + p->reg = reg[opnum] & 0x7; + } + else if ((x & MODE) == POSTDEC) + { + /* Use the instruction to determine + the operand size. */ + p->type = X (OP_POSTDEC, OP_SIZE (q->how)); + p->reg = reg[opnum] & 0x7; + } + else if ((x & MODE) == IND) + { + /* Note: an indirect is transformed into + a displacement of zero. + */ + /* Use the instruction to determine + the operand size. */ + p->type = X (OP_DISP, OP_SIZE (q->how)); + p->reg = reg[opnum] & 0x7; + p->literal = 0; + if (OP_KIND (q->how) == O_JSR || + OP_KIND (q->how) == O_JMP) + if (lvalue (sd, p->type, p->reg, &p->type)) + goto end; + } + else if ((x & MODE) == ABS) + { + /* Note: a 16 or 32 bit ABS is transformed into a + displacement from pseudo-register ZERO_REGNUM, + which is always zero. An 8 bit ABS becomes + a displacement from SBR_REGNUM. + */ + /* Use the instruction to determine + the operand size. */ + p->type = X (OP_DISP, OP_SIZE (q->how)); + p->literal = cst[opnum]; + + /* 8-bit ABS is displacement from SBR. + 16 and 32-bit ABS are displacement from ZERO. + (SBR will always be zero except for h8/sx) + */ + if ((x & SIZE) == L_8) + p->reg = SBR_REGNUM; + else + p->reg = ZERO_REGNUM;; + } + else if ((x & MODE) == MEMIND) + { + /* Size doesn't matter. */ + p->type = X (OP_MEM, SB); + p->literal = cst[opnum]; + if (OP_KIND (q->how) == O_JSR || + OP_KIND (q->how) == O_JMP) + if (lvalue (sd, p->type, p->reg, &p->type)) + goto end; + } + else if ((x & MODE) == PCREL) + { + /* Size doesn't matter. */ + p->type = X (OP_PCREL, SB); + p->literal = cst[opnum]; + } + else if (x & ABSJMP) + { + p->type = X (OP_IMM, SP); + p->literal = cst[opnum]; + } + else if ((x & MODE) == INDEXB || + (x & MODE) == INDEXW || + (x & MODE) == INDEXL || + (x & MODE) == DISP) + { + /* Use the instruction to determine + the operand size. */ + switch (x & MODE) { + case INDEXB: + p->type = X (OP_INDEXB, OP_SIZE (q->how)); + break; + case INDEXW: + p->type = X (OP_INDEXW, OP_SIZE (q->how)); + break; + case INDEXL: + p->type = X (OP_INDEXL, OP_SIZE (q->how)); + break; + case DISP: + p->type = X (OP_DISP, OP_SIZE (q->how)); + break; + } + + p->literal = cst[opnum]; + p->reg = rdisp[opnum]; + } + else if (x & CTRL) + { + switch (reg[opnum]) + { + case C_CCR: + p->type = X (OP_CCR, SB); + break; + case C_EXR: + p->type = X (OP_EXR, SB); + break; + case C_MACH: + p->type = X (OP_MACH, SL); + break; + case C_MACL: + p->type = X (OP_MACL, SL); + break; + case C_VBR: + p->type = X (OP_VBR, SL); + break; + case C_SBR: + p->type = X (OP_SBR, SL); + break; + } + } + else if ((x & MODE) == CCR) + { + p->type = OP_CCR; + } + else if ((x & MODE) == EXR) + { + p->type = OP_EXR; + } + else + printf ("Hmmmm %x...\n", x); - pc = cpu.pc; + args++; + } + } - /* The PC should never be odd. */ - if (pc & 0x1) - abort (); + /* Unary operators: treat src and dst as equivalent. */ + if (dst->dst.type == -1) + dst->dst = dst->src; + if (dst->src.type == -1) + dst->src = dst->dst; + + dst->opcode = q->how; + dst->cycles = q->time; - GETSR (); - GETEXR (); + /* And jsr's to these locations are turned into + magic traps. */ - oldmask = cpu.mask; - if (!h8300hmode) - cpu.mask = 0xffff; - do + if (OP_KIND (dst->opcode) == O_JSR) + { + switch (dst->src.literal) + { + case 0xc5: + dst->opcode = O (O_SYS_OPEN, SB); + break; + case 0xc6: + dst->opcode = O (O_SYS_READ, SB); + break; + case 0xc7: + dst->opcode = O (O_SYS_WRITE, SB); + break; + case 0xc8: + dst->opcode = O (O_SYS_LSEEK, SB); + break; + case 0xc9: + dst->opcode = O (O_SYS_CLOSE, SB); + break; + case 0xca: + dst->opcode = O (O_SYS_STAT, SB); + break; + case 0xcb: + dst->opcode = O (O_SYS_FSTAT, SB); + break; + case 0xcc: + dst->opcode = O (O_SYS_CMDLINE, SB); + break; + } + /* End of Processing for system calls. */ + } + + dst->next_pc = addr + len / 2; + return; + } + else + printf ("Don't understand %x \n", looking_for); + } + + len++; + nib++; + } + + fail: + ; + } + end: + /* Fell off the end. */ + dst->opcode = O (O_ILL, SB); +} + +static void +compile (SIM_DESC sd, int pc) +{ + int idx; + + /* Find the next cache entry to use. */ + idx = h8_get_cache_top (sd) + 1; + h8_increment_compiles (sd); + if (idx >= sd->sim_cache_size) { - int cidx; - decoded_inst *code; + idx = 1; + } + h8_set_cache_top (sd, idx); - top: - cidx = cpu.cache_idx[pc]; - code = cpu.cache + cidx; + /* Throw away its old meaning. */ + h8_set_cache_idx (sd, sd->sim_cache[idx].oldpc, 0); + + /* Set to new address. */ + sd->sim_cache[idx].oldpc = pc; + /* Fill in instruction info. */ + decode (sd, pc, h8_get_memory_buf (sd) + pc, sd->sim_cache + idx); -#define ALUOP(STORE, NAME, HOW) \ - case O (NAME, SB): HOW; if (STORE) goto alu8; else goto just_flags_alu8; \ - case O (NAME, SW): HOW; if (STORE) goto alu16; else goto just_flags_alu16; \ - case O (NAME, SL): HOW; if (STORE) goto alu32; else goto just_flags_alu32; + /* Point to new cache entry. */ + h8_set_cache_idx (sd, pc, idx); +} -#define LOGOP(NAME, HOW) \ - case O (NAME, SB): HOW; goto log8; \ - case O (NAME, SW): HOW; goto log16; \ - case O (NAME, SL): HOW; goto log32; +static unsigned char *breg[32]; +static unsigned short *wreg[16]; +static unsigned int *lreg[18]; + +#define GET_B_REG(X) *(breg[X]) +#define SET_B_REG(X, Y) (*(breg[X])) = (Y) +#define GET_W_REG(X) *(wreg[X]) +#define SET_W_REG(X, Y) (*(wreg[X])) = (Y) +#define GET_L_REG(X) h8_get_reg (sd, X) +#define SET_L_REG(X, Y) h8_set_reg (sd, X, Y) + +#define GET_MEMORY_L(X) \ + ((X) < memory_size \ + ? ((h8_get_memory (sd, (X)+0) << 24) | (h8_get_memory (sd, (X)+1) << 16) \ + | (h8_get_memory (sd, (X)+2) << 8) | (h8_get_memory (sd, (X)+3) << 0)) \ + : ((h8_get_eightbit (sd, ((X)+0) & 0xff) << 24) \ + | (h8_get_eightbit (sd, ((X)+1) & 0xff) << 16) \ + | (h8_get_eightbit (sd, ((X)+2) & 0xff) << 8) \ + | (h8_get_eightbit (sd, ((X)+3) & 0xff) << 0))) + +#define GET_MEMORY_W(X) \ + ((X) < memory_size \ + ? ((h8_get_memory (sd, (X)+0) << 8) \ + | (h8_get_memory (sd, (X)+1) << 0)) \ + : ((h8_get_eightbit (sd, ((X)+0) & 0xff) << 8) \ + | (h8_get_eightbit (sd, ((X)+1) & 0xff) << 0))) + + +#define GET_MEMORY_B(X) \ + ((X) < memory_size ? (h8_get_memory (sd, (X))) \ + : (h8_get_eightbit (sd, (X) & 0xff))) + +#define SET_MEMORY_L(X, Y) \ +{ register unsigned char *_p; register int __y = (Y); \ + _p = ((X) < memory_size ? h8_get_memory_buf (sd) + (X) : \ + h8_get_eightbit_buf (sd) + ((X) & 0xff)); \ + _p[0] = __y >> 24; _p[1] = __y >> 16; \ + _p[2] = __y >> 8; _p[3] = __y >> 0; \ +} +#define SET_MEMORY_W(X, Y) \ +{ register unsigned char *_p; register int __y = (Y); \ + _p = ((X) < memory_size ? h8_get_memory_buf (sd) + (X) : \ + h8_get_eightbit_buf (sd) + ((X) & 0xff)); \ + _p[0] = __y >> 8; _p[1] = __y; \ +} +#define SET_MEMORY_B(X, Y) \ + ((X) < memory_size ? (h8_set_memory (sd, (X), (Y))) \ + : (h8_set_eightbit (sd, (X) & 0xff, (Y)))) -#if ADEBUG - if (debug) - { - printf ("%x %d %s\n", pc, code->opcode, - code->op ? code->op->name : "**"); - } - cpu.stats[code->opcode]++; +/* Simulate a memory fetch. + Return 0 for success, -1 for failure. +*/ -#endif +static int +fetch_1 (SIM_DESC sd, ea_type *arg, int *val, int twice) +{ + int rn = arg->reg; + int abs = arg->literal; + int r; + int t; + + if (val == NULL) + return -1; /* Paranoia. */ + + switch (arg->type) + { + /* Indexed register plus displacement mode: + + This new family of addressing modes are similar to OP_DISP + (register plus displacement), with two differences: + 1) INDEXB uses only the least significant byte of the register, + INDEXW uses only the least significant word, and + INDEXL uses the entire register (just like OP_DISP). + and + 2) The displacement value in abs is multiplied by two + for SW-sized operations, and by four for SL-size. + + This gives nine possible variations. + */ + + case X (OP_INDEXB, SB): + case X (OP_INDEXB, SW): + case X (OP_INDEXB, SL): + case X (OP_INDEXW, SB): + case X (OP_INDEXW, SW): + case X (OP_INDEXW, SL): + case X (OP_INDEXL, SB): + case X (OP_INDEXL, SW): + case X (OP_INDEXL, SL): + t = GET_L_REG (rn); + switch (OP_KIND (arg->type)) { + case OP_INDEXB: t &= 0xff; break; + case OP_INDEXW: t &= 0xffff; break; + case OP_INDEXL: + default: break; + } + switch (OP_SIZE (arg->type)) { + case SB: + *val = GET_MEMORY_B ((t * 1 + abs) & h8_get_mask (sd)); + break; + case SW: + *val = GET_MEMORY_W ((t * 2 + abs) & h8_get_mask (sd)); + break; + case SL: + *val = GET_MEMORY_L ((t * 4 + abs) & h8_get_mask (sd)); + break; + } + break; + + case X (OP_LOWREG, SB): + *val = GET_L_REG (rn) & 0xff; + break; + case X (OP_LOWREG, SW): + *val = GET_L_REG (rn) & 0xffff; + break; + + case X (OP_REG, SB): /* Register direct, byte. */ + *val = GET_B_REG (rn); + break; + case X (OP_REG, SW): /* Register direct, word. */ + *val = GET_W_REG (rn); + break; + case X (OP_REG, SL): /* Register direct, long. */ + *val = GET_L_REG (rn); + break; + case X (OP_IMM, SB): /* Immediate, byte. */ + case X (OP_IMM, SW): /* Immediate, word. */ + case X (OP_IMM, SL): /* Immediate, long. */ + *val = abs; + break; + case X (OP_POSTINC, SB): /* Register indirect w/post-incr: byte. */ + t = GET_L_REG (rn); + t &= h8_get_mask (sd); + r = GET_MEMORY_B (t); + if (!twice) + t += 1; + t = t & h8_get_mask (sd); + SET_L_REG (rn, t); + *val = r; + break; + case X (OP_POSTINC, SW): /* Register indirect w/post-incr: word. */ + t = GET_L_REG (rn); + t &= h8_get_mask (sd); + r = GET_MEMORY_W (t); + if (!twice) + t += 2; + t = t & h8_get_mask (sd); + SET_L_REG (rn, t); + *val = r; + break; + case X (OP_POSTINC, SL): /* Register indirect w/post-incr: long. */ + t = GET_L_REG (rn); + t &= h8_get_mask (sd); + r = GET_MEMORY_L (t); + if (!twice) + t += 4; + t = t & h8_get_mask (sd); + SET_L_REG (rn, t); + *val = r; + break; + + case X (OP_POSTDEC, SB): /* Register indirect w/post-decr: byte. */ + t = GET_L_REG (rn); + t &= h8_get_mask (sd); + r = GET_MEMORY_B (t); + if (!twice) + t -= 1; + t = t & h8_get_mask (sd); + SET_L_REG (rn, t); + *val = r; + break; + case X (OP_POSTDEC, SW): /* Register indirect w/post-decr: word. */ + t = GET_L_REG (rn); + t &= h8_get_mask (sd); + r = GET_MEMORY_W (t); + if (!twice) + t -= 2; + t = t & h8_get_mask (sd); + SET_L_REG (rn, t); + *val = r; + break; + case X (OP_POSTDEC, SL): /* Register indirect w/post-decr: long. */ + t = GET_L_REG (rn); + t &= h8_get_mask (sd); + r = GET_MEMORY_L (t); + if (!twice) + t -= 4; + t = t & h8_get_mask (sd); + SET_L_REG (rn, t); + *val = r; + break; + + case X (OP_PREDEC, SB): /* Register indirect w/pre-decr: byte. */ + t = GET_L_REG (rn) - 1; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + *val = GET_MEMORY_B (t); + break; + + case X (OP_PREDEC, SW): /* Register indirect w/pre-decr: word. */ + t = GET_L_REG (rn) - 2; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + *val = GET_MEMORY_W (t); + break; + + case X (OP_PREDEC, SL): /* Register indirect w/pre-decr: long. */ + t = GET_L_REG (rn) - 4; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + *val = GET_MEMORY_L (t); + break; + + case X (OP_PREINC, SB): /* Register indirect w/pre-incr: byte. */ + t = GET_L_REG (rn) + 1; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + *val = GET_MEMORY_B (t); + break; + + case X (OP_PREINC, SW): /* Register indirect w/pre-incr: long. */ + t = GET_L_REG (rn) + 2; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + *val = GET_MEMORY_W (t); + break; + + case X (OP_PREINC, SL): /* Register indirect w/pre-incr: long. */ + t = GET_L_REG (rn) + 4; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + *val = GET_MEMORY_L (t); + break; + + case X (OP_DISP, SB): /* Register indirect w/displacement: byte. */ + t = GET_L_REG (rn) + abs; + t &= h8_get_mask (sd); + *val = GET_MEMORY_B (t); + break; + + case X (OP_DISP, SW): /* Register indirect w/displacement: word. */ + t = GET_L_REG (rn) + abs; + t &= h8_get_mask (sd); + *val = GET_MEMORY_W (t); + break; + + case X (OP_DISP, SL): /* Register indirect w/displacement: long. */ + t = GET_L_REG (rn) + abs; + t &= h8_get_mask (sd); + *val =GET_MEMORY_L (t); + break; + + case X (OP_MEM, SL): /* Absolute memory address, long. */ + t = GET_MEMORY_L (abs); + t &= h8_get_mask (sd); + *val = t; + break; + + case X (OP_MEM, SW): /* Absolute memory address, word. */ + t = GET_MEMORY_W (abs); + t &= h8_get_mask (sd); + *val = t; + break; + + case X (OP_PCREL, SB): /* PC relative (for jump, branch etc). */ + case X (OP_PCREL, SW): + case X (OP_PCREL, SL): + case X (OP_PCREL, SN): + *val = abs; + break; + + case X (OP_MEM, SB): /* Why isn't this implemented? */ + default: + sim_engine_set_run_state (sd, sim_stopped, SIGSEGV); + return -1; + } + return 0; /* Success. */ +} + +/* Normal fetch. */ + +static int +fetch (SIM_DESC sd, ea_type *arg, int *val) +{ + return fetch_1 (sd, arg, val, 0); +} + +/* Fetch which will be followed by a store to the same location. + The difference being that we don't want to do a post-increment + or post-decrement at this time: we'll do it when we store. */ + +static int +fetch2 (SIM_DESC sd, ea_type *arg, int *val) +{ + return fetch_1 (sd, arg, val, 1); +} + +/* Simulate a memory store. + Return 0 for success, -1 for failure. +*/ + +static int +store_1 (SIM_DESC sd, ea_type *arg, int n, int twice) +{ + int rn = arg->reg; + int abs = arg->literal; + int t; + + switch (arg->type) + { + /* Indexed register plus displacement mode: + + This new family of addressing modes are similar to OP_DISP + (register plus displacement), with two differences: + 1) INDEXB uses only the least significant byte of the register, + INDEXW uses only the least significant word, and + INDEXL uses the entire register (just like OP_DISP). + and + 2) The displacement value in abs is multiplied by two + for SW-sized operations, and by four for SL-size. + + This gives nine possible variations. + */ + + case X (OP_INDEXB, SB): + case X (OP_INDEXB, SW): + case X (OP_INDEXB, SL): + case X (OP_INDEXW, SB): + case X (OP_INDEXW, SW): + case X (OP_INDEXW, SL): + case X (OP_INDEXL, SB): + case X (OP_INDEXL, SW): + case X (OP_INDEXL, SL): + t = GET_L_REG (rn); + switch (OP_KIND (arg->type)) { + case OP_INDEXB: t &= 0xff; break; + case OP_INDEXW: t &= 0xffff; break; + case OP_INDEXL: + default: break; + } + switch (OP_SIZE (arg->type)) { + case SB: + SET_MEMORY_B ((t * 1 + abs) & h8_get_mask (sd), n); + break; + case SW: + SET_MEMORY_W ((t * 2 + abs) & h8_get_mask (sd), n); + break; + case SL: + SET_MEMORY_L ((t * 4 + abs) & h8_get_mask (sd), n); + break; + } + break; + + case X (OP_REG, SB): /* Register direct, byte. */ + SET_B_REG (rn, n); + break; + case X (OP_REG, SW): /* Register direct, word. */ + SET_W_REG (rn, n); + break; + case X (OP_REG, SL): /* Register direct, long. */ + SET_L_REG (rn, n); + break; + + case X (OP_PREDEC, SB): /* Register indirect w/pre-decr, byte. */ + t = GET_L_REG (rn); + if (!twice) + t -= 1; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + SET_MEMORY_B (t, n); + + break; + case X (OP_PREDEC, SW): /* Register indirect w/pre-decr, word. */ + t = GET_L_REG (rn); + if (!twice) + t -= 2; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + SET_MEMORY_W (t, n); + break; + + case X (OP_PREDEC, SL): /* Register indirect w/pre-decr, long. */ + t = GET_L_REG (rn); + if (!twice) + t -= 4; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + SET_MEMORY_L (t, n); + break; + + case X (OP_PREINC, SB): /* Register indirect w/pre-incr, byte. */ + t = GET_L_REG (rn); + if (!twice) + t += 1; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + SET_MEMORY_B (t, n); + + break; + case X (OP_PREINC, SW): /* Register indirect w/pre-incr, word. */ + t = GET_L_REG (rn); + if (!twice) + t += 2; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + SET_MEMORY_W (t, n); + break; + + case X (OP_PREINC, SL): /* Register indirect w/pre-incr, long. */ + t = GET_L_REG (rn); + if (!twice) + t += 4; + t &= h8_get_mask (sd); + SET_L_REG (rn, t); + SET_MEMORY_L (t, n); + break; + + case X (OP_POSTDEC, SB): /* Register indirect w/post-decr, byte. */ + t = GET_L_REG (rn) & h8_get_mask (sd); + SET_MEMORY_B (t, n); + SET_L_REG (rn, t - 1); + break; + + case X (OP_POSTDEC, SW): /* Register indirect w/post-decr, word. */ + t = GET_L_REG (rn) & h8_get_mask (sd); + SET_MEMORY_W (t, n); + SET_L_REG (rn, t - 2); + break; + + case X (OP_POSTDEC, SL): /* Register indirect w/post-decr, long. */ + t = GET_L_REG (rn) & h8_get_mask (sd); + SET_MEMORY_L (t, n); + SET_L_REG (rn, t - 4); + break; + + case X (OP_POSTINC, SB): /* Register indirect w/post-incr, byte. */ + t = GET_L_REG (rn) & h8_get_mask (sd); + SET_MEMORY_B (t, n); + SET_L_REG (rn, t + 1); + break; + + case X (OP_POSTINC, SW): /* Register indirect w/post-incr, word. */ + t = GET_L_REG (rn) & h8_get_mask (sd); + SET_MEMORY_W (t, n); + SET_L_REG (rn, t + 2); + break; + + case X (OP_POSTINC, SL): /* Register indirect w/post-incr, long. */ + t = GET_L_REG (rn) & h8_get_mask (sd); + SET_MEMORY_L (t, n); + SET_L_REG (rn, t + 4); + break; + + case X (OP_DISP, SB): /* Register indirect w/displacement, byte. */ + t = GET_L_REG (rn) + abs; + t &= h8_get_mask (sd); + SET_MEMORY_B (t, n); + break; + + case X (OP_DISP, SW): /* Register indirect w/displacement, word. */ + t = GET_L_REG (rn) + abs; + t &= h8_get_mask (sd); + SET_MEMORY_W (t, n); + break; + + case X (OP_DISP, SL): /* Register indirect w/displacement, long. */ + t = GET_L_REG (rn) + abs; + t &= h8_get_mask (sd); + SET_MEMORY_L (t, n); + break; + + + case X (OP_MEM, SB): /* Why isn't this implemented? */ + case X (OP_MEM, SW): /* Why isn't this implemented? */ + case X (OP_MEM, SL): /* Why isn't this implemented? */ + default: + sim_engine_set_run_state (sd, sim_stopped, SIGSEGV); + return -1; + } + return 0; +} + +/* Normal store. */ + +static int +store (SIM_DESC sd, ea_type *arg, int n) +{ + return store_1 (sd, arg, n, 0); +} + +/* Store which follows a fetch from the same location. + The difference being that we don't want to do a pre-increment + or pre-decrement at this time: it was already done when we fetched. */ + +static int +store2 (SIM_DESC sd, ea_type *arg, int n) +{ + return store_1 (sd, arg, n, 1); +} + +static union +{ + short int i; + struct + { + char low; + char high; + } + u; +} littleendian; + +/* Flag to be set whenever a new SIM_DESC object is created. */ +static int init_pointers_needed = 1; + +static void +init_pointers (SIM_DESC sd) +{ + if (init_pointers_needed) + { + int i; + + littleendian.i = 1; + + if (h8300smode) + memory_size = H8300S_MSIZE; + else if (h8300hmode) + memory_size = H8300H_MSIZE; + else + memory_size = H8300_MSIZE; + /* `msize' must be a power of two. */ + if ((memory_size & (memory_size - 1)) != 0) + { + (*sim_callback->printf_filtered) + (sim_callback, + "init_pointers: bad memory size %d, defaulting to %d.\n", + memory_size, memory_size = H8300S_MSIZE); + } + + if (h8_get_memory_buf (sd)) + free (h8_get_memory_buf (sd)); + if (h8_get_cache_idx_buf (sd)) + free (h8_get_cache_idx_buf (sd)); + if (h8_get_eightbit_buf (sd)) + free (h8_get_eightbit_buf (sd)); + + h8_set_memory_buf (sd, (unsigned char *) + calloc (sizeof (char), memory_size)); + h8_set_cache_idx_buf (sd, (unsigned short *) + calloc (sizeof (short), memory_size)); + sd->memory_size = memory_size; + h8_set_eightbit_buf (sd, (unsigned char *) calloc (sizeof (char), 256)); + + h8_set_mask (sd, memory_size - 1); + + memset (h8_get_reg_buf (sd), 0, sizeof (((STATE_CPU (sd, 0))->regs))); + + for (i = 0; i < 8; i++) + { + /* FIXME: rewrite using local buffer. */ + unsigned char *p = (unsigned char *) (h8_get_reg_buf (sd) + i); + unsigned char *e = (unsigned char *) (h8_get_reg_buf (sd) + i + 1); + unsigned short *q = (unsigned short *) (h8_get_reg_buf (sd) + i); + unsigned short *u = (unsigned short *) (h8_get_reg_buf (sd) + i + 1); + h8_set_reg (sd, i, 0x00112233); + + while (p < e) + { + if (*p == 0x22) + breg[i] = p; + if (*p == 0x33) + breg[i + 8] = p; + if (*p == 0x11) + breg[i + 16] = p; + if (*p == 0x00) + breg[i + 24] = p; + p++; + } + + wreg[i] = wreg[i + 8] = 0; + while (q < u) + { + if (*q == 0x2233) + { + wreg[i] = q; + } + if (*q == 0x0011) + { + wreg[i + 8] = q; + } + q++; + } + + if (wreg[i] == 0 || wreg[i + 8] == 0) + (*sim_callback->printf_filtered) (sim_callback, + "init_pointers: internal error.\n"); + + h8_set_reg (sd, i, 0); + lreg[i] = h8_get_reg_buf (sd) + i; + } + + /* Note: sim uses pseudo-register ZERO as a zero register. */ + lreg[ZERO_REGNUM] = h8_get_reg_buf (sd) + ZERO_REGNUM; + init_pointers_needed = 0; + + /* Initialize the seg registers. */ + if (!sd->sim_cache) + set_simcache_size (sd, CSIZE); + } +} + +/* Grotty global variable for use by control_c signal handler. */ +static SIM_DESC control_c_sim_desc; + +static void +control_c (int sig) +{ + sim_engine_set_run_state (control_c_sim_desc, sim_stopped, SIGINT); +} + +int +sim_stop (SIM_DESC sd) +{ + /* FIXME: use a real signal value. */ + sim_engine_set_run_state (sd, sim_stopped, SIGINT); + return 1; +} + +#define OBITOP(name, f, s, op) \ +case O (name, SB): \ +{ \ + int m, tmp; \ + \ + if (f) \ + if (fetch (sd, &code->dst, &ea)) \ + goto end; \ + if (fetch (sd, &code->src, &tmp)) \ + goto end; \ + m = 1 << tmp; \ + op; \ + if (s) \ + if (store (sd, &code->dst,ea)) \ + goto end; \ + goto next; \ +} + +void +sim_resume (SIM_DESC sd, int step, int siggnal) +{ + static int init1; + int cycles = 0; + int insts = 0; + int tick_start = get_now (); + void (*prev) (); + int poll_count = 0; + int res; + int tmp; + int rd; + int ea; + int bit; + int pc; + int c, nz, v, n, u, h, ui, intMaskBit; + int trace, intMask; + int oldmask; + enum sim_stop reason; + int sigrc; + + init_pointers (sd); + + control_c_sim_desc = sd; + prev = signal (SIGINT, control_c); + + if (step) + { + sim_engine_set_run_state (sd, sim_stopped, SIGTRAP); + } + else + { + sim_engine_set_run_state (sd, sim_running, 0); + } + + pc = h8_get_pc (sd); + + /* The PC should never be odd. */ + if (pc & 0x1) + { + sim_engine_set_run_state (sd, sim_stopped, SIGBUS); + return; + } + + /* Get Status Register (flags). */ + c = (h8_get_ccr (sd) >> 0) & 1; + v = (h8_get_ccr (sd) >> 1) & 1; + nz = !((h8_get_ccr (sd) >> 2) & 1); + n = (h8_get_ccr (sd) >> 3) & 1; + u = (h8_get_ccr (sd) >> 4) & 1; + h = (h8_get_ccr (sd) >> 5) & 1; + ui = ((h8_get_ccr (sd) >> 6) & 1); + intMaskBit = (h8_get_ccr (sd) >> 7) & 1; + + if (h8300smode) /* Get exr. */ + { + trace = (h8_get_exr (sd) >> 7) & 1; + intMask = h8_get_exr (sd) & 7; + } + + oldmask = h8_get_mask (sd); + if (!h8300hmode) + h8_set_mask (sd, 0xffff); + do + { + unsigned short cidx; + decoded_inst *code; + + top: + cidx = h8_get_cache_idx (sd, pc); + if (cidx == (unsigned short) -1 || + cidx >= sd->sim_cache_size) + goto illegal; + + code = sd->sim_cache + cidx; + +#if ADEBUG + if (debug) + { + printf ("%x %d %s\n", pc, code->opcode, + code->op ? code->op->name : "**"); + } + h8_increment_stats (sd, code->opcode); +#endif + + if (code->opcode) + { + cycles += code->cycles; + insts++; + } + + switch (code->opcode) + { + case 0: + /* + * This opcode is a fake for when we get to an + * instruction which hasnt been compiled + */ + compile (sd, pc); + goto top; + break; + + case O (O_MOVAB, SL): + case O (O_MOVAW, SL): + case O (O_MOVAL, SL): + /* 1) Evaluate 2nd argument (dst). + 2) Mask / zero extend according to whether 1st argument (src) + is INDEXB, INDEXW, or INDEXL. + 3) Left-shift the result by 0, 1 or 2, according to size of mova + (mova/b, mova/w, mova/l). + 4) Add literal value of 1st argument (src). + 5) Store result in 3rd argument (op3). + + */ + if (fetch (sd, &code->dst, &ea)) + goto end; + + switch (OP_KIND (code->src.type)) { + case OP_INDEXB: ea = ea & 0xff; break; + case OP_INDEXW: ea = ea & 0xffff; break; + case OP_INDEXL: break; + default: goto illegal; + } + + switch (code->opcode) { + case O (O_MOVAB, SL): break; + case O (O_MOVAW, SL): ea = ea << 1; break; + case O (O_MOVAL, SL): ea = ea << 2; break; + default: goto illegal; + } + + ea = ea + code->src.literal; + + if (store (sd, &code->op3, ea)) + goto end; + + goto next; + + case O (O_SUBX, SB): /* subx, extended sub */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = -(ea + C); + res = rd + ea; + goto alu8; + + case O (O_SUBX, SW): /* subx, extended sub */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = -(ea + C); + res = rd + ea; + goto alu16; + + case O (O_SUBX, SL): /* subx, extended sub */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = -(ea + C); + res = rd + ea; + goto alu32; + + case O (O_ADDX, SB): /* addx, extended add */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = ea + C; + res = rd + ea; + goto alu8; + + case O (O_ADDX, SW): /* addx, extended add */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = ea + C; + res = rd + ea; + goto alu16; + + case O (O_ADDX, SL): /* addx, extended add */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = ea + C; + res = rd + ea; + goto alu32; + + case O (O_SUB, SB): /* sub.b */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + ea = -ea; + res = rd + ea; + goto alu8; + + case O (O_SUB, SW): /* sub.w */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + ea = -ea; + res = rd + ea; + goto alu16; + + case O (O_SUB, SL): /* sub.l */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + ea = -ea; + res = rd + ea; + goto alu32; + + case O (O_NEG, SB): /* neg.b */ + /* Fetch ea. */ + if (fetch2 (sd, &code->src, &ea)) + goto end; + ea = -ea; + rd = 0; + res = rd + ea; + goto alu8; + + case O (O_NEG, SW): /* neg.w */ + /* Fetch ea. */ + if (fetch2 (sd, &code->src, &ea)) + goto end; + ea = -ea; + rd = 0; + res = rd + ea; + goto alu16; + + case O (O_NEG, SL): /* neg.l */ + /* Fetch ea. */ + if (fetch2 (sd, &code->src, &ea)) + goto end; + ea = -ea; + rd = 0; + res = rd + ea; + goto alu32; + + case O (O_ADD, SB): /* add.b */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + res = rd + ea; + goto alu8; + + case O (O_ADD, SW): /* add.w */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + res = rd + ea; + goto alu16; + + case O (O_ADD, SL): /* add.l */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + res = rd + ea; + goto alu32; + + case O (O_AND, SB): /* and.b */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd & ea; + goto log8; + + case O (O_AND, SW): /* and.w */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd & ea; + goto log16; + + case O (O_AND, SL): /* and.l */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd & ea; + goto log32; + + case O (O_OR, SB): /* or.b */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd | ea; + goto log8; + + case O (O_OR, SW): /* or.w */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd | ea; + goto log16; + + case O (O_OR, SL): /* or.l */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd | ea; + goto log32; + + case O (O_XOR, SB): /* xor.b */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd ^ ea; + goto log8; + + case O (O_XOR, SW): /* xor.w */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd ^ ea; + goto log16; + + case O (O_XOR, SL): /* xor.l */ + /* Fetch rd and ea. */ + if (fetch (sd, &code->src, &ea) || fetch2 (sd, &code->dst, &rd)) + goto end; + res = rd ^ ea; + goto log32; + + case O (O_MOV, SB): + if (fetch (sd, &code->src, &res)) + goto end; + if (store (sd, &code->dst, res)) + goto end; + goto just_flags_log8; + case O (O_MOV, SW): + if (fetch (sd, &code->src, &res)) + goto end; + if (store (sd, &code->dst, res)) + goto end; + goto just_flags_log16; + case O (O_MOV, SL): + if (fetch (sd, &code->src, &res)) + goto end; + if (store (sd, &code->dst, res)) + goto end; + goto just_flags_log32; + + case O (O_MOVMD, SB): /* movsd.b */ + ea = GET_W_REG (4); + if (ea == 0) + ea = 0x10000; + + while (ea--) + { + rd = GET_MEMORY_B (GET_L_REG (5)); + SET_MEMORY_B (GET_L_REG (6), rd); + SET_L_REG (5, GET_L_REG (5) + 1); + SET_L_REG (6, GET_L_REG (6) + 1); + SET_W_REG (4, ea); + } + goto next; + + case O (O_MOVMD, SW): /* movsd.b */ + ea = GET_W_REG (4); + if (ea == 0) + ea = 0x10000; + + while (ea--) + { + rd = GET_MEMORY_W (GET_L_REG (5)); + SET_MEMORY_W (GET_L_REG (6), rd); + SET_L_REG (5, GET_L_REG (5) + 2); + SET_L_REG (6, GET_L_REG (6) + 2); + SET_W_REG (4, ea); + } + goto next; + + case O (O_MOVMD, SL): /* movsd.b */ + ea = GET_W_REG (4); + if (ea == 0) + ea = 0x10000; + + while (ea--) + { + rd = GET_MEMORY_L (GET_L_REG (5)); + SET_MEMORY_L (GET_L_REG (6), rd); + SET_L_REG (5, GET_L_REG (5) + 4); + SET_L_REG (6, GET_L_REG (6) + 4); + SET_W_REG (4, ea); + } + goto next; + + case O (O_MOVSD, SB): /* movsd.b */ + /* This instruction implements strncpy, with a conditional branch. + r4 contains n, r5 contains src, and r6 contains dst. + The 16-bit displacement operand is added to the pc + if and only if the end of string is reached before + n bytes are transferred. */ + + ea = GET_L_REG (4) & 0xffff; + if (ea == 0) + ea = 0x10000; + + while (ea--) + { + rd = GET_MEMORY_B (GET_L_REG (5)); + SET_MEMORY_B (GET_L_REG (6), rd); + SET_L_REG (5, GET_L_REG (5) + 1); + SET_L_REG (6, GET_L_REG (6) + 1); + SET_W_REG (4, ea); + if (rd == 0) + goto condtrue; + } + goto next; + + case O (O_EEPMOV, SB): /* eepmov.b */ + case O (O_EEPMOV, SW): /* eepmov.w */ + if (h8300hmode || h8300smode) + { + register unsigned char *_src, *_dst; + unsigned int count = ((code->opcode == O (O_EEPMOV, SW)) + ? h8_get_reg (sd, R4_REGNUM) & 0xffff + : h8_get_reg (sd, R4_REGNUM) & 0xff); + + _src = (h8_get_reg (sd, R5_REGNUM) < memory_size + ? h8_get_memory_buf (sd) + h8_get_reg (sd, R5_REGNUM) + : h8_get_eightbit_buf (sd) + + (h8_get_reg (sd, R5_REGNUM) & 0xff)); + if ((_src + count) >= (h8_get_memory_buf (sd) + memory_size)) + { + if ((_src + count) >= (h8_get_eightbit_buf (sd) + 0x100)) + goto illegal; + } + _dst = (h8_get_reg (sd, R6_REGNUM) < memory_size + ? h8_get_memory_buf (sd) + h8_get_reg (sd, R6_REGNUM) + : h8_get_eightbit_buf (sd) + + (h8_get_reg (sd, R6_REGNUM) & 0xff)); + + if ((_dst + count) >= (h8_get_memory_buf (sd) + memory_size)) + { + if ((_dst + count) >= (h8_get_eightbit_buf (sd) + 0x100)) + goto illegal; + } + memcpy (_dst, _src, count); + + h8_set_reg (sd, R5_REGNUM, h8_get_reg (sd, R5_REGNUM) + count); + h8_set_reg (sd, R6_REGNUM, h8_get_reg (sd, R6_REGNUM) + count); + h8_set_reg (sd, R4_REGNUM, h8_get_reg (sd, R4_REGNUM) & + ((code->opcode == O (O_EEPMOV, SW)) + ? (~0xffff) : (~0xff))); + cycles += 2 * count; + goto next; + } + goto illegal; + + case O (O_ADDS, SL): /* adds (.l) */ + /* FIXME fetch. + * This insn only uses register operands, but still + * it would be cleaner to use fetch and store... */ + SET_L_REG (code->dst.reg, + GET_L_REG (code->dst.reg) + + code->src.literal); + + goto next; + + case O (O_SUBS, SL): /* subs (.l) */ + /* FIXME fetch. + * This insn only uses register operands, but still + * it would be cleaner to use fetch and store... */ + SET_L_REG (code->dst.reg, + GET_L_REG (code->dst.reg) + - code->src.literal); + goto next; + + case O (O_CMP, SB): /* cmp.b */ + if (fetch (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = -ea; + res = rd + ea; + goto just_flags_alu8; + + case O (O_CMP, SW): /* cmp.w */ + if (fetch (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = -ea; + res = rd + ea; + goto just_flags_alu16; + + case O (O_CMP, SL): /* cmp.l */ + if (fetch (sd, &code->dst, &rd)) + goto end; + if (fetch (sd, &code->src, &ea)) + goto end; + ea = -ea; + res = rd + ea; + goto just_flags_alu32; + + case O (O_DEC, SB): /* dec.b */ + /* FIXME fetch. + * This insn only uses register operands, but still + * it would be cleaner to use fetch and store... */ + rd = GET_B_REG (code->src.reg); + ea = -1; + res = rd + ea; + SET_B_REG (code->src.reg, res); + goto just_flags_inc8; + + case O (O_DEC, SW): /* dec.w */ + /* FIXME fetch. + * This insn only uses register operands, but still + * it would be cleaner to use fetch and store... */ + rd = GET_W_REG (code->dst.reg); + ea = -code->src.literal; + res = rd + ea; + SET_W_REG (code->dst.reg, res); + goto just_flags_inc16; + + case O (O_DEC, SL): /* dec.l */ + /* FIXME fetch. + * This insn only uses register operands, but still + * it would be cleaner to use fetch and store... */ + rd = GET_L_REG (code->dst.reg); + ea = -code->src.literal; + res = rd + ea; + SET_L_REG (code->dst.reg, res); + goto just_flags_inc32; + + case O (O_INC, SB): /* inc.b */ + /* FIXME fetch. + * This insn only uses register operands, but still + * it would be cleaner to use fetch and store... */ + rd = GET_B_REG (code->src.reg); + ea = 1; + res = rd + ea; + SET_B_REG (code->src.reg, res); + goto just_flags_inc8; + + case O (O_INC, SW): /* inc.w */ + /* FIXME fetch. + * This insn only uses register operands, but still + * it would be cleaner to use fetch and store... */ + rd = GET_W_REG (code->dst.reg); + ea = code->src.literal; + res = rd + ea; + SET_W_REG (code->dst.reg, res); + goto just_flags_inc16; + + case O (O_INC, SL): /* inc.l */ + /* FIXME fetch. + * This insn only uses register operands, but still + * it would be cleaner to use fetch and store... */ + rd = GET_L_REG (code->dst.reg); + ea = code->src.literal; + res = rd + ea; + SET_L_REG (code->dst.reg, res); + goto just_flags_inc32; + + case O (O_LDC, SB): /* ldc.b */ + if (fetch (sd, &code->src, &res)) + goto end; + goto setc; + + case O (O_LDC, SW): /* ldc.w */ + if (fetch (sd, &code->src, &res)) + goto end; + + /* Word operand, value from MSB, must be shifted. */ + res >>= 8; + goto setc; + + case O (O_LDC, SL): /* ldc.l */ + if (fetch (sd, &code->src, &res)) + goto end; + switch (code->dst.type) { + case X (OP_SBR, SL): + h8_set_sbr (sd, res); + break; + case X (OP_VBR, SL): + h8_set_vbr (sd, res); + break; + default: + goto illegal; + } + goto next; + + case O (O_STC, SW): /* stc.w */ + case O (O_STC, SB): /* stc.b */ + if (code->src.type == X (OP_CCR, SB)) + { + BUILDSR (sd); + res = h8_get_ccr (sd); + } + else if (code->src.type == X (OP_EXR, SB) && h8300smode) + { + if (h8300smode) + h8_set_exr (sd, (trace << 7) | intMask); + res = h8_get_exr (sd); + } + else + goto illegal; + + /* Word operand, value to MSB, must be shifted. */ + if (code->opcode == X (O_STC, SW)) + res <<= 8; + if (store (sd, &code->dst, res)) + goto end; + goto next; + case O (O_STC, SL): /* stc.l */ + switch (code->src.type) { + case X (OP_SBR, SL): + res = h8_get_sbr (sd); + break; + case X (OP_VBR, SL): + res = h8_get_vbr (sd); + break; + default: + goto illegal; + } + if (store (sd, &code->dst, res)) + goto end; + goto next; + + case O (O_ANDC, SB): /* andc.b */ + if (code->dst.type == X (OP_CCR, SB)) + { + BUILDSR (sd); + rd = h8_get_ccr (sd); + } + else if (code->dst.type == X (OP_EXR, SB) && h8300smode) + { + if (h8300smode) + h8_set_exr (sd, (trace << 7) | intMask); + res = h8_get_exr (sd); + } + else + goto illegal; + ea = code->src.literal; + res = rd & ea; + goto setc; + + case O (O_ORC, SB): /* orc.b */ + if (code->dst.type == X (OP_CCR, SB)) + { + BUILDSR (sd); + rd = h8_get_ccr (sd); + } + else if (code->dst.type == X (OP_EXR, SB) && h8300smode) + { + if (h8300smode) + h8_set_exr (sd, (trace << 7) | intMask); + rd = h8_get_exr (sd); + } + else + goto illegal; + ea = code->src.literal; + res = rd | ea; + goto setc; + + case O (O_XORC, SB): /* xorc.b */ + if (code->dst.type == X (OP_CCR, SB)) + { + BUILDSR (sd); + rd = h8_get_ccr (sd); + } + else if (code->dst.type == X (OP_EXR, SB) && h8300smode) + { + if (h8300smode) + h8_set_exr (sd, (trace << 7) | intMask); + rd = h8_get_exr (sd); + } + else + goto illegal; + ea = code->src.literal; + res = rd ^ ea; + goto setc; + + case O (O_BRAS, SB): /* bra/s */ + /* This is basically an ordinary branch, with a delay slot. */ + if (fetch (sd, &code->src, &res)) + goto end; + + if ((res & 1) == 0) + goto illegal; + + res -= 1; + + /* Execution continues at next instruction, but + delayed_branch is set up for next cycle. */ + h8_set_delayed_branch (sd, code->next_pc + res); + pc = code->next_pc; + goto end; + + case O (O_BRAB, SB): /* bra rd.b */ + case O (O_BRAW, SW): /* bra rd.w */ + case O (O_BRAL, SL): /* bra erd.l */ + if (fetch (sd, &code->src, &rd)) + goto end; + switch (OP_SIZE (code->opcode)) { + case SB: rd &= 0xff; break; + case SW: rd &= 0xffff; break; + case SL: rd &= 0xffffffff; break; + } + pc = code->next_pc + rd; + goto end; + + case O (O_BRABC, SB): /* bra/bc, branch if bit clear */ + case O (O_BRABS, SB): /* bra/bs, branch if bit set */ + case O (O_BSRBC, SB): /* bsr/bc, call if bit clear */ + case O (O_BSRBS, SB): /* bsr/bs, call if bit set */ + if (fetch (sd, &code->dst, &rd) || + fetch (sd, &code->src, &bit)) + goto end; + + if (code->opcode == O (O_BRABC, SB) || /* branch if clear */ + code->opcode == O (O_BSRBC, SB)) /* call if clear */ + { + if ((rd & (1 << bit))) /* no branch */ + goto next; + } + else /* branch/call if set */ + { + if (!(rd & (1 << bit))) /* no branch */ + goto next; + } + + if (fetch (sd, &code->op3, &res)) /* branch */ + goto end; + pc = code->next_pc + res; + + if (code->opcode == O (O_BRABC, SB) || + code->opcode == O (O_BRABS, SB)) /* branch */ + goto end; + else /* call */ + goto call; + + case O (O_BRA, SN): + case O (O_BRA, SL): + case O (O_BRA, SW): + case O (O_BRA, SB): /* bra, branch always */ + if (1) + goto condtrue; + goto next; + + case O (O_BRN, SB): /* brn, ;-/ branch never? */ + if (0) + goto condtrue; + goto next; + + case O (O_BHI, SB): /* bhi */ + if ((C || Z) == 0) + goto condtrue; + goto next; + + + case O (O_BLS, SB): /* bls */ + if ((C || Z)) + goto condtrue; + goto next; + + case O (O_BCS, SB): /* bcs, branch if carry set */ + if ((C == 1)) + goto condtrue; + goto next; + + case O (O_BCC, SB): /* bcc, branch if carry clear */ + if ((C == 0)) + goto condtrue; + goto next; + + case O (O_BEQ, SB): /* beq, branch if zero set */ + if (Z) + goto condtrue; + goto next; + case O (O_BGT, SB): /* bgt */ + if (((Z || (N ^ V)) == 0)) + goto condtrue; + goto next; + + case O (O_BLE, SB): /* ble */ + if (((Z || (N ^ V)) == 1)) + goto condtrue; + goto next; + + case O (O_BGE, SB): /* bge */ + if ((N ^ V) == 0) + goto condtrue; + goto next; + case O (O_BLT, SB): /* blt */ + if ((N ^ V)) + goto condtrue; + goto next; + case O (O_BMI, SB): /* bmi */ + if ((N)) + goto condtrue; + goto next; + case O (O_BNE, SB): /* bne, branch if zero clear */ + if ((Z == 0)) + goto condtrue; + goto next; + + case O (O_BPL, SB): /* bpl */ + if (N == 0) + goto condtrue; + goto next; + case O (O_BVC, SB): /* bvc */ + if ((V == 0)) + goto condtrue; + goto next; + case O (O_BVS, SB): /* bvs */ + if ((V == 1)) + goto condtrue; + goto next; + + /* Trap for Command Line setup. */ + case O (O_SYS_CMDLINE, SB): + { + int i = 0; /* Loop counter. */ + int j = 0; /* Loop counter. */ + int ind_arg_len = 0; /* Length of each argument. */ + int no_of_args = 0; /* The no. or cmdline args. */ + int current_location = 0; /* Location of string. */ + int old_sp = 0; /* The Initial Stack Pointer. */ + int no_of_slots = 0; /* No. of slots required on the stack + for storing cmdline args. */ + int sp_move = 0; /* No. of locations by which the stack needs + to grow. */ + int new_sp = 0; /* The final stack pointer location passed + back. */ + int *argv_ptrs; /* Pointers of argv strings to be stored. */ + int argv_ptrs_location = 0; /* Location of pointers to cmdline + args on the stack. */ + int char_ptr_size = 0; /* Size of a character pointer on + target machine. */ + int addr_cmdline = 0; /* Memory location where cmdline has + to be stored. */ + int size_cmdline = 0; /* Size of cmdline. */ + + /* Set the address of 256 free locations where command line is + stored. */ + addr_cmdline = cmdline_location(); + h8_set_reg (sd, 0, addr_cmdline); + + /* Counting the no. of commandline arguments. */ + for (i = 0; h8_get_cmdline_arg (sd, i) != NULL; i++) + continue; + + /* No. of arguments in the command line. */ + no_of_args = i; + + /* Current location is just a temporary variable,which we are + setting to the point to the start of our commandline string. */ + current_location = addr_cmdline; + + /* Allocating space for storing pointers of the command line + arguments. */ + argv_ptrs = (int *) malloc (sizeof (int) * no_of_args); + + /* Setting char_ptr_size to the sizeof (char *) on the different + architectures. */ + if (h8300hmode || h8300smode) + { + char_ptr_size = 4; + } + else + { + char_ptr_size = 2; + } + + for (i = 0; i < no_of_args; i++) + { + ind_arg_len = 0; + + /* The size of the commandline argument. */ + ind_arg_len = strlen (h8_get_cmdline_arg (sd, i) + 1); + + /* The total size of the command line string. */ + size_cmdline += ind_arg_len; + + /* As we have only 256 bytes, we need to provide a graceful + exit. Anyways, a program using command line arguments + where we cannot store all the command line arguments + given may behave unpredictably. */ + if (size_cmdline >= 256) + { + h8_set_reg (sd, 0, 0); + goto next; + } + else + { + /* current_location points to the memory where the next + commandline argument is stored. */ + argv_ptrs[i] = current_location; + for (j = 0; j < ind_arg_len; j++) + { + SET_MEMORY_B ((current_location + + (sizeof (char) * j)), + *(h8_get_cmdline_arg (sd, i) + + sizeof (char) * j)); + } + + /* Setting current_location to the starting of next + argument. */ + current_location += ind_arg_len; + } + } + + /* This is the original position of the stack pointer. */ + old_sp = h8_get_reg (sd, SP_REGNUM); + + /* We need space from the stack to store the pointers to argvs. */ + /* As we will infringe on the stack, we need to shift the stack + pointer so that the data is not overwritten. We calculate how + much space is required. */ + sp_move = (no_of_args) * (char_ptr_size); + + /* The final position of stack pointer, we have thus taken some + space from the stack. */ + new_sp = old_sp - sp_move; + + /* Temporary variable holding value where the argv pointers need + to be stored. */ + argv_ptrs_location = new_sp; + + /* The argv pointers are stored at sequential locations. As per + the H8300 ABI. */ + for (i = 0; i < no_of_args; i++) + { + /* Saving the argv pointer. */ + if (h8300hmode || h8300smode) + { + SET_MEMORY_L (argv_ptrs_location, argv_ptrs[i]); + } + else + { + SET_MEMORY_W (argv_ptrs_location, argv_ptrs[i]); + } + + /* The next location where the pointer to the next argv + string has to be stored. */ + argv_ptrs_location += char_ptr_size; + } + + /* Required by POSIX, Setting 0x0 at the end of the list of argv + pointers. */ + if (h8300hmode || h8300smode) + { + SET_MEMORY_L (old_sp, 0x0); + } + else + { + SET_MEMORY_W (old_sp, 0x0); + } + + /* Freeing allocated memory. */ + free (argv_ptrs); + for (i = 0; i <= no_of_args; i++) + { + free (h8_get_cmdline_arg (sd, i)); + } + free (h8_get_command_line (sd)); + + /* The no. of argv arguments are returned in Reg 0. */ + h8_set_reg (sd, 0, no_of_args); + /* The Pointer to argv in Register 1. */ + h8_set_reg (sd, 1, new_sp); + /* Setting the stack pointer to the new value. */ + h8_set_reg (sd, SP_REGNUM, new_sp); + } + goto next; + + /* System call processing starts. */ + case O (O_SYS_OPEN, SB): + { + int len = 0; /* Length of filename. */ + char *filename; /* Filename would go here. */ + char temp_char; /* Temporary character */ + int mode = 0; /* Mode bits for the file. */ + int open_return; /* Return value of open, file descriptor. */ + int i; /* Loop counter */ + int filename_ptr; /* Pointer to filename in cpu memory. */ + + /* Setting filename_ptr to first argument of open, */ + /* and trying to get mode. */ + if (h8300sxmode || h8300hmode || h8300smode) + { + filename_ptr = GET_L_REG (0); + mode = GET_MEMORY_L (h8_get_reg (sd, SP_REGNUM) + 4); + } + else + { + filename_ptr = GET_W_REG (0); + mode = GET_MEMORY_W (h8_get_reg (sd, SP_REGNUM) + 2); + } + + /* Trying to find the length of the filename. */ + temp_char = GET_MEMORY_B (h8_get_reg (sd, 0)); + + len = 1; + while (temp_char != '\0') + { + temp_char = GET_MEMORY_B (filename_ptr + len); + len++; + } + + /* Allocating space for the filename. */ + filename = (char *) malloc (sizeof (char) * len); + + /* String copying the filename from memory. */ + for (i = 0; i < len; i++) + { + temp_char = GET_MEMORY_B (filename_ptr + i); + filename[i] = temp_char; + } + + /* Callback to open and return the file descriptor. */ + open_return = sim_callback->open (sim_callback, filename, mode); + + /* Return value in register 0. */ + h8_set_reg (sd, 0, open_return); + + /* Freeing memory used for filename. */ + free (filename); + } + goto next; + + case O (O_SYS_READ, SB): + { + char *char_ptr; /* Where characters read would be stored. */ + int fd; /* File descriptor */ + int buf_size; /* BUF_SIZE parameter in read. */ + int i = 0; /* Temporary Loop counter */ + int read_return = 0; /* Return value from callback to + read. */ + + fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); + buf_size = h8300hmode ? GET_L_REG (2) : GET_W_REG (2); + + char_ptr = (char *) malloc (sizeof (char) * buf_size); + + /* Callback to read and return the no. of characters read. */ + read_return = + sim_callback->read (sim_callback, fd, char_ptr, buf_size); + + /* The characters read are stored in cpu memory. */ + for (i = 0; i < buf_size; i++) + { + SET_MEMORY_B ((h8_get_reg (sd, 1) + (sizeof (char) * i)), + *(char_ptr + (sizeof (char) * i))); + } + + /* Return value in Register 0. */ + h8_set_reg (sd, 0, read_return); + + /* Freeing memory used as buffer. */ + free (char_ptr); + } + goto next; + + case O (O_SYS_WRITE, SB): + { + int fd; /* File descriptor */ + char temp_char; /* Temporary character */ + int len; /* Length of write, Parameter II to write. */ + int char_ptr; /* Character Pointer, Parameter I of write. */ + char *ptr; /* Where characters to be written are stored. + */ + int write_return; /* Return value from callback to write. */ + int i = 0; /* Loop counter */ + + fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); + char_ptr = h8300hmode ? GET_L_REG (1) : GET_W_REG (1); + len = h8300hmode ? GET_L_REG (2) : GET_W_REG (2); + + /* Allocating space for the characters to be written. */ + ptr = (char *) malloc (sizeof (char) * len); + + /* Fetching the characters from cpu memory. */ + for (i = 0; i < len; i++) + { + temp_char = GET_MEMORY_B (char_ptr + i); + ptr[i] = temp_char; + } + + /* Callback write and return the no. of characters written. */ + write_return = sim_callback->write (sim_callback, fd, ptr, len); + + /* Return value in Register 0. */ + h8_set_reg (sd, 0, write_return); + + /* Freeing memory used as buffer. */ + free (ptr); + } + goto next; + + case O (O_SYS_LSEEK, SB): + { + int fd; /* File descriptor */ + int offset; /* Offset */ + int origin; /* Origin */ + int lseek_return; /* Return value from callback to lseek. */ + + fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); + offset = h8300hmode ? GET_L_REG (1) : GET_W_REG (1); + origin = h8300hmode ? GET_L_REG (2) : GET_W_REG (2); - if (code->opcode) - { - cycles += code->cycles; - insts++; - } + /* Callback lseek and return offset. */ + lseek_return = + sim_callback->lseek (sim_callback, fd, offset, origin); - switch (code->opcode) - { - case 0: - /* - * This opcode is a fake for when we get to an - * instruction which hasnt been compiled - */ - compile (pc); - goto top; - break; + /* Return value in register 0. */ + h8_set_reg (sd, 0, lseek_return); + } + goto next; + case O (O_SYS_CLOSE, SB): + { + int fd; /* File descriptor */ + int close_return; /* Return value from callback to close. */ - case O (O_SUBX, SB): - rd = fetch (&code->dst); - ea = fetch (&code->src); - ea = -(ea + C); - res = rd + ea; - goto alu8; + fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); - case O (O_ADDX, SB): - rd = fetch (&code->dst); - ea = fetch (&code->src); - ea = C + ea; - res = rd + ea; - goto alu8; + /* Callback close and return. */ + close_return = sim_callback->close (sim_callback, fd); -#define EA ea = fetch (&code->src); -#define RD_EA ea = fetch (&code->src); rd = fetch (&code->dst); + /* Return value in register 0. */ + h8_set_reg (sd, 0, close_return); + } + goto next; - ALUOP (1, O_SUB, RD_EA; - ea = -ea; - res = rd + ea); - ALUOP (1, O_NEG, EA; - ea = -ea; - rd = 0; - res = rd + ea); + case O (O_SYS_FSTAT, SB): + { + int fd; /* File descriptor */ + struct stat stat_rec; /* Stat record */ + int fstat_return; /* Return value from callback to stat. */ + int stat_ptr; /* Pointer to stat record. */ + char *temp_stat_ptr; /* Temporary stat_rec pointer. */ - case O (O_ADD, SB): - rd = GET_B_REG (code->dst.reg); - ea = fetch (&code->src); - res = rd + ea; - goto alu8; - case O (O_ADD, SW): - rd = GET_W_REG (code->dst.reg); - ea = fetch (&code->src); - res = rd + ea; - goto alu16; - case O (O_ADD, SL): - rd = GET_L_REG (code->dst.reg); - ea = fetch (&code->src); - res = rd + ea; - goto alu32; + fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); + /* Setting stat_ptr to second argument of stat. */ + stat_ptr = h8300hmode ? GET_L_REG (1) : GET_W_REG (1); - LOGOP (O_AND, RD_EA; - res = rd & ea); + /* Callback stat and return. */ + fstat_return = sim_callback->fstat (sim_callback, fd, &stat_rec); - LOGOP (O_OR, RD_EA; - res = rd | ea); + /* Have stat_ptr point to starting of stat_rec. */ + temp_stat_ptr = (char *) (&stat_rec); - LOGOP (O_XOR, RD_EA; - res = rd ^ ea); + /* Setting up the stat structure returned. */ + SET_MEMORY_W (stat_ptr, stat_rec.st_dev); + stat_ptr += 2; + SET_MEMORY_W (stat_ptr, stat_rec.st_ino); + stat_ptr += 2; + SET_MEMORY_L (stat_ptr, stat_rec.st_mode); + stat_ptr += 4; + SET_MEMORY_W (stat_ptr, stat_rec.st_nlink); + stat_ptr += 2; + SET_MEMORY_W (stat_ptr, stat_rec.st_uid); + stat_ptr += 2; + SET_MEMORY_W (stat_ptr, stat_rec.st_gid); + stat_ptr += 2; + SET_MEMORY_W (stat_ptr, stat_rec.st_rdev); + stat_ptr += 2; + SET_MEMORY_L (stat_ptr, stat_rec.st_size); + stat_ptr += 4; + SET_MEMORY_L (stat_ptr, stat_rec.st_atime); + stat_ptr += 8; + SET_MEMORY_L (stat_ptr, stat_rec.st_mtime); + stat_ptr += 8; + SET_MEMORY_L (stat_ptr, stat_rec.st_ctime); + /* Return value in register 0. */ + h8_set_reg (sd, 0, fstat_return); + } + goto next; - case O (O_MOV_TO_MEM, SB): - res = GET_B_REG (code->src.reg); - goto log8; - case O (O_MOV_TO_MEM, SW): - res = GET_W_REG (code->src.reg); - goto log16; - case O (O_MOV_TO_MEM, SL): - res = GET_L_REG (code->src.reg); - goto log32; + case O (O_SYS_STAT, SB): + { + int len = 0; /* Length of filename. */ + char *filename; /* Filename would go here. */ + char temp_char; /* Temporary character */ + int filename_ptr; /* Pointer to filename in cpu memory. */ + struct stat stat_rec; /* Stat record */ + int stat_return; /* Return value from callback to stat */ + int stat_ptr; /* Pointer to stat record. */ + char *temp_stat_ptr; /* Temporary stat_rec pointer. */ + int i = 0; /* Loop Counter */ + /* Setting filename_ptr to first argument of open. */ + filename_ptr = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); - case O (O_MOV_TO_REG, SB): - res = fetch (&code->src); - SET_B_REG (code->dst.reg, res); - goto just_flags_log8; - case O (O_MOV_TO_REG, SW): - res = fetch (&code->src); - SET_W_REG (code->dst.reg, res); - goto just_flags_log16; - case O (O_MOV_TO_REG, SL): - res = fetch (&code->src); - SET_L_REG (code->dst.reg, res); - goto just_flags_log32; + /* Trying to find the length of the filename. */ + temp_char = GET_MEMORY_B (h8_get_reg (sd, 0)); - case O (O_EEPMOV, SB): - case O (O_EEPMOV, SW): - if (h8300hmode || h8300smode) - { - register unsigned char *_src, *_dst; - unsigned int count = ((code->opcode == O (O_EEPMOV, SW)) - ? cpu.regs[R4_REGNUM] & 0xffff - : cpu.regs[R4_REGNUM] & 0xff); + len = 1; + while (temp_char != '\0') + { + temp_char = GET_MEMORY_B (filename_ptr + len); + len++; + } - _src = (cpu.regs[R5_REGNUM] < memory_size - ? cpu.memory + cpu.regs[R5_REGNUM] - : cpu.eightbit + (cpu.regs[R5_REGNUM] & 0xff)); - if ((_src + count) >= (cpu.memory + memory_size)) - { - if ((_src + count) >= (cpu.eightbit + 0x100)) - goto illegal; - } - _dst = (cpu.regs[R6_REGNUM] < memory_size - ? cpu.memory + cpu.regs[R6_REGNUM] - : cpu.eightbit + (cpu.regs[R6_REGNUM] & 0xff)); - if ((_dst + count) >= (cpu.memory + memory_size)) - { - if ((_dst + count) >= (cpu.eightbit + 0x100)) - goto illegal; - } - memcpy (_dst, _src, count); + /* Allocating space for the filename. */ + filename = (char *) malloc (sizeof (char) * len); - cpu.regs[R5_REGNUM] += count; - cpu.regs[R6_REGNUM] += count; - cpu.regs[R4_REGNUM] &= ((code->opcode == O (O_EEPMOV, SW)) - ? (~0xffff) : (~0xff)); - cycles += 2 * count; - goto next; - } - goto illegal; + /* String copying the filename from memory. */ + for (i = 0; i < len; i++) + { + temp_char = GET_MEMORY_B (filename_ptr + i); + filename[i] = temp_char; + } - case O (O_ADDS, SL): - SET_L_REG (code->dst.reg, - GET_L_REG (code->dst.reg) - + code->src.literal); + /* Setting stat_ptr to second argument of stat. */ + /* stat_ptr = h8_get_reg (sd, 1); */ + stat_ptr = h8300hmode ? GET_L_REG (1) : GET_W_REG (1); - goto next; + /* Callback stat and return. */ + stat_return = + sim_callback->stat (sim_callback, filename, &stat_rec); - case O (O_SUBS, SL): - SET_L_REG (code->dst.reg, - GET_L_REG (code->dst.reg) - - code->src.literal); + /* Have stat_ptr point to starting of stat_rec. */ + temp_stat_ptr = (char *) (&stat_rec); + + /* Freeing memory used for filename. */ + free (filename); + + /* Setting up the stat structure returned. */ + SET_MEMORY_W (stat_ptr, stat_rec.st_dev); + stat_ptr += 2; + SET_MEMORY_W (stat_ptr, stat_rec.st_ino); + stat_ptr += 2; + SET_MEMORY_L (stat_ptr, stat_rec.st_mode); + stat_ptr += 4; + SET_MEMORY_W (stat_ptr, stat_rec.st_nlink); + stat_ptr += 2; + SET_MEMORY_W (stat_ptr, stat_rec.st_uid); + stat_ptr += 2; + SET_MEMORY_W (stat_ptr, stat_rec.st_gid); + stat_ptr += 2; + SET_MEMORY_W (stat_ptr, stat_rec.st_rdev); + stat_ptr += 2; + SET_MEMORY_L (stat_ptr, stat_rec.st_size); + stat_ptr += 4; + SET_MEMORY_L (stat_ptr, stat_rec.st_atime); + stat_ptr += 8; + SET_MEMORY_L (stat_ptr, stat_rec.st_mtime); + stat_ptr += 8; + SET_MEMORY_L (stat_ptr, stat_rec.st_ctime); + + /* Return value in register 0. */ + h8_set_reg (sd, 0, stat_return); + } goto next; + /* End of system call processing. */ - case O (O_CMP, SB): - rd = fetch (&code->dst); - ea = fetch (&code->src); - ea = -ea; - res = rd + ea; - goto just_flags_alu8; - - case O (O_CMP, SW): - rd = fetch (&code->dst); - ea = fetch (&code->src); - ea = -ea; - res = rd + ea; - goto just_flags_alu16; + case O (O_NOT, SB): /* not.b */ + if (fetch2 (sd, &code->src, &rd)) + goto end; + rd = ~rd; + v = 0; + goto shift8; - case O (O_CMP, SL): - rd = fetch (&code->dst); - ea = fetch (&code->src); - ea = -ea; - res = rd + ea; - goto just_flags_alu32; + case O (O_NOT, SW): /* not.w */ + if (fetch2 (sd, &code->src, &rd)) + goto end; + rd = ~rd; + v = 0; + goto shift16; + case O (O_NOT, SL): /* not.l */ + if (fetch2 (sd, &code->src, &rd)) + goto end; + rd = ~rd; + v = 0; + goto shift32; - case O (O_DEC, SB): - rd = GET_B_REG (code->src.reg); - ea = -1; - res = rd + ea; - SET_B_REG (code->src.reg, res); - goto just_flags_inc8; + case O (O_SHLL, SB): /* shll.b */ + case O (O_SHLR, SB): /* shlr.b */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; - case O (O_DEC, SW): - rd = GET_W_REG (code->dst.reg); - ea = -code->src.literal; - res = rd + ea; - SET_W_REG (code->dst.reg, res); - goto just_flags_inc16; + if (code->src.type == X (OP_IMM, SB)) + fetch (sd, &code->src, &ea); + else + ea = 1; - case O (O_DEC, SL): - rd = GET_L_REG (code->dst.reg); - ea = -code->src.literal; - res = rd + ea; - SET_L_REG (code->dst.reg, res); - goto just_flags_inc32; + if (code->opcode == O (O_SHLL, SB)) + { + v = (ea > 8); + c = rd & (0x80 >> (ea - 1)); + rd <<= ea; + } + else + { + v = 0; + c = rd & (1 << (ea - 1)); + rd = (unsigned char) rd >> ea; + } + goto shift8; + case O (O_SHLL, SW): /* shll.w */ + case O (O_SHLR, SW): /* shlr.w */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; - case O (O_INC, SB): - rd = GET_B_REG (code->src.reg); - ea = 1; - res = rd + ea; - SET_B_REG (code->src.reg, res); - goto just_flags_inc8; + if (code->src.type == X (OP_IMM, SW)) + fetch (sd, &code->src, &ea); + else + ea = 1; - case O (O_INC, SW): - rd = GET_W_REG (code->dst.reg); - ea = code->src.literal; - res = rd + ea; - SET_W_REG (code->dst.reg, res); - goto just_flags_inc16; + if (code->opcode == O (O_SHLL, SW)) + { + v = (ea > 16); + c = rd & (0x8000 >> (ea - 1)); + rd <<= ea; + } + else + { + v = 0; + c = rd & (1 << (ea - 1)); + rd = (unsigned short) rd >> ea; + } + goto shift16; - case O (O_INC, SL): - rd = GET_L_REG (code->dst.reg); - ea = code->src.literal; - res = rd + ea; - SET_L_REG (code->dst.reg, res); - goto just_flags_inc32; + case O (O_SHLL, SL): /* shll.l */ + case O (O_SHLR, SL): /* shlr.l */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; -#define GET_CCR(x) BUILDSR();x = cpu.ccr -#define GET_EXR(x) BUILDEXR ();x = cpu.exr + if (code->src.type == X (OP_IMM, SL)) + fetch (sd, &code->src, &ea); + else + ea = 1; - case O (O_LDC, SB): - case O (O_LDC, SW): - res = fetch (&code->src); - goto setc; - case O (O_STC, SB): - case O (O_STC, SW): - if (code->src.type == OP_CCR) + if (code->opcode == O (O_SHLL, SL)) { - GET_CCR (res); + v = (ea > 32); + c = rd & (0x80000000 >> (ea - 1)); + rd <<= ea; } - else if (code->src.type == OP_EXR && h8300smode) + else { - GET_EXR (res); + v = 0; + c = rd & (1 << (ea - 1)); + rd = (unsigned int) rd >> ea; } + goto shift32; + + case O (O_SHAL, SB): + case O (O_SHAR, SB): + if (fetch2 (sd, &code->dst, &rd)) + goto end; + + if (code->src.type == X (OP_IMM, SB)) + fetch (sd, &code->src, &ea); else - goto illegal; - store (&code->dst, res); - goto next; + ea = 1; - case O (O_ANDC, SB): - if (code->dst.type == OP_CCR) + if (code->opcode == O (O_SHAL, SB)) { - GET_CCR (rd); + c = rd & (0x80 >> (ea - 1)); + res = rd >> (7 - ea); + v = ((res & 1) && !(res & 2)) + || (!(res & 1) && (res & 2)); + rd <<= ea; } - else if (code->dst.type == OP_EXR && h8300smode) + else { - GET_EXR (rd); + c = rd & (1 << (ea - 1)); + v = 0; + rd = ((signed char) rd) >> ea; } + goto shift8; + + case O (O_SHAL, SW): + case O (O_SHAR, SW): + if (fetch2 (sd, &code->dst, &rd)) + goto end; + + if (code->src.type == X (OP_IMM, SW)) + fetch (sd, &code->src, &ea); else - goto illegal; - ea = code->src.literal; - res = rd & ea; - goto setc; + ea = 1; - case O (O_ORC, SB): - if (code->dst.type == OP_CCR) + if (code->opcode == O (O_SHAL, SW)) { - GET_CCR (rd); + c = rd & (0x8000 >> (ea - 1)); + res = rd >> (15 - ea); + v = ((res & 1) && !(res & 2)) + || (!(res & 1) && (res & 2)); + rd <<= ea; } - else if (code->dst.type == OP_EXR && h8300smode) + else { - GET_EXR (rd); + c = rd & (1 << (ea - 1)); + v = 0; + rd = ((signed short) rd) >> ea; } - else - goto illegal; - ea = code->src.literal; - res = rd | ea; - goto setc; + goto shift16; + + case O (O_SHAL, SL): + case O (O_SHAR, SL): + if (fetch2 (sd, &code->dst, &rd)) + goto end; + + if (code->src.type == X (OP_IMM, SL)) + fetch (sd, &code->src, &ea); + else + ea = 1; - case O (O_XORC, SB): - if (code->dst.type == OP_CCR) + if (code->opcode == O (O_SHAL, SL)) { - GET_CCR (rd); + c = rd & (0x80000000 >> (ea - 1)); + res = rd >> (31 - ea); + v = ((res & 1) && !(res & 2)) + || (!(res & 1) && (res & 2)); + rd <<= ea; } - else if (code->dst.type == OP_EXR && h8300smode) + else { - GET_EXR (rd); + c = rd & (1 << (ea - 1)); + v = 0; + rd = ((signed int) rd) >> ea; } - else - goto illegal; - ea = code->src.literal; - res = rd ^ ea; - goto setc; - + goto shift32; - case O (O_BRA, SB): - if (1) - goto condtrue; - goto next; + case O (O_ROTL, SB): + case O (O_ROTR, SB): + if (fetch2 (sd, &code->dst, &rd)) + goto end; - case O (O_BRN, SB): - if (0) - goto condtrue; - goto next; + if (code->src.type == X (OP_IMM, SB)) + fetch (sd, &code->src, &ea); + else + ea = 1; - case O (O_BHI, SB): - if ((C || Z) == 0) - goto condtrue; - goto next; + while (ea--) + if (code->opcode == O (O_ROTL, SB)) + { + c = rd & 0x80; + rd <<= 1; + if (c) + rd |= 1; + } + else + { + c = rd & 1; + rd = ((unsigned char) rd) >> 1; + if (c) + rd |= 0x80; + } + v = 0; + goto shift8; - case O (O_BLS, SB): - if ((C || Z)) - goto condtrue; - goto next; + case O (O_ROTL, SW): + case O (O_ROTR, SW): + if (fetch2 (sd, &code->dst, &rd)) + goto end; - case O (O_BCS, SB): - if ((C == 1)) - goto condtrue; - goto next; + if (code->src.type == X (OP_IMM, SW)) + fetch (sd, &code->src, &ea); + else + ea = 1; - case O (O_BCC, SB): - if ((C == 0)) - goto condtrue; - goto next; + while (ea--) + if (code->opcode == O (O_ROTL, SW)) + { + c = rd & 0x8000; + rd <<= 1; + if (c) + rd |= 1; + } + else + { + c = rd & 1; + rd = ((unsigned short) rd) >> 1; + if (c) + rd |= 0x8000; + } - case O (O_BEQ, SB): - if (Z) - goto condtrue; - goto next; - case O (O_BGT, SB): - if (((Z || (N ^ V)) == 0)) - goto condtrue; - goto next; + v = 0; + goto shift16; + case O (O_ROTL, SL): + case O (O_ROTR, SL): + if (fetch2 (sd, &code->dst, &rd)) + goto end; - case O (O_BLE, SB): - if (((Z || (N ^ V)) == 1)) - goto condtrue; - goto next; + if (code->src.type == X (OP_IMM, SL)) + fetch (sd, &code->src, &ea); + else + ea = 1; - case O (O_BGE, SB): - if ((N ^ V) == 0) - goto condtrue; - goto next; - case O (O_BLT, SB): - if ((N ^ V)) - goto condtrue; - goto next; - case O (O_BMI, SB): - if ((N)) - goto condtrue; - goto next; - case O (O_BNE, SB): - if ((Z == 0)) - goto condtrue; - goto next; + while (ea--) + if (code->opcode == O (O_ROTL, SL)) + { + c = rd & 0x80000000; + rd <<= 1; + if (c) + rd |= 1; + } + else + { + c = rd & 1; + rd = ((unsigned int) rd) >> 1; + if (c) + rd |= 0x80000000; + } - case O (O_BPL, SB): - if (N == 0) - goto condtrue; - goto next; - case O (O_BVC, SB): - if ((V == 0)) - goto condtrue; - goto next; - case O (O_BVS, SB): - if ((V == 1)) - goto condtrue; - goto next; + v = 0; + goto shift32; - /* Trap for Command Line setup. */ - case O (O_SYS_CMDLINE, SB): - { - int i = 0; /* Loop counter. */ - int j = 0; /* Loop counter. */ - int ind_arg_len = 0; /* Length of each argument. */ - int no_of_args = 0; /* The no. or cmdline args. */ - int current_location = 0; /* Location of string. */ - int old_sp = 0; /* The Initial Stack Pointer. */ - int no_of_slots = 0; /* No. of slots required on the stack - for storing cmdline args. */ - int sp_move = 0; /* No. of locations by which the stack needs - to grow. */ - int new_sp = 0; /* The final stack pointer location passed - back. */ - int *argv_ptrs; /* Pointers of argv strings to be stored. */ - int argv_ptrs_location = 0; /* Location of pointers to cmdline - args on the stack. */ - int char_ptr_size = 0; /* Size of a character pointer on - target machine. */ - int addr_cmdline = 0; /* Memory location where cmdline has - to be stored. */ - int size_cmdline = 0; /* Size of cmdline. */ + case O (O_ROTXL, SB): + case O (O_ROTXR, SB): + if (fetch2 (sd, &code->dst, &rd)) + goto end; - /* Set the address of 256 free locations where command line is - stored. */ - addr_cmdline = cmdline_location(); - cpu.regs[0] = addr_cmdline; + if (code->src.type == X (OP_IMM, SB)) + fetch (sd, &code->src, &ea); + else + ea = 1; - /* Counting the no. of commandline arguments. */ - for (i = 0; ptr_command_line[i] != NULL; i++) - continue; + while (ea--) + if (code->opcode == O (O_ROTXL, SB)) + { + res = rd & 0x80; + rd <<= 1; + if (C) + rd |= 1; + c = res; + } + else + { + res = rd & 1; + rd = ((unsigned char) rd) >> 1; + if (C) + rd |= 0x80; + c = res; + } - /* No. of arguments in the command line. */ - no_of_args = i; + v = 0; + goto shift8; - /* Current location is just a temporary variable,which we are - setting to the point to the start of our commandline string. */ - current_location = addr_cmdline; + case O (O_ROTXL, SW): + case O (O_ROTXR, SW): + if (fetch2 (sd, &code->dst, &rd)) + goto end; - /* Allocating space for storing pointers of the command line - arguments. */ - argv_ptrs = (int *) malloc (sizeof (int) * no_of_args); + if (code->src.type == X (OP_IMM, SW)) + fetch (sd, &code->src, &ea); + else + ea = 1; - /* Setting char_ptr_size to the sizeof (char *) on the different - architectures. */ - if (h8300hmode || h8300smode) + while (ea--) + if (code->opcode == O (O_ROTXL, SW)) { - char_ptr_size = 4; + res = rd & 0x8000; + rd <<= 1; + if (C) + rd |= 1; + c = res; } else { - char_ptr_size = 2; + res = rd & 1; + rd = ((unsigned short) rd) >> 1; + if (C) + rd |= 0x8000; + c = res; } - for (i = 0; i < no_of_args; i++) - { - ind_arg_len = 0; - - /* The size of the commandline argument. */ - ind_arg_len = (strlen (ptr_command_line[i]) + 1); + v = 0; + goto shift16; - /* The total size of the command line string. */ - size_cmdline += ind_arg_len; + case O (O_ROTXL, SL): + case O (O_ROTXR, SL): + if (fetch2 (sd, &code->dst, &rd)) + goto end; - /* As we have only 256 bytes, we need to provide a graceful - exit. Anyways, a program using command line arguments - where we cannot store all the command line arguments - given may behave unpredictably. */ - if (size_cmdline >= 256) - { - cpu.regs[0] = 0; - goto next; - } - else - { - /* current_location points to the memory where the next - commandline argument is stored. */ - argv_ptrs[i] = current_location; - for (j = 0; j < ind_arg_len; j++) - { - SET_MEMORY_B ((current_location + - (sizeof (char) * j)), - *(ptr_command_line[i] + - sizeof (char) * j)); - } + if (code->src.type == X (OP_IMM, SL)) + fetch (sd, &code->src, &ea); + else + ea = 1; - /* Setting current_location to the starting of next - argument. */ - current_location += ind_arg_len; - } + while (ea--) + if (code->opcode == O (O_ROTXL, SL)) + { + res = rd & 0x80000000; + rd <<= 1; + if (C) + rd |= 1; + c = res; + } + else + { + res = rd & 1; + rd = ((unsigned int) rd) >> 1; + if (C) + rd |= 0x80000000; + c = res; } - /* This is the original position of the stack pointer. */ - old_sp = cpu.regs[7]; - - /* We need space from the stack to store the pointers to argvs. */ - /* As we will infringe on the stack, we need to shift the stack - pointer so that the data is not overwritten. We calculate how - much space is required. */ - sp_move = (no_of_args) * (char_ptr_size); - - /* The final position of stack pointer, we have thus taken some - space from the stack. */ - new_sp = old_sp - sp_move; + v = 0; + goto shift32; - /* Temporary variable holding value where the argv pointers need - to be stored. */ - argv_ptrs_location = new_sp; + case O (O_JMP, SN): + case O (O_JMP, SL): + case O (O_JMP, SB): /* jmp */ + case O (O_JMP, SW): + { + fetch (sd, &code->src, &pc); + goto end; + } - /* The argv pointers are stored at sequential locations. As per - the H8300 ABI. */ - for (i = 0; i < no_of_args; i++) - { - /* Saving the argv pointer. */ - if (h8300hmode || h8300smode) - { - SET_MEMORY_L (argv_ptrs_location, argv_ptrs[i]); - } - else - { - SET_MEMORY_W (argv_ptrs_location, argv_ptrs[i]); - } - - /* The next location where the pointer to the next argv - string has to be stored. */ - argv_ptrs_location += char_ptr_size; - } + case O (O_JSR, SN): + case O (O_JSR, SL): + case O (O_JSR, SB): /* jsr, jump to subroutine */ + case O (O_JSR, SW): + { + int tmp; + if (fetch (sd, &code->src, &pc)) + goto end; + call: + tmp = h8_get_reg (sd, SP_REGNUM); - /* Required by POSIX, Setting 0x0 at the end of the list of argv - pointers. */ - if (h8300hmode || h8300smode) + if (h8300hmode) { - SET_MEMORY_L (old_sp, 0x0); + tmp -= 4; + SET_MEMORY_L (tmp, code->next_pc); } else { - SET_MEMORY_W (old_sp, 0x0); + tmp -= 2; + SET_MEMORY_W (tmp, code->next_pc); } + h8_set_reg (sd, SP_REGNUM, tmp); - /* Freeing allocated memory. */ - free (argv_ptrs); - for (i = 0; i <= no_of_args; i++) + goto end; + } + + case O (O_BSR, SW): + case O (O_BSR, SL): + case O (O_BSR, SB): /* bsr, branch to subroutine */ + if (fetch (sd, &code->src, &res)) + goto end; + pc = code->next_pc + res; + goto call; + + case O (O_RTS, SN): /* rts, return from subroutine */ + { + int tmp; + + tmp = h8_get_reg (sd, SP_REGNUM); + + if (h8300hmode) + { + pc = GET_MEMORY_L (tmp); + tmp += 4; + } + else { - free (ptr_command_line[i]); + pc = GET_MEMORY_W (tmp); + tmp += 2; } - free (ptr_command_line); - /* The no. of argv arguments are returned in Reg 0. */ - cpu.regs[0] = no_of_args; - /* The Pointer to argv in Register 1. */ - cpu.regs[1] = new_sp; - /* Setting the stack pointer to the new value. */ - cpu.regs[7] = new_sp; + h8_set_reg (sd, SP_REGNUM, tmp); + goto end; } - goto next; - /* System call processing starts. */ - case O (O_SYS_OPEN, SB): - { - int len = 0; /* Length of filename. */ - char *filename; /* Filename would go here. */ - char temp_char; /* Temporary character */ - int mode = 0; /* Mode bits for the file. */ - int open_return; /* Return value of open, file descriptor. */ - int i; /* Loop counter */ - int filename_ptr; /* Pointer to filename in cpu memory. */ + case O (O_ILL, SB): /* illegal */ + sim_engine_set_run_state (sd, sim_stopped, SIGILL); + goto end; + + case O (O_SLEEP, SN): /* sleep */ + /* Check for magic numbers in r1 and r2. */ + if ((h8_get_reg (sd, R1_REGNUM) & 0xffff) == LIBC_EXIT_MAGIC1 && + (h8_get_reg (sd, R2_REGNUM) & 0xffff) == LIBC_EXIT_MAGIC2 && + SIM_WIFEXITED (h8_get_reg (sd, 0))) + { + /* This trap comes from _exit, not from gdb. */ + sim_engine_set_run_state (sd, sim_exited, + SIM_WEXITSTATUS (h8_get_reg (sd, 0))); + } + else + { + /* Treat it as a sigtrap. */ + sim_engine_set_run_state (sd, sim_stopped, SIGTRAP); + } + goto end; - /* Setting filename_ptr to first argument of open. */ - filename_ptr = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); + case O (O_BPT, SN): + sim_engine_set_run_state (sd, sim_stopped, SIGTRAP); + goto end; - /* Trying to get mode. */ - if (h8300hmode || h8300smode) - { - mode = GET_MEMORY_L (cpu.regs[7] + 4); - } - else - { - mode = GET_MEMORY_W (cpu.regs[7] + 2); - } + case O (O_BSETEQ, SB): + if (Z) + goto bset; + goto next; - /* Trying to find the length of the filename. */ - temp_char = GET_MEMORY_B (cpu.regs[0]); + case O (O_BSETNE, SB): + if (!Z) + goto bset; + goto next; - len = 1; - while (temp_char != '\0') - { - temp_char = GET_MEMORY_B (filename_ptr + len); - len++; - } + case O (O_BCLREQ, SB): + if (Z) + goto bclr; + goto next; - /* Allocating space for the filename. */ - filename = (char *) malloc (sizeof (char) * len); + case O (O_BCLRNE, SB): + if (!Z) + goto bclr; + goto next; - /* String copying the filename from memory. */ - for (i = 0; i < len; i++) - { - temp_char = GET_MEMORY_B (filename_ptr + i); - filename[i] = temp_char; - } + OBITOP (O_BNOT, 1, 1, ea ^= m); /* bnot */ + OBITOP (O_BTST, 1, 0, nz = ea & m); /* btst */ + bset: + OBITOP (O_BSET, 1, 1, ea |= m); /* bset */ + bclr: + OBITOP (O_BCLR, 1, 1, ea &= ~m); /* bclr */ + OBITOP (O_BLD, 1, 0, c = ea & m); /* bld */ + OBITOP (O_BILD, 1, 0, c = !(ea & m)); /* bild */ + OBITOP (O_BST, 1, 1, ea &= ~m; + if (C) ea |= m); /* bst */ + OBITOP (O_BIST, 1, 1, ea &= ~m; + if (!C) ea |= m); /* bist */ + OBITOP (O_BSTZ, 1, 1, ea &= ~m; + if (Z) ea |= m); /* bstz */ + OBITOP (O_BISTZ, 1, 1, ea &= ~m; + if (!Z) ea |= m); /* bistz */ + OBITOP (O_BAND, 1, 0, c = (ea & m) && C); /* band */ + OBITOP (O_BIAND, 1, 0, c = !(ea & m) && C); /* biand */ + OBITOP (O_BOR, 1, 0, c = (ea & m) || C); /* bor */ + OBITOP (O_BIOR, 1, 0, c = !(ea & m) || C); /* bior */ + OBITOP (O_BXOR, 1, 0, c = ((ea & m) != 0)!= C); /* bxor */ + OBITOP (O_BIXOR, 1, 0, c = !(ea & m) != C); /* bixor */ + + case O (O_BFLD, SB): /* bfld */ + /* bitfield load */ + ea = 0; + if (fetch (sd, &code->src, &bit)) + goto end; - /* Callback to open and return the file descriptor. */ - open_return = sim_callback->open (sim_callback, filename, mode); + if (bit != 0) + { + if (fetch (sd, &code->dst, &ea)) + goto end; - /* Return value in register 0. */ - cpu.regs[0] = open_return; + ea &= bit; + while (!(bit & 1)) + { + ea >>= 1; + bit >>= 1; + } + } + if (store (sd, &code->op3, ea)) + goto end; - /* Freeing memory used for filename. */ - free (filename); - } goto next; - case O (O_SYS_READ, SB): - { - char *char_ptr; /* Where characters read would be stored. */ - int fd; /* File descriptor */ - int buf_size; /* BUF_SIZE parameter in read. */ - int i = 0; /* Temporary Loop counter */ - int read_return = 0; /* Return value from callback to - read. */ + case O(O_BFST, SB): /* bfst */ + /* bitfield store */ + /* NOTE: the imm8 value is in dst, and the ea value + (which is actually the destination) is in op3. + It has to be that way, to avoid breaking the assembler. */ - fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); - buf_size = h8300hmode ? GET_L_REG (2) : GET_W_REG (2); + if (fetch (sd, &code->dst, &bit)) /* imm8 */ + goto end; + if (bit == 0) /* noop -- nothing to do. */ + goto next; - char_ptr = (char *) malloc (sizeof (char) * buf_size); + if (fetch (sd, &code->src, &rd)) /* reg8 src */ + goto end; - /* Callback to read and return the no. of characters read. */ - read_return = - sim_callback->read (sim_callback, fd, char_ptr, buf_size); + if (fetch2 (sd, &code->op3, &ea)) /* ea dst */ + goto end; - /* The characters read are stored in cpu memory. */ - for (i = 0; i < buf_size; i++) - { - SET_MEMORY_B ((cpu.regs[1] + (sizeof (char) * i)), - *(char_ptr + (sizeof (char) * i))); - } + /* Left-shift the register data into position. */ + for (tmp = bit; !(tmp & 1); tmp >>= 1) + rd <<= 1; - /* Return value in Register 0. */ - cpu.regs[0] = read_return; + /* Combine it with the neighboring bits. */ + ea = (ea & ~bit) | (rd & bit); - /* Freeing memory used as buffer. */ - free (char_ptr); + /* Put it back. */ + if (store2 (sd, &code->op3, ea)) + goto end; + goto next; + + case O (O_CLRMAC, SN): /* clrmac */ + h8_set_mach (sd, 0); + h8_set_macl (sd, 0); + h8_set_macZ (sd, 1); + h8_set_macV (sd, 0); + h8_set_macN (sd, 0); + goto next; + + case O (O_STMAC, SL): /* stmac, 260 */ + switch (code->src.type) { + case X (OP_MACH, SL): + res = h8_get_mach (sd); + if (res & 0x200) /* sign extend */ + res |= 0xfffffc00; + break; + case X (OP_MACL, SL): + res = h8_get_macl (sd); + break; + default: goto illegal; } + nz = !h8_get_macZ (sd); + n = h8_get_macN (sd); + v = h8_get_macV (sd); + + if (store (sd, &code->dst, res)) + goto end; + goto next; - case O (O_SYS_WRITE, SB): - { - int fd; /* File descriptor */ - char temp_char; /* Temporary character */ - int len; /* Length of write, Parameter II to write. */ - int char_ptr; /* Character Pointer, Parameter I of write. */ - char *ptr; /* Where characters to be written are stored. - */ - int write_return; /* Return value from callback to write. */ - int i = 0; /* Loop counter */ + case O (O_LDMAC, SL): /* ldmac, 179 */ + if (fetch (sd, &code->src, &rd)) + goto end; - fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); - char_ptr = h8300hmode ? GET_L_REG (1) : GET_W_REG (1); - len = h8300hmode ? GET_L_REG (2) : GET_W_REG (2); + switch (code->dst.type) { + case X (OP_MACH, SL): + rd &= 0x3ff; /* Truncate to 10 bits */ + h8_set_mach (sd, rd); + break; + case X (OP_MACL, SL): + h8_set_macl (sd, rd); + break; + default: goto illegal; + } + h8_set_macV (sd, 0); + goto next; - /* Allocating space for the characters to be written. */ - ptr = (char *) malloc (sizeof (char) * len); + case O (O_MAC, SW): + if (fetch (sd, &code->src, &rd) || + fetch (sd, &code->dst, &res)) + goto end; - /* Fetching the characters from cpu memory. */ - for (i = 0; i < len; i++) - { - temp_char = GET_MEMORY_B (char_ptr + i); - ptr[i] = temp_char; - } + /* Ye gods, this is non-portable! + However, the existing mul/div code is similar. */ + res = SEXTSHORT (res) * SEXTSHORT (rd); - /* Callback write and return the no. of characters written. */ - write_return = sim_callback->write (sim_callback, fd, ptr, len); + if (h8_get_macS (sd)) /* Saturating mode */ + { + long long mac = h8_get_macl (sd); - /* Return value in Register 0. */ - cpu.regs[0] = write_return; + if (mac & 0x80000000) /* sign extend */ + mac |= 0xffffffff00000000LL; - /* Freeing memory used as buffer. */ - free (ptr); - } + mac += res; + if (mac > 0x7fffffff || mac < 0xffffffff80000000LL) + h8_set_macV (sd, 1); + h8_set_macZ (sd, (mac == 0)); + h8_set_macN (sd, (mac < 0)); + h8_set_macl (sd, (int) mac); + } + else /* "Less Saturating" mode */ + { + long long mac = h8_get_mach (sd); + mac <<= 32; + mac += h8_get_macl (sd); + + if (mac & 0x20000000000LL) /* sign extend */ + mac |= 0xfffffc0000000000LL; + + mac += res; + if (mac > 0x1ffffffffffLL || + mac < (long long) 0xfffffe0000000000LL) + h8_set_macV (sd, 1); + h8_set_macZ (sd, (mac == 0)); + h8_set_macN (sd, (mac < 0)); + h8_set_macl (sd, (int) mac); + mac >>= 32; + h8_set_mach (sd, (int) (mac & 0x3ff)); + } goto next; - case O (O_SYS_LSEEK, SB): - { - int fd; /* File descriptor */ - int offset; /* Offset */ - int origin; /* Origin */ - int lseek_return; /* Return value from callback to lseek. */ + case O (O_MULS, SW): /* muls.w */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; - fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); - offset = h8300hmode ? GET_L_REG (1) : GET_W_REG (1); - origin = h8300hmode ? GET_L_REG (2) : GET_W_REG (2); + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfff0; + else + ea = SEXTSHORT (ea); - /* Callback lseek and return offset. */ - lseek_return = - sim_callback->lseek (sim_callback, fd, offset, origin); + res = SEXTSHORT (ea * SEXTSHORT (rd)); + + n = res & 0x8000; + nz = res & 0xffff; + if (store (sd, &code->dst, res)) + goto end; - /* Return value in register 0. */ - cpu.regs[0] = lseek_return; - } goto next; - case O (O_SYS_CLOSE, SB): - { - int fd; /* File descriptor */ - int close_return; /* Return value from callback to close. */ + case O (O_MULS, SL): /* muls.l */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; - fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfffffff0; - /* Callback close and return. */ - close_return = sim_callback->close (sim_callback, fd); + res = ea * rd; - /* Return value in register 0. */ - cpu.regs[0] = close_return; - } + n = res & 0x80000000; + nz = res & 0xffffffff; + if (store (sd, &code->dst, res)) + goto end; goto next; - case O (O_SYS_FSTAT, SB): - { - int fd; /* File descriptor */ - struct stat stat_rec; /* Stat record */ - int fstat_return; /* Return value from callback to stat. */ - int stat_ptr; /* Pointer to stat record. */ - char *temp_stat_ptr; /* Temporary stat_rec pointer. */ + case O (O_MULSU, SL): /* muls/u.l */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; - fd = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfffffff0; - /* Setting stat_ptr to second argument of stat. */ - stat_ptr = h8300hmode ? GET_L_REG (1) : GET_W_REG (1); + /* Compute upper 32 bits of the 64-bit result. */ + res = (((long long) ea) * ((long long) rd)) >> 32; - /* Callback stat and return. */ - fstat_return = sim_callback->fstat (sim_callback, fd, &stat_rec); + n = res & 0x80000000; + nz = res & 0xffffffff; + if (store (sd, &code->dst, res)) + goto end; + goto next; - /* Have stat_ptr point to starting of stat_rec. */ - temp_stat_ptr = (char *) (&stat_rec); + case O (O_MULU, SW): /* mulu.w */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; - /* Setting up the stat structure returned. */ - SET_MEMORY_W (stat_ptr, stat_rec.st_dev); - stat_ptr += 2; - SET_MEMORY_W (stat_ptr, stat_rec.st_ino); - stat_ptr += 2; - SET_MEMORY_L (stat_ptr, stat_rec.st_mode); - stat_ptr += 4; - SET_MEMORY_W (stat_ptr, stat_rec.st_nlink); - stat_ptr += 2; - SET_MEMORY_W (stat_ptr, stat_rec.st_uid); - stat_ptr += 2; - SET_MEMORY_W (stat_ptr, stat_rec.st_gid); - stat_ptr += 2; - SET_MEMORY_W (stat_ptr, stat_rec.st_rdev); - stat_ptr += 2; - SET_MEMORY_L (stat_ptr, stat_rec.st_size); - stat_ptr += 4; - SET_MEMORY_L (stat_ptr, stat_rec.st_atime); - stat_ptr += 8; - SET_MEMORY_L (stat_ptr, stat_rec.st_mtime); - stat_ptr += 8; - SET_MEMORY_L (stat_ptr, stat_rec.st_ctime); + res = UEXTSHORT ((UEXTSHORT (ea) * UEXTSHORT (rd))); + + /* Don't set Z or N. */ + if (store (sd, &code->dst, res)) + goto end; - /* Return value in register 0. */ - cpu.regs[0] = fstat_return; - } goto next; - case O (O_SYS_STAT, SB): - { - int len = 0; /* Length of filename. */ - char *filename; /* Filename would go here. */ - char temp_char; /* Temporary character */ - int filename_ptr; /* Pointer to filename in cpu memory. */ - struct stat stat_rec; /* Stat record */ - int stat_return; /* Return value from callback to stat */ - int stat_ptr; /* Pointer to stat record. */ - char *temp_stat_ptr; /* Temporary stat_rec pointer. */ - int i = 0; /* Loop Counter */ + case O (O_MULU, SL): /* mulu.l */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; - /* Setting filename_ptr to first argument of open. */ - filename_ptr = h8300hmode ? GET_L_REG (0) : GET_W_REG (0); + res = ea * rd; - /* Trying to find the length of the filename. */ - temp_char = GET_MEMORY_B (cpu.regs[0]); + /* Don't set Z or N. */ + if (store (sd, &code->dst, res)) + goto end; - len = 1; - while (temp_char != '\0') - { - temp_char = GET_MEMORY_B (filename_ptr + len); - len++; - } + goto next; - /* Allocating space for the filename. */ - filename = (char *) malloc (sizeof (char) * len); + case O (O_MULUU, SL): /* mulu/u.l */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; - /* String copying the filename from memory. */ - for (i = 0; i < len; i++) - { - temp_char = GET_MEMORY_B (filename_ptr + i); - filename[i] = temp_char; - } + /* Compute upper 32 bits of the 64-bit result. */ + res = (((unsigned long long) (unsigned) ea) * + ((unsigned long long) (unsigned) rd)) >> 32; - /* Setting stat_ptr to second argument of stat. */ - /* stat_ptr = cpu.regs[1]; */ - stat_ptr = h8300hmode ? GET_L_REG (1) : GET_W_REG (1); + /* Don't set Z or N. */ + if (store (sd, &code->dst, res)) + goto end; - /* Callback stat and return. */ - stat_return = - sim_callback->stat (sim_callback, filename, &stat_rec); + goto next; - /* Have stat_ptr point to starting of stat_rec. */ - temp_stat_ptr = (char *) (&stat_rec); + case O (O_MULXS, SB): /* mulxs.b */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; - /* Freeing memory used for filename. */ - free (filename); + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfffffff0; + else + ea = SEXTCHAR (ea); - /* Setting up the stat structure returned. */ - SET_MEMORY_W (stat_ptr, stat_rec.st_dev); - stat_ptr += 2; - SET_MEMORY_W (stat_ptr, stat_rec.st_ino); - stat_ptr += 2; - SET_MEMORY_L (stat_ptr, stat_rec.st_mode); - stat_ptr += 4; - SET_MEMORY_W (stat_ptr, stat_rec.st_nlink); - stat_ptr += 2; - SET_MEMORY_W (stat_ptr, stat_rec.st_uid); - stat_ptr += 2; - SET_MEMORY_W (stat_ptr, stat_rec.st_gid); - stat_ptr += 2; - SET_MEMORY_W (stat_ptr, stat_rec.st_rdev); - stat_ptr += 2; - SET_MEMORY_L (stat_ptr, stat_rec.st_size); - stat_ptr += 4; - SET_MEMORY_L (stat_ptr, stat_rec.st_atime); - stat_ptr += 8; - SET_MEMORY_L (stat_ptr, stat_rec.st_mtime); - stat_ptr += 8; - SET_MEMORY_L (stat_ptr, stat_rec.st_ctime); + res = ea * SEXTCHAR (rd); + + n = res & 0x8000; + nz = res & 0xffff; + if (store (sd, &code->dst, res)) + goto end; - /* Return value in register 0. */ - cpu.regs[0] = stat_return; - } goto next; - /* End of system call processing. */ - ONOT (O_NOT, rd = ~rd; v = 0;); - OSHIFTS (O_SHLL, - c = rd & hm; v = 0; rd <<= 1, - c = rd & (hm >> 1); v = 0; rd <<= 2); - OSHIFTS (O_SHLR, - c = rd & 1; v = 0; rd = (unsigned int) rd >> 1, - c = rd & 2; v = 0; rd = (unsigned int) rd >> 2); - OSHIFTS (O_SHAL, - c = rd & hm; v = (rd & hm) != ((rd & (hm >> 1)) << 1); rd <<= 1, - c = rd & (hm >> 1); v = (rd & (hm >> 1)) != ((rd & (hm >> 2)) << 2); rd <<= 2); - OSHIFTS (O_SHAR, - t = rd & hm; c = rd & 1; v = 0; rd >>= 1; rd |= t, - t = rd & hm; c = rd & 2; v = 0; rd >>= 2; rd |= t | t >> 1); - OSHIFTS (O_ROTL, - c = rd & hm; v = 0; rd <<= 1; rd |= C, - c = rd & hm; v = 0; rd <<= 1; rd |= C; c = rd & hm; rd <<= 1; rd |= C); - OSHIFTS (O_ROTR, - c = rd & 1; v = 0; rd = (unsigned int) rd >> 1; if (c) rd |= hm, - c = rd & 1; v = 0; rd = (unsigned int) rd >> 1; if (c) rd |= hm; c = rd & 1; rd = (unsigned int) rd >> 1; if (c) rd |= hm); - OSHIFTS (O_ROTXL, - t = rd & hm; rd <<= 1; rd |= C; c = t; v = 0, - t = rd & hm; rd <<= 1; rd |= C; c = t; v = 0; t = rd & hm; rd <<= 1; rd |= C; c = t); - OSHIFTS (O_ROTXR, - t = rd & 1; rd = (unsigned int) rd >> 1; if (C) rd |= hm; c = t; v = 0, - t = rd & 1; rd = (unsigned int) rd >> 1; if (C) rd |= hm; c = t; v = 0; t = rd & 1; rd = (unsigned int) rd >> 1; if (C) rd |= hm; c = t); - - case O (O_JMP, SB): - { - pc = fetch (&code->src); + case O (O_MULXS, SW): /* mulxs.w */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) goto end; - } + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfff0; + else + ea = SEXTSHORT (ea); - case O (O_JSR, SB): - { - int tmp; - pc = fetch (&code->src); - call: - tmp = cpu.regs[7]; + res = ea * SEXTSHORT (rd & 0xffff); - if (h8300hmode) - { - tmp -= 4; - SET_MEMORY_L (tmp, code->next_pc); - } - else - { - tmp -= 2; - SET_MEMORY_W (tmp, code->next_pc); - } - cpu.regs[7] = tmp; + n = res & 0x80000000; + nz = res & 0xffffffff; + if (store (sd, &code->dst, res)) + goto end; + + goto next; + case O (O_MULXU, SB): /* mulxu.b */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) goto end; - } - case O (O_BSR, SB): - pc = code->src.literal; - goto call; - case O (O_RTS, SN): - { - int tmp; + res = UEXTCHAR (ea) * UEXTCHAR (rd); - tmp = cpu.regs[7]; + if (store (sd, &code->dst, res)) + goto end; - if (h8300hmode) - { - pc = GET_MEMORY_L (tmp); - tmp += 4; - } - else - { - pc = GET_MEMORY_W (tmp); - tmp += 2; - } + goto next; - cpu.regs[7] = tmp; + case O (O_MULXU, SW): /* mulxu.w */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) goto end; - } - case O (O_ILL, SB): - cpu.state = SIM_STATE_STOPPED; - cpu.exception = SIGILL; - goto end; - case O (O_SLEEP, SN): - /* FIXME: Doesn't this break for breakpoints when r0 - contains just the right (er, wrong) value? */ - cpu.state = SIM_STATE_STOPPED; - /* The format of r0 is defined by target newlib. Expand - the macros here instead of looking for .../sys/wait.h. */ -#define SIM_WIFEXITED(v) (((v) & 0xff) == 0) -#define SIM_WIFSIGNALED(v) (((v) & 0x7f) > 0 && (((v) & 0x7f) < 0x7f)) - if (! SIM_WIFEXITED (cpu.regs[0]) && SIM_WIFSIGNALED (cpu.regs[0])) - cpu.exception = SIGILL; - else - cpu.exception = SIGTRAP; - goto end; - case O (O_BPT, SN): - cpu.state = SIM_STATE_STOPPED; - cpu.exception = SIGTRAP; - goto end; + res = UEXTSHORT (ea) * UEXTSHORT (rd); - OBITOP (O_BNOT, 1, 1, ea ^= m); - OBITOP (O_BTST, 1, 0, nz = ea & m); - OBITOP (O_BCLR, 1, 1, ea &= ~m); - OBITOP (O_BSET, 1, 1, ea |= m); - OBITOP (O_BLD, 1, 0, c = ea & m); - OBITOP (O_BILD, 1, 0, c = !(ea & m)); - OBITOP (O_BST, 1, 1, ea &= ~m; - if (C) ea |= m); - OBITOP (O_BIST, 1, 1, ea &= ~m; - if (!C) ea |= m); - OBITOP (O_BAND, 1, 0, c = (ea & m) && C); - OBITOP (O_BIAND, 1, 0, c = !(ea & m) && C); - OBITOP (O_BOR, 1, 0, c = (ea & m) || C); - OBITOP (O_BIOR, 1, 0, c = !(ea & m) || C); - OBITOP (O_BXOR, 1, 0, c = ((ea & m) != 0) != C); - OBITOP (O_BIXOR, 1, 0, c = !(ea & m) != C); - -#define MOP(bsize, signed) \ - mop (code, bsize, signed); \ - goto next; - - case O (O_MULS, SB): - MOP (1, 1); - break; - case O (O_MULS, SW): - MOP (0, 1); - break; - case O (O_MULU, SB): - MOP (1, 0); - break; - case O (O_MULU, SW): - MOP (0, 0); - break; + if (store (sd, &code->dst, res)) + goto end; + + goto next; - case O (O_TAS, SB): + case O (O_TAS, SB): /* tas, (test and set?) */ if (!h8300smode || code->src.type != X (OP_REG, SL)) goto illegal; switch (code->src.reg) @@ -2013,127 +3911,297 @@ sim_resume (SIM_DESC sd, int step, int siggnal) default: goto illegal; } - res = fetch (&code->src); - store (&code->src, res | 0x80); + if (fetch (sd, &code->src, &res)) + goto end; + if (store (sd, &code->src, res | 0x80)) + goto end; + goto just_flags_log8; - case O (O_DIVU, SB): - { - rd = GET_W_REG (code->dst.reg); - ea = GET_B_REG (code->src.reg); - if (ea) - { - tmp = (unsigned) rd % ea; - rd = (unsigned) rd / ea; - } - SET_W_REG (code->dst.reg, (rd & 0xff) | (tmp << 8)); - n = ea & 0x80; - nz = ea & 0xff; + case O (O_DIVU, SW): /* divu.w */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; - goto next; - } - case O (O_DIVU, SW): - { - rd = GET_L_REG (code->dst.reg); - ea = GET_W_REG (code->src.reg); - n = ea & 0x8000; - nz = ea & 0xffff; - if (ea) - { - tmp = (unsigned) rd % ea; - rd = (unsigned) rd / ea; - } - SET_L_REG (code->dst.reg, (rd & 0xffff) | (tmp << 16)); - goto next; - } + n = ea & 0x8000; + nz = ea & 0xffff; + if (ea) + res = (unsigned) (UEXTSHORT (rd) / UEXTSHORT (ea)); + else + res = 0; - case O (O_DIVS, SB): - { + if (store (sd, &code->dst, res)) + goto end; + goto next; - rd = SEXTSHORT (GET_W_REG (code->dst.reg)); - ea = SEXTCHAR (GET_B_REG (code->src.reg)); - if (ea) - { - tmp = (int) rd % (int) ea; - rd = (int) rd / (int) ea; - n = rd & 0x8000; - nz = 1; - } - else - nz = 0; - SET_W_REG (code->dst.reg, (rd & 0xff) | (tmp << 8)); - goto next; - } - case O (O_DIVS, SW): - { - rd = GET_L_REG (code->dst.reg); - ea = SEXTSHORT (GET_W_REG (code->src.reg)); - if (ea) - { - tmp = (int) rd % (int) ea; - rd = (int) rd / (int) ea; - n = rd & 0x80000000; - nz = 1; - } - else - nz = 0; - SET_L_REG (code->dst.reg, (rd & 0xffff) | (tmp << 16)); - goto next; - } - case O (O_EXTS, SW): - rd = GET_W_REG (code->src.reg) & 0xff; /* Yes, src, not dst. */ + case O (O_DIVU, SL): /* divu.l */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; + + n = ea & 0x80000000; + nz = ea & 0xffffffff; + if (ea) + res = (unsigned) rd / ea; + else + res = 0; + + if (store (sd, &code->dst, res)) + goto end; + goto next; + + case O (O_DIVS, SW): /* divs.w */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; + + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfffffff0; + + if (ea) + { + res = SEXTSHORT (rd) / SEXTSHORT (ea); + nz = 1; + } + else + { + res = 0; + nz = 0; + } + + n = res & 0x8000; + if (store (sd, &code->dst, res)) + goto end; + goto next; + + case O (O_DIVS, SL): /* divs.l */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; + + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfffffff0; + + if (ea) + { + res = rd / ea; + nz = 1; + } + else + { + res = 0; + nz = 0; + } + + n = res & 0x80000000; + if (store (sd, &code->dst, res)) + goto end; + goto next; + + case O (O_DIVXU, SB): /* divxu.b */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; + + rd = UEXTSHORT (rd); + ea = UEXTCHAR (ea); + + n = ea & 0x80; + nz = ea & 0xff; + if (ea) + { + tmp = (unsigned) rd % ea; + res = (unsigned) rd / ea; + } + else + { + tmp = 0; + res = 0; + } + + if (store (sd, &code->dst, (res & 0xffff) | (tmp << 8))) + goto end; + goto next; + + case O (O_DIVXU, SW): /* divxu.w */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; + + ea = UEXTSHORT (ea); + + n = ea & 0x8000; + nz = ea & 0xffff; + if (ea) + { + tmp = (unsigned) rd % ea; + res = (unsigned) rd / ea; + } + else + { + tmp = 0; + res = 0; + } + + if (store (sd, &code->dst, (res & 0xffff) | (tmp << 16))) + goto end; + goto next; + + case O (O_DIVXS, SB): /* divxs.b */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; + + rd = SEXTSHORT (rd); + + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfffffff0; + else + ea = SEXTCHAR (ea); + + if (ea) + { + tmp = (int) rd % (int) ea; + res = (int) rd / (int) ea; + nz = 1; + } + else + { + tmp = 0; + res = 0; + nz = 0; + } + + n = res & 0x8000; + if (store (sd, &code->dst, (res & 0xff) | (tmp << 8))) + goto end; + goto next; + + case O (O_DIVXS, SW): /* divxs.w */ + if (fetch (sd, &code->src, &ea) || + fetch (sd, &code->dst, &rd)) + goto end; + + /* FIXME: is this the right place to be doing sign extend? */ + if (OP_KIND (code->src.type) == OP_IMM && + (ea & 8) != 0) + ea |= 0xfffffff0; + else + ea = SEXTSHORT (ea); + + if (ea) + { + tmp = (int) rd % (int) ea; + res = (int) rd / (int) ea; + nz = 1; + } + else + { + tmp = 0; + res = 0; + nz = 0; + } + + n = res & 0x80000000; + if (store (sd, &code->dst, (res & 0xffff) | (tmp << 16))) + goto end; + goto next; + + case O (O_EXTS, SW): /* exts.w, signed extend */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; ea = rd & 0x80 ? -256 : 0; - res = rd + ea; + res = (rd & 0xff) + ea; goto log16; - case O (O_EXTS, SL): - rd = GET_W_REG (code->src.reg) & 0xffff; + + case O (O_EXTS, SL): /* exts.l, signed extend */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (code->src.type == X (OP_IMM, SL)) + { + if (fetch (sd, &code->src, &ea)) + goto end; + + if (ea == 2) /* exts.l #2, nn */ + { + /* Sign-extend from 8-bit to 32-bit. */ + ea = rd & 0x80 ? -256 : 0; + res = (rd & 0xff) + ea; + goto log32; + } + } + /* Sign-extend from 16-bit to 32-bit. */ ea = rd & 0x8000 ? -65536 : 0; - res = rd + ea; + res = (rd & 0xffff) + ea; goto log32; - case O (O_EXTU, SW): - rd = GET_W_REG (code->src.reg) & 0xff; + + case O (O_EXTU, SW): /* extu.w, unsigned extend */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; ea = 0; - res = rd + ea; + res = (rd & 0xff) + ea; goto log16; - case O (O_EXTU, SL): - rd = GET_W_REG (code->src.reg) & 0xffff; + + case O (O_EXTU, SL): /* extu.l, unsigned extend */ + if (fetch2 (sd, &code->dst, &rd)) + goto end; + if (code->src.type == X (OP_IMM, SL)) + { + if (fetch (sd, &code->src, &ea)) + goto end; + + if (ea == 2) /* extu.l #2, nn */ + { + /* Zero-extend from 8-bit to 32-bit. */ + ea = 0; + res = (rd & 0xff) + ea; + goto log32; + } + } + /* Zero-extend from 16-bit to 32-bit. */ ea = 0; - res = rd + ea; + res = (rd & 0xffff) + ea; goto log32; - case O (O_NOP, SN): + case O (O_NOP, SN): /* nop */ goto next; - case O (O_STM, SL): + case O (O_STM, SL): /* stm, store to memory */ { int nregs, firstreg, i; nregs = GET_MEMORY_B (pc + 1); nregs >>= 4; nregs &= 0xf; - firstreg = GET_MEMORY_B (pc + 3); + firstreg = code->src.reg; firstreg &= 0xf; for (i = firstreg; i <= firstreg + nregs; i++) { - cpu.regs[7] -= 4; - SET_MEMORY_L (cpu.regs[7], cpu.regs[i]); + h8_set_reg (sd, SP_REGNUM, h8_get_reg (sd, SP_REGNUM) - 4); + SET_MEMORY_L (h8_get_reg (sd, SP_REGNUM), h8_get_reg (sd, i)); } } goto next; - case O (O_LDM, SL): + case O (O_LDM, SL): /* ldm, load from memory */ { int nregs, firstreg, i; nregs = GET_MEMORY_B (pc + 1); nregs >>= 4; nregs &= 0xf; - firstreg = GET_MEMORY_B (pc + 3); + firstreg = code->dst.reg; firstreg &= 0xf; for (i = firstreg; i >= firstreg - nregs; i--) { - cpu.regs[i] = GET_MEMORY_L (cpu.regs[7]); - cpu.regs[7] += 4; + h8_set_reg (sd, i, GET_MEMORY_L (h8_get_reg (sd, SP_REGNUM))); + h8_set_reg (sd, SP_REGNUM, h8_get_reg (sd, SP_REGNUM) + 4); } } goto next; @@ -2141,73 +4209,91 @@ sim_resume (SIM_DESC sd, int step, int siggnal) case O (O_DAA, SB): /* Decimal Adjust Addition. This is for BCD arithmetic. */ res = GET_B_REG (code->src.reg); - if (!c && (0 <= (res >> 4) && (res >> 4) <= 9) - && !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) + if (!c && (0 <= (res >> 4) && (res >> 4) <= 9) && + !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) res = res; /* Value added == 0. */ - else if (!c && (0 <= (res >> 4) && (res >> 4) <= 8) - && !h && (10 <= (res & 0xf) && (res & 0xf) <= 15)) + else if (!c && (0 <= (res >> 4) && (res >> 4) <= 8) && + !h && (10 <= (res & 0xf) && (res & 0xf) <= 15)) res = res + 0x6; /* Value added == 6. */ - else if (!c && (0 <= (res >> 4) && (res >> 4) <= 9) - && h && (0 <= (res & 0xf) && (res & 0xf) <= 3)) + else if (!c && (0 <= (res >> 4) && (res >> 4) <= 9) && + h && (0 <= (res & 0xf) && (res & 0xf) <= 3)) res = res + 0x6; /* Value added == 6. */ - else if (!c && (10 <= (res >> 4) && (res >> 4) <= 15) - && !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) + else if (!c && (10 <= (res >> 4) && (res >> 4) <= 15) && + !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) + res = res + 0x60; /* Value added == 60. */ + else if (!c && (9 <= (res >> 4) && (res >> 4) <= 15) && + !h && (10 <= (res & 0xf) && (res & 0xf) <= 15)) + res = res + 0x66; /* Value added == 66. */ + else if (!c && (10 <= (res >> 4) && (res >> 4) <= 15) && + h && (0 <= (res & 0xf) && (res & 0xf) <= 3)) + res = res + 0x66; /* Value added == 66. */ + else if ( c && (1 <= (res >> 4) && (res >> 4) <= 2) && + !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) res = res + 0x60; /* Value added == 60. */ - else if (!c && (9 <= (res >> 4) && (res >> 4) <= 15) - && !h && (10 <= (res & 0xf) && (res & 0xf) <= 15)) + else if ( c && (1 <= (res >> 4) && (res >> 4) <= 2) && + !h && (10 <= (res & 0xf) && (res & 0xf) <= 15)) res = res + 0x66; /* Value added == 66. */ - else if (!c && (10 <= (res >> 4) && (res >> 4) <= 15) - && h && (0 <= (res & 0xf) && (res & 0xf) <= 3)) + else if (c && (1 <= (res >> 4) && (res >> 4) <= 3) && + h && (0 <= (res & 0xf) && (res & 0xf) <= 3)) res = res + 0x66; /* Value added == 66. */ - else if (c && (1 <= (res >> 4) && (res >> 4) <= 2) - && !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) - res = res + 0x160; /* Value added == 60, plus 'carry'. */ - else if (c && (1 <= (res >> 4) && (res >> 4) <= 2) - && !h && (10 <= (res & 0xf) && (res & 0xf) <= 15)) - res = res + 0x166; /* Value added == 66, plus 'carry'. */ - else if (c && (1 <= (res >> 4) && (res >> 4) <= 3) - && h && (0 <= (res & 0xf) && (res & 0xf) <= 3)) - res = res + 0x166; /* Value added == 66, plus 'carry'. */ goto alu8; case O (O_DAS, SB): /* Decimal Adjust Subtraction. This is for BCD arithmetic. */ res = GET_B_REG (code->src.reg); /* FIXME fetch, fetch2... */ - if (!c && (0 <= (res >> 4) && (res >> 4) <= 9) - && !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) + if (!c && (0 <= (res >> 4) && (res >> 4) <= 9) && + !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) res = res; /* Value added == 0. */ - else if (!c && (0 <= (res >> 4) && (res >> 4) <= 8) - && h && (6 <= (res & 0xf) && (res & 0xf) <= 15)) + else if (!c && (0 <= (res >> 4) && (res >> 4) <= 8) && + h && (6 <= (res & 0xf) && (res & 0xf) <= 15)) res = res + 0xfa; /* Value added == 0xfa. */ - else if (c && (7 <= (res >> 4) && (res >> 4) <= 15) - && !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) + else if ( c && (7 <= (res >> 4) && (res >> 4) <= 15) && + !h && (0 <= (res & 0xf) && (res & 0xf) <= 9)) res = res + 0xa0; /* Value added == 0xa0. */ - else if (c && (6 <= (res >> 4) && (res >> 4) <= 15) - && h && (6 <= (res & 0xf) && (res & 0xf) <= 15)) + else if (c && (6 <= (res >> 4) && (res >> 4) <= 15) && + h && (6 <= (res & 0xf) && (res & 0xf) <= 15)) res = res + 0x9a; /* Value added == 0x9a. */ goto alu8; default: illegal: - cpu.state = SIM_STATE_STOPPED; - cpu.exception = SIGILL; + sim_engine_set_run_state (sd, sim_stopped, SIGILL); goto end; } - abort (); + + (*sim_callback->printf_filtered) (sim_callback, + "sim_resume: internal error.\n"); + sim_engine_set_run_state (sd, sim_stopped, SIGILL); + goto end; setc: - if (code->dst.type == OP_CCR) + if (code->dst.type == X (OP_CCR, SB) || + code->dst.type == X (OP_CCR, SW)) { - cpu.ccr = res; - GETSR (); + h8_set_ccr (sd, res); + /* Get Status Register (flags). */ + c = (h8_get_ccr (sd) >> 0) & 1; + v = (h8_get_ccr (sd) >> 1) & 1; + nz = !((h8_get_ccr (sd) >> 2) & 1); + n = (h8_get_ccr (sd) >> 3) & 1; + u = (h8_get_ccr (sd) >> 4) & 1; + h = (h8_get_ccr (sd) >> 5) & 1; + ui = ((h8_get_ccr (sd) >> 6) & 1); + intMaskBit = (h8_get_ccr (sd) >> 7) & 1; } - else if (code->dst.type == OP_EXR && h8300smode) + else if (h8300smode && + (code->dst.type == X (OP_EXR, SB) || + code->dst.type == X (OP_EXR, SW))) { - cpu.exr = res; - GETEXR (); + h8_set_exr (sd, res); + if (h8300smode) /* Get exr. */ + { + trace = (h8_get_exr (sd) >> 7) & 1; + intMask = h8_get_exr (sd) & 7; + } } else goto illegal; @@ -2216,7 +4302,11 @@ sim_resume (SIM_DESC sd, int step, int siggnal) condtrue: /* When a branch works */ - pc = code->src.literal; + if (fetch (sd, &code->src, &res)) + goto end; + if (res & 1) /* bad address */ + goto illegal; + pc = code->next_pc + res; goto end; /* Set the cond codes from res */ @@ -2229,7 +4319,6 @@ sim_resume (SIM_DESC sd, int step, int siggnal) v = (rd & 0x7f) == 0x7f; goto next; - /* Set the flags after an 16 bit inc/dec operation */ just_flags_inc16: n = res & 0x8000; @@ -2237,7 +4326,6 @@ sim_resume (SIM_DESC sd, int step, int siggnal) v = (rd & 0x7fff) == 0x7fff; goto next; - /* Set the flags after an 32 bit inc/dec operation */ just_flags_inc32: n = res & 0x80000000; @@ -2245,30 +4333,34 @@ sim_resume (SIM_DESC sd, int step, int siggnal) v = (rd & 0x7fffffff) == 0x7fffffff; goto next; - shift8: /* Set flags after an 8 bit shift op, carry,overflow set in insn */ n = (rd & 0x80); nz = rd & 0xff; - SET_B_REG (code->src.reg, rd); + if (store2 (sd, &code->dst, rd)) + goto end; goto next; shift16: /* Set flags after an 16 bit shift op, carry,overflow set in insn */ n = (rd & 0x8000); nz = rd & 0xffff; - SET_W_REG (code->src.reg, rd); + if (store2 (sd, &code->dst, rd)) + goto end; goto next; shift32: /* Set flags after an 32 bit shift op, carry,overflow set in insn */ n = (rd & 0x80000000); nz = rd & 0xffffffff; - SET_L_REG (code->src.reg, rd); + if (store2 (sd, &code->dst, rd)) + goto end; goto next; log32: - store (&code->dst, res); + if (store2 (sd, &code->dst, res)) + goto end; + just_flags_log32: /* flags after a 32bit logical operation */ n = res & 0x80000000; @@ -2277,7 +4369,9 @@ sim_resume (SIM_DESC sd, int step, int siggnal) goto next; log16: - store (&code->dst, res); + if (store2 (sd, &code->dst, res)) + goto end; + just_flags_log16: /* flags after a 16bit logical operation */ n = res & 0x8000; @@ -2285,9 +4379,10 @@ sim_resume (SIM_DESC sd, int step, int siggnal) v = 0; goto next; - log8: - store (&code->dst, res); + if (store2 (sd, &code->dst, res)) + goto end; + just_flags_log8: n = res & 0x80; nz = res & 0xff; @@ -2295,7 +4390,9 @@ sim_resume (SIM_DESC sd, int step, int siggnal) goto next; alu8: - SET_B_REG (code->dst.reg, res); + if (store2 (sd, &code->dst, res)) + goto end; + just_flags_alu8: n = res & 0x80; nz = res & 0xff; @@ -2303,10 +4400,12 @@ sim_resume (SIM_DESC sd, int step, int siggnal) switch (code->opcode / 4) { case O_ADD: + case O_ADDX: v = ((rd & 0x80) == (ea & 0x80) && (rd & 0x80) != (res & 0x80)); break; case O_SUB: + case O_SUBX: case O_CMP: v = ((rd & 0x80) != (-ea & 0x80) && (rd & 0x80) != (res & 0x80)); @@ -2314,11 +4413,16 @@ sim_resume (SIM_DESC sd, int step, int siggnal) case O_NEG: v = (rd == 0x80); break; + case O_DAA: + case O_DAS: + break; /* No effect on v flag. */ } goto next; alu16: - SET_W_REG (code->dst.reg, res); + if (store2 (sd, &code->dst, res)) + goto end; + just_flags_alu16: n = res & 0x8000; nz = res & 0xffff; @@ -2326,10 +4430,12 @@ sim_resume (SIM_DESC sd, int step, int siggnal) switch (code->opcode / 4) { case O_ADD: + case O_ADDX: v = ((rd & 0x8000) == (ea & 0x8000) && (rd & 0x8000) != (res & 0x8000)); break; case O_SUB: + case O_SUBX: case O_CMP: v = ((rd & 0x8000) != (-ea & 0x8000) && (rd & 0x8000) != (res & 0x8000)); @@ -2341,18 +4447,23 @@ sim_resume (SIM_DESC sd, int step, int siggnal) goto next; alu32: - SET_L_REG (code->dst.reg, res); + if (store2 (sd, &code->dst, res)) + goto end; + just_flags_alu32: n = res & 0x80000000; nz = res & 0xffffffff; switch (code->opcode / 4) { case O_ADD: + case O_ADDX: v = ((rd & 0x80000000) == (ea & 0x80000000) && (rd & 0x80000000) != (res & 0x80000000)); - c = ((unsigned) res < (unsigned) rd) || ((unsigned) res < (unsigned) ea); + c = ((unsigned) res < (unsigned) rd) || + ((unsigned) res < (unsigned) ea); break; case O_SUB: + case O_SUBX: case O_CMP: v = ((rd & 0x80000000) != (-ea & 0x80000000) && (rd & 0x80000000) != (res & 0x80000000)); @@ -2365,34 +4476,37 @@ sim_resume (SIM_DESC sd, int step, int siggnal) } goto next; - next:; - pc = code->next_pc; + next: + if ((res = h8_get_delayed_branch (sd)) != 0) + { + pc = res; + h8_set_delayed_branch (sd, 0); + } + else + pc = code->next_pc; end: - ; -#if 0 - if (cpu.regs[8]) - abort (); -#endif - + if (--poll_count < 0) { poll_count = POLL_QUIT_INTERVAL; if ((*sim_callback->poll_quit) != NULL && (*sim_callback->poll_quit) (sim_callback)) - sim_stop (sd); + sim_engine_set_run_state (sd, sim_stopped, SIGINT); } + sim_engine_get_run_state (sd, &reason, &sigrc); + } while (reason == sim_running); - } - while (cpu.state == SIM_STATE_RUNNING); - cpu.ticks += get_now () - tick_start; - cpu.cycles += cycles; - cpu.insts += insts; - - cpu.pc = pc; - BUILDSR (); - BUILDEXR (); - cpu.mask = oldmask; + h8_set_ticks (sd, h8_get_ticks (sd) + get_now () - tick_start); + h8_set_cycles (sd, h8_get_cycles (sd) + cycles); + h8_set_insts (sd, h8_get_insts (sd) + insts); + h8_set_pc (sd, pc); + BUILDSR (sd); + + if (h8300smode) + h8_set_exr (sd, (trace<<7) | intMask); + + h8_set_mask (sd, oldmask); signal (SIGINT, prev); } @@ -2400,7 +4514,9 @@ int sim_trace (SIM_DESC sd) { /* FIXME: Unfinished. */ - abort (); + (*sim_callback->printf_filtered) (sim_callback, + "sim_trace: trace not supported.\n"); + return 1; /* Done. */ } int @@ -2408,18 +4524,20 @@ sim_write (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size) { int i; - init_pointers (); + init_pointers (sd); if (addr < 0) return 0; for (i = 0; i < size; i++) { if (addr < memory_size) { - cpu.memory[addr + i] = buffer[i]; - cpu.cache_idx[addr + i] = 0; + h8_set_memory (sd, addr + i, buffer[i]); + h8_set_cache_idx (sd, addr + i, 0); } else - cpu.eightbit[(addr + i) & 0xff] = buffer[i]; + { + h8_set_eightbit (sd, (addr + i) & 0xff, buffer[i]); + } } return size; } @@ -2427,13 +4545,13 @@ sim_write (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size) int sim_read (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size) { - init_pointers (); + init_pointers (sd); if (addr < 0) return 0; if (addr < memory_size) - memcpy (buffer, cpu.memory + addr, size); + memcpy (buffer, h8_get_memory_buf (sd) + addr, size); else - memcpy (buffer, cpu.eightbit + (addr & 0xff), size); + memcpy (buffer, h8_get_eightbit_buf (sd) + (addr & 0xff), size); return size; } @@ -2448,14 +4566,16 @@ sim_store_register (SIM_DESC sd, int rn, unsigned char *value, int length) shortval = (value[0] << 8) | (value[1]); intval = h8300hmode ? longval : shortval; - init_pointers (); + init_pointers (sd); switch (rn) { case PC_REGNUM: - cpu.pc = intval; + h8_set_pc (sd, intval); break; default: - abort (); + (*sim_callback->printf_filtered) (sim_callback, + "sim_store_register: bad regnum %d.\n", + rn); case R0_REGNUM: case R1_REGNUM: case R2_REGNUM: @@ -2464,24 +4584,24 @@ sim_store_register (SIM_DESC sd, int rn, unsigned char *value, int length) case R5_REGNUM: case R6_REGNUM: case R7_REGNUM: - cpu.regs[rn] = intval; + h8_set_reg (sd, rn, intval); break; case CCR_REGNUM: - cpu.ccr = intval; + h8_set_ccr (sd, intval); break; case EXR_REGNUM: - cpu.exr = intval; + h8_set_exr (sd, intval); break; case CYCLE_REGNUM: - cpu.cycles = longval; + h8_set_cycles (sd, longval); break; case INST_REGNUM: - cpu.insts = longval; + h8_set_insts (sd, longval); break; case TICK_REGNUM: - cpu.ticks = longval; + h8_set_ticks (sd, longval); break; } return -1; @@ -2493,22 +4613,26 @@ sim_fetch_register (SIM_DESC sd, int rn, unsigned char *buf, int length) int v; int longreg = 0; - init_pointers (); + init_pointers (sd); if (!h8300smode && rn >= EXR_REGNUM) rn++; switch (rn) { default: - abort (); + (*sim_callback->printf_filtered) (sim_callback, + "sim_fetch_register: bad regnum %d.\n", + rn); + v = 0; + break; case CCR_REGNUM: - v = cpu.ccr; + v = h8_get_ccr (sd); break; case EXR_REGNUM: - v = cpu.exr; + v = h8_get_exr (sd); break; case PC_REGNUM: - v = cpu.pc; + v = h8_get_pc (sd); break; case R0_REGNUM: case R1_REGNUM: @@ -2518,18 +4642,18 @@ sim_fetch_register (SIM_DESC sd, int rn, unsigned char *buf, int length) case R5_REGNUM: case R6_REGNUM: case R7_REGNUM: - v = cpu.regs[rn]; + v = h8_get_reg (sd, rn); break; case CYCLE_REGNUM: - v = cpu.cycles; + v = h8_get_cycles (sd); longreg = 1; break; case TICK_REGNUM: - v = cpu.ticks; + v = h8_get_ticks (sd); longreg = 1; break; case INST_REGNUM: - v = cpu.insts; + v = h8_get_insts (sd); longreg = 1; break; } @@ -2551,19 +4675,7 @@ sim_fetch_register (SIM_DESC sd, int rn, unsigned char *buf, int length) void sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc) { -#if 0 /* FIXME: This should work but we can't use it. - grep for SLEEP above. */ - switch (cpu.state) - { - case SIM_STATE_EXITED : *reason = sim_exited; break; - case SIM_STATE_SIGNALLED : *reason = sim_signalled; break; - case SIM_STATE_STOPPED : *reason = sim_stopped; break; - default : abort (); - } -#else - *reason = sim_stopped; -#endif - *sigrc = cpu.exception; + sim_engine_get_run_state (sd, reason, sigrc); } /* FIXME: Rename to sim_set_mem_size. */ @@ -2574,31 +4686,31 @@ sim_size (int n) /* Memory size is fixed. */ } -void -sim_set_simcache_size (int n) +static void +set_simcache_size (SIM_DESC sd, int n) { - if (cpu.cache) - free (cpu.cache); + if (sd->sim_cache) + free (sd->sim_cache); if (n < 2) n = 2; - cpu.cache = (decoded_inst *) malloc (sizeof (decoded_inst) * n); - memset (cpu.cache, 0, sizeof (decoded_inst) * n); - cpu.csize = n; + sd->sim_cache = (decoded_inst *) malloc (sizeof (decoded_inst) * n); + memset (sd->sim_cache, 0, sizeof (decoded_inst) * n); + sd->sim_cache_size = n; } void sim_info (SIM_DESC sd, int verbose) { - double timetaken = (double) cpu.ticks / (double) now_persec (); - double virttime = cpu.cycles / 10.0e6; + double timetaken = (double) h8_get_ticks (sd) / (double) now_persec (); + double virttime = h8_get_cycles (sd) / 10.0e6; (*sim_callback->printf_filtered) (sim_callback, "\n\n#instructions executed %10d\n", - cpu.insts); + h8_get_insts (sd)); (*sim_callback->printf_filtered) (sim_callback, "#cycles (v approximate) %10d\n", - cpu.cycles); + h8_get_cycles (sd)); (*sim_callback->printf_filtered) (sim_callback, "#real time taken %10.4f\n", timetaken); @@ -2611,10 +4723,10 @@ sim_info (SIM_DESC sd, int verbose) virttime / timetaken); (*sim_callback->printf_filtered) (sim_callback, "#compiles %10d\n", - cpu.compiles); + h8_get_compiles (sd)); (*sim_callback->printf_filtered) (sim_callback, "#cache size %10d\n", - cpu.csize); + sd->sim_cache_size); #ifdef ADEBUG /* This to be conditional on `what' (aka `verbose'), @@ -2624,9 +4736,9 @@ sim_info (SIM_DESC sd, int verbose) int i; for (i = 0; i < O_LAST; i++) { - if (cpu.stats[i]) - (*sim_callback->printf_filtered) (sim_callback, - "%d: %d\n", i, cpu.stats[i]); + if (h8_get_stats (sd, i)) + (*sim_callback->printf_filtered) (sim_callback, "%d: %d\n", + i, h8_get_stats (sd, i)); } } #endif @@ -2636,28 +4748,100 @@ sim_info (SIM_DESC sd, int verbose) FLAG is non-zero for the H8/300H. */ void -set_h8300h (int h_flag, int s_flag) +set_h8300h (int h_flag, int s_flag, int sx_flag) { /* FIXME: Much of the code in sim_load can be moved to sim_open. This function being replaced by a sim_open:ARGV configuration option. */ - h8300hmode = h_flag; - h8300smode = s_flag; + + h8300hmode = h_flag; + h8300smode = s_flag; + h8300sxmode = sx_flag; +} + +/* Cover function of sim_state_free to free the cpu buffers as well. */ + +static void +free_state (SIM_DESC sd) +{ + if (STATE_MODULES (sd) != NULL) + sim_module_uninstall (sd); + + /* Fixme: free buffers in _sim_cpu. */ + sim_state_free (sd); } SIM_DESC sim_open (SIM_OPEN_KIND kind, - struct host_callback_struct *ptr, + struct host_callback_struct *callback, struct bfd *abfd, char **argv) { + SIM_DESC sd; + sim_cpu *cpu; + + sd = sim_state_alloc (kind, callback); + sd->cpu = sim_cpu_alloc (sd, 0); + cpu = STATE_CPU (sd, 0); + SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); + sim_state_initialize (sd, cpu); + /* sim_cpu object is new, so some initialization is needed. */ + init_pointers_needed = 1; + + /* For compatibility (FIXME: is this right?). */ + current_alignment = NONSTRICT_ALIGNMENT; + current_target_byte_order = BIG_ENDIAN; + + if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK) + { + free_state (sd); + return 0; + } + + /* 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 print_filtered. */ + if (sim_parse_args (sd, argv) != SIM_RC_OK) + { + /* Uninstall the modules to avoid memory leaks, + file descriptor leaks, etc. */ + free_state (sd); + return 0; + } + + /* Check for/establish the a reference program image. */ + if (sim_analyze_program (sd, + (STATE_PROG_ARGV (sd) != NULL + ? *STATE_PROG_ARGV (sd) + : NULL), abfd) != SIM_RC_OK) + { + free_state (sd); + return 0; + } + + /* Establish any remaining configuration options. */ + if (sim_config (sd) != SIM_RC_OK) + { + free_state (sd); + return 0; + } + + if (sim_post_argv_init (sd) != SIM_RC_OK) + { + /* Uninstall the modules to avoid memory leaks, + file descriptor leaks, etc. */ + free_state (sd); + return 0; + } + + /* sim_hw_configure (sd); */ + /* FIXME: Much of the code in sim_load can be moved here. */ sim_kind = kind; myname = argv[0]; - sim_callback = ptr; - /* Fudge our descriptor. */ - return (SIM_DESC) 1; + sim_callback = callback; + return sd; } void @@ -2690,8 +4874,13 @@ sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty) if (bfd_check_format (prog_bfd, bfd_object)) { unsigned long mach = bfd_get_mach (prog_bfd); - set_h8300h (mach == bfd_mach_h8300h || mach == bfd_mach_h8300s, - mach == bfd_mach_h8300s); + + set_h8300h (mach == bfd_mach_h8300h || + mach == bfd_mach_h8300s || + mach == bfd_mach_h8300sx, + mach == bfd_mach_h8300s || + mach == bfd_mach_h8300sx, + mach == bfd_mach_h8300sx); } } @@ -2717,21 +4906,27 @@ sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty) else memory_size = H8300_MSIZE; - if (cpu.memory) - free (cpu.memory); - if (cpu.cache_idx) - free (cpu.cache_idx); - if (cpu.eightbit) - free (cpu.eightbit); + if (h8_get_memory_buf (sd)) + free (h8_get_memory_buf (sd)); + if (h8_get_cache_idx_buf (sd)) + free (h8_get_cache_idx_buf (sd)); + if (h8_get_eightbit_buf (sd)) + free (h8_get_eightbit_buf (sd)); - cpu.memory = (unsigned char *) calloc (sizeof (char), memory_size); - cpu.cache_idx = (unsigned short *) calloc (sizeof (short), memory_size); - cpu.eightbit = (unsigned char *) calloc (sizeof (char), 256); + h8_set_memory_buf (sd, (unsigned char *) + calloc (sizeof (char), memory_size)); + h8_set_cache_idx_buf (sd, (unsigned short *) + calloc (sizeof (short), memory_size)); + h8_set_eightbit_buf (sd, (unsigned char *) calloc (sizeof (char), 256)); /* `msize' must be a power of two. */ if ((memory_size & (memory_size - 1)) != 0) - abort (); - cpu.mask = memory_size - 1; + { + (*sim_callback->printf_filtered) (sim_callback, + "sim_load: bad memory size.\n"); + return SIM_RC_FAIL; + } + h8_set_mask (sd, memory_size - 1); if (sim_load_file (sd, myname, sim_callback, prog, prog_bfd, sim_kind == SIM_OPEN_DEBUG, @@ -2756,11 +4951,11 @@ sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char **argv, char **env) int i = 0; int len_arg = 0; int no_of_args = 0; - + if (abfd != NULL) - cpu.pc = bfd_get_start_address (abfd); + h8_set_pc (sd, bfd_get_start_address (abfd)); else - cpu.pc = 0; + h8_set_pc (sd, 0); /* Command Line support. */ if (argv != NULL) @@ -2770,18 +4965,15 @@ sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char **argv, char **env) continue; /* Allocating memory for the argv pointers. */ - ptr_command_line = (char **) malloc ((sizeof (char *)) - * (no_of_args + 1)); + h8_set_command_line (sd, (char **) malloc ((sizeof (char *)) + * (no_of_args + 1))); for (i = 0; i < no_of_args; i++) { - /* Calculating the length of argument for allocating memory. */ - len_arg = strlen (argv[i] + 1); - ptr_command_line[i] = (char *) malloc (sizeof (char) * len_arg); /* Copying the argument string. */ - ptr_command_line[i] = (char *) strdup (argv[i]); + h8_set_cmdline_arg (sd, i, (char *) strdup (argv[i])); } - ptr_command_line[i] = NULL; + h8_set_cmdline_arg (sd, i, NULL); } return SIM_RC_OK; diff --git a/sim/h8300/sim-main.h b/sim/h8300/sim-main.h new file mode 100644 index 00000000000..11fc3204759 --- /dev/null +++ b/sim/h8300/sim-main.h @@ -0,0 +1,170 @@ +/* Main header for the Hitachi h8/300 architecture. */ + +#include "bfd.h" + +#ifndef SIM_MAIN_H +#define SIM_MAIN_H + +#define DEBUG + +/* These define the size of main memory for the simulator. + + Note the size of main memory for the H8/300H is only 256k. Keeping it + small makes the simulator run much faster and consume less memory. + + The linker knows about the limited size of the simulator's main memory + on the H8/300H (via the h8300h.sc linker script). So if you change + H8300H_MSIZE, be sure to fix the linker script too. + + Also note that there's a separate "eightbit" area aside from main + memory. For simplicity, the simulator assumes any data memory reference + outside of main memory refers to the eightbit area (in theory, this + can only happen when simulating H8/300H programs). We make no attempt + to catch overlapping addresses, wrapped addresses, etc etc. */ + +#define H8300_MSIZE (1 << 16) + +/* avolkov: + Next 2 macros are ugly for any workstation, but while they're work. + Memory size MUST be configurable. */ +#define H8300H_MSIZE (1 << 18) +#define H8300S_MSIZE (1 << 24) + +#define CSIZE 1024 + +enum h8_regnum { + R0_REGNUM = 0, + R1_REGNUM = 1, + R2_REGNUM = 2, + R3_REGNUM = 3, + R4_REGNUM = 4, + R5_REGNUM = 5, + R6_REGNUM = 6, + R7_REGNUM = 7, + + SP_REGNUM = R7_REGNUM, /* Contains address of top of stack */ + FP_REGNUM = R6_REGNUM, /* Contains address of executing + stack frame */ + CCR_REGNUM = 8, /* Contains processor status */ + PC_REGNUM = 9, /* Contains program counter */ + CYCLE_REGNUM = 10, + EXR_REGNUM = 11, + INST_REGNUM = 12, + TICK_REGNUM = 13, + SBR_REGNUM = 14, + VBR_REGNUM = 15, + MACH_REGNUM = 16, + MACL_REGNUM = 17, + + ZERO_REGNUM = 18 +}; + +enum h8_typecodes { + OP_NULL, + OP_REG, /* Register direct. */ + OP_LOWREG, /* Special reg syntax for "bra". */ + OP_DISP, /* Register indirect w/displacement. */ + /* Note: h8300, h8300h, and h8300s permit only pre-decr and post-incr. */ + OP_PREDEC, /* Register indirect w/pre-decrement. */ + OP_POSTDEC, /* Register indirect w/post-decrement. */ + OP_PREINC, /* Register indirect w/pre-increment. */ + OP_POSTINC, /* Register indirect w/post-increment. */ + OP_PCREL, /* PC Relative. */ + OP_MEM, /* Absolute memory address. */ + OP_CCR, /* Condition Code Register. */ + OP_IMM, /* Immediate value. */ + /*OP_ABS*/ /* Un-used (duplicates op_mem?). */ + OP_EXR, /* EXtended control Register. */ + OP_SBR, /* Vector Base Register. */ + OP_VBR, /* Short-address Base Register. */ + OP_MACH, /* Multiply Accumulator - high. */ + OP_MACL, /* Multiply Accumulator - low. */ + /* FIXME: memory indirect? */ + OP_INDEXB, /* Byte index mode */ + OP_INDEXW, /* Word index mode */ + OP_INDEXL /* Long index mode */ +}; + +#include "sim-basics.h" + +/* Define sim_cia. */ +typedef unsigned32 sim_cia; + +#include "sim-base.h" + +/* Structure used to describe addressing */ + +typedef struct +{ + int type; + int reg; + int literal; +} ea_type; + +/* Struct for instruction decoder. */ +typedef struct +{ + ea_type src; + ea_type dst; + ea_type op3; + int opcode; + int next_pc; + int oldpc; + int cycles; +#ifdef DEBUG + struct h8_opcode *op; +#endif +} decoded_inst; + +struct _sim_cpu { + unsigned int regs[20]; /* 8 GR's plus ZERO, SBR, and VBR. */ + unsigned int pc; + + int macS; /* MAC Saturating mode */ + int macV; /* MAC Overflow */ + int macN; /* MAC Negative */ + int macZ; /* MAC Zero */ + + int delayed_branch; + char **command_line; /* Pointer to command line arguments. */ + + unsigned char *memory; + unsigned char *eightbit; + int mask; + + sim_cpu_base base; +}; + +/* The sim_state struct. */ +struct sim_state { + struct _sim_cpu *cpu; + unsigned int sim_cache_size; + decoded_inst *sim_cache; + unsigned short *cache_idx; + unsigned long memory_size; + int cache_top; + int compiles; +#ifdef ADEBUG + int stats[O_LAST]; +#endif + sim_state_base base; +}; + +/* The current state of the processor; registers, memory, etc. */ + +#define CIA_GET(CPU) (cpu_get_pc (CPU)) +#define CIA_SET(CPU, VAL) (cpu_set_pc ((CPU), (VAL))) +#define STATE_CPU(SD, N) ((SD)->cpu) /* Single Processor. */ +#define cpu_set_pc(CPU, VAL) (((CPU)->pc) = (VAL)) +#define cpu_get_pc(CPU) (((CPU)->pc)) + +/* Magic numbers used to distinguish an exit from a breakpoint. */ +#define LIBC_EXIT_MAGIC1 0xdead +#define LIBC_EXIT_MAGIC2 0xbeef +/* Local version of macros for decoding exit status. + (included here rather than try to find target version of wait.h) +*/ +#define SIM_WIFEXITED(V) (((V) & 0xff) == 0) +#define SIM_WEXITSTATUS(V) ((V) >> 8) + +#endif /* SIM_MAIN_H */ -- cgit v1.2.1