Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-06 12:53:46 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

cpu/saturn: clean up a little (nw)

Browse Source
This commit is contained in:
Vas Crabb 2019-10-27 02:16:50 +11:00
parent 236c87cfea
commit d80e7f95eb
5 changed files with 524 additions and 554 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
scripts/src/cpu.lua
View File

@ -2031,8 +2031,8 @@ if (CPUS["SATURN"]~=null) then
files {
MAME_DIR .. "src/devices/cpu/saturn/saturn.cpp",
MAME_DIR .. "src/devices/cpu/saturn/saturn.h",
MAME_DIR .. "src/devices/cpu/saturn/satops.hxx",
MAME_DIR .. "src/devices/cpu/saturn/sattable.hxx",
MAME_DIR .. "src/devices/cpu/saturn/satops.ipp",
MAME_DIR .. "src/devices/cpu/saturn/sattable.ipp",
}
end

545
src/devices/cpu/saturn/satops.hxx → src/devices/cpu/saturn/satops.ipp
View File

File diff suppressed because it is too large Load Diff

68
src/devices/cpu/saturn/sattable.hxx → src/devices/cpu/saturn/sattable.ipp
View File

@ -1,34 +1,46 @@
// license:BSD-3-Clause
// copyright-holders:Peter Trauner,Antoine Mine
#define IRQ_ADDRESS 0xf
#define BEGIN_B 0
#define COUNT_B 2
#define BEGIN_X 0
#define COUNT_X 3
#define BEGIN_XS 2
#define COUNT_XS 1
#define BEGIN_A 0
#define COUNT_A 5
#define BEGIN_M 3
#define COUNT_M 12
#define BEGIN_S 15
#define COUNT_S 1
#define BEGIN_W 0
#define COUNT_W 16
static const int adr_a_begin[]={
-1, -1, BEGIN_XS, BEGIN_X, BEGIN_S, BEGIN_M, BEGIN_B, BEGIN_W,
-1, -1, -1, -1, -1, -1, -1, -1,
};
-1, -1, -1, -1, -1, -1, -1, -1, };
static const int adr_a_count[]={
-1, -1, COUNT_XS, COUNT_X, COUNT_S, COUNT_M, COUNT_B, COUNT_W,
-1, -1, -1, -1, -1, -1, -1, -1,
};
-1, -1, -1, -1, -1, -1, -1, -1, };
static const int adr_b_begin[]={
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, BEGIN_XS, BEGIN_X, BEGIN_S, BEGIN_M, BEGIN_B, BEGIN_W,
};
-1, -1, BEGIN_XS, BEGIN_X, BEGIN_S, BEGIN_M, BEGIN_B, BEGIN_W, };
static const int adr_b_count[]={
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, COUNT_XS, COUNT_X, COUNT_S, COUNT_M, COUNT_B, COUNT_W,
};
-1, -1, COUNT_XS, COUNT_X, COUNT_S, COUNT_M, COUNT_B, COUNT_W, };
static const int adr_af_begin[]={
-1, -1, BEGIN_XS, BEGIN_X, BEGIN_S, BEGIN_M, BEGIN_B, BEGIN_W,
-1, -1, -1, -1, -1, -1, -1, BEGIN_A
};
-1, -1, -1, -1, -1, -1, -1, BEGIN_A };
static const int adr_af_count[]={
-1, -1, COUNT_XS, COUNT_X, COUNT_S, COUNT_M, COUNT_B, COUNT_W,
-1, -1, -1, -1, -1, -1, -1, COUNT_A
};
-1, -1, -1, -1, -1, -1, -1, COUNT_A };
static const int reg_left[] ={A,B,C,D, B,C,A,C, I,I,I,I, I,I,I,I};
static const int reg_right[]={B,C,A,C, A,B,C,D, I,I,I,I, I,I,I,I};
@ -39,26 +51,22 @@ static const int sub_right[]={B,C,A,C, I,I,I,I, A,B,C,D, B,C,A,C};
void saturn_device::saturn_invalid3(int op1, int op2, int op3)
{
logerror( "SATURN '%s' invalid opcode %x%x%x at %05x\n",
tag(), op1, op2, op3, m_pc-3 );
logerror("SATURN invalid opcode %x%x%x at %05x\n", op1, op2, op3, m_pc-3);
}
void saturn_device::saturn_invalid4(int op1, int op2, int op3, int op4)
{
logerror( "SATURN '%s' invalid opcode %x%x%x%x at %05x\n",
tag(), op1, op2, op3, op4, m_pc-4 );
logerror("SATURN invalid opcode %x%x%x%x at %05x\n", op1, op2, op3, op4, m_pc-4);
}
void saturn_device::saturn_invalid5(int op1, int op2, int op3, int op4, int op5)
{
logerror( "SATURN '%s' invalid opcode %x%x%x%x%x at %05x\n",
tag(), op1, op2, op3, op4, op5, m_pc-5 );
logerror("SATURN invalid opcode %x%x%x%x%x at %05x\n", op1, op2, op3, op4, op5, m_pc-5);
}
void saturn_device::saturn_invalid6(int op1, int op2, int op3, int op4, int op5, int op6)
{
logerror( "SATURN '%s' invalid opcode %x%x%x%x%x%x at %05x\n",
tag(), op1, op2, op3, op4, op5, op6, m_pc-6 );
logerror("SATURN invalid opcode %x%x%x%x%x%x at %05x\n", op1, op2, op3, op4, op5, op6, m_pc-6);
}
@ -914,16 +922,16 @@ void saturn_device::saturn_instruction()
switch (READ_OP()) {
case 0:
switch (READ_OP()) {
case 0: saturn_return_xm_set();break;
case 1: saturn_return(1);break;
case 2: saturn_return_carry_set();break;
case 3: saturn_return_carry_clear();break;
case 4: saturn_sethex();break;
case 5: saturn_setdec();break;
case 6: saturn_push_c();break;
case 7: saturn_pop_c();break;
case 8: saturn_clear_st();break;
case 9: saturn_st_to_c();break;
case 0x0: saturn_return_xm_set();break;
case 0x1: saturn_return(1);break;
case 0x2: saturn_return_carry_set();break;
case 0x3: saturn_return_carry_clear();break;
case 0x4: saturn_sethex();break;
case 0x5: saturn_setdec();break;
case 0x6: saturn_push_c();break;
case 0x7: saturn_pop_c();break;
case 0x8: saturn_clear_st();break;
case 0x9: saturn_st_to_c();break;
case 0xa: saturn_c_to_st();break;
case 0xb: saturn_exchange_c_st();break;
case 0xc: saturn_inc_p();break;

25
src/devices/cpu/saturn/saturn.cpp
View File

@ -15,6 +15,10 @@
#include "debugger.h"
//#define VERBOSE 1
#include "logmacro.h"
#define R0 0
#define R1 1
#define R2 2
@ -27,10 +31,6 @@
#define I 9 // invalid
//#define VERBOSE 1
#include "logmacro.h"
// Hardware status bits
#define XM 1 // external Modules missing
#define SB 2 // Sticky bit
@ -52,16 +52,19 @@ saturn_device::saturn_device(const machine_config &mconfig, const char *tag, dev
, m_unconfig_func(*this)
, m_id_func(*this)
, m_crc_func(*this)
, m_rsi_func(*this), m_pc(0), m_oldpc(0), m_p(0), m_out(0), m_carry(0), m_decimal(0), m_st(0), m_hst(0), m_nmi_state(0), m_irq_state(0), m_irq_enable(0), m_in_irq(0),
m_pending_irq(0), m_sleeping(0), m_monitor_id(0), m_monitor_in(0), m_program(nullptr), m_cache(nullptr), m_icount(0), m_debugger_temp(0)
, m_rsi_func(*this)
, m_pc(0), m_oldpc(0), m_p(0), m_out(0), m_carry(0), m_decimal(0), m_st(0), m_hst(0)
, m_nmi_state(0), m_irq_state(0), m_irq_enable(0), m_in_irq(0), m_pending_irq(0)
, m_sleeping(0), m_monitor_id(0), m_monitor_in(0)
, m_program(nullptr), m_cache(nullptr)
, m_icount(0)
, m_debugger_temp(0)
{
}
device_memory_interface::space_config_vector saturn_device::memory_space_config() const
{
return space_config_vector {
std::make_pair(AS_PROGRAM, &m_program_config)
};
return space_config_vector{ std::make_pair(AS_PROGRAM, &m_program_config) };
}
bool saturn_device::get_nonstandard_mnemonics_mode() const
@ -81,8 +84,8 @@ std::unique_ptr<util::disasm_interface> saturn_device::create_disassembler()
* include the opcode macros, functions and tables
***************************************************************/
#include "satops.hxx"
#include "sattable.hxx"
#include "satops.ipp"
#include "sattable.ipp"
/*****************************************************************************
*

232
src/devices/cpu/saturn/saturn.h
View File

@ -146,122 +146,122 @@ typedef uint8_t Saturn64[16];
void IntReg64(Saturn64 r, int64_t d);
int64_t Reg64Int(Saturn64 r);
inline int READ_OP();
inline int READ_OP_ARG();
inline int READ_OP_ARG8();
inline int8_t READ_OP_DIS8();
inline int READ_OP_ARG12();
inline int READ_OP_DIS12();
inline int READ_OP_ARG16();
inline int16_t READ_OP_DIS16();
inline int READ_OP_ARG20();
inline int READ_NIBBLE(uint32_t adr);
inline int READ_8(uint32_t adr);
inline int READ_12(uint32_t adr);
inline int READ_16(uint32_t adr);
inline int READ_20(uint32_t adr);
inline void WRITE_NIBBLE(uint32_t adr, uint8_t nib);
inline int S64_READ_X(int r);
inline int S64_READ_WORD(int r);
inline int S64_READ_A(int r);
inline void S64_WRITE_X(int r, int v);
inline void S64_WRITE_WORD(int r, int v);
inline void S64_WRITE_A(int r, int v);
inline uint32_t saturn_pop();
inline void saturn_push(uint32_t adr);
inline void saturn_interrupt_on();
inline void saturn_interrupt_off();
inline void saturn_reset_interrupt();
inline void saturn_mem_reset();
inline void saturn_mem_config();
inline void saturn_mem_unconfig();
inline void saturn_mem_id();
inline void saturn_shutdown();
inline void saturn_bus_command_b();
inline void saturn_bus_command_c();
inline void saturn_bus_command_d();
inline void saturn_serial_request();
inline void saturn_out_c();
inline void saturn_out_cs();
inline void saturn_in(int reg);
inline void saturn_sethex() { m_decimal=0; }
inline void saturn_setdec() { m_decimal=1; }
inline void saturn_clear_st();
inline void saturn_st_to_c();
inline void saturn_c_to_st();
inline void saturn_exchange_c_st();
inline void saturn_jump_after_test();
inline void saturn_st_clear_bit();
inline void saturn_st_set_bit();
inline void saturn_st_jump_bit_clear();
inline void saturn_st_jump_bit_set();
inline void saturn_hst_clear_bits();
inline void saturn_hst_bits_cleared();
inline void saturn_exchange_p();
inline void saturn_p_to_c();
inline void saturn_c_to_p();
inline void saturn_dec_p();
inline void saturn_inc_p();
inline void saturn_load_p();
inline void saturn_p_equals();
inline void saturn_p_not_equals();
inline void saturn_ca_p_1();
inline void saturn_load_reg(int reg);
inline void saturn_jump(int adr, int jump);
inline void saturn_call(int adr);
inline void saturn_return(int yes);
inline void saturn_return_carry_set();
inline void saturn_return_carry_clear();
inline void saturn_return_interrupt();
inline void saturn_return_xm_set();
inline void saturn_pop_c();
inline void saturn_push_c();
inline void saturn_indirect_jump(int reg);
inline void saturn_equals_zero(int reg, int begin, int count);
inline void saturn_equals(int reg, int begin, int count, int right);
inline void saturn_not_equals_zero(int reg, int begin, int count);
inline void saturn_not_equals(int reg, int begin, int count, int right);
inline void saturn_greater(int reg, int begin, int count, int right);
inline void saturn_greater_equals(int reg, int begin, int count, int right);
inline void saturn_smaller_equals(int reg, int begin, int count, int right);
inline void saturn_smaller(int reg, int begin, int count, int right);
inline void saturn_jump_bit_clear(int reg);
inline void saturn_jump_bit_set(int reg);
inline void saturn_load_pc(int reg);
inline void saturn_store_pc(int reg);
inline void saturn_exchange_pc(int reg);
inline void saturn_load_adr(int reg, int nibbles);
inline void saturn_add_adr(int reg);
inline void saturn_sub_adr(int reg);
inline void saturn_adr_to_reg(int adr, int reg);
inline void saturn_reg_to_adr(int reg, int adr);
inline void saturn_adr_to_reg_word(int adr, int reg);
inline void saturn_reg_to_adr_word(int reg, int adr);
inline void saturn_exchange_adr_reg(int adr, int reg);
inline void saturn_exchange_adr_reg_word(int adr, int reg);
inline void saturn_load_nibbles(int reg, int begin, int count, int adr);
inline void saturn_store_nibbles(int reg, int begin, int count, int adr);
inline void saturn_clear_bit(int reg);
inline void saturn_set_bit(int reg);
inline void saturn_clear(int reg, int begin, int count);
inline void saturn_exchange(int left, int begin, int count, int right);
inline void saturn_copy(int dest, int begin, int count, int src);
inline void saturn_add(int reg, int begin, int count, int right);
inline void saturn_add_const(int reg, int begin, int count, uint8_t right);
inline void saturn_sub(int reg, int begin, int count, int right);
inline void saturn_sub_const(int reg, int begin, int count, int right);
inline void saturn_sub2(int reg, int begin, int count, int right);
inline void saturn_increment(int reg, int begin, int count);
inline void saturn_decrement(int reg, int begin, int count);
inline void saturn_invert(int reg, int begin, int count);
inline void saturn_negate(int reg, int begin, int count);
inline void saturn_or(int dest, int begin, int count, int src);
inline void saturn_and(int dest, int begin, int count, int src);
inline void saturn_shift_nibble_left(int reg, int begin, int count);
inline void saturn_shift_nibble_right(int reg, int begin, int count);
inline void saturn_rotate_nibble_left_w(int reg);
inline void saturn_rotate_nibble_right_w(int reg);
inline void saturn_shift_right(int reg, int begin, int count);
int READ_OP();
int READ_OP_ARG();
int READ_OP_ARG8();
int8_t READ_OP_DIS8();
int READ_OP_ARG12();
int READ_OP_DIS12();
int READ_OP_ARG16();
int16_t READ_OP_DIS16();
int READ_OP_ARG20();
int READ_NIBBLE(uint32_t adr);
int READ_8(uint32_t adr);
int READ_12(uint32_t adr);
int READ_16(uint32_t adr);
int READ_20(uint32_t adr);
void WRITE_NIBBLE(uint32_t adr, uint8_t nib);
int S64_READ_X(int r);
int S64_READ_WORD(int r);
int S64_READ_A(int r);
void S64_WRITE_X(int r, int v);
void S64_WRITE_WORD(int r, int v);
void S64_WRITE_A(int r, int v);
uint32_t saturn_pop();
void saturn_push(uint32_t adr);
void saturn_interrupt_on();
void saturn_interrupt_off();
void saturn_reset_interrupt();
void saturn_mem_reset();
void saturn_mem_config();
void saturn_mem_unconfig();
void saturn_mem_id();
void saturn_shutdown();
void saturn_bus_command_b();
void saturn_bus_command_c();
void saturn_bus_command_d();
void saturn_serial_request();
void saturn_out_c();
void saturn_out_cs();
void saturn_in(int reg);
void saturn_sethex() { m_decimal=0; }
void saturn_setdec() { m_decimal=1; }
void saturn_clear_st();
void saturn_st_to_c();
void saturn_c_to_st();
void saturn_exchange_c_st();
void saturn_jump_after_test();
void saturn_st_clear_bit();
void saturn_st_set_bit();
void saturn_st_jump_bit_clear();
void saturn_st_jump_bit_set();
void saturn_hst_clear_bits();
void saturn_hst_bits_cleared();
void saturn_exchange_p();
void saturn_p_to_c();
void saturn_c_to_p();
void saturn_dec_p();
void saturn_inc_p();
void saturn_load_p();
void saturn_p_equals();
void saturn_p_not_equals();
void saturn_ca_p_1();
void saturn_load_reg(int reg);
void saturn_jump(int adr, int jump);
void saturn_call(int adr);
void saturn_return(int yes);
void saturn_return_carry_set();
void saturn_return_carry_clear();
void saturn_return_interrupt();
void saturn_return_xm_set();
void saturn_pop_c();
void saturn_push_c();
void saturn_indirect_jump(int reg);
void saturn_equals_zero(int reg, int begin, int count);
void saturn_equals(int reg, int begin, int count, int right);
void saturn_not_equals_zero(int reg, int begin, int count);
void saturn_not_equals(int reg, int begin, int count, int right);
void saturn_greater(int reg, int begin, int count, int right);
void saturn_greater_equals(int reg, int begin, int count, int right);
void saturn_smaller_equals(int reg, int begin, int count, int right);
void saturn_smaller(int reg, int begin, int count, int right);
void saturn_jump_bit_clear(int reg);
void saturn_jump_bit_set(int reg);
void saturn_load_pc(int reg);
void saturn_store_pc(int reg);
void saturn_exchange_pc(int reg);
void saturn_load_adr(int reg, int nibbles);
void saturn_add_adr(int reg);
void saturn_sub_adr(int reg);
void saturn_adr_to_reg(int adr, int reg);
void saturn_reg_to_adr(int reg, int adr);
void saturn_adr_to_reg_word(int adr, int reg);
void saturn_reg_to_adr_word(int reg, int adr);
void saturn_exchange_adr_reg(int adr, int reg);
void saturn_exchange_adr_reg_word(int adr, int reg);
void saturn_load_nibbles(int reg, int begin, int count, int adr);
void saturn_store_nibbles(int reg, int begin, int count, int adr);
void saturn_clear_bit(int reg);
void saturn_set_bit(int reg);
void saturn_clear(int reg, int begin, int count);
void saturn_exchange(int left, int begin, int count, int right);
void saturn_copy(int dest, int begin, int count, int src);
void saturn_add(int reg, int begin, int count, int right);
void saturn_add_const(int reg, int begin, int count, uint8_t right);
void saturn_sub(int reg, int begin, int count, int right);
void saturn_sub_const(int reg, int begin, int count, int right);
void saturn_sub2(int reg, int begin, int count, int right);
void saturn_increment(int reg, int begin, int count);
void saturn_decrement(int reg, int begin, int count);
void saturn_invert(int reg, int begin, int count);
void saturn_negate(int reg, int begin, int count);
void saturn_or(int dest, int begin, int count, int src);
void saturn_and(int dest, int begin, int count, int src);
void saturn_shift_nibble_left(int reg, int begin, int count);
void saturn_shift_nibble_right(int reg, int begin, int count);
void saturn_rotate_nibble_left_w(int reg);
void saturn_rotate_nibble_right_w(int reg);
void saturn_shift_right(int reg, int begin, int count);
void saturn_invalid3(int op1, int op2, int op3);
void saturn_invalid4(int op1, int op2, int op3, int op4);
void saturn_invalid5(int op1, int op2, int op3, int op4, int op5);