diff --git a/src/emu/cpu/lr35902/lr35902.c b/src/emu/cpu/lr35902/lr35902.c index bc0885fb36d..04b182de438 100644 --- a/src/emu/cpu/lr35902/lr35902.c +++ b/src/emu/cpu/lr35902/lr35902.c @@ -41,98 +41,144 @@ #include "debugger.h" #include "lr35902.h" -#define FLAG_Z 0x80 -#define FLAG_N 0x40 -#define FLAG_H 0x20 -#define FLAG_C 0x10 - -#define CYCLES_PASSED(X) cpustate->icount -= ((X) / (cpustate->gb_speed)); \ - if ( cpustate->timer_expired_func ) { \ - cpustate->timer_expired_func( cpustate->device, X ); \ - } - -typedef struct _lr35902_state { - UINT8 A; - UINT8 F; - UINT8 B; - UINT8 C; - UINT8 D; - UINT8 E; - UINT8 H; - UINT8 L; - - UINT16 SP; - UINT16 PC; - /* Interrupt related */ - UINT8 IE; - UINT8 IF; - int irq_state; - int ei_delay; - device_irq_callback irq_callback; - legacy_cpu_device *device; - address_space *program; - int icount; - /* Timer stuff */ - lr35902_timer_fired_func timer_expired_func; - /* Fetch & execute related */ - int execution_state; - UINT8 op; - /* Others */ - int gb_speed; - int gb_speed_change_pending; - int enable; - int doHALTbug; - UINT8 features; - const lr35902_cpu_core *config; -} lr35902_state; - -INLINE lr35902_state *get_safe_token(device_t *device) -{ - assert(device != NULL); - assert(device->type() == LR35902); - return (lr35902_state *)downcast(device)->token(); -} - -typedef int (*OpcodeEmulator) (lr35902_state *cpustate); #define IME 0x01 -#define HALTED 0x02 +#define HALTED 0x02 + + +//************************************************************************** +// LR35902 DEVICE +//************************************************************************** + +const device_type LR35902 = &device_creator; + + +lr35902_cpu_device::lr35902_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : cpu_device(mconfig, LR35902, "LR35902", tag, owner, clock), + m_program_config("program", ENDIANNESS_LITTLE, 8, 16, 0) +{ + c_regs = NULL; + c_features = 0; + c_timer_expired_func = NULL; +} + + +void lr35902_cpu_device::static_set_config(device_t &device, const lr35902_config &config) +{ + lr35902_cpu_device &conf = downcast(device); + static_cast(conf) = config; +} + /****************************************************************************/ /* Memory functions */ /****************************************************************************/ -#define mem_ReadByte(cs,A) ((UINT8)(cs)->program->read_byte(A)); CYCLES_PASSED(4); -#define mem_WriteByte(cs,A,V) ((cs)->program->write_byte(A,V)); CYCLES_PASSED(4); - -INLINE UINT8 mem_ReadOp(lr35902_state *cpustate) +inline void lr35902_cpu_device::cycles_passed(UINT8 cycles) { - UINT8 r = mem_ReadByte (cpustate, cpustate->PC++); - return r; + m_icount -= cycles / m_gb_speed; + if ( m_timer_expired_func ) + { + m_timer_expired_func( this, cycles ); + } } -INLINE UINT16 mem_ReadWord (lr35902_state *cpustate, UINT32 address) + +inline UINT8 lr35902_cpu_device::mem_read_byte( UINT16 addr ) { - UINT16 value = mem_ReadByte (cpustate, (address + 1) & 0xffff); - value <<= 8; - value |= mem_ReadByte (cpustate, address); - return value; + UINT8 data = m_program->read_byte( addr ); + cycles_passed( 4 ); + return data; } -INLINE void mem_WriteWord (lr35902_state *cpustate, UINT32 address, UINT16 value) + +inline void lr35902_cpu_device::mem_write_byte( UINT16 addr, UINT8 data ) { - mem_WriteByte (cpustate, address, value & 0xFF); - mem_WriteByte (cpustate, (address + 1) & 0xffff, value >> 8); + m_program->write_byte( addr, data ); + cycles_passed( 4 ); } -static CPU_INIT( lr35902 ) -{ - lr35902_state *cpustate = get_safe_token(device); - cpustate->config = (const lr35902_cpu_core *) device->static_config(); - cpustate->irq_callback = irqcallback; - cpustate->device = device; - cpustate->program = device->space(AS_PROGRAM); +inline UINT16 lr35902_cpu_device::mem_read_word( UINT16 addr ) +{ + UINT16 data = mem_read_byte( addr ); + data |= ( mem_read_byte( addr + 1 ) << 8 ); + return data; +} + + +inline void lr35902_cpu_device::mem_write_word( UINT16 addr, UINT16 data ) +{ + mem_write_byte( addr, data & 0xFF ); + mem_write_byte( addr + 1, data >> 8 ); +} + + +void lr35902_cpu_device::device_start() +{ + m_device = this; + m_program = this->space(AS_PROGRAM); + + save_item(NAME(m_A)); + save_item(NAME(m_F)); + save_item(NAME(m_B)); + save_item(NAME(m_C)); + save_item(NAME(m_D)); + save_item(NAME(m_E)); + save_item(NAME(m_H)); + save_item(NAME(m_L)); + save_item(NAME(m_PC)); + save_item(NAME(m_SP)); + save_item(NAME(m_IE)); + save_item(NAME(m_IF)); + save_item(NAME(m_irq_state)); + save_item(NAME(m_ei_delay)); + save_item(NAME(m_execution_state)); + save_item(NAME(m_op)); + save_item(NAME(m_gb_speed)); + save_item(NAME(m_gb_speed_change_pending)); + save_item(NAME(m_enable)); + save_item(NAME(m_doHALTbug)); + + // Register state for debugger + state_add( LR35902_PC, "PC", m_PC ).callimport().callexport().formatstr("%04X"); + state_add( LR35902_SP, "SP", m_SP ).callimport().callexport().formatstr("%04X"); + state_add( LR35902_A, "A", m_A ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_F, "F", m_F ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_B, "B", m_B ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_C, "C", m_C ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_D, "D", m_D ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_E, "E", m_E ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_H, "H", m_H ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_L, "L", m_L ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_IRQ_STATE, "IRQ", m_enable ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_IE, "IE", m_IE ).callimport().callexport().formatstr("%02X"); + state_add( LR35902_IF, "IF", m_IF ).callimport().callexport().formatstr("%02X"); + + state_add(STATE_GENPC, "curpc", m_PC).callimport().callexport().formatstr("%8s").noshow(); + state_add(STATE_GENFLAGS, "GENFLAGS", m_F).mask(0xf0).formatstr("%8s").noshow(); + + m_icountptr = &m_icount; +} + + +void lr35902_cpu_device::state_string_export(const device_state_entry &entry, astring &string) +{ + switch (entry.index()) + { + case LR35902_SPEED: + string.printf("%02X", 0x7E | ( ( m_gb_speed - 1 ) << 7 ) | m_gb_speed_change_pending ); + break; + + case STATE_GENFLAGS: + string.printf("%c%c%c%c", + m_F & FLAG_Z ? 'Z' : '.', + m_F & FLAG_N ? 'N' : '.', + m_F & FLAG_H ? 'H' : '.', + m_F & FLAG_C ? 'C' : '.' + ); + break; + } } /*** Reset lr353902 registers: ******************************/ @@ -140,64 +186,68 @@ static CPU_INIT( lr35902 ) /*** file before starting execution with lr35902_execute(cpustate)***/ /*** It sets the registers to their initial values. ***/ /************************************************************/ -static CPU_RESET( lr35902 ) +void lr35902_cpu_device::device_reset() { - lr35902_state *cpustate = get_safe_token(device); - - cpustate->A = 0x00; - cpustate->F = 0x00; - cpustate->B = 0x00; - cpustate->C = 0x00; - cpustate->D = 0x00; - cpustate->E = 0x00; - cpustate->H = 0x00; - cpustate->L = 0x00; - cpustate->SP = 0x0000; - cpustate->PC = 0x0000; - cpustate->timer_expired_func = NULL; - cpustate->features = LR35902_FEATURE_HALT_BUG; - if (cpustate->config) - { - if ( cpustate->config->regs ) { - cpustate->A = cpustate->config->regs[0] >> 8; - cpustate->F = cpustate->config->regs[0] & 0xFF; - cpustate->B = cpustate->config->regs[1] >> 8; - cpustate->C = cpustate->config->regs[1] & 0xFF; - cpustate->D = cpustate->config->regs[2] >> 8; - cpustate->E = cpustate->config->regs[2] & 0xFF; - cpustate->H = cpustate->config->regs[3] >> 8; - cpustate->L = cpustate->config->regs[3] & 0xFF; - cpustate->SP = cpustate->config->regs[4]; - cpustate->PC = cpustate->config->regs[5]; - } - cpustate->timer_expired_func = cpustate->config->timer_expired_func; - cpustate->features = cpustate->config->features; + m_A = 0x00; + m_F = 0x00; + m_B = 0x00; + m_C = 0x00; + m_D = 0x00; + m_E = 0x00; + m_H = 0x00; + m_L = 0x00; + m_SP = 0x0000; + m_PC = 0x0000; + m_timer_expired_func = NULL; + m_features = LR35902_FEATURE_HALT_BUG; + if ( c_regs ) { + m_A = c_regs[0] >> 8; + m_F = c_regs[0] & 0xFF; + m_B = c_regs[1] >> 8; + m_C = c_regs[1] & 0xFF; + m_D = c_regs[2] >> 8; + m_E = c_regs[2] & 0xFF; + m_H = c_regs[3] >> 8; + m_L = c_regs[3] & 0xFF; + m_SP = c_regs[4]; + m_PC = c_regs[5]; } - cpustate->enable = 0; - cpustate->IE = 0; - cpustate->IF = 0; + m_timer_expired_func = c_timer_expired_func; + m_features = c_features; - cpustate->execution_state = 0; - cpustate->doHALTbug = 0; - cpustate->ei_delay = 0; - cpustate->gb_speed_change_pending = 0; - cpustate->gb_speed = 1; + m_enable = 0; + m_IE = 0; + m_IF = 0; + + m_execution_state = 0; + m_doHALTbug = 0; + m_ei_delay = 0; + m_gb_speed_change_pending = 0; + m_gb_speed = 1; } -INLINE void lr35902_ProcessInterrupts (lr35902_state *cpustate) + +offs_t lr35902_cpu_device::disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) { - UINT8 irq = cpustate->IE & cpustate->IF; + extern CPU_DISASSEMBLE( lr35902 ); + return CPU_DISASSEMBLE_NAME( lr35902 )(NULL, buffer, pc, oprom, opram, 0); +} + + +void lr35902_cpu_device::check_interrupts() +{ + UINT8 irq = m_IE & m_IF; /* Interrupts should be taken after the first instruction after an EI instruction */ - if (cpustate->ei_delay) { - cpustate->ei_delay = 0; + if (m_ei_delay) { + m_ei_delay = 0; return; } /* logerror("Attempting to process LR35902 Interrupt IRQ $%02X\n", irq); - logerror("Attempting to process LR35902 Interrupt IE $%02X\n", cpustate->IE); - logerror("Attempting to process LR35902 Interrupt IF $%02X\n", cpustate->IF); + logerror("Attempting to process LR35902 Interrupt IE $%02X\n", m_IE); + logerror("Attempting to process LR35902 Interrupt IF $%02X\n", m_IF); */ if (irq) { @@ -210,34 +260,32 @@ INLINE void lr35902_ProcessInterrupts (lr35902_state *cpustate) { if( irq & (1<enable & HALTED) + if (m_enable & HALTED) { - cpustate->enable &= ~HALTED; - cpustate->PC++; - if ( cpustate->features & LR35902_FEATURE_HALT_BUG ) { - if ( ! ( cpustate->enable & IME ) ) { + m_enable &= ~HALTED; + m_PC++; + if ( m_features & LR35902_FEATURE_HALT_BUG ) { + if ( ! ( m_enable & IME ) ) { /* Old cpu core (dmg/mgb/sgb) */ - cpustate->doHALTbug = 1; + m_doHALTbug = 1; } } else { /* New cpu core (cgb/agb/ags) */ /* Adjust for internal syncing with video core */ /* This feature needs more investigation */ if ( irqline < 2 ) { - CYCLES_PASSED( 4 ); + cycles_passed( 4 ); } } } - if ( cpustate->enable & IME ) { - if ( cpustate->irq_callback ) - (*cpustate->irq_callback)(cpustate->device, irqline); - cpustate->enable &= ~IME; - cpustate->IF &= ~(1 << irqline); - CYCLES_PASSED( 12 ); - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 0x40 + irqline * 8; - /*logerror("LR35902 Interrupt PC $%04X\n", cpustate->PC );*/ + if ( m_enable & IME ) { + m_enable &= ~IME; + m_IF &= ~(1 << irqline); + cycles_passed( 12 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 0x40 + irqline * 8; + /*logerror("LR35902 Interrupt PC $%04X\n", m_PC );*/ return; } } @@ -245,198 +293,63 @@ INLINE void lr35902_ProcessInterrupts (lr35902_state *cpustate) } } + /************************************************************/ /*** Execute lr35902 code for cycles cycles, return nr of ***/ /*** cycles actually executed. ***/ /************************************************************/ -static CPU_EXECUTE( lr35902 ) +void lr35902_cpu_device::execute_run() { - lr35902_state *cpustate = get_safe_token(device); - do { - if ( cpustate->execution_state ) { + if ( m_execution_state ) { UINT8 x; /* Execute instruction */ - switch( cpustate->op ) { + switch( m_op ) { #include "opc_main.h" } } else { /* Fetch and count cycles */ - lr35902_ProcessInterrupts (cpustate); - debugger_instruction_hook(device, cpustate->PC); - if ( cpustate->enable & HALTED ) { - CYCLES_PASSED( 4 ); - cpustate->execution_state = 1; + check_interrupts(); + debugger_instruction_hook(this, m_PC); + if ( m_enable & HALTED ) { + cycles_passed( 4 ); + m_execution_state = 1; } else { - cpustate->op = mem_ReadOp (cpustate); - if ( cpustate->doHALTbug ) { - cpustate->PC--; - cpustate->doHALTbug = 0; + m_op = mem_read_byte( m_PC++ ); + if ( m_doHALTbug ) { + m_PC--; + m_doHALTbug = 0; } } } - cpustate->execution_state ^= 1; - } while (cpustate->icount > 0); + m_execution_state ^= 1; + } while (m_icount > 0); } -static CPU_BURN( lr35902 ) + +void lr35902_cpu_device::execute_set_input( int inptnum, int state ) { - lr35902_state *cpustate = get_safe_token(device); - - if( cycles > 0 ) - { - /* NOP takes 4 cycles per instruction */ - int n = (cycles + 3) / 4; - cpustate->icount -= 4 * n; - } -} - -static void lr35902_set_irq_line (lr35902_state *cpustate, int irqline, int state) -{ - /*logerror("setting irq line 0x%02x state 0x%08x\n", irqline, state);*/ - //if( cpustate->irq_state == state ) - // return; - - cpustate->irq_state = state; + m_irq_state = state; if( state == ASSERT_LINE ) { - - cpustate->IF |= (0x01 << irqline); - /*logerror("LR35902 assert irq line %d ($%02X)\n", irqline, cpustate->IF);*/ - + m_IF |= (0x01 << inptnum); } else { - - cpustate->IF &= ~(0x01 << irqline); - /*logerror("LR35902 clear irq line %d ($%02X)\n", irqline, cpustate->IF);*/ - + m_IF &= ~(0x01 << inptnum); } } -#ifdef UNUSED_FUNCTION -static void lr35902_clear_pending_interrupts (lr35902_state *cpustate) + +UINT8 lr35902_cpu_device::get_speed() { - cpustate->IF = 0; -} -#endif - -static CPU_SET_INFO( lr35902 ) -{ - lr35902_state *cpustate = get_safe_token(device); - - switch (state) - { - /* --- the following bits of info are set as 64-bit signed integers --- */ - case CPUINFO_INT_INPUT_STATE + 0: - case CPUINFO_INT_INPUT_STATE + 1: - case CPUINFO_INT_INPUT_STATE + 2: - case CPUINFO_INT_INPUT_STATE + 3: - case CPUINFO_INT_INPUT_STATE + 4: lr35902_set_irq_line(cpustate, state-CPUINFO_INT_INPUT_STATE, info->i); break; - - case CPUINFO_INT_SP: cpustate->SP = info->i; break; - case CPUINFO_INT_PC: cpustate->PC = info->i; break; - - case CPUINFO_INT_REGISTER + LR35902_PC: cpustate->PC = info->i; break; - case CPUINFO_INT_REGISTER + LR35902_SP: cpustate->SP = info->i; break; - case CPUINFO_INT_REGISTER + LR35902_AF: cpustate->A = info->i >> 8; cpustate->F = info->i & 0xFF; break; - case CPUINFO_INT_REGISTER + LR35902_BC: cpustate->B = info->i >> 8; cpustate->C = info->i & 0xFF; break; - case CPUINFO_INT_REGISTER + LR35902_DE: cpustate->D = info->i >> 8; cpustate->E = info->i & 0xFF; break; - case CPUINFO_INT_REGISTER + LR35902_HL: cpustate->H = info->i >> 8; cpustate->L = info->i & 0xFF; break; - case CPUINFO_INT_REGISTER + LR35902_IE: cpustate->IE = info->i; break; - case CPUINFO_INT_REGISTER + LR35902_IF: cpustate->IF = info->i; break; - case CPUINFO_INT_REGISTER + LR35902_SPEED: cpustate->gb_speed_change_pending = info->i & 0x01; break; - } + return 0x7E | ( ( m_gb_speed - 1 ) << 7 ) | m_gb_speed_change_pending; } -CPU_GET_INFO( lr35902 ) + +void lr35902_cpu_device::set_speed( UINT8 speed_request ) { - lr35902_state *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(lr35902_state); break; - case CPUINFO_INT_INPUT_LINES: info->i = 5; break; - case CPUINFO_INT_DEFAULT_IRQ_VECTOR: info->i = 0xff; break; - case DEVINFO_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; /* right? */ break; - case CPUINFO_INT_MAX_CYCLES: info->i = 16; /* right? */ break; - - case DEVINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 8; break; - case DEVINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 16; break; - case DEVINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = 0; break; - case DEVINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 0; break; - case DEVINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 0; break; - case DEVINFO_INT_ADDRBUS_SHIFT + AS_DATA: info->i = 0; break; - case DEVINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 8; break; - case DEVINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 16; break; - case DEVINFO_INT_ADDRBUS_SHIFT + AS_IO: info->i = 0; break; - - case CPUINFO_INT_SP: info->i = cpustate->SP; break; - case CPUINFO_INT_PC: info->i = cpustate->PC; break; - case CPUINFO_INT_PREVIOUSPC: info->i = 0; /* TODO??? */ break; - - case CPUINFO_INT_INPUT_STATE + 0: - case CPUINFO_INT_INPUT_STATE + 1: - case CPUINFO_INT_INPUT_STATE + 2: - case CPUINFO_INT_INPUT_STATE + 3: - case CPUINFO_INT_INPUT_STATE + 4: info->i = cpustate->IF & (1 << (state-CPUINFO_INT_INPUT_STATE)); break; - - case CPUINFO_INT_REGISTER + LR35902_PC: info->i = cpustate->PC; break; - case CPUINFO_INT_REGISTER + LR35902_SP: info->i = cpustate->SP; break; - case CPUINFO_INT_REGISTER + LR35902_AF: info->i = ( cpustate->A << 8 ) | cpustate->F; break; - case CPUINFO_INT_REGISTER + LR35902_BC: info->i = ( cpustate->B << 8 ) | cpustate->C; break; - case CPUINFO_INT_REGISTER + LR35902_DE: info->i = ( cpustate->D << 8 ) | cpustate->E; break; - case CPUINFO_INT_REGISTER + LR35902_HL: info->i = ( cpustate->H << 8 ) | cpustate->L; break; - case CPUINFO_INT_REGISTER + LR35902_IE: info->i = cpustate->IE; break; - case CPUINFO_INT_REGISTER + LR35902_IF: info->i = cpustate->IF; break; - case CPUINFO_INT_REGISTER + LR35902_SPEED: info->i = 0x7E | ( ( cpustate->gb_speed - 1 ) << 7 ) | cpustate->gb_speed_change_pending; 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(lr35902); break; - case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(lr35902); break; - case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(lr35902); break; - case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(lr35902); break; - case CPUINFO_FCT_BURN: info->burn = CPU_BURN_NAME(lr35902); break; - case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(lr35902); break; - case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->icount; break; - - /* --- the following bits of info are returned as NULL-terminated strings --- */ - case DEVINFO_STR_NAME: strcpy(info->s, "LR35902"); break; - case DEVINFO_STR_FAMILY: strcpy(info->s, "Sharp LR35902"); break; - case DEVINFO_STR_VERSION: strcpy(info->s, "1.4"); break; - case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; - case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright The MESS Team."); break; - - case CPUINFO_STR_FLAGS: - sprintf(info->s, "%c%c%c%c%c%c%c%c", - cpustate->F & 0x80 ? 'Z':'.', - cpustate->F & 0x40 ? 'N':'.', - cpustate->F & 0x20 ? 'H':'.', - cpustate->F & 0x10 ? 'C':'.', - cpustate->F & 0x08 ? '3':'.', - cpustate->F & 0x04 ? '2':'.', - cpustate->F & 0x02 ? '1':'.', - cpustate->F & 0x01 ? '0':'.'); - break; - - case CPUINFO_STR_REGISTER + LR35902_PC: sprintf(info->s, "PC:%04X", cpustate->PC); break; - case CPUINFO_STR_REGISTER + LR35902_SP: sprintf(info->s, "SP:%04X", cpustate->SP); break; - case CPUINFO_STR_REGISTER + LR35902_AF: sprintf(info->s, "AF:%02X%02X", cpustate->A, cpustate->F); break; - case CPUINFO_STR_REGISTER + LR35902_BC: sprintf(info->s, "BC:%02X%02X", cpustate->B, cpustate->C); break; - case CPUINFO_STR_REGISTER + LR35902_DE: sprintf(info->s, "DE:%02X%02X", cpustate->D, cpustate->E); break; - case CPUINFO_STR_REGISTER + LR35902_HL: sprintf(info->s, "HL:%02X%02X", cpustate->H, cpustate->L); break; - case CPUINFO_STR_REGISTER + LR35902_IRQ_STATE: sprintf(info->s, "IRQ:%X", cpustate->enable & IME ); break; - case CPUINFO_STR_REGISTER + LR35902_IE: sprintf(info->s, "IE:%02X", cpustate->IE); break; - case CPUINFO_STR_REGISTER + LR35902_IF: sprintf(info->s, "IF:%02X", cpustate->IF); break; - case CPUINFO_STR_REGISTER + LR35902_SPEED: sprintf(info->s, "SPD:%02x", 0x7E | ( ( cpustate->gb_speed - 1 ) << 7 ) | cpustate->gb_speed_change_pending ); break; - } + m_gb_speed_change_pending = speed_request & 0x01; } -DEFINE_LEGACY_CPU_DEVICE(LR35902, lr35902); diff --git a/src/emu/cpu/lr35902/lr35902.h b/src/emu/cpu/lr35902/lr35902.h index 54f5717de9a..47e03e1ae87 100644 --- a/src/emu/cpu/lr35902/lr35902.h +++ b/src/emu/cpu/lr35902/lr35902.h @@ -4,19 +4,24 @@ #define __LR35902_H__ -typedef void (*lr35902_timer_fired_func)(device_t *device, int cycles); +#define MCFG_LR35902_CONFIG(_config) \ + lr35902_cpu_device::static_set_config(*device, _config); -typedef struct _lr35902_cpu_core lr35902_cpu_core; -struct _lr35902_cpu_core +class lr35902_cpu_device; + +// Perhaps replace this with a standard device callback +typedef void (*lr35902_timer_fired_func)(lr35902_cpu_device *device, int cycles); + +struct lr35902_config { - const UINT16 *regs; - UINT8 features; - lr35902_timer_fired_func timer_expired_func; + const UINT16 *c_regs; + UINT8 c_features; + lr35902_timer_fired_func c_timer_expired_func; }; enum { - LR35902_PC=1, LR35902_SP, LR35902_AF, LR35902_BC, LR35902_DE, LR35902_HL, + LR35902_PC=1, LR35902_SP, LR35902_A, LR35902_F, LR35902_B, LR35902_C, LR35902_D, LR35902_E, LR35902_H, LR35902_L, LR35902_IRQ_STATE, /* Pseudo registers to keep track of the interrupt statuses */ LR35902_IE, LR35902_IF, @@ -24,13 +29,100 @@ enum LR35902_SPEED, }; +// This and the features configuration could be removed if we introduce proper subclasses #define LR35902_FEATURE_HALT_BUG 0x01 -/****************************************************************************/ -/* Return register contents */ -/****************************************************************************/ -DECLARE_LEGACY_CPU_DEVICE(LR35902, lr35902); -extern CPU_DISASSEMBLE( lr35902 ); +class lr35902_cpu_device : public cpu_device, + public lr35902_config +{ +public: + // construction/destruction + lr35902_cpu_device(const machine_config &mconfig, const char *_tag, device_t *_owner, UINT32 _clock); + + static void static_set_config(device_t &device, const lr35902_config &config); + + UINT8 get_speed(); + void set_speed( UINT8 speed_request ); + + UINT8 get_ie() { return m_IE; } + void set_ie( UINT8 data ) { m_IE = data; } + + UINT8 get_if() { return m_IF; } + void set_if( UINT8 data ) { m_IF = data; } + +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 16; } + 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 + 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); + + inline void cycles_passed(UINT8 cycles); + inline UINT8 mem_read_byte(UINT16 addr); + inline void mem_write_byte(UINT16 addr, UINT8 data); + inline UINT16 mem_read_word(UINT16 addr); + inline void mem_write_word(UINT16 addr, UINT16 data); + inline void check_interrupts(); + +protected: + address_space_config m_program_config; + + UINT8 m_A; + UINT8 m_F; + UINT8 m_B; + UINT8 m_C; + UINT8 m_D; + UINT8 m_E; + UINT8 m_H; + UINT8 m_L; + + UINT16 m_SP; + UINT16 m_PC; + /* Interrupt related */ + UINT8 m_IE; + UINT8 m_IF; + int m_irq_state; + int m_ei_delay; + lr35902_cpu_device *m_device; + address_space *m_program; + int m_icount; + /* Timer stuff */ + lr35902_timer_fired_func m_timer_expired_func; + /* Fetch & execute related */ + int m_execution_state; + UINT8 m_op; + /* Others */ + int m_gb_speed; + int m_gb_speed_change_pending; + int m_enable; + int m_doHALTbug; + UINT8 m_features; + const struct lr35902_config *m_config; + + /* Flag bit definitions */ + static const UINT8 FLAG_Z = 0x80; + static const UINT8 FLAG_N = 0x40; + static const UINT8 FLAG_H = 0x20; + static const UINT8 FLAG_C = 0x10; +}; + +extern const device_type LR35902; #endif /* __LR35902_H__ */ diff --git a/src/emu/cpu/lr35902/opc_cb.h b/src/emu/cpu/lr35902/opc_cb.h index e2b106a610a..e01dd029246 100644 --- a/src/emu/cpu/lr35902/opc_cb.h +++ b/src/emu/cpu/lr35902/opc_cb.h @@ -8,17 +8,17 @@ f=0; \ if( (x)==0 ) \ f|=FLAG_Z; \ - cpustate->F=f; \ + m_F=f; \ } #define RL_8BIT(x) \ { \ register UINT8 r; \ r=((x)&0x80)?FLAG_C:0; \ - (x)=(UINT8)(((x)<<1)|((cpustate->F&FLAG_C)?1:0)); \ + (x)=(UINT8)(((x)<<1)|((m_F&FLAG_C)?1:0)); \ if( (x)==0 ) \ r|=FLAG_Z; \ - cpustate->F=r; \ + m_F=r; \ } #define RRC_8BIT(x) \ @@ -31,17 +31,17 @@ f=0; \ if( (x)==0 ) \ f|=FLAG_Z; \ - cpustate->F=f; \ + m_F=f; \ } #define RR_8BIT(x) \ { \ register UINT8 r; \ r=((x)&1)?FLAG_C:0; \ - (x)=(UINT8)(((x)>>1)|((cpustate->F&FLAG_C)?0x80:0)); \ + (x)=(UINT8)(((x)>>1)|((m_F&FLAG_C)?0x80:0)); \ if( (x)==0 ) \ r|=FLAG_Z; \ - cpustate->F=r; \ + m_F=r; \ } #define SLA_8BIT(x) \ @@ -54,7 +54,7 @@ (x)<<=1; \ if( (x)==0 ) \ f|=FLAG_Z; \ - cpustate->F=f; \ + m_F=f; \ } #define SRA_8BIT(x) \ @@ -67,15 +67,15 @@ (x)=(UINT8)(((char)(x))>>1); \ if( (x)==0 ) \ f|=FLAG_Z; \ - cpustate->F=f; \ + m_F=f; \ } #define SWAP_8BIT(x) \ (x)=(UINT8)(((x)>>4)|((x)<<4)); \ if( (x)==0 ) \ - cpustate->F=FLAG_Z; \ + m_F=FLAG_Z; \ else \ - cpustate->F=0; + m_F=0; #define SRL_8BIT(x) \ @@ -88,14 +88,14 @@ (x)>>=1; \ if( (x)==0 ) \ f|=FLAG_Z; \ - cpustate->F=f; \ + m_F=f; \ } #define BIT_8BIT(n,x) \ if( (x)&(1<<(n)) ) \ - cpustate->F=(UINT8)(FLAG_H|(cpustate->F&FLAG_C)); \ + m_F=(UINT8)(FLAG_H|(m_F&FLAG_C)); \ else \ - cpustate->F=(UINT8)(FLAG_Z|FLAG_H|(cpustate->F&FLAG_C)); + m_F=(UINT8)(FLAG_Z|FLAG_H|(m_F&FLAG_C)); #define RES_8BIT(n,x) (x)&=~(1<<(n)); @@ -105,1432 +105,1432 @@ case 0x00: /* RLC B */ - RLC_8BIT (cpustate->B) + RLC_8BIT (m_B) break; case 0x01: /* RLC C */ - RLC_8BIT (cpustate->C) + RLC_8BIT (m_C) break; case 0x02: /* RLC D */ - RLC_8BIT (cpustate->D) + RLC_8BIT (m_D) break; case 0x03: /* RLC E */ - RLC_8BIT (cpustate->E) + RLC_8BIT (m_E) break; case 0x04: /* RLC H */ - RLC_8BIT (cpustate->H) + RLC_8BIT (m_H) break; case 0x05: /* RLC L */ - RLC_8BIT (cpustate->L) + RLC_8BIT (m_L) break; case 0x06: /* RLC (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr ); RLC_8BIT (x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x ); } break; case 0x07: /* RLC A */ - RLC_8BIT (cpustate->A) + RLC_8BIT (m_A) break; case 0x08: /* RRC B */ - RRC_8BIT (cpustate->B) + RRC_8BIT (m_B) break; case 0x09: /* RRC C */ - RRC_8BIT (cpustate->C) + RRC_8BIT (m_C) break; case 0x0A: /* RRC D */ - RRC_8BIT (cpustate->D) + RRC_8BIT (m_D) break; case 0x0B: /* RRC E */ - RRC_8BIT (cpustate->E) + RRC_8BIT (m_E) break; case 0x0C: /* RRC H */ - RRC_8BIT (cpustate->H) + RRC_8BIT (m_H) break; case 0x0D: /* RRC L */ - RRC_8BIT (cpustate->L) + RRC_8BIT (m_L) break; case 0x0E: /* RRC (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RRC_8BIT (x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x0F: /* RRC A */ - RRC_8BIT (cpustate->A) + RRC_8BIT (m_A) break; case 0x10: /* RL B */ - RL_8BIT (cpustate->B) + RL_8BIT (m_B) break; case 0x11: /* RL C */ - RL_8BIT (cpustate->C) + RL_8BIT (m_C) break; case 0x12: /* RL D */ - RL_8BIT (cpustate->D) + RL_8BIT (m_D) break; case 0x13: /* RL E */ - RL_8BIT (cpustate->E) + RL_8BIT (m_E) break; case 0x14: /* RL H */ - RL_8BIT (cpustate->H) + RL_8BIT (m_H) break; case 0x15: /* RL L */ - RL_8BIT (cpustate->L) + RL_8BIT (m_L) break; case 0x16: /* RL (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RL_8BIT (x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x17: /* RL A */ - RL_8BIT (cpustate->A) + RL_8BIT (m_A) break; case 0x18: /* RR B */ - RR_8BIT (cpustate->B) + RR_8BIT (m_B) break; case 0x19: /* RR C */ - RR_8BIT (cpustate->C) + RR_8BIT (m_C) break; case 0x1A: /* RR D */ - RR_8BIT (cpustate->D) + RR_8BIT (m_D) break; case 0x1B: /* RR E */ - RR_8BIT (cpustate->E) + RR_8BIT (m_E) break; case 0x1C: /* RR H */ - RR_8BIT (cpustate->H) + RR_8BIT (m_H) break; case 0x1D: /* RR L */ - RR_8BIT (cpustate->L) + RR_8BIT (m_L) break; case 0x1E: /* RR (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RR_8BIT (x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x1F: /* RR A */ - RR_8BIT (cpustate->A) + RR_8BIT (m_A) break; case 0x20: /* SLA B */ - SLA_8BIT (cpustate->B) + SLA_8BIT (m_B) break; case 0x21: /* SLA C */ - SLA_8BIT (cpustate->C) + SLA_8BIT (m_C) break; case 0x22: /* SLA D */ - SLA_8BIT (cpustate->D) + SLA_8BIT (m_D) break; case 0x23: /* SLA E */ - SLA_8BIT (cpustate->E) + SLA_8BIT (m_E) break; case 0x24: /* SLA H */ - SLA_8BIT (cpustate->H) + SLA_8BIT (m_H) break; case 0x25: /* SLA L */ - SLA_8BIT (cpustate->L) + SLA_8BIT (m_L) break; case 0x26: /* SLA (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SLA_8BIT (x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x27: /* SLA A */ - SLA_8BIT (cpustate->A) + SLA_8BIT (m_A) break; case 0x28: /* SRA B */ - SRA_8BIT (cpustate->B) + SRA_8BIT (m_B) break; case 0x29: /* SRA C */ - SRA_8BIT (cpustate->C) + SRA_8BIT (m_C) break; case 0x2A: /* SRA D */ - SRA_8BIT (cpustate->D) + SRA_8BIT (m_D) break; case 0x2B: /* SRA E */ - SRA_8BIT (cpustate->E) + SRA_8BIT (m_E) break; case 0x2C: /* SRA H */ - SRA_8BIT (cpustate->H) + SRA_8BIT (m_H) break; case 0x2D: /* SRA L */ - SRA_8BIT (cpustate->L) + SRA_8BIT (m_L) break; case 0x2E: /* SRA (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SRA_8BIT (x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x2F: /* SRA A */ - SRA_8BIT (cpustate->A) + SRA_8BIT (m_A) break; case 0x30: /* SWAP B */ - SWAP_8BIT (cpustate->B) + SWAP_8BIT (m_B) break; case 0x31: /* SWAP C */ - SWAP_8BIT (cpustate->C) + SWAP_8BIT (m_C) break; case 0x32: /* SWAP D */ - SWAP_8BIT (cpustate->D) + SWAP_8BIT (m_D) break; case 0x33: /* SWAP E */ - SWAP_8BIT (cpustate->E) + SWAP_8BIT (m_E) break; case 0x34: /* SWAP H */ - SWAP_8BIT (cpustate->H) + SWAP_8BIT (m_H) break; case 0x35: /* SWAP L */ - SWAP_8BIT (cpustate->L) + SWAP_8BIT (m_L) break; case 0x36: /* SWAP (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SWAP_8BIT (x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x37: /* SWAP A */ - SWAP_8BIT (cpustate->A) + SWAP_8BIT (m_A) break; case 0x38: /* SRL B */ - SRL_8BIT (cpustate->B) + SRL_8BIT (m_B) break; case 0x39: /* SRL C */ - SRL_8BIT (cpustate->C) + SRL_8BIT (m_C) break; case 0x3A: /* SRL D */ - SRL_8BIT (cpustate->D) + SRL_8BIT (m_D) break; case 0x3B: /* SRL E */ - SRL_8BIT (cpustate->E) + SRL_8BIT (m_E) break; case 0x3C: /* SRL H */ - SRL_8BIT (cpustate->H) + SRL_8BIT (m_H) break; case 0x3D: /* SRL L */ - SRL_8BIT (cpustate->L) + SRL_8BIT (m_L) break; case 0x3E: /* SRL (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SRL_8BIT (x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x3F: /* SRL A */ - SRL_8BIT (cpustate->A) + SRL_8BIT (m_A) break; case 0x40: /* BIT 0,B */ - BIT_8BIT (0, cpustate->B) + BIT_8BIT (0, m_B) break; case 0x41: /* BIT 0,C */ - BIT_8BIT (0, cpustate->C) + BIT_8BIT (0, m_C) break; case 0x42: /* BIT 0,D */ - BIT_8BIT (0, cpustate->D) + BIT_8BIT (0, m_D) break; case 0x43: /* BIT 0,E */ - BIT_8BIT (0, cpustate->E) + BIT_8BIT (0, m_E) break; case 0x44: /* BIT 0,H */ - BIT_8BIT (0, cpustate->H) + BIT_8BIT (0, m_H) break; case 0x45: /* BIT 0,L */ - BIT_8BIT (0, cpustate->L) + BIT_8BIT (0, m_L) break; case 0x46: /* BIT 0,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); BIT_8BIT (0, x) } break; case 0x47: /* BIT 0,A */ - BIT_8BIT (0, cpustate->A) + BIT_8BIT (0, m_A) break; case 0x48: /* BIT 1,B */ - BIT_8BIT (1, cpustate->B) + BIT_8BIT (1, m_B) break; case 0x49: /* BIT 1,C */ - BIT_8BIT (1, cpustate->C) + BIT_8BIT (1, m_C) break; case 0x4A: /* BIT 1,D */ - BIT_8BIT (1, cpustate->D) + BIT_8BIT (1, m_D) break; case 0x4B: /* BIT 1,E */ - BIT_8BIT (1, cpustate->E) + BIT_8BIT (1, m_E) break; case 0x4C: /* BIT 1,H */ - BIT_8BIT (1, cpustate->H) + BIT_8BIT (1, m_H) break; case 0x4D: /* BIT 1,L */ - BIT_8BIT (1, cpustate->L) + BIT_8BIT (1, m_L) break; case 0x4E: /* BIT 1,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); BIT_8BIT (1, x) } break; case 0x4F: /* BIT 1,A */ - BIT_8BIT (1, cpustate->A) + BIT_8BIT (1, m_A) break; case 0x50: /* BIT 2,B */ - BIT_8BIT (2, cpustate->B) + BIT_8BIT (2, m_B) break; case 0x51: /* BIT 2,C */ - BIT_8BIT (2, cpustate->C) + BIT_8BIT (2, m_C) break; case 0x52: /* BIT 2,D */ - BIT_8BIT (2, cpustate->D) + BIT_8BIT (2, m_D) break; case 0x53: /* BIT 2,E */ - BIT_8BIT (2, cpustate->E) + BIT_8BIT (2, m_E) break; case 0x54: /* BIT 2,H */ - BIT_8BIT (2, cpustate->H) + BIT_8BIT (2, m_H) break; case 0x55: /* BIT 2,L */ - BIT_8BIT (2, cpustate->L) + BIT_8BIT (2, m_L) break; case 0x56: /* BIT 2,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); BIT_8BIT (2, x) } break; case 0x57: /* BIT 2,A */ - BIT_8BIT (2, cpustate->A) + BIT_8BIT (2, m_A) break; case 0x58: /* BIT 3,B */ - BIT_8BIT (3, cpustate->B) + BIT_8BIT (3, m_B) break; case 0x59: /* BIT 3,C */ - BIT_8BIT (3, cpustate->C) + BIT_8BIT (3, m_C) break; case 0x5A: /* BIT 3,D */ - BIT_8BIT (3, cpustate->D) + BIT_8BIT (3, m_D) break; case 0x5B: /* BIT 3,E */ - BIT_8BIT (3, cpustate->E) + BIT_8BIT (3, m_E) break; case 0x5C: /* BIT 3,H */ - BIT_8BIT (3, cpustate->H) + BIT_8BIT (3, m_H) break; case 0x5D: /* BIT 3,L */ - BIT_8BIT (3, cpustate->L) + BIT_8BIT (3, m_L) break; case 0x5E: /* BIT 3,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); BIT_8BIT (3, x) } break; case 0x5F: /* BIT 3,A */ - BIT_8BIT (3, cpustate->A) + BIT_8BIT (3, m_A) break; case 0x60: /* BIT 4,B */ - BIT_8BIT (4, cpustate->B) + BIT_8BIT (4, m_B) break; case 0x61: /* BIT 4,C */ - BIT_8BIT (4, cpustate->C) + BIT_8BIT (4, m_C) break; case 0x62: /* BIT 4,D */ - BIT_8BIT (4, cpustate->D) + BIT_8BIT (4, m_D) break; case 0x63: /* BIT 4,E */ - BIT_8BIT (4, cpustate->E) + BIT_8BIT (4, m_E) break; case 0x64: /* BIT 4,H */ - BIT_8BIT (4, cpustate->H) + BIT_8BIT (4, m_H) break; case 0x65: /* BIT 4,L */ - BIT_8BIT (4, cpustate->L) + BIT_8BIT (4, m_L) break; case 0x66: /* BIT 4,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); BIT_8BIT (4, x) } break; case 0x67: /* BIT 4,A */ - BIT_8BIT (4, cpustate->A) + BIT_8BIT (4, m_A) break; case 0x68: /* BIT 5,B */ - BIT_8BIT (5, cpustate->B) + BIT_8BIT (5, m_B) break; case 0x69: /* BIT 5,C */ - BIT_8BIT (5, cpustate->C) + BIT_8BIT (5, m_C) break; case 0x6A: /* BIT 5,D */ - BIT_8BIT (5, cpustate->D) + BIT_8BIT (5, m_D) break; case 0x6B: /* BIT 5,E */ - BIT_8BIT (5, cpustate->E) + BIT_8BIT (5, m_E) break; case 0x6C: /* BIT 5,H */ - BIT_8BIT (5, cpustate->H) + BIT_8BIT (5, m_H) break; case 0x6D: /* BIT 5,L */ - BIT_8BIT (5, cpustate->L) + BIT_8BIT (5, m_L) break; case 0x6E: /* BIT 5,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); BIT_8BIT (5, x) } break; case 0x6F: /* BIT 5,A */ - BIT_8BIT (5, cpustate->A) + BIT_8BIT (5, m_A) break; case 0x70: /* BIT 6,B */ - BIT_8BIT (6, cpustate->B) + BIT_8BIT (6, m_B) break; case 0x71: /* BIT 6,C */ - BIT_8BIT (6, cpustate->C) + BIT_8BIT (6, m_C) break; case 0x72: /* BIT 6,D */ - BIT_8BIT (6, cpustate->D) + BIT_8BIT (6, m_D) break; case 0x73: /* BIT 6,E */ - BIT_8BIT (6, cpustate->E) + BIT_8BIT (6, m_E) break; case 0x74: /* BIT 6,H */ - BIT_8BIT (6, cpustate->H) + BIT_8BIT (6, m_H) break; case 0x75: /* BIT 6,L */ - BIT_8BIT (6, cpustate->L) + BIT_8BIT (6, m_L) break; case 0x76: /* BIT 6,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); BIT_8BIT (6, x) } break; case 0x77: /* BIT 6,A */ - BIT_8BIT (6, cpustate->A) + BIT_8BIT (6, m_A) break; case 0x78: /* BIT 7,B */ - BIT_8BIT (7, cpustate->B) + BIT_8BIT (7, m_B) break; case 0x79: /* BIT 7,C */ - BIT_8BIT (7, cpustate->C) + BIT_8BIT (7, m_C) break; case 0x7A: /* BIT 7,D */ - BIT_8BIT (7, cpustate->D) + BIT_8BIT (7, m_D) break; case 0x7B: /* BIT 7,E */ - BIT_8BIT (7, cpustate->E) + BIT_8BIT (7, m_E) break; case 0x7C: /* BIT 7,H */ - BIT_8BIT (7, cpustate->H) + BIT_8BIT (7, m_H) break; case 0x7D: /* BIT 7,L */ - BIT_8BIT (7, cpustate->L) + BIT_8BIT (7, m_L) break; case 0x7E: /* BIT 7,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); BIT_8BIT (7, x) } break; case 0x7F: /* BIT 7,A */ - BIT_8BIT (7, cpustate->A) + BIT_8BIT (7, m_A) break; case 0x80: /* RES 0,B */ - RES_8BIT (0, cpustate->B) + RES_8BIT (0, m_B) break; case 0x81: /* RES 0,C */ - RES_8BIT (0, cpustate->C) + RES_8BIT (0, m_C) break; case 0x82: /* RES 0,D */ - RES_8BIT (0, cpustate->D) + RES_8BIT (0, m_D) break; case 0x83: /* RES 0,E */ - RES_8BIT (0, cpustate->E) + RES_8BIT (0, m_E) break; case 0x84: /* RES 0,H */ - RES_8BIT (0, cpustate->H) + RES_8BIT (0, m_H) break; case 0x85: /* RES 0,L */ - RES_8BIT (0, cpustate->L) + RES_8BIT (0, m_L) break; case 0x86: /* RES 0,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RES_8BIT (0, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x87: /* RES 0,A */ - RES_8BIT (0, cpustate->A) + RES_8BIT (0, m_A) break; case 0x88: /* RES 1,B */ - RES_8BIT (1, cpustate->B) + RES_8BIT (1, m_B) break; case 0x89: /* RES 1,C */ - RES_8BIT (1, cpustate->C) + RES_8BIT (1, m_C) break; case 0x8A: /* RES 1,D */ - RES_8BIT (1, cpustate->D) + RES_8BIT (1, m_D) break; case 0x8B: /* RES 1,E */ - RES_8BIT (1, cpustate->E) + RES_8BIT (1, m_E) break; case 0x8C: /* RES 1,H */ - RES_8BIT (1, cpustate->H) + RES_8BIT (1, m_H) break; case 0x8D: /* RES 1,L */ - RES_8BIT (1, cpustate->L) + RES_8BIT (1, m_L) break; case 0x8E: /* RES 1,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RES_8BIT (1, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x8F: /* RES 1,A */ - RES_8BIT (1, cpustate->A) + RES_8BIT (1, m_A) break; case 0x90: /* RES 2,B */ - RES_8BIT (2, cpustate->B) + RES_8BIT (2, m_B) break; case 0x91: /* RES 2,C */ - RES_8BIT (2, cpustate->C) + RES_8BIT (2, m_C) break; case 0x92: /* RES 2,D */ - RES_8BIT (2, cpustate->D) + RES_8BIT (2, m_D) break; case 0x93: /* RES 2,E */ - RES_8BIT (2, cpustate->E) + RES_8BIT (2, m_E) break; case 0x94: /* RES 2,H */ - RES_8BIT (2, cpustate->H) + RES_8BIT (2, m_H) break; case 0x95: /* RES 2,L */ - RES_8BIT (2, cpustate->L) + RES_8BIT (2, m_L) break; case 0x96: /* RES 2,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RES_8BIT (2, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x97: /* RES 2,A */ - RES_8BIT (2, cpustate->A) + RES_8BIT (2, m_A) break; case 0x98: /* RES 3,B */ - RES_8BIT (3, cpustate->B) + RES_8BIT (3, m_B) break; case 0x99: /* RES 3,C */ - RES_8BIT (3, cpustate->C) + RES_8BIT (3, m_C) break; case 0x9A: /* RES 3,D */ - RES_8BIT (3, cpustate->D) + RES_8BIT (3, m_D) break; case 0x9B: /* RES 3,E */ - RES_8BIT (3, cpustate->E) + RES_8BIT (3, m_E) break; case 0x9C: /* RES 3,H */ - RES_8BIT (3, cpustate->H) + RES_8BIT (3, m_H) break; case 0x9D: /* RES 3,L */ - RES_8BIT (3, cpustate->L) + RES_8BIT (3, m_L) break; case 0x9E: /* RES 3,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RES_8BIT (3, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0x9F: /* RES 3,A */ - RES_8BIT (3, cpustate->A) + RES_8BIT (3, m_A) break; case 0xA0: /* RES 4,B */ - RES_8BIT (4, cpustate->B) + RES_8BIT (4, m_B) break; case 0xA1: /* RES 4,C */ - RES_8BIT (4, cpustate->C) + RES_8BIT (4, m_C) break; case 0xA2: /* RES 4,D */ - RES_8BIT (4, cpustate->D) + RES_8BIT (4, m_D) break; case 0xA3: /* RES 4,E */ - RES_8BIT (4, cpustate->E) + RES_8BIT (4, m_E) break; case 0xA4: /* RES 4,H */ - RES_8BIT (4, cpustate->H) + RES_8BIT (4, m_H) break; case 0xA5: /* RES 4,L */ - RES_8BIT (4, cpustate->L) + RES_8BIT (4, m_L) break; case 0xA6: /* RES 4,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RES_8BIT (4, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xA7: /* RES 4,A */ - RES_8BIT (4, cpustate->A) + RES_8BIT (4, m_A) break; case 0xA8: /* RES 5,B */ - RES_8BIT (5, cpustate->B) + RES_8BIT (5, m_B) break; case 0xA9: /* RES 5,C */ - RES_8BIT (5, cpustate->C) + RES_8BIT (5, m_C) break; case 0xAA: /* RES 5,D */ - RES_8BIT (5, cpustate->D) + RES_8BIT (5, m_D) break; case 0xAB: /* RES 5,E */ - RES_8BIT (5, cpustate->E) + RES_8BIT (5, m_E) break; case 0xAC: /* RES 5,H */ - RES_8BIT (5, cpustate->H) + RES_8BIT (5, m_H) break; case 0xAD: /* RES 5,L */ - RES_8BIT (5, cpustate->L) + RES_8BIT (5, m_L) break; case 0xAE: /* RES 5,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RES_8BIT (5, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xAF: /* RES 5,A */ - RES_8BIT (5, cpustate->A) + RES_8BIT (5, m_A) break; case 0xB0: /* RES 6,B */ - RES_8BIT (6, cpustate->B) + RES_8BIT (6, m_B) break; case 0xB1: /* RES 6,C */ - RES_8BIT (6, cpustate->C) + RES_8BIT (6, m_C) break; case 0xB2: /* RES 6,D */ - RES_8BIT (6, cpustate->D) + RES_8BIT (6, m_D) break; case 0xB3: /* RES 6,E */ - RES_8BIT (6, cpustate->E) + RES_8BIT (6, m_E) break; case 0xB4: /* RES 6,H */ - RES_8BIT (6, cpustate->H) + RES_8BIT (6, m_H) break; case 0xB5: /* RES 6,L */ - RES_8BIT (6, cpustate->L) + RES_8BIT (6, m_L) break; case 0xB6: /* RES 6,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RES_8BIT (6, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xB7: /* RES 6,A */ - RES_8BIT (6, cpustate->A) + RES_8BIT (6, m_A) break; case 0xB8: /* RES 7,B */ - RES_8BIT (7, cpustate->B) + RES_8BIT (7, m_B) break; case 0xB9: /* RES 7,C */ - RES_8BIT (7, cpustate->C) + RES_8BIT (7, m_C) break; case 0xBA: /* RES 7,D */ - RES_8BIT (7, cpustate->D) + RES_8BIT (7, m_D) break; case 0xBB: /* RES 7,E */ - RES_8BIT (7, cpustate->E) + RES_8BIT (7, m_E) break; case 0xBC: /* RES 7,H */ - RES_8BIT (7, cpustate->H) + RES_8BIT (7, m_H) break; case 0xBD: /* RES 7,L */ - RES_8BIT (7, cpustate->L) + RES_8BIT (7, m_L) break; case 0xBE: /* RES 7,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); RES_8BIT (7, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xBF: /* RES 7,A */ - RES_8BIT (7, cpustate->A) + RES_8BIT (7, m_A) break; case 0xC0: /* SET 0,B */ - SET_8BIT (0, cpustate->B) + SET_8BIT (0, m_B) break; case 0xC1: /* SET 0,C */ - SET_8BIT (0, cpustate->C) + SET_8BIT (0, m_C) break; case 0xC2: /* SET 0,D */ - SET_8BIT (0, cpustate->D) + SET_8BIT (0, m_D) break; case 0xC3: /* SET 0,E */ - SET_8BIT (0, cpustate->E) + SET_8BIT (0, m_E) break; case 0xC4: /* SET 0,H */ - SET_8BIT (0, cpustate->H) + SET_8BIT (0, m_H) break; case 0xC5: /* SET 0,L */ - SET_8BIT (0, cpustate->L) + SET_8BIT (0, m_L) break; case 0xC6: /* SET 0,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SET_8BIT (0, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xC7: /* SET 0,A */ - SET_8BIT (0, cpustate->A) + SET_8BIT (0, m_A) break; case 0xC8: /* SET 1,B */ - SET_8BIT (1, cpustate->B) + SET_8BIT (1, m_B) break; case 0xC9: /* SET 1,C */ - SET_8BIT (1, cpustate->C) + SET_8BIT (1, m_C) break; case 0xCA: /* SET 1,D */ - SET_8BIT (1, cpustate->D) + SET_8BIT (1, m_D) break; case 0xCB: /* SET 1,E */ - SET_8BIT (1, cpustate->E) + SET_8BIT (1, m_E) break; case 0xCC: /* SET 1,H */ - SET_8BIT (1, cpustate->H) + SET_8BIT (1, m_H) break; case 0xCD: /* SET 1,L */ - SET_8BIT (1, cpustate->L) + SET_8BIT (1, m_L) break; case 0xCE: /* SET 1,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SET_8BIT (1, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xCF: /* SET 1,A */ - SET_8BIT (1, cpustate->A) + SET_8BIT (1, m_A) break; case 0xD0: /* SET 2,B */ - SET_8BIT (2, cpustate->B) + SET_8BIT (2, m_B) break; case 0xD1: /* SET 2,C */ - SET_8BIT (2, cpustate->C) + SET_8BIT (2, m_C) break; case 0xD2: /* SET 2,D */ - SET_8BIT (2, cpustate->D) + SET_8BIT (2, m_D) break; case 0xD3: /* SET 2,E */ - SET_8BIT (2, cpustate->E) + SET_8BIT (2, m_E) break; case 0xD4: /* SET 2,H */ - SET_8BIT (2, cpustate->H) + SET_8BIT (2, m_H) break; case 0xD5: /* SET 2,L */ - SET_8BIT (2, cpustate->L) + SET_8BIT (2, m_L) break; case 0xD6: /* SET 2,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SET_8BIT (2, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xD7: /* SET 2,A */ - SET_8BIT (2, cpustate->A) + SET_8BIT (2, m_A) break; case 0xD8: /* SET 3,B */ - SET_8BIT (3, cpustate->B) + SET_8BIT (3, m_B) break; case 0xD9: /* SET 3,C */ - SET_8BIT (3, cpustate->C) + SET_8BIT (3, m_C) break; case 0xDA: /* SET 3,D */ - SET_8BIT (3, cpustate->D) + SET_8BIT (3, m_D) break; case 0xDB: /* SET 3,E */ - SET_8BIT (3, cpustate->E) + SET_8BIT (3, m_E) break; case 0xDC: /* SET 3,H */ - SET_8BIT (3, cpustate->H) + SET_8BIT (3, m_H) break; case 0xDD: /* SET 3,L */ - SET_8BIT (3, cpustate->L) + SET_8BIT (3, m_L) break; case 0xDE: /* SET 3,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SET_8BIT (3, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xDF: /* SET 3,A */ - SET_8BIT (3, cpustate->A) + SET_8BIT (3, m_A) break; case 0xE0: /* SET 4,B */ - SET_8BIT (4, cpustate->B) + SET_8BIT (4, m_B) break; case 0xE1: /* SET 4,C */ - SET_8BIT (4, cpustate->C) + SET_8BIT (4, m_C) break; case 0xE2: /* SET 4,D */ - SET_8BIT (4, cpustate->D) + SET_8BIT (4, m_D) break; case 0xE3: /* SET 4,E */ - SET_8BIT (4, cpustate->E) + SET_8BIT (4, m_E) break; case 0xE4: /* SET 4,H */ - SET_8BIT (4, cpustate->H) + SET_8BIT (4, m_H) break; case 0xE5: /* SET 4,L */ - SET_8BIT (4, cpustate->L) + SET_8BIT (4, m_L) break; case 0xE6: /* SET 4,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SET_8BIT (4, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xE7: /* SET 4,A */ - SET_8BIT (4, cpustate->A) + SET_8BIT (4, m_A) break; case 0xE8: /* SET 5,B */ - SET_8BIT (5, cpustate->B) + SET_8BIT (5, m_B) break; case 0xE9: /* SET 5,C */ - SET_8BIT (5, cpustate->C) + SET_8BIT (5, m_C) break; case 0xEA: /* SET 5,D */ - SET_8BIT (5, cpustate->D) + SET_8BIT (5, m_D) break; case 0xEB: /* SET 5,E */ - SET_8BIT (5, cpustate->E) + SET_8BIT (5, m_E) break; case 0xEC: /* SET 5,H */ - SET_8BIT (5, cpustate->H) + SET_8BIT (5, m_H) break; case 0xED: /* SET 5,L */ - SET_8BIT (5, cpustate->L) + SET_8BIT (5, m_L) break; case 0xEE: /* SET 5,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SET_8BIT (5, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xEF: /* SET 5,A */ - SET_8BIT (5, cpustate->A) + SET_8BIT (5, m_A) break; case 0xF0: /* SET 6,B */ - SET_8BIT (6, cpustate->B) + SET_8BIT (6, m_B) break; case 0xF1: /* SET 6,C */ - SET_8BIT (6, cpustate->C) + SET_8BIT (6, m_C) break; case 0xF2: /* SET 6,D */ - SET_8BIT (6, cpustate->D) + SET_8BIT (6, m_D) break; case 0xF3: /* SET 6,E */ - SET_8BIT (6, cpustate->E) + SET_8BIT (6, m_E) break; case 0xF4: /* SET 6,H */ - SET_8BIT (6, cpustate->H) + SET_8BIT (6, m_H) break; case 0xF5: /* SET 6,L */ - SET_8BIT (6, cpustate->L) + SET_8BIT (6, m_L) break; case 0xF6: /* SET 6,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SET_8BIT (6, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xF7: /* SET 6,A */ - SET_8BIT (6, cpustate->A) + SET_8BIT (6, m_A) break; case 0xF8: /* SET 7,B */ - SET_8BIT (7, cpustate->B) + SET_8BIT (7, m_B) break; case 0xF9: /* SET 7,C */ - SET_8BIT (7, cpustate->C) + SET_8BIT (7, m_C) break; case 0xFA: /* SET 7,D */ - SET_8BIT (7, cpustate->D) + SET_8BIT (7, m_D) break; case 0xFB: /* SET 7,E */ - SET_8BIT (7, cpustate->E) + SET_8BIT (7, m_E) break; case 0xFC: /* SET 7,H */ - SET_8BIT (7, cpustate->H) + SET_8BIT (7, m_H) break; case 0xFD: /* SET 7,L */ - SET_8BIT (7, cpustate->L) + SET_8BIT (7, m_L) break; case 0xFE: /* SET 7,(HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; - x = mem_ReadByte (cpustate, addr); + x = mem_read_byte( addr); SET_8BIT (7, x) - mem_WriteByte (cpustate, addr, x); + mem_write_byte( addr, x); } break; case 0xFF: /* SET 7,A */ - SET_8BIT (7, cpustate->A) + SET_8BIT (7, m_A) break; diff --git a/src/emu/cpu/lr35902/opc_main.h b/src/emu/cpu/lr35902/opc_main.h index f052c485120..82a00dd8643 100644 --- a/src/emu/cpu/lr35902/opc_main.h +++ b/src/emu/cpu/lr35902/opc_main.h @@ -3,10 +3,10 @@ register UINT8 r,f; \ x++; \ r=(x); \ - f=(UINT8)(cpustate->F&FLAG_C); \ + f=(UINT8)(m_F&FLAG_C); \ if( r==0 ) f|=FLAG_Z; \ if( (r&0xF)==0 ) f|=FLAG_H; \ - cpustate->F=f; \ + m_F=f; \ } #define DEC_8BIT(x) \ @@ -14,52 +14,52 @@ register UINT8 r,f; \ x--; \ r=(x); \ - f=(UINT8)((cpustate->F&FLAG_C)|FLAG_N); \ + f=(UINT8)((m_F&FLAG_C)|FLAG_N); \ if( r==0 ) f|=FLAG_Z; \ if( (r&0xF)==0xF ) f|=FLAG_H; \ - cpustate->F=f; \ + m_F=f; \ } #define ADD_HL_RR(x) \ { \ register UINT32 r1,r2; \ register UINT8 f; \ - r1=((cpustate->H<<8)|cpustate->L)+(x); \ - r2=(((cpustate->H<<8)|cpustate->L)&0xFFF)+((x)&0xFFF); \ - f=(UINT8)(cpustate->F&FLAG_Z); \ + r1=((m_H<<8)|m_L)+(x); \ + r2=(((m_H<<8)|m_L)&0xFFF)+((x)&0xFFF); \ + f=(UINT8)(m_F&FLAG_Z); \ if( r1>0xFFFF ) f|=FLAG_C; \ if( r2>0x0FFF ) f|=FLAG_H; \ - cpustate->L = r1; \ - cpustate->H = r1 >> 8; \ - cpustate->F=f; \ + m_L = r1; \ + m_H = r1 >> 8; \ + m_F=f; \ } #define ADD_A_X(x) \ { \ register UINT16 r1,r2; \ register UINT8 f; \ - r1=(UINT16)((cpustate->A&0xF)+((x)&0xF)); \ - r2=(UINT16)(cpustate->A+(x)); \ - cpustate->A=(UINT8)r2; \ + r1=(UINT16)((m_A&0xF)+((x)&0xF)); \ + r2=(UINT16)(m_A+(x)); \ + m_A=(UINT8)r2; \ if( ((UINT8)r2)==0 ) f=FLAG_Z; \ else f=0; \ if( r2>0xFF ) f|=FLAG_C; \ if( r1>0xF ) f|=FLAG_H; \ - cpustate->F=f; \ + m_F=f; \ } #define SUB_A_X(x) \ { \ register UINT16 r1,r2; \ register UINT8 f; \ - r1=(UINT16)((cpustate->A&0xF)-((x)&0xF)); \ - r2=(UINT16)(cpustate->A-(x)); \ - cpustate->A=(UINT8)r2; \ + r1=(UINT16)((m_A&0xF)-((x)&0xF)); \ + r2=(UINT16)(m_A-(x)); \ + m_A=(UINT8)r2; \ if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \ else f=FLAG_N; \ if( r2>0xFF ) f|=FLAG_C; \ if( r1>0xF ) f|=FLAG_H; \ - cpustate->F=f; \ + m_F=f; \ } /* @@ -67,15 +67,15 @@ { \ register UINT16 r; \ register UINT8 f; \ - r=(UINT16)(cpustate->A-(x)); \ + r=(UINT16)(m_A-(x)); \ if( ((UINT8)r)==0 ) \ f=FLAG_N|FLAG_Z; \ else \ f=FLAG_N; \ f|=(UINT8)((r>>8)&FLAG_C); \ - if( (r^cpustate->A^(x))&0x10 ) \ + if( (r^m_A^(x))&0x10 ) \ f|=FLAG_H; \ - cpustate->F=f; \ + m_F=f; \ } */ @@ -83,450 +83,455 @@ { \ register UINT16 r1,r2; \ register UINT8 f; \ - r1=(UINT16)((cpustate->A&0xF)-((x)&0xF)); \ - r2=(UINT16)(cpustate->A-(x)); \ + r1=(UINT16)((m_A&0xF)-((x)&0xF)); \ + r2=(UINT16)(m_A-(x)); \ if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \ else f=FLAG_N; \ if( r2>0xFF ) f|=FLAG_C; \ if( r1>0xF ) f|=FLAG_H; \ - cpustate->F=f; \ + m_F=f; \ } #define SBC_A_X(x) \ { \ register UINT16 r1,r2; \ register UINT8 f; \ - r1=(UINT16)((cpustate->A&0xF)-((x)&0xF)-((cpustate->F&FLAG_C)?1:0)); \ - r2=(UINT16)(cpustate->A-(x)-((cpustate->F&FLAG_C)?1:0)); \ - cpustate->A=(UINT8)r2; \ + r1=(UINT16)((m_A&0xF)-((x)&0xF)-((m_F&FLAG_C)?1:0)); \ + r2=(UINT16)(m_A-(x)-((m_F&FLAG_C)?1:0)); \ + m_A=(UINT8)r2; \ if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \ else f=FLAG_N; \ if( r2>0xFF ) f|=FLAG_C; \ if( r1>0xF ) f|=FLAG_H; \ - cpustate->F=f; \ + m_F=f; \ } #define ADC_A_X(x) \ { \ register UINT16 r1,r2; \ register UINT8 f; \ - r1=(UINT16)((cpustate->A&0xF)+((x)&0xF)+((cpustate->F&FLAG_C)?1:0)); \ - r2=(UINT16)(cpustate->A+(x)+((cpustate->F&FLAG_C)?1:0)); \ - if( (cpustate->A=(UINT8)r2)==0 ) f=FLAG_Z; \ + r1=(UINT16)((m_A&0xF)+((x)&0xF)+((m_F&FLAG_C)?1:0)); \ + r2=(UINT16)(m_A+(x)+((m_F&FLAG_C)?1:0)); \ + if( (m_A=(UINT8)r2)==0 ) f=FLAG_Z; \ else f=0; \ if( r2>0xFF ) f|=FLAG_C; \ if( r1>0xF ) f|=FLAG_H; \ - cpustate->F=f; \ + m_F=f; \ } #define AND_A_X(x) \ - if( (cpustate->A&=(x))==0 ) \ - cpustate->F=FLAG_H|FLAG_Z; \ + if( (m_A&=(x))==0 ) \ + m_F=FLAG_H|FLAG_Z; \ else \ - cpustate->F=FLAG_H; + m_F=FLAG_H; #define XOR_A_X(x) \ - if( (cpustate->A^=(x))==0 ) \ - cpustate->F=FLAG_Z; \ + if( (m_A^=(x))==0 ) \ + m_F=FLAG_Z; \ else \ - cpustate->F=0; + m_F=0; #define OR_A_X(x) \ - if( (cpustate->A|=(x))==0 ) \ - cpustate->F=FLAG_Z; \ + if( (m_A|=(x))==0 ) \ + m_F=FLAG_Z; \ else \ - cpustate->F=0; + m_F=0; #define POP(x,y) \ - y = mem_ReadByte( cpustate, cpustate->SP++ ); \ - x = mem_ReadByte( cpustate, cpustate->SP++ ); + y = mem_read_byte( m_SP++ ); \ + x = mem_read_byte( m_SP++ ); #define PUSH(x,y) \ - cpustate->SP--; \ - mem_WriteByte( cpustate, cpustate->SP, x ); \ - cpustate->SP--; \ - mem_WriteByte( cpustate, cpustate->SP, y ); + m_SP--; \ + mem_write_byte( m_SP, x ); \ + m_SP--; \ + mem_write_byte( m_SP, y ); case 0x00: /* NOP */ - break; -case 0x01: /* LD BC,n16 */ - cpustate->C = mem_ReadOp (cpustate); - cpustate->B = mem_ReadOp (cpustate); break; + +case 0x01: /* LD BC,n16 */ + m_C = mem_read_byte( m_PC++ ); + m_B = mem_read_byte( m_PC++ ); + break; + case 0x02: /* LD (BC),A */ - mem_WriteByte (cpustate, ( cpustate->B << 8 ) | cpustate->C, cpustate->A); - break; + mem_write_byte( ( m_B << 8 ) | m_C, m_A ); + break; + case 0x03: /* INC BC */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->B == 0xFE) + if (m_B == 0xFE) { trash_sprites (state); } #endif - cpustate->C++; - if ( cpustate->C == 0 ) + m_C++; + if ( m_C == 0 ) { - cpustate->B++; + m_B++; } - CYCLES_PASSED( 4 ); + cycles_passed( 4 ); break; case 0x04: /* INC B */ - INC_8BIT (cpustate->B) + INC_8BIT (m_B) break; case 0x05: /* DEC B */ - DEC_8BIT (cpustate->B) + DEC_8BIT (m_B) break; -case 0x06: /* LD B,n8 */ - cpustate->B = mem_ReadByte (cpustate, cpustate->PC++); - break; +case 0x06: /* LD B,n8 */ + m_B = mem_read_byte( m_PC++ ); + break; + case 0x07: /* RLCA */ - cpustate->A = (UINT8) ((cpustate->A << 1) | (cpustate->A >> 7)); - if (cpustate->A & 1) + m_A = (UINT8) ((m_A << 1) | (m_A >> 7)); + if (m_A & 1) { - cpustate->F = FLAG_C; + m_F = FLAG_C; } else { - cpustate->F = 0; + m_F = 0; } break; -case 0x08: /* LD (n16),SP */ - mem_WriteWord (cpustate, mem_ReadWord (cpustate, cpustate->PC), cpustate->SP); - cpustate->PC += 2; - break; +case 0x08: /* LD (n16),SP */ + mem_write_word (mem_read_word (m_PC), m_SP); + m_PC += 2; + break; + case 0x09: /* ADD HL,BC */ - ADD_HL_RR ((cpustate->B<<8)|cpustate->C) - CYCLES_PASSED( 4 ); + ADD_HL_RR ((m_B<<8)|m_C) + cycles_passed( 4 ); break; case 0x0A: /* LD A,(BC) */ - cpustate->A = mem_ReadByte (cpustate, (cpustate->B<<8)|cpustate->C); + m_A = mem_read_byte ( (m_B<<8)|m_C ); break; case 0x0B: /* DEC BC */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->B == 0xFE) + if (m_B == 0xFE) { trash_sprites (state); } #endif - cpustate->C--; - if ( cpustate->C == 0xFF ) + m_C--; + if ( m_C == 0xFF ) { - cpustate->B--; + m_B--; } - CYCLES_PASSED( 4 ); + cycles_passed( 4 ); break; case 0x0C: /* INC C */ - INC_8BIT (cpustate->C) + INC_8BIT (m_C) break; case 0x0D: /* DEC C */ - DEC_8BIT (cpustate->C) + DEC_8BIT (m_C) break; case 0x0E: /* LD C,n8 */ - cpustate->C = mem_ReadByte (cpustate, cpustate->PC++); + m_C = mem_read_byte ( m_PC++ ); break; case 0x0F: /* RRCA */ - cpustate->A = (UINT8) ((cpustate->A >> 1) | (cpustate->A << 7)); - cpustate->F = 0; - if (cpustate->A & 0x80) + m_A = (UINT8) ((m_A >> 1) | (m_A << 7)); + m_F = 0; + if (m_A & 0x80) { - cpustate->F |= FLAG_C; + m_F |= FLAG_C; } break; case 0x10: /* STOP */ - if ( cpustate->gb_speed_change_pending ) { - cpustate->gb_speed = ( cpustate->gb_speed == 1 ) ? 2 : 1; + if ( m_gb_speed_change_pending ) { + m_gb_speed = ( m_gb_speed == 1 ) ? 2 : 1; } - cpustate->gb_speed_change_pending = 0; + m_gb_speed_change_pending = 0; break; case 0x11: /* LD DE,n16 */ - cpustate->E = mem_ReadOp (cpustate); - cpustate->D = mem_ReadOp (cpustate); + m_E = mem_read_byte( m_PC++ ); + m_D = mem_read_byte( m_PC++ ); break; case 0x12: /* LD (DE),A */ - mem_WriteByte (cpustate, ( cpustate->D << 8 ) | cpustate->E, cpustate->A); + mem_write_byte( ( m_D << 8 ) | m_E, m_A ); break; case 0x13: /* INC DE */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->D == 0xFE) + if (m_D == 0xFE) { trash_sprites (state); } #endif - cpustate->E++; - if ( cpustate->E == 0 ) + m_E++; + if ( m_E == 0 ) { - cpustate->D++; + m_D++; } - CYCLES_PASSED( 4 ); + cycles_passed( 4 ); break; case 0x14: /* INC D */ - INC_8BIT (cpustate->D) + INC_8BIT (m_D) break; case 0x15: /* DEC D */ - DEC_8BIT (cpustate->D) + DEC_8BIT (m_D) break; case 0x16: /* LD D,n8 */ - cpustate->D = mem_ReadByte (cpustate, cpustate->PC++); + m_D = mem_read_byte ( m_PC++ ); break; case 0x17: /* RLA */ - x = (cpustate->A & 0x80) ? FLAG_C : 0; + x = (m_A & 0x80) ? FLAG_C : 0; - cpustate->A = (UINT8) ((cpustate->A << 1) | ((cpustate->F & FLAG_C) ? 1 : 0)); - cpustate->F = x; + m_A = (UINT8) ((m_A << 1) | ((m_F & FLAG_C) ? 1 : 0)); + m_F = x; break; case 0x18: /* JR n8 */ { INT8 offset; - offset = mem_ReadByte (cpustate, cpustate->PC++); - cpustate->PC += offset; - CYCLES_PASSED( 4 ); + offset = mem_read_byte( m_PC++ ); + m_PC += offset; + cycles_passed( 4 ); } break; case 0x19: /* ADD HL,DE */ - ADD_HL_RR (( cpustate->D << 8 ) | cpustate->E) - CYCLES_PASSED( 4 ); + ADD_HL_RR (( m_D << 8 ) | m_E) + cycles_passed( 4 ); break; case 0x1A: /* LD A,(DE) */ - cpustate->A = mem_ReadByte (cpustate, ( cpustate->D << 8 ) | cpustate->E); + m_A = mem_read_byte( ( m_D << 8 ) | m_E ); break; case 0x1B: /* DEC DE */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->D == 0xFE) + if (m_D == 0xFE) { trash_sprites (state); } #endif - cpustate->E--; - if ( cpustate->E == 0xFF ) + m_E--; + if ( m_E == 0xFF ) { - cpustate->D--; + m_D--; } - CYCLES_PASSED( 4 ); + cycles_passed( 4 ); break; case 0x1C: /* INC E */ - INC_8BIT (cpustate->E) + INC_8BIT (m_E) break; case 0x1D: /* DEC E */ - DEC_8BIT (cpustate->E) + DEC_8BIT (m_E) break; case 0x1E: /* LD E,n8 */ - cpustate->E = mem_ReadByte (cpustate, cpustate->PC++); + m_E = mem_read_byte( m_PC++ ); break; case 0x1F: /* RRA */ - x = (cpustate->A & 1) ? FLAG_C : 0; + x = (m_A & 1) ? FLAG_C : 0; - cpustate->A = (UINT8) ((cpustate->A >> 1) | ((cpustate->F & FLAG_C) ? 0x80 : 0)); - cpustate->F = x; + m_A = (UINT8) ((m_A >> 1) | ((m_F & FLAG_C) ? 0x80 : 0)); + m_F = x; break; case 0x20: /* JR NZ,n8 */ { - INT8 offset = mem_ReadByte (cpustate, cpustate->PC++); - if (! (cpustate->F & FLAG_Z) ) + INT8 offset = mem_read_byte( m_PC++ ); + if (! (m_F & FLAG_Z) ) { - cpustate->PC += offset; - CYCLES_PASSED( 4 ); + m_PC += offset; + cycles_passed( 4 ); } } break; case 0x21: /* LD HL,n16 */ - cpustate->L = mem_ReadOp (cpustate); - cpustate->H = mem_ReadOp (cpustate); + m_L = mem_read_byte( m_PC++ ); + m_H = mem_read_byte( m_PC++ ); break; case 0x22: /* LD (HL+),A */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->H == 0xFE) + if (m_H == 0xFE) { trash_sprites (state); } #endif - mem_WriteByte (cpustate, (cpustate->H << 8 ) | cpustate->L, cpustate->A); - cpustate->L++; - if ( cpustate->L == 0 ) + mem_write_byte( (m_H << 8 ) | m_L, m_A ); + m_L++; + if ( m_L == 0 ) { - cpustate->H++; + m_H++; } break; case 0x23: /* INC HL */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->H == 0xFE) + if (m_H == 0xFE) { trash_sprites (state); } #endif - cpustate->L++; - if ( cpustate->L == 0 ) + m_L++; + if ( m_L == 0 ) { - cpustate->H++; + m_H++; } - CYCLES_PASSED( 4 ); + cycles_passed( 4 ); break; case 0x24: /* INC H */ - INC_8BIT (cpustate->H); + INC_8BIT (m_H); break; case 0x25: /* DEC H */ - DEC_8BIT (cpustate->H); + DEC_8BIT (m_H); break; case 0x26: /* LD H,n8 */ - cpustate->H = mem_ReadByte (cpustate, cpustate->PC++); + m_H = mem_read_byte( m_PC++ ); break; case 0x27: /* DAA */ { - int tmp = cpustate->A; + int tmp = m_A; - if ( ! ( cpustate->F & FLAG_N ) ) { - if ( ( cpustate->F & FLAG_H ) || ( tmp & 0x0F ) > 9 ) + if ( ! ( m_F & FLAG_N ) ) { + if ( ( m_F & FLAG_H ) || ( tmp & 0x0F ) > 9 ) tmp += 6; - if ( ( cpustate->F & FLAG_C ) || tmp > 0x9F ) + if ( ( m_F & FLAG_C ) || tmp > 0x9F ) tmp += 0x60; } else { - if ( cpustate->F & FLAG_H ) { + if ( m_F & FLAG_H ) { tmp -= 6; - if ( ! ( cpustate->F & FLAG_C ) ) + if ( ! ( m_F & FLAG_C ) ) tmp &= 0xFF; } - if ( cpustate->F & FLAG_C ) + if ( m_F & FLAG_C ) tmp -= 0x60; } - cpustate->F &= ~ ( FLAG_H | FLAG_Z ); + m_F &= ~ ( FLAG_H | FLAG_Z ); if ( tmp & 0x100 ) - cpustate->F |= FLAG_C; - cpustate->A = tmp & 0xFF; - if ( ! cpustate->A ) - cpustate->F |= FLAG_Z; + m_F |= FLAG_C; + m_A = tmp & 0xFF; + if ( ! m_A ) + m_F |= FLAG_Z; } break; case 0x28: /* JR Z,n8 */ { - INT8 offset = mem_ReadByte (cpustate, cpustate->PC++);; + INT8 offset = mem_read_byte( m_PC++ ); - if (cpustate->F & FLAG_Z) + if (m_F & FLAG_Z) { - cpustate->PC += offset; - CYCLES_PASSED( 4 ); + m_PC += offset; + cycles_passed( 4 ); } } break; case 0x29: /* ADD HL,HL */ - ADD_HL_RR ((cpustate->H << 8 ) | cpustate->L) - CYCLES_PASSED( 4 ); + ADD_HL_RR ((m_H << 8 ) | m_L) + cycles_passed( 4 ); break; case 0x2A: /* LD A,(HL+) */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->H == 0xFE) + if (m_H == 0xFE) { trash_sprites (state); } #endif - cpustate->A = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); - cpustate->L++; - if ( cpustate->L == 0 ) + m_A = mem_read_byte( ( m_H << 8 ) | m_L ); + m_L++; + if ( m_L == 0 ) { - cpustate->H++; + m_H++; } break; case 0x2B: /* DEC HL */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->H == 0xFE) + if (m_H == 0xFE) { trash_sprites (state); } #endif - cpustate->L--; - if ( cpustate->L == 0xFF ) + m_L--; + if ( m_L == 0xFF ) { - cpustate->H--; + m_H--; } - CYCLES_PASSED( 4 ); + cycles_passed( 4 ); break; case 0x2C: /* INC L */ - INC_8BIT (cpustate->L); + INC_8BIT (m_L); break; case 0x2D: /* DEC L */ - DEC_8BIT (cpustate->L); + DEC_8BIT (m_L); break; case 0x2E: /* LD L,n8 */ - cpustate->L = mem_ReadByte (cpustate, cpustate->PC++); + m_L = mem_read_byte( m_PC++ ); break; case 0x2F: /* CPL */ - cpustate->A = ~cpustate->A; - cpustate->F |= FLAG_N | FLAG_H; + m_A = ~m_A; + m_F |= FLAG_N | FLAG_H; break; case 0x30: /* JR NC,n8 */ { - INT8 offset = mem_ReadByte (cpustate, cpustate->PC++); + INT8 offset = mem_read_byte( m_PC++ ); - if ( ! (cpustate->F & FLAG_C) ) + if ( ! (m_F & FLAG_C) ) { - cpustate->PC += offset; - CYCLES_PASSED( 4 ); + m_PC += offset; + cycles_passed( 4 ); } } break; case 0x31: /* LD SP,n16 */ - cpustate->SP = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + m_SP = mem_read_word( m_PC ); + m_PC += 2; break; case 0x32: /* LD (HL-),A */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->H == 0xFE) + if (m_H == 0xFE) { trash_sprites (state); } #endif - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, cpustate->A); - cpustate->L--; - if ( cpustate->L == 0xFF ) + mem_write_byte( ( m_H << 8 ) | m_L, m_A ); + m_L--; + if ( m_L == 0xFF ) { - cpustate->H--; + m_H--; } break; case 0x33: /* INC SP */ - cpustate->SP += 1; - CYCLES_PASSED( 4 ); + m_SP += 1; + cycles_passed( 4 ); break; case 0x34: /* INC (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; register UINT8 r, f; - f = (UINT8) (cpustate->F & FLAG_C); - r = mem_ReadByte (cpustate, addr); + f = (UINT8) (m_F & FLAG_C); + r = mem_read_byte( addr ); r += 1; - mem_WriteByte (cpustate, addr, r); + mem_write_byte( addr, r ); if (r == 0) f |= FLAG_Z; @@ -534,18 +539,18 @@ case 0x34: /* INC (HL) */ if ((r & 0xF) == 0) f |= FLAG_H; - cpustate->F = f; + m_F = f; } break; case 0x35: /* DEC (HL) */ { - UINT16 addr = ( cpustate->H << 8 ) | cpustate->L; + UINT16 addr = ( m_H << 8 ) | m_L; register UINT8 r, f; - f = (UINT8) ((cpustate->F & FLAG_C) | FLAG_N); - r = mem_ReadByte (cpustate, addr); + f = (UINT8) ((m_F & FLAG_C) | FLAG_N); + r = mem_read_byte( addr ); r -= 1; - mem_WriteByte (cpustate, addr, r); + mem_write_byte( addr, r ); if (r == 0) f |= FLAG_Z; @@ -553,667 +558,663 @@ case 0x35: /* DEC (HL) */ if ((r & 0xF) == 0xF) f |= FLAG_H; - cpustate->F = f; + m_F = f; } break; case 0x36: /* LD (HL),n8 */ { - UINT8 v = mem_ReadByte (cpustate, cpustate->PC++); - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, v); + UINT8 v = mem_read_byte( m_PC++ ); + mem_write_byte( ( m_H << 8 ) | m_L, v ); } break; case 0x37: /* SCF */ - cpustate->F = (UINT8) ((cpustate->F & FLAG_Z) | FLAG_C); + m_F = (UINT8) ((m_F & FLAG_Z) | FLAG_C); break; case 0x38: /* JR C,n8 */ { - INT8 offset = mem_ReadByte (cpustate, cpustate->PC++); + INT8 offset = mem_read_byte( m_PC++ ); - if (cpustate->F & FLAG_C) + if (m_F & FLAG_C) { - cpustate->PC += offset; - CYCLES_PASSED( 4 ); + m_PC += offset; + cycles_passed( 4 ); } } break; case 0x39: /* ADD HL,SP */ - ADD_HL_RR (cpustate->SP) - CYCLES_PASSED( 4 ); + ADD_HL_RR (m_SP) + cycles_passed( 4 ); break; case 0x3A: /* LD A,(HL-) */ #if 0 /* FIXME ?? do we want to support this? (bug emulation) */ - if (cpustate->H == 0xFE) + if (m_H == 0xFE) { trash_sprites (state); } #endif - cpustate->A = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); - cpustate->L--; - if ( cpustate->L == 0xFF ) + m_A = mem_read_byte( ( m_H << 8 ) | m_L ); + m_L--; + if ( m_L == 0xFF ) { - cpustate->H--; + m_H--; } break; case 0x3B: /* DEC SP */ - cpustate->SP -= 1; - CYCLES_PASSED( 4 ); + m_SP -= 1; + cycles_passed( 4 ); break; case 0x3C: /* INC A */ - INC_8BIT (cpustate->A); + INC_8BIT (m_A); break; case 0x3D: /* DEC A */ - DEC_8BIT (cpustate->A); + DEC_8BIT (m_A); break; case 0x3E: /* LD A,n8 */ - cpustate->A = mem_ReadByte (cpustate, cpustate->PC++); + m_A = mem_read_byte( m_PC++ ); break; case 0x3F: /* CCF */ - cpustate->F = (UINT8) ((cpustate->F & FLAG_Z) | ((cpustate->F & FLAG_C) ? 0 : FLAG_C)); + m_F = (UINT8) ((m_F & FLAG_Z) | ((m_F & FLAG_C) ? 0 : FLAG_C)); break; case 0x40: /* LD B,B */ break; case 0x41: /* LD B,C */ - cpustate->B = cpustate->C; + m_B = m_C; break; case 0x42: /* LD B,D */ - cpustate->B = cpustate->D; + m_B = m_D; break; case 0x43: /* LD B,E */ - cpustate->B = cpustate->E; + m_B = m_E; break; case 0x44: /* LD B,H */ - cpustate->B = cpustate->H; + m_B = m_H; break; case 0x45: /* LD B,L */ - cpustate->B = cpustate->L; + m_B = m_L; break; case 0x46: /* LD B,(HL) */ + m_B = mem_read_byte( ( m_H << 8 ) | m_L) ; + break; - cpustate->B = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); - break; case 0x47: /* LD B,A */ - cpustate->B = cpustate->A; + m_B = m_A; break; case 0x48: /* LD C,B */ - cpustate->C = cpustate->B; + m_C = m_B; break; case 0x49: /* LD C,C */ break; case 0x4A: /* LD C,D */ - cpustate->C = cpustate->D; + m_C = m_D; break; case 0x4B: /* LD C,E */ - cpustate->C = cpustate->E; + m_C = m_E; break; case 0x4C: /* LD C,H */ - cpustate->C = cpustate->H; + m_C = m_H; break; case 0x4D: /* LD C,L */ - cpustate->C = cpustate->L; + m_C = m_L; break; -case 0x4E: /* LD C,(HL) */ - cpustate->C = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); - break; +case 0x4E: /* LD C,(HL) */ + m_C = mem_read_byte( ( m_H << 8 ) | m_L ); + break; + case 0x4F: /* LD C,A */ - cpustate->C = cpustate->A; + m_C = m_A; break; case 0x50: /* LD D,B */ - cpustate->D = cpustate->B; + m_D = m_B; break; case 0x51: /* LD D,C */ - cpustate->D = cpustate->C; + m_D = m_C; break; case 0x52: /* LD D,D */ break; case 0x53: /* LD D,E */ - cpustate->D = cpustate->E; + m_D = m_E; break; case 0x54: /* LD D,H */ - cpustate->D = cpustate->H; + m_D = m_H; break; case 0x55: /* LD D,L */ - cpustate->D = cpustate->L; + m_D = m_L; break; case 0x56: /* LD D,(HL) */ - cpustate->D = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + m_D = mem_read_byte( ( m_H << 8 ) | m_L ); break; case 0x57: /* LD D,A */ - cpustate->D = cpustate->A; + m_D = m_A; break; case 0x58: /* LD E,B */ - cpustate->E = cpustate->B; + m_E = m_B; break; case 0x59: /* LD E,C */ - cpustate->E = cpustate->C; + m_E = m_C; break; case 0x5A: /* LD E,D */ - cpustate->E = cpustate->D; + m_E = m_D; break; case 0x5B: /* LD E,E */ break; case 0x5C: /* LD E,H */ - cpustate->E = cpustate->H; + m_E = m_H; break; case 0x5D: /* LD E,L */ - cpustate->E = cpustate->L; + m_E = m_L; break; case 0x5E: /* LD E,(HL) */ - cpustate->E = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + m_E = mem_read_byte( ( m_H << 8 ) | m_L ); break; case 0x5F: /* LD E,A */ - cpustate->E = cpustate->A; + m_E = m_A; break; case 0x60: /* LD H,B */ - cpustate->H = cpustate->B; + m_H = m_B; break; case 0x61: /* LD H,C */ - cpustate->H = cpustate->C; + m_H = m_C; break; case 0x62: /* LD H,D */ - cpustate->H = cpustate->D; + m_H = m_D; break; case 0x63: /* LD H,E */ - cpustate->H = cpustate->E; + m_H = m_E; break; case 0x64: /* LD H,H */ break; case 0x65: /* LD H,L */ - cpustate->H = cpustate->L; + m_H = m_L; break; case 0x66: /* LD H,(HL) */ - cpustate->H = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + m_H = mem_read_byte( ( m_H << 8 ) | m_L ); break; case 0x67: /* LD H,A */ - cpustate->H = cpustate->A; + m_H = m_A; break; case 0x68: /* LD L,B */ - cpustate->L = cpustate->B; + m_L = m_B; break; case 0x69: /* LD L,C */ - cpustate->L = cpustate->C; + m_L = m_C; break; case 0x6A: /* LD L,D */ - cpustate->L = cpustate->D; + m_L = m_D; break; case 0x6B: /* LD L,E */ - cpustate->L = cpustate->E; + m_L = m_E; break; case 0x6C: /* LD L,H */ - cpustate->L = cpustate->H; + m_L = m_H; break; case 0x6D: /* LD L,L */ break; case 0x6E: /* LD L,(HL) */ - cpustate->L = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + m_L = mem_read_byte( ( m_H << 8 ) | m_L ); break; case 0x6F: /* LD L,A */ - cpustate->L = cpustate->A; + m_L = m_A; break; + case 0x70: /* LD (HL),B */ + mem_write_byte( ( m_H << 8 ) | m_L, m_B ); + break; - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, cpustate->B); - break; case 0x71: /* LD (HL),C */ - - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, cpustate->C); - break; + mem_write_byte( ( m_H << 8 ) | m_L, m_C ); + break; case 0x72: /* LD (HL),D */ - - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, cpustate->D); - break; + mem_write_byte( ( m_H << 8 ) | m_L, m_D ); + break; case 0x73: /* LD (HL),E */ - - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, cpustate->E); - break; + mem_write_byte( ( m_H << 8 ) | m_L, m_E ); + break; case 0x74: /* LD (HL),H */ - - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, cpustate->H); - break; + mem_write_byte( ( m_H << 8 ) | m_L, m_H ); + break; case 0x75: /* LD (HL),L */ - - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, cpustate->L); - break; + mem_write_byte( ( m_H << 8 ) | m_L, m_L ); + break; case 0x76: /* HALT */ - cpustate->enable |= HALTED; - cpustate->PC--; - break; + m_enable |= HALTED; + m_PC--; + break; case 0x77: /* LD (HL),A */ - - mem_WriteByte (cpustate, ( cpustate->H << 8 ) | cpustate->L, cpustate->A); - break; + mem_write_byte( ( m_H << 8 ) | m_L, m_A ); + break; case 0x78: /* LD A,B */ - cpustate->A = cpustate->B; + m_A = m_B; break; case 0x79: /* LD A,C */ - cpustate->A = cpustate->C; + m_A = m_C; break; case 0x7A: /* LD A,D */ - cpustate->A = cpustate->D; + m_A = m_D; break; case 0x7B: /* LD A,E */ - cpustate->A = cpustate->E; + m_A = m_E; break; case 0x7C: /* LD A,H */ - cpustate->A = cpustate->H; + m_A = m_H; break; case 0x7D: /* LD A,L */ - cpustate->A = cpustate->L; + m_A = m_L; break; case 0x7E: /* LD A,(HL) */ - cpustate->A = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + m_A = mem_read_byte( ( m_H << 8 ) | m_L ); break; case 0x7F: /* LD A,A */ break; case 0x80: /* ADD A,B */ - ADD_A_X (cpustate->B) + ADD_A_X (m_B) break; case 0x81: /* ADD A,C */ - ADD_A_X (cpustate->C) + ADD_A_X (m_C) break; case 0x82: /* ADD A,D */ - ADD_A_X (cpustate->D) + ADD_A_X (m_D) break; case 0x83: /* ADD A,E */ - ADD_A_X (cpustate->E) + ADD_A_X (m_E) break; case 0x84: /* ADD A,H */ - ADD_A_X (cpustate->H) + ADD_A_X (m_H) break; case 0x85: /* ADD A,L */ - ADD_A_X (cpustate->L) + ADD_A_X (m_L) break; case 0x86: /* ADD A,(HL) */ - x = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + x = mem_read_byte( ( m_H << 8 ) | m_L ); ADD_A_X (x) break; case 0x87: /* ADD A,A */ - ADD_A_X (cpustate->A) + ADD_A_X (m_A) break; case 0x88: /* ADC A,B */ - ADC_A_X (cpustate->B) + ADC_A_X (m_B) break; case 0x89: /* ADC A,C */ - ADC_A_X (cpustate->C) + ADC_A_X (m_C) break; case 0x8A: /* ADC A,D */ - ADC_A_X (cpustate->D) + ADC_A_X (m_D) break; case 0x8B: /* ADC A,E */ - ADC_A_X (cpustate->E) + ADC_A_X (m_E) break; case 0x8C: /* ADC A,H */ - ADC_A_X (cpustate->H) + ADC_A_X (m_H) break; case 0x8D: /* ADC A,L */ - ADC_A_X (cpustate->L) + ADC_A_X (m_L) break; case 0x8E: /* ADC A,(HL) */ - x = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + x = mem_read_byte( ( m_H << 8 ) | m_L ); ADC_A_X (x) break; case 0x8F: /* ADC A,A */ - ADC_A_X (cpustate->A) + ADC_A_X (m_A) break; case 0x90: /* SUB A,B */ - SUB_A_X (cpustate->B) + SUB_A_X (m_B) break; case 0x91: /* SUB A,C */ - SUB_A_X (cpustate->C) + SUB_A_X (m_C) break; case 0x92: /* SUB A,D */ - SUB_A_X (cpustate->D) + SUB_A_X (m_D) break; case 0x93: /* SUB A,E */ - SUB_A_X (cpustate->E) + SUB_A_X (m_E) break; case 0x94: /* SUB A,H */ - SUB_A_X (cpustate->H) + SUB_A_X (m_H) break; case 0x95: /* SUB A,L */ - SUB_A_X (cpustate->L) + SUB_A_X (m_L) break; case 0x96: /* SUB A,(HL) */ - x = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + x = mem_read_byte( ( m_H << 8 ) | m_L ); SUB_A_X (x) break; case 0x97: /* SUB A,A */ - SUB_A_X (cpustate->A) + SUB_A_X (m_A) break; case 0x98: /* SBC A,B */ - SBC_A_X (cpustate->B) + SBC_A_X (m_B) break; case 0x99: /* SBC A,C */ - SBC_A_X (cpustate->C) + SBC_A_X (m_C) break; case 0x9A: /* SBC A,D */ - SBC_A_X (cpustate->D) + SBC_A_X (m_D) break; case 0x9B: /* SBC A,E */ - SBC_A_X (cpustate->E) + SBC_A_X (m_E) break; case 0x9C: /* SBC A,H */ - SBC_A_X (cpustate->H) + SBC_A_X (m_H) break; case 0x9D: /* SBC A,L */ - SBC_A_X (cpustate->L) + SBC_A_X (m_L) break; case 0x9E: /* SBC A,(HL) */ - x = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + x = mem_read_byte( ( m_H << 8 ) | m_L ); SBC_A_X (x) break; case 0x9F: /* SBC A,A */ - SBC_A_X (cpustate->A) + SBC_A_X (m_A) break; case 0xA0: /* AND A,B */ - AND_A_X (cpustate->B) + AND_A_X (m_B) break; case 0xA1: /* AND A,C */ - AND_A_X (cpustate->C) + AND_A_X (m_C) break; case 0xA2: /* AND A,D */ - AND_A_X (cpustate->D) + AND_A_X (m_D) break; case 0xA3: /* AND A,E */ - AND_A_X (cpustate->E) + AND_A_X (m_E) break; case 0xA4: /* AND A,H */ - AND_A_X (cpustate->H) + AND_A_X (m_H) break; case 0xA5: /* AND A,L */ - AND_A_X (cpustate->L) + AND_A_X (m_L) break; case 0xA6: /* AND A,(HL) */ - x = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + x = mem_read_byte( ( m_H << 8 ) | m_L ); AND_A_X (x) break; case 0xA7: /* AND A,A */ - cpustate->F = (cpustate->A == 0) ? (FLAG_H | FLAG_Z) : FLAG_H; + m_F = (m_A == 0) ? (FLAG_H | FLAG_Z) : FLAG_H; break; case 0xA8: /* XOR A,B */ - XOR_A_X (cpustate->B) + XOR_A_X (m_B) break; case 0xA9: /* XOR A,C */ - XOR_A_X (cpustate->C) + XOR_A_X (m_C) break; case 0xAA: /* XOR A,D */ - XOR_A_X (cpustate->D) + XOR_A_X (m_D) break; case 0xAB: /* XOR A,E */ - XOR_A_X (cpustate->E) + XOR_A_X (m_E) break; case 0xAC: /* XOR A,H */ - XOR_A_X (cpustate->H) + XOR_A_X (m_H) break; case 0xAD: /* XOR A,L */ - XOR_A_X (cpustate->L) + XOR_A_X (m_L) break; case 0xAE: /* XOR A,(HL) */ - x = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + x = mem_read_byte( ( m_H << 8 ) | m_L ); XOR_A_X (x) break; case 0xAF: /* XOR A,A */ - XOR_A_X (cpustate->A) + XOR_A_X (m_A) break; case 0xB0: /* OR A,B */ - OR_A_X (cpustate->B) + OR_A_X (m_B) break; case 0xB1: /* OR A,C */ - OR_A_X (cpustate->C) + OR_A_X (m_C) break; case 0xB2: /* OR A,D */ - OR_A_X (cpustate->D) + OR_A_X (m_D) break; case 0xB3: /* OR A,E */ - OR_A_X (cpustate->E) + OR_A_X (m_E) break; case 0xB4: /* OR A,H */ - OR_A_X (cpustate->H) + OR_A_X (m_H) break; case 0xB5: /* OR A,L */ - OR_A_X (cpustate->L) + OR_A_X (m_L) break; case 0xB6: /* OR A,(HL) */ - x = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + x = mem_read_byte( ( m_H << 8 ) | m_L ); OR_A_X (x) break; case 0xB7: /* OR A,A */ - OR_A_X (cpustate->A) + OR_A_X (m_A) break; case 0xB8: /* CP A,B */ - CP_A_X (cpustate->B) + CP_A_X (m_B) break; case 0xB9: /* CP A,C */ - CP_A_X (cpustate->C) + CP_A_X (m_C) break; case 0xBA: /* CP A,D */ - CP_A_X (cpustate->D) + CP_A_X (m_D) break; case 0xBB: /* CP A,E */ - CP_A_X (cpustate->E) + CP_A_X (m_E) break; case 0xBC: /* CP A,H */ - CP_A_X (cpustate->H) + CP_A_X (m_H) break; case 0xBD: /* CP A,L */ - CP_A_X (cpustate->L) + CP_A_X (m_L) break; case 0xBE: /* CP A,(HL) */ - x = mem_ReadByte (cpustate, ( cpustate->H << 8 ) | cpustate->L); + x = mem_read_byte( ( m_H << 8 ) | m_L ); CP_A_X (x) break; case 0xBF: /* CP A,A */ - CP_A_X (cpustate->A) + CP_A_X (m_A) break; case 0xC0: /* RET NZ */ - CYCLES_PASSED( 4 ); - if (!(cpustate->F & FLAG_Z)) + cycles_passed( 4 ); + if (!(m_F & FLAG_Z)) { - cpustate->PC = mem_ReadWord (cpustate, cpustate->SP); - cpustate->SP += 2; - CYCLES_PASSED( 4 ); + m_PC = mem_read_word( m_SP ); + m_SP += 2; + cycles_passed( 4 ); } break; case 0xC1: /* POP BC */ - POP( cpustate->B, cpustate->C ); + POP( m_B, m_C ); break; case 0xC2: /* JP NZ,n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - if ( ! (cpustate->F & FLAG_Z) ) + if ( ! (m_F & FLAG_Z) ) { - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_PC = addr; + cycles_passed( 4 ); } } break; case 0xC3: /* JP n16 */ - cpustate->PC = mem_ReadWord (cpustate, cpustate->PC); - CYCLES_PASSED( 4 ); + m_PC = mem_read_word( m_PC ); + cycles_passed( 4 ); break; case 0xC4: /* CALL NZ,n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - if ( ! (cpustate->F & FLAG_Z) ) + if ( ! (m_F & FLAG_Z) ) { - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = addr; + cycles_passed( 4 ); } } break; case 0xC5: /* PUSH BC */ - PUSH( cpustate->B, cpustate->C ); - CYCLES_PASSED( 4 ); + PUSH( m_B, m_C ); + cycles_passed( 4 ); break; case 0xC6: /* ADD A,n8 */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); ADD_A_X (x) break; case 0xC7: /* RST 0 */ - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 0; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 0; + cycles_passed( 4 ); break; case 0xC8: /* RET Z */ - CYCLES_PASSED( 4 ); - if (cpustate->F & FLAG_Z) + cycles_passed( 4 ); + if (m_F & FLAG_Z) { - cpustate->PC = mem_ReadWord (cpustate, cpustate->SP); - cpustate->SP += 2; - CYCLES_PASSED( 4 ); + m_PC = mem_read_word( m_SP ); + m_SP += 2; + cycles_passed( 4 ); } break; case 0xC9: /* RET */ - cpustate->PC = mem_ReadWord (cpustate, cpustate->SP); - cpustate->SP += 2; - CYCLES_PASSED( 4 ); + m_PC = mem_read_word( m_SP ); + m_SP += 2; + cycles_passed( 4 ); break; case 0xCA: /* JP Z,n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - if (cpustate->F & FLAG_Z) + if (m_F & FLAG_Z) { - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_PC = addr; + cycles_passed( 4 ); } } break; case 0xCB: /* PREFIX! */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); switch (x) { #include "opc_cb.h" @@ -1221,61 +1222,61 @@ case 0xCB: /* PREFIX! */ break; case 0xCC: /* CALL Z,n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - if (cpustate->F & FLAG_Z) + if (m_F & FLAG_Z) { - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = addr; + cycles_passed( 4 ); } } break; case 0xCD: /* CALL n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = addr; + cycles_passed( 4 ); } break; case 0xCE: /* ADC A,n8 */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); ADC_A_X (x) break; case 0xCF: /* RST 8 */ - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 8; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 8; + cycles_passed( 4 ); break; case 0xD0: /* RET NC */ - CYCLES_PASSED( 4 ); - if (!(cpustate->F & FLAG_C)) + cycles_passed( 4 ); + if (!(m_F & FLAG_C)) { - cpustate->PC = mem_ReadWord (cpustate, cpustate->SP); - cpustate->SP += 2; - CYCLES_PASSED( 4 ); + m_PC = mem_read_word( m_SP ); + m_SP += 2; + cycles_passed( 4 ); } break; case 0xD1: /* POP DE */ - POP( cpustate->D, cpustate->E ); + POP( m_D, m_E ); break; case 0xD2: /* JP NC,n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - if ( ! (cpustate->F & FLAG_C) ) + if ( ! (m_F & FLAG_C) ) { - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_PC = addr; + cycles_passed( 4 ); } } break; @@ -1283,57 +1284,57 @@ case 0xD3: /* EH? */ break; case 0xD4: /* CALL NC,n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - if ( ! (cpustate->F & FLAG_C) ) + if ( ! (m_F & FLAG_C) ) { - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = addr; + cycles_passed( 4 ); } } break; case 0xD5: /* PUSH DE */ - PUSH( cpustate->D, cpustate->E ); - CYCLES_PASSED( 4 ); + PUSH( m_D, m_E ); + cycles_passed( 4 ); break; case 0xD6: /* SUB A,n8 */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); SUB_A_X (x) break; case 0xD7: /* RST $10 */ - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 0x10; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 0x10; + cycles_passed( 4 ); break; case 0xD8: /* RET C */ - CYCLES_PASSED( 4 ); - if (cpustate->F & FLAG_C) + cycles_passed( 4 ); + if (m_F & FLAG_C) { - cpustate->PC = mem_ReadWord (cpustate, cpustate->SP); - cpustate->SP += 2; - CYCLES_PASSED( 4 ); + m_PC = mem_read_word( m_SP ); + m_SP += 2; + cycles_passed( 4 ); } break; case 0xD9: /* RETI */ - cpustate->PC = mem_ReadWord (cpustate, cpustate->SP); - cpustate->SP += 2; - cpustate->enable |= IME; - CYCLES_PASSED( 4 ); + m_PC = mem_read_word( m_SP ); + m_SP += 2; + m_enable |= IME; + cycles_passed( 4 ); break; case 0xDA: /* JP C,n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - if (cpustate->F & FLAG_C) + if (m_F & FLAG_C) { - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_PC = addr; + cycles_passed( 4 ); } } break; @@ -1341,15 +1342,15 @@ case 0xDB: /* EH? */ break; case 0xDC: /* CALL C,n16 */ { - UINT16 addr = mem_ReadWord (cpustate, cpustate->PC); - cpustate->PC += 2; + UINT16 addr = mem_read_word( m_PC ); + m_PC += 2; - if (cpustate->F & FLAG_C) + if (m_F & FLAG_C) { - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = addr; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = addr; + cycles_passed( 4 ); } } break; @@ -1357,46 +1358,46 @@ case 0xDD: /* EH? */ break; case 0xDE: /* SBC A,n8 */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); SBC_A_X (x) break; case 0xDF: /* RST $18 */ - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 0x18; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 0x18; + cycles_passed( 4 ); break; case 0xE0: /* LD ($FF00+n8),A */ { - UINT8 v = mem_ReadByte (cpustate, cpustate->PC++); - mem_WriteByte (cpustate, 0xFF00 + v, cpustate->A); + UINT8 v = mem_read_byte( m_PC++ ); + mem_write_byte( 0xFF00 + v, m_A ); } break; case 0xE1: /* POP HL */ - POP( cpustate->H, cpustate->L ); + POP( m_H, m_L ); break; case 0xE2: /* LD ($FF00+C),A */ - mem_WriteByte (cpustate, (UINT16) (0xFF00 + cpustate->C), cpustate->A); + mem_write_byte( 0xFF00 + m_C, m_A ); break; case 0xE3: /* EH? */ break; case 0xE4: /* EH? */ break; case 0xE5: /* PUSH HL */ - PUSH( cpustate->H, cpustate->L ); - CYCLES_PASSED( 4 ); + PUSH( m_H, m_L ); + cycles_passed( 4 ); break; case 0xE6: /* AND A,n8 */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); AND_A_X (x) break; case 0xE7: /* RST $20 */ - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 0x20; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 0x20; + cycles_passed( 4 ); break; case 0xE8: /* ADD SP,n8 */ /* @@ -1409,33 +1410,33 @@ case 0xE8: /* ADD SP,n8 */ { register INT32 n; - n = (INT8) mem_ReadByte (cpustate, cpustate->PC++); + n = (INT8) mem_read_byte( m_PC++ ); - if ( ( cpustate->SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF ) + if ( ( m_SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF ) { - cpustate->F = FLAG_C; + m_F = FLAG_C; } else { - cpustate->F = 0; + m_F = 0; } - if ( ( cpustate->SP & 0x0F ) + ( n & 0x0F ) > 0x0F ) + if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F ) { - cpustate->F |= FLAG_H; + m_F |= FLAG_H; } - cpustate->SP = (UINT16) ( cpustate->SP + n ); + m_SP = (UINT16) ( m_SP + n ); } - CYCLES_PASSED( 8 ); + cycles_passed( 8 ); break; case 0xE9: /* JP (HL) */ - cpustate->PC = ( cpustate->H << 8 ) | cpustate->L; + m_PC = ( m_H << 8 ) | m_L; break; case 0xEA: /* LD (n16),A */ - mem_WriteByte (cpustate, mem_ReadWord (cpustate, cpustate->PC), cpustate->A); - cpustate->PC += 2; + mem_write_byte( mem_read_word( m_PC ), m_A ); + m_PC += 2; break; case 0xEB: /* EH? */ break; @@ -1445,50 +1446,50 @@ case 0xED: /* EH? */ break; case 0xEE: /* XOR A,n8 */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); XOR_A_X (x) break; case 0xEF: /* RST $28 */ - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 0x28; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 0x28; + cycles_passed( 4 ); break; case 0xF0: /* LD A,($FF00+n8) */ { - UINT8 v = mem_ReadByte (cpustate, cpustate->PC++); - cpustate->A = mem_ReadByte (cpustate, 0xFF00 + v); + UINT8 v = mem_read_byte( m_PC++ ); + m_A = mem_read_byte( 0xFF00 + v ); } break; case 0xF1: /* POP AF */ - POP( cpustate->A, cpustate->F ); - cpustate->F &= 0xF0; + POP( m_A, m_F ); + m_F &= 0xF0; break; case 0xF2: /* LD A,($FF00+C) */ - cpustate->A = mem_ReadByte (cpustate, (UINT16) (0xFF00 + cpustate->C)); + m_A = mem_read_byte( 0xFF00 + m_C ); break; case 0xF3: /* DI */ - cpustate->ei_delay = 0; - cpustate->enable &= ~IME; + m_ei_delay = 0; + m_enable &= ~IME; break; case 0xF4: /* EH? */ break; case 0xF5: /* PUSH AF */ - cpustate->F &= 0xF0; - PUSH( cpustate->A, cpustate->F ); - CYCLES_PASSED( 4 ); + m_F &= 0xF0; + PUSH( m_A, m_F ); + cycles_passed( 4 ); break; case 0xF6: /* OR A,n8 */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); OR_A_X (x) break; case 0xF7: /* RST $30 */ - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 0x30; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 0x30; + cycles_passed( 4 ); break; case 0xF8: /* LD HL,SP+n8 */ /* @@ -1504,52 +1505,52 @@ case 0xF8: /* LD HL,SP+n8 */ { register INT32 n; - n = (INT8) mem_ReadByte (cpustate, cpustate->PC++); + n = (INT8) mem_read_byte( m_PC++ ); - if ( ( cpustate->SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF ) + if ( ( m_SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF ) { - cpustate->F = FLAG_C; + m_F = FLAG_C; } else { - cpustate->F = 0; + m_F = 0; } - if ( ( cpustate->SP & 0x0F ) + ( n & 0x0F ) > 0x0F ) + if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F ) { - cpustate->F |= FLAG_H; + m_F |= FLAG_H; } - UINT16 res = cpustate->SP + n; + UINT16 res = m_SP + n; - cpustate->L = res & 0xFF; - cpustate->H = res >> 8; + m_L = res & 0xFF; + m_H = res >> 8; } - CYCLES_PASSED( 4 ); + cycles_passed( 4 ); break; case 0xF9: /* LD SP,HL */ - cpustate->SP = ( cpustate->H << 8 ) | cpustate->L; - CYCLES_PASSED( 4 ); + m_SP = ( m_H << 8 ) | m_L; + cycles_passed( 4 ); break; case 0xFA: /* LD A,(n16) */ - cpustate->A = mem_ReadByte (cpustate, mem_ReadWord (cpustate, cpustate->PC)); - cpustate->PC += 2; + m_A = mem_read_byte( mem_read_word( m_PC ) ); + m_PC += 2; break; case 0xFB: /* EI */ - cpustate->enable |= IME; - cpustate->ei_delay = 1; + m_enable |= IME; + m_ei_delay = 1; break; case 0xFC: /* EH? */ break; case 0xFD: /* EH? */ break; case 0xFE: /* CP A,n8 */ - x = mem_ReadByte (cpustate, cpustate->PC++); + x = mem_read_byte( m_PC++ ); CP_A_X (x) break; case 0xFF: /* RST $38 */ - cpustate->SP -= 2; - mem_WriteWord (cpustate, cpustate->SP, cpustate->PC); - cpustate->PC = 0x38; - CYCLES_PASSED( 4 ); + m_SP -= 2; + mem_write_word( m_SP, m_PC ); + m_PC = 0x38; + cycles_passed( 4 ); break;