Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-06 17:08:28 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

z8.c: Modernized cpu core. [Wilbert Pol]

Browse Source
This commit is contained in:
Wilbert Pol 2013-12-20 21:18:51 +00:00
parent 3faea5bc66
commit 37866bccb3
3 changed files with 772 additions and 558 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

692
src/emu/cpu/z8/z8.c
View File

File diff suppressed because it is too large Load Diff

298
src/emu/cpu/z8/z8.h
View File

@ -23,15 +23,305 @@ enum
Z8_GENSP = STATE_GENSP Z8_GENSP = STATE_GENSP
}; };
class z8_device : public cpu_device
{
public:
// construction/destruction
z8_device(const machine_config &mconfig, device_type type, const char *name, const char *_tag, device_t *_owner, UINT32 _clock, const char *shortname, const char *source, int size);
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 6; }
virtual UINT32 execute_max_cycles() const { return 20; }
virtual UINT32 execute_input_lines() const { return 4; }
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 2 - 1) / 2; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 2); }
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
{
switch ( spacenum )
{
case AS_PROGRAM: return &m_program_config;
case AS_DATA: return &m_data_config;
case AS_IO: return &m_io_config;
default: return NULL;
}
return NULL;
}
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
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 3; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
private:
address_space_config m_program_config;
address_space_config m_data_config;
address_space_config m_io_config;
address_space *m_program;
direct_read_data *m_direct;
address_space *m_data;
address_space *m_io;
/* registers */
UINT16 m_pc; /* program counter */
UINT8 m_r[256]; /* register file */
UINT8 m_input[4]; /* port input latches */
UINT8 m_output[4]; /* port output latches */
UINT8 m_t0; /* timer 0 current count */
UINT8 m_t1; /* timer 1 current count */
/* fake registers */
UINT16 m_fake_sp; /* fake stack pointer */
UINT8 m_fake_r[16]; /* fake working registers */
/* interrupts */
int m_irq[6]; /* interrupts */
/* execution logic */
int m_icount; /* instruction counter */
/* timers */
emu_timer *m_t0_timer;
emu_timer *m_t1_timer;
TIMER_CALLBACK_MEMBER( t0_tick );
TIMER_CALLBACK_MEMBER( t1_tick );
inline UINT8 fetch();
inline UINT8 register_read(UINT8 offset);
inline UINT16 register_pair_read(UINT8 offset);
inline void register_write(UINT8 offset, UINT8 data);
inline void register_pair_write(UINT8 offset, UINT16 data);
inline UINT8 get_working_register(int offset);
inline UINT8 get_register(UINT8 offset);
inline UINT8 get_intermediate_register(int offset);
inline void stack_push_byte(UINT8 src);
inline void stack_push_word(UINT16 src);
inline UINT8 stack_pop_byte();
inline UINT16 stack_pop_word();
inline void set_flag(UINT8 flag, int state);
inline void clear(UINT8 dst);
inline void load(UINT8 dst, UINT8 src);
inline void load_from_memory(address_space *space);
inline void load_to_memory(address_space *space);
inline void load_from_memory_autoinc(address_space *space);
inline void load_to_memory_autoinc(address_space *space);
inline void pop(UINT8 dst);
inline void push(UINT8 src);
inline void add_carry(UINT8 dst, INT8 src);
inline void add(UINT8 dst, INT8 src);
inline void compare(UINT8 dst, UINT8 src);
inline void decimal_adjust(UINT8 dst);
inline void decrement(UINT8 dst);
inline void decrement_word(UINT8 dst);
inline void increment(UINT8 dst);
inline void increment_word(UINT8 dst);
inline void subtract_carry(UINT8 dst, UINT8 src);
inline void subtract(UINT8 dst, UINT8 src);
inline void _and(UINT8 dst, UINT8 src);
inline void complement(UINT8 dst);
inline void _or(UINT8 dst, UINT8 src);
inline void _xor(UINT8 dst, UINT8 src);
inline void call(UINT16 dst);
inline void jump(UINT16 dst);
inline int check_condition_code(int cc);
inline void test_complement_under_mask(UINT8 dst, UINT8 src);
inline void test_under_mask(UINT8 dst, UINT8 src);
inline void rotate_left(UINT8 dst);
inline void rotate_left_carry(UINT8 dst);
inline void rotate_right(UINT8 dst);
inline void rotate_right_carry(UINT8 dst);
inline void shift_right_arithmetic(UINT8 dst);
inline void swap(UINT8 dst);
#define INSTRUCTION(inst) void inst(UINT8 opcode, int *cycles);
INSTRUCTION( illegal );
INSTRUCTION( clr_R1 );
INSTRUCTION( clr_IR1 );
INSTRUCTION( ld_r1_IM );
INSTRUCTION( ld_r1_R2 );
INSTRUCTION( ld_r2_R1 );
INSTRUCTION( ld_Ir1_r2 );
INSTRUCTION( ld_R2_IR1 );
INSTRUCTION( ld_r1_x_R2 );
INSTRUCTION( ld_r2_x_R1 );
INSTRUCTION( ld_r1_r2 );
INSTRUCTION( ld_r1_Ir2 );
INSTRUCTION( ld_R2_R1 );
INSTRUCTION( ld_IR2_R1 );
INSTRUCTION( ld_R1_IM );
INSTRUCTION( ld_IR1_IM );
INSTRUCTION( ldc_r1_Irr2 );
INSTRUCTION( ldc_r2_Irr1 );
INSTRUCTION( ldci_Ir1_Irr2 );
INSTRUCTION( ldci_Ir2_Irr1 );
INSTRUCTION( lde_r1_Irr2 );
INSTRUCTION( lde_r2_Irr1 );
INSTRUCTION( ldei_Ir1_Irr2 );
INSTRUCTION( ldei_Ir2_Irr1 );
INSTRUCTION( pop_R1 );
INSTRUCTION( pop_IR1 );
INSTRUCTION( push_R2 );
INSTRUCTION( push_IR2 );
INSTRUCTION( adc_r1_r2 );
INSTRUCTION( adc_r1_Ir2 );
INSTRUCTION( adc_R2_R1 );
INSTRUCTION( adc_IR2_R1 );
INSTRUCTION( adc_R1_IM );
INSTRUCTION( adc_IR1_IM );
INSTRUCTION( add_r1_r2 );
INSTRUCTION( add_r1_Ir2 );
INSTRUCTION( add_R2_R1 );
INSTRUCTION( add_IR2_R1 );
INSTRUCTION( add_R1_IM );
INSTRUCTION( add_IR1_IM );
INSTRUCTION( cp_r1_r2 );
INSTRUCTION( cp_r1_Ir2 );
INSTRUCTION( cp_R2_R1 );
INSTRUCTION( cp_IR2_R1 );
INSTRUCTION( cp_R1_IM );
INSTRUCTION( cp_IR1_IM );
INSTRUCTION( da_R1 );
INSTRUCTION( da_IR1 );
INSTRUCTION( dec_R1 );
INSTRUCTION( dec_IR1 );
INSTRUCTION( decw_RR1 );
INSTRUCTION( decw_IR1 );
INSTRUCTION( inc_r1 );
INSTRUCTION( inc_R1 );
INSTRUCTION( inc_IR1 );
INSTRUCTION( incw_RR1 );
INSTRUCTION( incw_IR1 );
INSTRUCTION( sbc_r1_r2 );
INSTRUCTION( sbc_r1_Ir2 );
INSTRUCTION( sbc_R2_R1 );
INSTRUCTION( sbc_IR2_R1 );
INSTRUCTION( sbc_R1_IM );
INSTRUCTION( sbc_IR1_IM );
INSTRUCTION( sub_r1_r2 );
INSTRUCTION( sub_r1_Ir2 );
INSTRUCTION( sub_R2_R1 );
INSTRUCTION( sub_IR2_R1 );
INSTRUCTION( sub_R1_IM );
INSTRUCTION( sub_IR1_IM );
INSTRUCTION( and_r1_r2 );
INSTRUCTION( and_r1_Ir2 );
INSTRUCTION( and_R2_R1 );
INSTRUCTION( and_IR2_R1 );
INSTRUCTION( and_R1_IM );
INSTRUCTION( and_IR1_IM );
INSTRUCTION( com_R1 );
INSTRUCTION( com_IR1 );
INSTRUCTION( or_r1_r2 );
INSTRUCTION( or_r1_Ir2 );
INSTRUCTION( or_R2_R1 );
INSTRUCTION( or_IR2_R1 );
INSTRUCTION( or_R1_IM );
INSTRUCTION( or_IR1_IM );
INSTRUCTION( xor_r1_r2 );
INSTRUCTION( xor_r1_Ir2 );
INSTRUCTION( xor_R2_R1 );
INSTRUCTION( xor_IR2_R1 );
INSTRUCTION( xor_R1_IM );
INSTRUCTION( xor_IR1_IM );
INSTRUCTION( call_IRR1 );
INSTRUCTION( call_DA );
INSTRUCTION( djnz_r1_RA );
INSTRUCTION( iret );
INSTRUCTION( ret );
INSTRUCTION( jp_IRR1 );
INSTRUCTION( jp_cc_DA )
INSTRUCTION( jr_cc_RA )
INSTRUCTION( tcm_r1_r2 );
INSTRUCTION( tcm_r1_Ir2 );
INSTRUCTION( tcm_R2_R1 );
INSTRUCTION( tcm_IR2_R1 );
INSTRUCTION( tcm_R1_IM );
INSTRUCTION( tcm_IR1_IM );
INSTRUCTION( tm_r1_r2 );
INSTRUCTION( tm_r1_Ir2 );
INSTRUCTION( tm_R2_R1 );
INSTRUCTION( tm_IR2_R1 );
INSTRUCTION( tm_R1_IM );
INSTRUCTION( tm_IR1_IM );
INSTRUCTION( rl_R1 );
INSTRUCTION( rl_IR1 );
INSTRUCTION( rlc_R1 );
INSTRUCTION( rlc_IR1 );
INSTRUCTION( rr_R1 );
INSTRUCTION( rr_IR1 );
INSTRUCTION( rrc_R1 );
INSTRUCTION( rrc_IR1 );
INSTRUCTION( sra_R1 );
INSTRUCTION( sra_IR1 );
INSTRUCTION( swap_R1 );
INSTRUCTION( swap_IR1 );
INSTRUCTION( ccf );
INSTRUCTION( di );
INSTRUCTION( ei );
INSTRUCTION( nop );
INSTRUCTION( rcf );
INSTRUCTION( scf );
INSTRUCTION( srp_IM );
#undef INSTRUCTION
typedef void (z8_device::*z8_opcode_func) (UINT8 opcode, int *cycles);
struct z8_opcode_map
{
z8_opcode_func function;
int execution_cycles;
int pipeline_cycles;
};
static const z8_opcode_map Z8601_OPCODE_MAP[256];
};
class z8601_device : public z8_device
{
public:
z8601_device(const machine_config &mconfig, const char *_tag, device_t *_owner, UINT32 _clock);
};
class ub8830d_device : public z8_device
{
public:
ub8830d_device(const machine_config &mconfig, const char *_tag, device_t *_owner, UINT32 _clock);
};
class z8611_device : public z8_device
{
public:
z8611_device(const machine_config &mconfig, const char *_tag, device_t *_owner, UINT32 _clock);
};
/* Zilog Z8601 */ /* Zilog Z8601 */
DECLARE_LEGACY_CPU_DEVICE(Z8601, z8601); extern const device_type Z8601;
/* VEB Mikroelektronik Erfurt UB8830D MME */ /* VEB Mikroelektronik Erfurt UB8830D MME */
DECLARE_LEGACY_CPU_DEVICE(UB8830D, ub8830d); extern const device_type UB8830D;
/* Zilog Z8611 */ /* Zilog Z8611 */
DECLARE_LEGACY_CPU_DEVICE(Z8611, z8611); extern const device_type Z8611;
CPU_DISASSEMBLE( z8 );
#endif #endif

340
src/emu/cpu/z8/z8ops.c
View File

@ -11,118 +11,118 @@
MACROS MACROS
***************************************************************************/ ***************************************************************************/
#define read(_reg) register_read(cpustate, _reg) #define read(_reg) register_read(_reg)
#define r(_data) get_working_register(cpustate, _data) #define r(_data) get_working_register(_data)
#define Ir(_data) get_intermediate_register(cpustate, get_working_register(cpustate, _data)) #define Ir(_data) get_intermediate_register(get_working_register(_data))
#define R get_register(cpustate, fetch(cpustate)) #define R get_register(fetch())
#define IR get_intermediate_register(cpustate, get_register(cpustate, fetch(cpustate))) #define IR get_intermediate_register(get_register(fetch()))
#define RR get_intermediate_register(cpustate, get_register(cpustate, fetch(cpustate))) #define RR get_intermediate_register(get_register(fetch()))
#define IM fetch(cpustate) #define IM fetch()
#define flag(_flag) ((cpustate->r[Z8_REGISTER_FLAGS] & Z8_FLAGS##_##_flag) ? 1 : 0) #define flag(_flag) ((m_r[Z8_REGISTER_FLAGS] & Z8_FLAGS##_##_flag) ? 1 : 0)
#define mode_r1_r2(_func) \ #define mode_r1_r2(_func) \
UINT8 dst_src = fetch(cpustate);\ UINT8 dst_src = fetch();\
UINT8 dst = r(dst_src >> 4);\ UINT8 dst = r(dst_src >> 4);\
UINT8 src = read(r(dst_src & 0x0f));\ UINT8 src = read(r(dst_src & 0x0f));\
_func(cpustate, dst, src); _func(dst, src);
#define mode_r1_Ir2(_func) \ #define mode_r1_Ir2(_func) \
UINT8 dst_src = fetch(cpustate);\ UINT8 dst_src = fetch();\
UINT8 dst = r(dst_src >> 4);\ UINT8 dst = r(dst_src >> 4);\
UINT8 src = read(Ir(dst_src & 0x0f));\ UINT8 src = read(Ir(dst_src & 0x0f));\
_func(cpustate, dst, src); _func(dst, src);
#define mode_R2_R1(_func) \ #define mode_R2_R1(_func) \
UINT8 src = read(R);\ UINT8 src = read(R);\
UINT8 dst = R;\ UINT8 dst = R;\
_func(cpustate, dst, src); _func(dst, src);
#define mode_IR2_R1(_func) \ #define mode_IR2_R1(_func) \
UINT8 src = read(R);\ UINT8 src = read(R);\
UINT8 dst = IR;\ UINT8 dst = IR;\
_func(cpustate, dst, src); _func(dst, src);
#define mode_R1_IM(_func) \ #define mode_R1_IM(_func) \
UINT8 dst = R;\ UINT8 dst = R;\
UINT8 src = IM;\ UINT8 src = IM;\
_func(cpustate, dst, src); _func(dst, src);
#define mode_IR1_IM(_func) \ #define mode_IR1_IM(_func) \
UINT8 dst = IR;\ UINT8 dst = IR;\
UINT8 src = IM;\ UINT8 src = IM;\
_func(cpustate, dst, src); _func(dst, src);
#define mode_r1(_func) \ #define mode_r1(_func) \
UINT8 dst = r(opcode >> 4);\ UINT8 dst = r(opcode >> 4);\
_func(cpustate, dst); _func(dst);
#define mode_R1(_func) \ #define mode_R1(_func) \
UINT8 dst = R;\ UINT8 dst = R;\
_func(cpustate, dst); _func(dst);
#define mode_RR1(_func) \ #define mode_RR1(_func) \
UINT8 dst = R;\ UINT8 dst = R;\
_func(cpustate, dst); _func(dst);
#define mode_IR1(_func) \ #define mode_IR1(_func) \
UINT8 dst = IR;\ UINT8 dst = IR;\
_func(cpustate, dst); _func(dst);
#define mode_r1_IM(_func) \ #define mode_r1_IM(_func) \
UINT8 dst = r(opcode >> 4);\ UINT8 dst = r(opcode >> 4);\
UINT8 src = IM;\ UINT8 src = IM;\
_func(cpustate, dst, src); _func(dst, src);
#define mode_r1_R2(_func) \ #define mode_r1_R2(_func) \
UINT8 dst = r(opcode >> 4);\ UINT8 dst = r(opcode >> 4);\
UINT8 src = read(R);\ UINT8 src = read(R);\
_func(cpustate, dst, src); _func(dst, src);
#define mode_r2_R1(_func) \ #define mode_r2_R1(_func) \
UINT8 src = read(r(opcode >> 4));\ UINT8 src = read(r(opcode >> 4));\
UINT8 dst = R;\ UINT8 dst = R;\
_func(cpustate, dst, src); _func(dst, src);
#define mode_Ir1_r2(_func) \ #define mode_Ir1_r2(_func) \
UINT8 dst_src = fetch(cpustate);\ UINT8 dst_src = fetch();\
UINT8 dst = Ir(dst_src >> 4);\ UINT8 dst = Ir(dst_src >> 4);\
UINT8 src = read(r(dst_src & 0x0f));\ UINT8 src = read(r(dst_src & 0x0f));\
_func(cpustate, dst, src); _func(dst, src);
#define mode_R2_IR1(_func) \ #define mode_R2_IR1(_func) \
UINT8 src = read(R);\ UINT8 src = read(R);\
UINT8 dst = IR;\ UINT8 dst = IR;\
_func(cpustate, dst, src); _func(dst, src);
#define mode_r1_x_R2(_func) \ #define mode_r1_x_R2(_func) \
UINT8 dst_src = fetch(cpustate);\ UINT8 dst_src = fetch();\
UINT8 dst = r(dst_src >> 4);\ UINT8 dst = r(dst_src >> 4);\
UINT8 src = read(read(r(dst_src & 0x0f)) + R);\ UINT8 src = read(read(r(dst_src & 0x0f)) + R);\
_func(cpustate, dst, src); _func(dst, src);
#define mode_r2_x_R1(_func) \ #define mode_r2_x_R1(_func) \
UINT8 dst_src = fetch(cpustate);\ UINT8 dst_src = fetch();\
UINT8 dst = R + read(r(dst_src & 0x0f));\ UINT8 dst = R + read(r(dst_src & 0x0f));\
UINT8 src = read(r(dst_src >> 4));\ UINT8 src = read(r(dst_src >> 4));\
_func(cpustate, dst, src); _func(dst, src);
/*************************************************************************** /***************************************************************************
LOAD INSTRUCTIONS LOAD INSTRUCTIONS
***************************************************************************/ ***************************************************************************/
static void clear(z8_state *cpustate, UINT8 dst) void z8_device::clear(UINT8 dst)
{ {
/* dst <- 0 */ /* dst <- 0 */
register_write(cpustate, dst, 0); register_write(dst, 0);
} }
INSTRUCTION( clr_R1 ) { mode_R1(clear) } INSTRUCTION( clr_R1 ) { mode_R1(clear) }
INSTRUCTION( clr_IR1 ) { mode_IR1(clear) } INSTRUCTION( clr_IR1 ) { mode_IR1(clear) }
static void load(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::load(UINT8 dst, UINT8 src)
{ {
/* dst <- src */ /* dst <- src */
register_write(cpustate, dst, src); register_write(dst, src);
} }
INSTRUCTION( ld_r1_IM ) { mode_r1_IM(load) } INSTRUCTION( ld_r1_IM ) { mode_r1_IM(load) }
@ -140,86 +140,86 @@ INSTRUCTION( ld_IR2_R1 ) { mode_IR2_R1(load) }
INSTRUCTION( ld_R1_IM ) { mode_R1_IM(load) } INSTRUCTION( ld_R1_IM ) { mode_R1_IM(load) }
INSTRUCTION( ld_IR1_IM ) { mode_IR1_IM(load) } INSTRUCTION( ld_IR1_IM ) { mode_IR1_IM(load) }
static void load_from_memory(z8_state *cpustate, address_space *space) void z8_device::load_from_memory(address_space *space)
{ {
UINT8 operands = fetch(cpustate); UINT8 operands = fetch();
UINT8 dst = get_working_register(cpustate, operands >> 4); UINT8 dst = get_working_register(operands >> 4);
UINT8 src = get_working_register(cpustate, operands & 0x0f); UINT8 src = get_working_register(operands & 0x0f);
UINT16 address = register_pair_read(cpustate, src); UINT16 address = register_pair_read(src);
UINT8 data = cpustate->direct->read_decrypted_byte(address); UINT8 data = m_direct->read_decrypted_byte(address);
register_write(cpustate, dst, data); register_write(dst, data);
} }
static void load_to_memory(z8_state *cpustate, address_space *space) void z8_device::load_to_memory(address_space *space)
{ {
UINT8 operands = fetch(cpustate); UINT8 operands = fetch();
UINT8 src = get_working_register(cpustate, operands >> 4); UINT8 src = get_working_register(operands >> 4);
UINT8 dst = get_working_register(cpustate, operands & 0x0f); UINT8 dst = get_working_register(operands & 0x0f);
UINT16 address = register_pair_read(cpustate, dst); UINT16 address = register_pair_read(dst);
UINT8 data = register_read(cpustate, src); UINT8 data = register_read(src);
cpustate->program->write_byte(address, data); m_program->write_byte(address, data);
} }
static void load_from_memory_autoinc(z8_state *cpustate, address_space *space) void z8_device::load_from_memory_autoinc(address_space *space)
{ {
UINT8 operands = fetch(cpustate); UINT8 operands = fetch();
UINT8 dst = get_working_register(cpustate, operands >> 4); UINT8 dst = get_working_register(operands >> 4);
UINT8 real_dst = get_intermediate_register(cpustate, dst); UINT8 real_dst = get_intermediate_register(dst);
UINT8 src = get_working_register(cpustate, operands & 0x0f); UINT8 src = get_working_register(operands & 0x0f);
UINT16 address = register_pair_read(cpustate, src); UINT16 address = register_pair_read(src);
UINT8 data = cpustate->direct->read_decrypted_byte(address); UINT8 data = m_direct->read_decrypted_byte(address);
register_write(cpustate, real_dst, data); register_write(real_dst, data);
register_write(cpustate, dst, real_dst + 1); register_write(dst, real_dst + 1);
register_pair_write(cpustate, src, address + 1); register_pair_write(src, address + 1);
} }
static void load_to_memory_autoinc(z8_state *cpustate, address_space *space) void z8_device::load_to_memory_autoinc(address_space *space)
{ {
UINT8 operands = fetch(cpustate); UINT8 operands = fetch();
UINT8 src = get_working_register(cpustate, operands >> 4); UINT8 src = get_working_register(operands >> 4);
UINT8 dst = get_working_register(cpustate, operands & 0x0f); UINT8 dst = get_working_register(operands & 0x0f);
UINT8 real_src = get_intermediate_register(cpustate, src); UINT8 real_src = get_intermediate_register(src);
UINT16 address = register_pair_read(cpustate, dst); UINT16 address = register_pair_read(dst);
UINT8 data = register_read(cpustate, real_src); UINT8 data = register_read(real_src);
cpustate->program->write_byte(address, data); m_program->write_byte(address, data);
register_pair_write(cpustate, dst, address + 1); register_pair_write(dst, address + 1);
register_write(cpustate, src, real_src + 1); register_write(src, real_src + 1);
} }
INSTRUCTION( ldc_r1_Irr2 ) { load_from_memory(cpustate, cpustate->program); } INSTRUCTION( ldc_r1_Irr2 ) { load_from_memory(m_program); }
INSTRUCTION( ldc_r2_Irr1 ) { load_to_memory(cpustate, cpustate->program); } INSTRUCTION( ldc_r2_Irr1 ) { load_to_memory(m_program); }
INSTRUCTION( ldci_Ir1_Irr2 ) { load_from_memory_autoinc(cpustate, cpustate->program); } INSTRUCTION( ldci_Ir1_Irr2 ) { load_from_memory_autoinc(m_program); }
INSTRUCTION( ldci_Ir2_Irr1 ) { load_to_memory_autoinc(cpustate, cpustate->program); } INSTRUCTION( ldci_Ir2_Irr1 ) { load_to_memory_autoinc(m_program); }
INSTRUCTION( lde_r1_Irr2 ) { load_from_memory(cpustate, cpustate->data); } INSTRUCTION( lde_r1_Irr2 ) { load_from_memory(m_data); }
INSTRUCTION( lde_r2_Irr1 ) { load_to_memory(cpustate, cpustate->data); } INSTRUCTION( lde_r2_Irr1 ) { load_to_memory(m_data); }
INSTRUCTION( ldei_Ir1_Irr2 ) { load_from_memory_autoinc(cpustate, cpustate->data); } INSTRUCTION( ldei_Ir1_Irr2 ) { load_from_memory_autoinc(m_data); }
INSTRUCTION( ldei_Ir2_Irr1 ) { load_to_memory_autoinc(cpustate, cpustate->data); } INSTRUCTION( ldei_Ir2_Irr1 ) { load_to_memory_autoinc(m_data); }
static void pop(z8_state *cpustate, UINT8 dst) void z8_device::pop(UINT8 dst)
{ {
/* dst <- @SP /* dst <- @SP
SP <- SP + 1 */ SP <- SP + 1 */
register_write(cpustate, dst, stack_pop_byte(cpustate)); register_write(dst, stack_pop_byte());
} }
INSTRUCTION( pop_R1 ) { mode_R1(pop) } INSTRUCTION( pop_R1 ) { mode_R1(pop) }
INSTRUCTION( pop_IR1 ) { mode_IR1(pop) } INSTRUCTION( pop_IR1 ) { mode_IR1(pop) }
static void push(z8_state *cpustate, UINT8 src) void z8_device::push(UINT8 src)
{ {
/* SP <- SP - 1 /* SP <- SP - 1
@SP <- src */ @SP <- src */
stack_push_byte(cpustate, read(src)); stack_push_byte(read(src));
} }
INSTRUCTION( push_R2 ) { mode_R1(push) } INSTRUCTION( push_R2 ) { mode_R1(push) }
@ -229,10 +229,10 @@ INSTRUCTION( push_IR2 ) { mode_IR1(push) }
ARITHMETIC INSTRUCTIONS ARITHMETIC INSTRUCTIONS
***************************************************************************/ ***************************************************************************/
static void add_carry(z8_state *cpustate, UINT8 dst, INT8 src) void z8_device::add_carry(UINT8 dst, INT8 src)
{ {
/* dst <- dst + src + C */ /* dst <- dst + src + C */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT16 new_data = data + src + flag(C); UINT16 new_data = data + src + flag(C);
set_flag_c(new_data & 0x100); set_flag_c(new_data & 0x100);
@ -242,7 +242,7 @@ static void add_carry(z8_state *cpustate, UINT8 dst, INT8 src)
set_flag_d(0); set_flag_d(0);
set_flag_h(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10)); set_flag_h(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10));
register_write(cpustate, dst, new_data & 0xff); register_write(dst, new_data & 0xff);
} }
INSTRUCTION( adc_r1_r2 ) { mode_r1_r2(add_carry) } INSTRUCTION( adc_r1_r2 ) { mode_r1_r2(add_carry) }
@ -252,10 +252,10 @@ INSTRUCTION( adc_IR2_R1 ) { mode_IR2_R1(add_carry) }
INSTRUCTION( adc_R1_IM ) { mode_R1_IM(add_carry) } INSTRUCTION( adc_R1_IM ) { mode_R1_IM(add_carry) }
INSTRUCTION( adc_IR1_IM ) { mode_IR1_IM(add_carry) } INSTRUCTION( adc_IR1_IM ) { mode_IR1_IM(add_carry) }
static void add(z8_state *cpustate, UINT8 dst, INT8 src) void z8_device::add(UINT8 dst, INT8 src)
{ {
/* dst <- dst + src */ /* dst <- dst + src */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT16 new_data = data + src; UINT16 new_data = data + src;
set_flag_c(new_data & 0x100); set_flag_c(new_data & 0x100);
@ -265,7 +265,7 @@ static void add(z8_state *cpustate, UINT8 dst, INT8 src)
set_flag_d(0); set_flag_d(0);
set_flag_h(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10)); set_flag_h(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10));
register_write(cpustate, dst, new_data & 0xff); register_write(dst, new_data & 0xff);
} }
INSTRUCTION( add_r1_r2 ) { mode_r1_r2(add) } INSTRUCTION( add_r1_r2 ) { mode_r1_r2(add) }
@ -275,10 +275,10 @@ INSTRUCTION( add_IR2_R1 ) { mode_IR2_R1(add) }
INSTRUCTION( add_R1_IM ) { mode_R1_IM(add) } INSTRUCTION( add_R1_IM ) { mode_R1_IM(add) }
INSTRUCTION( add_IR1_IM ) { mode_IR1_IM(add) } INSTRUCTION( add_IR1_IM ) { mode_IR1_IM(add) }
static void compare(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::compare(UINT8 dst, UINT8 src)
{ {
/* dst - src */ /* dst - src */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT16 new_data = data - src; UINT16 new_data = data - src;
set_flag_c(!(new_data & 0x100)); set_flag_c(!(new_data & 0x100));
@ -294,78 +294,78 @@ INSTRUCTION( cp_IR2_R1 ) { mode_IR2_R1(compare) }
INSTRUCTION( cp_R1_IM ) { mode_R1_IM(compare) } INSTRUCTION( cp_R1_IM ) { mode_R1_IM(compare) }
INSTRUCTION( cp_IR1_IM ) { mode_IR1_IM(compare) } INSTRUCTION( cp_IR1_IM ) { mode_IR1_IM(compare) }
static void decimal_adjust(z8_state *cpustate, UINT8 dst) void z8_device::decimal_adjust(UINT8 dst)
{ {
} }
INSTRUCTION( da_R1 ) { mode_R1(decimal_adjust) } INSTRUCTION( da_R1 ) { mode_R1(decimal_adjust) }
INSTRUCTION( da_IR1 ) { mode_IR1(decimal_adjust) } INSTRUCTION( da_IR1 ) { mode_IR1(decimal_adjust) }
static void decrement(z8_state *cpustate, UINT8 dst) void z8_device::decrement(UINT8 dst)
{ {
/* dst <- dst - 1 */ /* dst <- dst - 1 */
UINT8 data = register_read(cpustate, dst) - 1; UINT8 data = register_read(dst) - 1;
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
set_flag_v(data == 0x7f); set_flag_v(data == 0x7f);
register_write(cpustate, dst, data); register_write(dst, data);
} }
INSTRUCTION( dec_R1 ) { mode_R1(decrement) } INSTRUCTION( dec_R1 ) { mode_R1(decrement) }
INSTRUCTION( dec_IR1 ) { mode_IR1(decrement) } INSTRUCTION( dec_IR1 ) { mode_IR1(decrement) }
static void decrement_word(z8_state *cpustate, UINT8 dst) void z8_device::decrement_word(UINT8 dst)
{ {
/* dst <- dst - 1 */ /* dst <- dst - 1 */
UINT16 data = register_pair_read(cpustate, dst) - 1; UINT16 data = register_pair_read(dst) - 1;
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x8000); set_flag_s(data & 0x8000);
set_flag_v(data == 0x7fff); set_flag_v(data == 0x7fff);
register_pair_write(cpustate, dst, data); register_pair_write(dst, data);
} }
INSTRUCTION( decw_RR1 ) { mode_RR1(decrement_word) } INSTRUCTION( decw_RR1 ) { mode_RR1(decrement_word) }
INSTRUCTION( decw_IR1 ) { mode_IR1(decrement_word) } INSTRUCTION( decw_IR1 ) { mode_IR1(decrement_word) }
static void increment(z8_state *cpustate, UINT8 dst) void z8_device::increment(UINT8 dst)
{ {
/* dst <- dst + 1 */ /* dst <- dst + 1 */
UINT8 data = register_read(cpustate, dst) + 1; UINT8 data = register_read(dst) + 1;
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
set_flag_v(data == 0x80); set_flag_v(data == 0x80);
register_write(cpustate, dst, data); register_write(dst, data);
} }
INSTRUCTION( inc_r1 ) { mode_r1(increment) } INSTRUCTION( inc_r1 ) { mode_r1(increment) }
INSTRUCTION( inc_R1 ) { mode_R1(increment) } INSTRUCTION( inc_R1 ) { mode_R1(increment) }
INSTRUCTION( inc_IR1 ) { mode_IR1(increment) } INSTRUCTION( inc_IR1 ) { mode_IR1(increment) }
static void increment_word(z8_state *cpustate, UINT8 dst) void z8_device::increment_word(UINT8 dst)
{ {
/* dst <- dst + 1 */ /* dst <- dst + 1 */
UINT16 data = register_pair_read(cpustate, dst) + 1; UINT16 data = register_pair_read(dst) + 1;
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x8000); set_flag_s(data & 0x8000);
set_flag_v(data == 0x8000); set_flag_v(data == 0x8000);
register_pair_write(cpustate, dst, data); register_pair_write(dst, data);
} }
INSTRUCTION( incw_RR1 ) { mode_RR1(increment_word) } INSTRUCTION( incw_RR1 ) { mode_RR1(increment_word) }
INSTRUCTION( incw_IR1 ) { mode_IR1(increment_word) } INSTRUCTION( incw_IR1 ) { mode_IR1(increment_word) }
static void subtract_carry(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::subtract_carry(UINT8 dst, UINT8 src)
{ {
/* dst <- dst - src - C */ /* dst <- dst - src - C */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT16 new_data = data - src; UINT16 new_data = data - src;
set_flag_c(!(new_data & 0x100)); set_flag_c(!(new_data & 0x100));
@ -375,7 +375,7 @@ static void subtract_carry(z8_state *cpustate, UINT8 dst, UINT8 src)
set_flag_d(1); set_flag_d(1);
set_flag_h(!(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10))); set_flag_h(!(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10)));
register_write(cpustate, dst, new_data & 0xff); register_write(dst, new_data & 0xff);
} }
INSTRUCTION( sbc_r1_r2 ) { mode_r1_r2(subtract_carry) } INSTRUCTION( sbc_r1_r2 ) { mode_r1_r2(subtract_carry) }
@ -385,10 +385,10 @@ INSTRUCTION( sbc_IR2_R1 ) { mode_IR2_R1(subtract_carry) }
INSTRUCTION( sbc_R1_IM ) { mode_R1_IM(subtract_carry) } INSTRUCTION( sbc_R1_IM ) { mode_R1_IM(subtract_carry) }
INSTRUCTION( sbc_IR1_IM ) { mode_IR1_IM(subtract_carry) } INSTRUCTION( sbc_IR1_IM ) { mode_IR1_IM(subtract_carry) }
static void subtract(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::subtract(UINT8 dst, UINT8 src)
{ {
/* dst <- dst - src */ /* dst <- dst - src */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT16 new_data = data - src; UINT16 new_data = data - src;
set_flag_c(!(new_data & 0x100)); set_flag_c(!(new_data & 0x100));
@ -398,7 +398,7 @@ static void subtract(z8_state *cpustate, UINT8 dst, UINT8 src)
set_flag_d(1); set_flag_d(1);
set_flag_h(!(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10))); set_flag_h(!(((data & 0x1f) == 0x0f) && ((new_data & 0x1f) == 0x10)));
register_write(cpustate, dst, new_data & 0xff); register_write(dst, new_data & 0xff);
} }
INSTRUCTION( sub_r1_r2 ) { mode_r1_r2(subtract) } INSTRUCTION( sub_r1_r2 ) { mode_r1_r2(subtract) }
@ -412,11 +412,11 @@ INSTRUCTION( sub_IR1_IM ) { mode_IR1_IM(subtract) }
LOGICAL INSTRUCTIONS LOGICAL INSTRUCTIONS
***************************************************************************/ ***************************************************************************/
static void _and(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::_and(UINT8 dst, UINT8 src)
{ {
/* dst <- dst AND src */ /* dst <- dst AND src */
UINT8 data = register_read(cpustate, dst) & src; UINT8 data = register_read(dst) & src;
register_write(cpustate, dst, data); register_write(dst, data);
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
@ -430,11 +430,11 @@ INSTRUCTION( and_IR2_R1 ) { mode_IR2_R1(_and) }
INSTRUCTION( and_R1_IM ) { mode_R1_IM(_and) } INSTRUCTION( and_R1_IM ) { mode_R1_IM(_and) }
INSTRUCTION( and_IR1_IM ) { mode_IR1_IM(_and) } INSTRUCTION( and_IR1_IM ) { mode_IR1_IM(_and) }
static void complement(z8_state *cpustate, UINT8 dst) void z8_device::complement(UINT8 dst)
{ {
/* dst <- NOT dst */ /* dst <- NOT dst */
UINT8 data = register_read(cpustate, dst) ^ 0xff; UINT8 data = register_read(dst) ^ 0xff;
register_write(cpustate, dst, data); register_write(dst, data);
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
@ -444,11 +444,11 @@ static void complement(z8_state *cpustate, UINT8 dst)
INSTRUCTION( com_R1 ) { mode_R1(complement) } INSTRUCTION( com_R1 ) { mode_R1(complement) }
INSTRUCTION( com_IR1 ) { mode_IR1(complement) } INSTRUCTION( com_IR1 ) { mode_IR1(complement) }
static void _or(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::_or(UINT8 dst, UINT8 src)
{ {
/* dst <- dst OR src */ /* dst <- dst OR src */
UINT8 data = register_read(cpustate, dst) | src; UINT8 data = register_read(dst) | src;
register_write(cpustate, dst, data); register_write(dst, data);
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
@ -462,11 +462,11 @@ INSTRUCTION( or_IR2_R1 ) { mode_IR2_R1(_or) }
INSTRUCTION( or_R1_IM ) { mode_R1_IM(_or) } INSTRUCTION( or_R1_IM ) { mode_R1_IM(_or) }
INSTRUCTION( or_IR1_IM ) { mode_IR1_IM(_or) } INSTRUCTION( or_IR1_IM ) { mode_IR1_IM(_or) }
static void _xor(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::_xor(UINT8 dst, UINT8 src)
{ {
/* dst <- dst XOR src */ /* dst <- dst XOR src */
UINT8 data = register_read(cpustate, dst) ^ src; UINT8 data = register_read(dst) ^ src;
register_write(cpustate, dst, data); register_write(dst, data);
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
@ -484,28 +484,28 @@ INSTRUCTION( xor_IR1_IM ) { mode_IR1_IM(_xor) }
PROGRAM CONTROL INSTRUCTIONS PROGRAM CONTROL INSTRUCTIONS
***************************************************************************/ ***************************************************************************/
static void call(z8_state *cpustate, UINT16 dst) void z8_device::call(UINT16 dst)
{ {
stack_push_word(cpustate, cpustate->pc); stack_push_word(m_pc);
cpustate->pc = dst; m_pc = dst;
} }
INSTRUCTION( call_IRR1 ) { UINT16 dst = register_pair_read(cpustate, get_intermediate_register(cpustate, get_register(cpustate, fetch(cpustate)))); call(cpustate, dst); } INSTRUCTION( call_IRR1 ) { UINT16 dst = register_pair_read(get_intermediate_register(get_register(fetch()))); call(dst); }
INSTRUCTION( call_DA ) { UINT16 dst = (fetch(cpustate) << 8) | fetch(cpustate); call(cpustate, dst); } INSTRUCTION( call_DA ) { UINT16 dst = (fetch() << 8) | fetch(); call(dst); }
INSTRUCTION( djnz_r1_RA ) INSTRUCTION( djnz_r1_RA )
{ {
INT8 ra = (INT8)fetch(cpustate); INT8 ra = (INT8)fetch();
/* r <- r - 1 */ /* r <- r - 1 */
int r = get_working_register(cpustate, opcode >> 4); int r = get_working_register(opcode >> 4);
UINT8 data = register_read(cpustate, r) - 1; UINT8 data = register_read(r) - 1;
register_write(cpustate, r, data); register_write(r, data);
/* if r<>0, PC <- PC + dst */ /* if r<>0, PC <- PC + dst */
if (data != 0) if (data != 0)
{ {
cpustate->pc += ra; m_pc += ra;
*cycles += 2; *cycles += 2;
} }
} }
@ -514,32 +514,32 @@ INSTRUCTION( iret )
{ {
/* FLAGS <- @SP /* FLAGS <- @SP
SP <- SP + 1 */ SP <- SP + 1 */
register_write(cpustate, Z8_REGISTER_FLAGS, stack_pop_byte(cpustate)); register_write(Z8_REGISTER_FLAGS, stack_pop_byte());
/* PC <- @SP /* PC <- @SP
SP <- SP + 2 */ SP <- SP + 2 */
cpustate->pc = stack_pop_word(cpustate); m_pc = stack_pop_word();
/* IMR (7) <- 1 */ /* IMR (7) <- 1 */
cpustate->r[Z8_REGISTER_IMR] |= Z8_IMR_ENABLE; m_r[Z8_REGISTER_IMR] |= Z8_IMR_ENABLE;
} }
INSTRUCTION( ret ) INSTRUCTION( ret )
{ {
/* PC <- @SP /* PC <- @SP
SP <- SP + 2 */ SP <- SP + 2 */
cpustate->pc = stack_pop_word(cpustate); m_pc = stack_pop_word();
} }
static void jump(z8_state *cpustate, UINT16 dst) void z8_device::jump(UINT16 dst)
{ {
/* PC <- dst */ /* PC <- dst */
cpustate->pc = dst; m_pc = dst;
} }
INSTRUCTION( jp_IRR1 ) { jump(cpustate, register_pair_read(cpustate, IR)); } INSTRUCTION( jp_IRR1 ) { jump(register_pair_read(IR)); }
static int check_condition_code(z8_state *cpustate, int cc) int z8_device::check_condition_code(int cc)
{ {
int truth = 0; int truth = 0;
@ -568,25 +568,25 @@ static int check_condition_code(z8_state *cpustate, int cc)
INSTRUCTION( jp_cc_DA ) INSTRUCTION( jp_cc_DA )
{ {
UINT16 dst = (fetch(cpustate) << 8) | fetch(cpustate); UINT16 dst = (fetch() << 8) | fetch();
/* if cc is true, then PC <- dst */ /* if cc is true, then PC <- dst */
if (check_condition_code(cpustate, opcode >> 4)) if (check_condition_code(opcode >> 4))
{ {
jump(cpustate, dst); jump(dst);
*cycles += 2; *cycles += 2;
} }
} }
INSTRUCTION( jr_cc_RA ) INSTRUCTION( jr_cc_RA )
{ {
INT8 ra = (INT8)fetch(cpustate); INT8 ra = (INT8)fetch();
UINT16 dst = cpustate->pc + ra; UINT16 dst = m_pc + ra;
/* if cc is true, then PC <- dst */ /* if cc is true, then PC <- dst */
if (check_condition_code(cpustate, opcode >> 4)) if (check_condition_code(opcode >> 4))
{ {
jump(cpustate, dst); jump(dst);
*cycles += 2; *cycles += 2;
} }
} }
@ -595,10 +595,10 @@ INSTRUCTION( jr_cc_RA )
BIT MANIPULATION INSTRUCTIONS BIT MANIPULATION INSTRUCTIONS
***************************************************************************/ ***************************************************************************/
static void test_complement_under_mask(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::test_complement_under_mask(UINT8 dst, UINT8 src)
{ {
/* NOT(dst) AND src */ /* NOT(dst) AND src */
UINT8 data = (register_read(cpustate, dst) ^ 0xff) & src; UINT8 data = (register_read(dst) ^ 0xff) & src;
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
@ -612,10 +612,10 @@ INSTRUCTION( tcm_IR2_R1 ) { mode_IR2_R1(test_complement_under_mask) }
INSTRUCTION( tcm_R1_IM ) { mode_R1_IM(test_complement_under_mask) } INSTRUCTION( tcm_R1_IM ) { mode_R1_IM(test_complement_under_mask) }
INSTRUCTION( tcm_IR1_IM ) { mode_IR1_IM(test_complement_under_mask) } INSTRUCTION( tcm_IR1_IM ) { mode_IR1_IM(test_complement_under_mask) }
static void test_under_mask(z8_state *cpustate, UINT8 dst, UINT8 src) void z8_device::test_under_mask(UINT8 dst, UINT8 src)
{ {
/* dst AND src */ /* dst AND src */
UINT8 data = register_read(cpustate, dst) & src; UINT8 data = register_read(dst) & src;
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
@ -633,10 +633,10 @@ INSTRUCTION( tm_IR1_IM ) { mode_IR1_IM(test_under_mask) }
ROTATE AND SHIFT INSTRUCTIONS ROTATE AND SHIFT INSTRUCTIONS
***************************************************************************/ ***************************************************************************/
static void rotate_left(z8_state *cpustate, UINT8 dst) void z8_device::rotate_left(UINT8 dst)
{ {
/* << */ /* << */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT8 new_data = (data << 1) | BIT(data, 7); UINT8 new_data = (data << 1) | BIT(data, 7);
set_flag_c(data & 0x80); set_flag_c(data & 0x80);
@ -644,16 +644,16 @@ static void rotate_left(z8_state *cpustate, UINT8 dst)
set_flag_s(new_data & 0x80); set_flag_s(new_data & 0x80);
set_flag_v((data & 0x80) != (new_data & 0x80)); set_flag_v((data & 0x80) != (new_data & 0x80));
register_write(cpustate, dst, new_data); register_write(dst, new_data);
} }
INSTRUCTION( rl_R1 ) { mode_R1(rotate_left) } INSTRUCTION( rl_R1 ) { mode_R1(rotate_left) }
INSTRUCTION( rl_IR1 ) { mode_IR1(rotate_left) } INSTRUCTION( rl_IR1 ) { mode_IR1(rotate_left) }
static void rotate_left_carry(z8_state *cpustate, UINT8 dst) void z8_device::rotate_left_carry(UINT8 dst)
{ {
/* << C */ /* << C */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT8 new_data = (data << 1) | flag(C); UINT8 new_data = (data << 1) | flag(C);
set_flag_c(data & 0x80); set_flag_c(data & 0x80);
@ -661,16 +661,16 @@ static void rotate_left_carry(z8_state *cpustate, UINT8 dst)
set_flag_s(new_data & 0x80); set_flag_s(new_data & 0x80);
set_flag_v((data & 0x80) != (new_data & 0x80)); set_flag_v((data & 0x80) != (new_data & 0x80));
register_write(cpustate, dst, new_data); register_write(dst, new_data);
} }
INSTRUCTION( rlc_R1 ) { mode_R1(rotate_left_carry) } INSTRUCTION( rlc_R1 ) { mode_R1(rotate_left_carry) }
INSTRUCTION( rlc_IR1 ) { mode_IR1(rotate_left_carry) } INSTRUCTION( rlc_IR1 ) { mode_IR1(rotate_left_carry) }
static void rotate_right(z8_state *cpustate, UINT8 dst) void z8_device::rotate_right(UINT8 dst)
{ {
/* >> */ /* >> */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT8 new_data = ((data & 0x01) << 7) | (data >> 1); UINT8 new_data = ((data & 0x01) << 7) | (data >> 1);
set_flag_c(data & 0x01); set_flag_c(data & 0x01);
@ -678,16 +678,16 @@ static void rotate_right(z8_state *cpustate, UINT8 dst)
set_flag_s(new_data & 0x80); set_flag_s(new_data & 0x80);
set_flag_v((data & 0x80) != (new_data & 0x80)); set_flag_v((data & 0x80) != (new_data & 0x80));
register_write(cpustate, dst, new_data); register_write(dst, new_data);
} }
INSTRUCTION( rr_R1 ) { mode_R1(rotate_right) } INSTRUCTION( rr_R1 ) { mode_R1(rotate_right) }
INSTRUCTION( rr_IR1 ) { mode_IR1(rotate_right) } INSTRUCTION( rr_IR1 ) { mode_IR1(rotate_right) }
static void rotate_right_carry(z8_state *cpustate, UINT8 dst) void z8_device::rotate_right_carry(UINT8 dst)
{ {
/* >> C */ /* >> C */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT8 new_data = (flag(C) << 7) | (data >> 1); UINT8 new_data = (flag(C) << 7) | (data >> 1);
set_flag_c(data & 0x01); set_flag_c(data & 0x01);
@ -695,16 +695,16 @@ static void rotate_right_carry(z8_state *cpustate, UINT8 dst)
set_flag_s(new_data & 0x80); set_flag_s(new_data & 0x80);
set_flag_v((data & 0x80) != (new_data & 0x80)); set_flag_v((data & 0x80) != (new_data & 0x80));
register_write(cpustate, dst, new_data); register_write(dst, new_data);
} }
INSTRUCTION( rrc_R1 ) { mode_R1(rotate_right_carry) } INSTRUCTION( rrc_R1 ) { mode_R1(rotate_right_carry) }
INSTRUCTION( rrc_IR1 ) { mode_IR1(rotate_right_carry) } INSTRUCTION( rrc_IR1 ) { mode_IR1(rotate_right_carry) }
static void shift_right_arithmetic(z8_state *cpustate, UINT8 dst) void z8_device::shift_right_arithmetic(UINT8 dst)
{ {
/* */ /* */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
UINT8 new_data = (data & 0x80) | ((data >> 1) & 0x7f); UINT8 new_data = (data & 0x80) | ((data >> 1) & 0x7f);
set_flag_c(data & 0x01); set_flag_c(data & 0x01);
@ -712,18 +712,18 @@ static void shift_right_arithmetic(z8_state *cpustate, UINT8 dst)
set_flag_s(new_data & 0x80); set_flag_s(new_data & 0x80);
set_flag_v(0); set_flag_v(0);
register_write(cpustate, dst, new_data); register_write(dst, new_data);
} }
INSTRUCTION( sra_R1 ) { mode_R1(shift_right_arithmetic) } INSTRUCTION( sra_R1 ) { mode_R1(shift_right_arithmetic) }
INSTRUCTION( sra_IR1 ) { mode_IR1(shift_right_arithmetic) } INSTRUCTION( sra_IR1 ) { mode_IR1(shift_right_arithmetic) }
static void swap(z8_state *cpustate, UINT8 dst) void z8_device::swap(UINT8 dst)
{ {
/* dst(7-4) <-> dst(3-0) */ /* dst(7-4) <-> dst(3-0) */
UINT8 data = register_read(cpustate, dst); UINT8 data = register_read(dst);
data = (data << 4) | (data >> 4); data = (data << 4) | (data >> 4);
register_write(cpustate, dst, data); register_write(dst, data);
set_flag_z(data == 0); set_flag_z(data == 0);
set_flag_s(data & 0x80); set_flag_s(data & 0x80);
@ -737,10 +737,10 @@ INSTRUCTION( swap_IR1 ) { mode_IR1(swap) }
CPU CONTROL INSTRUCTIONS CPU CONTROL INSTRUCTIONS
***************************************************************************/ ***************************************************************************/
INSTRUCTION( ccf ) { cpustate->r[Z8_REGISTER_FLAGS] ^= Z8_FLAGS_C; } INSTRUCTION( ccf ) { m_r[Z8_REGISTER_FLAGS] ^= Z8_FLAGS_C; }
INSTRUCTION( di ) { cpustate->r[Z8_REGISTER_IMR] &= ~Z8_IMR_ENABLE; } INSTRUCTION( di ) { m_r[Z8_REGISTER_IMR] &= ~Z8_IMR_ENABLE; }
INSTRUCTION( ei ) { cpustate->r[Z8_REGISTER_IMR] |= Z8_IMR_ENABLE; } INSTRUCTION( ei ) { m_r[Z8_REGISTER_IMR] |= Z8_IMR_ENABLE; }
INSTRUCTION( nop ) { /* no operation */ } INSTRUCTION( nop ) { /* no operation */ }
INSTRUCTION( rcf ) { set_flag_c(0); } INSTRUCTION( rcf ) { set_flag_c(0); }
INSTRUCTION( scf ) { set_flag_c(1); } INSTRUCTION( scf ) { set_flag_c(1); }
INSTRUCTION( srp_IM ) { cpustate->r[Z8_REGISTER_RP] = fetch(cpustate); } INSTRUCTION( srp_IM ) { m_r[Z8_REGISTER_RP] = fetch(); }