From d80e7f95eb1ae276b86f8bd1dc818de1a1f887f7 Mon Sep 17 00:00:00 2001 From: Vas Crabb Date: Sun, 27 Oct 2019 02:16:50 +1100 Subject: cpu/saturn: clean up a little (nw) --- scripts/src/cpu.lua | 4 +- src/devices/cpu/saturn/satops.hxx | 1151 ----------------------------------- src/devices/cpu/saturn/satops.ipp | 1110 +++++++++++++++++++++++++++++++++ src/devices/cpu/saturn/sattable.hxx | 1039 ------------------------------- src/devices/cpu/saturn/sattable.ipp | 1047 +++++++++++++++++++++++++++++++ src/devices/cpu/saturn/saturn.cpp | 25 +- src/devices/cpu/saturn/saturn.h | 244 ++++---- 7 files changed, 2295 insertions(+), 2325 deletions(-) delete mode 100644 src/devices/cpu/saturn/satops.hxx create mode 100644 src/devices/cpu/saturn/satops.ipp delete mode 100644 src/devices/cpu/saturn/sattable.hxx create mode 100644 src/devices/cpu/saturn/sattable.ipp diff --git a/scripts/src/cpu.lua b/scripts/src/cpu.lua index ceb6fb6f27f..ecfa4c58882 100644 --- a/scripts/src/cpu.lua +++ b/scripts/src/cpu.lua @@ -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 diff --git a/src/devices/cpu/saturn/satops.hxx b/src/devices/cpu/saturn/satops.hxx deleted file mode 100644 index 8a1ecfe1c1d..00000000000 --- a/src/devices/cpu/saturn/satops.hxx +++ /dev/null @@ -1,1151 +0,0 @@ -// license:BSD-3-Clause -// copyright-holders:Peter Trauner,Antoine Mine -#define IRQ_ADDRESS 0xf - -#define saturn_assert(x) \ - do { if (!(x)) logerror("SATURN assertion failed: %s at %s:%i, pc=%05x\n", #x, __FILE__, __LINE__, m_pc); } while (0) - -int saturn_device::READ_OP() -{ - uint8_t data; - m_icount-=3; - data=m_cache->read_byte(m_pc); - saturn_assert(data<0x10); - m_pc=(m_pc+1)&0xfffff; - return data; -} - -int saturn_device::READ_OP_ARG() -{ - uint8_t data; - m_icount-=3; - data=m_cache->read_byte(m_pc); - saturn_assert(data<0x10); - m_pc=(m_pc+1)&0xfffff; - return data; -} - -int saturn_device::READ_OP_ARG8() -{ - int n0=READ_OP_ARG(); - int n1=READ_OP_ARG(); - return n0|(n1<<4); -} - -int8_t saturn_device::READ_OP_DIS8() -{ - return (int8_t)READ_OP_ARG8(); -} - -int saturn_device::READ_OP_ARG12() -{ - int n0=READ_OP_ARG(); - int n1=READ_OP_ARG(); - int n2=READ_OP_ARG(); - return n0|(n1<<4)|(n2<<8); -} - -int saturn_device::READ_OP_DIS12() -{ - int temp=READ_OP_ARG12(); - if (temp&0x800) temp-=0x1000; - return temp; -} - -int saturn_device::READ_OP_ARG16() -{ - int n0=READ_OP_ARG(); - int n1=READ_OP_ARG(); - int n2=READ_OP_ARG(); - int n3=READ_OP_ARG(); - return n0|(n1<<4)|(n2<<8)|(n3<<12); -} - -int16_t saturn_device::READ_OP_DIS16() -{ - return (int16_t)READ_OP_ARG16(); -} - -int saturn_device::READ_OP_ARG20() -{ - int n0=READ_OP_ARG(); - int n1=READ_OP_ARG(); - int n2=READ_OP_ARG(); - int n3=READ_OP_ARG(); - int n4=READ_OP_ARG(); - return n0|(n1<<4)|(n2<<8)|(n3<<12)|(n4<<16); -} - -int saturn_device::READ_NIBBLE(uint32_t adr) -{ - uint8_t data; - m_icount-=3; - data=m_program->read_byte(adr&0xfffff); - saturn_assert(data<0x10); - m_crc_func(adr&0xfffff, data, 0xffffffff); - return data; -} - -int saturn_device::READ_8(uint32_t adr) -{ - int n0=READ_NIBBLE(adr); - int n1=READ_NIBBLE(adr+1); - return n0|(n1<<4); -} - -int saturn_device::READ_12(uint32_t adr) -{ - int n0=READ_NIBBLE(adr); - int n1=READ_NIBBLE(adr+1); - int n2=READ_NIBBLE(adr+2); - return n0|(n1<<4)|(n2<<8); -} - -int saturn_device::READ_16(uint32_t adr) -{ - int n0=READ_NIBBLE(adr); - int n1=READ_NIBBLE(adr+1); - int n2=READ_NIBBLE(adr+2); - int n3=READ_NIBBLE(adr+3); - return n0|(n1<<4)|(n2<<8)|(n3<<12); -} - -int saturn_device::READ_20(uint32_t adr) -{ - int n0=READ_NIBBLE(adr); - int n1=READ_NIBBLE(adr+1); - int n2=READ_NIBBLE(adr+2); - int n3=READ_NIBBLE(adr+3); - int n4=READ_NIBBLE(adr+4); - return n0|(n1<<4)|(n2<<8)|(n3<<12)|(n4<<16); -} - -void saturn_device::WRITE_NIBBLE(uint32_t adr, uint8_t nib) -{ - m_icount-=3; - saturn_assert(nib<0x10); - m_program->write_byte(adr&0xfffff,nib); -} - -#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 - - -int saturn_device::S64_READ_X(int r) -{ - return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8); -} - -int saturn_device::S64_READ_WORD(int r) -{ - return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8)|(m_reg[r][3]<<12); -} - -int saturn_device::S64_READ_A(int r) -{ - return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8)|(m_reg[r][3]<<12)|(m_reg[r][4]<<16); -} - -void saturn_device::S64_WRITE_X(int r, int v) -{ - m_reg[r][0]=v&0xf; - m_reg[r][1]=(v>>4)&0xf; - m_reg[r][2]=(v>>8)&0xf; -} - -void saturn_device::S64_WRITE_WORD(int r, int v) -{ - m_reg[r][0]=v&0xf; - m_reg[r][1]=(v>>4)&0xf; - m_reg[r][2]=(v>>8)&0xf; - m_reg[r][3]=(v>>12)&0xf; -} - -void saturn_device::S64_WRITE_A(int r, int v) -{ - m_reg[r][0]=v&0xf; - m_reg[r][1]=(v>>4)&0xf; - m_reg[r][2]=(v>>8)&0xf; - m_reg[r][3]=(v>>12)&0xf; - m_reg[r][4]=(v>>16)&0xf; -} - - - - - -uint32_t saturn_device::saturn_pop() -{ - uint32_t temp=m_rstk[0]; - memmove(m_rstk, m_rstk+1, sizeof(m_rstk)-sizeof(m_rstk[0])); - m_rstk[7]=0; - return temp; -} - -void saturn_device::saturn_push(uint32_t adr) -{ - memmove(m_rstk+1, m_rstk, sizeof(m_rstk)-sizeof(m_rstk[0])); - m_rstk[0]=adr; -} - -void saturn_device::saturn_interrupt_on() -{ - LOG("SATURN at %05x: INTON\n", m_pc-4); - m_irq_enable=1; - if (m_irq_state) - { - LOG("SATURN set_irq_line(ASSERT)\n"); - m_pending_irq=1; - } -} - -void saturn_device::saturn_interrupt_off() -{ - LOG("SATURN at %05x: INTOFF\n", m_pc-4); - m_irq_enable=0; -} - -void saturn_device::saturn_reset_interrupt() -{ - LOG("SATURN at %05x: RSI\n", m_pc-5); - m_rsi_func(ASSERT_LINE); -} - -void saturn_device::saturn_mem_reset() -{ - m_reset_func(ASSERT_LINE); -} - -void saturn_device::saturn_mem_config() -{ - m_config_func(S64_READ_A(C)); -} - -void saturn_device::saturn_mem_unconfig() -{ - m_unconfig_func(S64_READ_A(C)); -} - -void saturn_device::saturn_mem_id() -{ - int id=0; - id = m_id_func(); - S64_WRITE_A(C,id); - m_monitor_id = id; -} - -void saturn_device::saturn_shutdown() -{ - m_sleeping=1; - m_irq_enable=1; - LOG("SATURN at %05x: SHUTDN\n", m_pc-3); -} - -void saturn_device::saturn_bus_command_b() -{ - logerror( "SATURN '%s' at %05x: BUSCB opcode not handled\n", tag(), m_pc-4 ); -} - -void saturn_device::saturn_bus_command_c() -{ - logerror( "SATURN '%s' at %05x: BUSCC opcode not handled\n", tag(), m_pc-3 ); -} - -void saturn_device::saturn_bus_command_d() -{ - logerror( "SATURN '%s' at %05x: BUSCD opcode not handled\n", tag(), m_pc-4 ); -} - -void saturn_device::saturn_serial_request() -{ - logerror( "SATURN '%s' at %05x: SREQ? opcode not handled\n", tag(), m_pc-3 ); -} - -void saturn_device::saturn_out_c() -{ - m_out=S64_READ_X(C); - m_out_func(m_out); -} - -void saturn_device::saturn_out_cs() -{ - m_out=(m_out&0xff0)|m_reg[C][0]; - m_out_func(m_out); -} - -void saturn_device::saturn_in(int reg) -{ - int in = 0; - saturn_assert(reg>=0 && reg<9); - if (!(m_pc&1)) - logerror( "SATURN '%s' at %05x: reg=IN opcode at odd addresse\n", - tag(), m_pc-3 ); - in = m_in_func(); - S64_WRITE_WORD(reg,in); - m_monitor_in = in; -} - - -/* st related */ -void saturn_device::saturn_clear_st() -{ - m_st&=0xf000; -} - -void saturn_device::saturn_st_to_c() -{ - S64_WRITE_X(C,m_st); -} - -void saturn_device::saturn_c_to_st() -{ - m_st=(m_st&0xf000)|(S64_READ_X(C)); -} - -void saturn_device::saturn_exchange_c_st() -{ - int t=m_st; - m_st=(t&0xf000)|(S64_READ_X(C)); - S64_WRITE_X(C,t); -} - -void saturn_device::saturn_jump_after_test() -{ - int adr=READ_OP_DIS8(); - if (m_carry) { - if (adr==0) { - m_pc=saturn_pop(); - } else { - m_pc=(m_pc+adr-2)&0xfffff; - } - } -} -void saturn_device::saturn_st_clear_bit() -{ - m_st &= ~(1<<(READ_OP_ARG())); -} - -void saturn_device::saturn_st_set_bit() -{ - m_st |= (1<<(READ_OP_ARG())); -} - -void saturn_device::saturn_st_jump_bit_clear() -{ - m_carry=!((m_st>>(READ_OP_ARG()))&1); - saturn_jump_after_test(); -} - -void saturn_device::saturn_st_jump_bit_set() -{ - m_carry=(m_st>>(READ_OP_ARG()))&1; - saturn_jump_after_test(); -} - -void saturn_device::saturn_hst_clear_bits() -{ - m_hst&=~(READ_OP_ARG()); -} - -void saturn_device::saturn_hst_bits_cleared() -{ - m_carry=!(m_hst&(READ_OP_ARG())); - saturn_jump_after_test(); -} - -/* p related */ -void saturn_device::saturn_exchange_p() -{ - int nr=READ_OP_ARG(); - int t=m_p; - m_p=m_reg[C][nr]; - m_reg[C][nr]=t; -} - -void saturn_device::saturn_p_to_c() -{ - int nr=READ_OP_ARG(); - m_reg[C][nr]=m_p; -} - -void saturn_device::saturn_c_to_p() -{ - int nr=READ_OP_ARG(); - m_p=m_reg[C][nr]; -} - -void saturn_device::saturn_dec_p() -{ - m_carry=m_p==0; - m_p=(m_p-1)&0xf; -} - -void saturn_device::saturn_inc_p() -{ - m_p=(m_p+1)&0xf; - m_carry=m_p==0; -} - -void saturn_device::saturn_load_p() -{ - m_p=READ_OP_ARG(); -} - -void saturn_device::saturn_p_equals() -{ - m_carry=m_p==(READ_OP_ARG()); - saturn_jump_after_test(); -} - -void saturn_device::saturn_p_not_equals() -{ - m_carry=m_p!=(READ_OP_ARG()); - saturn_jump_after_test(); -} - -void saturn_device::saturn_ca_p_1() -{ - int a=(S64_READ_A(C))+1+m_p; - m_carry=a>=0x100000; - S64_WRITE_A(C,a&0xfffff); -} - -void saturn_device::saturn_load_reg(int reg) -{ - int count=READ_OP_ARG(); - int pos=m_p; - saturn_assert(reg>=0 && reg<9); - for (; count>=0; count--, pos=(pos+1)&0xf ) { - m_reg[reg][pos]=READ_OP_ARG(); - } -} - -void saturn_device::saturn_jump(int adr, int jump) -{ - saturn_assert(adr>=0 && adr<0x100000); - if (jump) { - m_pc=adr; - m_icount-=10; - } -} - -void saturn_device::saturn_call(int adr) -{ - saturn_assert(adr>=0 && adr<0x100000); - saturn_push(m_pc); - m_pc=adr; -// m_icount-=10; -} - -void saturn_device::saturn_return(int yes) -{ - if (yes) { - m_pc=saturn_pop(); -// m_icount-=10; - } -} - -void saturn_device::saturn_return_carry_set() -{ - m_pc=saturn_pop(); -// m_icount-=10; - m_carry=1; -} - -void saturn_device::saturn_return_carry_clear() -{ - m_pc=saturn_pop(); -// m_icount-=10; - m_carry=0; -} - -void saturn_device::saturn_return_interrupt() -{ - LOG("SATURN at %05x: RTI\n", tag(), m_pc-2); - m_in_irq=0; /* set to 1 when an IRQ is taken */ - m_pc=saturn_pop(); -// m_icount-=10; -} - -void saturn_device::saturn_return_xm_set() -{ - m_pc=saturn_pop(); - m_hst|=XM; -// m_icount-=10; -} - -void saturn_device::saturn_pop_c() -{ - S64_WRITE_A(C,saturn_pop()); -} - -void saturn_device::saturn_push_c() -{ - saturn_push(S64_READ_A(C)); -} - -void saturn_device::saturn_indirect_jump(int reg) -{ - saturn_assert(reg>=0 && reg<9); - m_pc=READ_20(S64_READ_A(reg)); -} - -void saturn_device::saturn_equals_zero(int reg, int begin, int count) -{ - int i, t; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && begin<16 && count>0 && begin+count<=16); - m_carry=1; - for (i=0; i=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=1; - for (i=0; i=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (t>t2) { m_carry=1; break; } - if (t=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=1; - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (tt2) break; - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_smaller_equals(int reg, int begin, int count, int right) -{ - int i, t,t2; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=1; - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (t>t2) { m_carry=0; break; } - if (t=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (tt2) break; - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_jump_bit_clear(int reg) -{ - int op=READ_OP_ARG(); - saturn_assert(reg>=0 && reg<9); - m_carry=!((m_reg[reg][op>>2]>>(op&3))&1); - saturn_jump_after_test(); -} - -void saturn_device::saturn_jump_bit_set(int reg) -{ - int op=READ_OP_ARG(); - saturn_assert(reg>=0 && reg<9); - m_carry=(m_reg[reg][op>>2]>>(op&3))&1; - saturn_jump_after_test(); -} - -void saturn_device::saturn_load_pc(int reg) -{ - saturn_assert(reg>=0 && reg<9); - m_pc=S64_READ_A(reg); -} - -void saturn_device::saturn_store_pc(int reg) -{ - saturn_assert(reg>=0 && reg<9); - S64_WRITE_A(reg,m_pc); -} - -void saturn_device::saturn_exchange_pc(int reg) -{ - int temp=m_pc; - saturn_assert(reg>=0 && reg<9); - m_pc=S64_READ_A(reg); - S64_WRITE_A(reg, temp); -} - -/************************************************************************************* - address register related -*************************************************************************************/ -void saturn_device::saturn_load_adr(int reg, int nibbles) -{ - saturn_assert(reg>=0 && reg<2); - saturn_assert(nibbles==2 || nibbles==4 || nibbles==5); - switch (nibbles) { - case 5: - m_d[reg]=READ_OP_ARG20(); - break; - case 4: - m_d[reg]=(m_d[reg]&0xf0000)|READ_OP_ARG16(); - break; - case 2: - m_d[reg]=(m_d[reg]&0xfff00)|READ_OP_ARG8(); - break; - } -} - -void saturn_device::saturn_add_adr(int reg) -{ - int t=m_d[reg]+READ_OP_ARG()+1; - saturn_assert(reg>=0 && reg<2); - m_d[reg]=t&0xfffff; - m_carry=t>=0x100000; -} - -void saturn_device::saturn_sub_adr(int reg) -{ - int t=m_d[reg]-READ_OP_ARG()-1; - saturn_assert(reg>=0 && reg<2); - m_d[reg]=t&0xfffff; - m_carry=t<0; -} - -void saturn_device::saturn_adr_to_reg(int adr, int reg) -{ - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - S64_WRITE_A(reg,m_d[adr]); -} - -void saturn_device::saturn_reg_to_adr(int reg, int adr) -{ - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - m_d[adr]=S64_READ_A(reg); -} - -void saturn_device::saturn_adr_to_reg_word(int adr, int reg) -{ - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - S64_WRITE_WORD(reg,m_d[adr]&0xffff); -} - -void saturn_device::saturn_reg_to_adr_word(int reg, int adr) -{ - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - m_d[adr]=(m_d[adr]&0xf0000)|S64_READ_WORD(reg); -} - -void saturn_device::saturn_exchange_adr_reg(int adr, int reg) -{ - int temp=m_d[adr]; - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - m_d[adr]=S64_READ_A(reg); - S64_WRITE_A(reg,temp); -} - -void saturn_device::saturn_exchange_adr_reg_word(int adr, int reg) -{ - int temp=m_d[adr]&0xffff; - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - m_d[adr]=(m_d[adr]&0xf0000)|S64_READ_WORD(reg); - S64_WRITE_WORD(reg,temp); -} - -void saturn_device::saturn_load_nibbles(int reg, int begin, int count, int adr) -{ - int i; - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=0 && reg<9); - m_reg[reg][arg>>2]&=~(1<<(arg&3)); -} - -void saturn_device::saturn_set_bit(int reg) -{ - int arg=READ_OP_ARG(); - saturn_assert(reg>=0 && reg<9); - m_reg[reg][arg>>2]|=1<<(arg&3); -} - -/**************************************************************************** - clear opers - ****************************************************************************/ -void saturn_device::saturn_clear(int reg, int begin, int count) -{ - int i; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=0 && left<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=0 && dest<9); - saturn_assert(src>=0 && src<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i=base) { - m_carry=1; - t-=base; - } - else m_carry=0; - saturn_assert(t>=0); saturn_assert(t=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - saturn_assert(count>1 || !m_decimal); /* SATURN bug */ - for (i=0; i>=4; - if (t>=base) { - right++; - t-=base; - } - saturn_assert(t>=0); saturn_assert(t0; -} - -/**************************************************************************** - sub opers - ****************************************************************************/ -void saturn_device::saturn_sub(int reg, int begin, int count, int right) -{ - int i, t; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i=0); saturn_assert(t=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - saturn_assert(count>1 || !m_decimal); /* SATURN bug */ - for (i=0; i>=4; - if (t<0) { - right++; - t+=base; - } - saturn_assert(t>=0); saturn_assert(t0; -} - -/**************************************************************************** - sub2 opers (a=b-a) - ****************************************************************************/ -void saturn_device::saturn_sub2(int reg, int begin, int count, int right) -{ - int i, t; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i=0); saturn_assert(t=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=base) m_reg[reg][begin+i]=t-base; - else { m_reg[reg][begin+i]=t; break; } - } - m_carry=t>=base; -} - -/**************************************************************************** - decrement opers - ****************************************************************************/ -void saturn_device::saturn_decrement(int reg, int begin, int count) -{ - int i, t=0; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - c=1; - m_carry=0; - for (i=0; imax) n-=max+1; - else c=0; - saturn_assert(n>=0); saturn_assert(n<=max); - m_reg[reg][begin+i]=n&0xf; - m_icount-=2; - } -} - -/**************************************************************************** - or opers - ****************************************************************************/ -void saturn_device::saturn_or(int dest, int begin, int count, int src) -{ - int i; - saturn_assert(dest>=0 && dest<9); - saturn_assert(src>=0 && src<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=0 && dest<9); - saturn_assert(src>=0 && src<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - if (m_reg[reg][begin+count-1]) m_hst|=SB; - for (i=count-1; i>=1; i--) { - m_reg[reg][begin+i]=m_reg[reg][begin+i-1]; - m_icount-=2; - } - m_reg[reg][begin]=0; - m_icount-=2; -} - -/**************************************************************************** - shift nibbles right opers - ****************************************************************************/ -void saturn_device::saturn_shift_nibble_right(int reg, int begin, int count) -{ - int i; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - if (m_reg[reg][begin]) m_hst|=SB; - for (i=1; i=0 && reg<9); - for (i=15; i>=1; i--) { - m_reg[reg][i]=m_reg[reg][i-1]; - m_icount-=2; - } - m_reg[reg][0]=x; - m_icount-=2; -} - -/**************************************************************************** - rotate nibbles right opers - ****************************************************************************/ -void saturn_device::saturn_rotate_nibble_right_w(int reg) -{ - int i, x=m_reg[reg][0]; - saturn_assert(reg>=0 && reg<9); - for (i=1; i<16; i++) { - m_reg[reg][i-1]=m_reg[reg][i]; - m_icount-=2; - } - m_reg[reg][15]=x; - if (x) m_hst|=SB; - m_icount-=2; -} - - -/**************************************************************************** - shift right opers - ****************************************************************************/ -void saturn_device::saturn_shift_right(int reg, int begin, int count) -{ - int i, t, c=0; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t|=(c<<4); - c=t&1; - m_reg[reg][begin+i]=t>>1; - m_icount-=2; - } - if (c) m_hst|=SB; - m_icount-=2; -} diff --git a/src/devices/cpu/saturn/satops.ipp b/src/devices/cpu/saturn/satops.ipp new file mode 100644 index 00000000000..87632ca859b --- /dev/null +++ b/src/devices/cpu/saturn/satops.ipp @@ -0,0 +1,1110 @@ +// license:BSD-3-Clause +// copyright-holders:Peter Trauner,Antoine Mine +#ifndef MAME_CPU_SATURN_SATOPS_IPP +#define MAME_CPU_SATURN_SATOPS_IPP + +#pragma once + +#include "saturn.h" + + +#define saturn_assert(x) \ + do { if (!(x)) logerror("SATURN assertion failed: %s at %s:%i, pc=%05x\n", #x, __FILE__, __LINE__, m_pc); } while (false) + +inline int saturn_device::READ_OP() +{ + m_icount-=3; + const uint8_t data=m_cache->read_byte(m_pc); + saturn_assert(data<0x10); + m_pc=(m_pc+1)&0xfffff; + return data; +} + +inline int saturn_device::READ_OP_ARG() +{ + m_icount-=3; + const uint8_t data=m_cache->read_byte(m_pc); + saturn_assert(data<0x10); + m_pc=(m_pc+1)&0xfffff; + return data; +} + +inline int saturn_device::READ_OP_ARG8() +{ + const int n0=READ_OP_ARG(); + const int n1=READ_OP_ARG(); + return n0|(n1<<4); +} + +inline int8_t saturn_device::READ_OP_DIS8() +{ + return (int8_t)READ_OP_ARG8(); +} + +inline int saturn_device::READ_OP_ARG12() +{ + const int n0=READ_OP_ARG(); + const int n1=READ_OP_ARG(); + const int n2=READ_OP_ARG(); + return n0|(n1<<4)|(n2<<8); +} + +inline int saturn_device::READ_OP_DIS12() +{ + int temp=READ_OP_ARG12(); + if (temp&0x800) temp-=0x1000; + return temp; +} + +inline int saturn_device::READ_OP_ARG16() +{ + const int n0=READ_OP_ARG(); + const int n1=READ_OP_ARG(); + const int n2=READ_OP_ARG(); + const int n3=READ_OP_ARG(); + return n0|(n1<<4)|(n2<<8)|(n3<<12); +} + +inline int16_t saturn_device::READ_OP_DIS16() +{ + return (int16_t)READ_OP_ARG16(); +} + +inline int saturn_device::READ_OP_ARG20() +{ + const int n0=READ_OP_ARG(); + const int n1=READ_OP_ARG(); + const int n2=READ_OP_ARG(); + const int n3=READ_OP_ARG(); + const int n4=READ_OP_ARG(); + return n0|(n1<<4)|(n2<<8)|(n3<<12)|(n4<<16); +} + +inline int saturn_device::READ_NIBBLE(uint32_t adr) +{ + m_icount-=3; + const uint8_t data=m_program->read_byte(adr&0xfffff); + saturn_assert(data<0x10); + m_crc_func(adr&0xfffff, data, 0xffffffff); + return data; +} + +inline int saturn_device::READ_8(uint32_t adr) +{ + const int n0=READ_NIBBLE(adr); + const int n1=READ_NIBBLE(adr+1); + return n0|(n1<<4); +} + +inline int saturn_device::READ_12(uint32_t adr) +{ + const int n0=READ_NIBBLE(adr); + const int n1=READ_NIBBLE(adr+1); + const int n2=READ_NIBBLE(adr+2); + return n0|(n1<<4)|(n2<<8); +} + +inline int saturn_device::READ_16(uint32_t adr) +{ + const int n0=READ_NIBBLE(adr); + const int n1=READ_NIBBLE(adr+1); + const int n2=READ_NIBBLE(adr+2); + const int n3=READ_NIBBLE(adr+3); + return n0|(n1<<4)|(n2<<8)|(n3<<12); +} + +inline int saturn_device::READ_20(uint32_t adr) +{ + const int n0=READ_NIBBLE(adr); + const int n1=READ_NIBBLE(adr+1); + const int n2=READ_NIBBLE(adr+2); + const int n3=READ_NIBBLE(adr+3); + const int n4=READ_NIBBLE(adr+4); + return n0|(n1<<4)|(n2<<8)|(n3<<12)|(n4<<16); +} + +inline void saturn_device::WRITE_NIBBLE(uint32_t adr, uint8_t nib) +{ + m_icount-=3; + saturn_assert(nib<0x10); + m_program->write_byte(adr&0xfffff,nib); +} + +inline int saturn_device::S64_READ_X(int r) +{ + return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8); +} + +inline int saturn_device::S64_READ_WORD(int r) +{ + return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8)|(m_reg[r][3]<<12); +} + +inline int saturn_device::S64_READ_A(int r) +{ + return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8)|(m_reg[r][3]<<12)|(m_reg[r][4]<<16); +} + +inline void saturn_device::S64_WRITE_X(int r, int v) +{ + m_reg[r][0]=v&0xf; + m_reg[r][1]=(v>>4)&0xf; + m_reg[r][2]=(v>>8)&0xf; +} + +inline void saturn_device::S64_WRITE_WORD(int r, int v) +{ + m_reg[r][0]=v&0xf; + m_reg[r][1]=(v>>4)&0xf; + m_reg[r][2]=(v>>8)&0xf; + m_reg[r][3]=(v>>12)&0xf; +} + +inline void saturn_device::S64_WRITE_A(int r, int v) +{ + m_reg[r][0]=v&0xf; + m_reg[r][1]=(v>>4)&0xf; + m_reg[r][2]=(v>>8)&0xf; + m_reg[r][3]=(v>>12)&0xf; + m_reg[r][4]=(v>>16)&0xf; +} + + + +inline uint32_t saturn_device::saturn_pop() +{ + const uint32_t temp=m_rstk[0]; + memmove(m_rstk, m_rstk+1, sizeof(m_rstk)-sizeof(m_rstk[0])); + m_rstk[7]=0; + return temp; +} + +inline void saturn_device::saturn_push(uint32_t adr) +{ + memmove(m_rstk+1, m_rstk, sizeof(m_rstk)-sizeof(m_rstk[0])); + m_rstk[0]=adr; +} + +inline void saturn_device::saturn_interrupt_on() +{ + LOG("SATURN at %05x: INTON\n", m_pc-4); + m_irq_enable=1; + if (m_irq_state) { + LOG("SATURN set_irq_line(ASSERT)\n"); + m_pending_irq=1; + } +} + +inline void saturn_device::saturn_interrupt_off() +{ + LOG("SATURN at %05x: INTOFF\n", m_pc-4); + m_irq_enable=0; +} + +inline void saturn_device::saturn_reset_interrupt() +{ + LOG("SATURN at %05x: RSI\n", m_pc-5); + m_rsi_func(ASSERT_LINE); +} + +inline void saturn_device::saturn_mem_reset() +{ + m_reset_func(ASSERT_LINE); +} + +inline void saturn_device::saturn_mem_config() +{ + m_config_func(S64_READ_A(C)); +} + +inline void saturn_device::saturn_mem_unconfig() +{ + m_unconfig_func(S64_READ_A(C)); +} + +inline void saturn_device::saturn_mem_id() +{ + const int id = m_id_func(); + S64_WRITE_A(C,id); + m_monitor_id = id; +} + +inline void saturn_device::saturn_shutdown() +{ + m_sleeping=1; + m_irq_enable=1; + LOG("SATURN at %05x: SHUTDN\n", m_pc-3); +} + +inline void saturn_device::saturn_bus_command_b() +{ + logerror("SATURN at %05x: BUSCB opcode not handled\n", m_pc-4); +} + +inline void saturn_device::saturn_bus_command_c() +{ + logerror("SATURN at %05x: BUSCC opcode not handled\n", m_pc-3); +} + +inline void saturn_device::saturn_bus_command_d() +{ + logerror("SATURN at %05x: BUSCD opcode not handled\n", m_pc-4); +} + +inline void saturn_device::saturn_serial_request() +{ + logerror("SATURN at %05x: SREQ? opcode not handled\n", m_pc-3); +} + +inline void saturn_device::saturn_out_c() +{ + m_out=S64_READ_X(C); + m_out_func(m_out); +} + +inline void saturn_device::saturn_out_cs() +{ + m_out=(m_out&0xff0)|m_reg[C][0]; + m_out_func(m_out); +} + +inline void saturn_device::saturn_in(int reg) +{ + saturn_assert(reg>=0 && reg<9); + if (!(m_pc&1)) + logerror("SATURN at %05x: reg=IN opcode at odd addresse\n", m_pc-3); + const int in = m_in_func(); + S64_WRITE_WORD(reg,in); + m_monitor_in = in; +} + + +// st related +inline void saturn_device::saturn_clear_st() +{ + m_st&=0xf000; +} + +inline void saturn_device::saturn_st_to_c() +{ + S64_WRITE_X(C,m_st); +} + +inline void saturn_device::saturn_c_to_st() +{ + m_st=(m_st&0xf000)|(S64_READ_X(C)); +} + +inline void saturn_device::saturn_exchange_c_st() +{ + const int t=m_st; + m_st=(t&0xf000)|(S64_READ_X(C)); + S64_WRITE_X(C,t); +} + +inline void saturn_device::saturn_jump_after_test() +{ + const int adr=READ_OP_DIS8(); + if (m_carry) { + if (adr==0) { + m_pc=saturn_pop(); + } else { + m_pc=(m_pc+adr-2)&0xfffff; + } + } +} + +inline void saturn_device::saturn_st_clear_bit() +{ + m_st &= ~(1<<(READ_OP_ARG())); +} + +inline void saturn_device::saturn_st_set_bit() +{ + m_st |= (1<<(READ_OP_ARG())); +} + +inline void saturn_device::saturn_st_jump_bit_clear() +{ + m_carry=!((m_st>>(READ_OP_ARG()))&1); + saturn_jump_after_test(); +} + +inline void saturn_device::saturn_st_jump_bit_set() +{ + m_carry=(m_st>>(READ_OP_ARG()))&1; + saturn_jump_after_test(); +} + +inline void saturn_device::saturn_hst_clear_bits() +{ + m_hst&=~(READ_OP_ARG()); +} + +inline void saturn_device::saturn_hst_bits_cleared() +{ + m_carry=!(m_hst&(READ_OP_ARG())); + saturn_jump_after_test(); +} + +// p related +inline void saturn_device::saturn_exchange_p() +{ + const int nr=READ_OP_ARG(); + const int t=m_p; + m_p=m_reg[C][nr]; + m_reg[C][nr]=t; +} + +inline void saturn_device::saturn_p_to_c() +{ + const int nr=READ_OP_ARG(); + m_reg[C][nr]=m_p; +} + +inline void saturn_device::saturn_c_to_p() +{ + const int nr=READ_OP_ARG(); + m_p=m_reg[C][nr]; +} + +inline void saturn_device::saturn_dec_p() +{ + m_carry=m_p==0; + m_p=(m_p-1)&0xf; +} + +inline void saturn_device::saturn_inc_p() +{ + m_p=(m_p+1)&0xf; + m_carry=m_p==0; +} + +inline void saturn_device::saturn_load_p() +{ + m_p=READ_OP_ARG(); +} + +inline void saturn_device::saturn_p_equals() +{ + m_carry=m_p==(READ_OP_ARG()); + saturn_jump_after_test(); +} + +inline void saturn_device::saturn_p_not_equals() +{ + m_carry=m_p!=(READ_OP_ARG()); + saturn_jump_after_test(); +} + +inline void saturn_device::saturn_ca_p_1() +{ + const int a=(S64_READ_A(C))+1+m_p; + m_carry=a>=0x100000; + S64_WRITE_A(C,a&0xfffff); +} + +inline void saturn_device::saturn_load_reg(int reg) +{ + int count=READ_OP_ARG(); + int pos=m_p; + saturn_assert(reg>=0 && reg<9); + for (; count>=0; count--, pos=(pos+1)&0xf) { + m_reg[reg][pos]=READ_OP_ARG(); + } +} + +inline void saturn_device::saturn_jump(int adr, int jump) +{ + saturn_assert(adr>=0 && adr<0x100000); + if (jump) { + m_pc=adr; + m_icount-=10; + } +} + +inline void saturn_device::saturn_call(int adr) +{ + saturn_assert(adr>=0 && adr<0x100000); + saturn_push(m_pc); + m_pc=adr; + //m_icount-=10; +} + +inline void saturn_device::saturn_return(int yes) +{ + if (yes) { + m_pc=saturn_pop(); + //m_icount-=10; + } +} + +inline void saturn_device::saturn_return_carry_set() +{ + m_pc=saturn_pop(); + //m_icount-=10; + m_carry=1; +} + +inline void saturn_device::saturn_return_carry_clear() +{ + m_pc=saturn_pop(); + //m_icount-=10; + m_carry=0; +} + +inline void saturn_device::saturn_return_interrupt() +{ + LOG("SATURN at %05x: RTI\n", m_pc-2); + m_in_irq=0; // set to 1 when an IRQ is taken + m_pc=saturn_pop(); + //m_icount-=10; +} + +inline void saturn_device::saturn_return_xm_set() +{ + m_pc=saturn_pop(); + m_hst|=XM; + //m_icount-=10; +} + +inline void saturn_device::saturn_pop_c() +{ + S64_WRITE_A(C,saturn_pop()); +} + +inline void saturn_device::saturn_push_c() +{ + saturn_push(S64_READ_A(C)); +} + +inline void saturn_device::saturn_indirect_jump(int reg) +{ + saturn_assert(reg>=0 && reg<9); + m_pc=READ_20(S64_READ_A(reg)); +} + +inline void saturn_device::saturn_equals_zero(int reg, int begin, int count) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(begin>=0 && begin<16 && count>0 && begin+count<=16); + m_carry=1; + for (int i=0; i=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=1; + for (int i=0; i=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=0; + for (int i=0; i=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=0; + for (int i=0; i=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=0; + for (int i=count-1; i>=0; i--) { + const int t=m_reg[reg][begin+i]; + const int t2=m_reg[right][begin+i]; + if (t>t2) { m_carry=1; break; } + if (t=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=1; + for (int i=count-1; i>=0; i--) { + const int t=m_reg[reg][begin+i]; + const int t2=m_reg[right][begin+i]; + if (tt2) break; + m_icount-=2; + } + saturn_jump_after_test(); +} + +inline void saturn_device::saturn_smaller_equals(int reg, int begin, int count, int right) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=1; + for (int i=count-1; i>=0; i--) { + const int t=m_reg[reg][begin+i]; + const int t2=m_reg[right][begin+i]; + if (t>t2) { m_carry=0; break; } + if (t=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=0; + for (int i=count-1; i>=0; i--) { + const int t=m_reg[reg][begin+i]; + const int t2=m_reg[right][begin+i]; + if (tt2) break; + m_icount-=2; + } + saturn_jump_after_test(); +} + +inline void saturn_device::saturn_jump_bit_clear(int reg) +{ + const int op=READ_OP_ARG(); + saturn_assert(reg>=0 && reg<9); + m_carry=!((m_reg[reg][op>>2]>>(op&3))&1); + saturn_jump_after_test(); +} + +inline void saturn_device::saturn_jump_bit_set(int reg) +{ + const int op=READ_OP_ARG(); + saturn_assert(reg>=0 && reg<9); + m_carry=(m_reg[reg][op>>2]>>(op&3))&1; + saturn_jump_after_test(); +} + +inline void saturn_device::saturn_load_pc(int reg) +{ + saturn_assert(reg>=0 && reg<9); + m_pc=S64_READ_A(reg); +} + +inline void saturn_device::saturn_store_pc(int reg) +{ + saturn_assert(reg>=0 && reg<9); + S64_WRITE_A(reg,m_pc); +} + +inline void saturn_device::saturn_exchange_pc(int reg) +{ + const int temp=m_pc; + saturn_assert(reg>=0 && reg<9); + m_pc=S64_READ_A(reg); + S64_WRITE_A(reg, temp); +} + +/************************************************************************************* + address register related +*************************************************************************************/ +inline void saturn_device::saturn_load_adr(int reg, int nibbles) +{ + saturn_assert(reg>=0 && reg<2); + saturn_assert(nibbles==2 || nibbles==4 || nibbles==5); + switch (nibbles) { + case 5: + m_d[reg]=READ_OP_ARG20(); + break; + case 4: + m_d[reg]=(m_d[reg]&0xf0000)|READ_OP_ARG16(); + break; + case 2: + m_d[reg]=(m_d[reg]&0xfff00)|READ_OP_ARG8(); + break; + } +} + +inline void saturn_device::saturn_add_adr(int reg) +{ + const int t=m_d[reg]+READ_OP_ARG()+1; + saturn_assert(reg>=0 && reg<2); + m_d[reg]=t&0xfffff; + m_carry=t>=0x100000; +} + +inline void saturn_device::saturn_sub_adr(int reg) +{ + const int t=m_d[reg]-READ_OP_ARG()-1; + saturn_assert(reg>=0 && reg<2); + m_d[reg]=t&0xfffff; + m_carry=t<0; +} + +inline void saturn_device::saturn_adr_to_reg(int adr, int reg) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(adr>=0 && adr<2); + S64_WRITE_A(reg,m_d[adr]); +} + +inline void saturn_device::saturn_reg_to_adr(int reg, int adr) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(adr>=0 && adr<2); + m_d[adr]=S64_READ_A(reg); +} + +inline void saturn_device::saturn_adr_to_reg_word(int adr, int reg) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(adr>=0 && adr<2); + S64_WRITE_WORD(reg,m_d[adr]&0xffff); +} + +inline void saturn_device::saturn_reg_to_adr_word(int reg, int adr) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(adr>=0 && adr<2); + m_d[adr]=(m_d[adr]&0xf0000)|S64_READ_WORD(reg); +} + +inline void saturn_device::saturn_exchange_adr_reg(int adr, int reg) +{ + const int temp=m_d[adr]; + saturn_assert(reg>=0 && reg<9); + saturn_assert(adr>=0 && adr<2); + m_d[adr]=S64_READ_A(reg); + S64_WRITE_A(reg,temp); +} + +inline void saturn_device::saturn_exchange_adr_reg_word(int adr, int reg) +{ + const int temp=m_d[adr]&0xffff; + saturn_assert(reg>=0 && reg<9); + saturn_assert(adr>=0 && adr<2); + m_d[adr]=(m_d[adr]&0xf0000)|S64_READ_WORD(reg); + S64_WRITE_WORD(reg,temp); +} + +inline void saturn_device::saturn_load_nibbles(int reg, int begin, int count, int adr) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(adr>=0 && adr<2); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=0 && reg<9); + saturn_assert(adr>=0 && adr<2); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=0 && reg<9); + m_reg[reg][arg>>2]&=~(1<<(arg&3)); +} + +inline void saturn_device::saturn_set_bit(int reg) +{ + const int arg=READ_OP_ARG(); + saturn_assert(reg>=0 && reg<9); + m_reg[reg][arg>>2]|=1<<(arg&3); +} + +/**************************************************************************** + clear opers + ****************************************************************************/ +inline void saturn_device::saturn_clear(int reg, int begin, int count) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=0 && left<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=0 && dest<9); + saturn_assert(src>=0 && src<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=0; + for (int i=0; i=base) { + m_carry=1; + t-=base; + } + else m_carry=0; + saturn_assert(t>=0); saturn_assert(t=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + saturn_assert(count>1 || !m_decimal); /* SATURN bug */ + for (int i=0; i>=4; + if (t>=base) { + right++; + t-=base; + } + saturn_assert(t>=0); saturn_assert(t0; +} + +/**************************************************************************** + sub opers + ****************************************************************************/ +inline void saturn_device::saturn_sub(int reg, int begin, int count, int right) +{ + const int base=m_decimal?10:16; + saturn_assert(reg>=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=0; + for (int i=0; i=0); saturn_assert(t=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + saturn_assert(count>1 || !m_decimal); // SATURN bug + for (int i=0; i>=4; + if (t<0) { + right++; + t+=base; + } + saturn_assert(t>=0); saturn_assert(t0; +} + +/**************************************************************************** + sub2 opers (a=b-a) + ****************************************************************************/ +inline void saturn_device::saturn_sub2(int reg, int begin, int count, int right) +{ + const int base=m_decimal?10:16; + saturn_assert(reg>=0 && reg<9); + saturn_assert(right>=0 && right<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=0; + for (int i=0; i=0); saturn_assert(t=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=base) m_reg[reg][begin+i]=t-base; + else { m_reg[reg][begin+i]=t; break; } + } + m_carry=t>=base; +} + +/**************************************************************************** + decrement opers + ****************************************************************************/ +inline void saturn_device::saturn_decrement(int reg, int begin, int count) +{ + int t=0; + const int base=m_decimal?10:16; + saturn_assert(reg>=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + m_carry=0; + for (int i=0; i=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + int c=1; + m_carry=0; + for (int i=0; imax) n-=max+1; + else c=0; + saturn_assert(n>=0); saturn_assert(n<=max); + m_reg[reg][begin+i]=n&0xf; + m_icount-=2; + } +} + +/**************************************************************************** + or opers + ****************************************************************************/ +inline void saturn_device::saturn_or(int dest, int begin, int count, int src) +{ + saturn_assert(dest>=0 && dest<9); + saturn_assert(src>=0 && src<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=0 && dest<9); + saturn_assert(src>=0 && src<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=0; i=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + if (m_reg[reg][begin+count-1]) m_hst|=SB; + for (int i=count-1; i>=1; i--) { + m_reg[reg][begin+i]=m_reg[reg][begin+i-1]; + m_icount-=2; + } + m_reg[reg][begin]=0; + m_icount-=2; +} + +/**************************************************************************** + shift nibbles right opers + ****************************************************************************/ +inline void saturn_device::saturn_shift_nibble_right(int reg, int begin, int count) +{ + saturn_assert(reg>=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + if (m_reg[reg][begin]) m_hst|=SB; + for (int i=1; i=0 && reg<9); + for (int i=15; i>=1; i--) { + m_reg[reg][i]=m_reg[reg][i-1]; + m_icount-=2; + } + m_reg[reg][0]=x; + m_icount-=2; +} + +/**************************************************************************** + rotate nibbles right opers + ****************************************************************************/ +inline void saturn_device::saturn_rotate_nibble_right_w(int reg) +{ + const int x=m_reg[reg][0]; + saturn_assert(reg>=0 && reg<9); + for (int i=1; i<16; i++) { + m_reg[reg][i-1]=m_reg[reg][i]; + m_icount-=2; + } + m_reg[reg][15]=x; + if (x) m_hst|=SB; + m_icount-=2; +} + + +/**************************************************************************** + shift right opers + ****************************************************************************/ +inline void saturn_device::saturn_shift_right(int reg, int begin, int count) +{ + int c=0; + saturn_assert(reg>=0 && reg<9); + saturn_assert(begin>=0 && count>0 && begin+count<=16); + for (int i=count-1; i>=0; i--) { + int t=m_reg[reg][begin+i]; + t|=(c<<4); + c=t&1; + m_reg[reg][begin+i]=t>>1; + m_icount-=2; + } + if (c) m_hst|=SB; + m_icount-=2; +} + +#endif // MAME_CPU_SATURN_SATOPS_IPP diff --git a/src/devices/cpu/saturn/sattable.hxx b/src/devices/cpu/saturn/sattable.hxx deleted file mode 100644 index f8b5398973c..00000000000 --- a/src/devices/cpu/saturn/sattable.hxx +++ /dev/null @@ -1,1039 +0,0 @@ -// license:BSD-3-Clause -// copyright-holders:Peter Trauner,Antoine Mine -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, -}; - -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, -}; - -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, -}; - -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, -}; - -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 -}; - -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 -}; - -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}; -static const int add_left[] ={A,B,C,D, I,I,I,I, B,C,A,C, I,I,I,I}; -static const int add_right[]={B,C,A,C, I,I,I,I, A,B,C,D, I,I,I,I}; -static const int sub_left[] ={A,B,C,D, I,I,I,I, B,C,A,C, A,B,C,D}; -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 ); -} - -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 ); -} - -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 ); -} - -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 ); -} - - -void saturn_device::saturn_instruction_0e() -{ - int reg, adr; - - switch(adr=READ_OP()) { - case 0: - switch(reg=READ_OP()){ - case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: - saturn_and(reg_left[reg], m_p, 1, reg_right[reg]); - break; //A=A&B p - case 8: case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: - saturn_or(reg_left[reg&7], m_p, 1, reg_right[reg&7]); - break; //A=A!B p - } - break; - case 1: - switch(reg=READ_OP()){ - case 0: case 1: case 2: case 3:case 4: case 5: case 6: case 7: - saturn_and(reg_left[reg], 0, m_p+1, reg_right[reg]); - break; //A=A&B wp - case 8: case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: - saturn_or(reg_left[reg&7], 0, m_p+1, reg_right[reg&7]); - break; //A=A!B wp - } - break; - case 2: case 3: case 4: case 5: case 6: case 7: case 0xf: - switch(reg=READ_OP()){ - case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: - saturn_and(reg_left[reg], adr_af_begin[adr], adr_af_count[adr], reg_right[reg]); - break; //A=A&B xs - case 8: case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: - saturn_or(reg_left[reg&7], adr_af_begin[adr], adr_af_count[adr], reg_right[reg&7]); - break; //A=A!B xs - } - break; - default: - saturn_invalid3( 0, 0xe, adr ); - break; - } -} - -void saturn_device::saturn_instruction_1() -{ - int reg, adr, oper; - - switch (adr=READ_OP()) { - case 0: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_copy(R0+reg, BEGIN_W, COUNT_W, A); - break; // r0=a w - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_copy(R0+(reg&7), BEGIN_W, COUNT_W, C); - break; // r0=c w - default: - saturn_invalid3( 1, adr, reg ); - break; - } - break; - case 1: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_copy(A, BEGIN_W, COUNT_W, R0+reg); - break; // a=r0 w - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_copy(C, BEGIN_W, COUNT_W, R0+(reg&7)); - break; // c=r0 w - default: - saturn_invalid3( 1, adr, reg ); - break; - } - break; - case 2: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_exchange(A, BEGIN_W, COUNT_W, R0+reg); - break; // ar0ex w - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_exchange(C, BEGIN_W, COUNT_W, R0+(reg&7)); - break; // cr0ex w - default: - saturn_invalid3( 2, adr, reg ); - break; - } - break; - case 3: - switch (READ_OP()) { - case 0: saturn_reg_to_adr(A,0);break; - case 1: saturn_reg_to_adr(A,1);break; - case 2: saturn_exchange_adr_reg(0,A);break; - case 3: saturn_exchange_adr_reg(1,A);break; - case 4: saturn_reg_to_adr(C,0);break; - case 5: saturn_reg_to_adr(C,1);break; - case 6: saturn_exchange_adr_reg(0,C);break; - case 7: saturn_exchange_adr_reg(1,C);break; - case 8: saturn_reg_to_adr_word(A,0);break; - case 9: saturn_reg_to_adr_word(A,1);break; - case 0xa: saturn_exchange_adr_reg_word(0,A);break; - case 0xb: saturn_exchange_adr_reg_word(1,A);break; - case 0xc: saturn_reg_to_adr_word(C,0);break; - case 0xd: saturn_reg_to_adr_word(C,1);break; - case 0xe: saturn_exchange_adr_reg_word(0,C);break; - case 0xf: saturn_exchange_adr_reg_word(1,C);break; - } - break; - case 4: - switch (READ_OP()) { - case 0: saturn_store_nibbles(A, BEGIN_A, COUNT_A, 0); break; - case 1: saturn_store_nibbles(A, BEGIN_A, COUNT_A, 1); break; - case 2: saturn_load_nibbles(A, BEGIN_A, COUNT_A, 0); break; - case 3: saturn_load_nibbles(A, BEGIN_A, COUNT_A, 1); break; - case 4: saturn_store_nibbles(C, BEGIN_A, COUNT_A, 0); break; - case 5: saturn_store_nibbles(C, BEGIN_A, COUNT_A, 1); break; - case 6: saturn_load_nibbles(C, BEGIN_A, COUNT_A, 0); break; - case 7: saturn_load_nibbles(C, BEGIN_A, COUNT_A, 1); break; - case 8: saturn_store_nibbles(A, BEGIN_B, COUNT_B, 0); break; - case 9: saturn_store_nibbles(A, BEGIN_B, COUNT_B, 1); break; - case 0xa: saturn_load_nibbles(A, BEGIN_B, COUNT_B, 0); break; - case 0xb: saturn_load_nibbles(A, BEGIN_B, COUNT_B, 1); break; - case 0xc: saturn_store_nibbles(C, BEGIN_B, COUNT_B, 0); break; - case 0xd: saturn_store_nibbles(C, BEGIN_B, COUNT_B, 1); break; - case 0xe: saturn_load_nibbles(C, BEGIN_B, COUNT_B, 0); break; - case 0xf: saturn_load_nibbles(C, BEGIN_B, COUNT_B, 1); break; - } - break; - case 5: - switch (oper=READ_OP()) { - case 0: case 1: case 4: case 5: - switch (adr=READ_OP()) { - case 0: - saturn_store_nibbles(oper&4?C:A,m_p,1,oper&1); - break; - case 1: - saturn_store_nibbles(oper&4?C:A,0,m_p+1,oper&1); - break; - case 2: case 3: case 4: case 5: case 6: case 7: - saturn_store_nibbles(oper&4?C:A,adr_a_begin[adr],adr_a_count[adr],oper&1); - break; - default: - saturn_invalid4( 1, 5, oper, adr ); - break; - } - break; - case 2: case 3: case 6: case 7: - switch (adr=READ_OP()) { - case 0: - saturn_load_nibbles(oper&4?C:A,m_p,1,oper&1); - break; - case 1: - saturn_load_nibbles(oper&4?C:A,0,m_p+1,oper&1); - break; - case 2: case 3: case 4: case 5: case 6: case 7: - saturn_load_nibbles(oper&4?C:A,adr_a_begin[adr],adr_a_count[adr],oper&1); - break; - default: - saturn_invalid4( 1, 5, oper, adr ); - break; - } - break; - case 8: saturn_store_nibbles(A, 0, READ_OP()+1, 0); break; - case 9: saturn_store_nibbles(A, 0, READ_OP()+1, 1); break; - case 0xa: saturn_load_nibbles(A, 0, READ_OP()+1, 0); break; - case 0xb: saturn_load_nibbles(A, 0, READ_OP()+1, 1); break; - case 0xc: saturn_store_nibbles(C, 0, READ_OP()+1, 0); break; - case 0xd: saturn_store_nibbles(C, 0, READ_OP()+1, 1); break; - case 0xe: saturn_load_nibbles(C, 0, READ_OP()+1, 0); break; - case 0xf: saturn_load_nibbles(C, 0, READ_OP()+1, 1); break; - } - break; - case 6: saturn_add_adr(0);break; - case 7: saturn_add_adr(1);break; - case 8: saturn_sub_adr(0);break; - case 9: saturn_load_adr(0,2);break; - case 0xa: saturn_load_adr(0,4);break; - case 0xb: saturn_load_adr(0,5);break; - case 0xc: saturn_sub_adr(1);break; - case 0xd: saturn_load_adr(1,2);break; - case 0xe: saturn_load_adr(1,4);break; - case 0xf: saturn_load_adr(1,5);break; - } -} - -void saturn_device::saturn_instruction_80() -{ - int op; - switch(READ_OP()) { - case 0: saturn_out_cs();break; - case 1: saturn_out_c();break; - case 2: saturn_in(A);break; - case 3: saturn_in(C);break; - case 4: saturn_mem_unconfig();break; - case 5: saturn_mem_config();break; - case 6: saturn_mem_id();break; - case 7: saturn_shutdown();break; - case 8: - switch(READ_OP()) { - case 0: saturn_interrupt_on();break; - case 1: - switch(op=READ_OP()) { - case 0: saturn_reset_interrupt();break; - default: saturn_invalid5( 8, 0, 8, 1, op ); break; - } - break; - case 2: saturn_load_reg(A);break; //la - case 3: saturn_bus_command_b();break; - case 4: saturn_clear_bit(A);break; // abit=0 - case 5: saturn_set_bit(A);break; // abit=1 - case 6: saturn_jump_bit_clear(A);break; - case 7: saturn_jump_bit_set(A);break; - case 8: saturn_clear_bit(C);break; // cbit=0 - case 9: saturn_set_bit(C);break; // cbit=1 - case 0xa: saturn_jump_bit_clear(C);break; - case 0xb: saturn_jump_bit_set(C);break; - case 0xc: saturn_indirect_jump(A);break; - case 0xd: saturn_bus_command_d();break; - case 0xe: saturn_indirect_jump(C);break; - case 0xf: saturn_interrupt_off();break; - } - break; - case 9: saturn_ca_p_1();break;//C+P+1 - case 0xa: saturn_mem_reset();break; - case 0xb: saturn_bus_command_b();break; - case 0xc: saturn_p_to_c();break; - case 0xd: saturn_c_to_p();break; - case 0xe: saturn_serial_request();break; - case 0xf: saturn_exchange_p();break; - } -} - -void saturn_device::saturn_instruction_81a() -{ - int reg, adr,op; - switch(adr=READ_OP()) { - case 0: - switch(op=READ_OP()) { - case 0: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_copy(R0+reg,m_p,1,A); - break; //r0=a p - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_copy(R0+(reg&7),m_p,1,C); - break; //r0=c p - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - case 1: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_copy(A,m_p,1,R0+reg); - break; //a=r0 p - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_copy(C,m_p,1,R0+(reg&7)); - break; //c=r0 p - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - case 2: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_exchange(A, m_p,1,R0+reg); - break; // ar0ex p - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_exchange(C, m_p,1,R0+(reg&7)); - break; // cr0ex p - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - default: - saturn_invalid5( 8, 1, 0xa, adr, op ); - break; - } - break; - case 1: - switch(op=READ_OP()) { - case 0: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_copy(R0+reg,0,m_p+1,A); - break; //r0=a wp - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_copy(R0+(reg&7),0,m_p+1,C); - break; //r0=c wp - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - case 1: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_copy(A,0,m_p+1,R0+reg); - break; //a=r0 wp - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_copy(C,0,m_p+1,R0+(reg&7)); - break; //c=r0 wp - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - case 2: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_exchange(A, 0, m_p+1, R0+reg); - break; // ar0ex wp - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_exchange(C, 0, m_p+1, R0+(reg&7)); - break; // cr0ex wp - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - default: - saturn_invalid5( 8, 1, 0xa, adr, op ); - break; - } - break; - case 2: case 3: case 4: case 5: case 6: case 7: case 0xf: - switch(op=READ_OP()) { - case 0: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_copy(R0+reg,adr_af_begin[adr],adr_af_count[adr],A); - break; //r0=a xs - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_copy(R0+(reg&7),adr_af_begin[adr], adr_af_count[adr],C); - break; //r0=c xs - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - case 1: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_copy(A,adr_af_begin[adr],adr_af_count[adr],R0+reg); - break; //a=r0 xs - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_copy(C,adr_af_begin[adr],adr_af_count[adr],R0+(reg&7)); - break; //c=r0 xs - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - case 2: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: case 4: - saturn_exchange(A, adr_af_begin[adr], adr_af_count[adr], R0+reg); - break; // ar0ex xs - case 8: case 9: case 0xa: case 0xb: case 0xc: - saturn_exchange(C, adr_af_begin[adr], adr_af_count[adr], R0+(reg&7)); - break; // cr0ex xs - default: - saturn_invalid6( 8, 1, 0xa, adr, op, reg); - break; - } - break; - default: - saturn_invalid5( 8, 1, 0xa, adr, op ); - break; - } - break; - default: - saturn_invalid4( 8, 1, 0xa, adr ); - break; - } -} - -void saturn_device::saturn_instruction_81() -{ - int reg, adr; - - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_rotate_nibble_left_w(A+reg); break; // aslc w - case 4: case 5: case 6: case 7: - saturn_rotate_nibble_right_w(A+(reg&3)); break; // asrc w - case 8: - switch(adr=READ_OP()) { - case 0: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_add_const(A+reg, m_p, 1, READ_OP()+1); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_sub_const(A+(reg&3), m_p, 1, READ_OP()+1); - break; - default: - saturn_invalid5( 8, 1, 8, adr, reg ); - break; - } - break; - case 1: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_add_const(A+reg, 0, m_p+1, READ_OP()+1); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_sub_const(A+(reg&3), 0, m_p+1, READ_OP()+1); - break; - default: - saturn_invalid5( 8, 1, 8, adr, reg ); - break; - } - break; - case 2: case 3: case 4: case 5: case 6: case 7: case 0xf: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_add_const(A+reg, adr_af_begin[adr], adr_af_count[adr], READ_OP()+1); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_sub_const(A+(reg&3), adr_af_begin[adr], adr_af_count[adr], READ_OP()+1); - break; - default: - saturn_invalid5( 8, 1, 8, adr, reg ); - break; - } - break; - default: - saturn_invalid4( 8, 1, 8, adr ); - break; - } - break; - case 9: - switch(adr=READ_OP()) { - case 0: - switch(reg=READ_OP()){ - case 0: case 1: case 2: case 3: - saturn_shift_right(A+reg,m_p,1); - break; // asrb p - default: - saturn_invalid5( 8, 1, 9, adr, reg ); - break; - } - break; - case 1: - switch(reg=READ_OP()){ - case 0: case 1: case 2: case 3: - saturn_shift_right(A+reg, 0,m_p+1); - break; // asrb wp - default: - saturn_invalid5( 8, 1, 9, adr, reg ); - break; - } - break; - case 2: case 3: case 4: case 5: case 6: case 7: case 0xf: - switch(reg=READ_OP()){ - case 0: case 1: case 2: case 3: - saturn_shift_right(A+reg, adr_af_begin[adr], adr_af_count[adr]); - break; // asrb xs - default: - saturn_invalid5( 8, 1, 9, adr, reg ); - break; - } - break; - default: - saturn_invalid4( 8, 1, 9, adr ); - break; - } - break; - case 0xa: - saturn_instruction_81a(); - break; - case 0xb: - switch(adr=READ_OP()) { - case 2: saturn_load_pc(A);break; - case 3: saturn_load_pc(C);break; - case 4: saturn_store_pc(A);break; - case 5: saturn_store_pc(C);break; - case 6: saturn_exchange_pc(A);break; - case 7: saturn_exchange_pc(C);break; - default: saturn_invalid4( 8, 1, reg, adr ); break; - } - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_shift_right(A+(reg&3), BEGIN_W, COUNT_W); - break; // asrb w - } -} - -void saturn_device::saturn_instruction_8() -{ - int oper, adr; - - switch(READ_OP()) { - case 0: - saturn_instruction_80(); - break; - case 1: - saturn_instruction_81(); - break; - case 2: saturn_hst_clear_bits();break; - case 3: saturn_hst_bits_cleared();break; - case 4: saturn_st_clear_bit();break; - case 5: saturn_st_set_bit();break; - case 6: saturn_st_jump_bit_clear();break; - case 7: saturn_st_jump_bit_set();break; - case 8: saturn_p_not_equals(); break; - case 9: saturn_p_equals(); break; - case 0xa: - switch(oper=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_equals(reg_left[oper&3] , BEGIN_A, COUNT_A, reg_right[oper&3]); - break; - case 4: case 5: case 6: case 7: - saturn_not_equals(reg_left[oper&3] , BEGIN_A, COUNT_A, reg_right[oper&3]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_equals_zero(A+(oper&3), BEGIN_A, COUNT_A); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_not_equals_zero(A+(oper&3), BEGIN_A, COUNT_A); - break; - } - break; - case 0xb: - switch(oper=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_greater(reg_left[oper&3] , BEGIN_A, COUNT_A, reg_right[oper&3]); - break; - case 4: case 5: case 6: case 7: - saturn_smaller(reg_left[oper&3] , BEGIN_A, COUNT_A, reg_right[oper&3]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_greater_equals(reg_left[oper&3], BEGIN_A, COUNT_A, reg_right[oper&3]); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_smaller_equals(reg_left[oper&3], BEGIN_A, COUNT_A, reg_right[oper&3]); - break; - } - break; - case 0xc: - adr=READ_OP_DIS16(); - saturn_jump((adr+m_pc-4)&0xfffff,1); - break; - case 0xd: - adr=READ_OP_ARG20(); - saturn_jump(adr,1); - break; - case 0xe: - adr=READ_OP_DIS16(); - saturn_call((adr+m_pc)&0xfffff); - break; - case 0xf: - adr=READ_OP_ARG20(); - saturn_call(adr); - break; - } -} - -void saturn_device::saturn_instruction_9() -{ - int adr, oper; - - switch(adr=READ_OP()) { - case 0: - switch(oper=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_equals(reg_left[oper&3] , m_p, 1, reg_right[oper&3]); - break; - case 4: case 5: case 6: case 7: - saturn_not_equals(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_equals_zero(A+(oper&3), m_p, 1); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_not_equals_zero(A+(oper&3), m_p, 1); - break; - } - break; - case 1: - switch(oper=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_equals(reg_left[oper&3] , 0, m_p+1, reg_right[oper&3]); - break; - case 4: case 5: case 6: case 7: - saturn_not_equals(reg_left[oper&3] , 0, m_p+1, reg_right[oper&3]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_equals_zero(A+(oper&3), 0, m_p+1); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_not_equals_zero(A+(oper&3), 0, m_p+1); - break; - } - break; - case 2: case 3: case 4: case 5: case 6: case 7: - switch(oper=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_equals(reg_left[oper&3] ,adr_a_begin[adr], adr_a_count[adr], reg_right[oper&3]); - break; - case 4: case 5: case 6: case 7: - saturn_not_equals(reg_left[oper&3] ,adr_a_begin[adr], adr_a_count[adr], reg_right[oper&3]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_equals_zero(A+(oper&3),adr_a_begin[adr], adr_a_count[adr]); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_not_equals_zero(A+(oper&3) ,adr_a_begin[adr], adr_a_count[adr]); - break; - } - break; - case 8: - switch(oper=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_greater(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); - break; - case 4: case 5: case 6: case 7: - saturn_smaller(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_greater_equals(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_smaller_equals(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); - break; - } - break; - case 9: - switch(oper=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_greater(reg_left[oper&3] , 0, m_p+1, reg_right[oper&3]); - break; - case 4: case 5: case 6: case 7: - saturn_smaller(reg_left[oper&3] , 0, m_p+1, reg_right[oper&3]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_greater_equals(reg_left[oper&3], 0, m_p+1, reg_right[oper&3]); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_smaller_equals(reg_left[oper&3], 0, m_p+1, reg_right[oper&3]); - break; - } - break; - case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: - switch(oper=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_greater(reg_left[oper&3] ,adr_b_begin[adr], adr_b_count[adr], reg_right[oper&3]); - break; - case 4: case 5: case 6: case 7: - saturn_smaller(reg_left[oper&3] ,adr_b_begin[adr], adr_b_count[adr], reg_right[oper&3]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_greater_equals(reg_left[oper&3] ,adr_b_begin[adr], adr_b_count[adr], reg_right[oper&3]); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_smaller_equals(reg_left[oper&3] ,adr_b_begin[adr], adr_b_count[adr], reg_right[oper&3]); - break; - } - break; - } -} - -void saturn_device::saturn_instruction_a() -{ - int reg, adr; - - switch(adr=READ_OP()) { - case 0: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: - case 8: case 9: case 0xa: case 0xb: - saturn_add(add_left[reg], m_p, 1, add_right[reg]); - break; - case 4: case 5: case 6: case 7: - saturn_add(A+(reg&3), m_p, 1, A+(reg&3)); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_decrement(A+(reg&3), m_p, 1); - break; - } - break; - case 1: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: - case 8: case 9: case 0xa: case 0xb: - saturn_add(add_left[reg], 0, m_p+1, add_right[reg]); - break; - case 4: case 5: case 6: case 7: - saturn_add(A+(reg&3), 0, m_p+1, A+(reg&3)); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_decrement(A+(reg&3), 0, m_p+1); - break; - } - break; - case 2: case 3: case 4: case 5: case 6: case 7: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: - case 8: case 9: case 0xa: case 0xb: - saturn_add(add_left[reg], adr_a_begin[adr], adr_a_count[adr], add_right[reg]); - break; - case 4: case 5: case 6: case 7: - saturn_add(A+(reg&3), adr_a_begin[adr], adr_a_count[adr], A+(reg&3)); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_decrement(A+(reg&3), adr_a_begin[adr], adr_a_count[adr]); - break; - } - break; - case 8: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_clear(A+reg, m_p,1); - break; // a=0 p - case 4: case 5: case 6: case 7: - case 8: case 9: case 0xa: case 0xb: - saturn_copy(reg_right[reg&7], m_p,1,reg_left[reg&7]); - break; // a=b p - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_exchange(reg_left[reg&3], m_p,1,reg_right[reg&3]); - break; // abex p - } - break; - case 9: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_clear(A+reg,0,m_p+1); - break; // a=0 wp - case 4: case 5: case 6: case 7: - case 8: case 9: case 0xa: case 0xb: - saturn_copy(reg_right[reg&7], 0, m_p+1, reg_left[reg&7]); - break; // a=b wp - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_exchange(reg_left[reg&3], 0, m_p+1, reg_right[reg&3]); - break; // abex wp - } - break; - case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_clear(A+reg, adr_b_begin[adr], adr_b_count[adr]); - break; // a=0 xs - case 4: case 5: case 6: case 7: - case 8: case 9: case 0xa: case 0xb: - saturn_copy(reg_right[reg&7], adr_b_begin[adr], adr_b_count[adr], reg_left[reg&7]); - break; // a=b xs - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_exchange(reg_left[reg&3], adr_b_begin[adr], adr_b_count[adr], reg_right[reg&3]); - break; // abex xs - } - break; - } -} - -void saturn_device::saturn_instruction_b() -{ - int adr, reg; - - switch(adr=READ_OP()) { - case 0: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - case 8: case 9: case 0xa: case 0xb: - saturn_sub(sub_left[reg], m_p, 1, sub_right[reg]); - break; - case 4: case 5: case 6: case 7: - saturn_increment(A+(reg&3), m_p, 1); break; // a=a+1 p - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_sub2(sub_left[reg], m_p, 1, sub_right[reg]); - break; - } - break; - case 1: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - case 8: case 9: case 0xa: case 0xb: - saturn_sub(sub_left[reg], 0, m_p+1, sub_right[reg]); - break; - case 4: case 5: case 6: case 7: - saturn_increment(A+(reg&3), 0, m_p+1); break; // a=a+1 wp - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_sub2(sub_left[reg], 0, m_p+1, sub_right[reg]); - break; - } - break; - case 2: case 3: case 4: case 5: case 6: case 7: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - case 8: case 9: case 0xa: case 0xb: - saturn_sub(sub_left[reg], adr_a_begin[adr], adr_a_count[adr], sub_right[reg]); - break; - case 4: case 5: case 6: case 7: - saturn_increment(A+(reg&3), adr_a_begin[adr], adr_a_count[adr]); - break; // a=a+1 xs - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_sub2(sub_left[reg], adr_a_begin[adr], adr_a_count[adr], - sub_right[reg]); - break; - } - break; - case 8: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_shift_nibble_left(A+reg, m_p, 1); break; // asl p - case 4: case 5: case 6: case 7: - saturn_shift_nibble_right(A+(reg&3), m_p, 1); break; // asr p - case 8: case 9: case 0xa: case 0xb: - saturn_negate(A+(reg&3), m_p, 1); break; // A=-A p - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_invert(A+(reg&3), m_p, 1); break; // A=-A-1 p - } - break; - case 9: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_shift_nibble_left(A+reg,0,m_p+1); break; // asl wp - case 4: case 5: case 6: case 7: - saturn_shift_nibble_right(A+(reg&3),0,m_p+1); break; // asr wp - case 8: case 9: case 0xa: case 0xb: - saturn_negate(A+(reg&3),0,m_p+1); break; // A=-A wp - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_invert(A+(reg&3),0,m_p+1); break; // A=-A-1 wp - } - break; - case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_shift_nibble_left(A+reg,adr_b_begin[adr], adr_b_count[adr]); - break; - case 4: case 5: case 6: case 7: - saturn_shift_nibble_right(A+(reg&3), adr_b_begin[adr], adr_b_count[adr]); - break; - case 8: case 9: case 0xa: case 0xb: - saturn_negate(A+(reg&3), adr_b_begin[adr], adr_b_count[adr]); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_invert(A+(reg&3), adr_b_begin[adr], adr_b_count[adr]); - break; - } - break; - } -} - - -void saturn_device::saturn_instruction() -{ - int reg, adr; - - 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 0xa: saturn_c_to_st();break; - case 0xb: saturn_exchange_c_st();break; - case 0xc: saturn_inc_p();break; - case 0xd: saturn_dec_p();break; - case 0xe: saturn_instruction_0e();break; - case 0xf: saturn_return_interrupt();break; - } - break; - case 1: - saturn_instruction_1(); - break; - case 2: - saturn_load_p(); - break; - case 3: - saturn_load_reg(C); - break; // lc - case 4: - adr=READ_OP_DIS8(); - if (adr==0) { - saturn_return(m_carry); - } - else { - saturn_jump((m_pc+adr-2)&0xfffff, m_carry); - } - break; - case 5: - adr=READ_OP_DIS8(); - if (adr==0) { - saturn_return(!m_carry); - } - else { - saturn_jump((m_pc+adr-2)&0xfffff,!m_carry); - } - break; - case 6: - adr=READ_OP_DIS12(); - saturn_jump((m_pc+adr-3)&0xfffff,1); break; - case 7: - adr=READ_OP_DIS12(); - saturn_call((adr+m_pc)&0xfffff); break; - case 8: - saturn_instruction_8(); - break; - case 9: - saturn_instruction_9(); - break; - case 0xa: - saturn_instruction_a(); - break; - case 0xb: - saturn_instruction_b(); - break; - case 0xc: - switch (reg=READ_OP()) { - case 0: case 1: case 2: case 3: - case 8: case 9: case 0xa: case 0xb: - saturn_add(add_left[reg], BEGIN_A, COUNT_A, add_right[reg]); - break; - case 4: case 5: case 6: case 7: - saturn_add(A+(reg&3), BEGIN_A, COUNT_A, A+(reg&3)); - break; - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_decrement(A+(reg&3), BEGIN_A, COUNT_A); - break; - } - break; - case 0xd: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_clear(A+reg, BEGIN_A, COUNT_A); - break; // a=0 a - case 4: case 5: case 6: case 7: - case 8: case 9: case 0xa: case 0xb: - saturn_copy(reg_right[reg&7], BEGIN_A, COUNT_A, reg_left[reg&7]); - break; // a=b a - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_exchange(reg_left[reg&3], BEGIN_A, COUNT_A, reg_right[reg&3]); - break; // abex a - } - break; - case 0xe: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - case 8: case 9: case 0xa: case 0xb: - saturn_sub(sub_left[reg], BEGIN_A, COUNT_A, sub_right[reg]); - break; - case 4: case 5: case 6: case 7: - saturn_increment(A+(reg&3), BEGIN_A, COUNT_A); - break; // a=a+1 a - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_sub2(sub_left[reg], BEGIN_A, COUNT_A, sub_right[reg]); - break; - } - break; - case 0xf: - switch(reg=READ_OP()) { - case 0: case 1: case 2: case 3: - saturn_shift_nibble_left(A+reg,BEGIN_A, COUNT_A); - break; // asl a - case 4: case 5: case 6: case 7: - saturn_shift_nibble_right(A+(reg&3),BEGIN_A, COUNT_A); - break; // asr a - case 8: case 9: case 0xa: case 0xb: - saturn_negate(A+(reg&3),BEGIN_A, COUNT_A); - break; // A=-A a - case 0xc: case 0xd: case 0xe: case 0xf: - saturn_invert(A+(reg&3),BEGIN_A, COUNT_A); - break; // A=-A-1 a - } - break; - } -} diff --git a/src/devices/cpu/saturn/sattable.ipp b/src/devices/cpu/saturn/sattable.ipp new file mode 100644 index 00000000000..18b534da069 --- /dev/null +++ b/src/devices/cpu/saturn/sattable.ipp @@ -0,0 +1,1047 @@ +// 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, }; + +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, }; + +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, }; + +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, }; + +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 }; + +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 }; + +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}; +static const int add_left[] ={A,B,C,D, I,I,I,I, B,C,A,C, I,I,I,I}; +static const int add_right[]={B,C,A,C, I,I,I,I, A,B,C,D, I,I,I,I}; +static const int sub_left[] ={A,B,C,D, I,I,I,I, B,C,A,C, A,B,C,D}; +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 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 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 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 invalid opcode %x%x%x%x%x%x at %05x\n", op1, op2, op3, op4, op5, op6, m_pc-6); +} + + +void saturn_device::saturn_instruction_0e() +{ + int reg, adr; + + switch (adr=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: + saturn_and(reg_left[reg], m_p, 1, reg_right[reg]); + break; //A=A&B p + case 8: case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: + saturn_or(reg_left[reg&7], m_p, 1, reg_right[reg&7]); + break; //A=A!B p + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3:case 4: case 5: case 6: case 7: + saturn_and(reg_left[reg], 0, m_p+1, reg_right[reg]); + break; //A=A&B wp + case 8: case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: + saturn_or(reg_left[reg&7], 0, m_p+1, reg_right[reg&7]); + break; //A=A!B wp + } + break; + case 2: case 3: case 4: case 5: case 6: case 7: case 0xf: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: + saturn_and(reg_left[reg], adr_af_begin[adr], adr_af_count[adr], reg_right[reg]); + break; //A=A&B xs + case 8: case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: + saturn_or(reg_left[reg&7], adr_af_begin[adr], adr_af_count[adr], reg_right[reg&7]); + break; //A=A!B xs + } + break; + default: + saturn_invalid3(0, 0xe, adr); + break; + } +} + +void saturn_device::saturn_instruction_1() +{ + int reg, adr, oper; + + switch (adr=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_copy(R0+reg, BEGIN_W, COUNT_W, A); + break; // r0=a w + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_copy(R0+(reg&7), BEGIN_W, COUNT_W, C); + break; // r0=c w + default: + saturn_invalid3(1, adr, reg); + break; + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_copy(A, BEGIN_W, COUNT_W, R0+reg); + break; // a=r0 w + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_copy(C, BEGIN_W, COUNT_W, R0+(reg&7)); + break; // c=r0 w + default: + saturn_invalid3(1, adr, reg); + break; + } + break; + case 2: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_exchange(A, BEGIN_W, COUNT_W, R0+reg); + break; // ar0ex w + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_exchange(C, BEGIN_W, COUNT_W, R0+(reg&7)); + break; // cr0ex w + default: + saturn_invalid3(2, adr, reg); + break; + } + break; + case 3: + switch (READ_OP()) { + case 0: saturn_reg_to_adr(A,0);break; + case 1: saturn_reg_to_adr(A,1);break; + case 2: saturn_exchange_adr_reg(0,A);break; + case 3: saturn_exchange_adr_reg(1,A);break; + case 4: saturn_reg_to_adr(C,0);break; + case 5: saturn_reg_to_adr(C,1);break; + case 6: saturn_exchange_adr_reg(0,C);break; + case 7: saturn_exchange_adr_reg(1,C);break; + case 8: saturn_reg_to_adr_word(A,0);break; + case 9: saturn_reg_to_adr_word(A,1);break; + case 0xa: saturn_exchange_adr_reg_word(0,A);break; + case 0xb: saturn_exchange_adr_reg_word(1,A);break; + case 0xc: saturn_reg_to_adr_word(C,0);break; + case 0xd: saturn_reg_to_adr_word(C,1);break; + case 0xe: saturn_exchange_adr_reg_word(0,C);break; + case 0xf: saturn_exchange_adr_reg_word(1,C);break; + } + break; + case 4: + switch (READ_OP()) { + case 0: saturn_store_nibbles(A, BEGIN_A, COUNT_A, 0); break; + case 1: saturn_store_nibbles(A, BEGIN_A, COUNT_A, 1); break; + case 2: saturn_load_nibbles(A, BEGIN_A, COUNT_A, 0); break; + case 3: saturn_load_nibbles(A, BEGIN_A, COUNT_A, 1); break; + case 4: saturn_store_nibbles(C, BEGIN_A, COUNT_A, 0); break; + case 5: saturn_store_nibbles(C, BEGIN_A, COUNT_A, 1); break; + case 6: saturn_load_nibbles(C, BEGIN_A, COUNT_A, 0); break; + case 7: saturn_load_nibbles(C, BEGIN_A, COUNT_A, 1); break; + case 8: saturn_store_nibbles(A, BEGIN_B, COUNT_B, 0); break; + case 9: saturn_store_nibbles(A, BEGIN_B, COUNT_B, 1); break; + case 0xa: saturn_load_nibbles(A, BEGIN_B, COUNT_B, 0); break; + case 0xb: saturn_load_nibbles(A, BEGIN_B, COUNT_B, 1); break; + case 0xc: saturn_store_nibbles(C, BEGIN_B, COUNT_B, 0); break; + case 0xd: saturn_store_nibbles(C, BEGIN_B, COUNT_B, 1); break; + case 0xe: saturn_load_nibbles(C, BEGIN_B, COUNT_B, 0); break; + case 0xf: saturn_load_nibbles(C, BEGIN_B, COUNT_B, 1); break; + } + break; + case 5: + switch (oper=READ_OP()) { + case 0: case 1: case 4: case 5: + switch (adr=READ_OP()) { + case 0: + saturn_store_nibbles(oper&4?C:A,m_p,1,oper&1); + break; + case 1: + saturn_store_nibbles(oper&4?C:A,0,m_p+1,oper&1); + break; + case 2: case 3: case 4: case 5: case 6: case 7: + saturn_store_nibbles(oper&4?C:A,adr_a_begin[adr],adr_a_count[adr],oper&1); + break; + default: + saturn_invalid4(1, 5, oper, adr); + break; + } + break; + case 2: case 3: case 6: case 7: + switch (adr=READ_OP()) { + case 0: + saturn_load_nibbles(oper&4?C:A,m_p,1,oper&1); + break; + case 1: + saturn_load_nibbles(oper&4?C:A,0,m_p+1,oper&1); + break; + case 2: case 3: case 4: case 5: case 6: case 7: + saturn_load_nibbles(oper&4?C:A,adr_a_begin[adr],adr_a_count[adr],oper&1); + break; + default: + saturn_invalid4(1, 5, oper, adr); + break; + } + break; + case 8: saturn_store_nibbles(A, 0, READ_OP()+1, 0); break; + case 9: saturn_store_nibbles(A, 0, READ_OP()+1, 1); break; + case 0xa: saturn_load_nibbles(A, 0, READ_OP()+1, 0); break; + case 0xb: saturn_load_nibbles(A, 0, READ_OP()+1, 1); break; + case 0xc: saturn_store_nibbles(C, 0, READ_OP()+1, 0); break; + case 0xd: saturn_store_nibbles(C, 0, READ_OP()+1, 1); break; + case 0xe: saturn_load_nibbles(C, 0, READ_OP()+1, 0); break; + case 0xf: saturn_load_nibbles(C, 0, READ_OP()+1, 1); break; + } + break; + case 6: saturn_add_adr(0);break; + case 7: saturn_add_adr(1);break; + case 8: saturn_sub_adr(0);break; + case 9: saturn_load_adr(0,2);break; + case 0xa: saturn_load_adr(0,4);break; + case 0xb: saturn_load_adr(0,5);break; + case 0xc: saturn_sub_adr(1);break; + case 0xd: saturn_load_adr(1,2);break; + case 0xe: saturn_load_adr(1,4);break; + case 0xf: saturn_load_adr(1,5);break; + } +} + +void saturn_device::saturn_instruction_80() +{ + int op; + switch (READ_OP()) { + case 0: saturn_out_cs();break; + case 1: saturn_out_c();break; + case 2: saturn_in(A);break; + case 3: saturn_in(C);break; + case 4: saturn_mem_unconfig();break; + case 5: saturn_mem_config();break; + case 6: saturn_mem_id();break; + case 7: saturn_shutdown();break; + case 8: + switch (READ_OP()) { + case 0: saturn_interrupt_on();break; + case 1: + switch (op=READ_OP()) { + case 0: saturn_reset_interrupt();break; + default: saturn_invalid5(8, 0, 8, 1, op); break; + } + break; + case 2: saturn_load_reg(A);break; //la + case 3: saturn_bus_command_b();break; + case 4: saturn_clear_bit(A);break; // abit=0 + case 5: saturn_set_bit(A);break; // abit=1 + case 6: saturn_jump_bit_clear(A);break; + case 7: saturn_jump_bit_set(A);break; + case 8: saturn_clear_bit(C);break; // cbit=0 + case 9: saturn_set_bit(C);break; // cbit=1 + case 0xa: saturn_jump_bit_clear(C);break; + case 0xb: saturn_jump_bit_set(C);break; + case 0xc: saturn_indirect_jump(A);break; + case 0xd: saturn_bus_command_d();break; + case 0xe: saturn_indirect_jump(C);break; + case 0xf: saturn_interrupt_off();break; + } + break; + case 9: saturn_ca_p_1();break;//C+P+1 + case 0xa: saturn_mem_reset();break; + case 0xb: saturn_bus_command_b();break; + case 0xc: saturn_p_to_c();break; + case 0xd: saturn_c_to_p();break; + case 0xe: saturn_serial_request();break; + case 0xf: saturn_exchange_p();break; + } +} + +void saturn_device::saturn_instruction_81a() +{ + int reg, adr,op; + switch (adr=READ_OP()) { + case 0: + switch (op=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_copy(R0+reg,m_p,1,A); + break; //r0=a p + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_copy(R0+(reg&7),m_p,1,C); + break; //r0=c p + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_copy(A,m_p,1,R0+reg); + break; //a=r0 p + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_copy(C,m_p,1,R0+(reg&7)); + break; //c=r0 p + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + case 2: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_exchange(A, m_p,1,R0+reg); + break; // ar0ex p + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_exchange(C, m_p,1,R0+(reg&7)); + break; // cr0ex p + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + default: + saturn_invalid5(8, 1, 0xa, adr, op); + break; + } + break; + case 1: + switch (op=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_copy(R0+reg,0,m_p+1,A); + break; //r0=a wp + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_copy(R0+(reg&7),0,m_p+1,C); + break; //r0=c wp + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_copy(A,0,m_p+1,R0+reg); + break; //a=r0 wp + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_copy(C,0,m_p+1,R0+(reg&7)); + break; //c=r0 wp + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + case 2: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_exchange(A, 0, m_p+1, R0+reg); + break; // ar0ex wp + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_exchange(C, 0, m_p+1, R0+(reg&7)); + break; // cr0ex wp + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + default: + saturn_invalid5(8, 1, 0xa, adr, op); + break; + } + break; + case 2: case 3: case 4: case 5: case 6: case 7: case 0xf: + switch (op=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_copy(R0+reg,adr_af_begin[adr],adr_af_count[adr],A); + break; //r0=a xs + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_copy(R0+(reg&7),adr_af_begin[adr], adr_af_count[adr],C); + break; //r0=c xs + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_copy(A,adr_af_begin[adr],adr_af_count[adr],R0+reg); + break; //a=r0 xs + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_copy(C,adr_af_begin[adr],adr_af_count[adr],R0+(reg&7)); + break; //c=r0 xs + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + case 2: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: case 4: + saturn_exchange(A, adr_af_begin[adr], adr_af_count[adr], R0+reg); + break; // ar0ex xs + case 8: case 9: case 0xa: case 0xb: case 0xc: + saturn_exchange(C, adr_af_begin[adr], adr_af_count[adr], R0+(reg&7)); + break; // cr0ex xs + default: + saturn_invalid6(8, 1, 0xa, adr, op, reg); + break; + } + break; + default: + saturn_invalid5(8, 1, 0xa, adr, op); + break; + } + break; + default: + saturn_invalid4(8, 1, 0xa, adr); + break; + } +} + +void saturn_device::saturn_instruction_81() +{ + int reg, adr; + + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_rotate_nibble_left_w(A+reg); break; // aslc w + case 4: case 5: case 6: case 7: + saturn_rotate_nibble_right_w(A+(reg&3)); break; // asrc w + case 8: + switch (adr=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_add_const(A+reg, m_p, 1, READ_OP()+1); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_sub_const(A+(reg&3), m_p, 1, READ_OP()+1); + break; + default: + saturn_invalid5(8, 1, 8, adr, reg); + break; + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_add_const(A+reg, 0, m_p+1, READ_OP()+1); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_sub_const(A+(reg&3), 0, m_p+1, READ_OP()+1); + break; + default: + saturn_invalid5(8, 1, 8, adr, reg); + break; + } + break; + case 2: case 3: case 4: case 5: case 6: case 7: case 0xf: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_add_const(A+reg, adr_af_begin[adr], adr_af_count[adr], READ_OP()+1); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_sub_const(A+(reg&3), adr_af_begin[adr], adr_af_count[adr], READ_OP()+1); + break; + default: + saturn_invalid5(8, 1, 8, adr, reg); + break; + } + break; + default: + saturn_invalid4(8, 1, 8, adr); + break; + } + break; + case 9: + switch (adr=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_shift_right(A+reg,m_p,1); + break; // asrb p + default: + saturn_invalid5(8, 1, 9, adr, reg); + break; + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_shift_right(A+reg, 0,m_p+1); + break; // asrb wp + default: + saturn_invalid5(8, 1, 9, adr, reg); + break; + } + break; + case 2: case 3: case 4: case 5: case 6: case 7: case 0xf: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_shift_right(A+reg, adr_af_begin[adr], adr_af_count[adr]); + break; // asrb xs + default: + saturn_invalid5(8, 1, 9, adr, reg); + break; + } + break; + default: + saturn_invalid4(8, 1, 9, adr); + break; + } + break; + case 0xa: + saturn_instruction_81a(); + break; + case 0xb: + switch (adr=READ_OP()) { + case 2: saturn_load_pc(A);break; + case 3: saturn_load_pc(C);break; + case 4: saturn_store_pc(A);break; + case 5: saturn_store_pc(C);break; + case 6: saturn_exchange_pc(A);break; + case 7: saturn_exchange_pc(C);break; + default: saturn_invalid4(8, 1, reg, adr); break; + } + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_shift_right(A+(reg&3), BEGIN_W, COUNT_W); + break; // asrb w + } +} + +void saturn_device::saturn_instruction_8() +{ + int oper, adr; + + switch (READ_OP()) { + case 0: + saturn_instruction_80(); + break; + case 1: + saturn_instruction_81(); + break; + case 2: saturn_hst_clear_bits();break; + case 3: saturn_hst_bits_cleared();break; + case 4: saturn_st_clear_bit();break; + case 5: saturn_st_set_bit();break; + case 6: saturn_st_jump_bit_clear();break; + case 7: saturn_st_jump_bit_set();break; + case 8: saturn_p_not_equals(); break; + case 9: saturn_p_equals(); break; + case 0xa: + switch (oper=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_equals(reg_left[oper&3] , BEGIN_A, COUNT_A, reg_right[oper&3]); + break; + case 4: case 5: case 6: case 7: + saturn_not_equals(reg_left[oper&3] , BEGIN_A, COUNT_A, reg_right[oper&3]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_equals_zero(A+(oper&3), BEGIN_A, COUNT_A); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_not_equals_zero(A+(oper&3), BEGIN_A, COUNT_A); + break; + } + break; + case 0xb: + switch (oper=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_greater(reg_left[oper&3] , BEGIN_A, COUNT_A, reg_right[oper&3]); + break; + case 4: case 5: case 6: case 7: + saturn_smaller(reg_left[oper&3] , BEGIN_A, COUNT_A, reg_right[oper&3]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_greater_equals(reg_left[oper&3], BEGIN_A, COUNT_A, reg_right[oper&3]); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_smaller_equals(reg_left[oper&3], BEGIN_A, COUNT_A, reg_right[oper&3]); + break; + } + break; + case 0xc: + adr=READ_OP_DIS16(); + saturn_jump((adr+m_pc-4)&0xfffff,1); + break; + case 0xd: + adr=READ_OP_ARG20(); + saturn_jump(adr,1); + break; + case 0xe: + adr=READ_OP_DIS16(); + saturn_call((adr+m_pc)&0xfffff); + break; + case 0xf: + adr=READ_OP_ARG20(); + saturn_call(adr); + break; + } +} + +void saturn_device::saturn_instruction_9() +{ + int adr, oper; + + switch (adr=READ_OP()) { + case 0: + switch (oper=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_equals(reg_left[oper&3] , m_p, 1, reg_right[oper&3]); + break; + case 4: case 5: case 6: case 7: + saturn_not_equals(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_equals_zero(A+(oper&3), m_p, 1); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_not_equals_zero(A+(oper&3), m_p, 1); + break; + } + break; + case 1: + switch (oper=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_equals(reg_left[oper&3] , 0, m_p+1, reg_right[oper&3]); + break; + case 4: case 5: case 6: case 7: + saturn_not_equals(reg_left[oper&3] , 0, m_p+1, reg_right[oper&3]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_equals_zero(A+(oper&3), 0, m_p+1); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_not_equals_zero(A+(oper&3), 0, m_p+1); + break; + } + break; + case 2: case 3: case 4: case 5: case 6: case 7: + switch (oper=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_equals(reg_left[oper&3] ,adr_a_begin[adr], adr_a_count[adr], reg_right[oper&3]); + break; + case 4: case 5: case 6: case 7: + saturn_not_equals(reg_left[oper&3] ,adr_a_begin[adr], adr_a_count[adr], reg_right[oper&3]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_equals_zero(A+(oper&3),adr_a_begin[adr], adr_a_count[adr]); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_not_equals_zero(A+(oper&3) ,adr_a_begin[adr], adr_a_count[adr]); + break; + } + break; + case 8: + switch (oper=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_greater(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); + break; + case 4: case 5: case 6: case 7: + saturn_smaller(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_greater_equals(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_smaller_equals(reg_left[oper&3] ,m_p, 1, reg_right[oper&3]); + break; + } + break; + case 9: + switch (oper=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_greater(reg_left[oper&3] , 0, m_p+1, reg_right[oper&3]); + break; + case 4: case 5: case 6: case 7: + saturn_smaller(reg_left[oper&3] , 0, m_p+1, reg_right[oper&3]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_greater_equals(reg_left[oper&3], 0, m_p+1, reg_right[oper&3]); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_smaller_equals(reg_left[oper&3], 0, m_p+1, reg_right[oper&3]); + break; + } + break; + case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: + switch (oper=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_greater(reg_left[oper&3] ,adr_b_begin[adr], adr_b_count[adr], reg_right[oper&3]); + break; + case 4: case 5: case 6: case 7: + saturn_smaller(reg_left[oper&3] ,adr_b_begin[adr], adr_b_count[adr], reg_right[oper&3]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_greater_equals(reg_left[oper&3] ,adr_b_begin[adr], adr_b_count[adr], reg_right[oper&3]); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_smaller_equals(reg_left[oper&3] ,adr_b_begin[adr], adr_b_count[adr], reg_right[oper&3]); + break; + } + break; + } +} + +void saturn_device::saturn_instruction_a() +{ + int reg, adr; + + switch (adr=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + case 8: case 9: case 0xa: case 0xb: + saturn_add(add_left[reg], m_p, 1, add_right[reg]); + break; + case 4: case 5: case 6: case 7: + saturn_add(A+(reg&3), m_p, 1, A+(reg&3)); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_decrement(A+(reg&3), m_p, 1); + break; + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + case 8: case 9: case 0xa: case 0xb: + saturn_add(add_left[reg], 0, m_p+1, add_right[reg]); + break; + case 4: case 5: case 6: case 7: + saturn_add(A+(reg&3), 0, m_p+1, A+(reg&3)); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_decrement(A+(reg&3), 0, m_p+1); + break; + } + break; + case 2: case 3: case 4: case 5: case 6: case 7: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + case 8: case 9: case 0xa: case 0xb: + saturn_add(add_left[reg], adr_a_begin[adr], adr_a_count[adr], add_right[reg]); + break; + case 4: case 5: case 6: case 7: + saturn_add(A+(reg&3), adr_a_begin[adr], adr_a_count[adr], A+(reg&3)); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_decrement(A+(reg&3), adr_a_begin[adr], adr_a_count[adr]); + break; + } + break; + case 8: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_clear(A+reg, m_p,1); + break; // a=0 p + case 4: case 5: case 6: case 7: + case 8: case 9: case 0xa: case 0xb: + saturn_copy(reg_right[reg&7], m_p,1,reg_left[reg&7]); + break; // a=b p + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_exchange(reg_left[reg&3], m_p,1,reg_right[reg&3]); + break; // abex p + } + break; + case 9: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_clear(A+reg,0,m_p+1); + break; // a=0 wp + case 4: case 5: case 6: case 7: + case 8: case 9: case 0xa: case 0xb: + saturn_copy(reg_right[reg&7], 0, m_p+1, reg_left[reg&7]); + break; // a=b wp + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_exchange(reg_left[reg&3], 0, m_p+1, reg_right[reg&3]); + break; // abex wp + } + break; + case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_clear(A+reg, adr_b_begin[adr], adr_b_count[adr]); + break; // a=0 xs + case 4: case 5: case 6: case 7: + case 8: case 9: case 0xa: case 0xb: + saturn_copy(reg_right[reg&7], adr_b_begin[adr], adr_b_count[adr], reg_left[reg&7]); + break; // a=b xs + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_exchange(reg_left[reg&3], adr_b_begin[adr], adr_b_count[adr], reg_right[reg&3]); + break; // abex xs + } + break; + } +} + +void saturn_device::saturn_instruction_b() +{ + int adr, reg; + + switch (adr=READ_OP()) { + case 0: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + case 8: case 9: case 0xa: case 0xb: + saturn_sub(sub_left[reg], m_p, 1, sub_right[reg]); + break; + case 4: case 5: case 6: case 7: + saturn_increment(A+(reg&3), m_p, 1); break; // a=a+1 p + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_sub2(sub_left[reg], m_p, 1, sub_right[reg]); + break; + } + break; + case 1: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + case 8: case 9: case 0xa: case 0xb: + saturn_sub(sub_left[reg], 0, m_p+1, sub_right[reg]); + break; + case 4: case 5: case 6: case 7: + saturn_increment(A+(reg&3), 0, m_p+1); break; // a=a+1 wp + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_sub2(sub_left[reg], 0, m_p+1, sub_right[reg]); + break; + } + break; + case 2: case 3: case 4: case 5: case 6: case 7: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + case 8: case 9: case 0xa: case 0xb: + saturn_sub(sub_left[reg], adr_a_begin[adr], adr_a_count[adr], sub_right[reg]); + break; + case 4: case 5: case 6: case 7: + saturn_increment(A+(reg&3), adr_a_begin[adr], adr_a_count[adr]); + break; // a=a+1 xs + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_sub2(sub_left[reg], adr_a_begin[adr], adr_a_count[adr], + sub_right[reg]); + break; + } + break; + case 8: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_shift_nibble_left(A+reg, m_p, 1); break; // asl p + case 4: case 5: case 6: case 7: + saturn_shift_nibble_right(A+(reg&3), m_p, 1); break; // asr p + case 8: case 9: case 0xa: case 0xb: + saturn_negate(A+(reg&3), m_p, 1); break; // A=-A p + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_invert(A+(reg&3), m_p, 1); break; // A=-A-1 p + } + break; + case 9: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_shift_nibble_left(A+reg,0,m_p+1); break; // asl wp + case 4: case 5: case 6: case 7: + saturn_shift_nibble_right(A+(reg&3),0,m_p+1); break; // asr wp + case 8: case 9: case 0xa: case 0xb: + saturn_negate(A+(reg&3),0,m_p+1); break; // A=-A wp + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_invert(A+(reg&3),0,m_p+1); break; // A=-A-1 wp + } + break; + case 0xa: case 0xb: case 0xc: case 0xd: case 0xe: case 0xf: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_shift_nibble_left(A+reg,adr_b_begin[adr], adr_b_count[adr]); + break; + case 4: case 5: case 6: case 7: + saturn_shift_nibble_right(A+(reg&3), adr_b_begin[adr], adr_b_count[adr]); + break; + case 8: case 9: case 0xa: case 0xb: + saturn_negate(A+(reg&3), adr_b_begin[adr], adr_b_count[adr]); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_invert(A+(reg&3), adr_b_begin[adr], adr_b_count[adr]); + break; + } + break; + } +} + + +void saturn_device::saturn_instruction() +{ + int reg, adr; + + switch (READ_OP()) { + case 0: + switch (READ_OP()) { + 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; + case 0xd: saturn_dec_p();break; + case 0xe: saturn_instruction_0e();break; + case 0xf: saturn_return_interrupt();break; + } + break; + case 1: + saturn_instruction_1(); + break; + case 2: + saturn_load_p(); + break; + case 3: + saturn_load_reg(C); + break; // lc + case 4: + adr=READ_OP_DIS8(); + if (adr==0) { + saturn_return(m_carry); + } + else { + saturn_jump((m_pc+adr-2)&0xfffff, m_carry); + } + break; + case 5: + adr=READ_OP_DIS8(); + if (adr==0) { + saturn_return(!m_carry); + } + else { + saturn_jump((m_pc+adr-2)&0xfffff,!m_carry); + } + break; + case 6: + adr=READ_OP_DIS12(); + saturn_jump((m_pc+adr-3)&0xfffff,1); break; + case 7: + adr=READ_OP_DIS12(); + saturn_call((adr+m_pc)&0xfffff); break; + case 8: + saturn_instruction_8(); + break; + case 9: + saturn_instruction_9(); + break; + case 0xa: + saturn_instruction_a(); + break; + case 0xb: + saturn_instruction_b(); + break; + case 0xc: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + case 8: case 9: case 0xa: case 0xb: + saturn_add(add_left[reg], BEGIN_A, COUNT_A, add_right[reg]); + break; + case 4: case 5: case 6: case 7: + saturn_add(A+(reg&3), BEGIN_A, COUNT_A, A+(reg&3)); + break; + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_decrement(A+(reg&3), BEGIN_A, COUNT_A); + break; + } + break; + case 0xd: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_clear(A+reg, BEGIN_A, COUNT_A); + break; // a=0 a + case 4: case 5: case 6: case 7: + case 8: case 9: case 0xa: case 0xb: + saturn_copy(reg_right[reg&7], BEGIN_A, COUNT_A, reg_left[reg&7]); + break; // a=b a + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_exchange(reg_left[reg&3], BEGIN_A, COUNT_A, reg_right[reg&3]); + break; // abex a + } + break; + case 0xe: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + case 8: case 9: case 0xa: case 0xb: + saturn_sub(sub_left[reg], BEGIN_A, COUNT_A, sub_right[reg]); + break; + case 4: case 5: case 6: case 7: + saturn_increment(A+(reg&3), BEGIN_A, COUNT_A); + break; // a=a+1 a + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_sub2(sub_left[reg], BEGIN_A, COUNT_A, sub_right[reg]); + break; + } + break; + case 0xf: + switch (reg=READ_OP()) { + case 0: case 1: case 2: case 3: + saturn_shift_nibble_left(A+reg,BEGIN_A, COUNT_A); + break; // asl a + case 4: case 5: case 6: case 7: + saturn_shift_nibble_right(A+(reg&3),BEGIN_A, COUNT_A); + break; // asr a + case 8: case 9: case 0xa: case 0xb: + saturn_negate(A+(reg&3),BEGIN_A, COUNT_A); + break; // A=-A a + case 0xc: case 0xd: case 0xe: case 0xf: + saturn_invert(A+(reg&3),BEGIN_A, COUNT_A); + break; // A=-A-1 a + } + break; + } +} diff --git a/src/devices/cpu/saturn/saturn.cpp b/src/devices/cpu/saturn/saturn.cpp index 14b05baf3dd..004c0c09994 100644 --- a/src/devices/cpu/saturn/saturn.cpp +++ b/src/devices/cpu/saturn/saturn.cpp @@ -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 saturn_device::create_disassembler() * include the opcode macros, functions and tables ***************************************************************/ -#include "satops.hxx" -#include "sattable.hxx" +#include "satops.ipp" +#include "sattable.ipp" /***************************************************************************** * diff --git a/src/devices/cpu/saturn/saturn.h b/src/devices/cpu/saturn/saturn.h index a476d6ce677..bb520181450 100644 --- a/src/devices/cpu/saturn/saturn.h +++ b/src/devices/cpu/saturn/saturn.h @@ -114,8 +114,8 @@ private: devcb_write32 m_crc_func; devcb_write_line m_rsi_func; -// 64 bit, unpacked (one nibble per byte) -typedef uint8_t Saturn64[16]; + // 64 bit, unpacked (one nibble per byte) + typedef uint8_t Saturn64[16]; Saturn64 m_reg[9]; //r0,r1,r2,r3,r4,a,b,c,d @@ -146,126 +146,126 @@ 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); - 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 ); - void saturn_invalid6( int op1, int op2, int op3, int op4, int op5, int op6 ); + 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); + void saturn_invalid6(int op1, int op2, int op3, int op4, int op5, int op6); void saturn_instruction_0e(); void saturn_instruction_1(); void saturn_instruction_80(); -- cgit v1.2.3