X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=sim%2Fd10v%2Fsimops.c;h=cb0fa56c888fecfd709406cdcee7bc72e7d77797;hb=27842f65f27045c0f1d7885d4f34ac37625e645c;hp=b35a434135b07e03683d07d5a5a1621c74c151d0;hpb=2254cd90a9ce9460303b2585574b4bb219142bf4;p=deliverable%2Fbinutils-gdb.git diff --git a/sim/d10v/simops.c b/sim/d10v/simops.c index b35a434135..cb0fa56c88 100644 --- a/sim/d10v/simops.c +++ b/sim/d10v/simops.c @@ -1,12 +1,18 @@ +#include "config.h" + #include #include #include #include +#ifdef HAVE_UNISTD_H #include +#endif #include "d10v_sim.h" #include "simops.h" -#include "sys/syscall.h" +#include "targ-vals.h" + +extern char *strrchr (); enum op_types { OP_VOID, @@ -23,37 +29,129 @@ enum op_types { OP_FLAG, OP_FLAG_OUTPUT, OP_CONSTANT16, + OP_CONSTANT8, OP_CONSTANT3, OP_CONSTANT4, OP_MEMREF, OP_MEMREF2, + OP_MEMREF3, OP_POSTDEC, OP_POSTINC, - OP_PREDEC + OP_PREDEC, + OP_R0, + OP_R1, + OP_R2, +}; + + +enum { + PSW_MASK = (PSW_SM_BIT + | PSW_EA_BIT + | PSW_DB_BIT + | PSW_IE_BIT + | PSW_RP_BIT + | PSW_MD_BIT + | PSW_FX_BIT + | PSW_ST_BIT + | PSW_F0_BIT + | PSW_F1_BIT + | PSW_C_BIT), + /* The following bits in the PSW _can't_ be set by instructions such + as mvtc. */ + PSW_HW_MASK = (PSW_MASK | PSW_DM_BIT) }; +reg_t +move_to_cr (int cr, reg_t mask, reg_t val, int psw_hw_p) +{ + /* A MASK bit is set when the corresponding bit in the CR should + be left alone */ + /* This assumes that (VAL & MASK) == 0 */ + switch (cr) + { + case PSW_CR: + if (psw_hw_p) + val &= PSW_HW_MASK; + else + val &= PSW_MASK; + if ((mask & PSW_SM_BIT) == 0) + { + int new_psw_sm = (val & PSW_SM_BIT) != 0; + /* save old SP */ + SET_HELD_SP (PSW_SM, GPR (SP_IDX)); + if (PSW_SM != new_psw_sm) + /* restore new SP */ + SET_GPR (SP_IDX, HELD_SP (new_psw_sm)); + } + if ((mask & (PSW_ST_BIT | PSW_FX_BIT)) == 0) + { + if (val & PSW_ST_BIT && !(val & PSW_FX_BIT)) + { + (*d10v_callback->printf_filtered) + (d10v_callback, + "ERROR at PC 0x%x: ST can only be set when FX is set.\n", + PC<<2); + State.exception = SIGILL; + } + } + /* keep an up-to-date psw around for tracing */ + State.trace.psw = (State.trace.psw & mask) | val; + break; + case BPSW_CR: + case DPSW_CR: + /* Just like PSW, mask things like DM out. */ + if (psw_hw_p) + val &= PSW_HW_MASK; + else + val &= PSW_MASK; + break; + case MOD_S_CR: + case MOD_E_CR: + val &= ~1; + break; + default: + break; + } + /* only issue an update if the register is being changed */ + if ((State.cregs[cr] & ~mask) != val) + SLOT_PEND_MASK (State.cregs[cr], mask, val); + return val; +} + #ifdef DEBUG -static void trace_input PARAMS ((char *name, - enum op_types in1, - enum op_types in2, - enum op_types in3)); +static void trace_input_func PARAMS ((char *name, + enum op_types in1, + enum op_types in2, + enum op_types in3)); -static void trace_output PARAMS ((enum op_types result)); +#define trace_input(name, in1, in2, in3) do { if (d10v_debug) trace_input_func (name, in1, in2, in3); } while (0) #ifndef SIZE_INSTRUCTION -#define SIZE_INSTRUCTION 10 +#define SIZE_INSTRUCTION 8 #endif #ifndef SIZE_OPERANDS -#define SIZE_OPERANDS 24 +#define SIZE_OPERANDS 18 #endif #ifndef SIZE_VALUES #define SIZE_VALUES 13 #endif +#ifndef SIZE_LOCATION +#define SIZE_LOCATION 20 +#endif + +#ifndef SIZE_PC +#define SIZE_PC 6 +#endif + +#ifndef SIZE_LINE_NUMBER +#define SIZE_LINE_NUMBER 4 +#endif + static void -trace_input (name, in1, in2, in3) +trace_input_func (name, in1, in2, in3) char *name; enum op_types in1; enum op_types in2; @@ -62,10 +160,14 @@ trace_input (name, in1, in2, in3) char *comma; enum op_types in[3]; int i; - char buf[80]; + char buf[1024]; char *p; long tmp; char *type; + const char *filename; + const char *functionname; + unsigned int linenumber; + bfd_vma byte_pc; if ((d10v_debug & DEBUG_TRACE) == 0) return; @@ -78,13 +180,68 @@ trace_input (name, in1, in2, in3) case INS_RIGHT: type = " R"; break; case INS_LEFT_PARALLEL: type = "*L"; break; case INS_RIGHT_PARALLEL: type = "*R"; break; + case INS_LEFT_COND_TEST: type = "?L"; break; + case INS_RIGHT_COND_TEST: type = "?R"; break; + case INS_LEFT_COND_EXE: type = "&L"; break; + case INS_RIGHT_COND_EXE: type = "&R"; break; case INS_LONG: type = " B"; break; } - (*d10v_callback->printf_filtered) (d10v_callback, - "0x%.6x %s: %-*s", - (unsigned)PC, type, - SIZE_INSTRUCTION, name); + if ((d10v_debug & DEBUG_LINE_NUMBER) == 0) + (*d10v_callback->printf_filtered) (d10v_callback, + "0x%.*x %s: %-*s ", + SIZE_PC, (unsigned)PC, + type, + SIZE_INSTRUCTION, name); + + else + { + buf[0] = '\0'; + byte_pc = decode_pc (); + if (text && byte_pc >= text_start && byte_pc < text_end) + { + filename = (const char *)0; + functionname = (const char *)0; + linenumber = 0; + if (bfd_find_nearest_line (prog_bfd, text, (struct symbol_cache_entry **)0, byte_pc - text_start, + &filename, &functionname, &linenumber)) + { + p = buf; + if (linenumber) + { + sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, linenumber); + p += strlen (p); + } + else + { + sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---"); + p += SIZE_LINE_NUMBER+2; + } + + if (functionname) + { + sprintf (p, "%s ", functionname); + p += strlen (p); + } + else if (filename) + { + char *q = strrchr (filename, '/'); + sprintf (p, "%s ", (q) ? q+1 : filename); + p += strlen (p); + } + + if (*p == ' ') + *p = '\0'; + } + } + + (*d10v_callback->printf_filtered) (d10v_callback, + "0x%.*x %s: %-*.*s %-*s ", + SIZE_PC, (unsigned)PC, + type, + SIZE_LOCATION, SIZE_LOCATION, buf, + SIZE_INSTRUCTION, name); + } in[0] = in1; in[1] = in2; @@ -96,6 +253,9 @@ trace_input (name, in1, in2, in3) switch (in[i]) { case OP_VOID: + case OP_R0: + case OP_R1: + case OP_R2: break; case OP_REG: @@ -129,6 +289,12 @@ trace_input (name, in1, in2, in3) comma = ","; break; + case OP_CONSTANT8: + sprintf (p, "%s%d", comma, SEXT8(OP[i])); + p += strlen (p); + comma = ","; + break; + case OP_CONSTANT4: sprintf (p, "%s%d", comma, SEXT4(OP[i])); p += strlen (p); @@ -153,6 +319,12 @@ trace_input (name, in1, in2, in3) comma = ","; break; + case OP_MEMREF3: + sprintf (p, "%s@%d", comma, OP[i]); + p += strlen (p); + comma = ","; + break; + case OP_POSTINC: sprintf (p, "%s@r%d+", comma, OP[i]); p += strlen (p); @@ -223,25 +395,29 @@ trace_input (name, in1, in2, in3) case OP_POSTINC: case OP_PREDEC: (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", - (uint16)State.regs[OP[i]]); + (uint16) GPR (OP[i])); + break; + + case OP_MEMREF3: + (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", (uint16) OP[i]); break; case OP_DREG: - tmp = (long)((((uint32) State.regs[OP[i]]) << 16) | ((uint32) State.regs[OP[i]+1])); + tmp = (long)((((uint32) GPR (OP[i])) << 16) | ((uint32) GPR (OP[i] + 1))); (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.8lx", SIZE_VALUES-10, "", tmp); break; case OP_CR: case OP_CR_REVERSE: (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", - (uint16)State.cregs[OP[i]]); + (uint16) CREG (OP[i])); break; case OP_ACCUM: case OP_ACCUM_REVERSE: (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.2x%.8lx", SIZE_VALUES-12, "", - ((int)(State.a[OP[i]] >> 32) & 0xff), - ((unsigned long)State.a[OP[i]]) & 0xffffffff); + ((int)(ACC (OP[i]) >> 32) & 0xff), + ((unsigned long) ACC (OP[i])) & 0xffffffff); break; case OP_CONSTANT16: @@ -254,6 +430,11 @@ trace_input (name, in1, in2, in3) (uint16)SEXT4(OP[i])); break; + case OP_CONSTANT8: + (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", + (uint16)SEXT8(OP[i])); + break; + case OP_CONSTANT3: (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", (uint16)SEXT3(OP[i])); @@ -262,15 +443,15 @@ trace_input (name, in1, in2, in3) case OP_FLAG: if (OP[i] == 0) (*d10v_callback->printf_filtered) (d10v_callback, "%*sF0 = %d", SIZE_VALUES-6, "", - State.F0 != 0); + PSW_F0 != 0); else if (OP[i] == 1) (*d10v_callback->printf_filtered) (d10v_callback, "%*sF1 = %d", SIZE_VALUES-6, "", - State.F1 != 0); + PSW_F1 != 0); else (*d10v_callback->printf_filtered) (d10v_callback, "%*sC = %d", SIZE_VALUES-5, "", - State.C != 0); + PSW_C != 0); break; @@ -278,77 +459,117 @@ trace_input (name, in1, in2, in3) (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", (uint16)OP[i]); (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", - (uint16)State.regs[OP[++i]]); + (uint16)GPR (OP[i + 1])); + i++; + break; + + case OP_R0: + (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", + (uint16) GPR (0)); + break; + + case OP_R1: + (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", + (uint16) GPR (1)); + break; + + case OP_R2: + (*d10v_callback->printf_filtered) (d10v_callback, "%*s0x%.4x", SIZE_VALUES-6, "", + (uint16) GPR (2)); break; + } } } + + (*d10v_callback->flush_stdout) (d10v_callback); +} + +static void +do_trace_output_flush (void) +{ + (*d10v_callback->flush_stdout) (d10v_callback); +} + +static void +do_trace_output_finish (void) +{ + (*d10v_callback->printf_filtered) (d10v_callback, + " F0=%d F1=%d C=%d\n", + (State.trace.psw & PSW_F0_BIT) != 0, + (State.trace.psw & PSW_F1_BIT) != 0, + (State.trace.psw & PSW_C_BIT) != 0); + (*d10v_callback->flush_stdout) (d10v_callback); } static void -trace_output (result) - enum op_types result; +trace_output_40 (uint64 val) { if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES)) { - long tmp; + (*d10v_callback->printf_filtered) (d10v_callback, + " :: %*s0x%.2x%.8lx", + SIZE_VALUES - 12, + "", + ((int)(val >> 32) & 0xff), + ((unsigned long) val) & 0xffffffff); + do_trace_output_finish (); + } +} - switch (result) - { - default: - putchar ('\n'); - break; +static void +trace_output_32 (uint32 val) +{ + if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES)) + { + (*d10v_callback->printf_filtered) (d10v_callback, + " :: %*s0x%.8x", + SIZE_VALUES - 10, + "", + (int) val); + do_trace_output_finish (); + } +} - case OP_REG: - case OP_REG_OUTPUT: - (*d10v_callback->printf_filtered) (d10v_callback, " :: %*s0x%.4x F0=%d F1=%d C=%d\n", SIZE_VALUES-6, "", - (uint16)State.regs[OP[0]], - State.F0 != 0, State.F1 != 0, State.C != 0); - break; +static void +trace_output_16 (uint16 val) +{ + if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES)) + { + (*d10v_callback->printf_filtered) (d10v_callback, + " :: %*s0x%.4x", + SIZE_VALUES - 6, + "", + (int) val); + do_trace_output_finish (); + } +} - case OP_DREG: - case OP_DREG_OUTPUT: - tmp = (long)((((uint32) State.regs[OP[0]]) << 16) | ((uint32) State.regs[OP[0]+1])); - (*d10v_callback->printf_filtered) (d10v_callback, " :: %*s0x%.8lx F0=%d F1=%d C=%d\n", SIZE_VALUES-10, "", tmp, - State.F0 != 0, State.F1 != 0, State.C != 0); - break; +static void +trace_output_void () +{ + if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES)) + { + (*d10v_callback->printf_filtered) (d10v_callback, "\n"); + do_trace_output_flush (); + } +} - case OP_CR: - case OP_CR_OUTPUT: - (*d10v_callback->printf_filtered) (d10v_callback, " :: %*s0x%.4x F0=%d F1=%d C=%d\n", SIZE_VALUES-6, "", - (uint16)State.cregs[OP[0]], - State.F0 != 0, State.F1 != 0, State.C != 0); - break; +static void +trace_output_flag () +{ + if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES)) + { + (*d10v_callback->printf_filtered) (d10v_callback, + " :: %*s", + SIZE_VALUES, + ""); + do_trace_output_finish (); + } +} - case OP_CR_REVERSE: - (*d10v_callback->printf_filtered) (d10v_callback, " :: %*s0x%.4x F0=%d F1=%d C=%d\n", SIZE_VALUES-6, "", - (uint16)State.cregs[OP[1]], - State.F0 != 0, State.F1 != 0, State.C != 0); - break; - case OP_ACCUM: - case OP_ACCUM_OUTPUT: - (*d10v_callback->printf_filtered) (d10v_callback, " :: %*s0x%.2x%.8lx F0=%d F1=%d C=%d\n", SIZE_VALUES-12, "", - ((int)(State.a[OP[0]] >> 32) & 0xff), - ((unsigned long)State.a[OP[0]]) & 0xffffffff, - State.F0 != 0, State.F1 != 0, State.C != 0); - break; - case OP_ACCUM_REVERSE: - (*d10v_callback->printf_filtered) (d10v_callback, " :: %*s0x%.2x%.8lx F0=%d F1=%d C=%d\n", SIZE_VALUES-12, "", - ((int)(State.a[OP[1]] >> 32) & 0xff), - ((unsigned long)State.a[OP[1]]) & 0xffffffff, - State.F0 != 0, State.F1 != 0, State.C != 0); - break; - - case OP_FLAG: - case OP_FLAG_OUTPUT: - (*d10v_callback->printf_filtered) (d10v_callback, " :: %*s F0=%d F1=%d C=%d\n", SIZE_VALUES, "", - State.F0 != 0, State.F1 != 0, State.C != 0); - break; - } - } -} #else #define trace_input(NAME, IN1, IN2, IN3) @@ -359,16 +580,19 @@ trace_output (result) void OP_4607 () { + int16 tmp; trace_input ("abs", OP_REG, OP_VOID, OP_VOID); - State.F1 = State.F0; - if ((int16)(State.regs[OP[0]]) < 0) + SET_PSW_F1 (PSW_F0); + tmp = GPR(OP[0]); + if (tmp < 0) { - State.regs[OP[0]] = -(int16)(State.regs[OP[0]]); - State.F0 = 1; + tmp = - tmp; + SET_PSW_F0 (1); } else - State.F0 = 0; - trace_output (OP_REG); + SET_PSW_F0 (0); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* abs */ @@ -376,44 +600,46 @@ void OP_5607 () { int64 tmp; - trace_input ("abs", OP_ACCUM, OP_VOID, OP_VOID); - State.F1 = State.F0; - State.a[OP[0]] = SEXT40(State.a[OP[0]]); + SET_PSW_F1 (PSW_F0); - if (State.a[OP[0]] < 0 ) + tmp = SEXT40 (ACC (OP[0])); + if (tmp < 0 ) { - tmp = -State.a[OP[0]]; - if (State.ST) + tmp = - tmp; + if (PSW_ST) { - if (tmp > MAX32) - State.a[OP[0]] = MAX32; - else if (tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - State.F0 = 1; + tmp = (tmp & MASK40); + SET_PSW_F0 (1); } else - State.F0 = 0; - trace_output (OP_ACCUM); + { + tmp = (tmp & MASK40); + SET_PSW_F0 (0); + } + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* add */ void OP_200 () { - uint16 tmp = State.regs[OP[0]]; + uint16 a = GPR (OP[0]); + uint16 b = GPR (OP[1]); + uint16 tmp = (a + b); trace_input ("add", OP_REG, OP_REG, OP_VOID); - State.regs[OP[0]] += State.regs[OP[1]]; - if ( tmp > State.regs[OP[0]]) - State.C = 1; - else - State.C = 0; - trace_output (OP_REG); + SET_PSW_C (a > tmp); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* add */ @@ -421,21 +647,22 @@ void OP_1201 () { int64 tmp; - tmp = SEXT40(State.a[OP[0]]) + (SEXT16 (State.regs[OP[1]]) << 16 | State.regs[OP[1]+1]); + tmp = SEXT40(ACC (OP[0])) + (SEXT16 (GPR (OP[1])) << 16 | GPR (OP[1] + 1)); trace_input ("add", OP_ACCUM, OP_REG, OP_VOID); - if (State.ST) + if (PSW_ST) { - if ( tmp > MAX32) - State.a[OP[0]] = MAX32; - else if ( tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* add */ @@ -443,21 +670,22 @@ void OP_1203 () { int64 tmp; - tmp = SEXT40(State.a[OP[0]]) + SEXT40(State.a[OP[1]]); + tmp = SEXT40(ACC (OP[0])) + SEXT40(ACC (OP[1])); trace_input ("add", OP_ACCUM, OP_ACCUM, OP_VOID); - if (State.ST) + if (PSW_ST) { - if (tmp > MAX32) - State.a[OP[0]] = MAX32; - else if ( tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* add2w */ @@ -465,33 +693,27 @@ void OP_1200 () { uint32 tmp; - uint32 tmp1 = (State.regs[OP[0]]) << 16 | State.regs[OP[0]+1]; - uint32 tmp2 = (State.regs[OP[1]]) << 16 | State.regs[OP[1]+1]; - + uint32 a = (GPR (OP[0])) << 16 | GPR (OP[0] + 1); + uint32 b = (GPR (OP[1])) << 16 | GPR (OP[1] + 1); trace_input ("add2w", OP_DREG, OP_DREG, OP_VOID); - tmp = tmp1 + tmp2; - if ( (tmp < tmp1) || (tmp < tmp2) ) - State.C = 1; - else - State.C = 0; - State.regs[OP[0]] = tmp >> 16; - State.regs[OP[0]+1] = tmp & 0xFFFF; - trace_output (OP_DREG); + tmp = a + b; + SET_PSW_C (tmp < a); + SET_GPR (OP[0] + 0, (tmp >> 16)); + SET_GPR (OP[0] + 1, (tmp & 0xFFFF)); + trace_output_32 (tmp); } /* add3 */ void OP_1000000 () { - uint16 tmp = State.regs[OP[0]]; - State.regs[OP[0]] = State.regs[OP[1]] + OP[2]; - + uint16 a = GPR (OP[1]); + uint16 b = OP[2]; + uint16 tmp = (a + b); trace_input ("add3", OP_REG_OUTPUT, OP_REG, OP_CONSTANT16); - if ( tmp > State.regs[OP[0]]) - State.C = 1; - else - State.C = 0; - trace_output (OP_REG); + SET_PSW_C (tmp < a); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* addac3 */ @@ -499,12 +721,12 @@ void OP_17000200 () { int64 tmp; - tmp = SEXT40(State.a[OP[2]]) + SEXT40 ((State.regs[OP[1]] << 16) | State.regs[OP[1]+1]); + tmp = SEXT40(ACC (OP[2])) + SEXT40 ((GPR (OP[1]) << 16) | GPR (OP[1] + 1)); trace_input ("addac3", OP_DREG_OUTPUT, OP_DREG, OP_ACCUM); - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - trace_output (OP_DREG); + SET_GPR (OP[0] + 0, ((tmp >> 16) & 0xffff)); + SET_GPR (OP[0] + 1, (tmp & 0xffff)); + trace_output_32 (tmp); } /* addac3 */ @@ -512,12 +734,12 @@ void OP_17000202 () { int64 tmp; - tmp = SEXT40(State.a[OP[1]]) + SEXT40(State.a[OP[2]]); + tmp = SEXT40(ACC (OP[1])) + SEXT40(ACC (OP[2])); trace_input ("addac3", OP_DREG_OUTPUT, OP_ACCUM, OP_ACCUM); - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - trace_output (OP_DREG); + SET_GPR (OP[0] + 0, (tmp >> 16) & 0xffff); + SET_GPR (OP[0] + 1, tmp & 0xffff); + trace_output_32 (tmp); } /* addac3s */ @@ -525,29 +747,27 @@ void OP_17001200 () { int64 tmp; - State.F1 = State.F0; + SET_PSW_F1 (PSW_F0); trace_input ("addac3s", OP_DREG_OUTPUT, OP_DREG, OP_ACCUM); - tmp = SEXT40(State.a[OP[2]]) + SEXT40 ((State.regs[OP[1]] << 16) | State.regs[OP[1]+1]); - if ( tmp > MAX32) + tmp = SEXT40 (ACC (OP[2])) + SEXT40 ((GPR (OP[1]) << 16) | GPR (OP[1] + 1)); + if (tmp > SEXT40(MAX32)) { - State.regs[OP[0]] = 0x7fff; - State.regs[OP[0]+1] = 0xffff; - State.F0 = 1; + tmp = (MAX32); + SET_PSW_F0 (1); } - else if (tmp < MIN32) + else if (tmp < SEXT40(MIN32)) { - State.regs[OP[0]] = 0x8000; - State.regs[OP[0]+1] = 0; - State.F0 = 1; + tmp = (MIN32); + SET_PSW_F0 (1); } else { - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - State.F0 = 0; + SET_PSW_F0 (0); } - trace_output (OP_DREG); + SET_GPR (OP[0] + 0, (tmp >> 16) & 0xffff); + SET_GPR (OP[0] + 1, (tmp & 0xffff)); + trace_output_32 (tmp); } /* addac3s */ @@ -555,110 +775,115 @@ void OP_17001202 () { int64 tmp; - State.F1 = State.F0; + SET_PSW_F1 (PSW_F0); trace_input ("addac3s", OP_DREG_OUTPUT, OP_ACCUM, OP_ACCUM); - tmp = SEXT40(State.a[OP[1]]) + SEXT40(State.a[OP[2]]); - if ( tmp > MAX32) + tmp = SEXT40(ACC (OP[1])) + SEXT40(ACC (OP[2])); + if (tmp > SEXT40(MAX32)) { - State.regs[OP[0]] = 0x7fff; - State.regs[OP[0]+1] = 0xffff; - State.F0 = 1; + tmp = (MAX32); + SET_PSW_F0 (1); } - else if (tmp < MIN32) + else if (tmp < SEXT40(MIN32)) { - State.regs[OP[0]] = 0x8000; - State.regs[OP[0]+1] = 0; - State.F0 = 1; + tmp = (MIN32); + SET_PSW_F0 (1); } else { - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - State.F0 = 0; + SET_PSW_F0 (0); } - trace_output (OP_DREG); + SET_GPR (OP[0] + 0, (tmp >> 16) & 0xffff); + SET_GPR (OP[0] + 1, (tmp & 0xffff)); + trace_output_32 (tmp); } /* addi */ void OP_201 () { - uint tmp = State.regs[OP[0]]; + uint16 a = GPR (OP[0]); + uint16 b; + uint16 tmp; if (OP[1] == 0) OP[1] = 16; + b = OP[1]; + tmp = (a + b); trace_input ("addi", OP_REG, OP_CONSTANT16, OP_VOID); - State.regs[OP[0]] += OP[1]; - if (tmp > State.regs[OP[0]]) - State.C = 1; - else - State.C = 0; - trace_output (OP_REG); + SET_PSW_C (tmp < a); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* and */ void OP_C00 () { + uint16 tmp = GPR (OP[0]) & GPR (OP[1]); trace_input ("and", OP_REG, OP_REG, OP_VOID); - State.regs[OP[0]] &= State.regs[OP[1]]; - trace_output (OP_REG); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* and3 */ void OP_6000000 () { + uint16 tmp = GPR (OP[1]) & OP[2]; trace_input ("and3", OP_REG_OUTPUT, OP_REG, OP_CONSTANT16); - State.regs[OP[0]] = State.regs[OP[1]] & OP[2]; - trace_output (OP_REG); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* bclri */ void OP_C01 () { + int16 tmp; trace_input ("bclri", OP_REG, OP_CONSTANT16, OP_VOID); - State.regs[OP[0]] &= ~(0x8000 >> OP[1]); - trace_output (OP_REG); + tmp = (GPR (OP[0]) &~(0x8000 >> OP[1])); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* bl.s */ void OP_4900 () { - trace_input ("bl.s", OP_CONSTANT16, OP_VOID, OP_VOID); - State.regs[13] = PC+1; - PC += SEXT8 (OP[0]); - trace_output (OP_VOID); + trace_input ("bl.s", OP_CONSTANT8, OP_R0, OP_R1); + SET_GPR (13, PC + 1); + JMP( PC + SEXT8 (OP[0])); + trace_output_void (); } /* bl.l */ void OP_24800000 () { - trace_input ("bl.l", OP_CONSTANT16, OP_VOID, OP_VOID); - State.regs[13] = PC+1; - PC += OP[0]; - trace_output (OP_VOID); + trace_input ("bl.l", OP_CONSTANT16, OP_R0, OP_R1); + SET_GPR (13, (PC + 1)); + JMP (PC + OP[0]); + trace_output_void (); } /* bnoti */ void OP_A01 () { + int16 tmp; trace_input ("bnoti", OP_REG, OP_CONSTANT16, OP_VOID); - State.regs[OP[0]] ^= 0x8000 >> OP[1]; - trace_output (OP_REG); + tmp = (GPR (OP[0]) ^ (0x8000 >> OP[1])); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* bra.s */ void OP_4800 () { - trace_input ("bra.s", OP_CONSTANT16, OP_VOID, OP_VOID); - PC += SEXT8 (OP[0]); - trace_output (OP_VOID); + trace_input ("bra.s", OP_CONSTANT8, OP_VOID, OP_VOID); + JMP (PC + SEXT8 (OP[0])); + trace_output_void (); } /* bra.l */ @@ -666,18 +891,18 @@ void OP_24000000 () { trace_input ("bra.l", OP_CONSTANT16, OP_VOID, OP_VOID); - PC += OP[0]; - trace_output (OP_VOID); + JMP (PC + OP[0]); + trace_output_void (); } /* brf0f.s */ void OP_4A00 () { - trace_input ("brf0f.s", OP_CONSTANT16, OP_VOID, OP_VOID); - if (State.F0 == 0) - PC += SEXT8 (OP[0]); - trace_output (OP_FLAG); + trace_input ("brf0f.s", OP_CONSTANT8, OP_VOID, OP_VOID); + if (!PSW_F0) + JMP (PC + SEXT8 (OP[0])); + trace_output_flag (); } /* brf0f.l */ @@ -685,19 +910,19 @@ void OP_25000000 () { trace_input ("brf0f.l", OP_CONSTANT16, OP_VOID, OP_VOID); - if (State.F0 == 0) - PC += OP[0]; - trace_output (OP_FLAG); + if (!PSW_F0) + JMP (PC + OP[0]); + trace_output_flag (); } /* brf0t.s */ void OP_4B00 () { - trace_input ("brf0t.s", OP_CONSTANT16, OP_VOID, OP_VOID); - if (State.F0) - PC += SEXT8 (OP[0]); - trace_output (OP_FLAG); + trace_input ("brf0t.s", OP_CONSTANT8, OP_VOID, OP_VOID); + if (PSW_F0) + JMP (PC + SEXT8 (OP[0])); + trace_output_flag (); } /* brf0t.l */ @@ -705,18 +930,20 @@ void OP_25800000 () { trace_input ("brf0t.l", OP_CONSTANT16, OP_VOID, OP_VOID); - if (State.F0) - PC += OP[0]; - trace_output (OP_FLAG); + if (PSW_F0) + JMP (PC + OP[0]); + trace_output_flag (); } /* bseti */ void OP_801 () { + int16 tmp; trace_input ("bseti", OP_REG, OP_CONSTANT16, OP_VOID); - State.regs[OP[0]] |= 0x8000 >> OP[1]; - trace_output (OP_REG); + tmp = (GPR (OP[0]) | (0x8000 >> OP[1])); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* btsti */ @@ -724,9 +951,9 @@ void OP_E01 () { trace_input ("btsti", OP_REG, OP_CONSTANT16, OP_VOID); - State.F1 = State.F0; - State.F0 = (State.regs[OP[0]] & (0x8000 >> OP[1])) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 ((GPR (OP[0]) & (0x8000 >> OP[1])) ? 1 : 0); + trace_output_flag (); } /* clrac */ @@ -734,8 +961,8 @@ void OP_5601 () { trace_input ("clrac", OP_ACCUM_OUTPUT, OP_VOID, OP_VOID); - State.a[OP[0]] = 0; - trace_output (OP_ACCUM); + SET_ACC (OP[0], 0); + trace_output_40 (0); } /* cmp */ @@ -743,9 +970,9 @@ void OP_600 () { trace_input ("cmp", OP_REG, OP_REG, OP_VOID); - State.F1 = State.F0; - State.F0 = ((int16)(State.regs[OP[0]]) < (int16)(State.regs[OP[1]])) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 (((int16)(GPR (OP[0])) < (int16)(GPR (OP[1]))) ? 1 : 0); + trace_output_flag (); } /* cmp */ @@ -753,9 +980,9 @@ void OP_1603 () { trace_input ("cmp", OP_ACCUM, OP_ACCUM, OP_VOID); - State.F1 = State.F0; - State.F0 = (SEXT40(State.a[OP[0]]) < SEXT40(State.a[OP[1]])) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 ((SEXT40(ACC (OP[0])) < SEXT40(ACC (OP[1]))) ? 1 : 0); + trace_output_flag (); } /* cmpeq */ @@ -763,9 +990,9 @@ void OP_400 () { trace_input ("cmpeq", OP_REG, OP_REG, OP_VOID); - State.F1 = State.F0; - State.F0 = (State.regs[OP[0]] == State.regs[OP[1]]) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 ((GPR (OP[0]) == GPR (OP[1])) ? 1 : 0); + trace_output_flag (); } /* cmpeq */ @@ -773,19 +1000,19 @@ void OP_1403 () { trace_input ("cmpeq", OP_ACCUM, OP_ACCUM, OP_VOID); - State.F1 = State.F0; - State.F0 = (State.a[OP[0]] == State.a[OP[1]]) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 (((ACC (OP[0]) & MASK40) == (ACC (OP[1]) & MASK40)) ? 1 : 0); + trace_output_flag (); } /* cmpeqi.s */ void OP_401 () { - trace_input ("cmpeqi.s", OP_REG, OP_CONSTANT16, OP_VOID); - State.F1 = State.F0; - State.F0 = (State.regs[OP[0]] == SEXT4(OP[1])) ? 1 : 0; - trace_output (OP_FLAG); + trace_input ("cmpeqi.s", OP_REG, OP_CONSTANT4, OP_VOID); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 ((GPR (OP[0]) == (reg_t) SEXT4 (OP[1])) ? 1 : 0); + trace_output_flag (); } /* cmpeqi.l */ @@ -793,9 +1020,9 @@ void OP_2000000 () { trace_input ("cmpeqi.l", OP_REG, OP_CONSTANT16, OP_VOID); - State.F1 = State.F0; - State.F0 = (State.regs[OP[0]] == OP[1]) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 ((GPR (OP[0]) == (reg_t)OP[1]) ? 1 : 0); + trace_output_flag (); } /* cmpi.s */ @@ -803,9 +1030,9 @@ void OP_601 () { trace_input ("cmpi.s", OP_REG, OP_CONSTANT4, OP_VOID); - State.F1 = State.F0; - State.F0 = ((int16)(State.regs[OP[0]]) < SEXT4(OP[1])) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 (((int16)(GPR (OP[0])) < (int16)SEXT4(OP[1])) ? 1 : 0); + trace_output_flag (); } /* cmpi.l */ @@ -813,9 +1040,9 @@ void OP_3000000 () { trace_input ("cmpi.l", OP_REG, OP_CONSTANT16, OP_VOID); - State.F1 = State.F0; - State.F0 = ((int16)(State.regs[OP[0]]) < (int16)(OP[1])) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 (((int16)(GPR (OP[0])) < (int16)(OP[1])) ? 1 : 0); + trace_output_flag (); } /* cmpu */ @@ -823,9 +1050,9 @@ void OP_4600 () { trace_input ("cmpu", OP_REG, OP_REG, OP_VOID); - State.F1 = State.F0; - State.F0 = (State.regs[OP[0]] < State.regs[OP[1]]) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 ((GPR (OP[0]) < GPR (OP[1])) ? 1 : 0); + trace_output_flag (); } /* cmpui */ @@ -833,40 +1060,84 @@ void OP_23000000 () { trace_input ("cmpui", OP_REG, OP_CONSTANT16, OP_VOID); - State.F1 = State.F0; - State.F0 = (State.regs[OP[0]] < OP[1]) ? 1 : 0; - trace_output (OP_FLAG); + SET_PSW_F1 (PSW_F0); + SET_PSW_F0 ((GPR (OP[0]) < (reg_t)OP[1]) ? 1 : 0); + trace_output_flag (); } /* cpfg */ void OP_4E09 () { - uint8 *src, *dst; + uint8 val; trace_input ("cpfg", OP_FLAG_OUTPUT, OP_FLAG, OP_VOID); + + if (OP[1] == 0) + val = PSW_F0; + else if (OP[1] == 1) + val = PSW_F1; + else + val = PSW_C; if (OP[0] == 0) - dst = &State.F0; + SET_PSW_F0 (val); else - dst = &State.F1; + SET_PSW_F1 (val); + + trace_output_flag (); +} + +/* cpfg */ +void +OP_4E0F () +{ + uint8 val; + + trace_input ("cpfg", OP_FLAG_OUTPUT, OP_FLAG, OP_VOID); if (OP[1] == 0) - src = &State.F0; + val = PSW_F0; else if (OP[1] == 1) - src = &State.F1; + val = PSW_F1; else - src = &State.C; + val = PSW_C; + if (OP[0] == 0) + SET_PSW_F0 (val); + else + SET_PSW_F1 (val); - *dst = *src; - trace_output (OP_FLAG); + trace_output_flag (); } /* dbt */ void OP_5F20 () { - d10v_callback->printf_filtered(d10v_callback, "***** DBT ***** PC=%x\n",PC); - State.exception = SIGTRAP; + /* d10v_callback->printf_filtered(d10v_callback, "***** DBT ***** PC=%x\n",PC); */ + + /* GDB uses the instruction pair ``dbt || nop'' as a break-point. + The conditional below is for either of the instruction pairs + ``dbt -> XXX'' or ``dbt <- XXX'' and treats them as as cases + where the dbt instruction should be interpreted. + + The module `sim-break' provides a more effective mechanism for + detecting GDB planted breakpoints. The code below may, + eventually, be changed to use that mechanism. */ + + if (State.ins_type == INS_LEFT + || State.ins_type == INS_RIGHT) + { + trace_input ("dbt", OP_VOID, OP_VOID, OP_VOID); + SET_DPC (PC + 1); + SET_DPSW (PSW); + SET_HW_PSW (PSW_DM_BIT | (PSW & (PSW_F0_BIT | PSW_F1_BIT | PSW_C_BIT))); + JMP (DBT_VECTOR_START); + trace_output_void (); + } + else + { + State.exception = SIGTRAP; + } } /* divs */ @@ -874,14 +1145,18 @@ void OP_14002800 () { uint16 foo, tmp, tmpf; + uint16 hi; + uint16 lo; trace_input ("divs", OP_DREG, OP_REG, OP_VOID); - foo = (State.regs[OP[0]] << 1) | (State.regs[OP[0]+1] >> 15); - tmp = (int16)foo - (int16)(State.regs[OP[1]]); - tmpf = (foo >= State.regs[OP[1]]) ? 1 : 0; - State.regs[OP[0]] = (tmpf == 1) ? tmp : foo; - State.regs[OP[0]+1] = (State.regs[OP[0]+1] << 1) | tmpf; - trace_output (OP_DREG); + foo = (GPR (OP[0]) << 1) | (GPR (OP[0] + 1) >> 15); + tmp = (int16)foo - (int16)(GPR (OP[1])); + tmpf = (foo >= GPR (OP[1])) ? 1 : 0; + hi = ((tmpf == 1) ? tmp : foo); + lo = ((GPR (OP[0] + 1) << 1) | tmpf); + SET_GPR (OP[0] + 0, hi); + SET_GPR (OP[0] + 1, lo); + trace_output_32 (((uint32) hi << 16) | lo); } /* exef0f */ @@ -889,8 +1164,8 @@ void OP_4E04 () { trace_input ("exef0f", OP_VOID, OP_VOID, OP_VOID); - State.exe = (State.F0 == 0); - trace_output (OP_FLAG); + State.exe = (PSW_F0 == 0); + trace_output_flag (); } /* exef0t */ @@ -898,8 +1173,8 @@ void OP_4E24 () { trace_input ("exef0t", OP_VOID, OP_VOID, OP_VOID); - State.exe = (State.F0 != 0); - trace_output (OP_FLAG); + State.exe = (PSW_F0 != 0); + trace_output_flag (); } /* exef1f */ @@ -907,8 +1182,8 @@ void OP_4E40 () { trace_input ("exef1f", OP_VOID, OP_VOID, OP_VOID); - State.exe = (State.F1 == 0); - trace_output (OP_FLAG); + State.exe = (PSW_F1 == 0); + trace_output_flag (); } /* exef1t */ @@ -916,8 +1191,8 @@ void OP_4E42 () { trace_input ("exef1t", OP_VOID, OP_VOID, OP_VOID); - State.exe = (State.F1 != 0); - trace_output (OP_FLAG); + State.exe = (PSW_F1 != 0); + trace_output_flag (); } /* exefaf */ @@ -925,8 +1200,8 @@ void OP_4E00 () { trace_input ("exefaf", OP_VOID, OP_VOID, OP_VOID); - State.exe = (State.F0 == 0) & (State.F1 == 0); - trace_output (OP_FLAG); + State.exe = (PSW_F0 == 0) & (PSW_F1 == 0); + trace_output_flag (); } /* exefat */ @@ -934,8 +1209,8 @@ void OP_4E02 () { trace_input ("exefat", OP_VOID, OP_VOID, OP_VOID); - State.exe = (State.F0 == 0) & (State.F1 != 0); - trace_output (OP_FLAG); + State.exe = (PSW_F0 == 0) & (PSW_F1 != 0); + trace_output_flag (); } /* exetaf */ @@ -943,8 +1218,8 @@ void OP_4E20 () { trace_input ("exetaf", OP_VOID, OP_VOID, OP_VOID); - State.exe = (State.F0 != 0) & (State.F1 == 0); - trace_output (OP_FLAG); + State.exe = (PSW_F0 != 0) & (PSW_F1 == 0); + trace_output_flag (); } /* exetat */ @@ -952,8 +1227,8 @@ void OP_4E22 () { trace_input ("exetat", OP_VOID, OP_VOID, OP_VOID); - State.exe = (State.F0 != 0) & (State.F1 != 0); - trace_output (OP_FLAG); + State.exe = (PSW_F0 != 0) & (PSW_F1 != 0); + trace_output_flag (); } /* exp */ @@ -964,24 +1239,24 @@ OP_15002A00 () int i; trace_input ("exp", OP_REG_OUTPUT, OP_DREG, OP_VOID); - if (((int16)State.regs[OP[1]]) >= 0) - tmp = (State.regs[OP[1]] << 16) | State.regs[OP[1]+1]; + if (((int16)GPR (OP[1])) >= 0) + tmp = (GPR (OP[1]) << 16) | GPR (OP[1] + 1); else - tmp = ~((State.regs[OP[1]] << 16) | State.regs[OP[1]+1]); + tmp = ~((GPR (OP[1]) << 16) | GPR (OP[1] + 1)); foo = 0x40000000; for (i=1;i<17;i++) { if (tmp & foo) { - State.regs[OP[0]] = i-1; - trace_output (OP_REG); + SET_GPR (OP[0], (i - 1)); + trace_output_16 (i - 1); return; } foo >>= 1; } - State.regs[OP[0]] = 16; - trace_output (OP_REG); + SET_GPR (OP[0], 16); + trace_output_16 (16); } /* exp */ @@ -992,179 +1267,309 @@ OP_15002A02 () int i; trace_input ("exp", OP_REG_OUTPUT, OP_ACCUM, OP_VOID); - if (SEXT40(State.a[OP[1]]) >= 0) - tmp = State.a[OP[1]]; - else - tmp = ~(State.a[OP[1]]); + tmp = SEXT40(ACC (OP[1])); + if (tmp < 0) + tmp = ~tmp & MASK40; foo = 0x4000000000LL; for (i=1;i<25;i++) { if (tmp & foo) { - State.regs[OP[0]] = i-9; - trace_output (OP_REG); + SET_GPR (OP[0], i - 9); + trace_output_16 (i - 9); return; } foo >>= 1; } - State.regs[OP[0]] = 16; - trace_output (OP_REG); + SET_GPR (OP[0], 16); + trace_output_16 (16); } /* jl */ void OP_4D00 () { - trace_input ("jl", OP_REG, OP_VOID, OP_VOID); - State.regs[13] = PC+1; - PC = State.regs[OP[0]]; - trace_output (OP_VOID); + trace_input ("jl", OP_REG, OP_R0, OP_R1); + SET_GPR (13, PC + 1); + JMP (GPR (OP[0])); + trace_output_void (); } /* jmp */ void OP_4C00 () { - trace_input ("jmp", OP_REG, OP_VOID, OP_VOID); - PC = State.regs[OP[0]]; - trace_output (OP_VOID); + trace_input ("jmp", OP_REG, + (OP[0] == 13) ? OP_R0 : OP_VOID, + (OP[0] == 13) ? OP_R1 : OP_VOID); + + JMP (GPR (OP[0])); + trace_output_void (); } /* ld */ void OP_30000000 () { + uint16 tmp; + uint16 addr = OP[1] + GPR (OP[2]); trace_input ("ld", OP_REG_OUTPUT, OP_MEMREF2, OP_VOID); - State.regs[OP[0]] = RW (OP[1] + State.regs[OP[2]]); - trace_output (OP_REG); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RW (addr); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* ld */ void OP_6401 () { + uint16 tmp; + uint16 addr = GPR (OP[1]); trace_input ("ld", OP_REG_OUTPUT, OP_POSTDEC, OP_VOID); - State.regs[OP[0]] = RW (State.regs[OP[1]]); - INC_ADDR(State.regs[OP[1]],-2); - trace_output (OP_REG); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RW (addr); + SET_GPR (OP[0], tmp); + if (OP[0] != OP[1]) + INC_ADDR (OP[1], -2); + trace_output_16 (tmp); } /* ld */ void OP_6001 () { + uint16 tmp; + uint16 addr = GPR (OP[1]); trace_input ("ld", OP_REG_OUTPUT, OP_POSTINC, OP_VOID); - State.regs[OP[0]] = RW (State.regs[OP[1]]); - INC_ADDR(State.regs[OP[1]],2); - trace_output (OP_REG); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RW (addr); + SET_GPR (OP[0], tmp); + if (OP[0] != OP[1]) + INC_ADDR (OP[1], 2); + trace_output_16 (tmp); } /* ld */ void OP_6000 () { + uint16 tmp; + uint16 addr = GPR (OP[1]); trace_input ("ld", OP_REG_OUTPUT, OP_MEMREF, OP_VOID); - State.regs[OP[0]] = RW (State.regs[OP[1]]); - trace_output (OP_REG); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RW (addr); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); +} + +/* ld */ +void +OP_32010000 () +{ + uint16 tmp; + uint16 addr = OP[1]; + trace_input ("ld", OP_REG_OUTPUT, OP_MEMREF3, OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RW (addr); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* ld2w */ void OP_31000000 () { + int32 tmp; + uint16 addr = OP[1] + GPR (OP[2]); trace_input ("ld2w", OP_REG_OUTPUT, OP_MEMREF2, OP_VOID); - State.regs[OP[0]] = RW (OP[1] + State.regs[OP[2]]); - State.regs[OP[0]+1] = RW (OP[1] + State.regs[OP[2]] + 2); - trace_output (OP_DREG); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RLW (addr); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* ld2w */ void OP_6601 () { + uint16 addr = GPR (OP[1]); + int32 tmp; trace_input ("ld2w", OP_REG_OUTPUT, OP_POSTDEC, OP_VOID); - State.regs[OP[0]] = RW (State.regs[OP[1]]); - State.regs[OP[0]+1] = RW (State.regs[OP[1]]+2); - INC_ADDR(State.regs[OP[1]],-4); - trace_output (OP_DREG); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RLW (addr); + SET_GPR32 (OP[0], tmp); + if (OP[0] != OP[1] && ((OP[0] + 1) != OP[1])) + INC_ADDR (OP[1], -4); + trace_output_32 (tmp); } /* ld2w */ void OP_6201 () { + int32 tmp; + uint16 addr = GPR (OP[1]); trace_input ("ld2w", OP_REG_OUTPUT, OP_POSTINC, OP_VOID); - State.regs[OP[0]] = RW (State.regs[OP[1]]); - State.regs[OP[0]+1] = RW (State.regs[OP[1]]+2); - INC_ADDR(State.regs[OP[1]],4); - trace_output (OP_REG); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RLW (addr); + SET_GPR32 (OP[0], tmp); + if (OP[0] != OP[1] && ((OP[0] + 1) != OP[1])) + INC_ADDR (OP[1], 4); + trace_output_32 (tmp); } /* ld2w */ void OP_6200 () { - trace_input ("ld", OP_REG_OUTPUT, OP_MEMREF, OP_VOID); - State.regs[OP[0]] = RW (State.regs[OP[1]]); - State.regs[OP[0]+1] = RW (State.regs[OP[1]]+2); - trace_output (OP_REG); + uint16 addr = GPR (OP[1]); + int32 tmp; + trace_input ("ld2w", OP_REG_OUTPUT, OP_MEMREF, OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RLW (addr); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); +} + +/* ld2w */ +void +OP_33010000 () +{ + int32 tmp; + uint16 addr = OP[1]; + trace_input ("ld2w", OP_REG_OUTPUT, OP_MEMREF3, OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + tmp = RLW (addr); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* ldb */ void OP_38000000 () { + int16 tmp; trace_input ("ldb", OP_REG_OUTPUT, OP_MEMREF2, OP_VOID); - State.regs[OP[0]] = RB (OP[1] + State.regs[OP[2]]); - SEXT8 (State.regs[OP[0]]); - trace_output (OP_REG); + tmp = SEXT8 (RB (OP[1] + GPR (OP[2]))); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* ldb */ void OP_7000 () { + int16 tmp; trace_input ("ldb", OP_REG_OUTPUT, OP_MEMREF, OP_VOID); - State.regs[OP[0]] = RB (State.regs[OP[1]]); - SEXT8 (State.regs[OP[0]]); - trace_output (OP_REG); + tmp = SEXT8 (RB (GPR (OP[1]))); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* ldi.s */ void OP_4001 () { + int16 tmp; trace_input ("ldi.s", OP_REG_OUTPUT, OP_CONSTANT4, OP_VOID); - State.regs[OP[0]] = SEXT4(OP[1]); - trace_output (OP_REG); + tmp = SEXT4 (OP[1]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* ldi.l */ void OP_20000000 () { - trace_input ("ldi.s", OP_REG_OUTPUT, OP_CONSTANT16, OP_VOID); - State.regs[OP[0]] = OP[1]; - trace_output (OP_REG); + int16 tmp; + trace_input ("ldi.l", OP_REG_OUTPUT, OP_CONSTANT16, OP_VOID); + tmp = OP[1]; + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* ldub */ void OP_39000000 () { + int16 tmp; trace_input ("ldub", OP_REG_OUTPUT, OP_MEMREF2, OP_VOID); - State.regs[OP[0]] = RB (OP[1] + State.regs[OP[2]]); - trace_output (OP_REG); + tmp = RB (OP[1] + GPR (OP[2])); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* ldub */ void OP_7200 () { + int16 tmp; trace_input ("ldub", OP_REG_OUTPUT, OP_MEMREF, OP_VOID); - State.regs[OP[0]] = RB (State.regs[OP[1]]); - trace_output (OP_REG); + tmp = RB (GPR (OP[1])); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* mac */ @@ -1174,27 +1579,28 @@ OP_2A00 () int64 tmp; trace_input ("mac", OP_ACCUM, OP_REG, OP_REG); - tmp = SEXT40 ((int16)(State.regs[OP[1]]) * (int16)(State.regs[OP[2]])); + tmp = SEXT40 ((int16)(GPR (OP[1])) * (int16)(GPR (OP[2]))); - if (State.FX) + if (PSW_FX) tmp = SEXT40( (tmp << 1) & MASK40); - if (State.ST && tmp > MAX32) - tmp = MAX32; + if (PSW_ST && tmp > SEXT40(MAX32)) + tmp = (MAX32); - tmp += SEXT40(State.a[OP[0]]); - if (State.ST) + tmp += SEXT40 (ACC (OP[0])); + if (PSW_ST) { - if (tmp > MAX32) - State.a[OP[0]] = MAX32; - else if (tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* macsu */ @@ -1204,42 +1610,52 @@ OP_1A00 () int64 tmp; trace_input ("macsu", OP_ACCUM, OP_REG, OP_REG); - tmp = SEXT40 ((int16)State.regs[OP[1]] * State.regs[OP[2]]); - if (State.FX) - tmp = SEXT40( (tmp << 1) & MASK40); - - State.a[OP[0]] = (SEXT40 (State.a[OP[0]]) + tmp) & MASK40; - trace_output (OP_ACCUM); + tmp = SEXT40 ((int16) GPR (OP[1]) * GPR (OP[2])); + if (PSW_FX) + tmp = SEXT40 ((tmp << 1) & MASK40); + tmp = ((SEXT40 (ACC (OP[0])) + tmp) & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* macu */ void OP_3A00 () { - int64 tmp; + uint64 tmp; + uint32 src1; + uint32 src2; trace_input ("macu", OP_ACCUM, OP_REG, OP_REG); - tmp = SEXT40 (State.regs[OP[1]] * State.regs[OP[2]]); - if (State.FX) - tmp = SEXT40( (tmp << 1) & MASK40); - State.a[OP[0]] = (SEXT40 (State.a[OP[0]]) + tmp) & MASK40; - trace_output (OP_ACCUM); + src1 = (uint16) GPR (OP[1]); + src2 = (uint16) GPR (OP[2]); + tmp = src1 * src2; + if (PSW_FX) + tmp = (tmp << 1); + tmp = ((ACC (OP[0]) + tmp) & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* max */ void OP_2600 () { + int16 tmp; trace_input ("max", OP_REG, OP_REG, OP_VOID); - State.F1 = State.F0; - if ((int16)State.regs[OP[1]] > (int16)State.regs[OP[0]]) + SET_PSW_F1 (PSW_F0); + if ((int16) GPR (OP[1]) > (int16)GPR (OP[0])) { - State.regs[OP[0]] = State.regs[OP[1]]; - State.F0 = 1; + tmp = GPR (OP[1]); + SET_PSW_F0 (1); } else - State.F0 = 0; - trace_output (OP_REG); + { + tmp = GPR (OP[0]); + SET_PSW_F0 (0); + } + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* max */ @@ -1249,32 +1665,41 @@ OP_3600 () int64 tmp; trace_input ("max", OP_ACCUM, OP_DREG, OP_VOID); - State.F1 = State.F0; - tmp = SEXT16 (State.regs[OP[1]]) << 16 | State.regs[OP[1]+1]; - if (tmp > SEXT40(State.a[OP[0]])) + SET_PSW_F1 (PSW_F0); + tmp = SEXT16 (GPR (OP[1])) << 16 | GPR (OP[1] + 1); + if (tmp > SEXT40 (ACC (OP[0]))) { - State.a[OP[0]] = tmp & MASK40; - State.F0 = 1; + tmp = (tmp & MASK40); + SET_PSW_F0 (1); } else - State.F0 = 0; - trace_output (OP_ACCUM); + { + tmp = ACC (OP[0]); + SET_PSW_F0 (0); + } + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* max */ void OP_3602 () { + int64 tmp; trace_input ("max", OP_ACCUM, OP_ACCUM, OP_VOID); - State.F1 = State.F0; - if (SEXT40(State.a[OP[1]]) > SEXT40(State.a[OP[0]])) + SET_PSW_F1 (PSW_F0); + if (SEXT40 (ACC (OP[1])) > SEXT40 (ACC (OP[0]))) { - State.a[OP[0]] = State.a[OP[1]]; - State.F0 = 1; + tmp = ACC (OP[1]); + SET_PSW_F0 (1); } else - State.F0 = 0; - trace_output (OP_ACCUM); + { + tmp = ACC (OP[0]); + SET_PSW_F0 (0); + } + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } @@ -1282,16 +1707,21 @@ OP_3602 () void OP_2601 () { + int16 tmp; trace_input ("min", OP_REG, OP_REG, OP_VOID); - State.F1 = State.F0; - if ((int16)State.regs[OP[1]] < (int16)State.regs[OP[0]]) + SET_PSW_F1 (PSW_F0); + if ((int16)GPR (OP[1]) < (int16)GPR (OP[0])) { - State.regs[OP[0]] = State.regs[OP[1]]; - State.F0 = 1; + tmp = GPR (OP[1]); + SET_PSW_F0 (1); } else - State.F0 = 0; - trace_output (OP_REG); + { + tmp = GPR (OP[0]); + SET_PSW_F0 (0); + } + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* min */ @@ -1301,32 +1731,41 @@ OP_3601 () int64 tmp; trace_input ("min", OP_ACCUM, OP_DREG, OP_VOID); - State.F1 = State.F0; - tmp = SEXT16 (State.regs[OP[1]]) << 16 | State.regs[OP[1]+1]; - if (tmp < SEXT40(State.a[OP[0]])) + SET_PSW_F1 (PSW_F0); + tmp = SEXT16 (GPR (OP[1])) << 16 | GPR (OP[1] + 1); + if (tmp < SEXT40(ACC (OP[0]))) { - State.a[OP[0]] = tmp & MASK40; - State.F0 = 1; + tmp = (tmp & MASK40); + SET_PSW_F0 (1); } else - State.F0 = 0; - trace_output (OP_ACCUM); + { + tmp = ACC (OP[0]); + SET_PSW_F0 (0); + } + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* min */ void OP_3603 () { + int64 tmp; trace_input ("min", OP_ACCUM, OP_ACCUM, OP_VOID); - State.F1 = State.F0; - if (SEXT40(State.a[OP[1]]) < SEXT40(State.a[OP[0]])) + SET_PSW_F1 (PSW_F0); + if (SEXT40(ACC (OP[1])) < SEXT40(ACC (OP[0]))) { - State.a[OP[0]] = State.a[OP[1]]; - State.F0 = 1; + tmp = ACC (OP[1]); + SET_PSW_F0 (1); } else - State.F0 = 0; - trace_output (OP_ACCUM); + { + tmp = ACC (OP[0]); + SET_PSW_F0 (0); + } + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* msb */ @@ -1336,27 +1775,30 @@ OP_2800 () int64 tmp; trace_input ("msb", OP_ACCUM, OP_REG, OP_REG); - tmp = SEXT40 ((int16)(State.regs[OP[1]]) * (int16)(State.regs[OP[2]])); + tmp = SEXT40 ((int16)(GPR (OP[1])) * (int16)(GPR (OP[2]))); - if (State.FX) + if (PSW_FX) tmp = SEXT40 ((tmp << 1) & MASK40); - if (State.ST && tmp > MAX32) - tmp = MAX32; + if (PSW_ST && tmp > SEXT40(MAX32)) + tmp = (MAX32); - tmp = SEXT40(State.a[OP[0]]) - tmp; - if (State.ST) + tmp = SEXT40(ACC (OP[0])) - tmp; + if (PSW_ST) { - if (tmp > MAX32) - State.a[OP[0]] = MAX32; - else if (tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + { + tmp = (tmp & MASK40); + } + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* msbsu */ @@ -1366,36 +1808,42 @@ OP_1800 () int64 tmp; trace_input ("msbsu", OP_ACCUM, OP_REG, OP_REG); - tmp = SEXT40 ((int16)State.regs[OP[1]] * State.regs[OP[2]]); - if (State.FX) + tmp = SEXT40 ((int16)GPR (OP[1]) * GPR (OP[2])); + if (PSW_FX) tmp = SEXT40( (tmp << 1) & MASK40); - - State.a[OP[0]] = (SEXT40 (State.a[OP[0]]) - tmp) & MASK40; - trace_output (OP_ACCUM); + tmp = ((SEXT40 (ACC (OP[0])) - tmp) & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* msbu */ void OP_3800 () { - int64 tmp; + uint64 tmp; + uint32 src1; + uint32 src2; trace_input ("msbu", OP_ACCUM, OP_REG, OP_REG); - tmp = SEXT40 (State.regs[OP[1]] * State.regs[OP[2]]); - if (State.FX) - tmp = SEXT40( (tmp << 1) & MASK40); - - State.a[OP[0]] = (SEXT40 (State.a[OP[0]]) - tmp) & MASK40; - trace_output (OP_ACCUM); + src1 = (uint16) GPR (OP[1]); + src2 = (uint16) GPR (OP[2]); + tmp = src1 * src2; + if (PSW_FX) + tmp = (tmp << 1); + tmp = ((ACC (OP[0]) - tmp) & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* mul */ void OP_2E00 () { + int16 tmp; trace_input ("mul", OP_REG, OP_REG, OP_VOID); - State.regs[OP[0]] *= State.regs[OP[1]]; - trace_output (OP_REG); + tmp = GPR (OP[0]) * GPR (OP[1]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* mulx */ @@ -1405,16 +1853,17 @@ OP_2C00 () int64 tmp; trace_input ("mulx", OP_ACCUM_OUTPUT, OP_REG, OP_REG); - tmp = SEXT40 ((int16)(State.regs[OP[1]]) * (int16)(State.regs[OP[2]])); + tmp = SEXT40 ((int16)(GPR (OP[1])) * (int16)(GPR (OP[2]))); - if (State.FX) + if (PSW_FX) tmp = SEXT40 ((tmp << 1) & MASK40); - if (State.ST && tmp > MAX32) - State.a[OP[0]] = MAX32; + if (PSW_ST && tmp > SEXT40(MAX32)) + tmp = (MAX32); else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* mulxsu */ @@ -1424,237 +1873,242 @@ OP_1C00 () int64 tmp; trace_input ("mulxsu", OP_ACCUM_OUTPUT, OP_REG, OP_REG); - tmp = SEXT40 ((int16)(State.regs[OP[1]]) * State.regs[OP[2]]); + tmp = SEXT40 ((int16)(GPR (OP[1])) * GPR (OP[2])); - if (State.FX) + if (PSW_FX) tmp <<= 1; - - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* mulxu */ void OP_3C00 () { - int64 tmp; + uint64 tmp; + uint32 src1; + uint32 src2; trace_input ("mulxu", OP_ACCUM_OUTPUT, OP_REG, OP_REG); - tmp = SEXT40 (State.regs[OP[1]] * State.regs[OP[2]]); - - if (State.FX) + src1 = (uint16) GPR (OP[1]); + src2 = (uint16) GPR (OP[2]); + tmp = src1 * src2; + if (PSW_FX) tmp <<= 1; - - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* mv */ void OP_4000 () { + int16 tmp; trace_input ("mv", OP_REG_OUTPUT, OP_REG, OP_VOID); - State.regs[OP[0]] = State.regs[OP[1]]; - trace_output (OP_REG); + tmp = GPR (OP[1]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* mv2w */ void OP_5000 () { + int32 tmp; trace_input ("mv2w", OP_DREG_OUTPUT, OP_DREG, OP_VOID); - State.regs[OP[0]] = State.regs[OP[1]]; - State.regs[OP[0]+1] = State.regs[OP[1]+1]; - trace_output (OP_DREG); + tmp = GPR32 (OP[1]); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* mv2wfac */ void OP_3E00 () { + int32 tmp; trace_input ("mv2wfac", OP_DREG_OUTPUT, OP_ACCUM, OP_VOID); - State.regs[OP[0]] = (State.a[OP[1]] >> 16) & 0xffff; - State.regs[OP[0]+1] = State.a[OP[1]] & 0xffff; - trace_output (OP_DREG); + tmp = ACC (OP[1]); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* mv2wtac */ void OP_3E01 () { - trace_input ("mv2wtac", OP_ACCUM_OUTPUT, OP_DREG, OP_VOID); - State.a[OP[1]] = (SEXT16 (State.regs[OP[0]]) << 16 | State.regs[OP[0]+1]) & MASK40; - trace_output (OP_ACCUM); + int64 tmp; + trace_input ("mv2wtac", OP_DREG, OP_ACCUM_OUTPUT, OP_VOID); + tmp = ((SEXT16 (GPR (OP[0])) << 16 | GPR (OP[0] + 1)) & MASK40); + SET_ACC (OP[1], tmp); + trace_output_40 (tmp); } /* mvac */ void OP_3E03 () { + int64 tmp; trace_input ("mvac", OP_ACCUM_OUTPUT, OP_ACCUM, OP_VOID); - State.a[OP[0]] = State.a[OP[1]]; - trace_output (OP_ACCUM); + tmp = ACC (OP[1]); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* mvb */ void OP_5400 () { + int16 tmp; trace_input ("mvb", OP_REG_OUTPUT, OP_REG, OP_VOID); - State.regs[OP[0]] = SEXT8 (State.regs[OP[1]] & 0xff); - trace_output (OP_REG); + tmp = SEXT8 (GPR (OP[1]) & 0xff); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* mvf0f */ void OP_4400 () { + int16 tmp; trace_input ("mf0f", OP_REG_OUTPUT, OP_REG, OP_VOID); - if (State.F0 == 0) - State.regs[OP[0]] = State.regs[OP[1]]; - trace_output (OP_REG); + if (PSW_F0 == 0) + { + tmp = GPR (OP[1]); + SET_GPR (OP[0], tmp); + } + else + tmp = GPR (OP[0]); + trace_output_16 (tmp); } /* mvf0t */ void OP_4401 () { + int16 tmp; trace_input ("mf0t", OP_REG_OUTPUT, OP_REG, OP_VOID); - if (State.F0) - State.regs[OP[0]] = State.regs[OP[1]]; - trace_output (OP_REG); + if (PSW_F0) + { + tmp = GPR (OP[1]); + SET_GPR (OP[0], tmp); + } + else + tmp = GPR (OP[0]); + trace_output_16 (tmp); } /* mvfacg */ void OP_1E04 () { + int16 tmp; trace_input ("mvfacg", OP_REG_OUTPUT, OP_ACCUM, OP_VOID); - State.regs[OP[0]] = (State.a[OP[1]] >> 32) & 0xff; - trace_output (OP_ACCUM); + tmp = ((ACC (OP[1]) >> 32) & 0xff); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* mvfachi */ void OP_1E00 () { + int16 tmp; trace_input ("mvfachi", OP_REG_OUTPUT, OP_ACCUM, OP_VOID); - State.regs[OP[0]] = (State.a[OP[1]] >> 16) & 0xffff; - trace_output (OP_REG); + tmp = (ACC (OP[1]) >> 16); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* mvfaclo */ void OP_1E02 () { + int16 tmp; trace_input ("mvfaclo", OP_REG_OUTPUT, OP_ACCUM, OP_VOID); - State.regs[OP[0]] = State.a[OP[1]] & 0xffff; - trace_output (OP_REG); + tmp = ACC (OP[1]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* mvfc */ void OP_5200 () { + int16 tmp; trace_input ("mvfc", OP_REG_OUTPUT, OP_CR, OP_VOID); - if (OP[1] == 0) - { - /* PSW is treated specially */ - PSW = 0; - if (State.SM) PSW |= 0x8000; - if (State.EA) PSW |= 0x2000; - if (State.DB) PSW |= 0x1000; - if (State.IE) PSW |= 0x400; - if (State.RP) PSW |= 0x200; - if (State.MD) PSW |= 0x100; - if (State.FX) PSW |= 0x80; - if (State.ST) PSW |= 0x40; - if (State.F0) PSW |= 8; - if (State.F1) PSW |= 4; - if (State.C) PSW |= 1; - } - State.regs[OP[0]] = State.cregs[OP[1]]; - trace_output (OP_REG); + tmp = CREG (OP[1]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* mvtacg */ void OP_1E41 () { + int64 tmp; trace_input ("mvtacg", OP_REG, OP_ACCUM, OP_VOID); - State.a[OP[1]] &= MASK32; - State.a[OP[1]] |= (int64)(State.regs[OP[0]] & 0xff) << 32; - trace_output (OP_ACCUM_REVERSE); + tmp = ((ACC (OP[1]) & MASK32) + | ((int64)(GPR (OP[0]) & 0xff) << 32)); + SET_ACC (OP[1], tmp); + trace_output_40 (tmp); } /* mvtachi */ void OP_1E01 () { - uint16 tmp; - + uint64 tmp; trace_input ("mvtachi", OP_REG, OP_ACCUM, OP_VOID); - tmp = State.a[OP[1]] & 0xffff; - State.a[OP[1]] = (SEXT16 (State.regs[OP[0]]) << 16 | tmp) & MASK40; - trace_output (OP_ACCUM_REVERSE); + tmp = ACC (OP[1]) & 0xffff; + tmp = ((SEXT16 (GPR (OP[0])) << 16 | tmp) & MASK40); + SET_ACC (OP[1], tmp); + trace_output_40 (tmp); } /* mvtaclo */ void OP_1E21 () { + int64 tmp; trace_input ("mvtaclo", OP_REG, OP_ACCUM, OP_VOID); - State.a[OP[1]] = (SEXT16 (State.regs[OP[0]])) & MASK40; - trace_output (OP_ACCUM_REVERSE); + tmp = ((SEXT16 (GPR (OP[0]))) & MASK40); + SET_ACC (OP[1], tmp); + trace_output_40 (tmp); } /* mvtc */ void OP_5600 () { + int16 tmp; trace_input ("mvtc", OP_REG, OP_CR_OUTPUT, OP_VOID); - State.cregs[OP[1]] = State.regs[OP[0]]; - if (OP[1] == 0) - { - /* PSW is treated specially */ - State.SM = (PSW & 0x8000) ? 1 : 0; - State.EA = (PSW & 0x2000) ? 1 : 0; - State.DB = (PSW & 0x1000) ? 1 : 0; - State.IE = (PSW & 0x400) ? 1 : 0; - State.RP = (PSW & 0x200) ? 1 : 0; - State.MD = (PSW & 0x100) ? 1 : 0; - State.FX = (PSW & 0x80) ? 1 : 0; - State.ST = (PSW & 0x40) ? 1 : 0; - State.F0 = (PSW & 8) ? 1 : 0; - State.F1 = (PSW & 4) ? 1 : 0; - State.C = PSW & 1; - if (State.ST && !State.FX) - { - (*d10v_callback->printf_filtered) (d10v_callback, - "ERROR at PC 0x%x: ST can only be set when FX is set.\n", - PC<<2); - State.exception = SIGILL; - } - } - trace_output (OP_CR_REVERSE); + tmp = GPR (OP[0]); + tmp = SET_CREG (OP[1], tmp); + trace_output_16 (tmp); } /* mvub */ void OP_5401 () { + int16 tmp; trace_input ("mvub", OP_REG_OUTPUT, OP_REG, OP_VOID); - State.regs[OP[0]] = State.regs[OP[1]] & 0xff; - trace_output (OP_REG); + tmp = (GPR (OP[1]) & 0xff); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* neg */ void OP_4605 () { + int16 tmp; trace_input ("neg", OP_REG, OP_VOID, OP_VOID); - State.regs[OP[0]] = 0 - State.regs[OP[0]]; - trace_output (OP_REG); + tmp = - GPR (OP[0]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* neg */ @@ -1664,19 +2118,20 @@ OP_5605 () int64 tmp; trace_input ("neg", OP_ACCUM, OP_VOID, OP_VOID); - tmp = -SEXT40(State.a[OP[0]]); - if (State.ST) + tmp = -SEXT40(ACC (OP[0])); + if (PSW_ST) { - if ( tmp > MAX32) - State.a[OP[0]] = MAX32; - else if (tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } @@ -1685,39 +2140,73 @@ void OP_5E00 () { trace_input ("nop", OP_VOID, OP_VOID, OP_VOID); - trace_output (OP_VOID); - if (State.ins_type == INS_LEFT || State.ins_type == INS_LEFT_PARALLEL) - left_nops++; - else - right_nops++; + ins_type_counters[ (int)State.ins_type ]--; /* don't count nops as normal instructions */ + switch (State.ins_type) + { + default: + ins_type_counters[ (int)INS_UNKNOWN ]++; + break; + + case INS_LEFT_PARALLEL: + /* Don't count a parallel op that includes a NOP as a true parallel op */ + ins_type_counters[ (int)INS_RIGHT_PARALLEL ]--; + ins_type_counters[ (int)INS_RIGHT ]++; + ins_type_counters[ (int)INS_LEFT_NOPS ]++; + break; + + case INS_LEFT: + case INS_LEFT_COND_EXE: + ins_type_counters[ (int)INS_LEFT_NOPS ]++; + break; + + case INS_RIGHT_PARALLEL: + /* Don't count a parallel op that includes a NOP as a true parallel op */ + ins_type_counters[ (int)INS_LEFT_PARALLEL ]--; + ins_type_counters[ (int)INS_LEFT ]++; + ins_type_counters[ (int)INS_RIGHT_NOPS ]++; + break; + + case INS_RIGHT: + case INS_RIGHT_COND_EXE: + ins_type_counters[ (int)INS_RIGHT_NOPS ]++; + break; + } + + trace_output_void (); } /* not */ void OP_4603 () { + int16 tmp; trace_input ("not", OP_REG, OP_VOID, OP_VOID); - State.regs[OP[0]] = ~(State.regs[OP[0]]); - trace_output (OP_REG); + tmp = ~GPR (OP[0]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* or */ void OP_800 () { + int16 tmp; trace_input ("or", OP_REG, OP_REG, OP_VOID); - State.regs[OP[0]] |= State.regs[OP[1]]; - trace_output (OP_REG); + tmp = (GPR (OP[0]) | GPR (OP[1])); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* or3 */ void OP_4000000 () { + int16 tmp; trace_input ("or3", OP_REG_OUTPUT, OP_REG, OP_CONSTANT16); - State.regs[OP[0]] = State.regs[OP[1]] | OP[2]; - trace_output (OP_REG); + tmp = (GPR (OP[1]) | OP[2]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* rac */ @@ -1736,64 +2225,64 @@ OP_5201 () State.exception = SIGILL; } - State.F1 = State.F0; + SET_PSW_F1 (PSW_F0); + tmp = SEXT56 ((ACC (0) << 16) | (ACC (1) & 0xffff)); if (shift >=0) - tmp = ((State.a[0] << 16) | (State.a[1] & 0xffff)) << shift; + tmp <<= shift; else - tmp = ((State.a[0] << 16) | (State.a[1] & 0xffff)) >> -shift; - tmp = ( SEXT60(tmp) + 0x8000 ) >> 16; - if (tmp > MAX32) + tmp >>= -shift; + tmp += 0x8000; + tmp >>= 16; /* look at bits 0:43 */ + if (tmp > SEXT44 (SIGNED64 (0x0007fffffff))) { - State.regs[OP[0]] = 0x7fff; - State.regs[OP[0]+1] = 0xffff; - State.F0 = 1; + tmp = 0x7fffffff; + SET_PSW_F0 (1); } - else if (tmp < MIN32) + else if (tmp < SEXT44 (SIGNED64 (0xfff80000000))) { - State.regs[OP[0]] = 0x8000; - State.regs[OP[0]+1] = 0; - State.F0 = 1; + tmp = 0x80000000; + SET_PSW_F0 (1); } else { - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - State.F0 = 0; + SET_PSW_F0 (0); } - trace_output (OP_DREG); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* rachi */ void OP_4201 () { - int64 tmp; + signed64 tmp; int shift = SEXT3 (OP[2]); trace_input ("rachi", OP_REG_OUTPUT, OP_ACCUM, OP_CONSTANT3); - State.F1 = State.F0; + SET_PSW_F1 (PSW_F0); if (shift >=0) - tmp = SEXT44 (State.a[1]) << shift; + tmp = SEXT40 (ACC (OP[1])) << shift; else - tmp = SEXT44 (State.a[1]) >> -shift; + tmp = SEXT40 (ACC (OP[1])) >> -shift; tmp += 0x8000; - if (tmp > MAX32) + if (tmp > SEXT44 (SIGNED64 (0x0007fffffff))) { - State.regs[OP[0]] = 0x7fff; - State.F0 = 1; + tmp = 0x7fff; + SET_PSW_F0 (1); } - else if (tmp < 0xfff80000000LL) + else if (tmp < SEXT44 (SIGNED64 (0xfff80000000))) { - State.regs[OP[0]] = 0x8000; - State.F0 = 1; + tmp = 0x8000; + SET_PSW_F0 (1); } else { - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.F0 = 0; + tmp = (tmp >> 16); + SET_PSW_F0 (0); } - trace_output (OP_REG); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* rep */ @@ -1801,11 +2290,11 @@ void OP_27000000 () { trace_input ("rep", OP_REG, OP_CONSTANT16, OP_VOID); - RPT_S = PC + 1; - RPT_E = PC + OP[1]; - RPT_C = State.regs[OP[0]]; - State.RP = 1; - if (RPT_C == 0) + SET_RPT_S (PC + 1); + SET_RPT_E (PC + OP[1]); + SET_RPT_C (GPR (OP[0])); + SET_PSW_RP (1); + if (GPR (OP[0]) == 0) { (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: rep with count=0 is illegal.\n"); State.exception = SIGILL; @@ -1815,7 +2304,7 @@ OP_27000000 () (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: rep must include at least 4 instructions.\n"); State.exception = SIGILL; } - trace_output (OP_VOID); + trace_output_void (); } /* repi */ @@ -1823,11 +2312,11 @@ void OP_2F000000 () { trace_input ("repi", OP_CONSTANT16, OP_CONSTANT16, OP_VOID); - RPT_S = PC + 1; - RPT_E = PC + OP[1]; - RPT_C = OP[0]; - State.RP = 1; - if (RPT_C == 0) + SET_RPT_S (PC + 1); + SET_RPT_E (PC + OP[1]); + SET_RPT_C (OP[0]); + SET_PSW_RP (1); + if (OP[0] == 0) { (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: repi with count=0 is illegal.\n"); State.exception = SIGILL; @@ -1837,15 +2326,17 @@ OP_2F000000 () (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: repi must include at least 4 instructions.\n"); State.exception = SIGILL; } - trace_output (OP_VOID); + trace_output_void (); } /* rtd */ void OP_5F60 () { - d10v_callback->printf_filtered(d10v_callback, "ERROR: rtd - NOT IMPLEMENTED\n"); - State.exception = SIGILL; + trace_input ("rtd", OP_VOID, OP_VOID, OP_VOID); + SET_CREG (PSW_CR, DPSW); + JMP(DPC); + trace_output_void (); } /* rte */ @@ -1853,9 +2344,74 @@ void OP_5F40 () { trace_input ("rte", OP_VOID, OP_VOID, OP_VOID); - PC = BPC; - PSW = BPSW; - trace_output (OP_VOID); + SET_CREG (PSW_CR, BPSW); + JMP(BPC); + trace_output_void (); +} + +/* sac */ +void OP_5209 () +{ + int64 tmp; + + trace_input ("sac", OP_REG_OUTPUT, OP_ACCUM, OP_VOID); + + tmp = SEXT40(ACC (OP[1])); + + SET_PSW_F1 (PSW_F0); + + if (tmp > SEXT40(MAX32)) + { + tmp = (MAX32); + SET_PSW_F0 (1); + } + else if (tmp < SEXT40(MIN32)) + { + tmp = 0x80000000; + SET_PSW_F0 (1); + } + else + { + tmp = (tmp & MASK32); + SET_PSW_F0 (0); + } + + SET_GPR32 (OP[0], tmp); + + trace_output_40 (tmp); +} + +/* sachi */ +void +OP_4209 () +{ + int64 tmp; + + trace_input ("sachi", OP_REG_OUTPUT, OP_ACCUM, OP_VOID); + + tmp = SEXT40(ACC (OP[1])); + + SET_PSW_F1 (PSW_F0); + + if (tmp > SEXT40(MAX32)) + { + tmp = 0x7fff; + SET_PSW_F0 (1); + } + else if (tmp < SEXT40(MIN32)) + { + tmp = 0x8000; + SET_PSW_F0 (1); + } + else + { + tmp >>= 16; + SET_PSW_F0 (0); + } + + SET_GPR (OP[0], tmp); + + trace_output_16 (OP[0]); } /* sadd */ @@ -1865,37 +2421,94 @@ OP_1223 () int64 tmp; trace_input ("sadd", OP_ACCUM, OP_ACCUM, OP_VOID); - tmp = SEXT40(State.a[OP[0]]) + (SEXT40(State.a[OP[1]]) >> 16); - if (State.ST) + tmp = SEXT40(ACC (OP[0])) + (SEXT40(ACC (OP[1])) >> 16); + if (PSW_ST) { - if (tmp > MAX32) - State.a[OP[0]] = MAX32; - else if (tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* setf0f */ void OP_4611 () { + int16 tmp; trace_input ("setf0f", OP_REG_OUTPUT, OP_VOID, OP_VOID); - State.regs[OP[0]] = (State.F0 == 0) ? 1 : 0; - trace_output (OP_REG); + tmp = ((PSW_F0 == 0) ? 1 : 0); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* setf0t */ void OP_4613 () { + int16 tmp; trace_input ("setf0t", OP_REG_OUTPUT, OP_VOID, OP_VOID); - State.regs[OP[0]] = (State.F0 == 1) ? 1 : 0; - trace_output (OP_REG); + tmp = ((PSW_F0 == 1) ? 1 : 0); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); +} + +/* slae */ +void +OP_3220 () +{ + int64 tmp; + int16 reg; + + trace_input ("slae", OP_ACCUM, OP_REG, OP_VOID); + + reg = SEXT16 (GPR (OP[1])); + + if (reg >= 17 || reg <= -17) + { + (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: shift value %d too large.\n", reg); + State.exception = SIGILL; + return; + } + + tmp = SEXT40 (ACC (OP[0])); + + if (PSW_ST && (tmp < SEXT40 (MIN32) || tmp > SEXT40 (MAX32))) + { + (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: accumulator value 0x%.2x%.8lx out of range\n", ((int)(tmp >> 32) & 0xff), ((unsigned long) tmp) & 0xffffffff); + State.exception = SIGILL; + return; + } + + if (reg >= 0 && reg <= 16) + { + tmp = SEXT56 ((SEXT56 (tmp)) << (GPR (OP[1]))); + if (PSW_ST) + { + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); + else + tmp = (tmp & MASK40); + } + else + tmp = (tmp & MASK40); + } + else + { + tmp = (SEXT40 (ACC (OP[0]))) >> (-GPR (OP[1])); + } + + SET_ACC(OP[0], tmp); + + trace_output_40(tmp); } /* sleep */ @@ -1903,17 +2516,19 @@ void OP_5FC0 () { trace_input ("sleep", OP_VOID, OP_VOID, OP_VOID); - State.IE = 1; - trace_output (OP_VOID); + SET_PSW_IE (1); + trace_output_void (); } /* sll */ void OP_2200 () { + int16 tmp; trace_input ("sll", OP_REG, OP_REG, OP_VOID); - State.regs[OP[0]] <<= (State.regs[OP[1]] & 0xf); - trace_output (OP_REG); + tmp = (GPR (OP[0]) << (GPR (OP[1]) & 0xf)); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* sll */ @@ -1922,36 +2537,39 @@ OP_3200 () { int64 tmp; trace_input ("sll", OP_ACCUM, OP_REG, OP_VOID); - if ((State.regs[OP[1]] & 31) <= 16) - tmp = SEXT40 (State.a[OP[0]]) << (State.regs[OP[1]] & 31); + if ((GPR (OP[1]) & 31) <= 16) + tmp = SEXT40 (ACC (OP[0])) << (GPR (OP[1]) & 31); else { - (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: shift value %d too large.\n", State.regs[OP[1]] & 31); + (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: shift value %d too large.\n", GPR (OP[1]) & 31); State.exception = SIGILL; return; } - if (State.ST) + if (PSW_ST) { - if (tmp > MAX32) - State.a[OP[0]] = MAX32; - else if (tmp < 0xffffff80000000LL) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* slli */ void OP_2201 () { + int16 tmp; trace_input ("slli", OP_REG, OP_CONSTANT16, OP_VOID); - State.regs[OP[0]] <<= OP[1]; - trace_output (OP_REG); + tmp = (GPR (OP[0]) << OP[1]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* slli */ @@ -1964,40 +2582,43 @@ OP_3201 () OP[1] = 16; trace_input ("slli", OP_ACCUM, OP_CONSTANT16, OP_VOID); - tmp = SEXT40(State.a[OP[0]]) << OP[1]; + tmp = SEXT40(ACC (OP[0])) << OP[1]; - if (State.ST) + if (PSW_ST) { - if (tmp > MAX32) - State.a[OP[0]] = MAX32; - else if (tmp < 0xffffff80000000LL) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; - trace_output (OP_ACCUM); + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* slx */ void OP_460B () { - uint16 tmp; - + int16 tmp; trace_input ("slx", OP_REG, OP_FLAG, OP_VOID); - State.regs[OP[0]] = (State.regs[OP[0]] << 1) | State.F0; - trace_output (OP_REG); + tmp = ((GPR (OP[0]) << 1) | PSW_F0); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* sra */ void OP_2400 () { + int16 tmp; trace_input ("sra", OP_REG, OP_REG, OP_VOID); - State.regs[OP[0]] = ((int16)(State.regs[OP[0]])) >> (State.regs[OP[1]] & 0xf); - trace_output (OP_REG); + tmp = (((int16)(GPR (OP[0]))) >> (GPR (OP[1]) & 0xf)); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* sra */ @@ -2005,46 +2626,54 @@ void OP_3400 () { trace_input ("sra", OP_ACCUM, OP_REG, OP_VOID); - if ((State.regs[OP[1]] & 31) <= 16) - State.a[OP[0]] >>= (State.regs[OP[1]] & 31); + if ((GPR (OP[1]) & 31) <= 16) + { + int64 tmp = ((SEXT40(ACC (OP[0])) >> (GPR (OP[1]) & 31)) & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); + } else { - (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: shift value %d too large.\n", State.regs[OP[1]] & 31); + (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: shift value %d too large.\n", GPR (OP[1]) & 31); State.exception = SIGILL; return; } - - trace_output (OP_ACCUM); } /* srai */ void OP_2401 () { + int16 tmp; trace_input ("srai", OP_REG, OP_CONSTANT16, OP_VOID); - State.regs[OP[0]] = ((int16)(State.regs[OP[0]])) >> OP[1]; - trace_output (OP_REG); + tmp = (((int16)(GPR (OP[0]))) >> OP[1]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* srai */ void OP_3401 () { + int64 tmp; if (OP[1] == 0) OP[1] = 16; trace_input ("srai", OP_ACCUM, OP_CONSTANT16, OP_VOID); - State.a[OP[0]] >>= OP[1]; - trace_output (OP_ACCUM); + tmp = ((SEXT40(ACC (OP[0])) >> OP[1]) & MASK40); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* srl */ void OP_2000 () { + int16 tmp; trace_input ("srl", OP_REG, OP_REG, OP_VOID); - State.regs[OP[0]] >>= (State.regs[OP[1]] & 0xf); - trace_output (OP_REG); + tmp = (GPR (OP[0]) >> (GPR (OP[1]) & 0xf)); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* srl */ @@ -2052,37 +2681,44 @@ void OP_3000 () { trace_input ("srl", OP_ACCUM, OP_REG, OP_VOID); - if ((State.regs[OP[1]] & 31) <= 16) - State.a[OP[0]] >>= (State.regs[OP[1]] & 31); + if ((GPR (OP[1]) & 31) <= 16) + { + int64 tmp = ((uint64)((ACC (OP[0]) & MASK40) >> (GPR (OP[1]) & 31))); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); + } else { - (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: shift value %d too large.\n", State.regs[OP[1]] & 31); + (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: shift value %d too large.\n", GPR (OP[1]) & 31); State.exception = SIGILL; return; } - trace_output (OP_ACCUM); } /* srli */ void OP_2001 () { + int16 tmp; trace_input ("srli", OP_REG, OP_CONSTANT16, OP_VOID); - State.regs[OP[0]] >>= OP[1]; - trace_output (OP_REG); + tmp = (GPR (OP[0]) >> OP[1]); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* srli */ void OP_3001 () { + int64 tmp; if (OP[1] == 0) OP[1] = 16; trace_input ("srli", OP_ACCUM, OP_CONSTANT16, OP_VOID); - State.a[OP[0]] >>= OP[1]; - trace_output (OP_ACCUM); + tmp = ((uint64)(ACC (OP[0]) & MASK40) >> OP[1]); + SET_ACC (OP[0], tmp); + trace_output_40 (tmp); } /* srx */ @@ -2090,124 +2726,252 @@ void OP_4609 () { uint16 tmp; - trace_input ("srx", OP_REG, OP_FLAG, OP_VOID); - tmp = State.F0 << 15; - State.regs[OP[0]] = (State.regs[OP[0]] >> 1) | tmp; - trace_output (OP_REG); + tmp = PSW_F0 << 15; + tmp = ((GPR (OP[0]) >> 1) | tmp); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* st */ void OP_34000000 () { + uint16 addr = OP[1] + GPR (OP[2]); trace_input ("st", OP_REG, OP_MEMREF2, OP_VOID); - SW (OP[1] + State.regs[OP[2]], State.regs[OP[0]]); - trace_output (OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr, GPR (OP[0])); + trace_output_void (); } /* st */ void OP_6800 () { + uint16 addr = GPR (OP[1]); trace_input ("st", OP_REG, OP_MEMREF, OP_VOID); - SW (State.regs[OP[1]], State.regs[OP[0]]); - trace_output (OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr, GPR (OP[0])); + trace_output_void (); } /* st */ +/* st Rsrc1,@-SP */ void OP_6C1F () { + uint16 addr = GPR (OP[1]) - 2; trace_input ("st", OP_REG, OP_PREDEC, OP_VOID); - if ( OP[1] != 15 ) + if (OP[1] != 15) { (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: cannot pre-decrement any registers but r15 (SP).\n"); State.exception = SIGILL; return; } - State.regs[OP[1]] -= 2; - SW (State.regs[OP[1]], State.regs[OP[0]]); - trace_output (OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr, GPR (OP[0])); + SET_GPR (OP[1], addr); + trace_output_void (); } /* st */ void OP_6801 () { + uint16 addr = GPR (OP[1]); trace_input ("st", OP_REG, OP_POSTINC, OP_VOID); - SW (State.regs[OP[1]], State.regs[OP[0]]); - INC_ADDR (State.regs[OP[1]],2); - trace_output (OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr, GPR (OP[0])); + INC_ADDR (OP[1], 2); + trace_output_void (); } /* st */ void OP_6C01 () { + uint16 addr = GPR (OP[1]); trace_input ("st", OP_REG, OP_POSTDEC, OP_VOID); - SW (State.regs[OP[1]], State.regs[OP[0]]); - INC_ADDR (State.regs[OP[1]],-2); - trace_output (OP_VOID); + if ( OP[1] == 15 ) + { + (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: cannot post-decrement register r15 (SP).\n"); + State.exception = SIGILL; + return; + } + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr, GPR (OP[0])); + INC_ADDR (OP[1], -2); + trace_output_void (); +} + +/* st */ +void +OP_36010000 () +{ + uint16 addr = OP[1]; + trace_input ("st", OP_REG, OP_MEMREF3, OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr, GPR (OP[0])); + trace_output_void (); } /* st2w */ void OP_35000000 () { + uint16 addr = GPR (OP[2])+ OP[1]; trace_input ("st2w", OP_DREG, OP_MEMREF2, OP_VOID); - SW (State.regs[OP[2]]+OP[1], State.regs[OP[0]]); - SW (State.regs[OP[2]]+OP[1]+2, State.regs[OP[0]+1]); - trace_output (OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr + 0, GPR (OP[0] + 0)); + SW (addr + 2, GPR (OP[0] + 1)); + trace_output_void (); } /* st2w */ void OP_6A00 () { - trace_input ("st2w", OP_REG, OP_MEMREF, OP_VOID); - SW (State.regs[OP[1]], State.regs[OP[0]]); - SW (State.regs[OP[1]]+2, State.regs[OP[0]+1]); - trace_output (OP_VOID); + uint16 addr = GPR (OP[1]); + trace_input ("st2w", OP_DREG, OP_MEMREF, OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr + 0, GPR (OP[0] + 0)); + SW (addr + 2, GPR (OP[0] + 1)); + trace_output_void (); } /* st2w */ void OP_6E1F () { - trace_input ("st2w", OP_REG, OP_PREDEC, OP_VOID); + uint16 addr = GPR (OP[1]) - 4; + trace_input ("st2w", OP_DREG, OP_PREDEC, OP_VOID); if ( OP[1] != 15 ) { (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: cannot pre-decrement any registers but r15 (SP).\n"); State.exception = SIGILL; return; } - State.regs[OP[1]] -= 4; - SW (State.regs[OP[1]], State.regs[OP[0]]); - SW (State.regs[OP[1]]+2, State.regs[OP[0]+1]); - trace_output (OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr + 0, GPR (OP[0] + 0)); + SW (addr + 2, GPR (OP[0] + 1)); + SET_GPR (OP[1], addr); + trace_output_void (); } /* st2w */ void OP_6A01 () { - trace_input ("st2w", OP_REG, OP_POSTDEC, OP_VOID); - SW (State.regs[OP[1]], State.regs[OP[0]]); - SW (State.regs[OP[1]]+2, State.regs[OP[0]+1]); - INC_ADDR (State.regs[OP[1]],4); - trace_output (OP_VOID); + uint16 addr = GPR (OP[1]); + trace_input ("st2w", OP_DREG, OP_POSTINC, OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr + 0, GPR (OP[0] + 0)); + SW (addr + 2, GPR (OP[0] + 1)); + INC_ADDR (OP[1], 4); + trace_output_void (); } /* st2w */ void OP_6E01 () { - trace_input ("st2w", OP_REG, OP_POSTINC, OP_VOID); - SW (State.regs[OP[1]], State.regs[OP[0]]); - SW (State.regs[OP[1]]+2, State.regs[OP[0]+1]); - INC_ADDR (State.regs[OP[1]],-4); - trace_output (OP_VOID); + uint16 addr = GPR (OP[1]); + trace_input ("st2w", OP_DREG, OP_POSTDEC, OP_VOID); + if ( OP[1] == 15 ) + { + (*d10v_callback->printf_filtered) (d10v_callback, "ERROR: cannot post-decrement register r15 (SP).\n"); + State.exception = SIGILL; + return; + } + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr + 0, GPR (OP[0] + 0)); + SW (addr + 2, GPR (OP[0] + 1)); + INC_ADDR (OP[1], -4); + trace_output_void (); +} + +/* st2w */ +void +OP_37010000 () +{ + uint16 addr = OP[1]; + trace_input ("st2w", OP_DREG, OP_MEMREF3, OP_VOID); + if ((addr & 1)) + { + State.exception = SIG_D10V_BUS; + State.pc_changed = 1; /* Don't increment the PC. */ + trace_output_void (); + return; + } + SW (addr + 0, GPR (OP[0] + 0)); + SW (addr + 2, GPR (OP[0] + 1)); + trace_output_void (); } /* stb */ @@ -2215,8 +2979,8 @@ void OP_3C000000 () { trace_input ("stb", OP_REG, OP_MEMREF2, OP_VOID); - SB (State.regs[OP[2]]+OP[1], State.regs[OP[0]]); - trace_output (OP_VOID); + SB (GPR (OP[2]) + OP[1], GPR (OP[0])); + trace_output_void (); } /* stb */ @@ -2224,8 +2988,8 @@ void OP_7800 () { trace_input ("stb", OP_REG, OP_MEMREF, OP_VOID); - SB (State.regs[OP[1]], State.regs[OP[0]]); - trace_output (OP_VOID); + SB (GPR (OP[1]), GPR (OP[0])); + trace_output_void (); } /* stop */ @@ -2233,21 +2997,23 @@ void OP_5FE0 () { trace_input ("stop", OP_VOID, OP_VOID, OP_VOID); - State.exception = SIGQUIT; - trace_output (OP_VOID); + State.exception = SIG_D10V_STOP; + trace_output_void (); } /* sub */ void OP_0 () { - int32 tmp; - + uint16 a = GPR (OP[0]); + uint16 b = GPR (OP[1]); + uint16 tmp = (a - b); trace_input ("sub", OP_REG, OP_REG, OP_VOID); - tmp = (int16)State.regs[OP[0]]- (int16)State.regs[OP[1]]; - State.C = (tmp & 0xffff0000) ? 1 : 0; - State.regs[OP[0]] = tmp & 0xffff; - trace_output (OP_REG); + /* see ../common/sim-alu.h for a more extensive discussion on how to + compute the carry/overflow bits. */ + SET_PSW_C (a >= b); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* sub */ @@ -2257,20 +3023,21 @@ OP_1001 () int64 tmp; trace_input ("sub", OP_ACCUM, OP_DREG, OP_VOID); - tmp = SEXT40(State.a[OP[0]]) - (SEXT16 (State.regs[OP[1]]) << 16 | State.regs[OP[1]+1]); - if (State.ST) + tmp = SEXT40(ACC (OP[0])) - (SEXT16 (GPR (OP[1])) << 16 | GPR (OP[1] + 1)); + if (PSW_ST) { - if ( tmp > MAX32) - State.a[OP[0]] = MAX32; - else if ( tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); - trace_output (OP_ACCUM); + trace_output_40 (tmp); } /* sub */ @@ -2281,37 +3048,38 @@ OP_1003 () int64 tmp; trace_input ("sub", OP_ACCUM, OP_ACCUM, OP_VOID); - tmp = SEXT40(State.a[OP[0]]) - SEXT40(State.a[OP[1]]); - if (State.ST) + tmp = SEXT40(ACC (OP[0])) - SEXT40(ACC (OP[1])); + if (PSW_ST) { - if (tmp > MAX32) - State.a[OP[0]] = MAX32; - else if ( tmp < MIN32) - State.a[OP[0]] = MIN32; + if (tmp > SEXT40(MAX32)) + tmp = (MAX32); + else if (tmp < SEXT40(MIN32)) + tmp = (MIN32); else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); } else - State.a[OP[0]] = tmp & MASK40; + tmp = (tmp & MASK40); + SET_ACC (OP[0], tmp); - trace_output (OP_ACCUM); + trace_output_40 (tmp); } /* sub2w */ void OP_1000 () { - int64 tmp; - int32 a,b; + uint32 tmp, a, b; trace_input ("sub2w", OP_DREG, OP_DREG, OP_VOID); - a = (int32)((State.regs[OP[0]] << 16) | State.regs[OP[0]+1]); - b = (int32)((State.regs[OP[1]] << 16) | State.regs[OP[1]+1]); - tmp = a-b; - State.C = (tmp & 0xffffffff00000000LL) ? 1 : 0; - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - trace_output (OP_DREG); + a = (uint32)((GPR (OP[0]) << 16) | GPR (OP[0] + 1)); + b = (uint32)((GPR (OP[1]) << 16) | GPR (OP[1] + 1)); + /* see ../common/sim-alu.h for a more extensive discussion on how to + compute the carry/overflow bits */ + tmp = a - b; + SET_PSW_C (a >= b); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* subac3 */ @@ -2321,10 +3089,9 @@ OP_17000000 () int64 tmp; trace_input ("subac3", OP_DREG_OUTPUT, OP_DREG, OP_ACCUM); - tmp = SEXT40 ((State.regs[OP[1]] << 16) | State.regs[OP[1]+1]) - SEXT40 (State.a[OP[2]]); - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - trace_output (OP_DREG); + tmp = SEXT40 ((GPR (OP[1]) << 16) | GPR (OP[1] + 1)) - SEXT40 (ACC (OP[2])); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* subac3 */ @@ -2334,10 +3101,9 @@ OP_17000002 () int64 tmp; trace_input ("subac3", OP_DREG_OUTPUT, OP_ACCUM, OP_ACCUM); - tmp = SEXT40(State.a[OP[1]]) - SEXT40(State.a[OP[2]]); - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - trace_output (OP_DREG); + tmp = SEXT40 (ACC (OP[1])) - SEXT40(ACC (OP[2])); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* subac3s */ @@ -2347,27 +3113,24 @@ OP_17001000 () int64 tmp; trace_input ("subac3s", OP_DREG_OUTPUT, OP_DREG, OP_ACCUM); - State.F1 = State.F0; - tmp = SEXT40 ((State.regs[OP[1]] << 16) | State.regs[OP[1]+1]) - SEXT40(State.a[OP[2]]); - if ( tmp > MAX32) + SET_PSW_F1 (PSW_F0); + tmp = SEXT40 ((GPR (OP[1]) << 16) | GPR (OP[1] + 1)) - SEXT40(ACC (OP[2])); + if (tmp > SEXT40(MAX32)) { - State.regs[OP[0]] = 0x7fff; - State.regs[OP[0]+1] = 0xffff; - State.F0 = 1; + tmp = (MAX32); + SET_PSW_F0 (1); } - else if (tmp < MIN32) + else if (tmp < SEXT40(MIN32)) { - State.regs[OP[0]] = 0x8000; - State.regs[OP[0]+1] = 0; - State.F0 = 1; + tmp = (MIN32); + SET_PSW_F0 (1); } else { - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - State.F0 = 0; + SET_PSW_F0 (0); } - trace_output (OP_DREG); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* subac3s */ @@ -2377,171 +3140,374 @@ OP_17001002 () int64 tmp; trace_input ("subac3s", OP_DREG_OUTPUT, OP_ACCUM, OP_ACCUM); - State.F1 = State.F0; - tmp = SEXT40(State.a[OP[1]]) - SEXT40(State.a[OP[2]]); - if ( tmp > MAX32) + SET_PSW_F1 (PSW_F0); + tmp = SEXT40(ACC (OP[1])) - SEXT40(ACC (OP[2])); + if (tmp > SEXT40(MAX32)) { - State.regs[OP[0]] = 0x7fff; - State.regs[OP[0]+1] = 0xffff; - State.F0 = 1; + tmp = (MAX32); + SET_PSW_F0 (1); } - else if (tmp < MIN32) + else if (tmp < SEXT40(MIN32)) { - State.regs[OP[0]] = 0x8000; - State.regs[OP[0]+1] = 0; - State.F0 = 1; + tmp = (MIN32); + SET_PSW_F0 (1); } else { - State.regs[OP[0]] = (tmp >> 16) & 0xffff; - State.regs[OP[0]+1] = tmp & 0xffff; - State.F0 = 0; + SET_PSW_F0 (0); } - trace_output (OP_DREG); + SET_GPR32 (OP[0], tmp); + trace_output_32 (tmp); } /* subi */ void OP_1 () { - int32 tmp; + unsigned tmp; if (OP[1] == 0) OP[1] = 16; trace_input ("subi", OP_REG, OP_CONSTANT16, OP_VOID); - tmp = (int16)State.regs[OP[0]] - OP[1]; - State.C = (tmp & 0xffff0000) ? 1 : 0; - State.regs[OP[0]] = tmp & 0xffff; - trace_output (OP_REG); + /* see ../common/sim-alu.h for a more extensive discussion on how to + compute the carry/overflow bits. */ + /* since OP[1] is never <= 0, -OP[1] == ~OP[1]+1 can never overflow */ + tmp = ((unsigned)(unsigned16) GPR (OP[0]) + + (unsigned)(unsigned16) ( - OP[1])); + SET_PSW_C (tmp >= (1 << 16)); + SET_GPR (OP[0], tmp); + trace_output_16 (tmp); } /* trap */ void OP_5F00 () { - trace_input ("trap", OP_CONSTANT16, OP_REG, OP_VOID); - trace_output (OP_VOID); - + trace_input ("trap", OP_CONSTANT4, OP_VOID, OP_VOID); + trace_output_void (); + switch (OP[0]) { default: - (*d10v_callback->printf_filtered) (d10v_callback, "Unknown trap code %d\n", OP[0]); - State.exception = SIGILL; +#if (DEBUG & DEBUG_TRAP) == 0 + { + uint16 vec = OP[0] + TRAP_VECTOR_START; + SET_BPC (PC + 1); + SET_BPSW (PSW); + SET_PSW (PSW & PSW_SM_BIT); + JMP (vec); + break; + } +#else /* if debugging use trap to print registers */ + { + int i; + static int first_time = 1; + + if (first_time) + { + first_time = 0; + (*d10v_callback->printf_filtered) (d10v_callback, "Trap # PC "); + for (i = 0; i < 16; i++) + (*d10v_callback->printf_filtered) (d10v_callback, " %sr%d", (i > 9) ? "" : " ", i); + (*d10v_callback->printf_filtered) (d10v_callback, " a0 a1 f0 f1 c\n"); + } + + (*d10v_callback->printf_filtered) (d10v_callback, "Trap %2d 0x%.4x:", (int)OP[0], (int)PC); + + for (i = 0; i < 16; i++) + (*d10v_callback->printf_filtered) (d10v_callback, " %.4x", (int) GPR (i)); + + for (i = 0; i < 2; i++) + (*d10v_callback->printf_filtered) (d10v_callback, " %.2x%.8lx", + ((int)(ACC (i) >> 32) & 0xff), + ((unsigned long) ACC (i)) & 0xffffffff); - case 0: - /* Trap 0 is used for simulating low-level I/O */ + (*d10v_callback->printf_filtered) (d10v_callback, " %d %d %d\n", + PSW_F0 != 0, PSW_F1 != 0, PSW_C != 0); + (*d10v_callback->flush_stdout) (d10v_callback); + break; + } +#endif + case 15: /* new system call trap */ + /* Trap 15 is used for simulating low-level I/O */ { - int save_errno = errno; + unsigned32 result = 0; errno = 0; /* Registers passed to trap 0 */ -#define FUNC State.regs[2] /* function number, return value */ -#define PARM1 State.regs[3] /* optional parm 1 */ -#define PARM2 State.regs[4] /* optional parm 2 */ -#define PARM3 State.regs[5] /* optional parm 3 */ +#define FUNC GPR (4) /* function number */ +#define PARM1 GPR (0) /* optional parm 1 */ +#define PARM2 GPR (1) /* optional parm 2 */ +#define PARM3 GPR (2) /* optional parm 3 */ +#define PARM4 GPR (3) /* optional parm 3 */ /* Registers set by trap 0 */ -#define RETVAL State.regs[2] /* return value */ -#define RETERR State.regs[3] /* return error code */ +#define RETVAL(X) do { result = (X); SET_GPR (0, result); } while (0) +#define RETVAL32(X) do { result = (X); SET_GPR (0, result >> 16); SET_GPR (1, result); } while (0) +#define RETERR(X) SET_GPR (4, (X)) /* return error code */ /* Turn a pointer in a register into a pointer into real memory. */ -#define MEMPTR(x) ((char *)((x) + State.imem)) +#define MEMPTR(x) ((char *)(dmem_addr(x))) switch (FUNC) { #if !defined(__GO32__) && !defined(_WIN32) -#ifdef SYS_fork - case SYS_fork: - RETVAL = fork (); + case TARGET_SYS_fork: + trace_input ("", OP_VOID, OP_VOID, OP_VOID); + RETVAL (fork ()); + trace_output_16 (result); break; -#endif -#ifdef SYS_execve - case SYS_execve: - RETVAL = execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), - (char **)MEMPTR (PARM3)); + +#define getpid() 47 + case TARGET_SYS_getpid: + trace_input ("", OP_VOID, OP_VOID, OP_VOID); + RETVAL (getpid ()); + trace_output_16 (result); break; + + case TARGET_SYS_kill: + trace_input ("", OP_R0, OP_R1, OP_VOID); + if (PARM1 == getpid ()) + { + trace_output_void (); + State.exception = PARM2; + } + else + { + int os_sig = -1; + switch (PARM2) + { +#ifdef SIGHUP + case 1: os_sig = SIGHUP; break; +#endif +#ifdef SIGINT + case 2: os_sig = SIGINT; break; +#endif +#ifdef SIGQUIT + case 3: os_sig = SIGQUIT; break; +#endif +#ifdef SIGILL + case 4: os_sig = SIGILL; break; +#endif +#ifdef SIGTRAP + case 5: os_sig = SIGTRAP; break; +#endif +#ifdef SIGABRT + case 6: os_sig = SIGABRT; break; +#elif defined(SIGIOT) + case 6: os_sig = SIGIOT; break; +#endif +#ifdef SIGEMT + case 7: os_sig = SIGEMT; break; +#endif +#ifdef SIGFPE + case 8: os_sig = SIGFPE; break; +#endif +#ifdef SIGKILL + case 9: os_sig = SIGKILL; break; +#endif +#ifdef SIGBUS + case 10: os_sig = SIGBUS; break; #endif -#ifdef SYS_execv - case SYS_execv: - RETVAL = execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), NULL); +#ifdef SIGSEGV + case 11: os_sig = SIGSEGV; break; +#endif +#ifdef SIGSYS + case 12: os_sig = SIGSYS; break; +#endif +#ifdef SIGPIPE + case 13: os_sig = SIGPIPE; break; +#endif +#ifdef SIGALRM + case 14: os_sig = SIGALRM; break; +#endif +#ifdef SIGTERM + case 15: os_sig = SIGTERM; break; +#endif +#ifdef SIGURG + case 16: os_sig = SIGURG; break; +#endif +#ifdef SIGSTOP + case 17: os_sig = SIGSTOP; break; +#endif +#ifdef SIGTSTP + case 18: os_sig = SIGTSTP; break; +#endif +#ifdef SIGCONT + case 19: os_sig = SIGCONT; break; +#endif +#ifdef SIGCHLD + case 20: os_sig = SIGCHLD; break; +#elif defined(SIGCLD) + case 20: os_sig = SIGCLD; break; +#endif +#ifdef SIGTTIN + case 21: os_sig = SIGTTIN; break; +#endif +#ifdef SIGTTOU + case 22: os_sig = SIGTTOU; break; +#endif +#ifdef SIGIO + case 23: os_sig = SIGIO; break; +#elif defined (SIGPOLL) + case 23: os_sig = SIGPOLL; break; +#endif +#ifdef SIGXCPU + case 24: os_sig = SIGXCPU; break; +#endif +#ifdef SIGXFSZ + case 25: os_sig = SIGXFSZ; break; +#endif +#ifdef SIGVTALRM + case 26: os_sig = SIGVTALRM; break; +#endif +#ifdef SIGPROF + case 27: os_sig = SIGPROF; break; +#endif +#ifdef SIGWINCH + case 28: os_sig = SIGWINCH; break; +#endif +#ifdef SIGLOST + case 29: os_sig = SIGLOST; break; +#endif +#ifdef SIGUSR1 + case 30: os_sig = SIGUSR1; break; +#endif +#ifdef SIGUSR2 + case 31: os_sig = SIGUSR2; break; +#endif + } + + if (os_sig == -1) + { + trace_output_void (); + (*d10v_callback->printf_filtered) (d10v_callback, "Unknown signal %d\n", PARM2); + (*d10v_callback->flush_stdout) (d10v_callback); + State.exception = SIGILL; + } + else + { + RETVAL (kill (PARM1, PARM2)); + trace_output_16 (result); + } + } + break; + + case TARGET_SYS_execve: + trace_input ("", OP_R0, OP_R1, OP_R2); + RETVAL (execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), + (char **)MEMPTR (PARM3))); + trace_output_16 (result); + break; + +#ifdef TARGET_SYS_execv + case TARGET_SYS_execv: + trace_input ("", OP_R0, OP_R1, OP_VOID); + RETVAL (execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), NULL)); + trace_output_16 (result); break; #endif -#ifdef SYS_pipe - case SYS_pipe: + + case TARGET_SYS_pipe: { reg_t buf; int host_fd[2]; + trace_input ("", OP_R0, OP_VOID, OP_VOID); buf = PARM1; - RETVAL = pipe (host_fd); + RETVAL (pipe (host_fd)); SW (buf, host_fd[0]); buf += sizeof(uint16); SW (buf, host_fd[1]); + trace_output_16 (result); } break; -#endif -#ifdef SYS_wait - case SYS_wait: + +#if 0 +#ifdef TARGET_SYS_wait + case TARGET_SYS_wait: { int status; - - RETVAL = wait (&status); - SW (PARM1, status); + trace_input ("", OP_R0, OP_VOID, OP_VOID); + RETVAL (wait (&status)); + if (PARM1) + SW (PARM1, status); + trace_output_16 (result); } break; #endif #endif +#else + case TARGET_SYS_getpid: + trace_input ("", OP_VOID, OP_VOID, OP_VOID); + RETVAL (1); + trace_output_16 (result); + break; -#ifdef SYS_read - case SYS_read: - RETVAL = d10v_callback->read (d10v_callback, PARM1, MEMPTR (PARM2), - PARM3); + case TARGET_SYS_kill: + trace_input ("", OP_REG, OP_REG, OP_VOID); + trace_output_void (); + State.exception = PARM2; break; #endif -#ifdef SYS_write - case SYS_write: + + case TARGET_SYS_read: + trace_input ("", OP_R0, OP_R1, OP_R2); + RETVAL (d10v_callback->read (d10v_callback, PARM1, MEMPTR (PARM2), + PARM3)); + trace_output_16 (result); + break; + + case TARGET_SYS_write: + trace_input ("", OP_R0, OP_R1, OP_R2); if (PARM1 == 1) - RETVAL = (int)d10v_callback->write_stdout (d10v_callback, - MEMPTR (PARM2), PARM3); + RETVAL ((int)d10v_callback->write_stdout (d10v_callback, + MEMPTR (PARM2), PARM3)); else - RETVAL = (int)d10v_callback->write (d10v_callback, PARM1, - MEMPTR (PARM2), PARM3); + RETVAL ((int)d10v_callback->write (d10v_callback, PARM1, + MEMPTR (PARM2), PARM3)); + trace_output_16 (result); break; -#endif -#ifdef SYS_lseek - case SYS_lseek: - RETVAL = d10v_callback->lseek (d10v_callback, PARM1, PARM2, PARM3); + + case TARGET_SYS_lseek: + trace_input ("", OP_R0, OP_R1, OP_R2); + RETVAL32 (d10v_callback->lseek (d10v_callback, PARM1, + ((((unsigned long) PARM2) << 16) + || (unsigned long) PARM3), + PARM4)); + trace_output_32 (result); break; -#endif -#ifdef SYS_close - case SYS_close: - RETVAL = d10v_callback->close (d10v_callback, PARM1); + + case TARGET_SYS_close: + trace_input ("", OP_R0, OP_VOID, OP_VOID); + RETVAL (d10v_callback->close (d10v_callback, PARM1)); + trace_output_16 (result); break; -#endif -#ifdef SYS_open - case SYS_open: - RETVAL = d10v_callback->open (d10v_callback, MEMPTR (PARM1), PARM2); + + case TARGET_SYS_open: + trace_input ("", OP_R0, OP_R1, OP_R2); + RETVAL (d10v_callback->open (d10v_callback, MEMPTR (PARM1), PARM2)); + trace_output_16 (result); break; -#endif -#ifdef SYS_exit - case SYS_exit: - /* EXIT - caller can look in PARM1 to work out the - reason */ - State.exception = SIGQUIT; + + case TARGET_SYS_exit: + trace_input ("", OP_R0, OP_VOID, OP_VOID); + State.exception = SIG_D10V_EXIT; + trace_output_void (); break; -#endif -#ifdef SYS_stat - case SYS_stat: +#ifdef TARGET_SYS_stat + case TARGET_SYS_stat: + trace_input ("", OP_R0, OP_R1, OP_VOID); /* stat system call */ { struct stat host_stat; reg_t buf; - RETVAL = stat (MEMPTR (PARM1), &host_stat); + RETVAL (stat (MEMPTR (PARM1), &host_stat)); buf = PARM2; @@ -2560,57 +3526,53 @@ OP_5F00 () SLW (buf+28, host_stat.st_mtime); SLW (buf+36, host_stat.st_ctime); } + trace_output_16 (result); break; #endif -#ifdef SYS_chown - case SYS_chown: - RETVAL = chown (MEMPTR (PARM1), PARM2, PARM3); + case TARGET_SYS_chown: + trace_input ("", OP_R0, OP_R1, OP_R2); + RETVAL (chown (MEMPTR (PARM1), PARM2, PARM3)); + trace_output_16 (result); break; -#endif -#ifdef SYS_chmod - case SYS_chmod: - RETVAL = chmod (MEMPTR (PARM1), PARM2); + + case TARGET_SYS_chmod: + trace_input ("", OP_R0, OP_R1, OP_R2); + RETVAL (chmod (MEMPTR (PARM1), PARM2)); + trace_output_16 (result); break; -#endif -#ifdef SYS_utime - case SYS_utime: + +#if 0 +#ifdef TARGET_SYS_utime + case TARGET_SYS_utime: + trace_input ("", OP_R0, OP_R1, OP_R2); /* Cast the second argument to void *, to avoid type mismatch if a prototype is present. */ - RETVAL = utime (MEMPTR (PARM1), (void *) MEMPTR (PARM2)); + RETVAL (utime (MEMPTR (PARM1), (void *) MEMPTR (PARM2))); + trace_output_16 (result); break; #endif +#endif + +#if 0 +#ifdef TARGET_SYS_time + case TARGET_SYS_time: + trace_input ("