URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [sim/] [h8300/] [compile.c] - Rev 834
Go to most recent revision | Compare with Previous | Blame | View Log
/* * Simulator for the Renesas (formerly Hitachi) H8/300 architecture. * * Written by Steve Chamberlain of Cygnus Support. sac@cygnus.com * * This file is part of H8/300 sim * * * THIS SOFTWARE IS NOT COPYRIGHTED * * Cygnus offers the following for use in the public domain. Cygnus makes no * warranty with regard to the software or its performance and the user * accepts the software "AS IS" with all faults. * * CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS * SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. */ #include <signal.h> #ifdef HAVE_TIME_H #include <time.h> #endif #ifdef HAVE_STDLIB_H #include <stdlib.h> #endif #ifdef HAVE_SYS_PARAM_H #include <sys/param.h> #endif #include "bfd.h" #include "sim-main.h" #include "gdb/sim-h8300.h" #include "sys/stat.h" #include "sys/types.h" #ifndef SIGTRAP # define SIGTRAP 5 #endif int debug; host_callback *sim_callback; static SIM_OPEN_KIND sim_kind; static char *myname; /* FIXME: Needs to live in header file. 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. */ static void set_simcache_size (SIM_DESC, int); #define X(op, size) (op * 4 + size) #define SP (h8300hmode && !h8300_normal_mode ? SL : SW) #define h8_opcodes ops #define DEFINE_TABLE #include "opcode/h8300.h" /* CPU data object: */ 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; } static unsigned int h8_get_pc (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> pc; } static void h8_set_pc (SIM_DESC sd, unsigned int val) { (STATE_CPU (sd, 0)) -> pc = val; } static unsigned int h8_get_ccr (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> regs[CCR_REGNUM]; } static void h8_set_ccr (SIM_DESC sd, unsigned int val) { (STATE_CPU (sd, 0)) -> regs[CCR_REGNUM] = val; } static unsigned int h8_get_exr (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> regs[EXR_REGNUM]; } static void h8_set_exr (SIM_DESC sd, unsigned int val) { (STATE_CPU (sd, 0)) -> regs[EXR_REGNUM] = val; } static int h8_get_sbr (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> regs[SBR_REGNUM]; } static void h8_set_sbr (SIM_DESC sd, int val) { (STATE_CPU (sd, 0)) -> regs[SBR_REGNUM] = val; } static int h8_get_vbr (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> regs[VBR_REGNUM]; } static void h8_set_vbr (SIM_DESC sd, int val) { (STATE_CPU (sd, 0)) -> regs[VBR_REGNUM] = val; } static int h8_get_cache_top (SIM_DESC sd) { return sd -> cache_top; } static void h8_set_cache_top (SIM_DESC sd, int val) { sd -> cache_top = val; } static int h8_get_mask (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> mask; } static void h8_set_mask (SIM_DESC sd, int val) { (STATE_CPU (sd, 0)) -> mask = val; } #if 0 static int h8_get_exception (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> exception; } static void h8_set_exception (SIM_DESC sd, int val) { (STATE_CPU (sd, 0)) -> exception = val; } static enum h8300_sim_state h8_get_state (SIM_DESC sd) { return sd -> state; } static void h8_set_state (SIM_DESC sd, enum h8300_sim_state val) { 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 h8_get_insts (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> regs[INST_REGNUM]; } static void h8_set_insts (SIM_DESC sd, unsigned int val) { (STATE_CPU (sd, 0)) -> regs[INST_REGNUM] = val; } static unsigned int h8_get_ticks (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> regs[TICK_REGNUM]; } static void h8_set_ticks (SIM_DESC sd, unsigned int val) { (STATE_CPU (sd, 0)) -> regs[TICK_REGNUM] = val; } static unsigned int h8_get_mach (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> regs[MACH_REGNUM]; } static void h8_set_mach (SIM_DESC sd, unsigned int val) { (STATE_CPU (sd, 0)) -> regs[MACH_REGNUM] = val; } static unsigned int h8_get_macl (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> regs[MACL_REGNUM]; } static void h8_set_macl (SIM_DESC sd, unsigned int val) { (STATE_CPU (sd, 0)) -> regs[MACL_REGNUM] = val; } static int h8_get_compiles (SIM_DESC sd) { return sd -> compiles; } static void h8_increment_compiles (SIM_DESC sd) { sd -> compiles ++; } static unsigned int * h8_get_reg_buf (SIM_DESC sd) { return &(((STATE_CPU (sd, 0)) -> regs)[0]); } static unsigned int h8_get_reg (SIM_DESC sd, int regnum) { return (STATE_CPU (sd, 0)) -> regs[regnum]; } static void h8_set_reg (SIM_DESC sd, int regnum, int val) { (STATE_CPU (sd, 0)) -> regs[regnum] = val; } #ifdef ADEBUG static int h8_get_stats (SIM_DESC sd, int idx) { return sd -> stats[idx]; } static void h8_increment_stats (SIM_DESC sd, int idx) { sd -> stats[idx] ++; } #endif /* ADEBUG */ static unsigned short * h8_get_cache_idx_buf (SIM_DESC sd) { return sd -> cache_idx; } static void h8_set_cache_idx_buf (SIM_DESC sd, unsigned short *ptr) { sd -> cache_idx = ptr; } 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]; } static void h8_set_cache_idx (SIM_DESC sd, int idx, unsigned int val) { sd -> cache_idx[idx] = (unsigned short) val; } static unsigned char * h8_get_memory_buf (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> memory; } static void h8_set_memory_buf (SIM_DESC sd, unsigned char *ptr) { (STATE_CPU (sd, 0)) -> memory = ptr; } static unsigned char h8_get_memory (SIM_DESC sd, int idx) { return (STATE_CPU (sd, 0)) -> memory[idx]; } static void h8_set_memory (SIM_DESC sd, int idx, unsigned int val) { (STATE_CPU (sd, 0)) -> memory[idx] = (unsigned char) val; } static unsigned char * h8_get_eightbit_buf (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> eightbit; } static void h8_set_eightbit_buf (SIM_DESC sd, unsigned char *ptr) { (STATE_CPU (sd, 0)) -> eightbit = ptr; } static unsigned char h8_get_eightbit (SIM_DESC sd, int idx) { return (STATE_CPU (sd, 0)) -> eightbit[idx]; } static void h8_set_eightbit (SIM_DESC sd, int idx, unsigned int val) { (STATE_CPU (sd, 0)) -> eightbit[idx] = (unsigned char) val; } static unsigned int h8_get_delayed_branch (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> delayed_branch; } static void h8_set_delayed_branch (SIM_DESC sd, unsigned int dest) { (STATE_CPU (sd, 0)) -> delayed_branch = dest; } static char ** h8_get_command_line (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> command_line; } static void h8_set_command_line (SIM_DESC sd, char ** val) { (STATE_CPU (sd, 0)) -> command_line = val; } static char * h8_get_cmdline_arg (SIM_DESC sd, int index) { return (STATE_CPU (sd, 0)) -> command_line[index]; } static void h8_set_cmdline_arg (SIM_DESC sd, int index, char * val) { (STATE_CPU (sd, 0)) -> command_line[index] = val; } /* 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); } /* MAC Zero Flag */ static int h8_get_macZ (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> macZ; } static void h8_set_macZ (SIM_DESC sd, int val) { (STATE_CPU (sd, 0)) -> macZ = (val != 0); } /* MAC Negative Flag */ static int h8_get_macN (SIM_DESC sd) { return (STATE_CPU (sd, 0)) -> macN; } static void h8_set_macN (SIM_DESC sd, int val) { (STATE_CPU (sd, 0)) -> macN = (val != 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); } /* End CPU data object. */ /* The rate at which to call the host's poll_quit callback. */ enum { POLL_QUIT_INTERVAL = 0x80000 }; #define LOW_BYTE(x) ((x) & 0xff) #define HIGH_BYTE(x) (((x) >> 8) & 0xff) #define P(X, Y) ((X << 8) | Y) #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) #define BUILDSR(SD) \ h8_set_ccr (SD, (I << 7) | (UI << 6) | (H << 5) | (U << 4) \ | (N << 3) | (Z << 2) | (V << 1) | C) #define GETSR(SD) \ /* 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 #ifdef __CHAR_IS_SIGNED__ #define SEXTCHAR(x) ((char) (x)) #endif #ifndef SEXTCHAR #define SEXTCHAR(x) ((x & 0x80) ? (x | ~0xff) : x & 0xff) #endif #define UEXTCHAR(x) ((x) & 0xff) #define UEXTSHORT(x) ((x) & 0xffff) #define SEXTSHORT(x) ((short) (x)) int h8300hmode = 0; int h8300smode = 0; int h8300_normal_mode = 0; int h8300sxmode = 0; static int memory_size; static int get_now (void) { return time (0); /* WinXX HAS UNIX like 'time', so why not use it? */ } 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 && !h8300_normal_mode)? SL : SW; } return 0; } /* Simulate an indirection / dereference. return 0 for success, -1 for failure. */ static unsigned int lvalue (SIM_DESC sd, int x, int rn, unsigned int *val) { if (val == NULL) /* Paranoia. */ return -1; switch (x / 4) { case OP_DISP: if (rn == ZERO_REGNUM) *val = X (OP_IMM, SP); else *val = X (OP_REG, SP); break; case OP_MEM: *val = X (OP_MEM, SP); break; default: sim_engine_set_run_state (sd, sim_stopped, SIGSEGV); return -1; } return 0; } static int cmdline_location() { if (h8300smode && !h8300_normal_mode) return 0xffff00L; else if (h8300hmode && !h8300_normal_mode) return 0x2ff00L; else return 0xff00L; } static void decode (SIM_DESC sd, int addr, unsigned char *data, decoded_inst *dst) { 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; dst->dst.type = -1; dst->src.type = -1; /* Find the exact opcode/arg combo. */ for (q = h8_opcodes; q->name; q++) { const op_type *nib = q->data.nib; unsigned int len = 0; if ((q->available == AV_H8SX && !h8300sxmode) || (q->available == AV_H8S && !h8300smode) || (q->available == AV_H8H && !h8300hmode)) continue; cst[0] = cst[1] = cst[2] = 0; reg[0] = reg[1] = reg[2] = 0; rdisp[0] = rdisp[1] = rdisp[2] = 0; while (1) { op_type looking_for = *nib; int thisnib = data[len / 2]; 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 (looking_for != thisnib) goto fail; } else { if (looking_for & B31) { if (!((thisnib & 0x8) != 0)) goto fail; looking_for = (op_type) (looking_for & ~B31); thisnib &= 0x7; } else if (looking_for & B30) { if (!((thisnib & 0x8) == 0)) goto fail; looking_for = (op_type) (looking_for & ~B30); } if (looking_for & B21) { if (!((thisnib & 0x4) != 0)) goto fail; looking_for = (op_type) (looking_for & ~B21); thisnib &= 0xb; } else if (looking_for & B20) { if (!((thisnib & 0x4) == 0)) goto fail; looking_for = (op_type) (looking_for & ~B20); } if (looking_for & B11) { if (!((thisnib & 0x2) != 0)) goto fail; looking_for = (op_type) (looking_for & ~B11); thisnib &= 0xd; } else if (looking_for & B10) { if (!((thisnib & 0x2) == 0)) goto fail; looking_for = (op_type) (looking_for & ~B10); } if (looking_for & B01) { if (!((thisnib & 0x1) != 0)) goto fail; looking_for = (op_type) (looking_for & ~B01); thisnib &= 0xe; } else if (looking_for & B00) { if (!((thisnib & 0x1) == 0)) goto fail; looking_for = (op_type) (looking_for & ~B00); } 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; 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; 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) { switch (looking_for & SIZE) { case L_2: cst[opnum] = thisnib & 3; 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]; /* Immediates are always unsigned. */ if ((looking_for & SIZE) != L_16U && (looking_for & MODE) != IMM) 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 & MODE) == VECIND) { if(h8300_normal_mode) cst[opnum] = ((data[1] & 0x7f) + 0x80) * 2; else cst[opnum] = ((data[1] & 0x7f) + 0x80) * 4; cst[opnum] += h8_get_vbr (sd); /* Add vector base reg. */ } else if ((looking_for & SIZE) == L_32) { int i = len / 2; 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; 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_2) { cst[opnum] = thisnib & 3; } 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. */ { const op_type *args = q->args.nib; int hadone = 0; int nargs; for (nargs = 0; nargs < 3 && *args != E; nargs++) { int x = *args; ea_type *p; 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 ((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, (unsigned int *)&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 || (x & MODE) == VECIND) { /* 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, (unsigned int *)&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) { p->type = X (OP_INDEXB, OP_SIZE (q->how)); p->literal = cst[opnum]; p->reg = rdisp[opnum]; } else if ((x & MODE) == INDEXW) { p->type = X (OP_INDEXW, OP_SIZE (q->how)); p->literal = cst[opnum]; p->reg = rdisp[opnum]; } else if ((x & MODE) == INDEXL) { p->type = X (OP_INDEXL, OP_SIZE (q->how)); p->literal = cst[opnum]; p->reg = rdisp[opnum]; } else if ((x & MODE) == DISP) { /* Yuck -- special for mova args. */ if (strncmp (q->name, "mova", 4) == 0 && (x & SIZE) == L_2) { /* Mova can have a DISP2 dest, with an INDEXB or INDEXW src. The multiplier for the displacement value is determined by the src operand, not by the insn. */ switch (OP_KIND (dst->src.type)) { case OP_INDEXB: p->type = X (OP_DISP, SB); p->literal = cst[opnum]; break; case OP_INDEXW: p->type = X (OP_DISP, SW); p->literal = cst[opnum] * 2; break; default: goto fail; } } else { p->type = X (OP_DISP, OP_SIZE (q->how)); p->literal = cst[opnum]; /* DISP2 is special. */ if ((x & SIZE) == L_2) switch (OP_SIZE (q->how)) { case SB: break; case SW: p->literal *= 2; break; case SL: p->literal *= 4; break; } } 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 0x%x...\n", x); args++; } } /* 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; /* And jsr's to these locations are turned into magic traps. */ 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 0x%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) { idx = 1; } h8_set_cache_top (sd, idx); /* 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); /* Point to new cache entry. */ h8_set_cache_idx (sd, pc, idx); } 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)))) /* Simulate a memory fetch. Return 0 for success, -1 for failure. */ 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); r = GET_MEMORY_B (t & h8_get_mask (sd)); if (!twice) t += 1; SET_L_REG (rn, t); *val = r; break; case X (OP_POSTINC, SW): /* Register indirect w/post-incr: word. */ t = GET_L_REG (rn); r = GET_MEMORY_W (t & h8_get_mask (sd)); if (!twice) t += 2; SET_L_REG (rn, t); *val = r; break; case X (OP_POSTINC, SL): /* Register indirect w/post-incr: long. */ t = GET_L_REG (rn); r = GET_MEMORY_L (t & h8_get_mask (sd)); if (!twice) t += 4; SET_L_REG (rn, t); *val = r; break; case X (OP_POSTDEC, SB): /* Register indirect w/post-decr: byte. */ t = GET_L_REG (rn); r = GET_MEMORY_B (t & h8_get_mask (sd)); if (!twice) t -= 1; SET_L_REG (rn, t); *val = r; break; case X (OP_POSTDEC, SW): /* Register indirect w/post-decr: word. */ t = GET_L_REG (rn); r = GET_MEMORY_W (t & h8_get_mask (sd)); if (!twice) t -= 2; SET_L_REG (rn, t); *val = r; break; case X (OP_POSTDEC, SL): /* Register indirect w/post-decr: long. */ t = GET_L_REG (rn); r = GET_MEMORY_L (t & h8_get_mask (sd)); if (!twice) t -= 4; 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; SET_L_REG (rn, t); t &= h8_get_mask (sd); *val = GET_MEMORY_B (t); break; case X (OP_PREDEC, SW): /* Register indirect w/pre-decr: word. */ t = GET_L_REG (rn) - 2; SET_L_REG (rn, t); t &= h8_get_mask (sd); *val = GET_MEMORY_W (t); break; case X (OP_PREDEC, SL): /* Register indirect w/pre-decr: long. */ t = GET_L_REG (rn) - 4; SET_L_REG (rn, t); t &= h8_get_mask (sd); *val = GET_MEMORY_L (t); break; case X (OP_PREINC, SB): /* Register indirect w/pre-incr: byte. */ t = GET_L_REG (rn) + 1; SET_L_REG (rn, t); t &= h8_get_mask (sd); *val = GET_MEMORY_B (t); break; case X (OP_PREINC, SW): /* Register indirect w/pre-incr: long. */ t = GET_L_REG (rn) + 2; SET_L_REG (rn, t); t &= h8_get_mask (sd); *val = GET_MEMORY_W (t); break; case X (OP_PREINC, SL): /* Register indirect w/pre-incr: long. */ t = GET_L_REG (rn) + 4; SET_L_REG (rn, t); t &= h8_get_mask (sd); *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; SET_L_REG (rn, t); t &= h8_get_mask (sd); 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; SET_L_REG (rn, t); t &= h8_get_mask (sd); 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; SET_L_REG (rn, t); t &= h8_get_mask (sd); 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; SET_L_REG (rn, t); t &= h8_get_mask (sd); 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; SET_L_REG (rn, t); t &= h8_get_mask (sd); 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; SET_L_REG (rn, t); t &= h8_get_mask (sd); SET_MEMORY_L (t, n); break; case X (OP_POSTDEC, SB): /* Register indirect w/post-decr, byte. */ t = GET_L_REG (rn); SET_L_REG (rn, t - 1); t &= h8_get_mask (sd); SET_MEMORY_B (t, n); break; case X (OP_POSTDEC, SW): /* Register indirect w/post-decr, word. */ t = GET_L_REG (rn); SET_L_REG (rn, t - 2); t &= h8_get_mask (sd); SET_MEMORY_W (t, n); break; case X (OP_POSTDEC, SL): /* Register indirect w/post-decr, long. */ t = GET_L_REG (rn); SET_L_REG (rn, t - 4); t &= h8_get_mask (sd); SET_MEMORY_L (t, n); break; case X (OP_POSTINC, SB): /* Register indirect w/post-incr, byte. */ t = GET_L_REG (rn); SET_L_REG (rn, t + 1); t &= h8_get_mask (sd); SET_MEMORY_B (t, n); break; case X (OP_POSTINC, SW): /* Register indirect w/post-incr, word. */ t = GET_L_REG (rn); SET_L_REG (rn, t + 2); t &= h8_get_mask (sd); SET_MEMORY_W (t, n); break; case X (OP_POSTINC, SL): /* Register indirect w/post-incr, long. */ t = GET_L_REG (rn); SET_L_REG (rn, t + 4); t &= h8_get_mask (sd); SET_MEMORY_L (t, n); 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 && !h8300_normal_mode) memory_size = H8300S_MSIZE; else if (h8300hmode && !h8300_normal_mode) 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 & 7); \ 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). */ GETSR (sd); if (h8300smode) /* Get exr. */ { trace = (h8_get_exr (sd) >> 7) & 1; intMask = h8_get_exr (sd) & 7; } oldmask = h8_get_mask (sd); if (!h8300hmode || h8300_normal_mode) 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). */ /* Alas, since this is the only instruction with 3 arguments, decode doesn't handle them very well. Some fix-up is required. a) The size of dst is determined by whether src is INDEXB or INDEXW. */ if (OP_KIND (code->src.type) == OP_INDEXB) code->dst.type = X (OP_KIND (code->dst.type), SB); else if (OP_KIND (code->src.type) == OP_INDEXW) code->dst.type = X (OP_KIND (code->dst.type), SW); /* b) If op3 == null, then this is the short form of the insn. Dst is the dispreg of src, and op3 is the 32-bit form of the same register. */ if (code->op3.type == 0) { /* Short form: src == INDEXB/INDEXW, dst == op3 == 0. We get to compose dst and op3 as follows: op3 is a 32-bit register, ID == src.reg. dst is the same register, but 8 or 16 bits depending on whether src is INDEXB or INDEXW. */ code->op3.type = X (OP_REG, SL); code->op3.reg = code->src.reg; code->op3.literal = 0; if (OP_KIND (code->src.type) == OP_INDEXB) { code->dst.type = X (OP_REG, SB); code->dst.reg = code->op3.reg + 8; } else code->dst.type = X (OP_REG, SW); } 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): /* movmd.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): /* movmd.w */ 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): /* movmd.l */ 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); rd = 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) && !h8300_normal_mode) { 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) && !h8300_normal_mode) { 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) && !h8300_normal_mode) { 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) && !h8300_normal_mode) { 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 && !h8300_normal_mode) ? GET_L_REG (0) : GET_W_REG (0); buf_size = (h8300hmode && !h8300_normal_mode) ? 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 && !h8300_normal_mode) ? GET_L_REG (0) : GET_W_REG (0); char_ptr = (h8300hmode && !h8300_normal_mode) ? GET_L_REG (1) : GET_W_REG (1); len = (h8300hmode && !h8300_normal_mode) ? 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 && !h8300_normal_mode) ? GET_L_REG (0) : GET_W_REG (0); offset = (h8300hmode && !h8300_normal_mode) ? GET_L_REG (1) : GET_W_REG (1); origin = (h8300hmode && !h8300_normal_mode) ? GET_L_REG (2) : GET_W_REG (2); /* Callback lseek and return offset. */ lseek_return = sim_callback->lseek (sim_callback, fd, offset, origin); /* 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. */ fd = (h8300hmode && !h8300_normal_mode) ? GET_L_REG (0) : GET_W_REG (0); /* Callback close and return. */ close_return = sim_callback->close (sim_callback, fd); /* Return value in register 0. */ h8_set_reg (sd, 0, close_return); } 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. */ fd = (h8300hmode && !h8300_normal_mode) ? GET_L_REG (0) : GET_W_REG (0); /* Setting stat_ptr to second argument of stat. */ stat_ptr = (h8300hmode && !h8300_normal_mode) ? GET_L_REG (1) : GET_W_REG (1); /* Callback stat and return. */ fstat_return = sim_callback->fstat (sim_callback, fd, &stat_rec); /* Have stat_ptr point to starting of stat_rec. */ temp_stat_ptr = (char *) (&stat_rec); /* 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_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 && !h8300_normal_mode) ? GET_L_REG (0) : GET_W_REG (0); /* 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; } /* Setting stat_ptr to second argument of stat. */ /* stat_ptr = h8_get_reg (sd, 1); */ stat_ptr = (h8300hmode && !h8300_normal_mode) ? GET_L_REG (1) : GET_W_REG (1); /* Callback stat and return. */ stat_return = sim_callback->stat (sim_callback, filename, &stat_rec); /* 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_NOT, SB): /* not.b */ if (fetch2 (sd, &code->src, &rd)) goto end; rd = ~rd; v = 0; goto shift8; 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_SHLL, SB): /* shll.b */ case O (O_SHLR, SB): /* shlr.b */ if (fetch2 (sd, &code->dst, &rd)) goto end; if (memcmp (&code->src, &code->dst, sizeof (code->src)) == 0) ea = 1; /* unary op */ else /* binary op */ fetch (sd, &code->src, &ea); 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; if (memcmp (&code->src, &code->dst, sizeof (code->src)) == 0) ea = 1; /* unary op */ else fetch (sd, &code->src, &ea); 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_SHLL, SL): /* shll.l */ case O (O_SHLR, SL): /* shlr.l */ if (fetch2 (sd, &code->dst, &rd)) goto end; if (memcmp (&code->src, &code->dst, sizeof (code->src)) == 0) ea = 1; /* unary op */ else fetch (sd, &code->src, &ea); if (code->opcode == O (O_SHLL, SL)) { v = (ea > 32); c = rd & (0x80000000 >> (ea - 1)); rd <<= ea; } else { 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 ea = 1; if (code->opcode == O (O_SHAL, SB)) { c = rd & (0x80 >> (ea - 1)); res = rd >> (7 - ea); v = ((res & 1) && !(res & 2)) || (!(res & 1) && (res & 2)); rd <<= ea; } else { 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 ea = 1; if (code->opcode == O (O_SHAL, SW)) { c = rd & (0x8000 >> (ea - 1)); res = rd >> (15 - ea); v = ((res & 1) && !(res & 2)) || (!(res & 1) && (res & 2)); rd <<= ea; } else { c = rd & (1 << (ea - 1)); v = 0; rd = ((signed short) rd) >> ea; } 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; if (code->opcode == O (O_SHAL, SL)) { c = rd & (0x80000000 >> (ea - 1)); res = rd >> (31 - ea); v = ((res & 1) && !(res & 2)) || (!(res & 1) && (res & 2)); rd <<= ea; } else { c = rd & (1 << (ea - 1)); v = 0; rd = ((signed int) rd) >> ea; } goto shift32; case O (O_ROTL, SB): case O (O_ROTR, SB): if (fetch2 (sd, &code->dst, &rd)) goto end; if (code->src.type == X (OP_IMM, SB)) fetch (sd, &code->src, &ea); else ea = 1; 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_ROTL, SW): case O (O_ROTR, SW): if (fetch2 (sd, &code->dst, &rd)) goto end; if (code->src.type == X (OP_IMM, SW)) fetch (sd, &code->src, &ea); else ea = 1; 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; } v = 0; goto shift16; case O (O_ROTL, SL): case O (O_ROTR, 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; 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; } v = 0; goto shift32; case O (O_ROTXL, SB): case O (O_ROTXR, SB): if (fetch2 (sd, &code->dst, &rd)) goto end; if (code->src.type == X (OP_IMM, SB)) fetch (sd, &code->src, &ea); else ea = 1; 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; } v = 0; goto shift8; case O (O_ROTXL, SW): case O (O_ROTXR, SW): if (fetch2 (sd, &code->dst, &rd)) goto end; if (code->src.type == X (OP_IMM, SW)) fetch (sd, &code->src, &ea); else ea = 1; while (ea--) if (code->opcode == O (O_ROTXL, SW)) { res = rd & 0x8000; rd <<= 1; if (C) rd |= 1; c = res; } else { res = rd & 1; rd = ((unsigned short) rd) >> 1; if (C) rd |= 0x8000; c = res; } v = 0; goto shift16; case O (O_ROTXL, SL): case O (O_ROTXR, 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; 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; } v = 0; goto shift32; 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; case O (O_JSR, SN): case O (O_JSR, SL): case O (O_JSR, SB): /* jsr, jump to subroutine */ case O (O_JSR, SW): if (fetch (sd, &code->src, &pc)) goto end; call: tmp = h8_get_reg (sd, SP_REGNUM); if (h8300hmode && !h8300_normal_mode) { tmp -= 4; SET_MEMORY_L (tmp, code->next_pc); } else { tmp -= 2; SET_MEMORY_W (tmp, code->next_pc); } h8_set_reg (sd, SP_REGNUM, tmp); 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_RTE, SN): /* rte, return from exception */ rte: /* Pops exr and ccr before pc -- otherwise identical to rts. */ tmp = h8_get_reg (sd, SP_REGNUM); if (h8300smode) /* pop exr */ { h8_set_exr (sd, GET_MEMORY_L (tmp)); tmp += 4; } if (h8300hmode && !h8300_normal_mode) { h8_set_ccr (sd, GET_MEMORY_L (tmp)); tmp += 4; pc = GET_MEMORY_L (tmp); tmp += 4; } else { h8_set_ccr (sd, GET_MEMORY_W (tmp)); tmp += 2; pc = GET_MEMORY_W (tmp); tmp += 2; } GETSR (sd); h8_set_reg (sd, SP_REGNUM, tmp); goto end; case O (O_RTS, SN): /* rts, return from subroutine */ rts: tmp = h8_get_reg (sd, SP_REGNUM); if (h8300hmode && !h8300_normal_mode) { pc = GET_MEMORY_L (tmp); tmp += 4; } else { pc = GET_MEMORY_W (tmp); tmp += 2; } h8_set_reg (sd, SP_REGNUM, tmp); goto end; 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))); } #if 0 /* Unfortunately this won't really work, because when we take a breakpoint trap, R0 has a "random", user-defined value. Don't see any immediate solution. */ else if (SIM_WIFSTOPPED (h8_get_reg (sd, 0))) { /* Pass the stop signal up to gdb. */ sim_engine_set_run_state (sd, sim_stopped, SIM_WSTOPSIG (h8_get_reg (sd, 0))); } #endif else { /* Treat it as a sigtrap. */ sim_engine_set_run_state (sd, sim_stopped, SIGTRAP); } goto end; case O (O_TRAPA, SB): /* trapa */ if (fetch (sd, &code->src, &res)) goto end; /* res is vector number. */ tmp = h8_get_reg (sd, SP_REGNUM); if(h8300_normal_mode) { tmp -= 2; SET_MEMORY_W (tmp, code->next_pc); tmp -= 2; SET_MEMORY_W (tmp, h8_get_ccr (sd)); } else { tmp -= 4; SET_MEMORY_L (tmp, code->next_pc); tmp -= 4; SET_MEMORY_L (tmp, h8_get_ccr (sd)); } intMaskBit = 1; BUILDSR (sd); if (h8300smode) { tmp -= 4; SET_MEMORY_L (tmp, h8_get_exr (sd)); } h8_set_reg (sd, SP_REGNUM, tmp); if(h8300_normal_mode) pc = GET_MEMORY_L (0x10 + res * 2); /* Vector addresses are 0x10,0x12,0x14 and 0x16 */ else pc = GET_MEMORY_L (0x20 + res * 4); goto end; case O (O_BPT, SN): sim_engine_set_run_state (sd, sim_stopped, SIGTRAP); goto end; case O (O_BSETEQ, SB): if (Z) goto bset; goto next; case O (O_BSETNE, SB): if (!Z) goto bset; goto next; case O (O_BCLREQ, SB): if (Z) goto bclr; goto next; case O (O_BCLRNE, SB): if (!Z) goto bclr; goto next; 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; if (bit != 0) { if (fetch (sd, &code->dst, &ea)) goto end; ea &= bit; while (!(bit & 1)) { ea >>= 1; bit >>= 1; } } if (store (sd, &code->op3, ea)) goto end; goto next; 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. */ if (fetch (sd, &code->dst, &bit)) /* imm8 */ goto end; if (bit == 0) /* noop -- nothing to do. */ goto next; if (fetch (sd, &code->src, &rd)) /* reg8 src */ goto end; if (fetch2 (sd, &code->op3, &ea)) /* ea dst */ goto end; /* Left-shift the register data into position. */ for (tmp = bit; !(tmp & 1); tmp >>= 1) rd <<= 1; /* Combine it with the neighboring bits. */ ea = (ea & ~bit) | (rd & bit); /* 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_LDMAC, SL): /* ldmac, 179 */ if (fetch (sd, &code->src, &rd)) goto end; 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; case O (O_MAC, SW): if (fetch (sd, &code->src, &rd) || fetch (sd, &code->dst, &res)) goto end; /* Ye gods, this is non-portable! However, the existing mul/div code is similar. */ res = SEXTSHORT (res) * SEXTSHORT (rd); if (h8_get_macS (sd)) /* Saturating mode */ { long long mac = h8_get_macl (sd); if (mac & 0x80000000) /* sign extend */ mac |= 0xffffffff00000000LL; 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_MULS, SW): /* muls.w */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; ea = SEXTSHORT (ea); res = SEXTSHORT (ea * SEXTSHORT (rd)); n = res & 0x8000; nz = res & 0xffff; if (store (sd, &code->dst, res)) goto end; goto next; case O (O_MULS, SL): /* muls.l */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; res = ea * rd; n = res & 0x80000000; nz = res & 0xffffffff; if (store (sd, &code->dst, res)) goto end; goto next; case O (O_MULSU, SL): /* muls/u.l */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; /* Compute upper 32 bits of the 64-bit result. */ res = (((long long) ea) * ((long long) rd)) >> 32; n = res & 0x80000000; nz = res & 0xffffffff; if (store (sd, &code->dst, res)) goto end; goto next; case O (O_MULU, SW): /* mulu.w */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; res = UEXTSHORT ((UEXTSHORT (ea) * UEXTSHORT (rd))); /* Don't set Z or N. */ if (store (sd, &code->dst, res)) goto end; goto next; case O (O_MULU, SL): /* mulu.l */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; res = ea * rd; /* Don't set Z or N. */ if (store (sd, &code->dst, res)) goto end; goto next; case O (O_MULUU, SL): /* mulu/u.l */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; /* Compute upper 32 bits of the 64-bit result. */ res = (((unsigned long long) (unsigned) ea) * ((unsigned long long) (unsigned) rd)) >> 32; /* Don't set Z or N. */ if (store (sd, &code->dst, res)) goto end; goto next; case O (O_MULXS, SB): /* mulxs.b */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; ea = SEXTCHAR (ea); res = ea * SEXTCHAR (rd); n = res & 0x8000; nz = res & 0xffff; if (store (sd, &code->dst, res)) goto end; goto next; case O (O_MULXS, SW): /* mulxs.w */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; ea = SEXTSHORT (ea); res = ea * SEXTSHORT (rd & 0xffff); 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; res = UEXTCHAR (ea) * UEXTCHAR (rd); if (store (sd, &code->dst, res)) goto end; goto next; case O (O_MULXU, SW): /* mulxu.w */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; res = UEXTSHORT (ea) * UEXTSHORT (rd); if (store (sd, &code->dst, res)) goto end; goto next; case O (O_TAS, SB): /* tas (test and set) */ if (!h8300sxmode) /* h8sx can use any register. */ switch (code->src.reg) { case R0_REGNUM: case R1_REGNUM: case R4_REGNUM: case R5_REGNUM: break; default: goto illegal; } 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, SW): /* divu.w */ if (fetch (sd, &code->src, &ea) || fetch (sd, &code->dst, &rd)) goto end; n = ea & 0x8000; nz = ea & 0xffff; if (ea) res = (unsigned) (UEXTSHORT (rd) / UEXTSHORT (ea)); else res = 0; if (store (sd, &code->dst, res)) goto end; goto next; 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; 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; 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 & 0xff) | (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); 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; 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 & 0xff) + ea; goto log16; 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 & 0xffff) + ea; goto log32; case O (O_EXTU, SW): /* extu.w, unsigned extend */ if (fetch2 (sd, &code->dst, &rd)) goto end; ea = 0; res = (rd & 0xff) + ea; goto log16; 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 & 0xffff) + ea; goto log32; case O (O_NOP, SN): /* nop */ goto next; case O (O_STM, SL): /* stm, store to memory */ { int nregs, firstreg, i; nregs = GET_MEMORY_B (pc + 1); nregs >>= 4; nregs &= 0xf; firstreg = code->src.reg; firstreg &= 0xf; for (i = firstreg; i <= firstreg + nregs; 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): /* ldm, load from memory */ case O (O_RTEL, SN): /* rte/l, ldm plus rte */ case O (O_RTSL, SN): /* rts/l, ldm plus rts */ { int nregs, firstreg, i; nregs = ((GET_MEMORY_B (pc + 1) >> 4) & 0xf); firstreg = code->dst.reg & 0xf; for (i = firstreg; i >= firstreg - nregs; i--) { 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); } } switch (code->opcode) { case O (O_RTEL, SN): goto rte; case O (O_RTSL, SN): goto rts; case O (O_LDM, SL): goto next; default: goto illegal; } case O (O_DAA, SB): /* Decimal Adjust Addition. This is for BCD arithmetic. */ res = GET_B_REG (code->src.reg); /* FIXME fetch? */ 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)) res = res + 0x6; /* Value added == 6. */ 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)) 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 && (1 <= (res >> 4) && (res >> 4) <= 2) && !h && (10 <= (res & 0xf) && (res & 0xf) <= 15)) res = res + 0x66; /* Value added == 66. */ else if (c && (1 <= (res >> 4) && (res >> 4) <= 3) && h && (0 <= (res & 0xf) && (res & 0xf) <= 3)) res = res + 0x66; /* Value added == 66. */ 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)) res = res; /* Value added == 0. */ 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)) res = res + 0xa0; /* Value added == 0xa0. */ 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: sim_engine_set_run_state (sd, sim_stopped, SIGILL); goto end; } (*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 == X (OP_CCR, SB) || code->dst.type == X (OP_CCR, SW)) { h8_set_ccr (sd, res); GETSR (sd); } else if (h8300smode && (code->dst.type == X (OP_EXR, SB) || code->dst.type == X (OP_EXR, SW))) { 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; goto next; condtrue: /* When a branch works */ 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 */ bitop: /* Set the flags after an 8 bit inc/dec operation */ just_flags_inc8: n = res & 0x80; nz = res & 0xff; v = (rd & 0x7f) == 0x7f; goto next; /* Set the flags after an 16 bit inc/dec operation */ just_flags_inc16: n = res & 0x8000; nz = res & 0xffff; v = (rd & 0x7fff) == 0x7fff; goto next; /* Set the flags after an 32 bit inc/dec operation */ just_flags_inc32: n = res & 0x80000000; nz = res & 0xffffffff; 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; 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; 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; if (store2 (sd, &code->dst, rd)) goto end; goto next; log32: if (store2 (sd, &code->dst, res)) goto end; just_flags_log32: /* flags after a 32bit logical operation */ n = res & 0x80000000; nz = res & 0xffffffff; v = 0; goto next; log16: if (store2 (sd, &code->dst, res)) goto end; just_flags_log16: /* flags after a 16bit logical operation */ n = res & 0x8000; nz = res & 0xffff; v = 0; goto next; log8: if (store2 (sd, &code->dst, res)) goto end; just_flags_log8: n = res & 0x80; nz = res & 0xff; v = 0; goto next; alu8: if (store2 (sd, &code->dst, res)) goto end; just_flags_alu8: n = res & 0x80; nz = res & 0xff; c = (res & 0x100); 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)); break; case O_NEG: v = (rd == 0x80); break; case O_DAA: case O_DAS: break; /* No effect on v flag. */ } goto next; alu16: if (store2 (sd, &code->dst, res)) goto end; just_flags_alu16: n = res & 0x8000; nz = res & 0xffff; c = (res & 0x10000); 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)); break; case O_NEG: v = (rd == 0x8000); break; } goto next; alu32: 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); break; case O_SUB: case O_SUBX: case O_CMP: v = ((rd & 0x80000000) != (-ea & 0x80000000) && (rd & 0x80000000) != (res & 0x80000000)); c = (unsigned) rd < (unsigned) -ea; break; case O_NEG: v = (rd == 0x80000000); c = res != 0; break; } goto next; next: if ((res = h8_get_delayed_branch (sd)) != 0) { pc = res; h8_set_delayed_branch (sd, 0); } else pc = code->next_pc; end: if (--poll_count < 0) { poll_count = POLL_QUIT_INTERVAL; if ((*sim_callback->poll_quit) != NULL && (*sim_callback->poll_quit) (sim_callback)) sim_engine_set_run_state (sd, sim_stopped, SIGINT); } sim_engine_get_run_state (sd, &reason, &sigrc); } while (reason == sim_running); 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); } int sim_trace (SIM_DESC sd) { /* FIXME: Unfinished. */ (*sim_callback->printf_filtered) (sim_callback, "sim_trace: trace not supported.\n"); return 1; /* Done. */ } int sim_write (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size) { int i; init_pointers (sd); if (addr < 0) return 0; for (i = 0; i < size; i++) { if (addr < memory_size) { h8_set_memory (sd, addr + i, buffer[i]); h8_set_cache_idx (sd, addr + i, 0); } else { h8_set_eightbit (sd, (addr + i) & 0xff, buffer[i]); } } return size; } int sim_read (SIM_DESC sd, SIM_ADDR addr, unsigned char *buffer, int size) { init_pointers (sd); if (addr < 0) return 0; if (addr < memory_size) memcpy (buffer, h8_get_memory_buf (sd) + addr, size); else memcpy (buffer, h8_get_eightbit_buf (sd) + (addr & 0xff), size); return size; } int sim_store_register (SIM_DESC sd, int rn, unsigned char *value, int length) { int longval; int shortval; int intval; longval = (value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3]; shortval = (value[0] << 8) | (value[1]); intval = h8300hmode ? longval : shortval; init_pointers (sd); switch (rn) { case PC_REGNUM: if(h8300_normal_mode) h8_set_pc (sd, shortval); /* PC for Normal mode is 2 bytes */ else h8_set_pc (sd, intval); break; default: (*sim_callback->printf_filtered) (sim_callback, "sim_store_register: bad regnum %d.\n", rn); case R0_REGNUM: case R1_REGNUM: case R2_REGNUM: case R3_REGNUM: case R4_REGNUM: case R5_REGNUM: case R6_REGNUM: case R7_REGNUM: h8_set_reg (sd, rn, intval); break; case CCR_REGNUM: h8_set_ccr (sd, intval); break; case EXR_REGNUM: h8_set_exr (sd, intval); break; case SBR_REGNUM: h8_set_sbr (sd, intval); break; case VBR_REGNUM: h8_set_vbr (sd, intval); break; case MACH_REGNUM: h8_set_mach (sd, intval); break; case MACL_REGNUM: h8_set_macl (sd, intval); break; case CYCLE_REGNUM: h8_set_cycles (sd, longval); break; case INST_REGNUM: h8_set_insts (sd, longval); break; case TICK_REGNUM: h8_set_ticks (sd, longval); break; } return -1; } int sim_fetch_register (SIM_DESC sd, int rn, unsigned char *buf, int length) { int v; int longreg = 0; init_pointers (sd); if (!h8300smode && rn >= EXR_REGNUM) rn++; switch (rn) { default: (*sim_callback->printf_filtered) (sim_callback, "sim_fetch_register: bad regnum %d.\n", rn); v = 0; break; case CCR_REGNUM: v = h8_get_ccr (sd); break; case EXR_REGNUM: v = h8_get_exr (sd); break; case PC_REGNUM: v = h8_get_pc (sd); break; case SBR_REGNUM: v = h8_get_sbr (sd); break; case VBR_REGNUM: v = h8_get_vbr (sd); break; case MACH_REGNUM: v = h8_get_mach (sd); break; case MACL_REGNUM: v = h8_get_macl (sd); break; case R0_REGNUM: case R1_REGNUM: case R2_REGNUM: case R3_REGNUM: case R4_REGNUM: case R5_REGNUM: case R6_REGNUM: case R7_REGNUM: v = h8_get_reg (sd, rn); break; case CYCLE_REGNUM: v = h8_get_cycles (sd); longreg = 1; break; case TICK_REGNUM: v = h8_get_ticks (sd); longreg = 1; break; case INST_REGNUM: v = h8_get_insts (sd); longreg = 1; break; } /* In Normal mode PC is 2 byte, but other registers are 4 byte */ if ((h8300hmode || longreg) && !(rn == PC_REGNUM && h8300_normal_mode)) { buf[0] = v >> 24; buf[1] = v >> 16; buf[2] = v >> 8; buf[3] = v >> 0; } else { buf[0] = v >> 8; buf[1] = v; } return -1; } void sim_stop_reason (SIM_DESC sd, enum sim_stop *reason, int *sigrc) { sim_engine_get_run_state (sd, reason, sigrc); } /* FIXME: Rename to sim_set_mem_size. */ void sim_size (int n) { /* Memory size is fixed. */ } static void set_simcache_size (SIM_DESC sd, int n) { if (sd->sim_cache) free (sd->sim_cache); if (n < 2) n = 2; 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) 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", h8_get_insts (sd)); (*sim_callback->printf_filtered) (sim_callback, "#cycles (v approximate) %10d\n", h8_get_cycles (sd)); (*sim_callback->printf_filtered) (sim_callback, "#real time taken %10.4f\n", timetaken); (*sim_callback->printf_filtered) (sim_callback, "#virtual time taken %10.4f\n", virttime); if (timetaken != 0.0) (*sim_callback->printf_filtered) (sim_callback, "#simulation ratio %10.4f\n", virttime / timetaken); (*sim_callback->printf_filtered) (sim_callback, "#compiles %10d\n", h8_get_compiles (sd)); (*sim_callback->printf_filtered) (sim_callback, "#cache size %10d\n", sd->sim_cache_size); #ifdef ADEBUG /* This to be conditional on `what' (aka `verbose'), however it was never passed as non-zero. */ if (1) { int i; for (i = 0; i < O_LAST; i++) { if (h8_get_stats (sd, i)) (*sim_callback->printf_filtered) (sim_callback, "%d: %d\n", i, h8_get_stats (sd, i)); } } #endif } /* Indicate whether the cpu is an H8/300 or H8/300H. FLAG is non-zero for the H8/300H. */ void set_h8300h (unsigned long machine) { /* 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 = h8300smode = h8300sxmode = h8300_normal_mode = 0; if (machine == bfd_mach_h8300sx || machine == bfd_mach_h8300sxn) h8300sxmode = 1; if (machine == bfd_mach_h8300s || machine == bfd_mach_h8300sn || h8300sxmode) h8300smode = 1; if (machine == bfd_mach_h8300h || machine == bfd_mach_h8300hn || h8300smode) h8300hmode = 1; if(machine == bfd_mach_h8300hn || machine == bfd_mach_h8300sn || machine == bfd_mach_h8300sxn) h8300_normal_mode = 1; } /* 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 *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 = callback; return sd; } void sim_close (SIM_DESC sd, int quitting) { /* Nothing to do. */ } /* Called by gdb to load a program into memory. */ SIM_RC sim_load (SIM_DESC sd, char *prog, bfd *abfd, int from_tty) { bfd *prog_bfd; /* FIXME: The code below that sets a specific variant of the H8/300 being simulated should be moved to sim_open(). */ /* See if the file is for the H8/300 or H8/300H. */ /* ??? This may not be the most efficient way. The z8k simulator does this via a different mechanism (INIT_EXTRA_SYMTAB_INFO). */ if (abfd != NULL) prog_bfd = abfd; else prog_bfd = bfd_openr (prog, NULL); if (prog_bfd != NULL) { /* Set the cpu type. We ignore failure from bfd_check_format and bfd_openr as sim_load_file checks too. */ if (bfd_check_format (prog_bfd, bfd_object)) { set_h8300h (bfd_get_mach (prog_bfd)); } } /* If we're using gdb attached to the simulator, then we have to reallocate memory for the simulator. When gdb first starts, it calls fetch_registers (among other functions), which in turn calls init_pointers, which allocates simulator memory. The problem is when we do that, we don't know whether we're debugging an H8/300 or H8/300H program. This is the first point at which we can make that determination, so we just reallocate memory now; this will also allow us to handle switching between H8/300 and H8/300H programs without exiting gdb. */ if (h8300smode && !h8300_normal_mode) memory_size = H8300S_MSIZE; else if (h8300hmode && !h8300_normal_mode) memory_size = H8300H_MSIZE; else memory_size = H8300_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)); /* `msize' must be a power of two. */ if ((memory_size & (memory_size - 1)) != 0) { (*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, 0, sim_write) == NULL) { /* Close the bfd if we opened it. */ if (abfd == NULL && prog_bfd != NULL) bfd_close (prog_bfd); return SIM_RC_FAIL; } /* Close the bfd if we opened it. */ if (abfd == NULL && prog_bfd != NULL) bfd_close (prog_bfd); return SIM_RC_OK; } SIM_RC 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) h8_set_pc (sd, bfd_get_start_address (abfd)); else h8_set_pc (sd, 0); /* Command Line support. */ if (argv != NULL) { /* Counting the no. of commandline arguments. */ for (no_of_args = 0; argv[no_of_args] != NULL; no_of_args++) continue; /* Allocating memory for the argv pointers. */ h8_set_command_line (sd, (char **) malloc ((sizeof (char *)) * (no_of_args + 1))); for (i = 0; i < no_of_args; i++) { /* Copying the argument string. */ h8_set_cmdline_arg (sd, i, (char *) strdup (argv[i])); } h8_set_cmdline_arg (sd, i, NULL); } return SIM_RC_OK; } void sim_do_command (SIM_DESC sd, char *cmd) { (*sim_callback->printf_filtered) (sim_callback, "This simulator does not accept any commands.\n"); } void sim_set_callbacks (struct host_callback_struct *ptr) { sim_callback = ptr; }
Go to most recent revision | Compare with Previous | Blame | View Log