diff options
-rw-r--r-- | src/emu/cpu/g65816/g65816.c | 1183 | ||||
-rw-r--r-- | src/emu/cpu/g65816/g65816.h | 1490 | ||||
-rw-r--r-- | src/emu/cpu/g65816/g65816cm.h | 169 | ||||
-rw-r--r-- | src/emu/cpu/g65816/g65816op.h | 1060 | ||||
-rw-r--r-- | src/mess/includes/apple2gs.h | 3 | ||||
-rw-r--r-- | src/mess/machine/apple2gs.c | 2 |
6 files changed, 2644 insertions, 1263 deletions
diff --git a/src/emu/cpu/g65816/g65816.c b/src/emu/cpu/g65816/g65816.c index 143afc9c9d8..7beb093838e 100644 --- a/src/emu/cpu/g65816/g65816.c +++ b/src/emu/cpu/g65816/g65816.c @@ -95,111 +95,572 @@ TODO general: #include "emu.h" #include "g65816.h" -INLINE g65816i_cpu_struct *get_safe_token(device_t *device) + +const device_type G65816 = &device_creator<g65816_device>; +const device_type _5A22 = &device_creator<_5a22_device>; + + +g65816_device::g65816_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : cpu_device(mconfig, G65816, "G65C816", tag, owner, clock, "g65c816", __FILE__) + , m_program_config("program", ENDIANNESS_LITTLE, 8, 24, 0) + , m_cpu_type(CPU_TYPE_G65816) { - assert(device != NULL); - assert(device->type() == G65816 || device->type() == _5A22); - return (g65816i_cpu_struct *)downcast<legacy_cpu_device *>(device)->token(); } -/* Temporary Variables */ -static CPU_READOP( g65816 ) +g65816_device::g65816_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source, int cpu_type, address_map_constructor internal) + : cpu_device(mconfig, type, name, tag, owner, clock, shortname, source) + , m_program_config("program", ENDIANNESS_LITTLE, 8, 24, 0, internal) + , m_cpu_type(cpu_type) { - g65816i_cpu_struct *cpustate = get_safe_token(device); +} - *value = g65816_read_8_immediate(offset); - return 1; -} +static ADDRESS_MAP_START(_5a22_map, AS_PROGRAM, 8, _5a22_device) + AM_RANGE(0x4202, 0x4202) AM_MIRROR(0xbf0000) AM_WRITE(wrmpya_w) + AM_RANGE(0x4203, 0x4203) AM_MIRROR(0xbf0000) AM_WRITE(wrmpyb_w) + AM_RANGE(0x4204, 0x4204) AM_MIRROR(0xbf0000) AM_WRITE(wrdivl_w) + AM_RANGE(0x4205, 0x4205) AM_MIRROR(0xbf0000) AM_WRITE(wrdivh_w) + AM_RANGE(0x4206, 0x4206) AM_MIRROR(0xbf0000) AM_WRITE(wrdvdd_w) -extern void (*const g65816i_opcodes_M0X0[])(g65816i_cpu_struct *cpustate); -extern uint g65816i_get_reg_M0X0(g65816i_cpu_struct *cpustate, int regnum); -extern void g65816i_set_reg_M0X0(g65816i_cpu_struct *cpustate, int regnum, uint val); -extern void g65816i_set_line_M0X0(g65816i_cpu_struct *cpustate, int line, int state); -extern int g65816i_execute_M0X0(g65816i_cpu_struct *cpustate, int cycles); + AM_RANGE(0x420d, 0x420d) AM_MIRROR(0xbf0000) AM_WRITE(memsel_w) -extern void (*const g65816i_opcodes_M0X1[])(g65816i_cpu_struct *cpustate); -extern uint g65816i_get_reg_M0X1(g65816i_cpu_struct *cpustate, int regnum); -extern void g65816i_set_reg_M0X1(g65816i_cpu_struct *cpustate, int regnum, uint val); -extern void g65816i_set_line_M0X1(g65816i_cpu_struct *cpustate, int line, int state); -extern int g65816i_execute_M0X1(g65816i_cpu_struct *cpustate, int cycles); + AM_RANGE(0x4214, 0x4214) AM_MIRROR(0xbf0000) AM_READ(rddivl_r) + AM_RANGE(0x4215, 0x4215) AM_MIRROR(0xbf0000) AM_READ(rddivh_r) + AM_RANGE(0x4216, 0x4216) AM_MIRROR(0xbf0000) AM_READ(rdmpyl_r) + AM_RANGE(0x4217, 0x4217) AM_MIRROR(0xbf0000) AM_READ(rdmpyh_r) +ADDRESS_MAP_END -extern void (*const g65816i_opcodes_M1X0[])(g65816i_cpu_struct *cpustate); -extern uint g65816i_get_reg_M1X0(g65816i_cpu_struct *cpustate, int regnum); -extern void g65816i_set_reg_M1X0(g65816i_cpu_struct *cpustate, int regnum, uint val); -extern void g65816i_set_line_M1X0(g65816i_cpu_struct *cpustate, int line, int state); -extern int g65816i_execute_M1X0(g65816i_cpu_struct *cpustate, int cycles); -extern void (*const g65816i_opcodes_M1X1[])(g65816i_cpu_struct *cpustate); -extern uint g65816i_get_reg_M1X1(g65816i_cpu_struct *cpustate, int regnum); -extern void g65816i_set_reg_M1X1(g65816i_cpu_struct *cpustate, int regnum, uint val); -extern void g65816i_set_line_M1X1(g65816i_cpu_struct *cpustate, int line, int state); -extern int g65816i_execute_M1X1(g65816i_cpu_struct *cpustate, int cycles); +_5a22_device::_5a22_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : g65816_device(mconfig, _5A22, "5A22", tag, owner, clock, "5a22", __FILE__, CPU_TYPE_5A22, ADDRESS_MAP_NAME(_5a22_map)) +{ +} -extern void (*const g65816i_opcodes_E[])(g65816i_cpu_struct *cpustate); -extern uint g65816i_get_reg_E(g65816i_cpu_struct *cpustate, int regnum); -extern void g65816i_set_reg_E(g65816i_cpu_struct *cpustate, int regnum, uint val); -extern void g65816i_set_line_E(g65816i_cpu_struct *cpustate, int line, int state); -extern int g65816i_execute_E(g65816i_cpu_struct *cpustate, int cycles); -extern int bus_5A22_cycle_burst(g65816i_cpu_struct *cpustate, uint addr); +void g65816_device::g65816i_set_execution_mode(uint mode) +{ + assert(mode < 5); + switch (mode) + { + case 0: FTABLE_OPCODES = g65816i_opcodes_M0X0; break; + case 1: FTABLE_OPCODES = g65816i_opcodes_M0X1; break; + case 2: FTABLE_OPCODES = g65816i_opcodes_M1X0; break; + case 3: FTABLE_OPCODES = g65816i_opcodes_M1X1; break; + case 4: FTABLE_OPCODES = g65816i_opcodes_E; break; + } + FTABLE_GET_REG = s_g65816_get_reg[mode]; + FTABLE_SET_REG = s_g65816_set_reg[mode]; + FTABLE_SET_LINE = s_g65816_set_line[mode]; + FTABLE_EXECUTE = s_g65816_execute[mode]; +} -void (*const *const g65816i_opcodes[5])(g65816i_cpu_struct *cpustate) = +const g65816_device::get_reg_func g65816_device::s_g65816_get_reg[5] = { - g65816i_opcodes_M0X0, - g65816i_opcodes_M0X1, - g65816i_opcodes_M1X0, - g65816i_opcodes_M1X1, - g65816i_opcodes_E + &g65816_device::g65816i_get_reg_M0X0, + &g65816_device::g65816i_get_reg_M0X1, + &g65816_device::g65816i_get_reg_M1X0, + &g65816_device::g65816i_get_reg_M1X1, + &g65816_device::g65816i_get_reg_E }; -uint (*const g65816i_get_reg[5])(g65816i_cpu_struct *cpustate, int regnum) = +const g65816_device::set_reg_func g65816_device::s_g65816_set_reg[5] = { - g65816i_get_reg_M0X0, - g65816i_get_reg_M0X1, - g65816i_get_reg_M1X0, - g65816i_get_reg_M1X1, - g65816i_get_reg_E + &g65816_device::g65816i_set_reg_M0X0, + &g65816_device::g65816i_set_reg_M0X1, + &g65816_device::g65816i_set_reg_M1X0, + &g65816_device::g65816i_set_reg_M1X1, + &g65816_device::g65816i_set_reg_E }; -void (*const g65816i_set_reg[5])(g65816i_cpu_struct *cpustate, int regnum, uint val) = +const g65816_device::set_line_func g65816_device::s_g65816_set_line[5] = { - g65816i_set_reg_M0X0, - g65816i_set_reg_M0X1, - g65816i_set_reg_M1X0, - g65816i_set_reg_M1X1, - g65816i_set_reg_E + &g65816_device::g65816i_set_line_M0X0, + &g65816_device::g65816i_set_line_M0X1, + &g65816_device::g65816i_set_line_M1X0, + &g65816_device::g65816i_set_line_M1X1, + &g65816_device::g65816i_set_line_E }; -void (*const g65816i_set_line[5])(g65816i_cpu_struct *cpustate, int line, int state) = +const g65816_device::execute_func g65816_device::s_g65816_execute[5] = { - g65816i_set_line_M0X0, - g65816i_set_line_M0X1, - g65816i_set_line_M1X0, - g65816i_set_line_M1X1, - g65816i_set_line_E + &g65816_device::g65816i_execute_M0X0, + &g65816_device::g65816i_execute_M0X1, + &g65816_device::g65816i_execute_M1X0, + &g65816_device::g65816i_execute_M1X1, + &g65816_device::g65816i_execute_E }; -int (*const g65816i_execute[5])(g65816i_cpu_struct *cpustate, int cycles) = + +/* ======================================================================== */ +/* ================================= MEMORY =============================== */ +/* ======================================================================== */ + +#define ADDRESS_65816(A) ((A)&0x00ffffff) + +uint g65816_device::g65816i_read_8_normal(uint address) { - g65816i_execute_M0X0, - g65816i_execute_M0X1, - g65816i_execute_M1X0, - g65816i_execute_M1X1, - g65816i_execute_E -}; + address = ADDRESS_65816(address); + CLOCKS -= (bus_5A22_cycle_burst(address)); + return g65816_read_8(address); +} + +uint g65816_device::g65816i_read_8_immediate(uint address) +{ + address = ADDRESS_65816(address); + CLOCKS -= (bus_5A22_cycle_burst(address)); + return g65816_read_8_immediate(address); +} + +uint g65816_device::g65816i_read_8_direct(uint address) +{ + if (FLAG_E) + { + /* force address into zero page */ + address = REGISTER_D + MAKE_UINT_8(address - REGISTER_D); + CLOCKS -= (bus_5A22_cycle_burst(address)); + } + else + { + address = ADDRESS_65816(address); + CLOCKS -= (bus_5A22_cycle_burst(address)); + } + return g65816_read_8(address); +} + +uint g65816_device::g65816i_read_8_vector(uint address) +{ + if (!READ_VECTOR.isnull()) + return READ_VECTOR(*m_program, address, 0xff); + else + return g65816i_read_8_normal(address); +} + +void g65816_device::g65816i_write_8_normal(uint address, uint value) +{ + address = ADDRESS_65816(address); + CLOCKS -= (bus_5A22_cycle_burst(address)); + g65816_write_8(address, MAKE_UINT_8(value)); +} + +void g65816_device::g65816i_write_8_direct(uint address, uint value) +{ + if (FLAG_E) + { + /* force address into zero page */ + address = REGISTER_D + MAKE_UINT_8(address - REGISTER_D); + CLOCKS -= (bus_5A22_cycle_burst(address)); + } + else + { + address = ADDRESS_65816(address); + CLOCKS -= (bus_5A22_cycle_burst(address)); + } + g65816_write_8(address, MAKE_UINT_8(value)); +} + +uint g65816_device::g65816i_read_16_normal(uint address) +{ + return g65816i_read_8_normal(address) | + (g65816i_read_8_normal(address+1)<<8); +} + +uint g65816_device::g65816i_read_16_immediate(uint address) +{ + return g65816i_read_8_immediate(address) | + (g65816i_read_8_immediate(address+1)<<8); +} + +uint g65816_device::g65816i_read_16_direct(uint address) +{ + return g65816i_read_8_direct(address) | + (g65816i_read_8_direct(address+1)<<8); +} + +uint g65816_device::g65816i_read_16_vector(uint address) +{ + return g65816i_read_8_vector(address) | + (g65816i_read_8_vector(address+1)<<8); +} + +void g65816_device::g65816i_write_16_normal(uint address, uint value) +{ + g65816i_write_8_normal(address, value&0xff); + g65816i_write_8_normal(address+1, value>>8); +} + +void g65816_device::g65816i_write_16_direct(uint address, uint value) +{ + g65816i_write_8_direct(address, value&0xff); + g65816i_write_8_direct(address+1, value>>8); +} + +uint g65816_device::g65816i_read_24_normal(uint address) +{ + return g65816i_read_8_normal(address) | + (g65816i_read_8_normal(address+1)<<8) | + (g65816i_read_8_normal(address+2)<<16); +} + +uint g65816_device::g65816i_read_24_immediate(uint address) +{ + return g65816i_read_8_immediate(address) | + (g65816i_read_8_immediate(address+1)<<8) | + (g65816i_read_8_immediate(address+2)<<16); +} + +uint g65816_device::g65816i_read_24_direct(uint address) +{ + return g65816i_read_8_direct(address) | + (g65816i_read_8_direct(address+1)<<8) | + (g65816i_read_8_direct(address+2)<<16); +} + /* ======================================================================== */ -/* ================================= API ================================== */ +/* ================================= STACK ================================ */ +/* ======================================================================== */ + +void g65816_device::g65816i_push_8(uint value) +{ + g65816i_write_8_normal(REGISTER_S, value); + if (FLAG_E) + { + REGISTER_S = MAKE_UINT_8(REGISTER_S-1) | 0x100; + } + else + { + REGISTER_S = MAKE_UINT_16(REGISTER_S-1); + } +} + +uint g65816_device::g65816i_pull_8() +{ + if (FLAG_E) + { + REGISTER_S = MAKE_UINT_8(REGISTER_S+1) | 0x100; + } + else + { + REGISTER_S = MAKE_UINT_16(REGISTER_S+1); + } + return g65816i_read_8_normal(REGISTER_S); +} + +void g65816_device::g65816i_push_16(uint value) +{ + g65816i_push_8(value>>8); + g65816i_push_8(value&0xff); +} + +uint g65816_device::g65816i_pull_16() +{ + uint res = g65816i_pull_8(); + return res | (g65816i_pull_8() << 8); +} + +void g65816_device::g65816i_push_24(uint value) +{ + g65816i_push_8(value>>16); + g65816i_push_8((value>>8)&0xff); + g65816i_push_8(value&0xff); +} + +uint g65816_device::g65816i_pull_24() +{ + uint res = g65816i_pull_8(); + res |= g65816i_pull_8() << 8; + return ((res + 1) & 0xffff) | (g65816i_pull_8() << 16); +} + + +/* ======================================================================== */ +/* ============================ PROGRAM COUNTER =========================== */ +/* ======================================================================== */ + +void g65816_device::g65816i_jump_16(uint address) +{ + REGISTER_PC = MAKE_UINT_16(address); + g65816i_jumping(REGISTER_PC); +} + +void g65816_device::g65816i_jump_24(uint address) +{ + REGISTER_PB = address&0xff0000; + REGISTER_PC = MAKE_UINT_16(address); + g65816i_jumping(REGISTER_PC); +} + +void g65816_device::g65816i_branch_8(uint offset) +{ + if (FLAG_E) + { + uint old_pc = REGISTER_PC; + REGISTER_PC = MAKE_UINT_16(REGISTER_PC + MAKE_INT_8(offset)); + if((REGISTER_PC^old_pc)&0xff00) + CLK(1); + } + else + { + REGISTER_PC = MAKE_UINT_16(REGISTER_PC + MAKE_INT_8(offset)); + } + g65816i_branching(REGISTER_PC); +} + +void g65816_device::g65816i_branch_16(uint offset) +{ + REGISTER_PC = MAKE_UINT_16(REGISTER_PC + offset); + g65816i_branching(REGISTER_PC); +} + + +/* ======================================================================== */ +/* ============================ STATUS REGISTER =========================== */ +/* ======================================================================== */ + +void g65816_device::g65816i_set_flag_mx(uint value) +{ + if (FLAG_M) + { + if(!(value & FLAGPOS_M)) + { + REGISTER_A |= REGISTER_B; + REGISTER_B = 0; + FLAG_M = MFLAG_CLEAR; + } + } + else + { + if(value & FLAGPOS_M) + { + REGISTER_B = REGISTER_A & 0xff00; + REGISTER_A = MAKE_UINT_8(REGISTER_A); + FLAG_M = MFLAG_SET; + } + } + if (FLAG_X) + { + if(!(value & FLAGPOS_X)) + { + FLAG_X = XFLAG_CLEAR; + } + } + else + { + if(value & FLAGPOS_X) + { + REGISTER_X = MAKE_UINT_8(REGISTER_X); + REGISTER_Y = MAKE_UINT_8(REGISTER_Y); + FLAG_X = XFLAG_SET; + } + } + g65816i_set_execution_mode((FLAG_M>>4) | (FLAG_X>>4)); +} + +void g65816_device::g65816i_set_flag_e(uint value) +{ + if (FLAG_E) + { + if(!value) + { + FLAG_E = EFLAG_CLEAR; + g65816i_set_execution_mode(EXECUTION_MODE_M1X1); + } + } + else + { + if(value) + { + if (!FLAG_M) + { + REGISTER_B = REGISTER_A & 0xff00; + REGISTER_A &= 0x00ff; + FLAG_M = MFLAG_SET; + } + if (!FLAG_X) + { + REGISTER_X = MAKE_UINT_8(REGISTER_X); + REGISTER_Y = MAKE_UINT_8(REGISTER_Y); + FLAG_X = XFLAG_SET; + } + REGISTER_S = MAKE_UINT_8(REGISTER_S) | 0x100; + FLAG_E = EFLAG_SET; + g65816i_set_execution_mode(EXECUTION_MODE_E); + } + } +} + +void g65816_device::g65816i_set_flag_i(uint value) +{ + value &= FLAGPOS_I; + if(!FLAG_I || value) + { + FLAG_I = value; + return; + } + FLAG_I = value; +} + +/* Get the Processor Status Register */ +uint g65816_device::g65816i_get_reg_p() +{ + return (FLAG_N&0x80) | + ((FLAG_V>>1)&0x40) | + FLAG_M | + FLAG_X | + FLAG_D | + FLAG_I | + ((!FLAG_Z)<<1) | + ((FLAG_C>>8)&1); +} + +void g65816_device::g65816i_set_reg_p(uint value) +{ + if (FLAG_E) + { + FLAG_N = value; + FLAG_V = value << 1; + FLAG_D = value & FLAGPOS_D; + FLAG_Z = !(value & FLAGPOS_Z); + FLAG_C = value << 8; + g65816i_set_flag_i(value); + } + else + { + FLAG_N = value; + FLAG_V = value << 1; + FLAG_D = value & FLAGPOS_D; + FLAG_Z = !(value & FLAGPOS_Z); + FLAG_C = value << 8; + g65816i_set_flag_mx(value); + g65816i_set_flag_i(value); + } +} + + /* ======================================================================== */ +/* =============================== INTERRUPTS ============================= */ +/* ======================================================================== */ + +void g65816_device::g65816i_interrupt_hardware(uint vector) +{ + if (FLAG_E) + { + CLK(7); + g65816i_push_16(REGISTER_PC); + g65816i_push_8(g65816i_get_reg_p() & ~FLAGPOS_B); + FLAG_D = DFLAG_CLEAR; + g65816i_set_flag_i(IFLAG_SET); + REGISTER_PB = 0; + g65816i_jump_16(g65816i_read_16_vector(vector)); + standard_irq_callback(0); + } + else + { + CLK(8); + g65816i_push_8(REGISTER_PB>>16); + g65816i_push_16(REGISTER_PC); + g65816i_push_8(g65816i_get_reg_p()); + FLAG_D = DFLAG_CLEAR; + g65816i_set_flag_i(IFLAG_SET); + REGISTER_PB = 0; + g65816i_jump_16(g65816i_read_16_vector(vector)); + standard_irq_callback(0); + } +} + +void g65816_device::g65816i_interrupt_software(uint vector) +{ + if (FLAG_E) + { + CLK(7); + g65816i_push_16(REGISTER_PC); + g65816i_push_8(g65816i_get_reg_p()); + FLAG_D = DFLAG_CLEAR; + g65816i_set_flag_i(IFLAG_SET); + REGISTER_PB = 0; + g65816i_jump_16(g65816i_read_16_normal(vector)); + } + else + { + CLK(8); + g65816i_push_8(REGISTER_PB>>16); + g65816i_push_16(REGISTER_PC); + g65816i_push_8(g65816i_get_reg_p()); + FLAG_D = DFLAG_CLEAR; + g65816i_set_flag_i(IFLAG_SET); + REGISTER_PB = 0; + g65816i_jump_16(g65816i_read_16_normal(vector)); + } +} + +void g65816_device::g65816i_interrupt_nmi() +{ + if (FLAG_E) + { + CLK(7); + g65816i_push_16(REGISTER_PC); + g65816i_push_8(g65816i_get_reg_p() & ~FLAGPOS_B); + FLAG_D = DFLAG_CLEAR; + REGISTER_PB = 0; + g65816i_jump_16(g65816i_read_16_normal((FLAG_E) ? VECTOR_NMI_E : VECTOR_NMI_N)); + } + else + { + CLK(8); + g65816i_push_8(REGISTER_PB>>16); + g65816i_push_16(REGISTER_PC); + g65816i_push_8(g65816i_get_reg_p()); + FLAG_D = DFLAG_CLEAR; + REGISTER_PB = 0; + g65816i_jump_16(g65816i_read_16_normal((FLAG_E) ? VECTOR_NMI_E : VECTOR_NMI_N)); + } +} -static CPU_RESET( g65816 ) +void g65816_device::g65816i_check_maskable_interrupt() { - g65816i_cpu_struct *cpustate = get_safe_token(device); + if(!(CPU_STOPPED & STOP_LEVEL_STOP) && LINE_IRQ && !FLAG_I) + { + g65816i_interrupt_hardware((FLAG_E) ? VECTOR_IRQ_E : VECTOR_IRQ_N); + CPU_STOPPED &= ~STOP_LEVEL_WAI; + LINE_IRQ=0; + } +} + +uint g65816_device::EA_IMM8() {REGISTER_PC += 1; return REGISTER_PB | MAKE_UINT_16(REGISTER_PC-1);} +uint g65816_device::EA_IMM16() {REGISTER_PC += 2; return REGISTER_PB | MAKE_UINT_16(REGISTER_PC-2);} +uint g65816_device::EA_IMM24() {REGISTER_PC += 3; return REGISTER_PB | MAKE_UINT_16(REGISTER_PC-3);} +uint g65816_device::EA_D() {if(MAKE_UINT_8(REGISTER_D)) CLK(1); return MAKE_UINT_16(REGISTER_D + g65816i_read_8_immediate(EA_IMM8()));} +uint g65816_device::EA_A() {return REGISTER_DB | g65816i_read_16_immediate(EA_IMM16());} +uint g65816_device::EA_AL() {return g65816i_read_24_immediate(EA_IMM24());} +uint g65816_device::EA_DX() {return MAKE_UINT_16(REGISTER_D + g65816i_read_8_immediate(EA_IMM8()) + REGISTER_X);} +uint g65816_device::EA_DY() {return MAKE_UINT_16(REGISTER_D + g65816i_read_8_immediate(EA_IMM8()) + REGISTER_Y);} +uint g65816_device::EA_AX() {uint tmp = EA_A(); if((tmp^(tmp+REGISTER_X))&0xff00) CLK(1); return tmp + REGISTER_X;} +uint g65816_device::EA_ALX() {return EA_AL() + REGISTER_X;} +uint g65816_device::EA_AY() {uint tmp = EA_A(); if((tmp^(tmp+REGISTER_X))&0xff00) CLK(1); return tmp + REGISTER_Y;} +uint g65816_device::EA_DI() {return REGISTER_DB | g65816i_read_16_direct(EA_D());} +uint g65816_device::EA_DLI() {return g65816i_read_24_direct(EA_D());} +uint g65816_device::EA_AI() {return g65816i_read_16_normal(g65816i_read_16_immediate(EA_IMM16()));} +uint g65816_device::EA_ALI() {return g65816i_read_24_normal(EA_A());} +uint g65816_device::EA_DXI() {return REGISTER_DB | g65816i_read_16_direct(EA_DX());} +uint g65816_device::EA_DIY() {uint tmp = REGISTER_DB | g65816i_read_16_direct(EA_D()); if((tmp^(tmp+REGISTER_X))&0xff00) CLK(1); return tmp + REGISTER_Y;} +uint g65816_device::EA_DLIY() {return g65816i_read_24_direct(EA_D()) + REGISTER_Y;} +uint g65816_device::EA_AXI() {return g65816i_read_16_normal(MAKE_UINT_16(g65816i_read_16_immediate(EA_IMM16()) + REGISTER_X));} +uint g65816_device::EA_S() {return MAKE_UINT_16(REGISTER_S + g65816i_read_8_immediate(EA_IMM8()));} +uint g65816_device::EA_SIY() {return MAKE_UINT_16(g65816i_read_16_normal(REGISTER_S + g65816i_read_8_immediate(EA_IMM8())) + REGISTER_Y) | REGISTER_DB;} + + + +/* ======================================================================== */ +/* ================================= API ================================== */ +/* ======================================================================== */ + + +void g65816_device::device_reset() +{ /* Start the CPU */ CPU_STOPPED = 0; @@ -229,7 +690,7 @@ static CPU_RESET( g65816 ) IRQ_DELAY = 0; /* Set the function tables to emulation mode */ - g65816i_set_execution_mode(cpustate, EXECUTION_MODE_E); + g65816i_set_execution_mode(EXECUTION_MODE_E); /* 6502 expects these, but its not in the 65816 spec */ FLAG_Z = ZFLAG_CLEAR; @@ -240,30 +701,23 @@ static CPU_RESET( g65816 ) g65816i_jumping(REGISTER_PB | REGISTER_PC); } -/* Exit and clean up */ -static CPU_EXIT( g65816 ) -{ - /* nothing to do yet */ -} /* Execute some instructions */ -static CPU_EXECUTE( g65816 ) +void g65816_device::execute_run() { - g65816i_cpu_struct *cpustate = get_safe_token(device); - - int clocks = cpustate->ICount; - cpustate->ICount = clocks - FTABLE_EXECUTE(cpustate, cpustate->ICount); + int clocks = m_ICount; + m_ICount = clocks - (this->*FTABLE_EXECUTE)(m_ICount); } /* Get the current Program Counter */ -static unsigned g65816_get_pc(g65816i_cpu_struct *cpustate) +unsigned g65816_device::g65816_get_pc() { return REGISTER_PB | REGISTER_PC; } /* Set the Program Counter */ -static void g65816_set_pc(g65816i_cpu_struct *cpustate, unsigned val) +void g65816_device::g65816_set_pc(unsigned val) { REGISTER_PC = MAKE_UINT_16(val); REGISTER_PB = (val >> 16) & 0xFF; @@ -271,278 +725,273 @@ static void g65816_set_pc(g65816i_cpu_struct *cpustate, unsigned val) } /* Get the current Stack Pointer */ -static unsigned g65816_get_sp(g65816i_cpu_struct *cpustate) +unsigned g65816_device::g65816_get_sp() { return REGISTER_S; } /* Set the Stack Pointer */ -static void g65816_set_sp(g65816i_cpu_struct *cpustate, unsigned val) +void g65816_device::g65816_set_sp(unsigned val) { REGISTER_S = FLAG_E ? MAKE_UINT_8(val) | 0x100 : MAKE_UINT_16(val); } /* Get a register */ -static unsigned g65816_get_reg(g65816i_cpu_struct *cpustate, int regnum) +unsigned g65816_device::g65816_get_reg(int regnum) { /* Set the function tables to emulation mode if the FTABLE is NULL */ if( FTABLE_GET_REG == NULL ) - g65816i_set_execution_mode(cpustate, EXECUTION_MODE_E); + g65816i_set_execution_mode(EXECUTION_MODE_E); - return FTABLE_GET_REG(cpustate, regnum); + return (this->*FTABLE_GET_REG)(regnum); } /* Set a register */ -static void g65816_set_reg(g65816i_cpu_struct *cpustate, int regnum, unsigned value) +void g65816_device::g65816_set_reg(int regnum, unsigned value) { - FTABLE_SET_REG(cpustate, regnum, value); + (this->*FTABLE_SET_REG)(regnum, value); } /* Set an interrupt line */ -static void g65816_set_irq_line(g65816i_cpu_struct *cpustate, int line, int state) -{ - FTABLE_SET_LINE(cpustate, line, state); -} - -/* Set the callback that is called when servicing an interrupt */ -static void g65816_set_irq_callback(g65816i_cpu_struct *cpustate, device_irq_acknowledge_callback callback) +void g65816_device::execute_set_input(int line, int state) { - INT_ACK = callback; + (this->*FTABLE_SET_LINE)(line, state); } - /* Disassemble an instruction */ #include "g65816ds.h" -static CPU_DISASSEMBLE( g65816 ) -{ - g65816i_cpu_struct *cpustate = get_safe_token(device); +offs_t g65816_device::disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) +{ return g65816_disassemble(buffer, (pc & 0x00ffff), (pc & 0xff0000) >> 16, oprom, FLAG_M, FLAG_X); } -static void g65816_restore_state(g65816i_cpu_struct *cpustate) +CPU_DISASSEMBLE( g65816 ) +{ + return g65816_disassemble(buffer, (pc & 0x00ffff), (pc & 0xff0000) >> 16, oprom, 0/*FLAG_M*/, 0/*FLAG_X*/); +} + +void g65816_device::g65816_restore_state() { // restore proper function pointers - g65816i_set_execution_mode(cpustate, (FLAG_M>>4) | (FLAG_X>>4)); + g65816i_set_execution_mode((FLAG_M>>4) | (FLAG_X>>4)); // make sure the memory system can keep up g65816i_jumping(REGISTER_PB | REGISTER_PC); } -static CPU_INIT( g65816 ) +void g65816_device::device_start() { - g65816i_cpu_struct *cpustate = get_safe_token(device); - - memset(cpustate, 0, sizeof(*cpustate)); - - g65816_set_irq_callback(cpustate, irqcallback); - cpustate->device = device; - cpustate->program = &device->space(AS_PROGRAM); - cpustate->cpu_type = CPU_TYPE_G65816; - - device->save_item(NAME(cpustate->a)); - device->save_item(NAME(cpustate->b)); - device->save_item(NAME(cpustate->x)); - device->save_item(NAME(cpustate->y)); - device->save_item(NAME(cpustate->s)); - device->save_item(NAME(cpustate->pc)); - device->save_item(NAME(cpustate->ppc)); - device->save_item(NAME(cpustate->pb)); - device->save_item(NAME(cpustate->db)); - device->save_item(NAME(cpustate->d)); - device->save_item(NAME(cpustate->flag_e)); - device->save_item(NAME(cpustate->flag_m)); - device->save_item(NAME(cpustate->flag_x)); - device->save_item(NAME(cpustate->flag_n)); - device->save_item(NAME(cpustate->flag_v)); - device->save_item(NAME(cpustate->flag_d)); - device->save_item(NAME(cpustate->flag_i)); - device->save_item(NAME(cpustate->flag_z)); - device->save_item(NAME(cpustate->flag_c)); - device->save_item(NAME(cpustate->line_irq)); - device->save_item(NAME(cpustate->line_nmi)); - device->save_item(NAME(cpustate->ir)); - device->save_item(NAME(cpustate->irq_delay)); - device->save_item(NAME(cpustate->stopped)); - device->save_item(NAME(cpustate->fastROM)); - - device->machine().save().register_postload(save_prepost_delegate(FUNC(g65816_restore_state), cpustate)); - - cpustate->rw8_cycles = 1; - cpustate->rw16_cycles = 2; - cpustate->rw24_cycles = 3; + m_a = 0; + m_b = 0; + m_x = 0; + m_y = 0; + m_s = 0; + m_pc = 0; + m_ppc = 0; + m_pb = 0; + m_db = 0; + m_d = 0; + m_flag_e = 0; + m_flag_m = 0; + m_flag_x = 0; + m_flag_n = 0; + m_flag_v = 0; + m_flag_d = 0; + m_flag_i = 0; + m_flag_z = 0; + m_flag_c = 0; + m_line_irq = 0; + m_line_nmi = 0; + m_fastROM = 0; + m_ir = 0; + m_irq_delay = 0; + m_stopped = 0; + m_source = 0; + m_destination = 0; + m_wrmpya = 0; + m_wrmpyb = 0; + m_rdmpy = 0; + m_wrdiv = 0; + m_dvdd = 0; + m_rddiv = 0; + m_opcodes = NULL; + m_get_reg = NULL; + m_set_reg = NULL; + m_set_line = NULL; + m_execute = NULL; + + m_program = &space(AS_PROGRAM); + m_cpu_type = CPU_TYPE_G65816; + + save_item(NAME(m_a)); + save_item(NAME(m_b)); + save_item(NAME(m_x)); + save_item(NAME(m_y)); + save_item(NAME(m_s)); + save_item(NAME(m_pc)); + save_item(NAME(m_ppc)); + save_item(NAME(m_pb)); + save_item(NAME(m_db)); + save_item(NAME(m_d)); + save_item(NAME(m_flag_e)); + save_item(NAME(m_flag_m)); + save_item(NAME(m_flag_x)); + save_item(NAME(m_flag_n)); + save_item(NAME(m_flag_v)); + save_item(NAME(m_flag_d)); + save_item(NAME(m_flag_i)); + save_item(NAME(m_flag_z)); + save_item(NAME(m_flag_c)); + save_item(NAME(m_line_irq)); + save_item(NAME(m_line_nmi)); + save_item(NAME(m_ir)); + save_item(NAME(m_irq_delay)); + save_item(NAME(m_stopped)); + save_item(NAME(m_fastROM)); + + machine().save().register_postload(save_prepost_delegate(FUNC(g65816_device::g65816_restore_state), this)); + + m_rw8_cycles = 1; + m_rw16_cycles = 2; + m_rw24_cycles = 3; + + state_add( G65816_PC, "PC", m_debugger_temp).callimport().callexport().formatstr("%06X"); + state_add( G65816_S, "S", m_s).callimport().formatstr("%04X"); + state_add( G65816_P, "P", m_debugger_temp).callimport().callexport().formatstr("%02X"); + state_add( G65816_A, "A", m_debugger_temp).callimport().callexport().formatstr("%04X"); + state_add( G65816_X, "X", m_x).callimport().formatstr("%04X"); + state_add( G65816_Y, "Y", m_y).callimport().formatstr("%04X"); + state_add( G65816_PB, "PB", m_debugger_temp).callimport().callexport().formatstr("%02X"); + state_add( G65816_DB, "DB", m_debugger_temp).callimport().callexport().formatstr("%02X"); + state_add( G65816_D, "D", m_d).callimport().formatstr("%04X"); + state_add( G65816_E, "E", m_flag_e).mask(0x01).callimport().formatstr("%01X"); + state_add( G65816_NMI_STATE, "NMI", m_line_nmi).mask(0x01).callimport().formatstr("%01X"); + state_add( G65816_IRQ_STATE, "IRQ", m_line_irq).mask(0x01).callimport().formatstr("%01X"); + + state_add( STATE_GENPC, "GENPC", m_debugger_temp).callimport().callexport().formatstr("%06X").noshow(); + state_add( STATE_GENSP, "GENSP", m_debugger_temp).callimport().callexport().formatstr("%06X").noshow(); + state_add( STATE_GENFLAGS, "GENFLAGS", m_debugger_temp).formatstr("%8s").noshow(); + + m_icountptr = &m_ICount; } -/************************************************************************** - * Generic set_info - **************************************************************************/ - -static CPU_SET_INFO( g65816 ) +void g65816_device::state_import(const device_state_entry &entry) { - g65816i_cpu_struct *cpustate = get_safe_token(device); - - switch (state) + switch (entry.index()) { - /* --- the following bits of info are set as 64-bit signed integers --- */ - case CPUINFO_INT_INPUT_STATE + G65816_LINE_IRQ: g65816_set_irq_line(cpustate, G65816_LINE_IRQ, info->i); break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_NMI: g65816_set_irq_line(cpustate, G65816_LINE_NMI, info->i); break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_ABORT: g65816_set_irq_line(cpustate, G65816_LINE_ABORT, info->i); break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_SO: g65816_set_irq_line(cpustate, G65816_LINE_SO, info->i); break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_RDY: g65816_set_irq_line(cpustate, G65816_LINE_RDY, info->i); break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_RESET: g65816_set_irq_line(cpustate, G65816_LINE_RESET, info->i); break; - - case CPUINFO_INT_PC: g65816_set_pc(cpustate, info->i); break; - case CPUINFO_INT_SP: g65816_set_sp(cpustate, info->i); break; - - case CPUINFO_INT_REGISTER + G65816_PC: g65816_set_reg(cpustate, G65816_PC, info->i); break; - case CPUINFO_INT_REGISTER + G65816_S: g65816_set_reg(cpustate, G65816_S, info->i); break; - case CPUINFO_INT_REGISTER + G65816_P: g65816_set_reg(cpustate, G65816_P, info->i); break; - case CPUINFO_INT_REGISTER + G65816_A: g65816_set_reg(cpustate, G65816_A, info->i); break; - case CPUINFO_INT_REGISTER + G65816_X: g65816_set_reg(cpustate, G65816_X, info->i); break; - case CPUINFO_INT_REGISTER + G65816_Y: g65816_set_reg(cpustate, G65816_Y, info->i); break; - case CPUINFO_INT_REGISTER + G65816_PB: g65816_set_reg(cpustate, G65816_PB, info->i); break; - case CPUINFO_INT_REGISTER + G65816_DB: g65816_set_reg(cpustate, G65816_DB, info->i); break; - case CPUINFO_INT_REGISTER + G65816_D: g65816_set_reg(cpustate, G65816_D, info->i); break; - case CPUINFO_INT_REGISTER + G65816_E: g65816_set_reg(cpustate, G65816_E, info->i); break; - case CPUINFO_INT_REGISTER + G65816_NMI_STATE: g65816_set_reg(cpustate, G65816_NMI_STATE, info->i); break; - case CPUINFO_INT_REGISTER + G65816_IRQ_STATE: g65816_set_reg(cpustate, G65816_IRQ_STATE, info->i); break; + case STATE_GENPC: + g65816_set_pc(m_debugger_temp); + break; + case STATE_GENSP: + g65816_set_sp(m_debugger_temp); + break; + case G65816_PC: + case G65816_PB: + case G65816_DB: + g65816_set_reg(entry.index(), m_debugger_temp); + break; + case G65816_D: + g65816_set_reg(G65816_D, m_d); + break; + case G65816_S: + g65816_set_reg(G65816_S, m_s); + break; + case G65816_P: + g65816_set_reg(G65816_P, m_debugger_temp); + break; + case G65816_E: + g65816_set_reg(G65816_E, m_flag_e); + break; + case G65816_A: + g65816_set_reg(G65816_A, m_debugger_temp); + break; + case G65816_X: + g65816_set_reg(G65816_X, m_x); + break; + case G65816_Y: + g65816_set_reg(G65816_Y, m_y); + break; + case G65816_NMI_STATE: + g65816_set_reg(G65816_NMI_STATE, m_line_nmi); + break; + case G65816_IRQ_STATE: + g65816_set_reg(G65816_IRQ_STATE, m_line_irq); + break; } } - - -void g65816_set_read_vector_callback(device_t *device, read8_delegate read_vector) +void g65816_device::state_export(const device_state_entry &entry) { - g65816i_cpu_struct *cpustate = get_safe_token(device); - READ_VECTOR = read_vector; + switch (entry.index()) + { + case STATE_GENPC: + case G65816_PC: + m_debugger_temp = g65816_get_pc(); + break; + case STATE_GENSP: + m_debugger_temp = g65816_get_sp(); + break; + case G65816_PB: + m_debugger_temp = m_pb>>16; + break; + case G65816_DB: + m_debugger_temp = m_db>>16; + break; + case G65816_P: + m_debugger_temp = (m_flag_n&0x80) | + ((m_flag_v>>1)&0x40) | + m_flag_m | + m_flag_x | + m_flag_d | + m_flag_i | + ((!m_flag_z)<<1) | + ((m_flag_c>>8)&1); + break; + case G65816_A: + m_debugger_temp = m_a | m_b; + break; + } } -/************************************************************************** - * Generic get_info - **************************************************************************/ - -CPU_GET_INFO( g65816 ) -{ - g65816i_cpu_struct *cpustate = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL; - - switch (state) - { - /* --- the following bits of info are returned as 64-bit signed integers --- */ - case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(g65816i_cpu_struct); break; - case CPUINFO_INT_INPUT_LINES: info->i = 1; break; - case CPUINFO_INT_DEFAULT_IRQ_VECTOR: info->i = 0; break; - case CPUINFO_INT_ENDIANNESS: info->i = ENDIANNESS_LITTLE; break; - case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break; - case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break; - case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 1; break; - case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 4; break; - case CPUINFO_INT_MIN_CYCLES: info->i = 1; break; - case CPUINFO_INT_MAX_CYCLES: info->i = 20; /* rough guess */ break; - - case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 8; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 24; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = 0; break; - case CPUINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 0; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 0; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_DATA: info->i = 0; break; - case CPUINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 0; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 0; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_IO: info->i = 0; break; - - case CPUINFO_INT_INPUT_STATE + G65816_LINE_IRQ: info->i = LINE_IRQ; break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_NMI: info->i = LINE_NMI; break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_ABORT: info->i = 0; break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_SO: info->i = 0; break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_RDY: info->i = 0; break; - case CPUINFO_INT_INPUT_STATE + G65816_LINE_RESET: info->i = 0; break; - - case CPUINFO_INT_PREVIOUSPC: /* not supported */ break; - - case CPUINFO_INT_PC: info->i = g65816_get_pc(cpustate); break; - case CPUINFO_INT_SP: info->i = g65816_get_sp(cpustate); break; - - case CPUINFO_INT_REGISTER + G65816_PC: info->i = g65816_get_pc(cpustate); break; - case CPUINFO_INT_REGISTER + G65816_S: info->i = g65816_get_reg(cpustate, G65816_S); break; - case CPUINFO_INT_REGISTER + G65816_P: info->i = g65816_get_reg(cpustate, G65816_P); break; - case CPUINFO_INT_REGISTER + G65816_A: info->i = g65816_get_reg(cpustate, G65816_A); break; - case CPUINFO_INT_REGISTER + G65816_X: info->i = g65816_get_reg(cpustate, G65816_X); break; - case CPUINFO_INT_REGISTER + G65816_Y: info->i = g65816_get_reg(cpustate, G65816_Y); break; - case CPUINFO_INT_REGISTER + G65816_PB: info->i = g65816_get_reg(cpustate, G65816_PB); break; - case CPUINFO_INT_REGISTER + G65816_DB: info->i = g65816_get_reg(cpustate, G65816_DB); break; - case CPUINFO_INT_REGISTER + G65816_D: info->i = g65816_get_reg(cpustate, G65816_D); break; - case CPUINFO_INT_REGISTER + G65816_E: info->i = g65816_get_reg(cpustate, G65816_E); break; - case CPUINFO_INT_REGISTER + G65816_NMI_STATE: info->i = g65816_get_reg(cpustate, G65816_NMI_STATE); break; - case CPUINFO_INT_REGISTER + G65816_IRQ_STATE: info->i = g65816_get_reg(cpustate, G65816_IRQ_STATE); break; - - /* --- the following bits of info are returned as pointers to data or functions --- */ - case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(g65816); break; - case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(g65816); break; - case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(g65816); break; - case CPUINFO_FCT_EXIT: info->exit = CPU_EXIT_NAME(g65816); break; - case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(g65816); break; - case CPUINFO_FCT_BURN: info->burn = NULL; break; - case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(g65816); break; - case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->ICount; break; - - case CPUINFO_FCT_READOP: info->readop = CPU_READOP_NAME(g65816); break; - - /* --- the following bits of info are returned as NULL-terminated strings --- */ - case CPUINFO_STR_NAME: strcpy(info->s, "G65C816"); break; - case CPUINFO_STR_SHORTNAME: strcpy(info->s, "g65c816"); break; - case CPUINFO_STR_FAMILY: strcpy(info->s, "6500"); break; - case CPUINFO_STR_VERSION: strcpy(info->s, "1.0"); break; - case CPUINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; - case CPUINFO_STR_CREDITS: strcpy(info->s, "Copyright Karl Stenerud, all rights reserved."); break; - - case CPUINFO_STR_FLAGS: - sprintf(info->s, "%c%c%c%c%c%c%c%c", - cpustate->flag_n & NFLAG_SET ? 'N':'.', - cpustate->flag_v & VFLAG_SET ? 'V':'.', - cpustate->flag_m & MFLAG_SET ? 'M':'.', - cpustate->flag_x & XFLAG_SET ? 'X':'.', - cpustate->flag_d & DFLAG_SET ? 'D':'.', - - cpustate->flag_i & IFLAG_SET ? 'I':'.', - cpustate->flag_z == 0 ? 'Z':'.', - cpustate->flag_c & CFLAG_SET ? 'C':'.'); +void g65816_device::state_string_export(const device_state_entry &entry, astring &string) +{ + switch (entry.index()) + { + case STATE_GENFLAGS: + string.printf("%c%c%c%c%c%c%c%c", + m_flag_n & NFLAG_SET ? 'N':'.', + m_flag_v & VFLAG_SET ? 'V':'.', + m_flag_m & MFLAG_SET ? 'M':'.', + m_flag_x & XFLAG_SET ? 'X':'.', + m_flag_d & DFLAG_SET ? 'D':'.', + + m_flag_i & IFLAG_SET ? 'I':'.', + m_flag_z == 0 ? 'Z':'.', + m_flag_c & CFLAG_SET ? 'C':'.'); break; - - case CPUINFO_STR_REGISTER + G65816_PC: sprintf(info->s, "PC:%06X", g65816_get_pc(cpustate)); break; - case CPUINFO_STR_REGISTER + G65816_PB: sprintf(info->s, "PB:%02X", cpustate->pb>>16); break; - case CPUINFO_STR_REGISTER + G65816_DB: sprintf(info->s, "DB:%02X", cpustate->db>>16); break; - case CPUINFO_STR_REGISTER + G65816_D: sprintf(info->s, "D:%04X", cpustate->d); break; - case CPUINFO_STR_REGISTER + G65816_S: sprintf(info->s, "S:%04X", cpustate->s); break; - case CPUINFO_STR_REGISTER + G65816_P: sprintf(info->s, "P:%02X", - (cpustate->flag_n&0x80) | - ((cpustate->flag_v>>1)&0x40) | - cpustate->flag_m | - cpustate->flag_x | - cpustate->flag_d | - cpustate->flag_i | - ((!cpustate->flag_z)<<1) | - ((cpustate->flag_c>>8)&1)); break; - case CPUINFO_STR_REGISTER + G65816_E: sprintf(info->s, "E:%d", cpustate->flag_e); break; - case CPUINFO_STR_REGISTER + G65816_A: sprintf(info->s, "A:%04X", cpustate->a | cpustate->b); break; - case CPUINFO_STR_REGISTER + G65816_X: sprintf(info->s, "X:%04X", cpustate->x); break; - case CPUINFO_STR_REGISTER + G65816_Y: sprintf(info->s, "Y:%04X", cpustate->y); break; - case CPUINFO_STR_REGISTER + G65816_NMI_STATE: sprintf(info->s, "NMI:%X", cpustate->line_nmi); break; - case CPUINFO_STR_REGISTER + G65816_IRQ_STATE: sprintf(info->s, "IRQ:%X", cpustate->line_irq); break; } } +void g65816_device::set_read_vector_callback(read8_delegate read_vector) +{ + READ_VECTOR = read_vector; +} + + /* SNES specific, used to handle master cycles, based off byuu's BSNES code */ -int bus_5A22_cycle_burst(g65816i_cpu_struct *cpustate, uint addr) +int g65816_device::bus_5A22_cycle_burst(uint addr) { - if(cpustate->cpu_type == CPU_TYPE_G65816) + if(m_cpu_type == CPU_TYPE_G65816) return 0; if(addr & 0x408000) { if(addr & 0x800000) - return (cpustate->fastROM & 1) ? 6 : 8; + return (m_fastROM & 1) ? 6 : 8; return 8; } @@ -553,27 +1002,50 @@ int bus_5A22_cycle_burst(g65816i_cpu_struct *cpustate, uint addr) } -static CPU_INIT( 5a22 ) +void _5a22_device::device_start() { - g65816i_cpu_struct *cpustate = get_safe_token(device); + g65816_device::device_start(); - CPU_INIT_CALL(g65816); + state_add( _5A22_FASTROM, "fastROM", m_debugger_temp).mask(0x01).callimport().callexport().formatstr("%01X"); - cpustate->cpu_type = CPU_TYPE_5A22; - cpustate->rw8_cycles = 0; - cpustate->rw16_cycles = 0; - cpustate->rw24_cycles = 0; + m_rw8_cycles = 0; + m_rw16_cycles = 0; + m_rw24_cycles = 0; } -static CPU_RESET( 5a22 ) +void _5a22_device::state_import(const device_state_entry &entry) { - g65816i_cpu_struct *cpustate = get_safe_token(device); + switch (entry.index()) + { + case _5A22_FASTROM: + g65816_set_reg(_5A22_FASTROM, m_debugger_temp); + break; + default: + g65816_device::state_import(entry); + break; + } +} - CPU_RESET_CALL(g65816); +void _5a22_device::state_export(const device_state_entry &entry) +{ + switch (entry.index()) + { + case _5A22_FASTROM: + m_debugger_temp = g65816_get_reg(_5A22_FASTROM); + break; + default: + g65816_device::state_export(entry); + break; + } +} - cpustate->fastROM = 0; - cpustate->wrmpya = 0xff; - cpustate->wrdiv = 0xffff; +void _5a22_device::device_reset() +{ + g65816_device::device_reset(); + + m_fastROM = 0; + m_wrmpya = 0xff; + m_wrdiv = 0xffff; } /* TODO: multiplication / division should actually occur inside CPU_EXECUTE */ @@ -586,95 +1058,65 @@ Triforce pieces in Zelda 3 intro) */ WRITE8_MEMBER( _5a22_device::wrmpya_w ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - - cpustate->wrmpya = data; + m_wrmpya = data; } WRITE8_MEMBER( _5a22_device::wrmpyb_w ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - - cpustate->wrmpyb = data; - cpustate->rdmpy = cpustate->wrmpya * cpustate->wrmpyb; - /* TODO: cpustate->rddiv == 0? */ + m_wrmpyb = data; + m_rdmpy = m_wrmpya * m_wrmpyb; + /* TODO: m_rddiv == 0? */ } WRITE8_MEMBER( _5a22_device::wrdivl_w ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - - cpustate->wrdiv = (data) | (cpustate->wrdiv & 0xff00); + m_wrdiv = (data) | (m_wrdiv & 0xff00); } WRITE8_MEMBER( _5a22_device::wrdivh_w ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - - cpustate->wrdiv = (data << 8) | (cpustate->wrdiv & 0xff); + m_wrdiv = (data << 8) | (m_wrdiv & 0xff); } WRITE8_MEMBER( _5a22_device::wrdvdd_w ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); UINT16 quotient, remainder; - cpustate->dvdd = data; + m_dvdd = data; - quotient = (cpustate->dvdd == 0) ? 0xffff : cpustate->wrdiv / cpustate->dvdd; - remainder = (cpustate->dvdd == 0) ? 0x000c : cpustate->wrdiv % cpustate->dvdd; + quotient = (m_dvdd == 0) ? 0xffff : m_wrdiv / m_dvdd; + remainder = (m_dvdd == 0) ? 0x000c : m_wrdiv % m_dvdd; - cpustate->rddiv = quotient; - cpustate->rdmpy = remainder; + m_rddiv = quotient; + m_rdmpy = remainder; } WRITE8_MEMBER( _5a22_device::memsel_w ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - cpustate->fastROM = data & 1; + m_fastROM = data & 1; } READ8_MEMBER( _5a22_device::rddivl_r ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - return cpustate->rddiv & 0xff; + return m_rddiv & 0xff; } READ8_MEMBER( _5a22_device::rddivh_r ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - return cpustate->rddiv >> 8; + return m_rddiv >> 8; } READ8_MEMBER( _5a22_device::rdmpyl_r ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - return cpustate->rdmpy & 0xff; + return m_rdmpy & 0xff; } READ8_MEMBER( _5a22_device::rdmpyh_r ) { - g65816i_cpu_struct *cpustate = get_safe_token(this); - return cpustate->rdmpy >> 8; + return m_rdmpy >> 8; } -static ADDRESS_MAP_START(_5a22_map, AS_PROGRAM, 8, _5a22_device) - AM_RANGE(0x4202, 0x4202) AM_MIRROR(0xbf0000) AM_WRITE(wrmpya_w) - AM_RANGE(0x4203, 0x4203) AM_MIRROR(0xbf0000) AM_WRITE(wrmpyb_w) - AM_RANGE(0x4204, 0x4204) AM_MIRROR(0xbf0000) AM_WRITE(wrdivl_w) - AM_RANGE(0x4205, 0x4205) AM_MIRROR(0xbf0000) AM_WRITE(wrdivh_w) - AM_RANGE(0x4206, 0x4206) AM_MIRROR(0xbf0000) AM_WRITE(wrdvdd_w) - - AM_RANGE(0x420d, 0x420d) AM_MIRROR(0xbf0000) AM_WRITE(memsel_w) - - AM_RANGE(0x4214, 0x4214) AM_MIRROR(0xbf0000) AM_READ(rddivl_r) - AM_RANGE(0x4215, 0x4215) AM_MIRROR(0xbf0000) AM_READ(rddivh_r) - AM_RANGE(0x4216, 0x4216) AM_MIRROR(0xbf0000) AM_READ(rdmpyl_r) - AM_RANGE(0x4217, 0x4217) AM_MIRROR(0xbf0000) AM_READ(rdmpyh_r) - -ADDRESS_MAP_END - void _5a22_device::set_5a22_map() { space(AS_PROGRAM).install_write_handler(0x4202, 0x4202, 0, 0xbf0000, write8_delegate(FUNC(_5a22_device::wrmpya_w),this)); @@ -691,43 +1133,6 @@ void _5a22_device::set_5a22_map() space(AS_PROGRAM).install_read_handler(0x4217, 0x4217, 0, 0xbf0000, read8_delegate(FUNC(_5a22_device::rdmpyh_r),this)); } -CPU_SET_INFO( _5a22 ) -{ - g65816i_cpu_struct *cpustate = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL; - - switch (state) - { - case CPUINFO_INT_REGISTER + _5A22_FASTROM: g65816_set_reg(cpustate, _5A22_FASTROM, info->i); break; - - default: CPU_SET_INFO_CALL(g65816); break; - } -} - -CPU_GET_INFO( _5a22 ) -{ - g65816i_cpu_struct *cpustate = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL; - - switch (state) - { - /* --- the following bits of info are returned as pointers to data or functions --- */ - case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(_5a22); break; - case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(5a22); break; - case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(5a22); break; - - /* --- the following bits of info are returned as NULL-terminated strings --- */ - case CPUINFO_STR_NAME: strcpy(info->s, "5A22"); break; - case CPUINFO_STR_SHORTNAME: strcpy(info->s, "5a22"); break; - case CPUINFO_INT_REGISTER + _5A22_FASTROM: info->i = g65816_get_reg(cpustate, _5A22_FASTROM); break; - case CPUINFO_STR_REGISTER + _5A22_FASTROM: sprintf(info->s, "fastROM:%d", cpustate->fastROM & 1 ? 1 : 0); break; - case CPUINFO_PTR_INTERNAL_MEMORY_MAP + AS_PROGRAM: info->internal_map8 = ADDRESS_MAP_NAME(_5a22_map); break; - - default: CPU_GET_INFO_CALL(g65816); break; - } -} - - -DEFINE_LEGACY_CPU_DEVICE(G65816, g65816); -DEFINE_LEGACY_CPU_DEVICE(_5A22, _5a22); /* ======================================================================== */ /* ============================== END OF FILE ============================= */ diff --git a/src/emu/cpu/g65816/g65816.h b/src/emu/cpu/g65816/g65816.h index 0a7207730a0..f018dfdf719 100644 --- a/src/emu/cpu/g65816/g65816.h +++ b/src/emu/cpu/g65816/g65816.h @@ -57,15 +57,1482 @@ enum _5A22_FASTROM }; -/* Main interface function */ -DECLARE_LEGACY_CPU_DEVICE(G65816, g65816); -CPU_GET_INFO( _5a22 ); +class g65816_device : public cpu_device +{ +public: + // construction/destruction + g65816_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + g65816_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source, int cpu_type, address_map_constructor internal = NULL); + + void set_read_vector_callback(read8_delegate read_vector); + +protected: + // device-level overrides + virtual void device_start(); + virtual void device_reset(); + + // device_execute_interface overrides + virtual UINT32 execute_min_cycles() const { return 1; } + virtual UINT32 execute_max_cycles() const { return 20; } + virtual UINT32 execute_input_lines() const { return 5; } + virtual void execute_run(); + virtual void execute_set_input(int inputnum, int state); + + // device_memory_interface overrides + virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : NULL; } + + // device_state_interface overrides + virtual void state_import(const device_state_entry &entry); + virtual void state_export(const device_state_entry &entry); + virtual void state_string_export(const device_state_entry &entry, astring &string); + + // device_disasm_interface overrides + virtual UINT32 disasm_min_opcode_bytes() const { return 1; } + virtual UINT32 disasm_max_opcode_bytes() const { return 4; } + virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options); + + address_space_config m_program_config; + + typedef void (g65816_device::*opcode_func) (); + typedef uint (g65816_device::*get_reg_func)(int regnum); + typedef void (g65816_device::*set_reg_func)(int regnum, uint val); + typedef void (g65816_device::*set_line_func)(int line, int state); + typedef int (g65816_device::*execute_func)(int cycles); + + static const opcode_func g65816i_opcodes_M0X0[]; + uint g65816i_get_reg_M0X0(int regnum); + void g65816i_set_reg_M0X0(int regnum, uint val); + void g65816i_set_line_M0X0(int line, int state); + int g65816i_execute_M0X0(int cycles); + + static const opcode_func g65816i_opcodes_M0X1[]; + uint g65816i_get_reg_M0X1(int regnum); + void g65816i_set_reg_M0X1(int regnum, uint val); + void g65816i_set_line_M0X1(int line, int state); + int g65816i_execute_M0X1(int cycles); + + static const opcode_func g65816i_opcodes_M1X0[]; + uint g65816i_get_reg_M1X0(int regnum); + void g65816i_set_reg_M1X0(int regnum, uint val); + void g65816i_set_line_M1X0(int line, int state); + int g65816i_execute_M1X0(int cycles); -class _5a22_device : public legacy_cpu_device + static const opcode_func g65816i_opcodes_M1X1[]; + uint g65816i_get_reg_M1X1(int regnum); + void g65816i_set_reg_M1X1(int regnum, uint val); + void g65816i_set_line_M1X1(int line, int state); + int g65816i_execute_M1X1(int cycles); + + static const opcode_func g65816i_opcodes_E[]; + uint g65816i_get_reg_E(int regnum); + void g65816i_set_reg_E(int regnum, uint val); + void g65816i_set_line_E(int line, int state); + int g65816i_execute_E(int cycles); + + void g65816i_set_execution_mode(uint mode); + int bus_5A22_cycle_burst(uint addr); + unsigned g65816_get_pc(); + void g65816_set_pc(unsigned val); + unsigned g65816_get_sp(); + void g65816_set_sp(unsigned val); + unsigned g65816_get_reg(int regnum); + void g65816_set_reg(int regnum, unsigned value); + void g65816_restore_state(); + uint g65816i_read_8_normal(uint address); + uint g65816i_read_8_immediate(uint address); + uint g65816i_read_8_direct(uint address); + uint g65816i_read_8_vector(uint address); + void g65816i_write_8_normal(uint address, uint value); + void g65816i_write_8_direct(uint address, uint value); + uint g65816i_read_16_normal(uint address); + uint g65816i_read_16_immediate(uint address); + uint g65816i_read_16_direct(uint address); + uint g65816i_read_16_vector(uint address); + void g65816i_write_16_normal(uint address, uint value); + void g65816i_write_16_direct(uint address, uint value); + uint g65816i_read_24_normal(uint address); + uint g65816i_read_24_immediate(uint address); + uint g65816i_read_24_direct(uint address); + void g65816i_push_8(uint value); + uint g65816i_pull_8(); + void g65816i_push_16(uint value); + uint g65816i_pull_16(); + void g65816i_push_24(uint value); + uint g65816i_pull_24(); + void g65816i_jump_16(uint address); + void g65816i_jump_24(uint address); + void g65816i_branch_8(uint offset); + void g65816i_branch_16(uint offset); + void g65816i_set_flag_mx(uint value); + void g65816i_set_flag_e(uint value); + void g65816i_set_flag_i(uint value); + uint g65816i_get_reg_p(); + void g65816i_set_reg_p(uint value); + void g65816i_interrupt_hardware(uint vector); + void g65816i_interrupt_software(uint vector); + void g65816i_interrupt_nmi(); + void g65816i_check_maskable_interrupt(); + uint EA_IMM8(); + uint EA_IMM16(); + uint EA_IMM24(); + uint EA_D(); + uint EA_A(); + uint EA_AL(); + uint EA_DX(); + uint EA_DY(); + uint EA_AX(); + uint EA_ALX(); + uint EA_AY(); + uint EA_DI(); + uint EA_DLI(); + uint EA_AI(); + uint EA_ALI(); + uint EA_DXI(); + uint EA_DIY(); + uint EA_DLIY(); + uint EA_AXI(); + uint EA_S(); + uint EA_SIY(); + + static const get_reg_func s_g65816_get_reg[5]; + static const set_reg_func s_g65816_set_reg[5]; + static const set_line_func s_g65816_set_line[5]; + static const execute_func s_g65816_execute[5]; + + uint m_a; /* Accumulator */ + uint m_b; /* holds high byte of accumulator */ + uint m_x; /* Index Register X */ + uint m_y; /* Index Register Y */ + uint m_s; /* Stack Pointer */ + uint m_pc; /* Program Counter */ + uint m_ppc; /* Previous Program Counter */ + uint m_pb; /* Program Bank (shifted left 16) */ + uint m_db; /* Data Bank (shifted left 16) */ + uint m_d; /* Direct Register */ + uint m_flag_e; /* Emulation Mode Flag */ + uint m_flag_m; /* Memory/Accumulator Select Flag */ + uint m_flag_x; /* Index Select Flag */ + uint m_flag_n; /* Negative Flag */ + uint m_flag_v; /* Overflow Flag */ + uint m_flag_d; /* Decimal Mode Flag */ + uint m_flag_i; /* Interrupt Mask Flag */ + uint m_flag_z; /* Zero Flag (inverted) */ + uint m_flag_c; /* Carry Flag */ + uint m_line_irq; /* Status of the IRQ line */ + uint m_line_nmi; /* Status of the NMI line */ + uint m_fastROM; /* SNES specific */ + uint m_ir; /* Instruction Register */ + uint m_irq_delay; /* delay 1 instruction before checking irq */ + address_space *m_program; + read8_delegate m_read_vector; /* Read vector override */ + uint m_stopped; /* Sets how the CPU is stopped */ + const opcode_func* m_opcodes; + get_reg_func m_get_reg; + set_reg_func m_set_reg; + set_line_func m_set_line; + execute_func m_execute; + uint m_source; + uint m_destination; + int m_ICount; + int m_cpu_type; + UINT8 m_rw8_cycles, m_rw16_cycles, m_rw24_cycles; + UINT32 m_debugger_temp; + + /* 5A22 specific registers */ + UINT8 m_wrmpya, m_wrmpyb; + UINT16 m_rdmpy; + UINT16 m_wrdiv; + UINT8 m_dvdd; + UINT16 m_rddiv; + + void g65816i_00_M0X0(); + void g65816i_01_M0X0(); + void g65816i_02_M0X0(); + void g65816i_03_M0X0(); + void g65816i_04_M0X0(); + void g65816i_05_M0X0(); + void g65816i_06_M0X0(); + void g65816i_07_M0X0(); + void g65816i_08_M0X0(); + void g65816i_09_M0X0(); + void g65816i_0a_M0X0(); + void g65816i_0b_M0X0(); + void g65816i_0c_M0X0(); + void g65816i_0d_M0X0(); + void g65816i_0e_M0X0(); + void g65816i_0f_M0X0(); + void g65816i_10_M0X0(); + void g65816i_11_M0X0(); + void g65816i_12_M0X0(); + void g65816i_13_M0X0(); + void g65816i_14_M0X0(); + void g65816i_15_M0X0(); + void g65816i_16_M0X0(); + void g65816i_17_M0X0(); + void g65816i_18_M0X0(); + void g65816i_19_M0X0(); + void g65816i_1a_M0X0(); + void g65816i_1b_M0X0(); + void g65816i_1c_M0X0(); + void g65816i_1d_M0X0(); + void g65816i_1e_M0X0(); + void g65816i_1f_M0X0(); + void g65816i_20_M0X0(); + void g65816i_21_M0X0(); + void g65816i_22_M0X0(); + void g65816i_23_M0X0(); + void g65816i_24_M0X0(); + void g65816i_25_M0X0(); + void g65816i_26_M0X0(); + void g65816i_27_M0X0(); + void g65816i_28_M0X0(); + void g65816i_29_M0X0(); + void g65816i_2a_M0X0(); + void g65816i_2b_M0X0(); + void g65816i_2c_M0X0(); + void g65816i_2d_M0X0(); + void g65816i_2e_M0X0(); + void g65816i_2f_M0X0(); + void g65816i_30_M0X0(); + void g65816i_31_M0X0(); + void g65816i_32_M0X0(); + void g65816i_33_M0X0(); + void g65816i_34_M0X0(); + void g65816i_35_M0X0(); + void g65816i_36_M0X0(); + void g65816i_37_M0X0(); + void g65816i_38_M0X0(); + void g65816i_39_M0X0(); + void g65816i_3a_M0X0(); + void g65816i_3b_M0X0(); + void g65816i_3c_M0X0(); + void g65816i_3d_M0X0(); + void g65816i_3e_M0X0(); + void g65816i_3f_M0X0(); + void g65816i_40_M0X0(); + void g65816i_41_M0X0(); + void g65816i_42_M0X0(); + void g65816i_43_M0X0(); + void g65816i_44_M0X0(); + void g65816i_45_M0X0(); + void g65816i_46_M0X0(); + void g65816i_47_M0X0(); + void g65816i_48_M0X0(); + void g65816i_49_M0X0(); + void g65816i_4a_M0X0(); + void g65816i_4b_M0X0(); + void g65816i_4c_M0X0(); + void g65816i_4d_M0X0(); + void g65816i_4e_M0X0(); + void g65816i_4f_M0X0(); + void g65816i_50_M0X0(); + void g65816i_51_M0X0(); + void g65816i_52_M0X0(); + void g65816i_53_M0X0(); + void g65816i_54_M0X0(); + void g65816i_55_M0X0(); + void g65816i_56_M0X0(); + void g65816i_57_M0X0(); + void g65816i_58_M0X0(); + void g65816i_59_M0X0(); + void g65816i_5a_M0X0(); + void g65816i_5b_M0X0(); + void g65816i_5c_M0X0(); + void g65816i_5d_M0X0(); + void g65816i_5e_M0X0(); + void g65816i_5f_M0X0(); + void g65816i_60_M0X0(); + void g65816i_61_M0X0(); + void g65816i_62_M0X0(); + void g65816i_63_M0X0(); + void g65816i_64_M0X0(); + void g65816i_65_M0X0(); + void g65816i_66_M0X0(); + void g65816i_67_M0X0(); + void g65816i_68_M0X0(); + void g65816i_69_M0X0(); + void g65816i_6a_M0X0(); + void g65816i_6b_M0X0(); + void g65816i_6c_M0X0(); + void g65816i_6d_M0X0(); + void g65816i_6e_M0X0(); + void g65816i_6f_M0X0(); + void g65816i_70_M0X0(); + void g65816i_71_M0X0(); + void g65816i_72_M0X0(); + void g65816i_73_M0X0(); + void g65816i_74_M0X0(); + void g65816i_75_M0X0(); + void g65816i_76_M0X0(); + void g65816i_77_M0X0(); + void g65816i_78_M0X0(); + void g65816i_79_M0X0(); + void g65816i_7a_M0X0(); + void g65816i_7b_M0X0(); + void g65816i_7c_M0X0(); + void g65816i_7d_M0X0(); + void g65816i_7e_M0X0(); + void g65816i_7f_M0X0(); + void g65816i_80_M0X0(); + void g65816i_81_M0X0(); + void g65816i_82_M0X0(); + void g65816i_83_M0X0(); + void g65816i_84_M0X0(); + void g65816i_85_M0X0(); + void g65816i_86_M0X0(); + void g65816i_87_M0X0(); + void g65816i_88_M0X0(); + void g65816i_89_M0X0(); + void g65816i_8a_M0X0(); + void g65816i_8b_M0X0(); + void g65816i_8c_M0X0(); + void g65816i_8d_M0X0(); + void g65816i_8e_M0X0(); + void g65816i_8f_M0X0(); + void g65816i_90_M0X0(); + void g65816i_91_M0X0(); + void g65816i_92_M0X0(); + void g65816i_93_M0X0(); + void g65816i_94_M0X0(); + void g65816i_95_M0X0(); + void g65816i_96_M0X0(); + void g65816i_97_M0X0(); + void g65816i_98_M0X0(); + void g65816i_99_M0X0(); + void g65816i_9a_M0X0(); + void g65816i_9b_M0X0(); + void g65816i_9c_M0X0(); + void g65816i_9d_M0X0(); + void g65816i_9e_M0X0(); + void g65816i_9f_M0X0(); + void g65816i_a0_M0X0(); + void g65816i_a1_M0X0(); + void g65816i_a2_M0X0(); + void g65816i_a3_M0X0(); + void g65816i_a4_M0X0(); + void g65816i_a5_M0X0(); + void g65816i_a6_M0X0(); + void g65816i_a7_M0X0(); + void g65816i_a8_M0X0(); + void g65816i_a9_M0X0(); + void g65816i_aa_M0X0(); + void g65816i_ab_M0X0(); + void g65816i_ac_M0X0(); + void g65816i_ad_M0X0(); + void g65816i_ae_M0X0(); + void g65816i_af_M0X0(); + void g65816i_b0_M0X0(); + void g65816i_b1_M0X0(); + void g65816i_b2_M0X0(); + void g65816i_b3_M0X0(); + void g65816i_b4_M0X0(); + void g65816i_b5_M0X0(); + void g65816i_b6_M0X0(); + void g65816i_b7_M0X0(); + void g65816i_b8_M0X0(); + void g65816i_b9_M0X0(); + void g65816i_ba_M0X0(); + void g65816i_bb_M0X0(); + void g65816i_bc_M0X0(); + void g65816i_bd_M0X0(); + void g65816i_be_M0X0(); + void g65816i_bf_M0X0(); + void g65816i_c0_M0X0(); + void g65816i_c1_M0X0(); + void g65816i_c2_M0X0(); + void g65816i_c3_M0X0(); + void g65816i_c4_M0X0(); + void g65816i_c5_M0X0(); + void g65816i_c6_M0X0(); + void g65816i_c7_M0X0(); + void g65816i_c8_M0X0(); + void g65816i_c9_M0X0(); + void g65816i_ca_M0X0(); + void g65816i_cb_M0X0(); + void g65816i_cc_M0X0(); + void g65816i_cd_M0X0(); + void g65816i_ce_M0X0(); + void g65816i_cf_M0X0(); + void g65816i_d0_M0X0(); + void g65816i_d1_M0X0(); + void g65816i_d2_M0X0(); + void g65816i_d3_M0X0(); + void g65816i_d4_M0X0(); + void g65816i_d5_M0X0(); + void g65816i_d6_M0X0(); + void g65816i_d7_M0X0(); + void g65816i_d8_M0X0(); + void g65816i_d9_M0X0(); + void g65816i_da_M0X0(); + void g65816i_db_M0X0(); + void g65816i_dc_M0X0(); + void g65816i_dd_M0X0(); + void g65816i_de_M0X0(); + void g65816i_df_M0X0(); + void g65816i_e0_M0X0(); + void g65816i_e1_M0X0(); + void g65816i_e2_M0X0(); + void g65816i_e3_M0X0(); + void g65816i_e4_M0X0(); + void g65816i_e5_M0X0(); + void g65816i_e6_M0X0(); + void g65816i_e7_M0X0(); + void g65816i_e8_M0X0(); + void g65816i_e9_M0X0(); + void g65816i_ea_M0X0(); + void g65816i_eb_M0X0(); + void g65816i_ec_M0X0(); + void g65816i_ed_M0X0(); + void g65816i_ee_M0X0(); + void g65816i_ef_M0X0(); + void g65816i_f0_M0X0(); + void g65816i_f1_M0X0(); + void g65816i_f2_M0X0(); + void g65816i_f3_M0X0(); + void g65816i_f4_M0X0(); + void g65816i_f5_M0X0(); + void g65816i_f6_M0X0(); + void g65816i_f7_M0X0(); + void g65816i_f8_M0X0(); + void g65816i_f9_M0X0(); + void g65816i_fa_M0X0(); + void g65816i_fb_M0X0(); + void g65816i_fc_M0X0(); + void g65816i_fd_M0X0(); + void g65816i_fe_M0X0(); + void g65816i_ff_M0X0(); + void g65816i_00_M0X1(); + void g65816i_01_M0X1(); + void g65816i_02_M0X1(); + void g65816i_03_M0X1(); + void g65816i_04_M0X1(); + void g65816i_05_M0X1(); + void g65816i_06_M0X1(); + void g65816i_07_M0X1(); + void g65816i_08_M0X1(); + void g65816i_09_M0X1(); + void g65816i_0a_M0X1(); + void g65816i_0b_M0X1(); + void g65816i_0c_M0X1(); + void g65816i_0d_M0X1(); + void g65816i_0e_M0X1(); + void g65816i_0f_M0X1(); + void g65816i_10_M0X1(); + void g65816i_11_M0X1(); + void g65816i_12_M0X1(); + void g65816i_13_M0X1(); + void g65816i_14_M0X1(); + void g65816i_15_M0X1(); + void g65816i_16_M0X1(); + void g65816i_17_M0X1(); + void g65816i_18_M0X1(); + void g65816i_19_M0X1(); + void g65816i_1a_M0X1(); + void g65816i_1b_M0X1(); + void g65816i_1c_M0X1(); + void g65816i_1d_M0X1(); + void g65816i_1e_M0X1(); + void g65816i_1f_M0X1(); + void g65816i_20_M0X1(); + void g65816i_21_M0X1(); + void g65816i_22_M0X1(); + void g65816i_23_M0X1(); + void g65816i_24_M0X1(); + void g65816i_25_M0X1(); + void g65816i_26_M0X1(); + void g65816i_27_M0X1(); + void g65816i_28_M0X1(); + void g65816i_29_M0X1(); + void g65816i_2a_M0X1(); + void g65816i_2b_M0X1(); + void g65816i_2c_M0X1(); + void g65816i_2d_M0X1(); + void g65816i_2e_M0X1(); + void g65816i_2f_M0X1(); + void g65816i_30_M0X1(); + void g65816i_31_M0X1(); + void g65816i_32_M0X1(); + void g65816i_33_M0X1(); + void g65816i_34_M0X1(); + void g65816i_35_M0X1(); + void g65816i_36_M0X1(); + void g65816i_37_M0X1(); + void g65816i_38_M0X1(); + void g65816i_39_M0X1(); + void g65816i_3a_M0X1(); + void g65816i_3b_M0X1(); + void g65816i_3c_M0X1(); + void g65816i_3d_M0X1(); + void g65816i_3e_M0X1(); + void g65816i_3f_M0X1(); + void g65816i_40_M0X1(); + void g65816i_41_M0X1(); + void g65816i_42_M0X1(); + void g65816i_43_M0X1(); + void g65816i_44_M0X1(); + void g65816i_45_M0X1(); + void g65816i_46_M0X1(); + void g65816i_47_M0X1(); + void g65816i_48_M0X1(); + void g65816i_49_M0X1(); + void g65816i_4a_M0X1(); + void g65816i_4b_M0X1(); + void g65816i_4c_M0X1(); + void g65816i_4d_M0X1(); + void g65816i_4e_M0X1(); + void g65816i_4f_M0X1(); + void g65816i_50_M0X1(); + void g65816i_51_M0X1(); + void g65816i_52_M0X1(); + void g65816i_53_M0X1(); + void g65816i_54_M0X1(); + void g65816i_55_M0X1(); + void g65816i_56_M0X1(); + void g65816i_57_M0X1(); + void g65816i_58_M0X1(); + void g65816i_59_M0X1(); + void g65816i_5a_M0X1(); + void g65816i_5b_M0X1(); + void g65816i_5c_M0X1(); + void g65816i_5d_M0X1(); + void g65816i_5e_M0X1(); + void g65816i_5f_M0X1(); + void g65816i_60_M0X1(); + void g65816i_61_M0X1(); + void g65816i_62_M0X1(); + void g65816i_63_M0X1(); + void g65816i_64_M0X1(); + void g65816i_65_M0X1(); + void g65816i_66_M0X1(); + void g65816i_67_M0X1(); + void g65816i_68_M0X1(); + void g65816i_69_M0X1(); + void g65816i_6a_M0X1(); + void g65816i_6b_M0X1(); + void g65816i_6c_M0X1(); + void g65816i_6d_M0X1(); + void g65816i_6e_M0X1(); + void g65816i_6f_M0X1(); + void g65816i_70_M0X1(); + void g65816i_71_M0X1(); + void g65816i_72_M0X1(); + void g65816i_73_M0X1(); + void g65816i_74_M0X1(); + void g65816i_75_M0X1(); + void g65816i_76_M0X1(); + void g65816i_77_M0X1(); + void g65816i_78_M0X1(); + void g65816i_79_M0X1(); + void g65816i_7a_M0X1(); + void g65816i_7b_M0X1(); + void g65816i_7c_M0X1(); + void g65816i_7d_M0X1(); + void g65816i_7e_M0X1(); + void g65816i_7f_M0X1(); + void g65816i_80_M0X1(); + void g65816i_81_M0X1(); + void g65816i_82_M0X1(); + void g65816i_83_M0X1(); + void g65816i_84_M0X1(); + void g65816i_85_M0X1(); + void g65816i_86_M0X1(); + void g65816i_87_M0X1(); + void g65816i_88_M0X1(); + void g65816i_89_M0X1(); + void g65816i_8a_M0X1(); + void g65816i_8b_M0X1(); + void g65816i_8c_M0X1(); + void g65816i_8d_M0X1(); + void g65816i_8e_M0X1(); + void g65816i_8f_M0X1(); + void g65816i_90_M0X1(); + void g65816i_91_M0X1(); + void g65816i_92_M0X1(); + void g65816i_93_M0X1(); + void g65816i_94_M0X1(); + void g65816i_95_M0X1(); + void g65816i_96_M0X1(); + void g65816i_97_M0X1(); + void g65816i_98_M0X1(); + void g65816i_99_M0X1(); + void g65816i_9a_M0X1(); + void g65816i_9b_M0X1(); + void g65816i_9c_M0X1(); + void g65816i_9d_M0X1(); + void g65816i_9e_M0X1(); + void g65816i_9f_M0X1(); + void g65816i_a0_M0X1(); + void g65816i_a1_M0X1(); + void g65816i_a2_M0X1(); + void g65816i_a3_M0X1(); + void g65816i_a4_M0X1(); + void g65816i_a5_M0X1(); + void g65816i_a6_M0X1(); + void g65816i_a7_M0X1(); + void g65816i_a8_M0X1(); + void g65816i_a9_M0X1(); + void g65816i_aa_M0X1(); + void g65816i_ab_M0X1(); + void g65816i_ac_M0X1(); + void g65816i_ad_M0X1(); + void g65816i_ae_M0X1(); + void g65816i_af_M0X1(); + void g65816i_b0_M0X1(); + void g65816i_b1_M0X1(); + void g65816i_b2_M0X1(); + void g65816i_b3_M0X1(); + void g65816i_b4_M0X1(); + void g65816i_b5_M0X1(); + void g65816i_b6_M0X1(); + void g65816i_b7_M0X1(); + void g65816i_b8_M0X1(); + void g65816i_b9_M0X1(); + void g65816i_ba_M0X1(); + void g65816i_bb_M0X1(); + void g65816i_bc_M0X1(); + void g65816i_bd_M0X1(); + void g65816i_be_M0X1(); + void g65816i_bf_M0X1(); + void g65816i_c0_M0X1(); + void g65816i_c1_M0X1(); + void g65816i_c2_M0X1(); + void g65816i_c3_M0X1(); + void g65816i_c4_M0X1(); + void g65816i_c5_M0X1(); + void g65816i_c6_M0X1(); + void g65816i_c7_M0X1(); + void g65816i_c8_M0X1(); + void g65816i_c9_M0X1(); + void g65816i_ca_M0X1(); + void g65816i_cb_M0X1(); + void g65816i_cc_M0X1(); + void g65816i_cd_M0X1(); + void g65816i_ce_M0X1(); + void g65816i_cf_M0X1(); + void g65816i_d0_M0X1(); + void g65816i_d1_M0X1(); + void g65816i_d2_M0X1(); + void g65816i_d3_M0X1(); + void g65816i_d4_M0X1(); + void g65816i_d5_M0X1(); + void g65816i_d6_M0X1(); + void g65816i_d7_M0X1(); + void g65816i_d8_M0X1(); + void g65816i_d9_M0X1(); + void g65816i_da_M0X1(); + void g65816i_db_M0X1(); + void g65816i_dc_M0X1(); + void g65816i_dd_M0X1(); + void g65816i_de_M0X1(); + void g65816i_df_M0X1(); + void g65816i_e0_M0X1(); + void g65816i_e1_M0X1(); + void g65816i_e2_M0X1(); + void g65816i_e3_M0X1(); + void g65816i_e4_M0X1(); + void g65816i_e5_M0X1(); + void g65816i_e6_M0X1(); + void g65816i_e7_M0X1(); + void g65816i_e8_M0X1(); + void g65816i_e9_M0X1(); + void g65816i_ea_M0X1(); + void g65816i_eb_M0X1(); + void g65816i_ec_M0X1(); + void g65816i_ed_M0X1(); + void g65816i_ee_M0X1(); + void g65816i_ef_M0X1(); + void g65816i_f0_M0X1(); + void g65816i_f1_M0X1(); + void g65816i_f2_M0X1(); + void g65816i_f3_M0X1(); + void g65816i_f4_M0X1(); + void g65816i_f5_M0X1(); + void g65816i_f6_M0X1(); + void g65816i_f7_M0X1(); + void g65816i_f8_M0X1(); + void g65816i_f9_M0X1(); + void g65816i_fa_M0X1(); + void g65816i_fb_M0X1(); + void g65816i_fc_M0X1(); + void g65816i_fd_M0X1(); + void g65816i_fe_M0X1(); + void g65816i_ff_M0X1(); + void g65816i_00_M1X0(); + void g65816i_01_M1X0(); + void g65816i_02_M1X0(); + void g65816i_03_M1X0(); + void g65816i_04_M1X0(); + void g65816i_05_M1X0(); + void g65816i_06_M1X0(); + void g65816i_07_M1X0(); + void g65816i_08_M1X0(); + void g65816i_09_M1X0(); + void g65816i_0a_M1X0(); + void g65816i_0b_M1X0(); + void g65816i_0c_M1X0(); + void g65816i_0d_M1X0(); + void g65816i_0e_M1X0(); + void g65816i_0f_M1X0(); + void g65816i_10_M1X0(); + void g65816i_11_M1X0(); + void g65816i_12_M1X0(); + void g65816i_13_M1X0(); + void g65816i_14_M1X0(); + void g65816i_15_M1X0(); + void g65816i_16_M1X0(); + void g65816i_17_M1X0(); + void g65816i_18_M1X0(); + void g65816i_19_M1X0(); + void g65816i_1a_M1X0(); + void g65816i_1b_M1X0(); + void g65816i_1c_M1X0(); + void g65816i_1d_M1X0(); + void g65816i_1e_M1X0(); + void g65816i_1f_M1X0(); + void g65816i_20_M1X0(); + void g65816i_21_M1X0(); + void g65816i_22_M1X0(); + void g65816i_23_M1X0(); + void g65816i_24_M1X0(); + void g65816i_25_M1X0(); + void g65816i_26_M1X0(); + void g65816i_27_M1X0(); + void g65816i_28_M1X0(); + void g65816i_29_M1X0(); + void g65816i_2a_M1X0(); + void g65816i_2b_M1X0(); + void g65816i_2c_M1X0(); + void g65816i_2d_M1X0(); + void g65816i_2e_M1X0(); + void g65816i_2f_M1X0(); + void g65816i_30_M1X0(); + void g65816i_31_M1X0(); + void g65816i_32_M1X0(); + void g65816i_33_M1X0(); + void g65816i_34_M1X0(); + void g65816i_35_M1X0(); + void g65816i_36_M1X0(); + void g65816i_37_M1X0(); + void g65816i_38_M1X0(); + void g65816i_39_M1X0(); + void g65816i_3a_M1X0(); + void g65816i_3b_M1X0(); + void g65816i_3c_M1X0(); + void g65816i_3d_M1X0(); + void g65816i_3e_M1X0(); + void g65816i_3f_M1X0(); + void g65816i_40_M1X0(); + void g65816i_41_M1X0(); + void g65816i_42_M1X0(); + void g65816i_43_M1X0(); + void g65816i_44_M1X0(); + void g65816i_45_M1X0(); + void g65816i_46_M1X0(); + void g65816i_47_M1X0(); + void g65816i_48_M1X0(); + void g65816i_49_M1X0(); + void g65816i_4a_M1X0(); + void g65816i_4b_M1X0(); + void g65816i_4c_M1X0(); + void g65816i_4d_M1X0(); + void g65816i_4e_M1X0(); + void g65816i_4f_M1X0(); + void g65816i_50_M1X0(); + void g65816i_51_M1X0(); + void g65816i_52_M1X0(); + void g65816i_53_M1X0(); + void g65816i_54_M1X0(); + void g65816i_55_M1X0(); + void g65816i_56_M1X0(); + void g65816i_57_M1X0(); + void g65816i_58_M1X0(); + void g65816i_59_M1X0(); + void g65816i_5a_M1X0(); + void g65816i_5b_M1X0(); + void g65816i_5c_M1X0(); + void g65816i_5d_M1X0(); + void g65816i_5e_M1X0(); + void g65816i_5f_M1X0(); + void g65816i_60_M1X0(); + void g65816i_61_M1X0(); + void g65816i_62_M1X0(); + void g65816i_63_M1X0(); + void g65816i_64_M1X0(); + void g65816i_65_M1X0(); + void g65816i_66_M1X0(); + void g65816i_67_M1X0(); + void g65816i_68_M1X0(); + void g65816i_69_M1X0(); + void g65816i_6a_M1X0(); + void g65816i_6b_M1X0(); + void g65816i_6c_M1X0(); + void g65816i_6d_M1X0(); + void g65816i_6e_M1X0(); + void g65816i_6f_M1X0(); + void g65816i_70_M1X0(); + void g65816i_71_M1X0(); + void g65816i_72_M1X0(); + void g65816i_73_M1X0(); + void g65816i_74_M1X0(); + void g65816i_75_M1X0(); + void g65816i_76_M1X0(); + void g65816i_77_M1X0(); + void g65816i_78_M1X0(); + void g65816i_79_M1X0(); + void g65816i_7a_M1X0(); + void g65816i_7b_M1X0(); + void g65816i_7c_M1X0(); + void g65816i_7d_M1X0(); + void g65816i_7e_M1X0(); + void g65816i_7f_M1X0(); + void g65816i_80_M1X0(); + void g65816i_81_M1X0(); + void g65816i_82_M1X0(); + void g65816i_83_M1X0(); + void g65816i_84_M1X0(); + void g65816i_85_M1X0(); + void g65816i_86_M1X0(); + void g65816i_87_M1X0(); + void g65816i_88_M1X0(); + void g65816i_89_M1X0(); + void g65816i_8a_M1X0(); + void g65816i_8b_M1X0(); + void g65816i_8c_M1X0(); + void g65816i_8d_M1X0(); + void g65816i_8e_M1X0(); + void g65816i_8f_M1X0(); + void g65816i_90_M1X0(); + void g65816i_91_M1X0(); + void g65816i_92_M1X0(); + void g65816i_93_M1X0(); + void g65816i_94_M1X0(); + void g65816i_95_M1X0(); + void g65816i_96_M1X0(); + void g65816i_97_M1X0(); + void g65816i_98_M1X0(); + void g65816i_99_M1X0(); + void g65816i_9a_M1X0(); + void g65816i_9b_M1X0(); + void g65816i_9c_M1X0(); + void g65816i_9d_M1X0(); + void g65816i_9e_M1X0(); + void g65816i_9f_M1X0(); + void g65816i_a0_M1X0(); + void g65816i_a1_M1X0(); + void g65816i_a2_M1X0(); + void g65816i_a3_M1X0(); + void g65816i_a4_M1X0(); + void g65816i_a5_M1X0(); + void g65816i_a6_M1X0(); + void g65816i_a7_M1X0(); + void g65816i_a8_M1X0(); + void g65816i_a9_M1X0(); + void g65816i_aa_M1X0(); + void g65816i_ab_M1X0(); + void g65816i_ac_M1X0(); + void g65816i_ad_M1X0(); + void g65816i_ae_M1X0(); + void g65816i_af_M1X0(); + void g65816i_b0_M1X0(); + void g65816i_b1_M1X0(); + void g65816i_b2_M1X0(); + void g65816i_b3_M1X0(); + void g65816i_b4_M1X0(); + void g65816i_b5_M1X0(); + void g65816i_b6_M1X0(); + void g65816i_b7_M1X0(); + void g65816i_b8_M1X0(); + void g65816i_b9_M1X0(); + void g65816i_ba_M1X0(); + void g65816i_bb_M1X0(); + void g65816i_bc_M1X0(); + void g65816i_bd_M1X0(); + void g65816i_be_M1X0(); + void g65816i_bf_M1X0(); + void g65816i_c0_M1X0(); + void g65816i_c1_M1X0(); + void g65816i_c2_M1X0(); + void g65816i_c3_M1X0(); + void g65816i_c4_M1X0(); + void g65816i_c5_M1X0(); + void g65816i_c6_M1X0(); + void g65816i_c7_M1X0(); + void g65816i_c8_M1X0(); + void g65816i_c9_M1X0(); + void g65816i_ca_M1X0(); + void g65816i_cb_M1X0(); + void g65816i_cc_M1X0(); + void g65816i_cd_M1X0(); + void g65816i_ce_M1X0(); + void g65816i_cf_M1X0(); + void g65816i_d0_M1X0(); + void g65816i_d1_M1X0(); + void g65816i_d2_M1X0(); + void g65816i_d3_M1X0(); + void g65816i_d4_M1X0(); + void g65816i_d5_M1X0(); + void g65816i_d6_M1X0(); + void g65816i_d7_M1X0(); + void g65816i_d8_M1X0(); + void g65816i_d9_M1X0(); + void g65816i_da_M1X0(); + void g65816i_db_M1X0(); + void g65816i_dc_M1X0(); + void g65816i_dd_M1X0(); + void g65816i_de_M1X0(); + void g65816i_df_M1X0(); + void g65816i_e0_M1X0(); + void g65816i_e1_M1X0(); + void g65816i_e2_M1X0(); + void g65816i_e3_M1X0(); + void g65816i_e4_M1X0(); + void g65816i_e5_M1X0(); + void g65816i_e6_M1X0(); + void g65816i_e7_M1X0(); + void g65816i_e8_M1X0(); + void g65816i_e9_M1X0(); + void g65816i_ea_M1X0(); + void g65816i_eb_M1X0(); + void g65816i_ec_M1X0(); + void g65816i_ed_M1X0(); + void g65816i_ee_M1X0(); + void g65816i_ef_M1X0(); + void g65816i_f0_M1X0(); + void g65816i_f1_M1X0(); + void g65816i_f2_M1X0(); + void g65816i_f3_M1X0(); + void g65816i_f4_M1X0(); + void g65816i_f5_M1X0(); + void g65816i_f6_M1X0(); + void g65816i_f7_M1X0(); + void g65816i_f8_M1X0(); + void g65816i_f9_M1X0(); + void g65816i_fa_M1X0(); + void g65816i_fb_M1X0(); + void g65816i_fc_M1X0(); + void g65816i_fd_M1X0(); + void g65816i_fe_M1X0(); + void g65816i_ff_M1X0(); + void g65816i_00_M1X1(); + void g65816i_01_M1X1(); + void g65816i_02_M1X1(); + void g65816i_03_M1X1(); + void g65816i_04_M1X1(); + void g65816i_05_M1X1(); + void g65816i_06_M1X1(); + void g65816i_07_M1X1(); + void g65816i_08_M1X1(); + void g65816i_09_M1X1(); + void g65816i_0a_M1X1(); + void g65816i_0b_M1X1(); + void g65816i_0c_M1X1(); + void g65816i_0d_M1X1(); + void g65816i_0e_M1X1(); + void g65816i_0f_M1X1(); + void g65816i_10_M1X1(); + void g65816i_11_M1X1(); + void g65816i_12_M1X1(); + void g65816i_13_M1X1(); + void g65816i_14_M1X1(); + void g65816i_15_M1X1(); + void g65816i_16_M1X1(); + void g65816i_17_M1X1(); + void g65816i_18_M1X1(); + void g65816i_19_M1X1(); + void g65816i_1a_M1X1(); + void g65816i_1b_M1X1(); + void g65816i_1c_M1X1(); + void g65816i_1d_M1X1(); + void g65816i_1e_M1X1(); + void g65816i_1f_M1X1(); + void g65816i_20_M1X1(); + void g65816i_21_M1X1(); + void g65816i_22_M1X1(); + void g65816i_23_M1X1(); + void g65816i_24_M1X1(); + void g65816i_25_M1X1(); + void g65816i_26_M1X1(); + void g65816i_27_M1X1(); + void g65816i_28_M1X1(); + void g65816i_29_M1X1(); + void g65816i_2a_M1X1(); + void g65816i_2b_M1X1(); + void g65816i_2c_M1X1(); + void g65816i_2d_M1X1(); + void g65816i_2e_M1X1(); + void g65816i_2f_M1X1(); + void g65816i_30_M1X1(); + void g65816i_31_M1X1(); + void g65816i_32_M1X1(); + void g65816i_33_M1X1(); + void g65816i_34_M1X1(); + void g65816i_35_M1X1(); + void g65816i_36_M1X1(); + void g65816i_37_M1X1(); + void g65816i_38_M1X1(); + void g65816i_39_M1X1(); + void g65816i_3a_M1X1(); + void g65816i_3b_M1X1(); + void g65816i_3c_M1X1(); + void g65816i_3d_M1X1(); + void g65816i_3e_M1X1(); + void g65816i_3f_M1X1(); + void g65816i_40_M1X1(); + void g65816i_41_M1X1(); + void g65816i_42_M1X1(); + void g65816i_43_M1X1(); + void g65816i_44_M1X1(); + void g65816i_45_M1X1(); + void g65816i_46_M1X1(); + void g65816i_47_M1X1(); + void g65816i_48_M1X1(); + void g65816i_49_M1X1(); + void g65816i_4a_M1X1(); + void g65816i_4b_M1X1(); + void g65816i_4c_M1X1(); + void g65816i_4d_M1X1(); + void g65816i_4e_M1X1(); + void g65816i_4f_M1X1(); + void g65816i_50_M1X1(); + void g65816i_51_M1X1(); + void g65816i_52_M1X1(); + void g65816i_53_M1X1(); + void g65816i_54_M1X1(); + void g65816i_55_M1X1(); + void g65816i_56_M1X1(); + void g65816i_57_M1X1(); + void g65816i_58_M1X1(); + void g65816i_59_M1X1(); + void g65816i_5a_M1X1(); + void g65816i_5b_M1X1(); + void g65816i_5c_M1X1(); + void g65816i_5d_M1X1(); + void g65816i_5e_M1X1(); + void g65816i_5f_M1X1(); + void g65816i_60_M1X1(); + void g65816i_61_M1X1(); + void g65816i_62_M1X1(); + void g65816i_63_M1X1(); + void g65816i_64_M1X1(); + void g65816i_65_M1X1(); + void g65816i_66_M1X1(); + void g65816i_67_M1X1(); + void g65816i_68_M1X1(); + void g65816i_69_M1X1(); + void g65816i_6a_M1X1(); + void g65816i_6b_M1X1(); + void g65816i_6c_M1X1(); + void g65816i_6d_M1X1(); + void g65816i_6e_M1X1(); + void g65816i_6f_M1X1(); + void g65816i_70_M1X1(); + void g65816i_71_M1X1(); + void g65816i_72_M1X1(); + void g65816i_73_M1X1(); + void g65816i_74_M1X1(); + void g65816i_75_M1X1(); + void g65816i_76_M1X1(); + void g65816i_77_M1X1(); + void g65816i_78_M1X1(); + void g65816i_79_M1X1(); + void g65816i_7a_M1X1(); + void g65816i_7b_M1X1(); + void g65816i_7c_M1X1(); + void g65816i_7d_M1X1(); + void g65816i_7e_M1X1(); + void g65816i_7f_M1X1(); + void g65816i_80_M1X1(); + void g65816i_81_M1X1(); + void g65816i_82_M1X1(); + void g65816i_83_M1X1(); + void g65816i_84_M1X1(); + void g65816i_85_M1X1(); + void g65816i_86_M1X1(); + void g65816i_87_M1X1(); + void g65816i_88_M1X1(); + void g65816i_89_M1X1(); + void g65816i_8a_M1X1(); + void g65816i_8b_M1X1(); + void g65816i_8c_M1X1(); + void g65816i_8d_M1X1(); + void g65816i_8e_M1X1(); + void g65816i_8f_M1X1(); + void g65816i_90_M1X1(); + void g65816i_91_M1X1(); + void g65816i_92_M1X1(); + void g65816i_93_M1X1(); + void g65816i_94_M1X1(); + void g65816i_95_M1X1(); + void g65816i_96_M1X1(); + void g65816i_97_M1X1(); + void g65816i_98_M1X1(); + void g65816i_99_M1X1(); + void g65816i_9a_M1X1(); + void g65816i_9b_M1X1(); + void g65816i_9c_M1X1(); + void g65816i_9d_M1X1(); + void g65816i_9e_M1X1(); + void g65816i_9f_M1X1(); + void g65816i_a0_M1X1(); + void g65816i_a1_M1X1(); + void g65816i_a2_M1X1(); + void g65816i_a3_M1X1(); + void g65816i_a4_M1X1(); + void g65816i_a5_M1X1(); + void g65816i_a6_M1X1(); + void g65816i_a7_M1X1(); + void g65816i_a8_M1X1(); + void g65816i_a9_M1X1(); + void g65816i_aa_M1X1(); + void g65816i_ab_M1X1(); + void g65816i_ac_M1X1(); + void g65816i_ad_M1X1(); + void g65816i_ae_M1X1(); + void g65816i_af_M1X1(); + void g65816i_b0_M1X1(); + void g65816i_b1_M1X1(); + void g65816i_b2_M1X1(); + void g65816i_b3_M1X1(); + void g65816i_b4_M1X1(); + void g65816i_b5_M1X1(); + void g65816i_b6_M1X1(); + void g65816i_b7_M1X1(); + void g65816i_b8_M1X1(); + void g65816i_b9_M1X1(); + void g65816i_ba_M1X1(); + void g65816i_bb_M1X1(); + void g65816i_bc_M1X1(); + void g65816i_bd_M1X1(); + void g65816i_be_M1X1(); + void g65816i_bf_M1X1(); + void g65816i_c0_M1X1(); + void g65816i_c1_M1X1(); + void g65816i_c2_M1X1(); + void g65816i_c3_M1X1(); + void g65816i_c4_M1X1(); + void g65816i_c5_M1X1(); + void g65816i_c6_M1X1(); + void g65816i_c7_M1X1(); + void g65816i_c8_M1X1(); + void g65816i_c9_M1X1(); + void g65816i_ca_M1X1(); + void g65816i_cb_M1X1(); + void g65816i_cc_M1X1(); + void g65816i_cd_M1X1(); + void g65816i_ce_M1X1(); + void g65816i_cf_M1X1(); + void g65816i_d0_M1X1(); + void g65816i_d1_M1X1(); + void g65816i_d2_M1X1(); + void g65816i_d3_M1X1(); + void g65816i_d4_M1X1(); + void g65816i_d5_M1X1(); + void g65816i_d6_M1X1(); + void g65816i_d7_M1X1(); + void g65816i_d8_M1X1(); + void g65816i_d9_M1X1(); + void g65816i_da_M1X1(); + void g65816i_db_M1X1(); + void g65816i_dc_M1X1(); + void g65816i_dd_M1X1(); + void g65816i_de_M1X1(); + void g65816i_df_M1X1(); + void g65816i_e0_M1X1(); + void g65816i_e1_M1X1(); + void g65816i_e2_M1X1(); + void g65816i_e3_M1X1(); + void g65816i_e4_M1X1(); + void g65816i_e5_M1X1(); + void g65816i_e6_M1X1(); + void g65816i_e7_M1X1(); + void g65816i_e8_M1X1(); + void g65816i_e9_M1X1(); + void g65816i_ea_M1X1(); + void g65816i_eb_M1X1(); + void g65816i_ec_M1X1(); + void g65816i_ed_M1X1(); + void g65816i_ee_M1X1(); + void g65816i_ef_M1X1(); + void g65816i_f0_M1X1(); + void g65816i_f1_M1X1(); + void g65816i_f2_M1X1(); + void g65816i_f3_M1X1(); + void g65816i_f4_M1X1(); + void g65816i_f5_M1X1(); + void g65816i_f6_M1X1(); + void g65816i_f7_M1X1(); + void g65816i_f8_M1X1(); + void g65816i_f9_M1X1(); + void g65816i_fa_M1X1(); + void g65816i_fb_M1X1(); + void g65816i_fc_M1X1(); + void g65816i_fd_M1X1(); + void g65816i_fe_M1X1(); + void g65816i_ff_M1X1(); + void g65816i_00_E(); + void g65816i_01_E(); + void g65816i_02_E(); + void g65816i_03_E(); + void g65816i_04_E(); + void g65816i_05_E(); + void g65816i_06_E(); + void g65816i_07_E(); + void g65816i_08_E(); + void g65816i_09_E(); + void g65816i_0a_E(); + void g65816i_0b_E(); + void g65816i_0c_E(); + void g65816i_0d_E(); + void g65816i_0e_E(); + void g65816i_0f_E(); + void g65816i_10_E(); + void g65816i_11_E(); + void g65816i_12_E(); + void g65816i_13_E(); + void g65816i_14_E(); + void g65816i_15_E(); + void g65816i_16_E(); + void g65816i_17_E(); + void g65816i_18_E(); + void g65816i_19_E(); + void g65816i_1a_E(); + void g65816i_1b_E(); + void g65816i_1c_E(); + void g65816i_1d_E(); + void g65816i_1e_E(); + void g65816i_1f_E(); + void g65816i_20_E(); + void g65816i_21_E(); + void g65816i_22_E(); + void g65816i_23_E(); + void g65816i_24_E(); + void g65816i_25_E(); + void g65816i_26_E(); + void g65816i_27_E(); + void g65816i_28_E(); + void g65816i_29_E(); + void g65816i_2a_E(); + void g65816i_2b_E(); + void g65816i_2c_E(); + void g65816i_2d_E(); + void g65816i_2e_E(); + void g65816i_2f_E(); + void g65816i_30_E(); + void g65816i_31_E(); + void g65816i_32_E(); + void g65816i_33_E(); + void g65816i_34_E(); + void g65816i_35_E(); + void g65816i_36_E(); + void g65816i_37_E(); + void g65816i_38_E(); + void g65816i_39_E(); + void g65816i_3a_E(); + void g65816i_3b_E(); + void g65816i_3c_E(); + void g65816i_3d_E(); + void g65816i_3e_E(); + void g65816i_3f_E(); + void g65816i_40_E(); + void g65816i_41_E(); + void g65816i_42_E(); + void g65816i_43_E(); + void g65816i_44_E(); + void g65816i_45_E(); + void g65816i_46_E(); + void g65816i_47_E(); + void g65816i_48_E(); + void g65816i_49_E(); + void g65816i_4a_E(); + void g65816i_4b_E(); + void g65816i_4c_E(); + void g65816i_4d_E(); + void g65816i_4e_E(); + void g65816i_4f_E(); + void g65816i_50_E(); + void g65816i_51_E(); + void g65816i_52_E(); + void g65816i_53_E(); + void g65816i_54_E(); + void g65816i_55_E(); + void g65816i_56_E(); + void g65816i_57_E(); + void g65816i_58_E(); + void g65816i_59_E(); + void g65816i_5a_E(); + void g65816i_5b_E(); + void g65816i_5c_E(); + void g65816i_5d_E(); + void g65816i_5e_E(); + void g65816i_5f_E(); + void g65816i_60_E(); + void g65816i_61_E(); + void g65816i_62_E(); + void g65816i_63_E(); + void g65816i_64_E(); + void g65816i_65_E(); + void g65816i_66_E(); + void g65816i_67_E(); + void g65816i_68_E(); + void g65816i_69_E(); + void g65816i_6a_E(); + void g65816i_6b_E(); + void g65816i_6c_E(); + void g65816i_6d_E(); + void g65816i_6e_E(); + void g65816i_6f_E(); + void g65816i_70_E(); + void g65816i_71_E(); + void g65816i_72_E(); + void g65816i_73_E(); + void g65816i_74_E(); + void g65816i_75_E(); + void g65816i_76_E(); + void g65816i_77_E(); + void g65816i_78_E(); + void g65816i_79_E(); + void g65816i_7a_E(); + void g65816i_7b_E(); + void g65816i_7c_E(); + void g65816i_7d_E(); + void g65816i_7e_E(); + void g65816i_7f_E(); + void g65816i_80_E(); + void g65816i_81_E(); + void g65816i_82_E(); + void g65816i_83_E(); + void g65816i_84_E(); + void g65816i_85_E(); + void g65816i_86_E(); + void g65816i_87_E(); + void g65816i_88_E(); + void g65816i_89_E(); + void g65816i_8a_E(); + void g65816i_8b_E(); + void g65816i_8c_E(); + void g65816i_8d_E(); + void g65816i_8e_E(); + void g65816i_8f_E(); + void g65816i_90_E(); + void g65816i_91_E(); + void g65816i_92_E(); + void g65816i_93_E(); + void g65816i_94_E(); + void g65816i_95_E(); + void g65816i_96_E(); + void g65816i_97_E(); + void g65816i_98_E(); + void g65816i_99_E(); + void g65816i_9a_E(); + void g65816i_9b_E(); + void g65816i_9c_E(); + void g65816i_9d_E(); + void g65816i_9e_E(); + void g65816i_9f_E(); + void g65816i_a0_E(); + void g65816i_a1_E(); + void g65816i_a2_E(); + void g65816i_a3_E(); + void g65816i_a4_E(); + void g65816i_a5_E(); + void g65816i_a6_E(); + void g65816i_a7_E(); + void g65816i_a8_E(); + void g65816i_a9_E(); + void g65816i_aa_E(); + void g65816i_ab_E(); + void g65816i_ac_E(); + void g65816i_ad_E(); + void g65816i_ae_E(); + void g65816i_af_E(); + void g65816i_b0_E(); + void g65816i_b1_E(); + void g65816i_b2_E(); + void g65816i_b3_E(); + void g65816i_b4_E(); + void g65816i_b5_E(); + void g65816i_b6_E(); + void g65816i_b7_E(); + void g65816i_b8_E(); + void g65816i_b9_E(); + void g65816i_ba_E(); + void g65816i_bb_E(); + void g65816i_bc_E(); + void g65816i_bd_E(); + void g65816i_be_E(); + void g65816i_bf_E(); + void g65816i_c0_E(); + void g65816i_c1_E(); + void g65816i_c2_E(); + void g65816i_c3_E(); + void g65816i_c4_E(); + void g65816i_c5_E(); + void g65816i_c6_E(); + void g65816i_c7_E(); + void g65816i_c8_E(); + void g65816i_c9_E(); + void g65816i_ca_E(); + void g65816i_cb_E(); + void g65816i_cc_E(); + void g65816i_cd_E(); + void g65816i_ce_E(); + void g65816i_cf_E(); + void g65816i_d0_E(); + void g65816i_d1_E(); + void g65816i_d2_E(); + void g65816i_d3_E(); + void g65816i_d4_E(); + void g65816i_d5_E(); + void g65816i_d6_E(); + void g65816i_d7_E(); + void g65816i_d8_E(); + void g65816i_d9_E(); + void g65816i_da_E(); + void g65816i_db_E(); + void g65816i_dc_E(); + void g65816i_dd_E(); + void g65816i_de_E(); + void g65816i_df_E(); + void g65816i_e0_E(); + void g65816i_e1_E(); + void g65816i_e2_E(); + void g65816i_e3_E(); + void g65816i_e4_E(); + void g65816i_e5_E(); + void g65816i_e6_E(); + void g65816i_e7_E(); + void g65816i_e8_E(); + void g65816i_e9_E(); + void g65816i_ea_E(); + void g65816i_eb_E(); + void g65816i_ec_E(); + void g65816i_ed_E(); + void g65816i_ee_E(); + void g65816i_ef_E(); + void g65816i_f0_E(); + void g65816i_f1_E(); + void g65816i_f2_E(); + void g65816i_f3_E(); + void g65816i_f4_E(); + void g65816i_f5_E(); + void g65816i_f6_E(); + void g65816i_f7_E(); + void g65816i_f8_E(); + void g65816i_f9_E(); + void g65816i_fa_E(); + void g65816i_fb_E(); + void g65816i_fc_E(); + void g65816i_fd_E(); + void g65816i_fe_E(); + void g65816i_ff_E(); +}; + + +class _5a22_device : public g65816_device { public: - _5a22_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock); + _5a22_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); DECLARE_WRITE8_MEMBER( wrmpya_w ); DECLARE_WRITE8_MEMBER( wrmpyb_w ); @@ -79,8 +1546,19 @@ public: DECLARE_READ8_MEMBER( rdmpyh_r ); void set_5a22_map(); + +protected: + // device-level overrides + virtual void device_start(); + virtual void device_reset(); + + // device_state_interface overrides + virtual void state_import(const device_state_entry &entry); + virtual void state_export(const device_state_entry &entry); }; + +extern const device_type G65816; extern const device_type _5A22; @@ -88,8 +1566,6 @@ extern const device_type _5A22; #define CPU_TYPE_5A22 1 -void g65816_set_read_vector_callback(device_t *device, read8_delegate read_vector); - /* ======================================================================== */ /* ============================== END OF FILE ============================= */ /* ======================================================================== */ diff --git a/src/emu/cpu/g65816/g65816cm.h b/src/emu/cpu/g65816/g65816cm.h index c404b00e6de..015d645d2da 100644 --- a/src/emu/cpu/g65816/g65816cm.h +++ b/src/emu/cpu/g65816/g65816cm.h @@ -9,11 +9,11 @@ #undef G65816_CALL_DEBUGGER -#define G65816_CALL_DEBUGGER(x) debugger_instruction_hook(cpustate->device, x) +#define G65816_CALL_DEBUGGER(x) debugger_instruction_hook(this, x) -#define g65816_read_8(addr) cpustate->program->read_byte(addr) -#define g65816_write_8(addr,data) cpustate->program->write_byte(addr,data) -#define g65816_read_8_immediate(A) cpustate->program->read_byte(A) +#define g65816_read_8(addr) m_program->read_byte(addr) +#define g65816_write_8(addr,data) m_program->write_byte(addr,data) +#define g65816_read_8_immediate(A) m_program->read_byte(A) #define g65816_jumping(A) #define g65816_branching(A) @@ -66,101 +66,43 @@ INLINE int MAKE_INT_8(int A) {return (A & 0x80) ? A | ~0xff : A & 0xff;} /* ================================== CPU ================================= */ /* ======================================================================== */ -/* CPU Structure */ -struct g65816i_cpu_struct -{ - uint a; /* Accumulator */ - uint b; /* holds high byte of accumulator */ - uint x; /* Index Register X */ - uint y; /* Index Register Y */ - uint s; /* Stack Pointer */ - uint pc; /* Program Counter */ - uint ppc; /* Previous Program Counter */ - uint pb; /* Program Bank (shifted left 16) */ - uint db; /* Data Bank (shifted left 16) */ - uint d; /* Direct Register */ - uint flag_e; /* Emulation Mode Flag */ - uint flag_m; /* Memory/Accumulator Select Flag */ - uint flag_x; /* Index Select Flag */ - uint flag_n; /* Negative Flag */ - uint flag_v; /* Overflow Flag */ - uint flag_d; /* Decimal Mode Flag */ - uint flag_i; /* Interrupt Mask Flag */ - uint flag_z; /* Zero Flag (inverted) */ - uint flag_c; /* Carry Flag */ - uint line_irq; /* Status of the IRQ line */ - uint line_nmi; /* Status of the NMI line */ - uint fastROM; /* SNES specific */ - uint ir; /* Instruction Register */ - uint irq_delay; /* delay 1 instruction before checking irq */ - device_irq_acknowledge_callback int_ack; /* Interrupt Acknowledge */ - legacy_cpu_device *device; - address_space *program; - read8_delegate read_vector; /* Read vector override */ - uint stopped; /* Sets how the CPU is stopped */ - void (*const *opcodes)(g65816i_cpu_struct *cpustate); - uint (*get_reg)(g65816i_cpu_struct *cpustate, int regnum); - void (*set_reg)(g65816i_cpu_struct *cpustate, int regnum, uint val); - void (*set_line)(g65816i_cpu_struct *cpustate, int line, int state); - int (*execute)(g65816i_cpu_struct *cpustate, int cycles); - int bus_5A22_cycle_burst(g65816i_cpu_struct *cpustate, uint addr); - uint source; - uint destination; - int ICount; - int cpu_type; - UINT8 rw8_cycles, rw16_cycles, rw24_cycles; - - /* 5A22 specific registers */ - UINT8 wrmpya, wrmpyb; - UINT16 rdmpy; - UINT16 wrdiv; - UINT8 dvdd; - UINT16 rddiv; -}; - -extern void (*const *const g65816i_opcodes[])(g65816i_cpu_struct *cpustate); -extern uint (*const g65816i_get_reg[])(g65816i_cpu_struct *cpustate, int regnum); -extern void (*const g65816i_set_reg[])(g65816i_cpu_struct *cpustate, int regnum, uint val); -extern void (*const g65816i_set_line[])(g65816i_cpu_struct *cpustate, int line, int state); -extern int (*const g65816i_execute[])(g65816i_cpu_struct *cpustate, int cycles); -extern int bus_5A22_cycle_burst(g65816i_cpu_struct *cpustate, uint addr); - -#define REGISTER_A cpustate->a /* Accumulator */ -#define REGISTER_B cpustate->b /* Accumulator hi byte */ -#define REGISTER_X cpustate->x /* Index X Register */ -#define REGISTER_Y cpustate->y /* Index Y Register */ -#define REGISTER_S cpustate->s /* Stack Pointer */ -#define REGISTER_PC cpustate->pc /* Program Counter */ -#define REGISTER_PPC cpustate->ppc /* Previous Program Counter */ -#define REGISTER_PB cpustate->pb /* Program Bank */ -#define REGISTER_DB cpustate->db /* Data Bank */ -#define REGISTER_D cpustate->d /* Direct Register */ -#define FLAG_E cpustate->flag_e /* Emulation Mode Flag */ -#define FLAG_M cpustate->flag_m /* Memory/Accumulator Select Flag */ -#define FLAG_X cpustate->flag_x /* Index Select Flag */ -#define FLAG_N cpustate->flag_n /* Negative Flag */ -#define FLAG_V cpustate->flag_v /* Overflow Flag */ -#define FLAG_D cpustate->flag_d /* Decimal Mode Flag */ -#define FLAG_I cpustate->flag_i /* Interrupt Mask Flag */ -#define FLAG_Z cpustate->flag_z /* Zero Flag (inverted) */ -#define FLAG_C cpustate->flag_c /* Carry Flag */ -#define LINE_IRQ cpustate->line_irq /* Status of the IRQ line */ -#define LINE_NMI cpustate->line_nmi /* Status of the NMI line */ -#define REGISTER_IR cpustate->ir /* Instruction Register */ -#define INT_ACK cpustate->int_ack /* Interrupt Acknowledge function pointer */ -#define READ_VECTOR cpustate->read_vector /* Vector reading override */ -#define CLOCKS cpustate->ICount /* Clock cycles remaining */ -#define IRQ_DELAY cpustate->irq_delay /* Delay 1 instruction before checking IRQ */ -#define CPU_STOPPED cpustate->stopped /* Stopped status of the CPU */ - -#define FTABLE_OPCODES cpustate->opcodes -#define FTABLE_GET_REG cpustate->get_reg -#define FTABLE_SET_REG cpustate->set_reg -#define FTABLE_SET_LINE cpustate->set_line -#define FTABLE_EXECUTE cpustate->execute - -#define SRC cpustate->source /* Source Operand */ -#define DST cpustate->destination /* Destination Operand */ + +#define REGISTER_A m_a /* Accumulator */ +#define REGISTER_B m_b /* Accumulator hi byte */ +#define REGISTER_X m_x /* Index X Register */ +#define REGISTER_Y m_y /* Index Y Register */ +#define REGISTER_S m_s /* Stack Pointer */ +#define REGISTER_PC m_pc /* Program Counter */ +#define REGISTER_PPC m_ppc /* Previous Program Counter */ +#define REGISTER_PB m_pb /* Program Bank */ +#define REGISTER_DB m_db /* Data Bank */ +#define REGISTER_D m_d /* Direct Register */ +#define FLAG_E m_flag_e /* Emulation Mode Flag */ +#define FLAG_M m_flag_m /* Memory/Accumulator Select Flag */ +#define FLAG_X m_flag_x /* Index Select Flag */ +#define FLAG_N m_flag_n /* Negative Flag */ +#define FLAG_V m_flag_v /* Overflow Flag */ +#define FLAG_D m_flag_d /* Decimal Mode Flag */ +#define FLAG_I m_flag_i /* Interrupt Mask Flag */ +#define FLAG_Z m_flag_z /* Zero Flag (inverted) */ +#define FLAG_C m_flag_c /* Carry Flag */ +#define LINE_IRQ m_line_irq /* Status of the IRQ line */ +#define LINE_NMI m_line_nmi /* Status of the NMI line */ +#define REGISTER_IR m_ir /* Instruction Register */ +#define INT_ACK m_int_ack /* Interrupt Acknowledge function pointer */ +#define READ_VECTOR m_read_vector /* Vector reading override */ +#define CLOCKS m_ICount /* Clock cycles remaining */ +#define IRQ_DELAY m_irq_delay /* Delay 1 instruction before checking IRQ */ +#define CPU_STOPPED m_stopped /* Stopped status of the CPU */ + +#define FTABLE_OPCODES m_opcodes +#define FTABLE_GET_REG m_get_reg +#define FTABLE_SET_REG m_set_reg +#define FTABLE_SET_LINE m_set_line +#define FTABLE_EXECUTE m_execute + +#define SRC m_source /* Source Operand */ +#define DST m_destination /* Destination Operand */ #define STOP_LEVEL_WAI 1 #define STOP_LEVEL_STOP 2 @@ -171,17 +113,6 @@ extern int bus_5A22_cycle_burst(g65816i_cpu_struct *cpustate, uint addr); #define EXECUTION_MODE_M1X1 3 #define EXECUTION_MODE_E 4 -INLINE void g65816i_set_execution_mode(g65816i_cpu_struct *cpustate, uint mode) -{ - FTABLE_OPCODES = g65816i_opcodes[mode]; - FTABLE_GET_REG = g65816i_get_reg[mode]; - FTABLE_SET_REG = g65816i_set_reg[mode]; - FTABLE_SET_LINE = g65816i_set_line[mode]; - FTABLE_EXECUTE = g65816i_execute[mode]; -} - - - #define VECTOR_RESET 0xfffc /* Reset */ #define VECTOR_IRQ_E 0xfffe /* Interrupt Request */ #define VECTOR_NMI_E 0xfffa /* Non-Maskable Interrupt */ @@ -201,14 +132,14 @@ INLINE void g65816i_set_execution_mode(g65816i_cpu_struct *cpustate, uint mode) /* ======================================================================== */ #define CLK_OP 1 -#define CLK_R8 cpustate->rw8_cycles -#define CLK_R16 cpustate->rw16_cycles -#define CLK_R24 cpustate->rw24_cycles -#define CLK_W8 cpustate->rw8_cycles -#define CLK_W16 cpustate->rw16_cycles -#define CLK_W24 cpustate->rw24_cycles -#define CLK_RMW8 cpustate->rw8_cycles+cpustate->rw8_cycles + 1 -#define CLK_RMW16 cpustate->rw16_cycles+cpustate->rw16_cycles + 1 +#define CLK_R8 m_rw8_cycles +#define CLK_R16 m_rw16_cycles +#define CLK_R24 m_rw24_cycles +#define CLK_W8 m_rw8_cycles +#define CLK_W16 m_rw16_cycles +#define CLK_W24 m_rw24_cycles +#define CLK_RMW8 m_rw8_cycles+m_rw8_cycles + 1 +#define CLK_RMW16 m_rw16_cycles+m_rw16_cycles + 1 #define CLK_IMPLIED 1 #define CLK_IMPLIED 1 @@ -253,7 +184,7 @@ INLINE void g65816i_set_execution_mode(g65816i_cpu_struct *cpustate, uint mode) #define CLK_W_S 2 #define CLK_W_SIY 5 -#define CLK(A) CLOCKS -= (cpustate->cpu_type == CPU_TYPE_G65816 ? A : A*6) +#define CLK(A) CLOCKS -= (m_cpu_type == CPU_TYPE_G65816 ? A : A*6) #define CLK_BUS(A) CLOCKS -= A #define USE_ALL_CLKS() CLOCKS = 0 diff --git a/src/emu/cpu/g65816/g65816op.h b/src/emu/cpu/g65816/g65816op.h index 3d5cefc4e01..03bc4c52203 100644 --- a/src/emu/cpu/g65816/g65816op.h +++ b/src/emu/cpu/g65816/g65816op.h @@ -51,601 +51,173 @@ /* ======================================================================== */ -/* ================================= MEMORY =============================== */ -/* ======================================================================== */ - -#define ADDRESS_65816(A) ((A)&0x00ffffff) - -INLINE uint g65816i_read_8_normal(g65816i_cpu_struct *cpustate, uint address) -{ - address = ADDRESS_65816(address); - CLOCKS -= (bus_5A22_cycle_burst(cpustate,address)); - return g65816_read_8(address); -} - -INLINE uint g65816i_read_8_immediate(g65816i_cpu_struct *cpustate, uint address) -{ - address = ADDRESS_65816(address); - CLOCKS -= (bus_5A22_cycle_burst(cpustate,address)); - return g65816_read_8_immediate(address); -} - -INLINE uint g65816i_read_8_direct(g65816i_cpu_struct *cpustate, uint address) -{ -#if FLAG_SET_E - /* force address into zero page */ - address = REGISTER_D + MAKE_UINT_8(address - REGISTER_D); -#else - address = ADDRESS_65816(address); -#endif - CLOCKS -= (bus_5A22_cycle_burst(cpustate,address)); - return g65816_read_8(address); -} - -INLINE uint g65816i_read_8_vector(g65816i_cpu_struct *cpustate, uint address) -{ - if (!READ_VECTOR.isnull()) - return READ_VECTOR(*cpustate->program, address, 0xff); - else - return g65816i_read_8_normal(cpustate, address); -} - -INLINE void g65816i_write_8_normal(g65816i_cpu_struct *cpustate, uint address, uint value) -{ - address = ADDRESS_65816(address); - CLOCKS -= (bus_5A22_cycle_burst(cpustate,address)); - g65816_write_8(address, MAKE_UINT_8(value)); -} - -INLINE void g65816i_write_8_direct(g65816i_cpu_struct *cpustate, uint address, uint value) -{ -#if FLAG_SET_E - /* force address into zero page */ - address = REGISTER_D + MAKE_UINT_8(address - REGISTER_D); -#else - address = ADDRESS_65816(address); -#endif - CLOCKS -= (bus_5A22_cycle_burst(cpustate,address)); - g65816_write_8(address, MAKE_UINT_8(value)); -} - -INLINE uint g65816i_read_16_normal(g65816i_cpu_struct *cpustate, uint address) -{ - return g65816i_read_8_normal(cpustate, address) | - (g65816i_read_8_normal(cpustate, address+1)<<8); -} - -INLINE uint g65816i_read_16_immediate(g65816i_cpu_struct *cpustate, uint address) -{ - return g65816i_read_8_immediate(cpustate, address) | - (g65816i_read_8_immediate(cpustate, address+1)<<8); -} - -INLINE uint g65816i_read_16_direct(g65816i_cpu_struct *cpustate, uint address) -{ - return g65816i_read_8_direct(cpustate, address) | - (g65816i_read_8_direct(cpustate, address+1)<<8); -} - -INLINE uint g65816i_read_16_vector(g65816i_cpu_struct *cpustate, uint address) -{ - return g65816i_read_8_vector(cpustate, address) | - (g65816i_read_8_vector(cpustate, address+1)<<8); -} - -INLINE void g65816i_write_16_normal(g65816i_cpu_struct *cpustate, uint address, uint value) -{ - g65816i_write_8_normal(cpustate, address, value&0xff); - g65816i_write_8_normal(cpustate, address+1, value>>8); -} - -INLINE void g65816i_write_16_direct(g65816i_cpu_struct *cpustate, uint address, uint value) -{ - g65816i_write_8_direct(cpustate, address, value&0xff); - g65816i_write_8_direct(cpustate, address+1, value>>8); -} - -INLINE uint g65816i_read_24_normal(g65816i_cpu_struct *cpustate, uint address) -{ - return g65816i_read_8_normal(cpustate, address) | - (g65816i_read_8_normal(cpustate, address+1)<<8) | - (g65816i_read_8_normal(cpustate, address+2)<<16); -} - -INLINE uint g65816i_read_24_immediate(g65816i_cpu_struct *cpustate, uint address) -{ - return g65816i_read_8_immediate(cpustate, address) | - (g65816i_read_8_immediate(cpustate, address+1)<<8) | - (g65816i_read_8_immediate(cpustate, address+2)<<16); -} - -INLINE uint g65816i_read_24_direct(g65816i_cpu_struct *cpustate, uint address) -{ - return g65816i_read_8_direct(cpustate, address) | - (g65816i_read_8_direct(cpustate, address+1)<<8) | - (g65816i_read_8_direct(cpustate, address+2)<<16); -} - - - -/* ======================================================================== */ -/* ================================= STACK ================================ */ -/* ======================================================================== */ - -INLINE void g65816i_push_8(g65816i_cpu_struct *cpustate, uint value) -{ - g65816i_write_8_normal(cpustate, REGISTER_S, value); -#if FLAG_SET_E - REGISTER_S = MAKE_UINT_8(REGISTER_S-1) | 0x100; -#else - REGISTER_S = MAKE_UINT_16(REGISTER_S-1); -#endif -} - -INLINE uint g65816i_pull_8(g65816i_cpu_struct *cpustate) -{ -#if FLAG_SET_E - REGISTER_S = MAKE_UINT_8(REGISTER_S+1) | 0x100; -#else - REGISTER_S = MAKE_UINT_16(REGISTER_S+1); -#endif - return g65816i_read_8_normal(cpustate, REGISTER_S); -} - -INLINE void g65816i_push_16(g65816i_cpu_struct *cpustate, uint value) -{ - g65816i_push_8(cpustate, value>>8); - g65816i_push_8(cpustate, value&0xff); -} - -INLINE uint g65816i_pull_16(g65816i_cpu_struct *cpustate) -{ - uint res = g65816i_pull_8(cpustate); - return res | (g65816i_pull_8(cpustate) << 8); -} - -INLINE void g65816i_push_24(g65816i_cpu_struct *cpustate, uint value) -{ - g65816i_push_8(cpustate, value>>16); - g65816i_push_8(cpustate, (value>>8)&0xff); - g65816i_push_8(cpustate, value&0xff); -} - -INLINE uint g65816i_pull_24(g65816i_cpu_struct *cpustate) -{ - uint res = g65816i_pull_8(cpustate); - res |= g65816i_pull_8(cpustate) << 8; - return ((res + 1) & 0xffff) | (g65816i_pull_8(cpustate) << 16); -} - - -/* ======================================================================== */ -/* ============================ PROGRAM COUNTER =========================== */ -/* ======================================================================== */ - -INLINE void g65816i_jump_16(g65816i_cpu_struct *cpustate, uint address) -{ - REGISTER_PC = MAKE_UINT_16(address); - g65816i_jumping(REGISTER_PC); -} - -INLINE void g65816i_jump_24(g65816i_cpu_struct *cpustate, uint address) -{ - REGISTER_PB = address&0xff0000; - REGISTER_PC = MAKE_UINT_16(address); - g65816i_jumping(REGISTER_PC); -} - -INLINE void g65816i_branch_8(g65816i_cpu_struct *cpustate, uint offset) -{ -#if FLAG_SET_E - uint old_pc = REGISTER_PC; - REGISTER_PC = MAKE_UINT_16(REGISTER_PC + MAKE_INT_8(offset)); - if((REGISTER_PC^old_pc)&0xff00) - CLK(1); -#else - REGISTER_PC = MAKE_UINT_16(REGISTER_PC + MAKE_INT_8(offset)); -#endif - g65816i_branching(REGISTER_PC); -} - -INLINE void g65816i_branch_16(g65816i_cpu_struct *cpustate, uint offset) -{ - REGISTER_PC = MAKE_UINT_16(REGISTER_PC + offset); - g65816i_branching(REGISTER_PC); -} - - -/* ======================================================================== */ -/* ============================ STATUS REGISTER =========================== */ -/* ======================================================================== */ - -#if !FLAG_SET_E -INLINE void g65816i_set_flag_mx(g65816i_cpu_struct *cpustate, uint value) -{ -#if FLAG_SET_M - if(!(value & FLAGPOS_M)) - { - REGISTER_A |= REGISTER_B; - REGISTER_B = 0; - FLAG_M = MFLAG_CLEAR; - } -#else - if(value & FLAGPOS_M) - { - REGISTER_B = REGISTER_A & 0xff00; - REGISTER_A = MAKE_UINT_8(REGISTER_A); - FLAG_M = MFLAG_SET; - } -#endif -#if FLAG_SET_X - if(!(value & FLAGPOS_X)) - { - FLAG_X = XFLAG_CLEAR; - } -#else - if(value & FLAGPOS_X) - { - REGISTER_X = MAKE_UINT_8(REGISTER_X); - REGISTER_Y = MAKE_UINT_8(REGISTER_Y); - FLAG_X = XFLAG_SET; - } -#endif - g65816i_set_execution_mode(cpustate, (FLAG_M>>4) | (FLAG_X>>4)); -} -#endif - -INLINE void g65816i_set_flag_e(g65816i_cpu_struct *cpustate, uint value) -{ -#if FLAG_SET_E - if(!value) - { - FLAG_E = EFLAG_CLEAR; - g65816i_set_execution_mode(cpustate, EXECUTION_MODE_M1X1); - } -#else - if(value) - { -#if !FLAG_SET_M - REGISTER_B = REGISTER_A & 0xff00; - REGISTER_A &= 0x00ff; - FLAG_M = MFLAG_SET; -#endif -#if !FLAG_SET_X - REGISTER_X = MAKE_UINT_8(REGISTER_X); - REGISTER_Y = MAKE_UINT_8(REGISTER_Y); - FLAG_X = XFLAG_SET; -#endif - REGISTER_S = MAKE_UINT_8(REGISTER_S) | 0x100; - FLAG_E = EFLAG_SET; - g65816i_set_execution_mode(cpustate, EXECUTION_MODE_E); - } -#endif -} - -//INLINE void g65816i_check_maskable_interrupt(void); - -INLINE void g65816i_set_flag_i(g65816i_cpu_struct *cpustate, uint value) -{ - value &= FLAGPOS_I; - if(!FLAG_I || value) - { - FLAG_I = value; - return; - } - FLAG_I = value; -// g65816i_check_maskable_interrupt(); -} - - - - -/* Get the Processor Status Register */ -INLINE uint g65816i_get_reg_p(g65816i_cpu_struct *cpustate) -{ - return (FLAG_N&0x80) | - ((FLAG_V>>1)&0x40) | - FLAG_M | - FLAG_X | - FLAG_D | - FLAG_I | - ((!FLAG_Z)<<1) | - ((FLAG_C>>8)&1); -} - -INLINE void g65816i_set_reg_p(g65816i_cpu_struct *cpustate, uint value) -{ -#if FLAG_SET_E - FLAG_N = value; - FLAG_V = value << 1; - FLAG_D = value & FLAGPOS_D; - FLAG_Z = !(value & FLAGPOS_Z); - FLAG_C = value << 8; - g65816i_set_flag_i(cpustate, value); -#else - FLAG_N = value; - FLAG_V = value << 1; - FLAG_D = value & FLAGPOS_D; - FLAG_Z = !(value & FLAGPOS_Z); - FLAG_C = value << 8; - g65816i_set_flag_mx(cpustate, value); - g65816i_set_flag_i(cpustate, value); -#endif -} - - -/* ======================================================================== */ -/* =============================== INTERRUPTS ============================= */ -/* ======================================================================== */ - -INLINE void g65816i_interrupt_hardware(g65816i_cpu_struct *cpustate, uint vector) -{ -#if FLAG_SET_E - CLK(7); - g65816i_push_16(cpustate, REGISTER_PC); - g65816i_push_8(cpustate, g65816i_get_reg_p(cpustate) & ~FLAGPOS_B); - FLAG_D = DFLAG_CLEAR; - g65816i_set_flag_i(cpustate, IFLAG_SET); - REGISTER_PB = 0; - g65816i_jump_16(cpustate, g65816i_read_16_vector(cpustate, vector)); - if(INT_ACK) INT_ACK(cpustate->device, 0); -#else - CLK(8); - g65816i_push_8(cpustate, REGISTER_PB>>16); - g65816i_push_16(cpustate, REGISTER_PC); - g65816i_push_8(cpustate, g65816i_get_reg_p(cpustate)); - FLAG_D = DFLAG_CLEAR; - g65816i_set_flag_i(cpustate, IFLAG_SET); - REGISTER_PB = 0; - g65816i_jump_16(cpustate, g65816i_read_16_vector(cpustate, vector)); - if(INT_ACK) INT_ACK(cpustate->device, 0); -#endif -} - -INLINE void g65816i_interrupt_software(g65816i_cpu_struct *cpustate, uint vector) -{ -#if FLAG_SET_E - CLK(7); - g65816i_push_16(cpustate, REGISTER_PC); - g65816i_push_8(cpustate, g65816i_get_reg_p(cpustate)); - FLAG_D = DFLAG_CLEAR; - g65816i_set_flag_i(cpustate, IFLAG_SET); - REGISTER_PB = 0; - g65816i_jump_16(cpustate, g65816i_read_16_normal(cpustate, vector)); -#else - CLK(8); - g65816i_push_8(cpustate, REGISTER_PB>>16); - g65816i_push_16(cpustate, REGISTER_PC); - g65816i_push_8(cpustate, g65816i_get_reg_p(cpustate)); - FLAG_D = DFLAG_CLEAR; - g65816i_set_flag_i(cpustate, IFLAG_SET); - REGISTER_PB = 0; - g65816i_jump_16(cpustate, g65816i_read_16_normal(cpustate, vector)); -#endif -} - -INLINE void g65816i_interrupt_nmi(g65816i_cpu_struct *cpustate) -{ -#if FLAG_SET_E - CLK(7); - g65816i_push_16(cpustate, REGISTER_PC); - g65816i_push_8(cpustate, g65816i_get_reg_p(cpustate) & ~FLAGPOS_B); - FLAG_D = DFLAG_CLEAR; - REGISTER_PB = 0; - g65816i_jump_16(cpustate, g65816i_read_16_normal(cpustate, VECTOR_NMI)); -#else - CLK(8); - g65816i_push_8(cpustate, REGISTER_PB>>16); - g65816i_push_16(cpustate, REGISTER_PC); - g65816i_push_8(cpustate, g65816i_get_reg_p(cpustate)); - FLAG_D = DFLAG_CLEAR; - REGISTER_PB = 0; - g65816i_jump_16(cpustate, g65816i_read_16_normal(cpustate, VECTOR_NMI)); -#endif -} - - -INLINE void g65816i_check_maskable_interrupt(g65816i_cpu_struct *cpustate) -{ - if(!(CPU_STOPPED & STOP_LEVEL_STOP) && LINE_IRQ && !FLAG_I) - { - g65816i_interrupt_hardware(cpustate, VECTOR_IRQ); - CPU_STOPPED &= ~STOP_LEVEL_WAI; - LINE_IRQ=0; - } -} - - -/* ======================================================================== */ /* ========================== EFFECTIVE ADDRESSES ========================= */ /* ======================================================================== */ /* Effective-address based memory access macros */ -#define read_8_NORM(A) g65816i_read_8_normal(cpustate, A) -#define read_8_IMM(A) g65816i_read_8_immediate(cpustate, A) -#define read_8_D(A) g65816i_read_8_direct(cpustate, A) -#define read_8_A(A) g65816i_read_8_normal(cpustate, A) -#define read_8_AL(A) g65816i_read_8_normal(cpustate, A) -#define read_8_DX(A) g65816i_read_8_direct(cpustate, A) -#define read_8_DY(A) g65816i_read_8_direct(cpustate, A) -#define read_8_AX(A) g65816i_read_8_normal(cpustate, A) -#define read_8_ALX(A) g65816i_read_8_normal(cpustate, A) -#define read_8_AY(A) g65816i_read_8_normal(cpustate, A) -#define read_8_DI(A) g65816i_read_8_normal(cpustate, A) -#define read_8_DLI(A) g65816i_read_8_normal(cpustate, A) -#define read_8_AI(A) g65816i_read_8_normal(cpustate, A) -#define read_8_ALI(A) g65816i_read_8_normal(cpustate, A) -#define read_8_DXI(A) g65816i_read_8_normal(cpustate, A) -#define read_8_DIY(A) g65816i_read_8_normal(cpustate, A) -#define read_8_DLIY(A) g65816i_read_8_normal(cpustate, A) -#define read_8_AXI(A) g65816i_read_8_normal(cpustate, A) -#define read_8_S(A) g65816i_read_8_normal(cpustate, A) -#define read_8_SIY(A) g65816i_read_8_normal(cpustate, A) - -#define read_16_NORM(A) g65816i_read_16_normal(cpustate, A) -#define read_16_IMM(A) g65816i_read_16_immediate(cpustate, A) -#define read_16_D(A) g65816i_read_16_direct(cpustate, A) -#define read_16_A(A) g65816i_read_16_normal(cpustate, A) -#define read_16_AL(A) g65816i_read_16_normal(cpustate, A) -#define read_16_DX(A) g65816i_read_16_direct(cpustate, A) -#define read_16_DY(A) g65816i_read_16_direct(cpustate, A) -#define read_16_AX(A) g65816i_read_16_normal(cpustate, A) -#define read_16_ALX(A) g65816i_read_16_normal(cpustate, A) -#define read_16_AY(A) g65816i_read_16_normal(cpustate, A) -#define read_16_DI(A) g65816i_read_16_normal(cpustate, A) -#define read_16_DLI(A) g65816i_read_16_normal(cpustate, A) -#define read_16_AI(A) g65816i_read_16_normal(cpustate, A) -#define read_16_ALI(A) g65816i_read_16_normal(cpustate, A) -#define read_16_DXI(A) g65816i_read_16_normal(cpustate, A) -#define read_16_DIY(A) g65816i_read_16_normal(cpustate, A) -#define read_16_DLIY(A) g65816i_read_16_normal(cpustate, A) -#define read_16_AXI(A) g65816i_read_16_normal(cpustate, A) -#define read_16_S(A) g65816i_read_16_normal(cpustate, A) -#define read_16_SIY(A) g65816i_read_16_normal(cpustate, A) - -#define read_24_NORM(A) g65816i_read_24_normal(cpustate, A) -#define read_24_IMM(A) g65816i_read_24_immediate(cpustate, A) -#define read_24_D(A) g65816i_read_24_direct(cpustate, A) -#define read_24_A(A) g65816i_read_24_normal(cpustate, A) -#define read_24_AL(A) g65816i_read_24_normal(cpustate, A) -#define read_24_DX(A) g65816i_read_24_direct(cpustate, A) -#define read_24_DY(A) g65816i_read_24_direct(cpustate, A) -#define read_24_AX(A) g65816i_read_24_normal(cpustate, A) -#define read_24_ALX(A) g65816i_read_24_normal(cpustate, A) -#define read_24_AY(A) g65816i_read_24_normal(cpustate, A) -#define read_24_DI(A) g65816i_read_24_normal(cpustate, A) -#define read_24_DLI(A) g65816i_read_24_normal(cpustate, A) -#define read_24_AI(A) g65816i_read_24_normal(cpustate, A) -#define read_24_ALI(A) g65816i_read_24_normal(cpustate, A) -#define read_24_DXI(A) g65816i_read_24_normal(cpustate, A) -#define read_24_DIY(A) g65816i_read_24_normal(cpustate, A) -#define read_24_DLIY(A) g65816i_read_24_normal(cpustate, A) -#define read_24_AXI(A) g65816i_read_24_normal(cpustate, A) -#define read_24_S(A) g65816i_read_24_normal(cpustate, A) -#define read_24_SIY(A) g65816i_read_24_normal(cpustate, A) - -#define write_8_NORM(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_D(A, V) g65816i_write_8_direct(cpustate, A, V) -#define write_8_A(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_AL(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_DX(A, V) g65816i_write_8_direct(cpustate, A, V) -#define write_8_DY(A, V) g65816i_write_8_direct(cpustate, A, V) -#define write_8_AX(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_ALX(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_AY(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_DI(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_DLI(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_AI(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_ALI(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_DXI(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_DIY(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_DLIY(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_AXI(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_S(A, V) g65816i_write_8_normal(cpustate, A, V) -#define write_8_SIY(A, V) g65816i_write_8_normal(cpustate, A, V) - -#define write_16_NORM(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_D(A, V) g65816i_write_16_direct(cpustate, A, V) -#define write_16_A(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_AL(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_DX(A, V) g65816i_write_16_direct(cpustate, A, V) -#define write_16_DY(A, V) g65816i_write_16_direct(cpustate, A, V) -#define write_16_AX(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_ALX(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_AY(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_DI(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_DLI(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_AI(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_ALI(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_DXI(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_DIY(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_DLIY(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_AXI(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_S(A, V) g65816i_write_16_normal(cpustate, A, V) -#define write_16_SIY(A, V) g65816i_write_16_normal(cpustate, A, V) - - -#define OPER_8_IMM(cpustate) read_8_IMM(EA_IMM8(cpustate)) -#define OPER_8_D(cpustate) read_8_D(EA_D(cpustate)) -#define OPER_8_A(cpustate) read_8_A(EA_A(cpustate)) -#define OPER_8_AL(cpustate) read_8_AL(EA_AL(cpustate)) -#define OPER_8_DX(cpustate) read_8_DX(EA_DX(cpustate)) -#define OPER_8_DY(cpustate) read_8_DY(EA_DY(cpustate)) -#define OPER_8_AX(cpustate) read_8_AX(EA_AX(cpustate)) -#define OPER_8_ALX(cpustate) read_8_ALX(EA_ALX(cpustate)) -#define OPER_8_AY(cpustate) read_8_AY(EA_AY(cpustate)) -#define OPER_8_DI(cpustate) read_8_DI(EA_DI(cpustate)) -#define OPER_8_DLI(cpustate) read_8_DLI(EA_DLI(cpustate)) -#define OPER_8_AI(cpustate) read_8_AI(EA_AI(cpustate)) -#define OPER_8_ALI(cpustate) read_8_ALI(EA_ALI(cpustate)) -#define OPER_8_DXI(cpustate) read_8_DXI(EA_DXI(cpustate)) -#define OPER_8_DIY(cpustate) read_8_DIY(EA_DIY(cpustate)) -#define OPER_8_DLIY(cpustate) read_8_DLIY(EA_DLIY(cpustate)) -#define OPER_8_AXI(cpustate) read_8_AXI(EA_AXI(cpustate)) -#define OPER_8_S(cpustate) read_8_S(EA_S(cpustate)) -#define OPER_8_SIY(cpustate) read_8_SIY(EA_SIY(cpustate)) - -#define OPER_16_IMM(cpustate) read_16_IMM(EA_IMM16(cpustate)) -#define OPER_16_D(cpustate) read_16_D(EA_D(cpustate)) -#define OPER_16_A(cpustate) read_16_A(EA_A(cpustate)) -#define OPER_16_AL(cpustate) read_16_AL(EA_AL(cpustate)) -#define OPER_16_DX(cpustate) read_16_DX(EA_DX(cpustate)) -#define OPER_16_DY(cpustate) read_16_DY(EA_DY(cpustate)) -#define OPER_16_AX(cpustate) read_16_AX(EA_AX(cpustate)) -#define OPER_16_ALX(cpustate) read_16_ALX(EA_ALX(cpustate)) -#define OPER_16_AY(cpustate) read_16_AY(EA_AY(cpustate)) -#define OPER_16_DI(cpustate) read_16_DI(EA_DI(cpustate)) -#define OPER_16_DLI(cpustate) read_16_DLI(EA_DLI(cpustate)) -#define OPER_16_AI(cpustate) read_16_AI(EA_AI(cpustate)) -#define OPER_16_ALI(cpustate) read_16_ALI(EA_ALI(cpustate)) -#define OPER_16_DXI(cpustate) read_16_DXI(EA_DXI(cpustate)) -#define OPER_16_DIY(cpustate) read_16_DIY(EA_DIY(cpustate)) -#define OPER_16_DLIY(cpustate) read_16_DLIY(EA_DLIY(cpustate)) -#define OPER_16_AXI(cpustate) read_16_AXI(EA_AXI(cpustate)) -#define OPER_16_S(cpustate) read_16_S(EA_S(cpustate)) -#define OPER_16_SIY(cpustate) read_16_SIY(EA_SIY(cpustate)) - -#define OPER_24_IMM(cpustate) read_24_IMM(EA_IMM24(cpustate)) -#define OPER_24_D(cpustate) read_24_D(EA_D(cpustate)) -#define OPER_24_A(cpustate) read_24_A(EA_A(cpustate)) -#define OPER_24_AL(cpustate) read_24_AL(EA_AL(cpustate)) -#define OPER_24_DX(cpustate) read_24_DX(EA_DX(cpustate)) -#define OPER_24_DY(cpustate) read_24_DY(EA_DY(cpustate)) -#define OPER_24_AX(cpustate) read_24_AX(EA_AX(cpustate)) -#define OPER_24_ALX(cpustate) read_24_ALX(EA_ALX(cpustate)) -#define OPER_24_AY(cpustate) read_24_AY(EA_AY(cpustate)) -#define OPER_24_DI(cpustate) read_24_DI(EA_DI(cpustate)) -#define OPER_24_DLI(cpustate) read_24_DLI(EA_DLI(cpustate)) -#define OPER_24_AI(cpustate) read_24_AI(EA_AI(cpustate)) -#define OPER_24_ALI(cpustate) read_24_ALI(EA_ALI(cpustate)) -#define OPER_24_DXI(cpustate) read_24_DXI(EA_DXI(cpustate)) -#define OPER_24_DIY(cpustate) read_24_DIY(EA_DIY(cpustate)) -#define OPER_24_DLIY(cpustate) read_24_DLIY(EA_DLIY(cpustate)) -#define OPER_24_AXI(cpustate) read_24_AXI(EA_AXI(cpustate)) -#define OPER_24_S(cpustate) read_24_S(EA_S(cpustate)) -#define OPER_24_SIY(cpustate) read_24_SIY(EA_SIY(cpustate)) - -INLINE uint EA_IMM8(g65816i_cpu_struct *cpustate) {REGISTER_PC += 1; return REGISTER_PB | MAKE_UINT_16(REGISTER_PC-1);} -INLINE uint EA_IMM16(g65816i_cpu_struct *cpustate) {REGISTER_PC += 2; return REGISTER_PB | MAKE_UINT_16(REGISTER_PC-2);} -INLINE uint EA_IMM24(g65816i_cpu_struct *cpustate) {REGISTER_PC += 3; return REGISTER_PB | MAKE_UINT_16(REGISTER_PC-3);} -INLINE uint EA_D(g65816i_cpu_struct *cpustate) {if(MAKE_UINT_8(REGISTER_D)) CLK(1); return MAKE_UINT_16(REGISTER_D + OPER_8_IMM(cpustate));} -INLINE uint EA_A(g65816i_cpu_struct *cpustate) {return REGISTER_DB | OPER_16_IMM(cpustate);} -INLINE uint EA_AL(g65816i_cpu_struct *cpustate) {return OPER_24_IMM(cpustate);} -INLINE uint EA_DX(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(REGISTER_D + OPER_8_IMM(cpustate) + REGISTER_X);} -INLINE uint EA_DY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(REGISTER_D + OPER_8_IMM(cpustate) + REGISTER_Y);} -INLINE uint EA_AX(g65816i_cpu_struct *cpustate) {uint tmp = EA_A(cpustate); if((tmp^(tmp+REGISTER_X))&0xff00) CLK(1); return tmp + REGISTER_X;} -INLINE uint EA_ALX(g65816i_cpu_struct *cpustate) {return EA_AL(cpustate) + REGISTER_X;} -INLINE uint EA_AY(g65816i_cpu_struct *cpustate) {uint tmp = EA_A(cpustate); if((tmp^(tmp+REGISTER_X))&0xff00) CLK(1); return tmp + REGISTER_Y;} -INLINE uint EA_DI(g65816i_cpu_struct *cpustate) {return REGISTER_DB | OPER_16_D(cpustate);} -INLINE uint EA_DLI(g65816i_cpu_struct *cpustate) {return OPER_24_D(cpustate);} -INLINE uint EA_AI(g65816i_cpu_struct *cpustate) {return read_16_A(OPER_16_IMM(cpustate));} -INLINE uint EA_ALI(g65816i_cpu_struct *cpustate) {return OPER_24_A(cpustate);} -INLINE uint EA_DXI(g65816i_cpu_struct *cpustate) {return REGISTER_DB | OPER_16_DX(cpustate);} -INLINE uint EA_DIY(g65816i_cpu_struct *cpustate) {uint tmp = REGISTER_DB | OPER_16_D(cpustate); if((tmp^(tmp+REGISTER_X))&0xff00) CLK(1); return tmp + REGISTER_Y;} -INLINE uint EA_DLIY(g65816i_cpu_struct *cpustate) {return OPER_24_D(cpustate) + REGISTER_Y;} -INLINE uint EA_AXI(g65816i_cpu_struct *cpustate) {return read_16_AXI(MAKE_UINT_16(OPER_16_IMM(cpustate) + REGISTER_X));} -INLINE uint EA_S(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(REGISTER_S + OPER_8_IMM(cpustate));} -INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_SIY(REGISTER_S + OPER_8_IMM(cpustate)) + REGISTER_Y) | REGISTER_DB;} +#define read_8_NORM(A) g65816i_read_8_normal(A) +#define read_8_IMM(A) g65816i_read_8_immediate(A) +#define read_8_D(A) g65816i_read_8_direct(A) +#define read_8_A(A) g65816i_read_8_normal(A) +#define read_8_AL(A) g65816i_read_8_normal(A) +#define read_8_DX(A) g65816i_read_8_direct(A) +#define read_8_DY(A) g65816i_read_8_direct(A) +#define read_8_AX(A) g65816i_read_8_normal(A) +#define read_8_ALX(A) g65816i_read_8_normal(A) +#define read_8_AY(A) g65816i_read_8_normal(A) +#define read_8_DI(A) g65816i_read_8_normal(A) +#define read_8_DLI(A) g65816i_read_8_normal(A) +#define read_8_AI(A) g65816i_read_8_normal(A) +#define read_8_ALI(A) g65816i_read_8_normal(A) +#define read_8_DXI(A) g65816i_read_8_normal(A) +#define read_8_DIY(A) g65816i_read_8_normal(A) +#define read_8_DLIY(A) g65816i_read_8_normal(A) +#define read_8_AXI(A) g65816i_read_8_normal(A) +#define read_8_S(A) g65816i_read_8_normal(A) +#define read_8_SIY(A) g65816i_read_8_normal(A) + +#define read_16_NORM(A) g65816i_read_16_normal(A) +#define read_16_IMM(A) g65816i_read_16_immediate(A) +#define read_16_D(A) g65816i_read_16_direct(A) +#define read_16_A(A) g65816i_read_16_normal(A) +#define read_16_AL(A) g65816i_read_16_normal(A) +#define read_16_DX(A) g65816i_read_16_direct(A) +#define read_16_DY(A) g65816i_read_16_direct(A) +#define read_16_AX(A) g65816i_read_16_normal(A) +#define read_16_ALX(A) g65816i_read_16_normal(A) +#define read_16_AY(A) g65816i_read_16_normal(A) +#define read_16_DI(A) g65816i_read_16_normal(A) +#define read_16_DLI(A) g65816i_read_16_normal(A) +#define read_16_AI(A) g65816i_read_16_normal(A) +#define read_16_ALI(A) g65816i_read_16_normal(A) +#define read_16_DXI(A) g65816i_read_16_normal(A) +#define read_16_DIY(A) g65816i_read_16_normal(A) +#define read_16_DLIY(A) g65816i_read_16_normal(A) +#define read_16_AXI(A) g65816i_read_16_normal(A) +#define read_16_S(A) g65816i_read_16_normal(A) +#define read_16_SIY(A) g65816i_read_16_normal(A) + +#define read_24_NORM(A) g65816i_read_24_normal(A) +#define read_24_IMM(A) g65816i_read_24_immediate(A) +#define read_24_D(A) g65816i_read_24_direct(A) +#define read_24_A(A) g65816i_read_24_normal(A) +#define read_24_AL(A) g65816i_read_24_normal(A) +#define read_24_DX(A) g65816i_read_24_direct(A) +#define read_24_DY(A) g65816i_read_24_direct(A) +#define read_24_AX(A) g65816i_read_24_normal(A) +#define read_24_ALX(A) g65816i_read_24_normal(A) +#define read_24_AY(A) g65816i_read_24_normal(A) +#define read_24_DI(A) g65816i_read_24_normal(A) +#define read_24_DLI(A) g65816i_read_24_normal(A) +#define read_24_AI(A) g65816i_read_24_normal(A) +#define read_24_ALI(A) g65816i_read_24_normal(A) +#define read_24_DXI(A) g65816i_read_24_normal(A) +#define read_24_DIY(A) g65816i_read_24_normal(A) +#define read_24_DLIY(A) g65816i_read_24_normal(A) +#define read_24_AXI(A) g65816i_read_24_normal(A) +#define read_24_S(A) g65816i_read_24_normal(A) +#define read_24_SIY(A) g65816i_read_24_normal(A) + +#define write_8_NORM(A, V) g65816i_write_8_normal(A, V) +#define write_8_D(A, V) g65816i_write_8_direct(A, V) +#define write_8_A(A, V) g65816i_write_8_normal(A, V) +#define write_8_AL(A, V) g65816i_write_8_normal(A, V) +#define write_8_DX(A, V) g65816i_write_8_direct(A, V) +#define write_8_DY(A, V) g65816i_write_8_direct(A, V) +#define write_8_AX(A, V) g65816i_write_8_normal(A, V) +#define write_8_ALX(A, V) g65816i_write_8_normal(A, V) +#define write_8_AY(A, V) g65816i_write_8_normal(A, V) +#define write_8_DI(A, V) g65816i_write_8_normal(A, V) +#define write_8_DLI(A, V) g65816i_write_8_normal(A, V) +#define write_8_AI(A, V) g65816i_write_8_normal(A, V) +#define write_8_ALI(A, V) g65816i_write_8_normal(A, V) +#define write_8_DXI(A, V) g65816i_write_8_normal(A, V) +#define write_8_DIY(A, V) g65816i_write_8_normal(A, V) +#define write_8_DLIY(A, V) g65816i_write_8_normal(A, V) +#define write_8_AXI(A, V) g65816i_write_8_normal(A, V) +#define write_8_S(A, V) g65816i_write_8_normal(A, V) +#define write_8_SIY(A, V) g65816i_write_8_normal(A, V) + +#define write_16_NORM(A, V) g65816i_write_16_normal(A, V) +#define write_16_D(A, V) g65816i_write_16_direct(A, V) +#define write_16_A(A, V) g65816i_write_16_normal(A, V) +#define write_16_AL(A, V) g65816i_write_16_normal(A, V) +#define write_16_DX(A, V) g65816i_write_16_direct(A, V) +#define write_16_DY(A, V) g65816i_write_16_direct(A, V) +#define write_16_AX(A, V) g65816i_write_16_normal(A, V) +#define write_16_ALX(A, V) g65816i_write_16_normal(A, V) +#define write_16_AY(A, V) g65816i_write_16_normal(A, V) +#define write_16_DI(A, V) g65816i_write_16_normal(A, V) +#define write_16_DLI(A, V) g65816i_write_16_normal(A, V) +#define write_16_AI(A, V) g65816i_write_16_normal(A, V) +#define write_16_ALI(A, V) g65816i_write_16_normal(A, V) +#define write_16_DXI(A, V) g65816i_write_16_normal(A, V) +#define write_16_DIY(A, V) g65816i_write_16_normal(A, V) +#define write_16_DLIY(A, V) g65816i_write_16_normal(A, V) +#define write_16_AXI(A, V) g65816i_write_16_normal(A, V) +#define write_16_S(A, V) g65816i_write_16_normal(A, V) +#define write_16_SIY(A, V) g65816i_write_16_normal(A, V) + + +#define OPER_8_IMM() read_8_IMM(EA_IMM8()) +#define OPER_8_D() read_8_D(EA_D()) +#define OPER_8_A() read_8_A(EA_A()) +#define OPER_8_AL() read_8_AL(EA_AL()) +#define OPER_8_DX() read_8_DX(EA_DX()) +#define OPER_8_DY() read_8_DY(EA_DY()) +#define OPER_8_AX() read_8_AX(EA_AX()) +#define OPER_8_ALX() read_8_ALX(EA_ALX()) +#define OPER_8_AY() read_8_AY(EA_AY()) +#define OPER_8_DI() read_8_DI(EA_DI()) +#define OPER_8_DLI() read_8_DLI(EA_DLI()) +#define OPER_8_AI() read_8_AI(EA_AI()) +#define OPER_8_ALI() read_8_ALI(EA_ALI()) +#define OPER_8_DXI() read_8_DXI(EA_DXI()) +#define OPER_8_DIY() read_8_DIY(EA_DIY()) +#define OPER_8_DLIY() read_8_DLIY(EA_DLIY()) +#define OPER_8_AXI() read_8_AXI(EA_AXI()) +#define OPER_8_S() read_8_S(EA_S()) +#define OPER_8_SIY() read_8_SIY(EA_SIY()) + +#define OPER_16_IMM() read_16_IMM(EA_IMM16()) +#define OPER_16_D() read_16_D(EA_D()) +#define OPER_16_A() read_16_A(EA_A()) +#define OPER_16_AL() read_16_AL(EA_AL()) +#define OPER_16_DX() read_16_DX(EA_DX()) +#define OPER_16_DY() read_16_DY(EA_DY()) +#define OPER_16_AX() read_16_AX(EA_AX()) +#define OPER_16_ALX() read_16_ALX(EA_ALX()) +#define OPER_16_AY() read_16_AY(EA_AY()) +#define OPER_16_DI() read_16_DI(EA_DI()) +#define OPER_16_DLI() read_16_DLI(EA_DLI()) +#define OPER_16_AI() read_16_AI(EA_AI()) +#define OPER_16_ALI() read_16_ALI(EA_ALI()) +#define OPER_16_DXI() read_16_DXI(EA_DXI()) +#define OPER_16_DIY() read_16_DIY(EA_DIY()) +#define OPER_16_DLIY() read_16_DLIY(EA_DLIY()) +#define OPER_16_AXI() read_16_AXI(EA_AXI()) +#define OPER_16_S() read_16_S(EA_S()) +#define OPER_16_SIY() read_16_SIY(EA_SIY()) + +#define OPER_24_IMM() read_24_IMM(EA_IMM24()) +#define OPER_24_D() read_24_D(EA_D()) +#define OPER_24_A() read_24_A(EA_A()) +#define OPER_24_AL() read_24_AL(EA_AL()) +#define OPER_24_DX() read_24_DX(EA_DX()) +#define OPER_24_DY() read_24_DY(EA_DY()) +#define OPER_24_AX() read_24_AX(EA_AX()) +#define OPER_24_ALX() read_24_ALX(EA_ALX()) +#define OPER_24_AY() read_24_AY(EA_AY()) +#define OPER_24_DI() read_24_DI(EA_DI()) +#define OPER_24_DLI() read_24_DLI(EA_DLI()) +#define OPER_24_AI() read_24_AI(EA_AI()) +#define OPER_24_ALI() read_24_ALI(EA_ALI()) +#define OPER_24_DXI() read_24_DXI(EA_DXI()) +#define OPER_24_DIY() read_24_DIY(EA_DIY()) +#define OPER_24_DLIY() read_24_DLIY(EA_DLIY()) +#define OPER_24_AXI() read_24_AXI(EA_AXI()) +#define OPER_24_S() read_24_S(EA_S()) +#define OPER_24_SIY() read_24_SIY(EA_SIY()) @@ -660,7 +232,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ { \ unsigned tmp16; \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - SRC = OPER_8_##MODE(cpustate); \ + SRC = OPER_8_##MODE(); \ if(FLAG_D) \ { \ INT32 result, r0, r1, carry; \ @@ -688,7 +260,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #else #define OP_ADC(MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - SRC = OPER_16_##MODE(cpustate); \ + SRC = OPER_16_##MODE(); \ INT32 result, r0, r1, carry; \ r0 = REGISTER_A; \ r1 = SRC; \ @@ -723,11 +295,11 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_AND(MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - FLAG_N = FLAG_Z = REGISTER_A &= OPER_8_##MODE(cpustate) + FLAG_N = FLAG_Z = REGISTER_A &= OPER_8_##MODE() #else #define OP_AND(MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - FLAG_Z = REGISTER_A &= OPER_16_##MODE(cpustate); \ + FLAG_Z = REGISTER_A &= OPER_16_##MODE(); \ FLAG_N = NFLAG_16(REGISTER_A) #endif @@ -752,14 +324,14 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_ASLM(MODE) \ CLK(CLK_OP + CLK_RMW8 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_C = read_8_##MODE(DST) << 1; \ FLAG_N = FLAG_Z = MAKE_UINT_8(FLAG_C); \ write_8_##MODE(DST, FLAG_Z) #else #define OP_ASLM(MODE) \ CLK(CLK_OP + CLK_RMW16 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_C = read_16_##MODE(DST) << 1; \ FLAG_Z = MAKE_UINT_16(FLAG_C); \ FLAG_N = NFLAG_16(FLAG_C); \ @@ -770,11 +342,11 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ /* M6502 Branch on Condition Code */ #undef OP_BCC #define OP_BCC(COND) \ - DST = OPER_8_IMM(cpustate); \ + DST = OPER_8_IMM(); \ if(COND) \ { \ CLK(CLK_OP + CLK_RELATIVE_8 + 1); \ - g65816i_branch_8(cpustate, DST); \ + g65816i_branch_8(DST); \ BREAKOUT; \ } \ CLK(CLK_OP + CLK_RELATIVE_8); @@ -783,13 +355,13 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_BIT(MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - FLAG_N = OPER_8_##MODE(cpustate); \ + FLAG_N = OPER_8_##MODE(); \ FLAG_Z = FLAG_N & REGISTER_A; \ FLAG_V = FLAG_N << 1 #else #define OP_BIT(MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - FLAG_N = OPER_16_##MODE(cpustate); \ + FLAG_N = OPER_16_##MODE(); \ FLAG_Z = FLAG_N & REGISTER_A; \ FLAG_N = NFLAG_16(FLAG_N); \ FLAG_V = FLAG_N << 1 @@ -800,30 +372,30 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_BITI() \ CLK(CLK_OP + CLK_R8 + CLK_IMM); \ - FLAG_Z = REGISTER_A & OPER_8_IMM(cpustate) + FLAG_Z = REGISTER_A & OPER_8_IMM() #else #define OP_BITI() \ CLK(CLK_OP + CLK_R16 + CLK_IMM); \ - FLAG_Z = REGISTER_A & OPER_16_IMM(cpustate) + FLAG_Z = REGISTER_A & OPER_16_IMM() #endif /* M6502 Cause a Break interrupt */ #undef OP_BRK #define OP_BRK() \ REGISTER_PC++; \ - g65816i_interrupt_software(cpustate, VECTOR_BRK) + g65816i_interrupt_software(VECTOR_BRK) /* G65816 Branch Always */ #undef OP_BRA #define OP_BRA() \ CLK(CLK_OP + CLK_IMPLIED + CLK_RELATIVE_8); \ - g65816i_branch_8(cpustate, OPER_8_IMM(cpustate)) + g65816i_branch_8(OPER_8_IMM()) /* G65816 Branch Always Long */ #undef OP_BRL #define OP_BRL() \ CLK(CLK_OP + CLK_IMPLIED + CLK_RELATIVE_16); \ - g65816i_branch_16(cpustate, OPER_16_IMM(cpustate)) + g65816i_branch_16(OPER_16_IMM()) /* M6502 Clear Carry flag */ #undef OP_CLC @@ -841,7 +413,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #undef OP_CLI #define OP_CLI() \ CLK(CLK_OP + CLK_IMPLIED); \ - g65816i_set_flag_i(cpustate, IFLAG_CLEAR) + g65816i_set_flag_i(IFLAG_CLEAR) /* M6502 Clear oVerflow flag */ #undef OP_CLV @@ -855,13 +427,13 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_CMP(MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - FLAG_C = REGISTER_A - OPER_8_##MODE(cpustate); \ + FLAG_C = REGISTER_A - OPER_8_##MODE(); \ FLAG_N = FLAG_Z = MAKE_UINT_8(FLAG_C); \ FLAG_C ^= CFLAG_SET #else #define OP_CMP(MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - FLAG_C = REGISTER_A - OPER_16_##MODE(cpustate); \ + FLAG_C = REGISTER_A - OPER_16_##MODE(); \ FLAG_Z = MAKE_UINT_16(FLAG_C); \ FLAG_N = NFLAG_16(FLAG_C); \ FLAG_C = ~CFLAG_16(FLAG_C) @@ -873,13 +445,13 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_X #define OP_CMPX(REG, MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - FLAG_C = REG - OPER_8_##MODE(cpustate); \ + FLAG_C = REG - OPER_8_##MODE(); \ FLAG_N = FLAG_Z = MAKE_UINT_8(FLAG_C); \ FLAG_C ^= CFLAG_SET #else #define OP_CMPX(REG, MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - FLAG_C = REG - OPER_16_##MODE(cpustate); \ + FLAG_C = REG - OPER_16_##MODE(); \ FLAG_Z = MAKE_UINT_16(FLAG_C); \ FLAG_N = NFLAG_16(FLAG_C); \ FLAG_C = ~CFLAG_16(FLAG_C) @@ -889,7 +461,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #undef OP_COP #define OP_COP() \ REGISTER_PC++; \ - g65816i_interrupt_software(cpustate, VECTOR_COP) + g65816i_interrupt_software(VECTOR_COP) /* M6502 Decrement accumulator */ #undef OP_DEC @@ -909,13 +481,13 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_DECM(MODE) \ CLK(CLK_OP + CLK_RMW8 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_N = FLAG_Z = MAKE_UINT_8(read_8_##MODE(DST) - 1); \ write_8_##MODE(DST, FLAG_Z) #else #define OP_DECM(MODE) \ CLK(CLK_OP + CLK_RMW16 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_Z = MAKE_UINT_16(read_16_##MODE(DST) - 1); \ FLAG_N = NFLAG_16(FLAG_Z); \ write_16_##MODE(DST, FLAG_Z) @@ -939,11 +511,11 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_EOR(MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - FLAG_N = FLAG_Z = REGISTER_A ^= OPER_8_##MODE(cpustate) + FLAG_N = FLAG_Z = REGISTER_A ^= OPER_8_##MODE() #else #define OP_EOR(MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - FLAG_Z = REGISTER_A ^= OPER_16_##MODE(cpustate); \ + FLAG_Z = REGISTER_A ^= OPER_16_##MODE(); \ FLAG_N = NFLAG_16(REGISTER_A) #endif @@ -965,13 +537,13 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_INCM(MODE) \ CLK(CLK_OP + CLK_RMW8 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_N = FLAG_Z = MAKE_UINT_8(read_8_##MODE(DST) + 1); \ write_8_##MODE(DST, FLAG_Z) #else #define OP_INCM(MODE) \ CLK(CLK_OP + CLK_RMW16 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_Z = MAKE_UINT_16(read_16_##MODE(DST) + 1); \ FLAG_N = NFLAG_16(FLAG_Z); \ write_16_##MODE(DST, FLAG_Z) @@ -994,64 +566,64 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #undef OP_JMLAI #define OP_JMLAI() \ CLK(CLK_OP + CLK_AI + 1); \ - g65816i_jump_24(cpustate, read_24_A(OPER_16_IMM(cpustate))) + g65816i_jump_24(read_24_A(OPER_16_IMM())) /* M6502 Jump */ #undef OP_JMP #define OP_JMP(MODE) \ CLK(CLK_OP + CLK_##MODE); \ - g65816i_jump_16(cpustate, EA_##MODE(cpustate)) + g65816i_jump_16(EA_##MODE()) /* M6502 Jump absolute indexed indirect */ #undef OP_JMPAXI #define OP_JMPAXI() \ CLK(CLK_OP + CLK_AXI); \ - g65816i_jump_16(cpustate, read_16_AXI(REGISTER_PB | (MAKE_UINT_16(OPER_16_IMM(cpustate) + REGISTER_X)))) + g65816i_jump_16(read_16_AXI(REGISTER_PB | (MAKE_UINT_16(OPER_16_IMM() + REGISTER_X)))) /* G65816 Jump absolute long */ #undef OP_JMPAL #define OP_JMPAL() \ CLK(CLK_OP + CLK_AL); \ - g65816i_jump_24(cpustate, EA_AL(cpustate)) + g65816i_jump_24(EA_AL()) /* G65816 Jump to Subroutine Long */ /* Unusual behavior: stacks PC-1 */ #undef OP_JSL #define OP_JSL(MODE) \ CLK(CLK_OP + CLK_W24 + CLK_##MODE + 1); \ - DST = EA_##MODE(cpustate); \ - g65816i_push_8(cpustate, REGISTER_PB>>16); \ - g65816i_push_16(cpustate, REGISTER_PC-1); \ - g65816i_jump_24(cpustate, DST) + DST = EA_##MODE(); \ + g65816i_push_8(REGISTER_PB>>16); \ + g65816i_push_16(REGISTER_PC-1); \ + g65816i_jump_24(DST) /* M6502 Jump to Subroutine */ /* Unusual behavior: stacks PC-1 */ #undef OP_JSR #define OP_JSR(MODE) \ CLK(CLK_OP + CLK_W16 + CLK_##MODE); \ - DST = EA_##MODE(cpustate); \ - g65816i_push_16(cpustate, REGISTER_PC-1); \ - g65816i_jump_16(cpustate, DST) + DST = EA_##MODE(); \ + g65816i_push_16(REGISTER_PC-1); \ + g65816i_jump_16(DST) /* M6502 Jump to Subroutine */ /* Unusual behavior: stacks PC-1 */ #undef OP_JSRAXI #define OP_JSRAXI() \ CLK(CLK_OP + CLK_W16 + CLK_AXI); \ - DST = read_16_AXI(REGISTER_PB | (MAKE_UINT_16(OPER_16_IMM(cpustate) + REGISTER_X))); \ - g65816i_push_16(cpustate, REGISTER_PC-1); \ - g65816i_jump_16(cpustate, DST) + DST = read_16_AXI(REGISTER_PB | (MAKE_UINT_16(OPER_16_IMM() + REGISTER_X))); \ + g65816i_push_16(REGISTER_PC-1); \ + g65816i_jump_16(DST) /* M6502 Load accumulator with operand */ #undef OP_LDA #if FLAG_SET_M #define OP_LDA(MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - FLAG_N = FLAG_Z = REGISTER_A = OPER_8_##MODE(cpustate) + FLAG_N = FLAG_Z = REGISTER_A = OPER_8_##MODE() #else #define OP_LDA(MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - FLAG_Z = REGISTER_A = OPER_16_##MODE(cpustate); \ + FLAG_Z = REGISTER_A = OPER_16_##MODE(); \ FLAG_N = NFLAG_16(REGISTER_A) #endif @@ -1060,11 +632,11 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_X #define OP_LDX(REG, MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - FLAG_N = FLAG_Z = REG = OPER_8_##MODE(cpustate) + FLAG_N = FLAG_Z = REG = OPER_8_##MODE() #else #define OP_LDX(REG, MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - FLAG_Z = REG = OPER_16_##MODE(cpustate); \ + FLAG_Z = REG = OPER_16_##MODE(); \ FLAG_N = NFLAG_16(REG) #endif @@ -1089,7 +661,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_LSRM(MODE) \ CLK(CLK_OP + CLK_RMW8 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_N = 0; \ FLAG_Z = read_8_##MODE(DST); \ FLAG_C = FLAG_Z << 8; \ @@ -1098,7 +670,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #else #define OP_LSRM(MODE) \ CLK(CLK_OP + CLK_RMW16 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_N = 0; \ FLAG_Z = read_16_##MODE(DST); \ FLAG_C = FLAG_Z << 8; \ @@ -1111,8 +683,8 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #if FLAG_SET_X #define OP_MVN() \ - DST = OPER_8_IMM(cpustate)<<16; \ - SRC = OPER_8_IMM(cpustate)<<16; \ + DST = OPER_8_IMM()<<16; \ + SRC = OPER_8_IMM()<<16; \ REGISTER_DB = DST; \ CLK(7); \ write_8_NORM(DST | REGISTER_Y, read_8_NORM(SRC | REGISTER_X)); \ @@ -1135,8 +707,8 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ } #else #define OP_MVN() \ - DST = OPER_8_IMM(cpustate)<<16; \ - SRC = OPER_8_IMM(cpustate)<<16; \ + DST = OPER_8_IMM()<<16; \ + SRC = OPER_8_IMM()<<16; \ REGISTER_DB = DST; \ CLK(7); \ write_8_NORM(DST | REGISTER_Y, read_8_NORM(SRC | REGISTER_X)); \ @@ -1161,8 +733,8 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #else #if FLAG_SET_X #define OP_MVN() \ - DST = OPER_8_IMM(cpustate)<<16; \ - SRC = OPER_8_IMM(cpustate)<<16; \ + DST = OPER_8_IMM()<<16; \ + SRC = OPER_8_IMM()<<16; \ REGISTER_DB = DST; \ REGISTER_A |= REGISTER_B; \ CLK(7); \ @@ -1176,8 +748,8 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ } #else #define OP_MVN() \ - DST = OPER_8_IMM(cpustate)<<16; \ - SRC = OPER_8_IMM(cpustate)<<16; \ + DST = OPER_8_IMM()<<16; \ + SRC = OPER_8_IMM()<<16; \ REGISTER_DB = DST; \ REGISTER_A |= REGISTER_B; \ CLK(7); \ @@ -1197,8 +769,8 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #if FLAG_SET_X #define OP_MVP() \ - DST = OPER_8_IMM(cpustate)<<16; \ - SRC = OPER_8_IMM(cpustate)<<16; \ + DST = OPER_8_IMM()<<16; \ + SRC = OPER_8_IMM()<<16; \ REGISTER_DB = DST; \ CLK(7); \ write_8_NORM(DST | REGISTER_Y, read_8_NORM(SRC | REGISTER_X)); \ @@ -1221,8 +793,8 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ } #else #define OP_MVP() \ - DST = OPER_8_IMM(cpustate)<<16; \ - SRC = OPER_8_IMM(cpustate)<<16; \ + DST = OPER_8_IMM()<<16; \ + SRC = OPER_8_IMM()<<16; \ REGISTER_DB = DST; \ CLK(7); \ write_8_NORM(DST | REGISTER_Y, read_8_NORM(SRC | REGISTER_X)); \ @@ -1247,8 +819,8 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #else #if FLAG_SET_X #define OP_MVP() \ - DST = OPER_8_IMM(cpustate)<<16; \ - SRC = OPER_8_IMM(cpustate)<<16; \ + DST = OPER_8_IMM()<<16; \ + SRC = OPER_8_IMM()<<16; \ REGISTER_DB = DST; \ REGISTER_A |= REGISTER_B; \ CLK(7); \ @@ -1262,8 +834,8 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ } #else #define OP_MVP() \ - DST = OPER_8_IMM(cpustate)<<16; \ - SRC = OPER_8_IMM(cpustate)<<16; \ + DST = OPER_8_IMM()<<16; \ + SRC = OPER_8_IMM()<<16; \ REGISTER_DB = DST; \ REGISTER_A |= REGISTER_B; \ CLK(7); \ @@ -1288,11 +860,11 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_ORA(MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - FLAG_N = FLAG_Z = REGISTER_A |= OPER_8_ ## MODE(cpustate) + FLAG_N = FLAG_Z = REGISTER_A |= OPER_8_ ## MODE() #else #define OP_ORA(MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - FLAG_Z = REGISTER_A |= OPER_16_##MODE(cpustate); \ + FLAG_Z = REGISTER_A |= OPER_16_##MODE(); \ FLAG_N = NFLAG_16(REGISTER_A) #endif @@ -1300,31 +872,31 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #undef OP_PEA #define OP_PEA() \ CLK(CLK_OP + CLK_R16 + CLK_W16); \ - g65816i_push_16(cpustate, OPER_16_IMM(cpustate)) + g65816i_push_16(OPER_16_IMM()) /* G65816 Push Effective Indirect Address */ #undef OP_PEI #define OP_PEI() \ CLK(CLK_OP + CLK_R16 + CLK_W16 + CLK_D); \ - g65816i_push_16(cpustate, EA_DI(cpustate)) + g65816i_push_16(EA_DI()) /* G65816 Push Effective PC-Relative Address */ #undef OP_PER #define OP_PER() \ CLK(CLK_OP + CLK_R16 + CLK_W16 + 1); \ - SRC = OPER_16_IMM(cpustate); \ - g65816i_push_16(cpustate, REGISTER_PC + SRC) + SRC = OPER_16_IMM(); \ + g65816i_push_16(REGISTER_PC + SRC) /* M6502 Push accumulator to the stack */ #undef OP_PHA #if FLAG_SET_M #define OP_PHA() \ CLK(CLK_OP + CLK_W8 + 1); \ - g65816i_push_8(cpustate, REGISTER_A) + g65816i_push_8(REGISTER_A) #else #define OP_PHA() \ CLK(CLK_OP + CLK_W16 + 1); \ - g65816i_push_16(cpustate, REGISTER_A) + g65816i_push_16(REGISTER_A) #endif /* M6502 Push index register to the stack */ @@ -1332,47 +904,47 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_X #define OP_PHX(REG) \ CLK(CLK_OP + CLK_W8 + 1); \ - g65816i_push_8(cpustate, REG) + g65816i_push_8(REG) #else #define OP_PHX(REG) \ CLK(CLK_OP + CLK_W16 + 1); \ - g65816i_push_16(cpustate, REG) + g65816i_push_16(REG) #endif /* G65816 Push data bank register */ #undef OP_PHB #define OP_PHB() \ CLK(CLK_OP + CLK_W8 + 1); \ - g65816i_push_8(cpustate, REGISTER_DB>>16) + g65816i_push_8(REGISTER_DB>>16) /* G65816 Push direct register */ #undef OP_PHD #define OP_PHD() \ CLK(CLK_OP + CLK_W16 + 1); \ - g65816i_push_16(cpustate, REGISTER_D) + g65816i_push_16(REGISTER_D) /* G65816 Push program bank register */ #undef OP_PHK #define OP_PHK() \ CLK(CLK_OP + CLK_W8 + 1); \ - g65816i_push_8(cpustate, REGISTER_PB>>16) + g65816i_push_8(REGISTER_PB>>16) /* M6502 Push the Processor Status Register to the stack */ #undef OP_PHP #define OP_PHP() \ CLK(CLK_OP + CLK_W8 + 1); \ - g65816i_push_8(cpustate, g65816i_get_reg_p(cpustate)) + g65816i_push_8(g65816i_get_reg_p()) /* M6502 Pull accumulator from the stack */ #undef OP_PLA #if FLAG_SET_M #define OP_PLA() \ CLK(CLK_OP + CLK_R8 + 2); \ - FLAG_N = FLAG_Z = REGISTER_A = g65816i_pull_8(cpustate) + FLAG_N = FLAG_Z = REGISTER_A = g65816i_pull_8() #else #define OP_PLA() \ CLK(CLK_OP + CLK_R16 + 2); \ - FLAG_Z = REGISTER_A = g65816i_pull_16(cpustate); \ + FLAG_Z = REGISTER_A = g65816i_pull_16(); \ FLAG_N = NFLAG_16(FLAG_Z) #endif @@ -1381,11 +953,11 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_X #define OP_PLX(REG) \ CLK(CLK_OP + CLK_R8 + 2); \ - FLAG_N = FLAG_Z = REG = g65816i_pull_8(cpustate) + FLAG_N = FLAG_Z = REG = g65816i_pull_8() #else #define OP_PLX(REG) \ CLK(CLK_OP + CLK_R16 + 2); \ - FLAG_Z = REG = g65816i_pull_16(cpustate); \ + FLAG_Z = REG = g65816i_pull_16(); \ FLAG_N = NFLAG_16(FLAG_Z) #endif @@ -1393,27 +965,27 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #undef OP_PLB #define OP_PLB() \ CLK(CLK_OP + CLK_R8 + 2); \ - FLAG_N = FLAG_Z = g65816i_pull_8(cpustate); \ + FLAG_N = FLAG_Z = g65816i_pull_8(); \ REGISTER_DB = FLAG_Z << 16 /* G65816 Pull direct register */ #undef OP_PLD #define OP_PLD() \ CLK(CLK_OP + CLK_R16 + 2); \ - FLAG_Z = REGISTER_D = g65816i_pull_16(cpustate); \ + FLAG_Z = REGISTER_D = g65816i_pull_16(); \ FLAG_N = NFLAG_16(FLAG_Z) /* M6502 Pull the Processor Status Register from the stack */ #undef OP_PLP #define OP_PLP() \ CLK(CLK_OP + CLK_R8 + 2); \ - g65816i_set_reg_p(cpustate, g65816i_pull_8(cpustate)) + g65816i_set_reg_p(g65816i_pull_8()) /* G65816 Reset Program status word */ #undef OP_REP #define OP_REP() \ CLK(CLK_OP + CLK_R8 + 1); \ - g65816i_set_reg_p(cpustate, g65816i_get_reg_p(cpustate) & ~OPER_8_IMM(cpustate)) + g65816i_set_reg_p(g65816i_get_reg_p() & ~OPER_8_IMM()) /* M6502 Rotate Left the accumulator */ #undef OP_ROL @@ -1436,14 +1008,14 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_ROLM(MODE) \ CLK(CLK_OP + CLK_RMW8 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_C = (read_8_##MODE(DST)<<1) | CFLAG_AS_1(); \ FLAG_N = FLAG_Z = MAKE_UINT_8(FLAG_C); \ write_8_##MODE(DST, FLAG_Z) #else #define OP_ROLM(MODE) \ CLK(CLK_OP + CLK_RMW16 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_C = (read_16_##MODE(DST)<<1) | CFLAG_AS_1(); \ FLAG_Z = MAKE_UINT_16(FLAG_C); \ FLAG_N = NFLAG_16(FLAG_C); \ @@ -1473,7 +1045,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_RORM(MODE) \ CLK(CLK_OP + CLK_RMW8 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_Z = read_8_##MODE(DST) | (FLAG_C & 0x100); \ FLAG_C = FLAG_Z << 8; \ FLAG_N = FLAG_Z >>= 1; \ @@ -1481,7 +1053,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #else #define OP_RORM(MODE) \ CLK(CLK_OP + CLK_RMW16 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_Z = read_16_##MODE(DST) | ((FLAG_C<<8) & 0x10000); \ FLAG_C = FLAG_Z << 8; \ FLAG_Z >>= 1; \ @@ -1494,14 +1066,14 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_E #define OP_RTI() \ CLK(7); \ - g65816i_set_reg_p(cpustate, g65816i_pull_8(cpustate)); \ - g65816i_jump_16(cpustate, g65816i_pull_16(cpustate)) + g65816i_set_reg_p(g65816i_pull_8()); \ + g65816i_jump_16(g65816i_pull_16()) #else #define OP_RTI() \ CLK(8); \ - g65816i_set_reg_p(cpustate, g65816i_pull_8(cpustate)); \ - g65816i_jump_16(cpustate, g65816i_pull_16(cpustate)); \ - REGISTER_PB = g65816i_pull_8(cpustate) << 16 + g65816i_set_reg_p(g65816i_pull_8()); \ + g65816i_jump_16(g65816i_pull_16()); \ + REGISTER_PB = g65816i_pull_8() << 16 #endif /* G65816 Return from Subroutine Long */ @@ -1509,14 +1081,14 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #undef OP_RTL #define OP_RTL() \ CLK(6); \ - g65816i_jump_24(cpustate, g65816i_pull_24(cpustate)) + g65816i_jump_24(g65816i_pull_24()) /* M6502 Return from Subroutine */ /* Unusual behavior: Gets PC and increments */ #undef OP_RTS #define OP_RTS() \ CLK(6); \ - g65816i_jump_16(cpustate, g65816i_pull_16(cpustate)+1) + g65816i_jump_16(g65816i_pull_16()+1) /* M6502 Subtract with Carry */ /* Unusual behavior: C flag is inverted */ @@ -1524,7 +1096,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_SBC(MODE) \ CLK(CLK_OP + CLK_R8 + CLK_##MODE); \ - SRC = OPER_8_##MODE(cpustate); \ + SRC = OPER_8_##MODE(); \ if(!FLAG_D) \ { \ FLAG_C = ~FLAG_C; \ @@ -1554,7 +1126,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #else #define OP_SBC(MODE) \ CLK(CLK_OP + CLK_R16 + CLK_##MODE); \ - SRC = OPER_16_##MODE(cpustate); \ + SRC = OPER_16_##MODE(); \ INT32 result, r0, r1, carry; \ r0 = REGISTER_A; \ r1 = SRC; \ @@ -1602,24 +1174,24 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #undef OP_SEI #define OP_SEI() \ CLK(CLK_OP + CLK_IMPLIED); \ - g65816i_set_flag_i(cpustate, IFLAG_SET) + g65816i_set_flag_i(IFLAG_SET) /* G65816 Set Program status word */ #undef OP_SEP #define OP_SEP() \ CLK(CLK_OP + CLK_R8 + 1); \ - g65816i_set_reg_p(cpustate, g65816i_get_reg_p(cpustate) | OPER_8_IMM(cpustate)) + g65816i_set_reg_p(g65816i_get_reg_p() | OPER_8_IMM()) /* M6502 Store accumulator to memory */ #undef OP_STA #if FLAG_SET_M #define OP_STA(MODE) \ CLK(CLK_OP + CLK_W8 + CLK_W_##MODE); \ - write_8_##MODE(EA_##MODE(cpustate), REGISTER_A) + write_8_##MODE(EA_##MODE(), REGISTER_A) #else #define OP_STA(MODE) \ CLK(CLK_OP + CLK_W16 + CLK_W_##MODE); \ - write_16_##MODE(EA_##MODE(cpustate), REGISTER_A) + write_16_##MODE(EA_##MODE(), REGISTER_A) #endif /* M6502 Store index register to memory */ @@ -1627,11 +1199,11 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_X #define OP_STX(REG, MODE) \ CLK(CLK_OP + CLK_W8 + CLK_W_##MODE); \ - write_8_##MODE(EA_##MODE(cpustate), REG) + write_8_##MODE(EA_##MODE(), REG) #else #define OP_STX(REG, MODE) \ CLK(CLK_OP + CLK_W16 + CLK_W_##MODE); \ - write_16_##MODE(EA_##MODE(cpustate), REG) + write_16_##MODE(EA_##MODE(), REG) #endif /* M6502 Store zero to memory */ @@ -1639,11 +1211,11 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_STZ(MODE) \ CLK(CLK_OP + CLK_W8 + CLK_W_##MODE); \ - write_8_##MODE(EA_##MODE(cpustate), 0) + write_8_##MODE(EA_##MODE(), 0) #else #define OP_STZ(MODE) \ CLK(CLK_OP + CLK_W16 + CLK_W_##MODE); \ - write_16_##MODE(EA_##MODE(cpustate), 0) + write_16_##MODE(EA_##MODE(), 0) #endif /* G65816 Stop the clock */ @@ -1812,14 +1384,14 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_TRB(MODE) \ CLK(CLK_OP + CLK_RMW8 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_Z = read_8_##MODE(DST); \ write_8_##MODE(DST, FLAG_Z & ~REGISTER_A); \ FLAG_Z &= REGISTER_A #else #define OP_TRB(MODE) \ CLK(CLK_OP + CLK_RMW16 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_Z = read_16_##MODE(DST); \ write_16_##MODE(DST, FLAG_Z & ~REGISTER_A); \ FLAG_Z &= REGISTER_A @@ -1830,14 +1402,14 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #if FLAG_SET_M #define OP_TSB(MODE) \ CLK(CLK_OP + CLK_RMW8 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_Z = read_8_##MODE(DST); \ write_8_##MODE(DST, FLAG_Z | REGISTER_A); \ FLAG_Z &= REGISTER_A #else #define OP_TSB(MODE) \ CLK(CLK_OP + CLK_RMW16 + CLK_W_##MODE); \ - DST = EA_##MODE(cpustate); \ + DST = EA_##MODE(); \ FLAG_Z = read_16_##MODE(DST); \ write_16_##MODE(DST, FLAG_Z | REGISTER_A); \ FLAG_Z &= REGISTER_A @@ -1878,7 +1450,7 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ CLK(CLK_OP + CLK_IMPLIED); \ SRC = CFLAG_AS_1(); \ FLAG_C = FLAG_E<<8; \ - g65816i_set_flag_e(cpustate, SRC) + g65816i_set_flag_e(SRC) @@ -1893,39 +1465,39 @@ INLINE uint EA_SIY(g65816i_cpu_struct *cpustate) {return MAKE_UINT_16(read_16_ #undef TABLE_FUNCTION #if FLAG_SET_E -#define OP(CODE, OPERATION) static void g65816i_ ## CODE ## _E(g65816i_cpu_struct *cpustate) {OPERATION;} -#define O(CODE) g65816i_ ## CODE ## _E -#define TABLE_OPCODES void (*const g65816i_opcodes_E[256])(g65816i_cpu_struct *cpustate) -#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816i_ ## NAME ## _E ARGS +#define OP(CODE, OPERATION) void g65816_device::g65816i_ ## CODE ## _E() {OPERATION;} +#define O(CODE) &g65816_device::g65816i_ ## CODE ## _E +#define TABLE_OPCODES const g65816_device::opcode_func g65816_device::g65816i_opcodes_E[256] +#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816_device::g65816i_ ## NAME ## _E ARGS #else #if !FLAG_SET_M && !FLAG_SET_X -#define OP(CODE, OPERATION) static void g65816i_ ## CODE ## _M0X0(g65816i_cpu_struct *cpustate) {OPERATION;} -#define O(CODE) g65816i_ ## CODE ## _M0X0 -#define TABLE_OPCODES void (*const g65816i_opcodes_M0X0[256])(g65816i_cpu_struct *cpustate) -#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816i_ ## NAME ## _M0X0 ARGS +#define OP(CODE, OPERATION) void g65816_device::g65816i_ ## CODE ## _M0X0() {OPERATION;} +#define O(CODE) &g65816_device::g65816i_ ## CODE ## _M0X0 +#define TABLE_OPCODES const g65816_device::opcode_func g65816_device::g65816i_opcodes_M0X0[256] +#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816_device::g65816i_ ## NAME ## _M0X0 ARGS #elif !FLAG_SET_M && FLAG_SET_X -#define OP(CODE, OPERATION) static void g65816i_ ## CODE ## _M0X1(g65816i_cpu_struct *cpustate) {OPERATION;} -#define O(CODE) g65816i_ ## CODE ## _M0X1 -#define TABLE_OPCODES void (*const g65816i_opcodes_M0X1[256])(g65816i_cpu_struct *cpustate) -#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816i_ ## NAME ## _M0X1 ARGS +#define OP(CODE, OPERATION) void g65816_device::g65816i_ ## CODE ## _M0X1() {OPERATION;} +#define O(CODE) &g65816_device::g65816i_ ## CODE ## _M0X1 +#define TABLE_OPCODES const g65816_device::opcode_func g65816_device::g65816i_opcodes_M0X1[256] +#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816_device::g65816i_ ## NAME ## _M0X1 ARGS #elif FLAG_SET_M && !FLAG_SET_X -#define OP(CODE, OPERATION) static void g65816i_ ## CODE ## _M1X0(g65816i_cpu_struct *cpustate) {OPERATION;} -#define O(CODE) g65816i_ ## CODE ## _M1X0 -#define TABLE_OPCODES void (*const g65816i_opcodes_M1X0[256])(g65816i_cpu_struct *cpustate) -#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816i_ ## NAME ## _M1X0 ARGS +#define OP(CODE, OPERATION) void g65816_device::g65816i_ ## CODE ## _M1X0() {OPERATION;} +#define O(CODE) &g65816_device::g65816i_ ## CODE ## _M1X0 +#define TABLE_OPCODES const g65816_device::opcode_func g65816_device::g65816i_opcodes_M1X0[256] +#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816_device::g65816i_ ## NAME ## _M1X0 ARGS #elif FLAG_SET_M && FLAG_SET_X -#define OP(CODE, OPERATION) static void g65816i_ ## CODE ## _M1X1(g65816i_cpu_struct *cpustate) {OPERATION;} -#define O(CODE) g65816i_ ## CODE ## _M1X1 -#define TABLE_OPCODES void (*const g65816i_opcodes_M1X1[256])(g65816i_cpu_struct *cpustate) -#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816i_ ## NAME ## _M1X1 ARGS +#define OP(CODE, OPERATION) void g65816_device::g65816i_ ## CODE ## _M1X1() {OPERATION;} +#define O(CODE) &g65816_device::g65816i_ ## CODE ## _M1X1 +#define TABLE_OPCODES const g65816_device::opcode_func g65816_device::g65816i_opcodes_M1X1[256] +#define TABLE_FUNCTION(RTYPE, NAME, ARGS) RTYPE g65816_device::g65816i_ ## NAME ## _M1X1 ARGS #endif #endif @@ -2193,7 +1765,6 @@ OP(ff, OP_SBC ( ALX ) ) /* SBC alx (G) */ -extern TABLE_OPCODES; TABLE_OPCODES = { O(00),O(01),O(02),O(03),O(04),O(05),O(06),O(07), @@ -2233,7 +1804,7 @@ TABLE_OPCODES = /* Assert or clear a line on the CPU */ -TABLE_FUNCTION(void, set_line, (g65816i_cpu_struct *cpustate, int line, int state)) +TABLE_FUNCTION(void, set_line, (int line, int state)) { switch(line) { @@ -2267,7 +1838,7 @@ TABLE_FUNCTION(void, set_line, (g65816i_cpu_struct *cpustate, int line, int stat LINE_NMI = 1; CPU_STOPPED &= ~STOP_LEVEL_WAI; if(!CPU_STOPPED) - g65816i_interrupt_nmi(cpustate); + g65816i_interrupt_nmi(); } return; case G65816_LINE_SO: @@ -2285,7 +1856,7 @@ TABLE_FUNCTION(void, set_line, (g65816i_cpu_struct *cpustate, int line, int stat /* Get a register from the CPU core */ -TABLE_FUNCTION(uint, get_reg, (g65816i_cpu_struct *cpustate, int regnum)) +TABLE_FUNCTION(uint, get_reg, (int regnum)) { switch(regnum) { @@ -2299,18 +1870,18 @@ TABLE_FUNCTION(uint, get_reg, (g65816i_cpu_struct *cpustate, int regnum)) case G65816_PB: return REGISTER_PB >> 16; case G65816_DB: return REGISTER_DB >> 16; case G65816_D: return REGISTER_D; - case G65816_P: return g65816i_get_reg_p(cpustate); + case G65816_P: return g65816i_get_reg_p(); case G65816_NMI_STATE: return LINE_NMI; case G65816_IRQ_STATE: return LINE_IRQ; case STATE_GENPCBASE: return REGISTER_PPC; - case _5A22_FASTROM: return cpustate->fastROM; + case _5A22_FASTROM: return m_fastROM; } return 0; } -TABLE_FUNCTION(void, set_reg, (g65816i_cpu_struct *cpustate, int regnum, uint val)) +TABLE_FUNCTION(void, set_reg, (int regnum, uint val)) { switch(regnum) { @@ -2320,7 +1891,7 @@ TABLE_FUNCTION(void, set_reg, (g65816i_cpu_struct *cpustate, int regnum, uint va #else case STATE_GENSP: case G65816_S: REGISTER_S = MAKE_UINT_16(val); break; #endif - case G65816_P: g65816i_set_reg_p(cpustate, val); break; + case G65816_P: g65816i_set_reg_p(val); break; #if FLAG_SET_M case G65816_A: REGISTER_A = MAKE_UINT_8(val); REGISTER_B = val&0xff00; break; #else @@ -2335,37 +1906,34 @@ TABLE_FUNCTION(void, set_reg, (g65816i_cpu_struct *cpustate, int regnum, uint va #endif case G65816_DB: REGISTER_DB = MAKE_UINT_8(val); break; case G65816_PB: REGISTER_PB = MAKE_UINT_8(val); break; - case G65816_NMI_STATE: FTABLE_SET_LINE(cpustate, G65816_LINE_NMI, val == 0 ? CLEAR_LINE : ASSERT_LINE); break; - case G65816_IRQ_STATE: FTABLE_SET_LINE(cpustate, G65816_LINE_IRQ, val == 0 ? CLEAR_LINE : ASSERT_LINE); break; - case _5A22_FASTROM: cpustate->fastROM = val; break; + case G65816_NMI_STATE: (this->*FTABLE_SET_LINE)(G65816_LINE_NMI, val == 0 ? CLEAR_LINE : ASSERT_LINE); break; + case G65816_IRQ_STATE: (this->*FTABLE_SET_LINE)(G65816_LINE_IRQ, val == 0 ? CLEAR_LINE : ASSERT_LINE); break; + case _5A22_FASTROM: m_fastROM = val; break; } } -INLINE int g65816i_correct_mode(g65816i_cpu_struct *cpustate) -{ #if EXECUTION_MODE == EXECUTION_MODE_E - return (FLAG_E == EFLAG_SET); +#define g65816i_correct_mode() (FLAG_E == EFLAG_SET) #elif EXECUTION_MODE == EXECUTION_MODE_M0X0 - return (FLAG_E == EFLAG_CLEAR) && (FLAG_M == MFLAG_CLEAR) && (FLAG_X == XFLAG_CLEAR); +#define g65816i_correct_mode() ((FLAG_E == EFLAG_CLEAR) && (FLAG_M == MFLAG_CLEAR) && (FLAG_X == XFLAG_CLEAR)) #elif EXECUTION_MODE == EXECUTION_MODE_M0X1 - return (FLAG_E == EFLAG_CLEAR) && (FLAG_M == MFLAG_CLEAR) && (FLAG_X == XFLAG_SET); +#define g65816i_correct_mode() ((FLAG_E == EFLAG_CLEAR) && (FLAG_M == MFLAG_CLEAR) && (FLAG_X == XFLAG_SET)) #elif EXECUTION_MODE == EXECUTION_MODE_M1X0 - return (FLAG_E == EFLAG_CLEAR) && (FLAG_M == MFLAG_SET) && (FLAG_X == XFLAG_CLEAR); +#define g65816i_correct_mode() ((FLAG_E == EFLAG_CLEAR) && (FLAG_M == MFLAG_SET) && (FLAG_X == XFLAG_CLEAR)) #elif EXECUTION_MODE == EXECUTION_MODE_M1X1 - return (FLAG_E == EFLAG_CLEAR) && (FLAG_M == MFLAG_SET) && (FLAG_X == XFLAG_SET); +#define g65816i_correct_mode() ((FLAG_E == EFLAG_CLEAR) && (FLAG_M == MFLAG_SET) && (FLAG_X == XFLAG_SET)) #else #error Invalid EXECUTION_MODE #endif -} -TABLE_FUNCTION(int, execute, (g65816i_cpu_struct *cpustate, int clocks)) +TABLE_FUNCTION(int, execute, (int clocks)) { // do a check here also in case we're in STOP_WAI mode - this'll clear it when the IRQ happens - g65816i_check_maskable_interrupt(cpustate); + g65816i_check_maskable_interrupt(); if (!CPU_STOPPED) { @@ -2376,15 +1944,15 @@ TABLE_FUNCTION(int, execute, (g65816i_cpu_struct *cpustate, int clocks)) * check until this core is working well enough * to start trying fancy stuff. */ - g65816i_check_maskable_interrupt(cpustate); + g65816i_check_maskable_interrupt(); REGISTER_PPC = REGISTER_PC; G65816_CALL_DEBUGGER(REGISTER_PB | REGISTER_PC); REGISTER_PC++; REGISTER_IR = read_8_IMM(REGISTER_PB | REGISTER_PPC); - FTABLE_OPCODES[REGISTER_IR](cpustate); - } while((CLOCKS > 0) && g65816i_correct_mode(cpustate)); + (this->*FTABLE_OPCODES[REGISTER_IR])(); + } while((CLOCKS > 0) && g65816i_correct_mode()); return clocks - CLOCKS; } return clocks; diff --git a/src/mess/includes/apple2gs.h b/src/mess/includes/apple2gs.h index fe5fc22638f..21d368af060 100644 --- a/src/mess/includes/apple2gs.h +++ b/src/mess/includes/apple2gs.h @@ -14,6 +14,7 @@ #include "includes/apple2.h" #include "sound/es5503.h" #include "machine/nvram.h" +#include "cpu/g65816/g65816.h" #if RUN_ADB_MICRO #include "cpu/m6502/m5074x.h" #endif @@ -102,7 +103,7 @@ public: m_palette(*this, "palette") { } - required_device<cpu_device> m_maincpu; + required_device<g65816_device> m_maincpu; required_device<es5503_device> m_es5503; required_device<applefdc_base_device> m_fdc; #if RUN_ADB_MICRO diff --git a/src/mess/machine/apple2gs.c b/src/mess/machine/apple2gs.c index c5b717b939e..ab7226879bd 100644 --- a/src/mess/machine/apple2gs.c +++ b/src/mess/machine/apple2gs.c @@ -2002,7 +2002,7 @@ MACHINE_START_MEMBER(apple2gs_state,apple2gscommon) apple2eplus_init_common(NULL); /* set up Apple IIgs vectoring */ - g65816_set_read_vector_callback(m_maincpu, read8_delegate(FUNC(apple2gs_state::apple2gs_read_vector),this)); + m_maincpu->set_read_vector_callback(read8_delegate(FUNC(apple2gs_state::apple2gs_read_vector),this)); /* setup globals */ m_is_rom3 = true; |