diff options
Diffstat (limited to 'src/emu/cpu/m6809/m6809.h')
-rw-r--r-- | src/emu/cpu/m6809/m6809.h | 190 |
1 files changed, 95 insertions, 95 deletions
diff --git a/src/emu/cpu/m6809/m6809.h b/src/emu/cpu/m6809/m6809.h index d6e7f3c0953..6d806672360 100644 --- a/src/emu/cpu/m6809/m6809.h +++ b/src/emu/cpu/m6809/m6809.h @@ -2,7 +2,7 @@ m6809.h - Portable Motorola 6809 emulator + Portable Motorola 6809 emulator **********************************************************************/ @@ -77,116 +77,116 @@ protected: // device_state_interface overrides virtual void state_string_export(const device_state_entry &entry, astring &string); - + // addressing modes enum { - ADDRESSING_MODE_IMMEDIATE = 0, - ADDRESSING_MODE_EA = 1, - ADDRESSING_MODE_REGISTER_A = 2, - ADDRESSING_MODE_REGISTER_B = 3, + ADDRESSING_MODE_IMMEDIATE = 0, + ADDRESSING_MODE_EA = 1, + ADDRESSING_MODE_REGISTER_A = 2, + ADDRESSING_MODE_REGISTER_B = 3, ADDRESSING_MODE_REGISTER_D = 4 }; // register transfer struct exgtfr_register { - UINT8 byte_value; - UINT16 word_value; + UINT8 byte_value; + UINT16 word_value; }; // flag bits in the cc register enum { - CC_C = 0x01, // Carry - CC_V = 0x02, // Overflow - CC_Z = 0x04, // Zero - CC_N = 0x08, // Negative - CC_I = 0x10, // Inhibit IRQ - CC_H = 0x20, // Half (auxiliary) carry - CC_F = 0x40, // Inhibit FIRQ - CC_E = 0x80 // Entire state pushed + CC_C = 0x01, // Carry + CC_V = 0x02, // Overflow + CC_Z = 0x04, // Zero + CC_N = 0x08, // Negative + CC_I = 0x10, // Inhibit IRQ + CC_H = 0x20, // Half (auxiliary) carry + CC_F = 0x40, // Inhibit FIRQ + CC_E = 0x80 // Entire state pushed }; // flag combinations enum { - CC_VC = CC_V | CC_C, - CC_ZC = CC_Z | CC_C, - CC_NZ = CC_N | CC_Z, - CC_NZC = CC_N | CC_Z | CC_C, - CC_NZV = CC_N | CC_Z | CC_V, - CC_NZVC = CC_N | CC_Z | CC_V | CC_C, + CC_VC = CC_V | CC_C, + CC_ZC = CC_Z | CC_C, + CC_NZ = CC_N | CC_Z, + CC_NZC = CC_N | CC_Z | CC_C, + CC_NZV = CC_N | CC_Z | CC_V, + CC_NZVC = CC_N | CC_Z | CC_V | CC_C, CC_HNZVC = CC_H | CC_N | CC_Z | CC_V | CC_C }; // interrupt vectors enum { - VECTOR_SWI3 = 0xFFF2, - VECTOR_SWI2 = 0xFFF4, - VECTOR_FIRQ = 0xFFF6, - VECTOR_IRQ = 0xFFF8, - VECTOR_SWI = 0xFFFA, - VECTOR_NMI = 0xFFFC, - VECTOR_RESET_FFFE = 0xFFFE + VECTOR_SWI3 = 0xFFF2, + VECTOR_SWI2 = 0xFFF4, + VECTOR_FIRQ = 0xFFF6, + VECTOR_IRQ = 0xFFF8, + VECTOR_SWI = 0xFFFA, + VECTOR_NMI = 0xFFFC, + VECTOR_RESET_FFFE = 0xFFFE }; // CPU registers - PAIR16 m_pc; // program counter - PAIR16 m_ppc; // previous program counter - PAIR16 m_d; // accumulator a and b - PAIR16 m_x, m_y; // index registers - PAIR16 m_u, m_s; // stack pointers - UINT8 m_dp; // direct page register - UINT8 m_cc; - PAIR16 m_temp; - UINT8 m_opcode; + PAIR16 m_pc; // program counter + PAIR16 m_ppc; // previous program counter + PAIR16 m_d; // accumulator a and b + PAIR16 m_x, m_y; // index registers + PAIR16 m_u, m_s; // stack pointers + UINT8 m_dp; // direct page register + UINT8 m_cc; + PAIR16 m_temp; + UINT8 m_opcode; // other internal state - bool m_nmi_line; - bool m_nmi_asserted; - bool m_firq_line; - bool m_irq_line; - bool m_lds_encountered; - int m_icount; - int m_addressing_mode; - PAIR16 m_ea; // effective address + bool m_nmi_line; + bool m_nmi_asserted; + bool m_firq_line; + bool m_irq_line; + bool m_lds_encountered; + int m_icount; + int m_addressing_mode; + PAIR16 m_ea; // effective address // eat cycles - ATTR_FORCE_INLINE void eat(int cycles) { m_icount -= cycles; } + ATTR_FORCE_INLINE void eat(int cycles) { m_icount -= cycles; } void eat_remaining(); // read a byte from given memory location - ATTR_FORCE_INLINE UINT8 read_memory(UINT16 address) { eat(1); return m_program->read_byte(address); } + ATTR_FORCE_INLINE UINT8 read_memory(UINT16 address) { eat(1); return m_program->read_byte(address); } // write a byte to given memory location - ATTR_FORCE_INLINE void write_memory(UINT16 address, UINT8 data) { eat(1); m_program->write_byte(address, data); } + ATTR_FORCE_INLINE void write_memory(UINT16 address, UINT8 data) { eat(1); m_program->write_byte(address, data); } // read_opcode() is like read_memory() except it is used for reading opcodes. In the case of a system - // with memory mapped I/O, this function can be used to greatly speed up emulation. - ATTR_FORCE_INLINE UINT8 read_opcode(UINT16 address) { eat(1); return m_direct->read_decrypted_byte(address); } + // with memory mapped I/O, this function can be used to greatly speed up emulation. + ATTR_FORCE_INLINE UINT8 read_opcode(UINT16 address) { eat(1); return m_direct->read_decrypted_byte(address); } // read_opcode_arg() is identical to read_opcode() except it is used for reading opcode arguments. This // difference can be used to support systems that use different encoding mechanisms for opcodes // and opcode arguments. - ATTR_FORCE_INLINE UINT8 read_opcode_arg(UINT16 address) { eat(1); return m_direct->read_raw_byte(address); } + ATTR_FORCE_INLINE UINT8 read_opcode_arg(UINT16 address) { eat(1); return m_direct->read_raw_byte(address); } // read_opcode() and bump the program counter - ATTR_FORCE_INLINE UINT8 read_opcode() { return read_opcode(m_pc.w++); } - ATTR_FORCE_INLINE UINT8 read_opcode_arg() { return read_opcode_arg(m_pc.w++); } + ATTR_FORCE_INLINE UINT8 read_opcode() { return read_opcode(m_pc.w++); } + ATTR_FORCE_INLINE UINT8 read_opcode_arg() { return read_opcode_arg(m_pc.w++); } // state stack - implemented as a UINT32 - void push_state(UINT8 state) { m_state = (m_state << 8) | state; } - UINT8 pop_state() { UINT8 result = (UINT8) m_state; m_state >>= 8; return result; } - void reset_state() { m_state = 0; } + void push_state(UINT8 state) { m_state = (m_state << 8) | state; } + UINT8 pop_state() { UINT8 result = (UINT8) m_state; m_state >>= 8; return result; } + void reset_state() { m_state = 0; } // effective address reading/writing - UINT8 read_ea() { return read_memory(m_ea.w); } - void write_ea(UINT8 data) { write_memory(m_ea.w, data); } - void set_ea(UINT16 ea) { m_ea.w = ea; m_addressing_mode = ADDRESSING_MODE_EA; } - void set_ea_h(UINT8 ea_h) { m_ea.b.h = ea_h; } - void set_ea_l(UINT8 ea_l) { m_ea.b.l = ea_l; m_addressing_mode = ADDRESSING_MODE_EA; } + UINT8 read_ea() { return read_memory(m_ea.w); } + void write_ea(UINT8 data) { write_memory(m_ea.w, data); } + void set_ea(UINT16 ea) { m_ea.w = ea; m_addressing_mode = ADDRESSING_MODE_EA; } + void set_ea_h(UINT8 ea_h) { m_ea.b.h = ea_h; } + void set_ea_l(UINT8 ea_l) { m_ea.b.l = ea_l; m_addressing_mode = ADDRESSING_MODE_EA; } // operand reading/writing UINT8 read_operand(); @@ -203,20 +203,20 @@ protected: void mul(); // miscellaneous - void nop() { } + void nop() { } template<class T> T rotate_right(T value); template<class T> UINT32 rotate_left(T value); - void set_a() { m_addressing_mode = ADDRESSING_MODE_REGISTER_A; } - void set_b() { m_addressing_mode = ADDRESSING_MODE_REGISTER_B; } - void set_d() { m_addressing_mode = ADDRESSING_MODE_REGISTER_D; } - void set_imm() { m_addressing_mode = ADDRESSING_MODE_IMMEDIATE; } - void set_regop8(UINT8 ®) { m_reg8 = ® m_reg16 = NULL; } - void set_regop16(PAIR16 ®) { m_reg16 = ® m_reg8 = NULL; } - UINT8 ®op8() { assert(m_reg8 != NULL); return *m_reg8; } - PAIR16 ®op16() { assert(m_reg16 != NULL); return *m_reg16; } - bool is_register_register_op_16_bit() { return m_reg16 != NULL; } - bool add8_sets_h() { return true; } - bool hd6309_native_mode() { return false; } + void set_a() { m_addressing_mode = ADDRESSING_MODE_REGISTER_A; } + void set_b() { m_addressing_mode = ADDRESSING_MODE_REGISTER_B; } + void set_d() { m_addressing_mode = ADDRESSING_MODE_REGISTER_D; } + void set_imm() { m_addressing_mode = ADDRESSING_MODE_IMMEDIATE; } + void set_regop8(UINT8 ®) { m_reg8 = ® m_reg16 = NULL; } + void set_regop16(PAIR16 ®) { m_reg16 = ® m_reg8 = NULL; } + UINT8 ®op8() { assert(m_reg8 != NULL); return *m_reg8; } + PAIR16 ®op16() { assert(m_reg16 != NULL); return *m_reg16; } + bool is_register_register_op_16_bit() { return m_reg16 != NULL; } + bool add8_sets_h() { return true; } + bool hd6309_native_mode() { return false; } // index reg UINT16 &ireg(); @@ -226,20 +226,20 @@ protected: template<class T> T set_flags(UINT8 mask, T r); // branch conditions - ATTR_FORCE_INLINE bool cond_hi() { return !(m_cc & CC_ZC); } // BHI/BLS - ATTR_FORCE_INLINE bool cond_cc() { return !(m_cc & CC_C); } // BCC/BCS - ATTR_FORCE_INLINE bool cond_ne() { return !(m_cc & CC_Z); } // BNE/BEQ - ATTR_FORCE_INLINE bool cond_vc() { return !(m_cc & CC_V); } // BVC/BVS - ATTR_FORCE_INLINE bool cond_pl() { return !(m_cc & CC_N); } // BPL/BMI - ATTR_FORCE_INLINE bool cond_ge() { return (m_cc & CC_N ? true : false) == (m_cc & CC_V ? true : false); } // BGE/BLT - ATTR_FORCE_INLINE bool cond_gt() { return cond_ge() && !(m_cc & CC_Z); } // BGT/BLE - ATTR_FORCE_INLINE void set_cond(bool cond) { m_cond = cond; } - ATTR_FORCE_INLINE bool branch_taken() { return m_cond; } + ATTR_FORCE_INLINE bool cond_hi() { return !(m_cc & CC_ZC); } // BHI/BLS + ATTR_FORCE_INLINE bool cond_cc() { return !(m_cc & CC_C); } // BCC/BCS + ATTR_FORCE_INLINE bool cond_ne() { return !(m_cc & CC_Z); } // BNE/BEQ + ATTR_FORCE_INLINE bool cond_vc() { return !(m_cc & CC_V); } // BVC/BVS + ATTR_FORCE_INLINE bool cond_pl() { return !(m_cc & CC_N); } // BPL/BMI + ATTR_FORCE_INLINE bool cond_ge() { return (m_cc & CC_N ? true : false) == (m_cc & CC_V ? true : false); } // BGE/BLT + ATTR_FORCE_INLINE bool cond_gt() { return cond_ge() && !(m_cc & CC_Z); } // BGT/BLE + ATTR_FORCE_INLINE void set_cond(bool cond) { m_cond = cond; } + ATTR_FORCE_INLINE bool branch_taken() { return m_cond; } // interrupt registers - bool firq_saves_entire_state() { return false; } - UINT16 partial_state_registers() { return 0x81; } - UINT16 entire_state_registers() { return 0xFF; } + bool firq_saves_entire_state() { return false; } + UINT16 partial_state_registers() { return 0x81; } + UINT16 entire_state_registers() { return 0xFF; } // miscellaneous exgtfr_register read_exgtfr_register(UINT8 reg); @@ -252,19 +252,19 @@ protected: private: // address spaces - const address_space_config m_program_config; - address_space * m_program; - direct_read_data * m_direct; + const address_space_config m_program_config; + address_space * m_program; + direct_read_data * m_direct; // other state - UINT32 m_state; - int m_reg; - UINT8 * m_reg8; - PAIR16 * m_reg16; - bool m_cond; + UINT32 m_state; + int m_reg; + UINT8 * m_reg8; + PAIR16 * m_reg16; + bool m_cond; // incidentals - int m_clock_divider; + int m_clock_divider; // functions void execute_one(); |