summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
-rw-r--r--src/emu/cpu/g65816/g65816.c1183
-rw-r--r--src/emu/cpu/g65816/g65816.h1490
-rw-r--r--src/emu/cpu/g65816/g65816cm.h169
-rw-r--r--src/emu/cpu/g65816/g65816op.h1060
-rw-r--r--src/mess/includes/apple2gs.h3
-rw-r--r--src/mess/machine/apple2gs.c2
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;