/* Build the opcode handler table */
void m68ki_build_opcode_table(void);
-extern void (*m68ki_instruction_jump_table[0x10000])(void); /* opcode handler jump table */
+struct m68ki_cpu_core;
+
+extern void (*m68ki_instruction_jump_table[0x10000])(struct m68ki_cpu_core *state); /* opcode handler jump table */
extern unsigned char m68ki_cycles[][0x10000];
#define NUM_CPU_TYPES 5
-void (*m68ki_instruction_jump_table[0x10000])(void); /* opcode handler jump table */
+void (*m68ki_instruction_jump_table[0x10000])(m68ki_cpu_core *state); /* opcode handler jump table */
unsigned char m68ki_cycles[NUM_CPU_TYPES][0x10000]; /* Cycles used by CPU type */
/* This is used to generate the opcode handler jump table */
typedef struct
{
- void (*opcode_handler)(void); /* handler function */
+ void (*opcode_handler)(m68ki_cpu_core *state); /* handler function */
unsigned int mask; /* mask on opcode */
unsigned int match; /* what to match after masking */
unsigned char cycles[NUM_CPU_TYPES]; /* cycles each cpu type takes */
#include <stdio.h>
#include "m68kcpu.h"
-extern void m68040_fpu_op0(void);
-extern void m68040_fpu_op1(void);
-extern void m68851_mmu_ops();
-extern void m68881_ftrap();
+extern void m68040_fpu_op0(m68ki_cpu_core *state);
+extern void m68040_fpu_op1(m68ki_cpu_core *state);
+extern void m68851_mmu_ops(m68ki_cpu_core *state);
+extern void m68881_ftrap(m68ki_cpu_core *state);
/* ======================================================================== */
/* ========================= INSTRUCTION HANDLERS ========================= */
M68KMAKE_OP(1010, 0, ., .)
{
- m68ki_exception_1010();
+ m68ki_exception_1010(state);
}
M68KMAKE_OP(1111, 0, ., .)
{
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
// printf("FPU 040fpu0 HAS_FPU=%d\n",!!HAS_FPU);
if(HAS_FPU)
{
- m68040_fpu_op0();
+ m68040_fpu_op0(state);
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
// printf("FPU 040fpu1 HAS_FPU=%d\n",!!HAS_FPU);
if(HAS_FPU)
{
- m68040_fpu_op1();
+ m68040_fpu_op1(state);
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
M68KMAKE_OP(abcd, 8, mm, ax7)
{
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea = EA_A7_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
uint corf = 0;
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(abcd, 8, mm, ay7)
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea = EA_AX_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
uint corf = 0;
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(abcd, 8, mm, axy7)
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea = EA_A7_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
uint corf = 0;
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(abcd, 8, mm, .)
{
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea = EA_AX_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
uint corf = 0;
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
{
uint ea = M68KMAKE_GET_EA_AY_8;
uint src = MASK_OUT_ABOVE_8(DX);
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = src + dst;
FLAG_N = NFLAG_8(res);
FLAG_X = FLAG_C = CFLAG_8(res);
FLAG_Z = MASK_OUT_ABOVE_8(res);
- m68ki_write_8(ea, FLAG_Z);
+ m68ki_write_8(state, ea, FLAG_Z);
}
{
uint ea = M68KMAKE_GET_EA_AY_16;
uint src = MASK_OUT_ABOVE_16(DX);
- uint dst = m68ki_read_16(ea);
+ uint dst = m68ki_read_16(state, ea);
uint res = src + dst;
FLAG_N = NFLAG_16(res);
FLAG_X = FLAG_C = CFLAG_16(res);
FLAG_Z = MASK_OUT_ABOVE_16(res);
- m68ki_write_16(ea, FLAG_Z);
+ m68ki_write_16(state, ea, FLAG_Z);
}
{
uint ea = M68KMAKE_GET_EA_AY_32;
uint src = DX;
- uint dst = m68ki_read_32(ea);
+ uint dst = m68ki_read_32(state, ea);
uint res = src + dst;
FLAG_N = NFLAG_32(res);
FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
FLAG_Z = MASK_OUT_ABOVE_32(res);
- m68ki_write_32(ea, FLAG_Z);
+ m68ki_write_32(state, ea, FLAG_Z);
}
M68KMAKE_OP(addi, 8, ., d)
{
uint* r_dst = &DY;
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint dst = MASK_OUT_ABOVE_8(*r_dst);
uint res = src + dst;
M68KMAKE_OP(addi, 8, ., .)
{
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = src + dst;
FLAG_N = NFLAG_8(res);
FLAG_X = FLAG_C = CFLAG_8(res);
FLAG_Z = MASK_OUT_ABOVE_8(res);
- m68ki_write_8(ea, FLAG_Z);
+ m68ki_write_8(state, ea, FLAG_Z);
}
M68KMAKE_OP(addi, 16, ., d)
{
uint* r_dst = &DY;
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint dst = MASK_OUT_ABOVE_16(*r_dst);
uint res = src + dst;
M68KMAKE_OP(addi, 16, ., .)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
- uint dst = m68ki_read_16(ea);
+ uint dst = m68ki_read_16(state, ea);
uint res = src + dst;
FLAG_N = NFLAG_16(res);
FLAG_X = FLAG_C = CFLAG_16(res);
FLAG_Z = MASK_OUT_ABOVE_16(res);
- m68ki_write_16(ea, FLAG_Z);
+ m68ki_write_16(state, ea, FLAG_Z);
}
M68KMAKE_OP(addi, 32, ., d)
{
uint* r_dst = &DY;
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint dst = *r_dst;
uint res = src + dst;
M68KMAKE_OP(addi, 32, ., .)
{
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint ea = M68KMAKE_GET_EA_AY_32;
- uint dst = m68ki_read_32(ea);
+ uint dst = m68ki_read_32(state, ea);
uint res = src + dst;
FLAG_N = NFLAG_32(res);
FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
FLAG_Z = MASK_OUT_ABOVE_32(res);
- m68ki_write_32(ea, FLAG_Z);
+ m68ki_write_32(state, ea, FLAG_Z);
}
{
uint src = (((REG_IR >> 9) - 1) & 7) + 1;
uint ea = M68KMAKE_GET_EA_AY_8;
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = src + dst;
FLAG_N = NFLAG_8(res);
FLAG_X = FLAG_C = CFLAG_8(res);
FLAG_Z = MASK_OUT_ABOVE_8(res);
- m68ki_write_8(ea, FLAG_Z);
+ m68ki_write_8(state, ea, FLAG_Z);
}
{
uint src = (((REG_IR >> 9) - 1) & 7) + 1;
uint ea = M68KMAKE_GET_EA_AY_16;
- uint dst = m68ki_read_16(ea);
+ uint dst = m68ki_read_16(state, ea);
uint res = src + dst;
FLAG_N = NFLAG_16(res);
FLAG_X = FLAG_C = CFLAG_16(res);
FLAG_Z = MASK_OUT_ABOVE_16(res);
- m68ki_write_16(ea, FLAG_Z);
+ m68ki_write_16(state, ea, FLAG_Z);
}
{
uint src = (((REG_IR >> 9) - 1) & 7) + 1;
uint ea = M68KMAKE_GET_EA_AY_32;
- uint dst = m68ki_read_32(ea);
+ uint dst = m68ki_read_32(state, ea);
uint res = src + dst;
FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
FLAG_Z = MASK_OUT_ABOVE_32(res);
- m68ki_write_32(ea, FLAG_Z);
+ m68ki_write_32(state, ea, FLAG_Z);
}
M68KMAKE_OP(addx, 8, mm, ax7)
{
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea = EA_A7_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = src + dst + XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(addx, 8, mm, ay7)
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea = EA_AX_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = src + dst + XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(addx, 8, mm, axy7)
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea = EA_A7_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = src + dst + XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(addx, 8, mm, .)
{
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea = EA_AX_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = src + dst + XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(addx, 16, mm, .)
{
- uint src = OPER_AY_PD_16();
+ uint src = OPER_AY_PD_16(state);
uint ea = EA_AX_PD_16();
- uint dst = m68ki_read_16(ea);
+ uint dst = m68ki_read_16(state, ea);
uint res = src + dst + XFLAG_AS_1();
FLAG_N = NFLAG_16(res);
res = MASK_OUT_ABOVE_16(res);
FLAG_Z |= res;
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
}
M68KMAKE_OP(addx, 32, mm, .)
{
- uint src = OPER_AY_PD_32();
+ uint src = OPER_AY_PD_32(state);
uint ea = EA_AX_PD_32();
- uint dst = m68ki_read_32(ea);
+ uint dst = m68ki_read_32(state, ea);
uint res = src + dst + XFLAG_AS_1();
FLAG_N = NFLAG_32(res);
res = MASK_OUT_ABOVE_32(res);
FLAG_Z |= res;
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
}
M68KMAKE_OP(and, 8, re, .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint res = DX & m68ki_read_8(ea);
+ uint res = DX & m68ki_read_8(state, ea);
FLAG_N = NFLAG_8(res);
FLAG_C = CFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
FLAG_Z = MASK_OUT_ABOVE_8(res);
- m68ki_write_8(ea, FLAG_Z);
+ m68ki_write_8(state, ea, FLAG_Z);
}
M68KMAKE_OP(and, 16, re, .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint res = DX & m68ki_read_16(ea);
+ uint res = DX & m68ki_read_16(state, ea);
FLAG_N = NFLAG_16(res);
FLAG_C = CFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
FLAG_Z = MASK_OUT_ABOVE_16(res);
- m68ki_write_16(ea, FLAG_Z);
+ m68ki_write_16(state, ea, FLAG_Z);
}
M68KMAKE_OP(and, 32, re, .)
{
uint ea = M68KMAKE_GET_EA_AY_32;
- uint res = DX & m68ki_read_32(ea);
+ uint res = DX & m68ki_read_32(state, ea);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
}
M68KMAKE_OP(andi, 8, ., d)
{
- FLAG_Z = MASK_OUT_ABOVE_8(DY &= (OPER_I_8() | 0xffffff00));
+ FLAG_Z = MASK_OUT_ABOVE_8(DY &= (OPER_I_8(state) | 0xffffff00));
FLAG_N = NFLAG_8(FLAG_Z);
FLAG_C = CFLAG_CLEAR;
M68KMAKE_OP(andi, 8, ., .)
{
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint res = src & m68ki_read_8(ea);
+ uint res = src & m68ki_read_8(state, ea);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(andi, 16, ., d)
{
- FLAG_Z = MASK_OUT_ABOVE_16(DY &= (OPER_I_16() | 0xffff0000));
+ FLAG_Z = MASK_OUT_ABOVE_16(DY &= (OPER_I_16(state) | 0xffff0000));
FLAG_N = NFLAG_16(FLAG_Z);
FLAG_C = CFLAG_CLEAR;
M68KMAKE_OP(andi, 16, ., .)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
- uint res = src & m68ki_read_16(ea);
+ uint res = src & m68ki_read_16(state, ea);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
}
M68KMAKE_OP(andi, 32, ., d)
{
- FLAG_Z = DY &= (OPER_I_32());
+ FLAG_Z = DY &= (OPER_I_32(state));
FLAG_N = NFLAG_32(FLAG_Z);
FLAG_C = CFLAG_CLEAR;
M68KMAKE_OP(andi, 32, ., .)
{
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint ea = M68KMAKE_GET_EA_AY_32;
- uint res = src & m68ki_read_32(ea);
+ uint res = src & m68ki_read_32(state, ea);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
}
M68KMAKE_OP(andi, 16, toc, .)
{
- m68ki_set_ccr(m68ki_get_ccr() & OPER_I_8());
+ m68ki_set_ccr(state, m68ki_get_ccr(state) & OPER_I_8(state));
}
{
if(FLAG_S)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_set_sr(m68ki_get_sr() & src);
+ m68ki_set_sr(state, m68ki_get_sr() & src);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
M68KMAKE_OP(asr, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = src >> 1;
if(GET_MSB_16(src))
res |= 0x8000;
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(asl, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = MASK_OUT_ABOVE_16(src << 1);
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
if(M68KMAKE_CC)
{
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ m68ki_branch_8(state, MASK_OUT_ABOVE_8(REG_IR));
return;
}
USE_CYCLES(CYC_BCC_NOTAKE_B);
{
if(M68KMAKE_CC)
{
- uint offset = OPER_I_16();
+ uint offset = OPER_I_16(state);
REG_PC -= 2;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_16(offset);
+ m68ki_branch_16(state, offset);
return;
}
REG_PC += 2;
{
if(M68KMAKE_CC)
{
- uint offset = OPER_I_32();
+ uint offset = OPER_I_32(state);
REG_PC -= 4;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_32(offset);
+ m68ki_branch_32(state, offset);
return;
}
REG_PC += 4;
if(M68KMAKE_CC)
{
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ m68ki_branch_8(state, MASK_OUT_ABOVE_8(REG_IR));
return;
}
USE_CYCLES(CYC_BCC_NOTAKE_B);
M68KMAKE_OP(bchg, 8, r, .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint src = m68ki_read_8(ea);
+ uint src = m68ki_read_8(state, ea);
uint mask = 1 << (DX & 7);
FLAG_Z = src & mask;
- m68ki_write_8(ea, src ^ mask);
+ m68ki_write_8(state, ea, src ^ mask);
}
M68KMAKE_OP(bchg, 32, s, d)
{
uint* r_dst = &DY;
- uint mask = 1 << (OPER_I_8() & 0x1f);
+ uint mask = 1 << (OPER_I_8(state) & 0x1f);
FLAG_Z = *r_dst & mask;
*r_dst ^= mask;
M68KMAKE_OP(bchg, 8, s, .)
{
- uint mask = 1 << (OPER_I_8() & 7);
+ uint mask = 1 << (OPER_I_8(state) & 7);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint src = m68ki_read_8(ea);
+ uint src = m68ki_read_8(state, ea);
FLAG_Z = src & mask;
- m68ki_write_8(ea, src ^ mask);
+ m68ki_write_8(state, ea, src ^ mask);
}
M68KMAKE_OP(bclr, 8, r, .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint src = m68ki_read_8(ea);
+ uint src = m68ki_read_8(state, ea);
uint mask = 1 << (DX & 7);
FLAG_Z = src & mask;
- m68ki_write_8(ea, src & ~mask);
+ m68ki_write_8(state, ea, src & ~mask);
}
M68KMAKE_OP(bclr, 32, s, d)
{
uint* r_dst = &DY;
- uint mask = 1 << (OPER_I_8() & 0x1f);
+ uint mask = 1 << (OPER_I_8(state) & 0x1f);
FLAG_Z = *r_dst & mask;
*r_dst &= ~mask;
M68KMAKE_OP(bclr, 8, s, .)
{
- uint mask = 1 << (OPER_I_8() & 7);
+ uint mask = 1 << (OPER_I_8(state) & 7);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint src = m68ki_read_8(ea);
+ uint src = m68ki_read_8(state, ea);
FLAG_Z = src & mask;
- m68ki_write_8(ea, src & ~mask);
+ m68ki_write_8(state, ea, src & ~mask);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint offset = (word2>>6)&31;
uint width = word2;
uint* data = &DY;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint offset = (word2>>6)&31;
uint width = word2;
uint mask_base;
mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
mask_long = mask_base >> offset;
- data_long = m68ki_read_32(ea);
+ data_long = m68ki_read_32(state, ea);
FLAG_N = NFLAG_32(data_long << offset);
FLAG_Z = data_long & mask_long;
FLAG_V = VFLAG_CLEAR;
FLAG_C = CFLAG_CLEAR;
- m68ki_write_32(ea, data_long ^ mask_long);
+ m68ki_write_32(state, ea, data_long ^ mask_long);
if((width + offset) > 32)
{
mask_byte = MASK_OUT_ABOVE_8(mask_base) << (8-offset);
- data_byte = m68ki_read_8(ea+4);
+ data_byte = m68ki_read_8(state, ea+4);
FLAG_Z |= (data_byte & mask_byte);
- m68ki_write_8(ea+4, data_byte ^ mask_byte);
+ m68ki_write_8(state, ea+4, data_byte ^ mask_byte);
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint offset = (word2>>6)&31;
uint width = word2;
uint* data = &DY;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint offset = (word2>>6)&31;
uint width = word2;
uint mask_base;
mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
mask_long = mask_base >> offset;
- data_long = m68ki_read_32(ea);
+ data_long = m68ki_read_32(state, ea);
FLAG_N = NFLAG_32(data_long << offset);
FLAG_Z = data_long & mask_long;
FLAG_V = VFLAG_CLEAR;
FLAG_C = CFLAG_CLEAR;
- m68ki_write_32(ea, data_long & ~mask_long);
+ m68ki_write_32(state, ea, data_long & ~mask_long);
if((width + offset) > 32)
{
mask_byte = MASK_OUT_ABOVE_8(mask_base) << (8-offset);
- data_byte = m68ki_read_8(ea+4);
+ data_byte = m68ki_read_8(state, ea+4);
FLAG_Z |= (data_byte & mask_byte);
- m68ki_write_8(ea+4, data_byte & ~mask_byte);
+ m68ki_write_8(state, ea+4, data_byte & ~mask_byte);
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint offset = (word2>>6)&31;
uint width = word2;
uint64 data = DY;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint offset = (word2>>6)&31;
uint width = word2;
uint data;
}
width = ((width-1) & 31) + 1;
- data = (offset+width) < 8 ? (m68ki_read_8(ea) << 24) :
- (offset+width) < 16 ? (m68ki_read_16(ea) << 16) : m68ki_read_32(ea);
+ data = (offset+width) < 8 ? (m68ki_read_8(state, ea) << 24) :
+ (offset+width) < 16 ? (m68ki_read_16(state, ea) << 16) : m68ki_read_32(state, ea);
data = MASK_OUT_ABOVE_32(data<<offset);
if((offset+width) > 32)
- data |= (m68ki_read_8(ea+4) << offset) >> 8;
+ data |= (m68ki_read_8(state, ea+4) << offset) >> 8;
FLAG_N = NFLAG_32(data);
data = MAKE_INT_32(data) >> (32 - width);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint offset = (word2>>6)&31;
uint width = word2;
uint64 data = DY;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint offset = (word2>>6)&31;
uint width = word2;
uint data;
}
width = ((width-1) & 31) + 1;
- data = (offset+width) < 8 ? (m68ki_read_8(ea) << 24) :
- (offset+width) < 16 ? (m68ki_read_16(ea) << 16) : m68ki_read_32(ea);
+ data = (offset+width) < 8 ? (m68ki_read_8(state, ea) << 24) :
+ (offset+width) < 16 ? (m68ki_read_16(state, ea) << 16) : m68ki_read_32(state, ea);
data = MASK_OUT_ABOVE_32(data<<offset);
if((offset+width) > 32)
- data |= (m68ki_read_8(ea+4) << offset) >> 8;
+ data |= (m68ki_read_8(state, ea+4) << offset) >> 8;
FLAG_N = NFLAG_32(data);
data >>= (32 - width);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint offset = (word2>>6)&31;
uint width = word2;
uint64 data = DY;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint offset = (word2>>6)&31;
sint local_offset;
uint width = word2;
}
width = ((width-1) & 31) + 1;
- data = (offset+width) < 16 ? (m68ki_read_16(ea) << 16) : m68ki_read_32(ea);
+ data = (offset+width) < 16 ? (m68ki_read_16(state, ea) << 16) : m68ki_read_32(state, ea);
data = MASK_OUT_ABOVE_32(data<<local_offset);
if((local_offset+width) > 32)
- data |= (m68ki_read_8(ea+4) << local_offset) >> 8;
+ data |= (m68ki_read_8(state, ea+4) << local_offset) >> 8;
FLAG_N = NFLAG_32(data);
data >>= (32 - width);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint offset = (word2>>6)&31;
uint width = word2;
uint* data = &DY;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint offset = (word2>>6)&31;
uint width = word2;
uint insert_base = REG_D[(word2>>12)&7];
FLAG_Z = insert_base;
insert_long = insert_base >> offset;
- data_long = (offset+width) < 8 ? (m68ki_read_8(ea) << 24) :
- (offset+width) < 16 ? (m68ki_read_16(ea) << 16) : m68ki_read_32(ea);
+ data_long = (offset+width) < 8 ? (m68ki_read_8(state, ea) << 24) :
+ (offset+width) < 16 ? (m68ki_read_16(state, ea) << 16) : m68ki_read_32(state, ea);
FLAG_V = VFLAG_CLEAR;
FLAG_C = CFLAG_CLEAR;
if((width + offset) < 8) {
- m68ki_write_8(ea, ((data_long & ~mask_long) | insert_long) >> 24);
+ m68ki_write_8(state, ea, ((data_long & ~mask_long) | insert_long) >> 24);
} else if((width + offset) < 16) {
- m68ki_write_16(ea, ((data_long & ~mask_long) | insert_long) >> 16);
+ m68ki_write_16(state, ea, ((data_long & ~mask_long) | insert_long) >> 16);
} else {
- m68ki_write_32(ea, (data_long & ~mask_long) | insert_long);
+ m68ki_write_32(state, ea, (data_long & ~mask_long) | insert_long);
}
if((width + offset) > 32)
{
mask_byte = MASK_OUT_ABOVE_8(mask_base);
insert_byte = MASK_OUT_ABOVE_8(insert_base);
- data_byte = m68ki_read_8(ea+4);
+ data_byte = m68ki_read_8(state, ea+4);
FLAG_Z |= (data_byte & mask_byte);
- m68ki_write_8(ea+4, (data_byte & ~mask_byte) | insert_byte);
+ m68ki_write_8(state, ea+4, (data_byte & ~mask_byte) | insert_byte);
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint offset = (word2>>6)&31;
uint width = word2;
uint* data = &DY;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint offset = (word2>>6)&31;
uint width = word2;
uint mask_base;
mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
mask_long = mask_base >> offset;
- data_long = m68ki_read_32(ea);
+ data_long = m68ki_read_32(state, ea);
FLAG_N = NFLAG_32(data_long << offset);
FLAG_Z = data_long & mask_long;
FLAG_V = VFLAG_CLEAR;
FLAG_C = CFLAG_CLEAR;
- m68ki_write_32(ea, data_long | mask_long);
+ m68ki_write_32(state, ea, data_long | mask_long);
if((width + offset) > 32)
{
mask_byte = MASK_OUT_ABOVE_8(mask_base);
- data_byte = m68ki_read_8(ea+4);
+ data_byte = m68ki_read_8(state, ea+4);
FLAG_Z |= (data_byte & mask_byte);
- m68ki_write_8(ea+4, data_byte | mask_byte);
+ m68ki_write_8(state, ea+4, data_byte | mask_byte);
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint offset = (word2>>6)&31;
uint width = word2;
uint* data = &DY;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint offset = (word2>>6)&31;
uint width = word2;
uint mask_base;
mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
mask_long = mask_base >> offset;
- data_long = m68ki_read_32(ea);
+ data_long = m68ki_read_32(state, ea);
FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24;
FLAG_Z = data_long & mask_long;
FLAG_V = VFLAG_CLEAR;
if((width + offset) > 32)
{
mask_byte = MASK_OUT_ABOVE_8(mask_base);
- data_byte = m68ki_read_8(ea+4);
+ data_byte = m68ki_read_8(state, ea+4);
FLAG_Z |= (data_byte & mask_byte);
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
m68ki_bkpt_ack(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE) ? REG_IR & 7 : 0); /* auto-disable (see m68kcpu.h) */
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(bra, 8, ., .)
{
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ m68ki_branch_8(state, MASK_OUT_ABOVE_8(REG_IR));
// TODO: review this...
// if(REG_PC == REG_PPC)
// USE_ALL_CYCLES();
M68KMAKE_OP(bra, 16, ., .)
{
- uint offset = OPER_I_16();
+ uint offset = OPER_I_16(state);
REG_PC -= 2;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_16(offset);
+ m68ki_branch_16(state, offset);
// TODO: review this...
// if(REG_PC == REG_PPC)
// USE_ALL_CYCLES();
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint offset = OPER_I_32();
+ uint offset = OPER_I_32(state);
REG_PC -= 4;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_32(offset);
+ m68ki_branch_32(state, offset);
// TODO: review this...
// if(REG_PC == REG_PPC)
// USE_ALL_CYCLES();
else
{
// TODO: review this...
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
// m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
-// m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+// m68ki_branch_8(state, MASK_OUT_ABOVE_8(REG_IR));
// if(REG_PC == REG_PPC)
// USE_ALL_CYCLES();
}
M68KMAKE_OP(bset, 8, r, .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint src = m68ki_read_8(ea);
+ uint src = m68ki_read_8(state, ea);
uint mask = 1 << (DX & 7);
FLAG_Z = src & mask;
- m68ki_write_8(ea, src | mask);
+ m68ki_write_8(state, ea, src | mask);
}
M68KMAKE_OP(bset, 32, s, d)
{
uint* r_dst = &DY;
- uint mask = 1 << (OPER_I_8() & 0x1f);
+ uint mask = 1 << (OPER_I_8(state) & 0x1f);
FLAG_Z = *r_dst & mask;
*r_dst |= mask;
M68KMAKE_OP(bset, 8, s, .)
{
- uint mask = 1 << (OPER_I_8() & 7);
+ uint mask = 1 << (OPER_I_8(state) & 7);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint src = m68ki_read_8(ea);
+ uint src = m68ki_read_8(state, ea);
FLAG_Z = src & mask;
- m68ki_write_8(ea, src | mask);
+ m68ki_write_8(state, ea, src | mask);
}
M68KMAKE_OP(bsr, 8, ., .)
{
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_push_32(REG_PC);
- m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ m68ki_push_32(state, REG_PC);
+ m68ki_branch_8(state, MASK_OUT_ABOVE_8(REG_IR));
}
M68KMAKE_OP(bsr, 16, ., .)
{
- uint offset = OPER_I_16();
+ uint offset = OPER_I_16(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_push_32(REG_PC);
+ m68ki_push_32(state, REG_PC);
REG_PC -= 2;
- m68ki_branch_16(offset);
+ m68ki_branch_16(state, offset);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint offset = OPER_I_32();
+ uint offset = OPER_I_32(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_push_32(REG_PC);
+ m68ki_push_32(state, REG_PC);
REG_PC -= 4;
- m68ki_branch_32(offset);
+ m68ki_branch_32(state, offset);
return;
}
else
{
// TODO: review this...
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
// m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
-// m68ki_push_32(REG_PC);
-// m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+// m68ki_push_32(state, REG_PC);
+// m68ki_branch_8(state, MASK_OUT_ABOVE_8(REG_IR));
}
}
M68KMAKE_OP(btst, 32, s, d)
{
- FLAG_Z = DY & (1 << (OPER_I_8() & 0x1f));
+ FLAG_Z = DY & (1 << (OPER_I_8(state) & 0x1f));
}
M68KMAKE_OP(btst, 8, s, .)
{
- uint bit = OPER_I_8() & 7;
+ uint bit = OPER_I_8(state) & 7;
FLAG_Z = M68KMAKE_GET_OPER_AY_8 & (1 << bit);
}
m68ki_disassemble_quick(ADDRESS_68K(REG_PC - 2),CPU_TYPE)));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint dest = m68ki_read_8(ea);
+ uint dest = m68ki_read_8(state, ea);
uint* compare = ®_D[word2 & 7];
uint res = dest - MASK_OUT_ABOVE_8(*compare);
else
{
USE_CYCLES(3);
- m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
+ m68ki_write_8(state, ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
- uint dest = m68ki_read_16(ea);
+ uint dest = m68ki_read_16(state, ea);
uint* compare = ®_D[word2 & 7];
uint res = dest - MASK_OUT_ABOVE_16(*compare);
else
{
USE_CYCLES(3);
- m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
+ m68ki_write_16(state, ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_32;
- uint dest = m68ki_read_32(ea);
+ uint dest = m68ki_read_32(state, ea);
uint* compare = ®_D[word2 & 7];
uint res = dest - *compare;
else
{
USE_CYCLES(3);
- m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]);
+ m68ki_write_32(state, ea, REG_D[(word2 >> 6) & 7]);
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_32();
+ uint word2 = OPER_I_32(state);
uint* compare1 = ®_D[(word2 >> 16) & 7];
uint ea1 = REG_DA[(word2 >> 28) & 15];
- uint dest1 = m68ki_read_16(ea1);
+ uint dest1 = m68ki_read_16(state, ea1);
uint res1 = dest1 - MASK_OUT_ABOVE_16(*compare1);
uint* compare2 = ®_D[word2 & 7];
uint ea2 = REG_DA[(word2 >> 12) & 15];
- uint dest2 = m68ki_read_16(ea2);
+ uint dest2 = m68ki_read_16(state, ea2);
uint res2;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
if(COND_EQ())
{
USE_CYCLES(3);
- m68ki_write_16(ea1, REG_D[(word2 >> 22) & 7]);
- m68ki_write_16(ea2, REG_D[(word2 >> 6) & 7]);
+ m68ki_write_16(state, ea1, REG_D[(word2 >> 22) & 7]);
+ m68ki_write_16(state, ea2, REG_D[(word2 >> 6) & 7]);
return;
}
}
*compare2 = BIT_F(word2) ? (uint)MAKE_INT_16(dest2) : MASK_OUT_BELOW_16(*compare2) | dest2;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_32();
+ uint word2 = OPER_I_32(state);
uint* compare1 = ®_D[(word2 >> 16) & 7];
uint ea1 = REG_DA[(word2 >> 28) & 15];
- uint dest1 = m68ki_read_32(ea1);
+ uint dest1 = m68ki_read_32(state, ea1);
uint res1 = dest1 - *compare1;
uint* compare2 = ®_D[word2 & 7];
uint ea2 = REG_DA[(word2 >> 12) & 15];
- uint dest2 = m68ki_read_32(ea2);
+ uint dest2 = m68ki_read_32(state, ea2);
uint res2;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
if(COND_EQ())
{
USE_CYCLES(3);
- m68ki_write_32(ea1, REG_D[(word2 >> 22) & 7]);
- m68ki_write_32(ea2, REG_D[(word2 >> 6) & 7]);
+ m68ki_write_32(state, ea1, REG_D[(word2 >> 22) & 7]);
+ m68ki_write_32(state, ea2, REG_D[(word2 >> 6) & 7]);
return;
}
}
*compare2 = dest2;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
return;
}
FLAG_N = (src < 0)<<7;
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
}
return;
}
FLAG_N = (src < 0)<<7;
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
}
return;
}
FLAG_N = (src < 0)<<7;
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
return;
}
FLAG_N = (src < 0)<<7;
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint compare = REG_DA[(word2 >> 12) & 15];
if(!BIT_F(word2))
compare &= 0xff;
uint ea = EA_PCDI_8();
- sint lower_bound = m68ki_read_pcrel_8(ea);
- sint upper_bound = m68ki_read_pcrel_8(ea + 1);
+ sint lower_bound = m68ki_read_pcrel_8(state, ea);
+ sint upper_bound = m68ki_read_pcrel_8(state, ea + 1);
// for signed compare, the arithmetically smaller value is the lower bound
if (lower_bound & 0x80) {
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
-
- m68ki_exception_illegal();
+
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint compare = REG_DA[(word2 >> 12) & 15];
if(!BIT_F(word2))
compare &= 0xff;
uint ea = EA_PCIX_8();
- sint lower_bound = m68ki_read_pcrel_8(ea);
- sint upper_bound = m68ki_read_pcrel_8(ea + 1);
+ sint lower_bound = m68ki_read_pcrel_8(state, ea);
+ sint upper_bound = m68ki_read_pcrel_8(state, ea + 1);
if (lower_bound & 0x80) {
lower_bound = (int32)(int8)lower_bound;
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint compare = REG_DA[(word2 >> 12) & 15];
if(!BIT_F(word2))
compare &= 0xff;
uint ea = M68KMAKE_GET_EA_AY_8;
- sint lower_bound = (int8)m68ki_read_8(ea);
- sint upper_bound = (int8)m68ki_read_8(ea + 1);
+ sint lower_bound = (int8)m68ki_read_8(state, ea);
+ sint upper_bound = (int8)m68ki_read_8(state, ea + 1);
// for signed compare, the arithmetically smaller value is the lower bound
if (lower_bound & 0x80) {
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint compare = REG_DA[(word2 >> 12) & 15];
if(!BIT_F(word2))
compare &= 0xffff;
uint ea = EA_PCDI_16();
- sint lower_bound = (int16)m68ki_read_pcrel_16(ea);
- sint upper_bound = (int16)m68ki_read_pcrel_16(ea + 2);
+ sint lower_bound = (int16)m68ki_read_pcrel_16(state, ea);
+ sint upper_bound = (int16)m68ki_read_pcrel_16(state, ea + 2);
// for signed compare, the arithmetically smaller value is the lower bound
if (lower_bound & 0x8000) {
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint compare = REG_DA[(word2 >> 12) & 15];
if(!BIT_F(word2))
compare &= 0xffff;
uint ea = EA_PCIX_16();
- sint lower_bound = (int16)m68ki_read_pcrel_16(ea);
- sint upper_bound = (int16)m68ki_read_pcrel_16(ea + 2);
+ sint lower_bound = (int16)m68ki_read_pcrel_16(state, ea);
+ sint upper_bound = (int16)m68ki_read_pcrel_16(state, ea + 2);
// for signed compare, the arithmetically smaller value is the lower bound
if (lower_bound & 0x8000) {
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
sint compare = REG_DA[(word2 >> 12) & 15];
if(!BIT_F(word2))
compare &= 0xffff;
uint ea = M68KMAKE_GET_EA_AY_16;
- sint lower_bound = (int16)m68ki_read_16(ea);
- sint upper_bound = (int16)m68ki_read_16(ea + 2);
+ sint lower_bound = (int16)m68ki_read_16(state, ea);
+ sint upper_bound = (int16)m68ki_read_16(state, ea + 2);
// for signed compare, the arithmetically smaller value is the lower bound
if (lower_bound & 0x8000) {
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint32 word2 = OPER_I_16();
+ uint32 word2 = OPER_I_16(state);
sint64 compare = REG_DA[(word2 >> 12) & 15];
uint32 ea = EA_PCDI_32();
- sint64 lower_bound = m68ki_read_pcrel_32(ea);
- sint64 upper_bound = m68ki_read_pcrel_32(ea + 4);
+ sint64 lower_bound = m68ki_read_pcrel_32(state, ea);
+ sint64 upper_bound = m68ki_read_pcrel_32(state, ea + 4);
// for signed compare, the arithmetically smaller value is the lower bound
if (lower_bound & 0x80000000) {
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint32 word2 = OPER_I_16();
+ uint32 word2 = OPER_I_16(state);
sint64 compare = REG_DA[(word2 >> 12) & 15];
uint32 ea = EA_PCIX_32();
- sint64 lower_bound = m68ki_read_32(ea);
- sint64 upper_bound = m68ki_read_32(ea + 4);
+ sint64 lower_bound = m68ki_read_32(state, ea);
+ sint64 upper_bound = m68ki_read_32(state, ea + 4);
// for signed compare, the arithmetically smaller value is the lower bound
if (lower_bound & 0x80000000) {
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(chk2cmp2, 32, ., .)
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
- {
- uint32 word2 = OPER_I_16();
+ {
+ uint32 word2 = OPER_I_16(state);
sint64 compare = REG_DA[(word2 >> 12) & 15];
uint32 ea = M68KMAKE_GET_EA_AY_32;
- sint64 lower_bound = m68ki_read_32(ea);
- sint64 upper_bound = m68ki_read_32(ea + 4);
+ sint64 lower_bound = m68ki_read_32(state, ea);
+ sint64 upper_bound = m68ki_read_32(state, ea + 4);
// for signed compare, the arithmetically smaller value is the lower bound
if (lower_bound & 0x80000000) {
FLAG_Z = ((upper_bound == compare) || (lower_bound == compare)) ? 0 : 1;
if(COND_CS() && BIT_B(word2))
- m68ki_exception_trap(EXCEPTION_CHK);
+ m68ki_exception_trap(state, EXCEPTION_CHK);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
uint32 ea = M68KMAKE_GET_EA_AY_8;
if(CPU_TYPE_IS_000(CPU_TYPE))
- m68ki_read_8(ea); /* the 68000 does a dummy read, the value is discarded */
- m68ki_write_8(ea, 0);
+ m68ki_read_8(state, ea); /* the 68000 does a dummy read, the value is discarded */
+ m68ki_write_8(state, ea, 0);
FLAG_N = NFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
uint32 ea = M68KMAKE_GET_EA_AY_16;
if(CPU_TYPE_IS_000(CPU_TYPE))
- m68ki_read_16(ea); /* the 68000 does a dummy read, the value is discarded */
- m68ki_write_16(ea, 0);
+ m68ki_read_16(state, ea); /* the 68000 does a dummy read, the value is discarded */
+ m68ki_write_16(state, ea, 0);
FLAG_N = NFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
uint32 ea = M68KMAKE_GET_EA_AY_32;
if(CPU_TYPE_IS_000(CPU_TYPE))
- m68ki_read_32(ea); /* the 68000 does a dummy read, the value is discarded */
- m68ki_write_32(ea, 0);
+ m68ki_read_32(state, ea); /* the 68000 does a dummy read, the value is discarded */
+ m68ki_write_32(state, ea, 0);
FLAG_N = NFLAG_CLEAR;
FLAG_V = VFLAG_CLEAR;
M68KMAKE_OP(cmpi, 8, ., d)
{
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint dst = MASK_OUT_ABOVE_8(DY);
uint res = dst - src;
M68KMAKE_OP(cmpi, 8, ., .)
{
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint dst = M68KMAKE_GET_OPER_AY_8;
uint res = dst - src;
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint src = OPER_I_8();
- uint dst = OPER_PCDI_8();
+ uint src = OPER_I_8(state);
+ uint dst = OPER_PCDI_8(state);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
FLAG_C = CFLAG_8(res);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint src = OPER_I_8();
- uint dst = OPER_PCIX_8();
+ uint src = OPER_I_8(state);
+ uint dst = OPER_PCIX_8(state);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
FLAG_C = CFLAG_8(res);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(cmpi, 16, ., d)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint dst = MASK_OUT_ABOVE_16(DY);
uint res = dst - src;
M68KMAKE_OP(cmpi, 16, ., .)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint dst = M68KMAKE_GET_OPER_AY_16;
uint res = dst - src;
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint src = OPER_I_16();
- uint dst = OPER_PCDI_16();
+ uint src = OPER_I_16(state);
+ uint dst = OPER_PCDI_16(state);
uint res = dst - src;
FLAG_N = NFLAG_16(res);
FLAG_C = CFLAG_16(res);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint src = OPER_I_16();
- uint dst = OPER_PCIX_16();
+ uint src = OPER_I_16(state);
+ uint dst = OPER_PCIX_16(state);
uint res = dst - src;
FLAG_N = NFLAG_16(res);
FLAG_C = CFLAG_16(res);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(cmpi, 32, ., d)
{
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint dst = DY;
uint res = dst - src;
M68KMAKE_OP(cmpi, 32, ., .)
{
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint dst = M68KMAKE_GET_OPER_AY_32;
uint res = dst - src;
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint src = OPER_I_32();
- uint dst = OPER_PCDI_32();
+ uint src = OPER_I_32(state);
+ uint dst = OPER_PCDI_32(state);
uint res = dst - src;
FLAG_N = NFLAG_32(res);
FLAG_C = CFLAG_SUB_32(src, dst, res);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint src = OPER_I_32();
- uint dst = OPER_PCIX_32();
+ uint src = OPER_I_32(state);
+ uint dst = OPER_PCIX_32(state);
uint res = dst - src;
FLAG_N = NFLAG_32(res);
FLAG_C = CFLAG_SUB_32(src, dst, res);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(cmpm, 8, ., ax7)
{
- uint src = OPER_AY_PI_8();
- uint dst = OPER_A7_PI_8();
+ uint src = OPER_AY_PI_8(state);
+ uint dst = OPER_A7_PI_8(state);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
M68KMAKE_OP(cmpm, 8, ., ay7)
{
- uint src = OPER_A7_PI_8();
- uint dst = OPER_AX_PI_8();
+ uint src = OPER_A7_PI_8(state);
+ uint dst = OPER_AX_PI_8(state);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
M68KMAKE_OP(cmpm, 8, ., axy7)
{
- uint src = OPER_A7_PI_8();
- uint dst = OPER_A7_PI_8();
+ uint src = OPER_A7_PI_8(state);
+ uint dst = OPER_A7_PI_8(state);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
M68KMAKE_OP(cmpm, 8, ., .)
{
- uint src = OPER_AY_PI_8();
- uint dst = OPER_AX_PI_8();
+ uint src = OPER_AY_PI_8(state);
+ uint dst = OPER_AX_PI_8(state);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
M68KMAKE_OP(cmpm, 16, ., .)
{
- uint src = OPER_AY_PI_16();
- uint dst = OPER_AX_PI_16();
+ uint src = OPER_AY_PI_16(state);
+ uint dst = OPER_AX_PI_16(state);
uint res = dst - src;
FLAG_N = NFLAG_16(res);
M68KMAKE_OP(cmpm, 32, ., .)
{
- uint src = OPER_AY_PI_32();
- uint dst = OPER_AX_PI_32();
+ uint src = OPER_AY_PI_32(state);
+ uint dst = OPER_AX_PI_32(state);
uint res = dst - src;
FLAG_N = NFLAG_32(res);
m68ki_disassemble_quick(ADDRESS_68K(REG_PC - 2),CPU_TYPE)));
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
m68ki_disassemble_quick(ADDRESS_68K(REG_PC - 2),CPU_TYPE)));
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
m68ki_disassemble_quick(ADDRESS_68K(REG_PC - 2),CPU_TYPE)));
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
m68ki_disassemble_quick(ADDRESS_68K(REG_PC - 2),CPU_TYPE)));
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
m68ki_disassemble_quick(ADDRESS_68K(REG_PC - 2),CPU_TYPE)));
// JFF: unsupported, but at least if the trap doesn't occur, app should still work, so at least PC increase is correct
- REG_PC += 4;
+ REG_PC += 4;
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
M68KMAKE_OP(ftrapcc,32, ., .)
{
if(HAS_FPU)
{
- m68881_ftrap();
+ m68881_ftrap(state);
} else {
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
}
*r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
if(res != 0xffff)
{
- uint offset = OPER_I_16();
+ uint offset = OPER_I_16(state);
REG_PC -= 2;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_16(offset);
+ m68ki_branch_16(state, offset);
USE_CYCLES(CYC_DBCC_F_NOEXP);
return;
}
*r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
if(res != 0xffff)
{
- uint offset = OPER_I_16();
+ uint offset = OPER_I_16(state);
REG_PC -= 2;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_branch_16(offset);
+ m68ki_branch_16(state, offset);
USE_CYCLES(CYC_DBCC_F_NOEXP);
return;
}
FLAG_V = VFLAG_SET;
return;
}
- m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+ m68ki_exception_trap(state, EXCEPTION_ZERO_DIVIDE);
}
FLAG_V = VFLAG_SET;
return;
}
- m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+ m68ki_exception_trap(state, EXCEPTION_ZERO_DIVIDE);
}
FLAG_V = VFLAG_SET;
return;
}
- m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+ m68ki_exception_trap(state, EXCEPTION_ZERO_DIVIDE);
}
FLAG_V = VFLAG_SET;
return;
}
- m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+ m68ki_exception_trap(state, EXCEPTION_ZERO_DIVIDE);
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint64 divisor = DY;
uint64 dividend = 0;
uint64 quotient = 0;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+ m68ki_exception_trap(state, EXCEPTION_ZERO_DIVIDE);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
#else
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint divisor = DY;
uint dividend_hi = REG_D[word2 & 7];
uint dividend_lo = REG_D[(word2 >> 12) & 7];
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+ m68ki_exception_trap(state, EXCEPTION_ZERO_DIVIDE);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
#endif
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint64 divisor = M68KMAKE_GET_OPER_AY_32;
uint64 dividend = 0;
uint64 quotient = 0;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+ m68ki_exception_trap(state, EXCEPTION_ZERO_DIVIDE);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
#else
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint divisor = M68KMAKE_GET_OPER_AY_32;
uint dividend_hi = REG_D[word2 & 7];
uint dividend_lo = REG_D[(word2 >> 12) & 7];
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+ m68ki_exception_trap(state, EXCEPTION_ZERO_DIVIDE);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
#endif
}
M68KMAKE_OP(eor, 8, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(state, ea));
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
M68KMAKE_OP(eor, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));
+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(state, ea));
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(eor, 32, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_32;
- uint res = DX ^ m68ki_read_32(ea);
+ uint res = DX ^ m68ki_read_32(state, ea);
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
M68KMAKE_OP(eori, 8, ., d)
{
- uint res = MASK_OUT_ABOVE_8(DY ^= OPER_I_8());
+ uint res = MASK_OUT_ABOVE_8(DY ^= OPER_I_8(state));
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
M68KMAKE_OP(eori, 8, ., .)
{
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint res = src ^ m68ki_read_8(ea);
+ uint res = src ^ m68ki_read_8(state, ea);
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
M68KMAKE_OP(eori, 16, ., d)
{
- uint res = MASK_OUT_ABOVE_16(DY ^= OPER_I_16());
+ uint res = MASK_OUT_ABOVE_16(DY ^= OPER_I_16(state));
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(eori, 16, ., .)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
- uint res = src ^ m68ki_read_16(ea);
+ uint res = src ^ m68ki_read_16(state, ea);
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(eori, 32, ., d)
{
- uint res = DY ^= OPER_I_32();
+ uint res = DY ^= OPER_I_32(state);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
M68KMAKE_OP(eori, 32, ., .)
{
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint ea = M68KMAKE_GET_EA_AY_32;
- uint res = src ^ m68ki_read_32(ea);
+ uint res = src ^ m68ki_read_32(state, ea);
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
M68KMAKE_OP(eori, 16, toc, .)
{
- m68ki_set_ccr(m68ki_get_ccr() ^ OPER_I_8());
+ m68ki_set_ccr(state, m68ki_get_ccr(state) ^ OPER_I_8(state));
}
{
if(FLAG_S)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_set_sr(m68ki_get_sr() ^ src);
+ m68ki_set_sr(state, m68ki_get_sr() ^ src);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(illegal, 0, ., .)
{
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(jmp, 32, ., .)
{
- m68ki_jump(M68KMAKE_GET_EA_AY_32);
+ m68ki_jump(state, M68KMAKE_GET_EA_AY_32);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
}
{
uint ea = M68KMAKE_GET_EA_AY_32;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_push_32(REG_PC);
- m68ki_jump(ea);
+ m68ki_push_32(state, REG_PC);
+ m68ki_jump(state, ea);
}
M68KMAKE_OP(link, 16, ., a7)
{
REG_A[7] -= 4;
- m68ki_write_32(REG_A[7], REG_A[7]);
- REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16()));
+ m68ki_write_32(state, REG_A[7], REG_A[7]);
+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16(state)));
}
{
uint* r_dst = &AY;
- m68ki_push_32(*r_dst);
+ m68ki_push_32(state, *r_dst);
*r_dst = REG_A[7];
- REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16()));
+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16(state)));
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
REG_A[7] -= 4;
- m68ki_write_32(REG_A[7], REG_A[7]);
- REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + OPER_I_32());
+ m68ki_write_32(state, REG_A[7], REG_A[7]);
+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + OPER_I_32(state));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
uint* r_dst = &AY;
- m68ki_push_32(*r_dst);
+ m68ki_push_32(state, *r_dst);
*r_dst = REG_A[7];
- REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + OPER_I_32());
+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + OPER_I_32(state));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(lsr, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = src >> 1;
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_CLEAR;
FLAG_Z = res;
M68KMAKE_OP(lsl, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = MASK_OUT_ABOVE_16(src << 1);
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_AX_AI_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_AX_AI_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_A7_PI_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_AX_PI_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_A7_PI_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_AX_PI_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_A7_PD_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_AX_PD_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_A7_PD_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_AX_PD_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_AX_DI_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_AX_DI_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_AX_IX_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_AX_IX_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_AW_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_AW_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_8(DY);
uint ea = EA_AL_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_8;
uint ea = EA_AL_8();
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(DY);
uint ea = EA_AX_AI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(AY);
uint ea = EA_AX_AI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_16;
uint ea = EA_AX_AI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(DY);
uint ea = EA_AX_PI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(AY);
uint ea = EA_AX_PI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_16;
uint ea = EA_AX_PI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(DY);
uint ea = EA_AX_PD_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(AY);
uint ea = EA_AX_PD_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_16;
uint ea = EA_AX_PD_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(DY);
uint ea = EA_AX_DI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(AY);
uint ea = EA_AX_DI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_16;
uint ea = EA_AX_DI_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(DY);
uint ea = EA_AX_IX_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(AY);
uint ea = EA_AX_IX_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_16;
uint ea = EA_AX_IX_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(DY);
uint ea = EA_AW_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(AY);
uint ea = EA_AW_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_16;
uint ea = EA_AW_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(DY);
uint ea = EA_AL_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = MASK_OUT_ABOVE_16(AY);
uint ea = EA_AL_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_16;
uint ea = EA_AL_16();
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
uint res = DY;
uint ea = EA_AX_AI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = AY;
uint ea = EA_AX_AI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_32;
uint ea = EA_AX_AI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = DY;
uint ea = EA_AX_PI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = AY;
uint ea = EA_AX_PI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_32;
uint ea = EA_AX_PI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = DY;
uint ea = EA_AX_PD_32();
- m68ki_write_16(ea+2, res & 0xFFFF );
- m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+ m68ki_write_16(state, ea+2, res & 0xFFFF );
+ m68ki_write_16(state, ea, (res >> 16) & 0xFFFF );
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = AY;
uint ea = EA_AX_PD_32();
- m68ki_write_16(ea+2, res & 0xFFFF );
- m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+ m68ki_write_16(state, ea+2, res & 0xFFFF );
+ m68ki_write_16(state, ea, (res >> 16) & 0xFFFF );
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_32;
uint ea = EA_AX_PD_32();
- m68ki_write_16(ea+2, res & 0xFFFF );
- m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+ m68ki_write_16(state, ea+2, res & 0xFFFF );
+ m68ki_write_16(state, ea, (res >> 16) & 0xFFFF );
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = DY;
uint ea = EA_AX_DI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = AY;
uint ea = EA_AX_DI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_32;
uint ea = EA_AX_DI_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = DY;
uint ea = EA_AX_IX_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = AY;
uint ea = EA_AX_IX_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_32;
uint ea = EA_AX_IX_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = DY;
uint ea = EA_AW_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = AY;
uint ea = EA_AW_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_32;
uint ea = EA_AW_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = DY;
uint ea = EA_AL_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = AY;
uint ea = EA_AL_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
uint res = M68KMAKE_GET_OPER_AY_32;
uint ea = EA_AL_32();
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
{
if(CPU_TYPE_IS_010_PLUS(CPU_TYPE))
{
- DY = MASK_OUT_BELOW_16(DY) | m68ki_get_ccr();
+ DY = MASK_OUT_BELOW_16(DY) | m68ki_get_ccr(state);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_010_PLUS(CPU_TYPE))
{
- m68ki_write_16(M68KMAKE_GET_EA_AY_16, m68ki_get_ccr());
+ m68ki_write_16(state, M68KMAKE_GET_EA_AY_16, m68ki_get_ccr(state));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(move, 16, toc, d)
{
- m68ki_set_ccr(DY);
+ m68ki_set_ccr(state, DY);
}
M68KMAKE_OP(move, 16, toc, .)
{
- m68ki_set_ccr(M68KMAKE_GET_OPER_AY_16);
+ m68ki_set_ccr(state, M68KMAKE_GET_OPER_AY_16);
}
DY = MASK_OUT_BELOW_16(DY) | m68ki_get_sr();
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
if(CPU_TYPE_IS_000(CPU_TYPE) || FLAG_S) /* NS990408 */
{
uint ea = M68KMAKE_GET_EA_AY_16;
- m68ki_write_16(ea, m68ki_get_sr());
+ m68ki_write_16(state, ea, m68ki_get_sr());
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
{
if(FLAG_S)
{
- m68ki_set_sr(DY);
+ m68ki_set_sr(state, DY);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
{
uint new_sr = M68KMAKE_GET_OPER_AY_16;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_set_sr(new_sr);
+ m68ki_set_sr(state, new_sr);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
AY = REG_USP;
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
REG_USP = AY;
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
{
if(FLAG_S)
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
switch (word2 & 0xfff)
REG_DA[(word2 >> 12) & 15] = REG_CAAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
break;
case 0x803: /* MSP */
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
REG_DA[(word2 >> 12) & 15] = FLAG_M ? REG_SP : REG_MSP;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x804: /* ISP */
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
REG_DA[(word2 >> 12) & 15] = FLAG_M ? REG_ISP : REG_SP;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x003: /* TC */
if(CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- REG_DA[(word2 >> 12) & 15] = m68ki_cpu.mmu_tc;
+ REG_DA[(word2 >> 12) & 15] = state->mmu_tc;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x004: /* ITT0 */
if(CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- REG_DA[(word2 >> 12) & 15] = m68ki_cpu.mmu_itt0;
+ REG_DA[(word2 >> 12) & 15] = state->mmu_itt0;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x005: /* ITT1 */
if(CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- REG_DA[(word2 >> 12) & 15] = m68ki_cpu.mmu_itt1;
+ REG_DA[(word2 >> 12) & 15] = state->mmu_itt1;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x006: /* DTT0 */
if(CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- REG_DA[(word2 >> 12) & 15] = m68ki_cpu.mmu_dtt0;
+ REG_DA[(word2 >> 12) & 15] = state->mmu_dtt0;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x007: /* DTT1 */
if(CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- REG_DA[(word2 >> 12) & 15] = m68ki_cpu.mmu_dtt1;
+ REG_DA[(word2 >> 12) & 15] = state->mmu_dtt1;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x805: /* MMUSR */
if(CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- REG_DA[(word2 >> 12) & 15] = m68ki_cpu.mmu_sr_040;
+ REG_DA[(word2 >> 12) & 15] = state->mmu_sr_040;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x806: /* URP */
if(CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- REG_DA[(word2 >> 12) & 15] = m68ki_cpu.mmu_urp_aptr;
+ REG_DA[(word2 >> 12) & 15] = state->mmu_urp_aptr;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x807: /* SRP */
if(CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- REG_DA[(word2 >> 12) & 15] = m68ki_cpu.mmu_srp_aptr;
+ REG_DA[(word2 >> 12) & 15] = state->mmu_srp_aptr;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
default:
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
}
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(FLAG_S)
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
switch (word2 & 0xfff)
}
if (REG_CACR & (M68K_CACR_CI | M68K_CACR_CEI)) {
- m68ki_ic_clear();
+ m68ki_ic_clear(state);
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x800: /* USP */
REG_USP = REG_DA[(word2 >> 12) & 15];
REG_CAAR = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x803: /* MSP */
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
REG_SP = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x804: /* ISP */
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
REG_ISP = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x003: /* TC */
if (CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- m68ki_cpu.mmu_tc = REG_DA[(word2 >> 12) & 15];
+ state->mmu_tc = REG_DA[(word2 >> 12) & 15];
- if (m68ki_cpu.mmu_tc & 0x8000)
+ if (state->mmu_tc & 0x8000)
{
- m68ki_cpu.pmmu_enabled = 1;
+ state->pmmu_enabled = 1;
}
else
{
- m68ki_cpu.pmmu_enabled = 0;
+ state->pmmu_enabled = 0;
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x004: /* ITT0 */
if (CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- m68ki_cpu.mmu_itt0 = REG_DA[(word2 >> 12) & 15];
+ state->mmu_itt0 = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x005: /* ITT1 */
if (CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- m68ki_cpu.mmu_itt1 = REG_DA[(word2 >> 12) & 15];
+ state->mmu_itt1 = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x006: /* DTT0 */
if (CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- m68ki_cpu.mmu_dtt0 = REG_DA[(word2 >> 12) & 15];
+ state->mmu_dtt0 = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x007: /* DTT1 */
if (CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- m68ki_cpu.mmu_dtt1 = REG_DA[(word2 >> 12) & 15];
+ state->mmu_dtt1 = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x805: /* MMUSR */
if (CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- m68ki_cpu.mmu_sr_040 = REG_DA[(word2 >> 12) & 15];
+ state->mmu_sr_040 = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x806: /* URP */
if (CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- m68ki_cpu.mmu_urp_aptr = REG_DA[(word2 >> 12) & 15];
+ state->mmu_urp_aptr = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
case 0x807: /* SRP */
if (CPU_TYPE_IS_040_PLUS(CPU_TYPE))
{
- m68ki_cpu.mmu_srp_aptr = REG_DA[(word2 >> 12) & 15];
+ state->mmu_srp_aptr = REG_DA[(word2 >> 12) & 15];
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
default:
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
return;
}
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(movem, 16, re, pd)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = AY;
uint count = 0;
if(register_list & (1 << i))
{
ea -= 2;
- m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[15-i]));
+ m68ki_write_16(state, ea, MASK_OUT_ABOVE_16(REG_DA[15-i]));
count++;
}
AY = ea;
M68KMAKE_OP(movem, 16, re, .)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));
+ m68ki_write_16(state, ea, MASK_OUT_ABOVE_16(REG_DA[i]));
ea += 2;
count++;
}
M68KMAKE_OP(movem, 32, re, pd)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = AY;
uint count = 0;
if(register_list & (1 << i))
{
ea -= 4;
- m68ki_write_16(ea+2, REG_DA[15-i] & 0xFFFF );
- m68ki_write_16(ea, (REG_DA[15-i] >> 16) & 0xFFFF );
+ m68ki_write_16(state, ea+2, REG_DA[15-i] & 0xFFFF );
+ m68ki_write_16(state, ea, (REG_DA[15-i] >> 16) & 0xFFFF );
count++;
}
AY = ea;
M68KMAKE_OP(movem, 32, re, .)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_32;
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- m68ki_write_32(ea, REG_DA[i]);
+ m68ki_write_32(state, ea, REG_DA[i]);
ea += 4;
count++;
}
M68KMAKE_OP(movem, 16, er, pi)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = AY;
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(state, ea)));
ea += 2;
count++;
}
M68KMAKE_OP(movem, 16, er, pcdi)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = EA_PCDI_16();
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_pcrel_16(ea)));
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_pcrel_16(state, ea)));
ea += 2;
count++;
}
M68KMAKE_OP(movem, 16, er, pcix)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = EA_PCIX_16();
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_pcrel_16(ea)));
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_pcrel_16(state, ea)));
ea += 2;
count++;
}
M68KMAKE_OP(movem, 16, er, .)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(state, ea)));
ea += 2;
count++;
}
M68KMAKE_OP(movem, 32, er, pi)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = AY;
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- REG_DA[i] = m68ki_read_32(ea);
+ REG_DA[i] = m68ki_read_32(state, ea);
ea += 4;
count++;
}
M68KMAKE_OP(movem, 32, er, pcdi)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = EA_PCDI_32();
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- REG_DA[i] = m68ki_read_pcrel_32(ea);
+ REG_DA[i] = m68ki_read_pcrel_32(state, ea);
ea += 4;
count++;
}
M68KMAKE_OP(movem, 32, er, pcix)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = EA_PCIX_32();
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- REG_DA[i] = m68ki_read_pcrel_32(ea);
+ REG_DA[i] = m68ki_read_pcrel_32(state, ea);
ea += 4;
count++;
}
M68KMAKE_OP(movem, 32, er, .)
{
uint i = 0;
- uint register_list = OPER_I_16();
+ uint register_list = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_32;
uint count = 0;
for(; i < 16; i++)
if(register_list & (1 << i))
{
- REG_DA[i] = m68ki_read_32(ea);
+ REG_DA[i] = m68ki_read_32(state, ea);
ea += 4;
count++;
}
uint ea = EA_AY_DI_16();
uint src = DX;
- m68ki_write_8(ea, MASK_OUT_ABOVE_8(src >> 8));
- m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src));
+ m68ki_write_8(state, ea, MASK_OUT_ABOVE_8(src >> 8));
+ m68ki_write_8(state, ea += 2, MASK_OUT_ABOVE_8(src));
}
uint ea = EA_AY_DI_32();
uint src = DX;
- m68ki_write_8(ea, MASK_OUT_ABOVE_8(src >> 24));
- m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src >> 16));
- m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src >> 8));
- m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src));
+ m68ki_write_8(state, ea, MASK_OUT_ABOVE_8(src >> 24));
+ m68ki_write_8(state, ea += 2, MASK_OUT_ABOVE_8(src >> 16));
+ m68ki_write_8(state, ea += 2, MASK_OUT_ABOVE_8(src >> 8));
+ m68ki_write_8(state, ea += 2, MASK_OUT_ABOVE_8(src));
}
uint ea = EA_AY_DI_16();
uint* r_dst = &DX;
- *r_dst = MASK_OUT_BELOW_16(*r_dst) | ((m68ki_read_8(ea) << 8) + m68ki_read_8(ea + 2));
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | ((m68ki_read_8(state, ea) << 8) + m68ki_read_8(state, ea + 2));
}
{
uint ea = EA_AY_DI_32();
- DX = (m68ki_read_8(ea) << 24) + (m68ki_read_8(ea + 2) << 16)
- + (m68ki_read_8(ea + 4) << 8) + m68ki_read_8(ea + 6);
+ DX = (m68ki_read_8(state, ea) << 24) + (m68ki_read_8(state, ea + 2) << 16)
+ + (m68ki_read_8(state, ea + 4) << 8) + m68ki_read_8(state, ea + 6);
}
{
if(FLAG_S)
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_8;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
if(BIT_B(word2)) /* Register to memory */
{
- m68ki_write_8_fc(ea, REG_DFC, MASK_OUT_ABOVE_8(REG_DA[(word2 >> 12) & 15]));
+ m68ki_write_8_fc(state, ea, REG_DFC, MASK_OUT_ABOVE_8(REG_DA[(word2 >> 12) & 15]));
return;
}
if(BIT_F(word2)) /* Memory to address register */
{
- REG_A[(word2 >> 12) & 7] = MAKE_INT_8(m68ki_read_8_fc(ea, REG_SFC));
+ REG_A[(word2 >> 12) & 7] = MAKE_INT_8(m68ki_read_8_fc(state, ea, REG_SFC));
if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
USE_CYCLES(2);
return;
}
/* Memory to data register */
- REG_D[(word2 >> 12) & 7] = MASK_OUT_BELOW_8(REG_D[(word2 >> 12) & 7]) | m68ki_read_8_fc(ea, REG_SFC);
+ REG_D[(word2 >> 12) & 7] = MASK_OUT_BELOW_8(REG_D[(word2 >> 12) & 7]) | m68ki_read_8_fc(state, ea, REG_SFC);
if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
USE_CYCLES(2);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(FLAG_S)
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
if(BIT_B(word2)) /* Register to memory */
{
- m68ki_write_16_fc(ea, REG_DFC, MASK_OUT_ABOVE_16(REG_DA[(word2 >> 12) & 15]));
+ m68ki_write_16_fc(state, ea, REG_DFC, MASK_OUT_ABOVE_16(REG_DA[(word2 >> 12) & 15]));
return;
}
if(BIT_F(word2)) /* Memory to address register */
{
- REG_A[(word2 >> 12) & 7] = MAKE_INT_16(m68ki_read_16_fc(ea, REG_SFC));
+ REG_A[(word2 >> 12) & 7] = MAKE_INT_16(m68ki_read_16_fc(state, ea, REG_SFC));
if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
USE_CYCLES(2);
return;
}
/* Memory to data register */
- REG_D[(word2 >> 12) & 7] = MASK_OUT_BELOW_16(REG_D[(word2 >> 12) & 7]) | m68ki_read_16_fc(ea, REG_SFC);
+ REG_D[(word2 >> 12) & 7] = MASK_OUT_BELOW_16(REG_D[(word2 >> 12) & 7]) | m68ki_read_16_fc(state, ea, REG_SFC);
if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
USE_CYCLES(2);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(FLAG_S)
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_32;
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
if(BIT_B(word2)) /* Register to memory */
{
- m68ki_write_32_fc(ea, REG_DFC, REG_DA[(word2 >> 12) & 15]);
+ m68ki_write_32_fc(state, ea, REG_DFC, REG_DA[(word2 >> 12) & 15]);
if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
USE_CYCLES(2);
return;
}
/* Memory to register */
- REG_DA[(word2 >> 12) & 15] = m68ki_read_32_fc(ea, REG_SFC);
+ REG_DA[(word2 >> 12) & 15] = m68ki_read_32_fc(state, ea, REG_SFC);
if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
USE_CYCLES(2);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(move16, 32, ., .)
{
- uint16 w2 = OPER_I_16();
+ uint16 w2 = OPER_I_16(state);
int ax = REG_IR & 7;
int ay = (w2 >> 12) & 7;
- m68ki_write_32(REG_A[ay], m68ki_read_32(REG_A[ax]));
- m68ki_write_32(REG_A[ay]+4, m68ki_read_32(REG_A[ax]+4));
- m68ki_write_32(REG_A[ay]+8, m68ki_read_32(REG_A[ax]+8));
- m68ki_write_32(REG_A[ay]+12, m68ki_read_32(REG_A[ax]+12));
+ m68ki_write_32(state, REG_A[ay], m68ki_read_32(state, REG_A[ax]));
+ m68ki_write_32(state, REG_A[ay]+4, m68ki_read_32(state, REG_A[ax]+4));
+ m68ki_write_32(state, REG_A[ay]+8, m68ki_read_32(state, REG_A[ax]+8));
+ m68ki_write_32(state, REG_A[ay]+12, m68ki_read_32(state, REG_A[ax]+12));
REG_A[ax] += 16;
REG_A[ay] += 16;
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint64 src = DY;
uint64 dst = REG_D[(word2 >> 12) & 7];
uint64 res;
REG_D[(word2 >> 12) & 7] = MASK_OUT_ABOVE_32(res);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
#else
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint src = DY;
uint dst = REG_D[(word2 >> 12) & 7];
uint neg = GET_MSB_32(src ^ dst);
FLAG_V = (hi != 0) << 7;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
#endif
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint64 src = M68KMAKE_GET_OPER_AY_32;
uint64 dst = REG_D[(word2 >> 12) & 7];
uint64 res;
REG_D[(word2 >> 12) & 7] = MASK_OUT_ABOVE_32(res);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
#else
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint word2 = OPER_I_16();
+ uint word2 = OPER_I_16(state);
uint src = M68KMAKE_GET_OPER_AY_32;
uint dst = REG_D[(word2 >> 12) & 7];
uint neg = GET_MSB_32(src ^ dst);
FLAG_V = (hi != 0) << 7;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
#endif
}
M68KMAKE_OP(nbcd, 8, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = - dst - XFLAG_AS_1();
if(res != 0)
FLAG_V &= ~res; /* Undefined V behavior part II */
- m68ki_write_8(ea, MASK_OUT_ABOVE_8(res));
+ m68ki_write_8(state, ea, MASK_OUT_ABOVE_8(res));
FLAG_Z |= res;
FLAG_C = CFLAG_SET;
M68KMAKE_OP(neg, 8, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint src = m68ki_read_8(ea);
+ uint src = m68ki_read_8(state, ea);
uint res = 0 - src;
FLAG_N = NFLAG_8(res);
FLAG_V = src & res;
FLAG_Z = MASK_OUT_ABOVE_8(res);
- m68ki_write_8(ea, FLAG_Z);
+ m68ki_write_8(state, ea, FLAG_Z);
}
M68KMAKE_OP(neg, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = 0 - src;
FLAG_N = NFLAG_16(res);
FLAG_V = (src & res)>>8;
FLAG_Z = MASK_OUT_ABOVE_16(res);
- m68ki_write_16(ea, FLAG_Z);
+ m68ki_write_16(state, ea, FLAG_Z);
}
M68KMAKE_OP(neg, 32, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_32;
- uint src = m68ki_read_32(ea);
+ uint src = m68ki_read_32(state, ea);
uint res = 0 - src;
FLAG_N = NFLAG_32(res);
FLAG_V = (src & res)>>24;
FLAG_Z = MASK_OUT_ABOVE_32(res);
- m68ki_write_32(ea, FLAG_Z);
+ m68ki_write_32(state, ea, FLAG_Z);
}
M68KMAKE_OP(negx, 8, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint src = m68ki_read_8(ea);
+ uint src = m68ki_read_8(state, ea);
uint res = 0 - src - XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(negx, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
FLAG_N = NFLAG_16(res);
res = MASK_OUT_ABOVE_16(res);
FLAG_Z |= res;
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
}
M68KMAKE_OP(negx, 32, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_32;
- uint src = m68ki_read_32(ea);
+ uint src = m68ki_read_32(state, ea);
uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
FLAG_N = NFLAG_32(res);
res = MASK_OUT_ABOVE_32(res);
FLAG_Z |= res;
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
}
M68KMAKE_OP(not, 8, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(state, ea));
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
M68KMAKE_OP(not, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(state, ea));
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(not, 32, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_32;
- uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(state, ea));
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
M68KMAKE_OP(or, 8, re, .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(state, ea));
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
M68KMAKE_OP(or, 16, re, .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(state, ea));
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(or, 32, re, .)
{
uint ea = M68KMAKE_GET_EA_AY_32;
- uint res = DX | m68ki_read_32(ea);
+ uint res = DX | m68ki_read_32(state, ea);
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
M68KMAKE_OP(ori, 8, ., d)
{
- uint res = MASK_OUT_ABOVE_8((DY |= OPER_I_8()));
+ uint res = MASK_OUT_ABOVE_8((DY |= OPER_I_8(state)));
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
M68KMAKE_OP(ori, 8, ., .)
{
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(state, ea));
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
M68KMAKE_OP(ori, 16, ., d)
{
- uint res = MASK_OUT_ABOVE_16(DY |= OPER_I_16());
+ uint res = MASK_OUT_ABOVE_16(DY |= OPER_I_16(state));
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(ori, 16, ., .)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
- uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(state, ea));
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(ori, 32, ., d)
{
- uint res = DY |= OPER_I_32();
+ uint res = DY |= OPER_I_32(state);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
M68KMAKE_OP(ori, 32, ., .)
{
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint ea = M68KMAKE_GET_EA_AY_32;
- uint res = src | m68ki_read_32(ea);
+ uint res = src | m68ki_read_32(state, ea);
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
M68KMAKE_OP(ori, 16, toc, .)
{
- m68ki_set_ccr(m68ki_get_ccr() | OPER_I_8());
+ m68ki_set_ccr(state, m68ki_get_ccr(state) | OPER_I_8(state));
}
{
if(FLAG_S)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_set_sr(m68ki_get_sr() | src);
+ m68ki_set_sr(state, m68ki_get_sr() | src);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
/* Note: DX and DY are reversed in Motorola's docs */
- uint src = DY + OPER_I_16();
+ uint src = DY + OPER_I_16(state);
uint* r_dst = &DX;
*r_dst = MASK_OUT_BELOW_8(*r_dst) | ((src >> 4) & 0x00f0) | (src & 0x000f);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
/* Note: AX and AY are reversed in Motorola's docs */
uint ea_src = EA_AY_PD_8();
- uint src = m68ki_read_8(ea_src);
+ uint src = m68ki_read_8(state, ea_src);
ea_src = EA_AY_PD_8();
- src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16();
+ src = ((src << 8) | m68ki_read_8(state, ea_src)) + OPER_I_16(state);
- m68ki_write_8(EA_A7_PD_8(), ((src >> 8) & 0x000f) | ((src<<4) & 0x00f0));
+ m68ki_write_8(state, EA_A7_PD_8(), ((src >> 8) & 0x000f) | ((src<<4) & 0x00f0));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
/* Note: AX and AY are reversed in Motorola's docs */
uint ea_src = EA_A7_PD_8();
- uint src = m68ki_read_8(ea_src);
+ uint src = m68ki_read_8(state, ea_src);
ea_src = EA_A7_PD_8();
- src = (src | (m68ki_read_8(ea_src) << 8)) + OPER_I_16();
+ src = (src | (m68ki_read_8(state, ea_src) << 8)) + OPER_I_16(state);
- m68ki_write_8(EA_AX_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
+ m68ki_write_8(state, EA_AX_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
uint ea_src = EA_A7_PD_8();
- uint src = m68ki_read_8(ea_src);
+ uint src = m68ki_read_8(state, ea_src);
ea_src = EA_A7_PD_8();
- src = (src | (m68ki_read_8(ea_src) << 8)) + OPER_I_16();
+ src = (src | (m68ki_read_8(state, ea_src) << 8)) + OPER_I_16(state);
- m68ki_write_8(EA_A7_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
+ m68ki_write_8(state, EA_A7_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
/* Note: AX and AY are reversed in Motorola's docs */
uint ea_src = EA_AY_PD_8();
- uint src = m68ki_read_8(ea_src);
+ uint src = m68ki_read_8(state, ea_src);
ea_src = EA_AY_PD_8();
- src = (src | (m68ki_read_8(ea_src) << 8)) + OPER_I_16();
+ src = (src | (m68ki_read_8(state, ea_src) << 8)) + OPER_I_16(state);
- m68ki_write_8(EA_AX_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
+ m68ki_write_8(state, EA_AX_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
uint ea = M68KMAKE_GET_EA_AY_32;
- m68ki_push_32(ea);
+ m68ki_push_32(state, ea);
}
M68KMAKE_OP(pflusha, 32, ., .)
fprintf(stderr,"68040: unhandled PFLUSHA (ir=%04x)\n", REG_IR);
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
M68KMAKE_OP(pflushan, 32, ., .)
fprintf(stderr,"68040: unhandled PFLUSHAN (ir=%04x)\n", REG_IR);
return;
}
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
M68KMAKE_OP(pmmu, 32, ., .)
{
if ((CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) && (HAS_PMMU))
{
- m68851_mmu_ops();
+ m68851_mmu_ops(state);
}
else
{
- m68ki_exception_1111();
+ m68ki_exception_1111(state);
}
}
USE_CYCLES(CYC_RESET);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
M68KMAKE_OP(ror, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = ROR_16(src, 1);
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(rol, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(roxr, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
FLAG_C = FLAG_X = res >> 8;
res = MASK_OUT_ABOVE_16(res);
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
M68KMAKE_OP(roxl, 16, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_16;
- uint src = m68ki_read_16(ea);
+ uint src = m68ki_read_16(state, ea);
uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
FLAG_C = FLAG_X = res >> 8;
res = MASK_OUT_ABOVE_16(res);
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
{
if(CPU_TYPE_IS_010_PLUS(CPU_TYPE))
{
- uint new_pc = m68ki_pull_32();
+ uint new_pc = m68ki_pull_32(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16()));
- m68ki_jump(new_pc);
+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16(state)));
+ m68ki_jump(state, new_pc);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
if(CPU_TYPE_IS_000(CPU_TYPE))
{
- new_sr = m68ki_pull_16();
- new_pc = m68ki_pull_32();
- m68ki_jump(new_pc);
- m68ki_set_sr(new_sr);
+ new_sr = m68ki_pull_16(state);
+ new_pc = m68ki_pull_32(state);
+ m68ki_jump(state, new_pc);
+ m68ki_set_sr(state, new_sr);
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
if(CPU_TYPE_IS_010(CPU_TYPE))
{
- format_word = m68ki_read_16(REG_A[7]+6) >> 12;
+ format_word = m68ki_read_16(state, REG_A[7]+6) >> 12;
if(format_word == 0)
{
- new_sr = m68ki_pull_16();
- new_pc = m68ki_pull_32();
- m68ki_fake_pull_16(); /* format word */
- m68ki_jump(new_pc);
- m68ki_set_sr(new_sr);
+ new_sr = m68ki_pull_16(state);
+ new_pc = m68ki_pull_32(state);
+ m68ki_fake_pull_16(state); /* format word */
+ m68ki_jump(state, new_pc);
+ m68ki_set_sr(state, new_sr);
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
return;
} else if (format_word == 8) {
/* Format 8 stack frame -- 68010 only. 29 word bus/address error */
- new_sr = m68ki_pull_16();
- new_pc = m68ki_pull_32();
- m68ki_fake_pull_16(); /* format word */
- m68ki_jump(new_pc);
- m68ki_set_sr(new_sr);
+ new_sr = m68ki_pull_16(state);
+ new_pc = m68ki_pull_32(state);
+ m68ki_fake_pull_16(state); /* format word */
+ m68ki_jump(state, new_pc);
+ m68ki_set_sr(state, new_sr);
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
- m68ki_fake_pull_16(); /* special status */
- m68ki_fake_pull_32(); /* fault address */
- m68ki_fake_pull_32(); /* reserved and data output buffer */
- m68ki_fake_pull_32(); /* reserved and data input buffer */
- m68ki_fake_pull_32(); /* reserved and instruction input buffer */
- m68ki_fake_pull_32(); /* 8 dwords of CPU specific undocumented data */
- m68ki_fake_pull_32();
- m68ki_fake_pull_32();
- m68ki_fake_pull_32();
- m68ki_fake_pull_32();
- m68ki_fake_pull_32();
- m68ki_fake_pull_32();
- m68ki_fake_pull_32();
+ m68ki_fake_pull_16(state); /* special status */
+ m68ki_fake_pull_32(state); /* fault address */
+ m68ki_fake_pull_32(state); /* reserved and data output buffer */
+ m68ki_fake_pull_32(state); /* reserved and data input buffer */
+ m68ki_fake_pull_32(state); /* reserved and instruction input buffer */
+ m68ki_fake_pull_32(state); /* 8 dwords of CPU specific undocumented data */
+ m68ki_fake_pull_32(state);
+ m68ki_fake_pull_32(state);
+ m68ki_fake_pull_32(state);
+ m68ki_fake_pull_32(state);
+ m68ki_fake_pull_32(state);
+ m68ki_fake_pull_32(state);
+ m68ki_fake_pull_32(state);
return;
}
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
/* Not handling other exception types (9) */
- m68ki_exception_format_error();
+ m68ki_exception_format_error(state);
return;
}
/* Otherwise it's 020 */
rte_loop:
- format_word = m68ki_read_16(REG_A[7]+6) >> 12;
+ format_word = m68ki_read_16(state, REG_A[7]+6) >> 12;
switch(format_word)
{
case 0: /* Normal */
- new_sr = m68ki_pull_16();
- new_pc = m68ki_pull_32();
- m68ki_fake_pull_16(); /* format word */
- m68ki_jump(new_pc);
- m68ki_set_sr(new_sr);
+ new_sr = m68ki_pull_16(state);
+ new_pc = m68ki_pull_32(state);
+ m68ki_fake_pull_16(state); /* format word */
+ m68ki_jump(state, new_pc);
+ m68ki_set_sr(state, new_sr);
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
return;
case 1: /* Throwaway */
- new_sr = m68ki_pull_16();
- m68ki_fake_pull_32(); /* program counter */
- m68ki_fake_pull_16(); /* format word */
- m68ki_set_sr_noint(new_sr);
+ new_sr = m68ki_pull_16(state);
+ m68ki_fake_pull_32(state); /* program counter */
+ m68ki_fake_pull_16(state); /* format word */
+ m68ki_set_sr_noint(state, new_sr);
goto rte_loop;
case 2: /* Trap */
- new_sr = m68ki_pull_16();
- new_pc = m68ki_pull_32();
- m68ki_fake_pull_16(); /* format word */
- m68ki_fake_pull_32(); /* address */
- m68ki_jump(new_pc);
- m68ki_set_sr(new_sr);
+ new_sr = m68ki_pull_16(state);
+ new_pc = m68ki_pull_32(state);
+ m68ki_fake_pull_16(state); /* format word */
+ m68ki_fake_pull_32(state); /* address */
+ m68ki_jump(state, new_pc);
+ m68ki_set_sr(state, new_sr);
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
return;
case 7: /* 68040 access error */
- new_sr = m68ki_pull_16();
- new_pc = m68ki_pull_32();
- m68ki_fake_pull_16(); /* $06: format word */
- m68ki_fake_pull_32(); /* $08: effective address */
- m68ki_fake_pull_16(); /* $0c: special status word */
- m68ki_fake_pull_16(); /* $0e: wb3s */
- m68ki_fake_pull_16(); /* $10: wb2s */
- m68ki_fake_pull_16(); /* $12: wb1s */
- m68ki_fake_pull_32(); /* $14: data fault address */
- m68ki_fake_pull_32(); /* $18: wb3a */
- m68ki_fake_pull_32(); /* $1c: wb3d */
- m68ki_fake_pull_32(); /* $20: wb2a */
- m68ki_fake_pull_32(); /* $24: wb2d */
- m68ki_fake_pull_32(); /* $28: wb1a */
- m68ki_fake_pull_32(); /* $2c: wb1d/pd0 */
- m68ki_fake_pull_32(); /* $30: pd1 */
- m68ki_fake_pull_32(); /* $34: pd2 */
- m68ki_fake_pull_32(); /* $38: pd3 */
- m68ki_jump(new_pc);
- m68ki_set_sr(new_sr);
+ new_sr = m68ki_pull_16(state);
+ new_pc = m68ki_pull_32(state);
+ m68ki_fake_pull_16(state); /* $06: format word */
+ m68ki_fake_pull_32(state); /* $08: effective address */
+ m68ki_fake_pull_16(state); /* $0c: special status word */
+ m68ki_fake_pull_16(state); /* $0e: wb3s */
+ m68ki_fake_pull_16(state); /* $10: wb2s */
+ m68ki_fake_pull_16(state); /* $12: wb1s */
+ m68ki_fake_pull_32(state); /* $14: data fault address */
+ m68ki_fake_pull_32(state); /* $18: wb3a */
+ m68ki_fake_pull_32(state); /* $1c: wb3d */
+ m68ki_fake_pull_32(state); /* $20: wb2a */
+ m68ki_fake_pull_32(state); /* $24: wb2d */
+ m68ki_fake_pull_32(state); /* $28: wb1a */
+ m68ki_fake_pull_32(state); /* $2c: wb1d/pd0 */
+ m68ki_fake_pull_32(state); /* $30: pd1 */
+ m68ki_fake_pull_32(state); /* $34: pd2 */
+ m68ki_fake_pull_32(state); /* $38: pd3 */
+ m68ki_jump(state, new_pc);
+ m68ki_set_sr(state, new_sr);
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
return;
case 0x0a: /* Bus Error at instruction boundary */
- new_sr = m68ki_pull_16();
- new_pc = m68ki_pull_32();
- m68ki_fake_pull_16(); /* $06: format word */
- m68ki_fake_pull_16(); /* $08: internal register */
- m68ki_fake_pull_16(); /* $0a: special status word */
- m68ki_fake_pull_16(); /* $0c: instruction pipe stage c */
- m68ki_fake_pull_16(); /* $0e: instruction pipe stage b */
- m68ki_fake_pull_32(); /* $10: data fault address */
- m68ki_fake_pull_32(); /* $14: internal registers */
- m68ki_fake_pull_32(); /* $18: data output buffer */
- m68ki_fake_pull_32(); /* $1c: internal registers */
-
- m68ki_jump(new_pc);
- m68ki_set_sr(new_sr);
+ new_sr = m68ki_pull_16(state);
+ new_pc = m68ki_pull_32(state);
+ m68ki_fake_pull_16(state); /* $06: format word */
+ m68ki_fake_pull_16(state); /* $08: internal register */
+ m68ki_fake_pull_16(state); /* $0a: special status word */
+ m68ki_fake_pull_16(state); /* $0c: instruction pipe stage c */
+ m68ki_fake_pull_16(state); /* $0e: instruction pipe stage b */
+ m68ki_fake_pull_32(state); /* $10: data fault address */
+ m68ki_fake_pull_32(state); /* $14: internal registers */
+ m68ki_fake_pull_32(state); /* $18: data output buffer */
+ m68ki_fake_pull_32(state); /* $1c: internal registers */
+
+ m68ki_jump(state, new_pc);
+ m68ki_set_sr(state, new_sr);
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
return;
case 0x0b: /* Bus Error - Instruction Execution in Progress */
- new_sr = m68ki_pull_16();
- new_pc = m68ki_pull_32();
- m68ki_fake_pull_16(); /* $06: format word */
- m68ki_fake_pull_16(); /* $08: internal register */
- m68ki_fake_pull_16(); /* $0a: special status word */
- m68ki_fake_pull_16(); /* $0c: instruction pipe stage c */
- m68ki_fake_pull_16(); /* $0e: instruction pipe stage b */
- m68ki_fake_pull_32(); /* $10: data fault address */
- m68ki_fake_pull_32(); /* $14: internal registers */
- m68ki_fake_pull_32(); /* $18: data output buffer */
- m68ki_fake_pull_32(); /* $1c: internal registers */
- m68ki_fake_pull_32(); /* $20: */
- m68ki_fake_pull_32(); /* $24: stage B address */
- m68ki_fake_pull_32(); /* $28: */
- m68ki_fake_pull_32(); /* $2c: data input buffer */
- m68ki_fake_pull_32(); /* $30: */
- m68ki_fake_pull_16(); /* $34: */
- m68ki_fake_pull_16(); /* $36: version #, internal information */
- m68ki_fake_pull_32(); /* $38: */
- m68ki_fake_pull_32(); /* $3c: */
- m68ki_fake_pull_32(); /* $40: */
- m68ki_fake_pull_32(); /* $44: */
- m68ki_fake_pull_32(); /* $48: */
- m68ki_fake_pull_32(); /* $4c: */
- m68ki_fake_pull_32(); /* $50: */
- m68ki_fake_pull_32(); /* $54: */
- m68ki_fake_pull_32(); /* $58: */
-
- m68ki_jump(new_pc);
- m68ki_set_sr(new_sr);
+ new_sr = m68ki_pull_16(state);
+ new_pc = m68ki_pull_32(state);
+ m68ki_fake_pull_16(state); /* $06: format word */
+ m68ki_fake_pull_16(state); /* $08: internal register */
+ m68ki_fake_pull_16(state); /* $0a: special status word */
+ m68ki_fake_pull_16(state); /* $0c: instruction pipe stage c */
+ m68ki_fake_pull_16(state); /* $0e: instruction pipe stage b */
+ m68ki_fake_pull_32(state); /* $10: data fault address */
+ m68ki_fake_pull_32(state); /* $14: internal registers */
+ m68ki_fake_pull_32(state); /* $18: data output buffer */
+ m68ki_fake_pull_32(state); /* $1c: internal registers */
+ m68ki_fake_pull_32(state); /* $20: */
+ m68ki_fake_pull_32(state); /* $24: stage B address */
+ m68ki_fake_pull_32(state); /* $28: */
+ m68ki_fake_pull_32(state); /* $2c: data input buffer */
+ m68ki_fake_pull_32(state); /* $30: */
+ m68ki_fake_pull_16(state); /* $34: */
+ m68ki_fake_pull_16(state); /* $36: version #, internal information */
+ m68ki_fake_pull_32(state); /* $38: */
+ m68ki_fake_pull_32(state); /* $3c: */
+ m68ki_fake_pull_32(state); /* $40: */
+ m68ki_fake_pull_32(state); /* $44: */
+ m68ki_fake_pull_32(state); /* $48: */
+ m68ki_fake_pull_32(state); /* $4c: */
+ m68ki_fake_pull_32(state); /* $50: */
+ m68ki_fake_pull_32(state); /* $54: */
+ m68ki_fake_pull_32(state); /* $58: */
+
+ m68ki_jump(state, new_pc);
+ m68ki_set_sr(state, new_sr);
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
return;
/* Not handling long or short bus fault */
CPU_INSTR_MODE = INSTRUCTION_YES;
CPU_RUN_MODE = RUN_MODE_NORMAL;
- m68ki_exception_format_error();
+ m68ki_exception_format_error(state);
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
m68ki_disassemble_quick(ADDRESS_68K(REG_PC - 2),CPU_TYPE)));
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(rtr, 32, ., .)
{
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_set_ccr(m68ki_pull_16());
- m68ki_jump(m68ki_pull_32());
+ m68ki_set_ccr(state, m68ki_pull_16(state));
+ m68ki_jump(state, m68ki_pull_32(state));
}
M68KMAKE_OP(rts, 32, ., .)
{
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
- m68ki_jump(m68ki_pull_32());
+ m68ki_jump(state, m68ki_pull_32(state));
}
M68KMAKE_OP(sbcd, 8, mm, ax7)
{
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea = EA_A7_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
uint corf = 0;
FLAG_N = NFLAG_8(res); /* Undefined N behavior */
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(sbcd, 8, mm, ay7)
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea = EA_AX_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
uint corf = 0;
FLAG_N = NFLAG_8(res); /* Undefined N behavior */
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(sbcd, 8, mm, axy7)
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea = EA_A7_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
uint corf = 0;
FLAG_N = NFLAG_8(res); /* Undefined N behavior */
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(sbcd, 8, mm, .)
{
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea = EA_AX_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
uint corf = 0;
FLAG_N = NFLAG_8(res); /* Undefined N behavior */
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(st, 8, ., .)
{
- m68ki_write_8(M68KMAKE_GET_EA_AY_8, 0xff);
+ m68ki_write_8(state, M68KMAKE_GET_EA_AY_8, 0xff);
}
M68KMAKE_OP(sf, 8, ., .)
{
- m68ki_write_8(M68KMAKE_GET_EA_AY_8, 0);
+ m68ki_write_8(state, M68KMAKE_GET_EA_AY_8, 0);
}
M68KMAKE_OP(scc, 8, ., .)
{
- m68ki_write_8(M68KMAKE_GET_EA_AY_8, M68KMAKE_CC ? 0xff : 0);
+ m68ki_write_8(state, M68KMAKE_GET_EA_AY_8, M68KMAKE_CC ? 0xff : 0);
}
{
if(FLAG_S)
{
- uint new_sr = OPER_I_16();
+ uint new_sr = OPER_I_16(state);
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
CPU_STOPPED |= STOP_LEVEL_STOP;
- m68ki_set_sr(new_sr);
+ m68ki_set_sr(state, new_sr);
if(m68ki_remaining_cycles >= CYC_INSTRUCTION[REG_IR])
m68ki_remaining_cycles = CYC_INSTRUCTION[REG_IR];
else
USE_ALL_CYCLES();
return;
}
- m68ki_exception_privilege_violation();
+ m68ki_exception_privilege_violation(state);
}
{
uint ea = M68KMAKE_GET_EA_AY_8;
uint src = MASK_OUT_ABOVE_8(DX);
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
FLAG_X = FLAG_C = CFLAG_8(res);
FLAG_V = VFLAG_SUB_8(src, dst, res);
- m68ki_write_8(ea, FLAG_Z);
+ m68ki_write_8(state, ea, FLAG_Z);
}
{
uint ea = M68KMAKE_GET_EA_AY_16;
uint src = MASK_OUT_ABOVE_16(DX);
- uint dst = m68ki_read_16(ea);
+ uint dst = m68ki_read_16(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_16(res);
FLAG_X = FLAG_C = CFLAG_16(res);
FLAG_V = VFLAG_SUB_16(src, dst, res);
- m68ki_write_16(ea, FLAG_Z);
+ m68ki_write_16(state, ea, FLAG_Z);
}
{
uint ea = M68KMAKE_GET_EA_AY_32;
uint src = DX;
- uint dst = m68ki_read_32(ea);
+ uint dst = m68ki_read_32(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_32(res);
FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
FLAG_V = VFLAG_SUB_32(src, dst, res);
- m68ki_write_32(ea, FLAG_Z);
+ m68ki_write_32(state, ea, FLAG_Z);
}
M68KMAKE_OP(subi, 8, ., d)
{
uint* r_dst = &DY;
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint dst = MASK_OUT_ABOVE_8(*r_dst);
uint res = dst - src;
M68KMAKE_OP(subi, 8, ., .)
{
- uint src = OPER_I_8();
+ uint src = OPER_I_8(state);
uint ea = M68KMAKE_GET_EA_AY_8;
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
FLAG_X = FLAG_C = CFLAG_8(res);
FLAG_V = VFLAG_SUB_8(src, dst, res);
- m68ki_write_8(ea, FLAG_Z);
+ m68ki_write_8(state, ea, FLAG_Z);
}
M68KMAKE_OP(subi, 16, ., d)
{
uint* r_dst = &DY;
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint dst = MASK_OUT_ABOVE_16(*r_dst);
uint res = dst - src;
M68KMAKE_OP(subi, 16, ., .)
{
- uint src = OPER_I_16();
+ uint src = OPER_I_16(state);
uint ea = M68KMAKE_GET_EA_AY_16;
- uint dst = m68ki_read_16(ea);
+ uint dst = m68ki_read_16(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_16(res);
FLAG_X = FLAG_C = CFLAG_16(res);
FLAG_V = VFLAG_SUB_16(src, dst, res);
- m68ki_write_16(ea, FLAG_Z);
+ m68ki_write_16(state, ea, FLAG_Z);
}
M68KMAKE_OP(subi, 32, ., d)
{
uint* r_dst = &DY;
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint dst = *r_dst;
uint res = dst - src;
M68KMAKE_OP(subi, 32, ., .)
{
- uint src = OPER_I_32();
+ uint src = OPER_I_32(state);
uint ea = M68KMAKE_GET_EA_AY_32;
- uint dst = m68ki_read_32(ea);
+ uint dst = m68ki_read_32(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_32(res);
FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
FLAG_V = VFLAG_SUB_32(src, dst, res);
- m68ki_write_32(ea, FLAG_Z);
+ m68ki_write_32(state, ea, FLAG_Z);
}
{
uint src = (((REG_IR >> 9) - 1) & 7) + 1;
uint ea = M68KMAKE_GET_EA_AY_8;
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_8(res);
FLAG_X = FLAG_C = CFLAG_8(res);
FLAG_V = VFLAG_SUB_8(src, dst, res);
- m68ki_write_8(ea, FLAG_Z);
+ m68ki_write_8(state, ea, FLAG_Z);
}
{
uint src = (((REG_IR >> 9) - 1) & 7) + 1;
uint ea = M68KMAKE_GET_EA_AY_16;
- uint dst = m68ki_read_16(ea);
+ uint dst = m68ki_read_16(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_16(res);
FLAG_X = FLAG_C = CFLAG_16(res);
FLAG_V = VFLAG_SUB_16(src, dst, res);
- m68ki_write_16(ea, FLAG_Z);
+ m68ki_write_16(state, ea, FLAG_Z);
}
{
uint src = (((REG_IR >> 9) - 1) & 7) + 1;
uint ea = M68KMAKE_GET_EA_AY_32;
- uint dst = m68ki_read_32(ea);
+ uint dst = m68ki_read_32(state, ea);
uint res = dst - src;
FLAG_N = NFLAG_32(res);
FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
FLAG_V = VFLAG_SUB_32(src, dst, res);
- m68ki_write_32(ea, FLAG_Z);
+ m68ki_write_32(state, ea, FLAG_Z);
}
M68KMAKE_OP(subx, 8, mm, ax7)
{
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea = EA_A7_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = dst - src - XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(subx, 8, mm, ay7)
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea = EA_AX_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = dst - src - XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(subx, 8, mm, axy7)
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea = EA_A7_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = dst - src - XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(subx, 8, mm, .)
{
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea = EA_AX_PD_8();
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint res = dst - src - XFLAG_AS_1();
FLAG_N = NFLAG_8(res);
res = MASK_OUT_ABOVE_8(res);
FLAG_Z |= res;
- m68ki_write_8(ea, res);
+ m68ki_write_8(state, ea, res);
}
M68KMAKE_OP(subx, 16, mm, .)
{
- uint src = OPER_AY_PD_16();
+ uint src = OPER_AY_PD_16(state);
uint ea = EA_AX_PD_16();
- uint dst = m68ki_read_16(ea);
+ uint dst = m68ki_read_16(state, ea);
uint res = dst - src - XFLAG_AS_1();
FLAG_N = NFLAG_16(res);
res = MASK_OUT_ABOVE_16(res);
FLAG_Z |= res;
- m68ki_write_16(ea, res);
+ m68ki_write_16(state, ea, res);
}
M68KMAKE_OP(subx, 32, mm, .)
{
- uint src = OPER_AY_PD_32();
+ uint src = OPER_AY_PD_32(state);
uint ea = EA_AX_PD_32();
- uint dst = m68ki_read_32(ea);
+ uint dst = m68ki_read_32(state, ea);
uint res = dst - src - XFLAG_AS_1();
FLAG_N = NFLAG_32(res);
res = MASK_OUT_ABOVE_32(res);
FLAG_Z |= res;
- m68ki_write_32(ea, res);
+ m68ki_write_32(state, ea, res);
}
M68KMAKE_OP(tas, 8, ., .)
{
uint ea = M68KMAKE_GET_EA_AY_8;
- uint dst = m68ki_read_8(ea);
+ uint dst = m68ki_read_8(state, ea);
uint allow_writeback;
FLAG_Z = dst;
will be needed. */
allow_writeback = m68ki_tas_callback();
- if (allow_writeback==1) m68ki_write_8(ea, dst | 0x80);
+ if (allow_writeback==1) m68ki_write_8(state, ea, dst | 0x80);
}
M68KMAKE_OP(trap, 0, ., .)
{
/* Trap#n stacks exception frame type 0 */
- m68ki_exception_trapN(EXCEPTION_TRAP_BASE + (REG_IR & 0xf)); /* HJB 990403 */
+ m68ki_exception_trapN(state, EXCEPTION_TRAP_BASE + (REG_IR & 0xf)); /* HJB 990403 */
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */
+ m68ki_exception_trap(state, EXCEPTION_TRAPV); /* HJB 990403 */
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
// TODO: review this... as mame is not using it...
REG_PC += 2; // JFF else stackframe & return addresses are incorrect
- m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */
+ m68ki_exception_trap(state, EXCEPTION_TRAPV); /* HJB 990403 */
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
// TODO: review this... as mame is not using it...
REG_PC += 4; // JFF else stackframe & return addresses are incorrect
- m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */
+ m68ki_exception_trap(state, EXCEPTION_TRAPV); /* HJB 990403 */
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
REG_PC += 2;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
REG_PC += 4;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
if(M68KMAKE_CC)
- m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */
+ m68ki_exception_trap(state, EXCEPTION_TRAPV); /* HJB 990403 */
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
REG_PC += 2; /* JFF increase before or 1) stackframe is incorrect 2) RTE address is wrong if trap is taken */
if(M68KMAKE_CC)
{
- m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */
+ m68ki_exception_trap(state, EXCEPTION_TRAPV); /* HJB 990403 */
return;
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
REG_PC += 4; /* JFF increase before or 1) stackframe is incorrect 2) RTE address is wrong if trap is taken */
if(M68KMAKE_CC)
{
- m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */
+ m68ki_exception_trap(state, EXCEPTION_TRAPV); /* HJB 990403 */
return;
}
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
return;
}
- m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */
+ m68ki_exception_trap(state, EXCEPTION_TRAPV); /* HJB 990403 */
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_PCDI_8();
+ uint res = OPER_PCDI_8(state);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_PCIX_8();
+ uint res = OPER_PCIX_8(state);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_I_8();
+ uint res = OPER_I_8(state);
FLAG_N = NFLAG_8(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_PCDI_16();
+ uint res = OPER_PCDI_16(state);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_PCIX_16();
+ uint res = OPER_PCIX_16(state);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_I_16();
+ uint res = OPER_I_16(state);
FLAG_N = NFLAG_16(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_PCDI_32();
+ uint res = OPER_PCDI_32(state);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_PCIX_32();
+ uint res = OPER_PCIX_32(state);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint res = OPER_I_32();
+ uint res = OPER_I_32(state);
FLAG_N = NFLAG_32(res);
FLAG_Z = res;
FLAG_C = CFLAG_CLEAR;
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
M68KMAKE_OP(unlk, 32, ., a7)
{
- REG_A[7] = m68ki_read_32(REG_A[7]);
+ REG_A[7] = m68ki_read_32(state, REG_A[7]);
}
uint* r_dst = &AY;
REG_A[7] = *r_dst;
- *r_dst = m68ki_pull_32();
+ *r_dst = m68ki_pull_32(state);
}
uint src = DY;
uint* r_dst = &DX;
- *r_dst = MASK_OUT_BELOW_16(*r_dst) | (((((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16()) & 0xffff);
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | (((((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(state)) & 0xffff);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
/* Note: AX and AY are reversed in Motorola's docs */
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea_dst;
- src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16();
+ src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(state);
ea_dst = EA_A7_PD_8();
- m68ki_write_8(ea_dst, src & 0xff);
+ m68ki_write_8(state, ea_dst, src & 0xff);
ea_dst = EA_A7_PD_8();
- m68ki_write_8(ea_dst, (src >> 8) & 0xff);
+ m68ki_write_8(state, ea_dst, (src >> 8) & 0xff);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
/* Note: AX and AY are reversed in Motorola's docs */
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea_dst;
- src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16();
+ src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(state);
ea_dst = EA_AX_PD_8();
- m68ki_write_8(ea_dst, src & 0xff);
+ m68ki_write_8(state, ea_dst, src & 0xff);
ea_dst = EA_AX_PD_8();
- m68ki_write_8(ea_dst, (src >> 8) & 0xff);
+ m68ki_write_8(state, ea_dst, (src >> 8) & 0xff);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
{
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
- uint src = OPER_A7_PD_8();
+ uint src = OPER_A7_PD_8(state);
uint ea_dst;
- src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16();
+ src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(state);
ea_dst = EA_A7_PD_8();
- m68ki_write_8(ea_dst, src & 0xff);
+ m68ki_write_8(state, ea_dst, src & 0xff);
ea_dst = EA_A7_PD_8();
- m68ki_write_8(ea_dst, (src >> 8) & 0xff);
+ m68ki_write_8(state, ea_dst, (src >> 8) & 0xff);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
{
/* Note: AX and AY are reversed in Motorola's docs */
- uint src = OPER_AY_PD_8();
+ uint src = OPER_AY_PD_8(state);
uint ea_dst;
- src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16();
+ src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(state);
ea_dst = EA_AX_PD_8();
- m68ki_write_8(ea_dst, src & 0xff);
+ m68ki_write_8(state, ea_dst, src & 0xff);
ea_dst = EA_AX_PD_8();
- m68ki_write_8(ea_dst, (src >> 8) & 0xff);
+ m68ki_write_8(state, ea_dst, (src >> 8) & 0xff);
return;
}
- m68ki_exception_illegal();
+ m68ki_exception_illegal(state);
}
projects / pistorm / blobdiff