diff --git a/src/emu/cpu/v60/am.c b/src/emu/cpu/v60/am.c index f237844f8e6..3bac1990374 100644 --- a/src/emu/cpu/v60/am.c +++ b/src/emu/cpu/v60/am.c @@ -1,7 +1,7 @@ // NOTE for bit string / field addressing // ************************************ -// cpustate->moddim must be passed as 10 for bit string instructions, +// m_moddim must be passed as 10 for bit string instructions, // and as 11 for bit field instructions @@ -14,69 +14,69 @@ /* Input: - cpustate->modadd - cpustate->moddim + m_modadd + m_moddim Output: - cpustate->amout + m_amout amLength */ -static UINT32 ReadAM(v60_state *cpustate) +UINT32 v60_device::ReadAM() { - cpustate->modm = cpustate->modm?1:0; - cpustate->modval = OpRead8(cpustate, cpustate->modadd); - return AMTable1[cpustate->modm][cpustate->modval >> 5](cpustate); + m_modm = m_modm?1:0; + m_modval = OpRead8(m_modadd); + return (this->*s_AMTable1[m_modm][m_modval >> 5])(); } -static UINT32 BitReadAM(v60_state *cpustate) +UINT32 v60_device::BitReadAM() { - cpustate->modm = cpustate->modm?1:0; - cpustate->modval = OpRead8(cpustate, cpustate->modadd); - return BAMTable1[cpustate->modm][cpustate->modval >> 5](cpustate); + m_modm = m_modm?1:0; + m_modval = OpRead8(m_modadd); + return (this->*s_BAMTable1[m_modm][m_modval >> 5])(); } /* Input: - cpustate->modadd - cpustate->moddim + m_modadd + m_moddim Output: - cpustate->amout - cpustate->amflag + m_amout + m_amflag amLength */ -static UINT32 ReadAMAddress(v60_state *cpustate) +UINT32 v60_device::ReadAMAddress() { - cpustate->modm = cpustate->modm?1:0; - cpustate->modval = OpRead8(cpustate, cpustate->modadd); - return AMTable2[cpustate->modm][cpustate->modval >> 5](cpustate); + m_modm = m_modm?1:0; + m_modval = OpRead8(m_modadd); + return (this->*s_AMTable2[m_modm][m_modval >> 5])(); } -static UINT32 BitReadAMAddress(v60_state *cpustate) +UINT32 v60_device::BitReadAMAddress() { - cpustate->modm = cpustate->modm?1:0; - cpustate->modval = OpRead8(cpustate, cpustate->modadd); - return BAMTable2[cpustate->modm][cpustate->modval >> 5](cpustate); + m_modm = m_modm?1:0; + m_modval = OpRead8(m_modadd); + return (this->*s_BAMTable2[m_modm][m_modval >> 5])(); } /* Input: - cpustate->modadd - cpustate->moddim - cpustate->modwritevalb / H/W + m_modadd + m_moddim + m_modwritevalb / H/W Output: - cpustate->amout + m_amout amLength */ -static UINT32 WriteAM(v60_state *cpustate) +UINT32 v60_device::WriteAM() { - cpustate->modm = cpustate->modm?1:0; - cpustate->modval = OpRead8(cpustate, cpustate->modadd); - return AMTable3[cpustate->modm][cpustate->modval >> 5](cpustate); + m_modm = m_modm?1:0; + m_modval = OpRead8(m_modadd); + return (this->*s_AMTable3[m_modm][m_modval >> 5])(); } diff --git a/src/emu/cpu/v60/am1.c b/src/emu/cpu/v60/am1.c index 6969b46820f..180551c1f1e 100644 --- a/src/emu/cpu/v60/am1.c +++ b/src/emu/cpu/v60/am1.c @@ -2,107 +2,107 @@ // AM1 Functions (for ReadAM) // ************************** -static UINT32 am1Register(v60_state *cpustate) +UINT32 v60_device::am1Register() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = (UINT8)cpustate->reg[cpustate->modval & 0x1F]; + m_amout = (UINT8)m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = (UINT16)cpustate->reg[cpustate->modval & 0x1F]; + m_amout = (UINT16)m_reg[m_modval & 0x1F]; break; case 2: - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_reg[m_modval & 0x1F]; break; } return 1; } -static UINT32 am1RegisterIndirect(v60_state *cpustate) +UINT32 v60_device::am1RegisterIndirect() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_word_unaligned(m_reg[m_modval & 0x1F]); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F]); break; } return 1; } -static UINT32 bam1RegisterIndirect(v60_state *cpustate) +UINT32 v60_device::bam1RegisterIndirect() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F]); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F]); return 1; } -static UINT32 am1RegisterIndirectIndexed(v60_state *cpustate) +UINT32 v60_device::am1RegisterIndirectIndexed() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F] * 4); break; } return 2; } -static UINT32 bam1RegisterIndirectIndexed(v60_state *cpustate) +UINT32 v60_device::bam1RegisterIndirectIndexed() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + m_bamoffset / 8); + m_bamoffset&=7; return 2; } -static UINT32 am1Autoincrement(v60_state *cpustate) +UINT32 v60_device::am1Autoincrement() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval & 0x1F]); - cpustate->reg[cpustate->modval & 0x1F]++; + m_amout = m_program->read_byte(m_reg[m_modval & 0x1F]); + m_reg[m_modval & 0x1F]++; break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval & 0x1F]); - cpustate->reg[cpustate->modval & 0x1F] +=2; + m_amout = m_program->read_word_unaligned(m_reg[m_modval & 0x1F]); + m_reg[m_modval & 0x1F] +=2; break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F]); - cpustate->reg[cpustate->modval & 0x1F] +=4; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F]); + m_reg[m_modval & 0x1F] +=4; break; } return 1; } -static UINT32 bam1Autoincrement(v60_state *cpustate) +UINT32 v60_device::bam1Autoincrement() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F]); - switch (cpustate->moddim) + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F]); + switch (m_moddim) { case 10: - cpustate->reg[cpustate->modval & 0x1F] +=1; + m_reg[m_modval & 0x1F] +=1; break; case 11: - cpustate->reg[cpustate->modval & 0x1F] +=4; + m_reg[m_modval & 0x1F] +=4; break; default: fatalerror("CPU - BAM1 - 7\n"); @@ -111,960 +111,960 @@ static UINT32 bam1Autoincrement(v60_state *cpustate) return 1; } -static UINT32 am1Autodecrement(v60_state *cpustate) +UINT32 v60_device::am1Autodecrement() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->reg[cpustate->modval & 0x1F]--; - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval & 0x1F]); + m_reg[m_modval & 0x1F]--; + m_amout = m_program->read_byte(m_reg[m_modval & 0x1F]); break; case 1: - cpustate->reg[cpustate->modval & 0x1F]-=2; - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval & 0x1F]); + m_reg[m_modval & 0x1F]-=2; + m_amout = m_program->read_word_unaligned(m_reg[m_modval & 0x1F]); break; case 2: - cpustate->reg[cpustate->modval & 0x1F]-=4; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F]); + m_reg[m_modval & 0x1F]-=4; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F]); break; } return 1; } -static UINT32 bam1Autodecrement(v60_state *cpustate) +UINT32 v60_device::bam1Autodecrement() { - cpustate->bamoffset = 0; - switch (cpustate->moddim) + m_bamoffset = 0; + switch (m_moddim) { case 10: - cpustate->reg[cpustate->modval & 0x1F]-=1; + m_reg[m_modval & 0x1F]-=1; break; case 11: - cpustate->reg[cpustate->modval & 0x1F]-=4; + m_reg[m_modval & 0x1F]-=4; break; default: fatalerror("CPU - BAM1 - 7\n"); break; } - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F]); return 1; } -static UINT32 am1Displacement8(v60_state *cpustate) +UINT32 v60_device::am1Displacement8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_byte(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_word_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)); break; } return 2; } -static UINT32 bam1Displacement8(v60_state *cpustate) +UINT32 v60_device::bam1Displacement8() { - cpustate->bamoffset = cpustate->program->read_byte(cpustate->modadd + 1); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_program->read_byte(m_modadd + 1); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + m_bamoffset / 8); + m_bamoffset&=7; return 2; } -static UINT32 am1Displacement16(v60_state *cpustate) +UINT32 v60_device::am1Displacement16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_byte(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_word_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)); break; } return 3; } -static UINT32 bam1Displacement16(v60_state *cpustate) +UINT32 v60_device::bam1Displacement16() { - cpustate->bamoffset = OpRead16(cpustate, cpustate->modadd + 1); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead16(m_modadd + 1); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + m_bamoffset / 8); + m_bamoffset&=7; return 3; } -static UINT32 am1Displacement32(v60_state *cpustate) +UINT32 v60_device::am1Displacement32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_byte(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_word_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)); break; } return 5; } -static UINT32 bam1Displacement32(v60_state *cpustate) +UINT32 v60_device::bam1Displacement32() { - cpustate->bamoffset = OpRead32(cpustate, cpustate->modadd + 1); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead32(m_modadd + 1); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + m_bamoffset / 8); + m_bamoffset&=7; return 5; } -static UINT32 am1DisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndexed8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4); break; } return 3; } -static UINT32 bam1DisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndexed8() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_bamoffset / 8); + m_bamoffset&=7; return 3; } -static UINT32 am1DisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndexed16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4); break; } return 4; } -static UINT32 bam1DisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndexed16() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_bamoffset / 8); + m_bamoffset&=7; return 4; } -static UINT32 am1DisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndexed32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4); break; } return 6; } -static UINT32 bam1DisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndexed32() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_bamoffset / 8); + m_bamoffset&=7; return 6; } -static UINT32 am1PCDisplacement8(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacement8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_byte(PC + (INT8)OpRead8(m_modadd + 1)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_word_unaligned(PC + (INT8)OpRead8(m_modadd + 1)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)); break; } return 2; } -static UINT32 bam1PCDisplacement8(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacement8() { - cpustate->bamoffset = OpRead8(cpustate, cpustate->modadd + 1); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead8(m_modadd + 1); + m_amout = m_program->read_dword_unaligned(PC + m_bamoffset / 8); + m_bamoffset&=7; return 2; } -static UINT32 am1PCDisplacement16(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacement16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_byte(PC + (INT16)OpRead16(m_modadd + 1)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_word_unaligned(PC + (INT16)OpRead16(m_modadd + 1)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)); break; } return 3; } -static UINT32 bam1PCDisplacement16(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacement16() { - cpustate->bamoffset = OpRead16(cpustate, cpustate->modadd + 1); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead16(m_modadd + 1); + m_amout = m_program->read_dword_unaligned(PC + m_bamoffset / 8); + m_bamoffset&=7; return 3; } -static UINT32 am1PCDisplacement32(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacement32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_byte(PC + OpRead32(m_modadd + 1)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_word_unaligned(PC + OpRead32(m_modadd + 1)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)); break; } return 5; } -static UINT32 bam1PCDisplacement32(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacement32() { - cpustate->bamoffset = OpRead32(cpustate, cpustate->modadd + 1); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead32(m_modadd + 1); + m_amout = m_program->read_dword_unaligned(PC + m_bamoffset / 8); + m_bamoffset&=7; return 5; } -static UINT32 am1PCDisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndexed8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4); break; } return 3; } -static UINT32 bam1PCDisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndexed8() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2) + m_bamoffset / 8); + m_bamoffset&=7; return 3; } -static UINT32 am1PCDisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndexed16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4); break; } return 4; } -static UINT32 bam1PCDisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndexed16() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2) + m_bamoffset / 8); + m_bamoffset&=7; return 4; } -static UINT32 am1PCDisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndexed32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4); break; } return 6; } -static UINT32 bam1PCDisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndexed32() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2) + m_bamoffset / 8); + m_bamoffset&=7; return 6; } -static UINT32 am1DisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndirect8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1))); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1))); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1))); break; } return 2; } -static UINT32 bam1DisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndirect8() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1))); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1))); return 2; } -static UINT32 am1DisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndirect16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1))); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1))); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1))); break; } return 3; } -static UINT32 bam1DisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndirect16() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1))); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1))); return 3; } -static UINT32 am1DisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndirect32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1))); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1))); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1))); break; } return 5; } -static UINT32 bam1DisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndirect32() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1))); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1))); return 5; } -static UINT32 am1DisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndirectIndexed8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4); break; } return 3; } -static UINT32 bam1DisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndirectIndexed8() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_bamoffset / 8); + m_bamoffset&=7; return 3; } -static UINT32 am1DisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndirectIndexed16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4); break; } return 4; } -static UINT32 bam1DisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndirectIndexed16() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_bamoffset / 8); + m_bamoffset&=7; return 4; } -static UINT32 am1DisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::am1DisplacementIndirectIndexed32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4); break; } return 6; } -static UINT32 bam1DisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::bam1DisplacementIndirectIndexed32() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_bamoffset / 8); + m_bamoffset&=7; return 6; } -static UINT32 am1PCDisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndirect8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1))); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1))); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1))); break; } return 2; } -static UINT32 bam1PCDisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndirect8() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1))); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1))); return 2; } -static UINT32 am1PCDisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndirect16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1))); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1))); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1))); break; } return 3; } -static UINT32 bam1PCDisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndirect16() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1))); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1))); return 3; } -static UINT32 am1PCDisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndirect32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1))); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1))); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1))); break; } return 5; } -static UINT32 bam1PCDisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndirect32() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1))); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1))); return 5; } -static UINT32 am1PCDisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndirectIndexed8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4); break; } return 3; } -static UINT32 bam1PCDisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndirectIndexed8() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_bamoffset / 8); + m_bamoffset&=7; return 3; } -static UINT32 am1PCDisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndirectIndexed16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4); break; } return 4; } -static UINT32 bam1PCDisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndirectIndexed16() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_bamoffset / 8); + m_bamoffset&=7; return 4; } -static UINT32 am1PCDisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::am1PCDisplacementIndirectIndexed32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4); break; } return 6; } -static UINT32 bam1PCDisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::bam1PCDisplacementIndirectIndexed32() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_bamoffset / 8); + m_bamoffset&=7; return 6; } -static UINT32 am1DoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::am1DoubleDisplacement8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2)); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2)); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2)); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2)); break; } return 3; } -static UINT32 bam1DoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::bam1DoubleDisplacement8() { - cpustate->bamoffset = OpRead8(cpustate, cpustate->modadd + 2); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead8(m_modadd + 2); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)) + m_bamoffset / 8); + m_bamoffset&=7; return 3; } -static UINT32 am1DoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::am1DoubleDisplacement16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3)); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3)); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3)); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3)); break; } return 5; } -static UINT32 bam1DoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::bam1DoubleDisplacement16() { - cpustate->bamoffset = OpRead16(cpustate, cpustate->modadd + 3); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead16(m_modadd + 3); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)) + m_bamoffset / 8); + m_bamoffset&=7; return 5; } -static UINT32 am1DoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::am1DoubleDisplacement32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5)); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5)); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5)); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5)); break; } return 9; } -static UINT32 bam1DoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::bam1DoubleDisplacement32() { - cpustate->bamoffset = OpRead32(cpustate, cpustate->modadd + 5); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead32(m_modadd + 5); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)) + m_bamoffset / 8); + m_bamoffset&=7; return 9; } -static UINT32 am1PCDoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::am1PCDoubleDisplacement8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2)); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2)); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2)); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2)); break; } return 3; } -static UINT32 bam1PCDoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::bam1PCDoubleDisplacement8() { - cpustate->bamoffset = OpRead8(cpustate, cpustate->modadd + 2); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead8(m_modadd + 2); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)) + m_bamoffset / 8); + m_bamoffset&=7; return 3; } -static UINT32 am1PCDoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::am1PCDoubleDisplacement16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3)); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3)); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3)); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3)); break; } return 5; } -static UINT32 bam1PCDoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::bam1PCDoubleDisplacement16() { - cpustate->bamoffset = OpRead16(cpustate, cpustate->modadd + 3); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead16(m_modadd + 3); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)) + m_bamoffset / 8); + m_bamoffset&=7; return 5; } -static UINT32 am1PCDoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::am1PCDoubleDisplacement32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5)); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5)); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5)); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5)); break; } return 9; } -static UINT32 bam1PCDoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::bam1PCDoubleDisplacement32() { - cpustate->bamoffset = OpRead32(cpustate, cpustate->modadd + 5); - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = OpRead32(m_modadd + 5); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)) + m_bamoffset / 8); + m_bamoffset&=7; return 9; } -static UINT32 am1DirectAddress(v60_state *cpustate) +UINT32 v60_device::am1DirectAddress() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_byte(OpRead32(m_modadd + 1)); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_word_unaligned(OpRead32(m_modadd + 1)); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1)); + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 1)); break; } return 5; } -static UINT32 bam1DirectAddress(v60_state *cpustate) +UINT32 v60_device::bam1DirectAddress() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1)); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 1)); return 5; } -static UINT32 am1DirectAddressIndexed(v60_state *cpustate) +UINT32 v60_device::am1DirectAddressIndexed() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4); break; } return 6; } -static UINT32 bam1DirectAddressIndexed(v60_state *cpustate) +UINT32 v60_device::bam1DirectAddressIndexed() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 2) + m_bamoffset / 8); + m_bamoffset&=7; return 6; } -static UINT32 am1DirectAddressDeferred(v60_state *cpustate) +UINT32 v60_device::am1DirectAddressDeferred() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(OpRead32(m_modadd + 1))); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 1))); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1))); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 1))); break; } return 5; } -static UINT32 bam1DirectAddressDeferred(v60_state *cpustate) +UINT32 v60_device::bam1DirectAddressDeferred() { - cpustate->bamoffset = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1))); + m_bamoffset = 0; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 1))); return 5; } -static UINT32 am1DirectAddressDeferredIndexed(v60_state *cpustate) +UINT32 v60_device::am1DirectAddressDeferredIndexed() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_byte(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]); + m_amout = m_program->read_byte(m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F]); break; case 1: - cpustate->amout = cpustate->program->read_word_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2); + m_amout = m_program->read_word_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2); break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4); + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4); break; } return 6; } -static UINT32 bam1DirectAddressDeferredIndexed(v60_state *cpustate) +UINT32 v60_device::bam1DirectAddressDeferredIndexed() { - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->bamoffset / 8); - cpustate->bamoffset&=7; + m_bamoffset = m_reg[m_modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_bamoffset / 8); + m_bamoffset&=7; return 6; } -static UINT32 am1Immediate(v60_state *cpustate) +UINT32 v60_device::am1Immediate() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = OpRead8(cpustate, cpustate->modadd + 1); + m_amout = OpRead8(m_modadd + 1); return 2; case 1: - cpustate->amout = OpRead16(cpustate, cpustate->modadd + 1); + m_amout = OpRead16(m_modadd + 1); return 3; case 2: - cpustate->amout = OpRead32(cpustate, cpustate->modadd + 1); + m_amout = OpRead32(m_modadd + 1); return 5; } @@ -1073,9 +1073,9 @@ static UINT32 am1Immediate(v60_state *cpustate) return 1; } -static UINT32 am1ImmediateQuick(v60_state *cpustate) +UINT32 v60_device::am1ImmediateQuick() { - cpustate->amout = cpustate->modval & 0xF; + m_amout = m_modval & 0xF; return 1; } @@ -1085,300 +1085,300 @@ static UINT32 am1ImmediateQuick(v60_state *cpustate) // AM1 Tables (for ReadAM) // *********************** -static UINT32 am1Error1(v60_state *cpustate) +UINT32 v60_device::am1Error1() { - fatalerror("CPU - AM1 - 1 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM1 - 1 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam1Error1(v60_state *cpustate) +UINT32 v60_device::bam1Error1() { - fatalerror("CPU - BAM1 - 1 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM1 - 1 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 am1Error2(v60_state *cpustate) +UINT32 v60_device::am1Error2() { - fatalerror("CPU - AM1 - 2 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM1 - 2 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam1Error2(v60_state *cpustate) +UINT32 v60_device::bam1Error2() { - fatalerror("CPU - BAM1 - 2 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM1 - 2 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } #ifdef UNUSED_FUNCTION -static UINT32 am1Error3(v60_state *cpustate) +UINT32 v60_device::am1Error3() { - fatalerror("CPU - AM1 - 3 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM1 - 3 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam1Error3(v60_state *cpustate) +UINT32 v60_device::bam1Error3() { - fatalerror("CPU - BAM1 - 3 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM1 - 3 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } #endif -static UINT32 am1Error4(v60_state *cpustate) +UINT32 v60_device::am1Error4() { - fatalerror("CPU - AM1 - 4 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM1 - 4 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam1Error4(v60_state *cpustate) +UINT32 v60_device::bam1Error4() { - fatalerror("CPU - BAM1 - 4 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM1 - 4 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 am1Error5(v60_state *cpustate) +UINT32 v60_device::am1Error5() { - fatalerror("CPU - AM1 - 5 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM1 - 5 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam1Error5(v60_state *cpustate) +UINT32 v60_device::bam1Error5() { - fatalerror("CPU - BAM1 - 5 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM1 - 5 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam1Error6(v60_state *cpustate) +UINT32 v60_device::bam1Error6() { - fatalerror("CPU - BAM1 - 6 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM1 - 6 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 (*const AMTable1_G7a[16])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable1_G7a[16] = { - am1PCDisplacementIndexed8, - am1PCDisplacementIndexed16, - am1PCDisplacementIndexed32, - am1DirectAddressIndexed, - am1Error5, - am1Error5, - am1Error5, - am1Error5, - am1PCDisplacementIndirectIndexed8, - am1PCDisplacementIndirectIndexed16, - am1PCDisplacementIndirectIndexed32, - am1DirectAddressDeferredIndexed, - am1Error5, - am1Error5, - am1Error5, - am1Error5 + &v60_device::am1PCDisplacementIndexed8, + &v60_device::am1PCDisplacementIndexed16, + &v60_device::am1PCDisplacementIndexed32, + &v60_device::am1DirectAddressIndexed, + &v60_device::am1Error5, + &v60_device::am1Error5, + &v60_device::am1Error5, + &v60_device::am1Error5, + &v60_device::am1PCDisplacementIndirectIndexed8, + &v60_device::am1PCDisplacementIndirectIndexed16, + &v60_device::am1PCDisplacementIndirectIndexed32, + &v60_device::am1DirectAddressDeferredIndexed, + &v60_device::am1Error5, + &v60_device::am1Error5, + &v60_device::am1Error5, + &v60_device::am1Error5 }; -static UINT32 (*const BAMTable1_G7a[16])(v60_state *) = +const v60_device::am_func v60_device::s_BAMTable1_G7a[16] = { - bam1PCDisplacementIndexed8, - bam1PCDisplacementIndexed16, - bam1PCDisplacementIndexed32, - bam1DirectAddressIndexed, - bam1Error5, - bam1Error5, - bam1Error5, - bam1Error5, - bam1PCDisplacementIndirectIndexed8, - bam1PCDisplacementIndirectIndexed16, - bam1PCDisplacementIndirectIndexed32, - bam1DirectAddressDeferredIndexed, - bam1Error5, - bam1Error5, - bam1Error5, - bam1Error5 + &v60_device::bam1PCDisplacementIndexed8, + &v60_device::bam1PCDisplacementIndexed16, + &v60_device::bam1PCDisplacementIndexed32, + &v60_device::bam1DirectAddressIndexed, + &v60_device::bam1Error5, + &v60_device::bam1Error5, + &v60_device::bam1Error5, + &v60_device::bam1Error5, + &v60_device::bam1PCDisplacementIndirectIndexed8, + &v60_device::bam1PCDisplacementIndirectIndexed16, + &v60_device::bam1PCDisplacementIndirectIndexed32, + &v60_device::bam1DirectAddressDeferredIndexed, + &v60_device::bam1Error5, + &v60_device::bam1Error5, + &v60_device::bam1Error5, + &v60_device::bam1Error5 }; -static UINT32 am1Group7a(v60_state *cpustate) +UINT32 v60_device::am1Group7a() { - if (!(cpustate->modval2 & 0x10)) - return am1Error4(cpustate); + if (!(m_modval2 & 0x10)) + return am1Error4(); - return AMTable1_G7a[cpustate->modval2 & 0xF](cpustate); + return (this->*s_AMTable1_G7a[m_modval2 & 0xF])(); } -static UINT32 bam1Group7a(v60_state *cpustate) +UINT32 v60_device::bam1Group7a() { - if (!(cpustate->modval2 & 0x10)) - return bam1Error4(cpustate); + if (!(m_modval2 & 0x10)) + return bam1Error4(); - return BAMTable1_G7a[cpustate->modval2 & 0xF](cpustate); + return (this->*s_BAMTable1_G7a[m_modval2 & 0xF])(); } -static UINT32 (*const AMTable1_G7[32])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable1_G7[32] = { - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1ImmediateQuick, - am1PCDisplacement8, - am1PCDisplacement16, - am1PCDisplacement32, - am1DirectAddress, - am1Immediate, - am1Error2, - am1Error2, - am1Error2, - am1PCDisplacementIndirect8, - am1PCDisplacementIndirect16, - am1PCDisplacementIndirect32, - am1DirectAddressDeferred, - am1PCDoubleDisplacement8, - am1PCDoubleDisplacement16, - am1PCDoubleDisplacement32, - am1Error2 + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1ImmediateQuick, + &v60_device::am1PCDisplacement8, + &v60_device::am1PCDisplacement16, + &v60_device::am1PCDisplacement32, + &v60_device::am1DirectAddress, + &v60_device::am1Immediate, + &v60_device::am1Error2, + &v60_device::am1Error2, + &v60_device::am1Error2, + &v60_device::am1PCDisplacementIndirect8, + &v60_device::am1PCDisplacementIndirect16, + &v60_device::am1PCDisplacementIndirect32, + &v60_device::am1DirectAddressDeferred, + &v60_device::am1PCDoubleDisplacement8, + &v60_device::am1PCDoubleDisplacement16, + &v60_device::am1PCDoubleDisplacement32, + &v60_device::am1Error2 }; -static UINT32 (*const BAMTable1_G7[32])(v60_state *) = +const v60_device::am_func v60_device::s_BAMTable1_G7[32] = { - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1Error6, - bam1PCDisplacement8, - bam1PCDisplacement16, - bam1PCDisplacement32, - bam1DirectAddress, - bam1Error6, - bam1Error2, - bam1Error2, - bam1Error2, - bam1PCDisplacementIndirect8, - bam1PCDisplacementIndirect16, - bam1PCDisplacementIndirect32, - bam1DirectAddressDeferred, - bam1PCDoubleDisplacement8, - bam1PCDoubleDisplacement16, - bam1PCDoubleDisplacement32, - bam1Error2 + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1Error6, + &v60_device::bam1PCDisplacement8, + &v60_device::bam1PCDisplacement16, + &v60_device::bam1PCDisplacement32, + &v60_device::bam1DirectAddress, + &v60_device::bam1Error6, + &v60_device::bam1Error2, + &v60_device::bam1Error2, + &v60_device::bam1Error2, + &v60_device::bam1PCDisplacementIndirect8, + &v60_device::bam1PCDisplacementIndirect16, + &v60_device::bam1PCDisplacementIndirect32, + &v60_device::bam1DirectAddressDeferred, + &v60_device::bam1PCDoubleDisplacement8, + &v60_device::bam1PCDoubleDisplacement16, + &v60_device::bam1PCDoubleDisplacement32, + &v60_device::bam1Error2 }; -static UINT32 (*const AMTable1_G6[8])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable1_G6[8] = { - am1DisplacementIndexed8, - am1DisplacementIndexed16, - am1DisplacementIndexed32, - am1RegisterIndirectIndexed, - am1DisplacementIndirectIndexed8, - am1DisplacementIndirectIndexed16, - am1DisplacementIndirectIndexed32, - am1Group7a + &v60_device::am1DisplacementIndexed8, + &v60_device::am1DisplacementIndexed16, + &v60_device::am1DisplacementIndexed32, + &v60_device::am1RegisterIndirectIndexed, + &v60_device::am1DisplacementIndirectIndexed8, + &v60_device::am1DisplacementIndirectIndexed16, + &v60_device::am1DisplacementIndirectIndexed32, + &v60_device::am1Group7a }; -static UINT32 (*const BAMTable1_G6[8])(v60_state *) = +const v60_device::am_func v60_device::s_BAMTable1_G6[8] = { - bam1DisplacementIndexed8, - bam1DisplacementIndexed16, - bam1DisplacementIndexed32, - bam1RegisterIndirectIndexed, - bam1DisplacementIndirectIndexed8, - bam1DisplacementIndirectIndexed16, - bam1DisplacementIndirectIndexed32, - bam1Group7a + &v60_device::bam1DisplacementIndexed8, + &v60_device::bam1DisplacementIndexed16, + &v60_device::bam1DisplacementIndexed32, + &v60_device::bam1RegisterIndirectIndexed, + &v60_device::bam1DisplacementIndirectIndexed8, + &v60_device::bam1DisplacementIndirectIndexed16, + &v60_device::bam1DisplacementIndirectIndexed32, + &v60_device::bam1Group7a }; -static UINT32 am1Group6(v60_state *cpustate) +UINT32 v60_device::am1Group6() { - cpustate->modval2 = OpRead8(cpustate, cpustate->modadd + 1); - return AMTable1_G6[cpustate->modval2 >> 5](cpustate); + m_modval2 = OpRead8(m_modadd + 1); + return (this->*s_AMTable1_G6[m_modval2 >> 5])(); } -static UINT32 bam1Group6(v60_state *cpustate) +UINT32 v60_device::bam1Group6() { - cpustate->modval2 = OpRead8(cpustate, cpustate->modadd + 1); - return BAMTable1_G6[cpustate->modval2 >> 5](cpustate); + m_modval2 = OpRead8(m_modadd + 1); + return (this->*s_BAMTable1_G6[m_modval2 >> 5])(); } -static UINT32 am1Group7(v60_state *cpustate) +UINT32 v60_device::am1Group7() { - return AMTable1_G7[cpustate->modval & 0x1F](cpustate); + return (this->*s_AMTable1_G7[m_modval & 0x1F])(); } -static UINT32 bam1Group7(v60_state *cpustate) +UINT32 v60_device::bam1Group7() { - return BAMTable1_G7[cpustate->modval & 0x1F](cpustate); + return (this->*s_BAMTable1_G7[m_modval & 0x1F])(); } -static UINT32 (*const AMTable1[2][8])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable1[2][8] = { { - am1Displacement8, - am1Displacement16, - am1Displacement32, - am1RegisterIndirect, - am1DisplacementIndirect8, - am1DisplacementIndirect16, - am1DisplacementIndirect32, - am1Group7 + &v60_device::am1Displacement8, + &v60_device::am1Displacement16, + &v60_device::am1Displacement32, + &v60_device::am1RegisterIndirect, + &v60_device::am1DisplacementIndirect8, + &v60_device::am1DisplacementIndirect16, + &v60_device::am1DisplacementIndirect32, + &v60_device::am1Group7 }, { - am1DoubleDisplacement8, - am1DoubleDisplacement16, - am1DoubleDisplacement32, - am1Register, - am1Autoincrement, - am1Autodecrement, - am1Group6, - am1Error1 + &v60_device::am1DoubleDisplacement8, + &v60_device::am1DoubleDisplacement16, + &v60_device::am1DoubleDisplacement32, + &v60_device::am1Register, + &v60_device::am1Autoincrement, + &v60_device::am1Autodecrement, + &v60_device::am1Group6, + &v60_device::am1Error1 } }; -static UINT32 (*const BAMTable1[2][8])(v60_state *) = +const v60_device::am_func v60_device::s_BAMTable1[2][8] = { { - bam1Displacement8, - bam1Displacement16, - bam1Displacement32, - bam1RegisterIndirect, - bam1DisplacementIndirect8, - bam1DisplacementIndirect16, - bam1DisplacementIndirect32, - bam1Group7 + &v60_device::bam1Displacement8, + &v60_device::bam1Displacement16, + &v60_device::bam1Displacement32, + &v60_device::bam1RegisterIndirect, + &v60_device::bam1DisplacementIndirect8, + &v60_device::bam1DisplacementIndirect16, + &v60_device::bam1DisplacementIndirect32, + &v60_device::bam1Group7 }, { - bam1DoubleDisplacement8, - bam1DoubleDisplacement16, - bam1DoubleDisplacement32, - bam1Error6, - bam1Autoincrement, - bam1Autodecrement, - bam1Group6, - bam1Error1 + &v60_device::bam1DoubleDisplacement8, + &v60_device::bam1DoubleDisplacement16, + &v60_device::bam1DoubleDisplacement32, + &v60_device::bam1Error6, + &v60_device::bam1Autoincrement, + &v60_device::bam1Autodecrement, + &v60_device::bam1Group6, + &v60_device::bam1Error1 } }; diff --git a/src/emu/cpu/v60/am2.c b/src/emu/cpu/v60/am2.c index c682a42df49..39c1a501294 100644 --- a/src/emu/cpu/v60/am2.c +++ b/src/emu/cpu/v60/am2.c @@ -2,692 +2,692 @@ // AM2 Functions (for ReadAMAddress) // ********************************* -static UINT32 am2Register(v60_state *cpustate) +UINT32 v60_device::am2Register() { - cpustate->amflag = 1; - cpustate->amout = cpustate->modval & 0x1F; + m_amflag = 1; + m_amout = m_modval & 0x1F; return 1; } -static UINT32 am2RegisterIndirect(v60_state *cpustate) +UINT32 v60_device::am2RegisterIndirect() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F]; return 1; } -static UINT32 bam2RegisterIndirect(v60_state *cpustate) +UINT32 v60_device::bam2RegisterIndirect() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F]; + m_bamoffset = 0; return 1; } -static UINT32 am2RegisterIndirectIndexed(v60_state *cpustate) +UINT32 v60_device::am2RegisterIndirectIndexed() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F] * 8; break; } return 2; } -static UINT32 bam2RegisterIndirectIndexed(v60_state *cpustate) +UINT32 v60_device::bam2RegisterIndirectIndexed() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F]; - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_reg[m_modval2 & 0x1F]; + m_bamoffset = m_reg[m_modval & 0x1F]; return 2; } -static UINT32 am2Autoincrement(v60_state *cpustate) +UINT32 v60_device::am2Autoincrement() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F]; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->reg[cpustate->modval & 0x1F] += 1; + m_reg[m_modval & 0x1F] += 1; break; case 1: - cpustate->reg[cpustate->modval & 0x1F] += 2; + m_reg[m_modval & 0x1F] += 2; break; case 2: - cpustate->reg[cpustate->modval & 0x1F] += 4; + m_reg[m_modval & 0x1F] += 4; break; case 3: - cpustate->reg[cpustate->modval & 0x1F] += 8; + m_reg[m_modval & 0x1F] += 8; break; } return 1; } -static UINT32 bam2Autoincrement(v60_state *cpustate) +UINT32 v60_device::bam2Autoincrement() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F]; + m_bamoffset = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 10: - cpustate->reg[cpustate->modval & 0x1F] +=1; + m_reg[m_modval & 0x1F] +=1; break; case 11: - cpustate->reg[cpustate->modval & 0x1F] +=4; + m_reg[m_modval & 0x1F] +=4; break; default: - fatalerror("CPU - AM2 - 7 (t0 cpustate->PC=%x)\n", cpustate->PC); + fatalerror("CPU - AM2 - 7 (t0 PC=%x)\n", PC); break; } return 1; } -static UINT32 am2Autodecrement(v60_state *cpustate) +UINT32 v60_device::am2Autodecrement() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->reg[cpustate->modval & 0x1F] -= 1; + m_reg[m_modval & 0x1F] -= 1; break; case 1: - cpustate->reg[cpustate->modval & 0x1F] -= 2; + m_reg[m_modval & 0x1F] -= 2; break; case 2: - cpustate->reg[cpustate->modval & 0x1F] -= 4; + m_reg[m_modval & 0x1F] -= 4; break; case 3: - cpustate->reg[cpustate->modval & 0x1F] -= 8; + m_reg[m_modval & 0x1F] -= 8; break; } - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_reg[m_modval & 0x1F]; return 1; } -static UINT32 bam2Autodecrement(v60_state *cpustate) +UINT32 v60_device::bam2Autodecrement() { - cpustate->amflag = 0; - cpustate->bamoffset = 0; + m_amflag = 0; + m_bamoffset = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 10: - cpustate->reg[cpustate->modval & 0x1F]-=1; + m_reg[m_modval & 0x1F]-=1; break; case 11: - cpustate->reg[cpustate->modval & 0x1F]-=4; + m_reg[m_modval & 0x1F]-=4; break; default: - fatalerror("CPU - BAM2 - 7 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM2 - 7 (PC=%06x)\n", PC); break; } - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_reg[m_modval & 0x1F]; return 1; } -static UINT32 am2Displacement8(v60_state *cpustate) +UINT32 v60_device::am2Displacement8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1); return 2; } -static UINT32 bam2Displacement8(v60_state *cpustate) +UINT32 v60_device::bam2Displacement8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F]; + m_bamoffset = (INT8)OpRead8(m_modadd + 1); return 2; } -static UINT32 am2Displacement16(v60_state *cpustate) +UINT32 v60_device::am2Displacement16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1); return 3; } -static UINT32 bam2Displacement16(v60_state *cpustate) +UINT32 v60_device::bam2Displacement16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->bamoffset = (INT16)OpRead16(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F]; + m_bamoffset = (INT16)OpRead16(m_modadd + 1); return 3; } -static UINT32 am2Displacement32(v60_state *cpustate) +UINT32 v60_device::am2Displacement32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1); return 5; } -static UINT32 bam2Displacement32(v60_state *cpustate) +UINT32 v60_device::bam2Displacement32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval & 0x1F]; - cpustate->bamoffset = OpRead32(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = m_reg[m_modval & 0x1F]; + m_bamoffset = OpRead32(m_modadd + 1); return 5; } -static UINT32 am2DisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndexed8() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 8; break; } return 3; } -static UINT32 bam2DisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndexed8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2); + m_bamoffset = m_reg[m_modval & 0x1F]; return 3; } -static UINT32 am2DisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndexed16() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 8; break; } return 4; } -static UINT32 bam2DisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndexed16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2); + m_bamoffset = m_reg[m_modval & 0x1F]; return 4; } -static UINT32 am2DisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndexed32() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 8; break; } return 6; } -static UINT32 bam2DisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndexed32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2); + m_bamoffset = m_reg[m_modval & 0x1F]; return 6; } -static UINT32 am2PCDisplacement8(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacement8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = PC + (INT8)OpRead8(m_modadd + 1); return 2; } -static UINT32 bam2PCDisplacement8(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacement8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC; - cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = PC; + m_bamoffset = (INT8)OpRead8(m_modadd + 1); return 2; } -static UINT32 am2PCDisplacement16(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacement16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = PC + (INT16)OpRead16(m_modadd + 1); return 3; } -static UINT32 bam2PCDisplacement16(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacement16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC; - cpustate->bamoffset = (INT16)OpRead16(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = PC; + m_bamoffset = (INT16)OpRead16(m_modadd + 1); return 3; } -static UINT32 am2PCDisplacement32(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacement32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = PC + OpRead32(m_modadd + 1); return 5; } -static UINT32 bam2PCDisplacement32(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacement32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC; - cpustate->bamoffset = OpRead32(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = PC; + m_bamoffset = OpRead32(m_modadd + 1); return 5; } -static UINT32 am2PCDisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndexed8() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 8; break; } return 3; } -static UINT32 bam2PCDisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndexed8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = PC + (INT8)OpRead8(m_modadd + 2); + m_bamoffset = m_reg[m_modval & 0x1F]; return 3; } -static UINT32 am2PCDisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndexed16() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 8; break; } return 4; } -static UINT32 bam2PCDisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndexed16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = PC + (INT16)OpRead16(m_modadd + 2); + m_bamoffset = m_reg[m_modval & 0x1F]; return 4; } -static UINT32 am2PCDisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndexed32() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 8; break; } return 6; } -static UINT32 bam2PCDisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndexed32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = PC + OpRead32(m_modadd + 2); + m_bamoffset = m_reg[m_modval & 0x1F]; return 6; } -static UINT32 am2DisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndirect8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)); return 2; } -static UINT32 bam2DisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndirect8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)); + m_bamoffset = 0; return 2; } -static UINT32 am2DisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndirect16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)); return 3; } -static UINT32 bam2DisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndirect16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)); + m_bamoffset = 0; return 3; } -static UINT32 am2DisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndirect32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)); return 5; } -static UINT32 bam2DisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndirect32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)); + m_bamoffset = 0; return 5; } -static UINT32 am2DisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndirectIndexed8() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 8; break; } return 3; } -static UINT32 bam2DisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndirectIndexed8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)); + m_bamoffset = m_reg[m_modval & 0x1F]; return 3; } -static UINT32 am2DisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndirectIndexed16() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 8; break; } return 4; } -static UINT32 bam2DisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndirectIndexed16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)); + m_bamoffset = m_reg[m_modval & 0x1F]; return 4; } -static UINT32 am2DisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::am2DisplacementIndirectIndexed32() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 8; break; } return 6; } -static UINT32 bam2DisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::bam2DisplacementIndirectIndexed32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)); + m_bamoffset = m_reg[m_modval & 0x1F]; return 6; } -static UINT32 am2PCDisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndirect8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)); return 2; } -static UINT32 bam2PCDisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndirect8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)); + m_bamoffset = 0; return 2; } -static UINT32 am2PCDisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndirect16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)); return 3; } -static UINT32 bam2PCDisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndirect16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)); + m_bamoffset = 0; return 3; } -static UINT32 am2PCDisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndirect32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)); return 5; } -static UINT32 bam2PCDisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndirect32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)); + m_bamoffset = 0; return 5; } -static UINT32 am2PCDisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndirectIndexed8() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 8; break; } return 3; } -static UINT32 bam2PCDisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndirectIndexed8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)); + m_bamoffset = m_reg[m_modval & 0x1F]; return 3; } -static UINT32 am2PCDisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndirectIndexed16() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 8; break; } @@ -695,559 +695,559 @@ static UINT32 am2PCDisplacementIndirectIndexed16(v60_state *cpustate) } -static UINT32 bam2PCDisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndirectIndexed16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)); + m_bamoffset = m_reg[m_modval & 0x1F]; return 4; } -static UINT32 am2PCDisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::am2PCDisplacementIndirectIndexed32() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 8; break; } return 6; } -static UINT32 bam2PCDisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::bam2PCDisplacementIndirectIndexed32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)); + m_bamoffset = m_reg[m_modval & 0x1F]; return 6; } -static UINT32 am2DoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::am2DoubleDisplacement8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2); return 3; } -static UINT32 bam2DoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::bam2DoubleDisplacement8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 2); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)); + m_bamoffset = (INT8)OpRead8(m_modadd + 2); return 3; } -static UINT32 am2DoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::am2DoubleDisplacement16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3); return 5; } -static UINT32 bam2DoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::bam2DoubleDisplacement16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 3); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)); + m_bamoffset = (INT8)OpRead8(m_modadd + 3); return 5; } -static UINT32 am2DoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::am2DoubleDisplacement32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5); return 9; } -static UINT32 bam2DoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::bam2DoubleDisplacement32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = OpRead32(cpustate, cpustate->modadd + 5); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)); + m_bamoffset = OpRead32(m_modadd + 5); return 9; } -static UINT32 am2PCDoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::am2PCDoubleDisplacement8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2); return 3; } -static UINT32 bam2PCDoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::bam2PCDoubleDisplacement8() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 2); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)); + m_bamoffset = (INT8)OpRead8(m_modadd + 2); return 3; } -static UINT32 am2PCDoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::am2PCDoubleDisplacement16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3); return 5; } -static UINT32 bam2PCDoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::bam2PCDoubleDisplacement16() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 3); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)); + m_bamoffset = (INT8)OpRead8(m_modadd + 3); return 5; } -static UINT32 am2PCDoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::am2PCDoubleDisplacement32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5); return 9; } -static UINT32 bam2PCDoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::bam2PCDoubleDisplacement32() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = OpRead32(cpustate, cpustate->modadd + 5); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)); + m_bamoffset = OpRead32(m_modadd + 5); return 9; } -static UINT32 am2DirectAddress(v60_state *cpustate) +UINT32 v60_device::am2DirectAddress() { - cpustate->amflag = 0; - cpustate->amout = OpRead32(cpustate, cpustate->modadd + 1); + m_amflag = 0; + m_amout = OpRead32(m_modadd + 1); return 5; } -static UINT32 bam2DirectAddress(v60_state *cpustate) +UINT32 v60_device::bam2DirectAddress() { - cpustate->amflag = 0; - cpustate->amout = OpRead32(cpustate, cpustate->modadd + 1); - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = OpRead32(m_modadd + 1); + m_bamoffset = 0; return 5; } -static UINT32 am2DirectAddressIndexed(v60_state *cpustate) +UINT32 v60_device::am2DirectAddressIndexed() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 8; break; } return 6; } -static UINT32 bam2DirectAddressIndexed(v60_state *cpustate) +UINT32 v60_device::bam2DirectAddressIndexed() { - cpustate->amflag = 0; - cpustate->amout = OpRead32(cpustate, cpustate->modadd + 2); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = OpRead32(m_modadd + 2); + m_bamoffset = m_reg[m_modval & 0x1F]; return 6; } -static UINT32 am2DirectAddressDeferred(v60_state *cpustate) +UINT32 v60_device::am2DirectAddressDeferred() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1)); + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 1)); return 5; } -static UINT32 bam2DirectAddressDeferred(v60_state *cpustate) +UINT32 v60_device::bam2DirectAddressDeferred() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1)); - cpustate->bamoffset = 0; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 1)); + m_bamoffset = 0; return 5; } -static UINT32 am2DirectAddressDeferredIndexed(v60_state *cpustate) +UINT32 v60_device::am2DirectAddressDeferredIndexed() { - cpustate->amflag = 0; + m_amflag = 0; - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F]; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F]; break; case 1: - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2; break; case 2: - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4; break; case 3: - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 8; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 8; break; } return 6; } -static UINT32 bam2DirectAddressDeferredIndexed(v60_state *cpustate) +UINT32 v60_device::bam2DirectAddressDeferredIndexed() { - cpustate->amflag = 0; - cpustate->amout = cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)); - cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F]; + m_amflag = 0; + m_amout = m_program->read_dword_unaligned(OpRead32(m_modadd + 2)); + m_bamoffset = m_reg[m_modval & 0x1F]; return 6; } -static UINT32 am2Immediate(v60_state *cpustate) +UINT32 v60_device::am2Immediate() { // ignore LDPR - return am1Immediate(cpustate); + return am1Immediate(); } -static UINT32 am2ImmediateQuick(v60_state *cpustate) +UINT32 v60_device::am2ImmediateQuick() { // ignore LDPR - return am1ImmediateQuick(cpustate); + return am1ImmediateQuick(); } // AM2 Tables (for ReadAMAddress) // ****************************** -static UINT32 am2Error1(v60_state *cpustate) +UINT32 v60_device::am2Error1() { // f1lap trips this, why? - logerror("CPU - AM2 - 1 (cpustate->PC=%06x)", cpustate->PC); + logerror("CPU - AM2 - 1 (PC=%06x)", PC); return 0; } -static UINT32 am2Error2(v60_state *cpustate) +UINT32 v60_device::am2Error2() { - fatalerror("CPU - AM2 - 2 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM2 - 2 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } #ifdef UNUSED_FUNCTION -static UINT32 am2Error3(v60_state *cpustate) +UINT32 v60_device::am2Error3() { - fatalerror("CPU - AM2 - 3 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM2 - 3 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } #endif -static UINT32 am2Error4(v60_state *cpustate) +UINT32 v60_device::am2Error4() { - fatalerror("CPU - AM2 - 4 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM2 - 4 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 am2Error5(v60_state *cpustate) +UINT32 v60_device::am2Error5() { - fatalerror("CPU - AM2 - 5 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM2 - 5 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam2Error1(v60_state *cpustate) +UINT32 v60_device::bam2Error1() { - fatalerror("CPU - BAM2 - 1 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM2 - 1 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam2Error2(v60_state *cpustate) +UINT32 v60_device::bam2Error2() { - fatalerror("CPU - BAM2 - 2 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM2 - 2 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } #ifdef UNUSED_FUNCTION -static UINT32 bam2Error3(v60_state *cpustate) +UINT32 v60_device::bam2Error3() { - fatalerror("CPU - BAM2 - 3 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM2 - 3 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } #endif -static UINT32 bam2Error4(v60_state *cpustate) +UINT32 v60_device::bam2Error4() { - fatalerror("CPU - BAM2 - 4 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM2 - 4 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam2Error5(v60_state *cpustate) +UINT32 v60_device::bam2Error5() { - fatalerror("CPU - BAM2 - 5 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM2 - 5 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 bam2Error6(v60_state *cpustate) +UINT32 v60_device::bam2Error6() { - fatalerror("CPU - BAM2 - 6 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - BAM2 - 6 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 (*const AMTable2_G7a[16])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable2_G7a[16] = { - am2PCDisplacementIndexed8, - am2PCDisplacementIndexed16, - am2PCDisplacementIndexed32, - am2DirectAddressIndexed, - am2Error5, - am2Error5, - am2Error5, - am2Error5, - am2PCDisplacementIndirectIndexed8, - am2PCDisplacementIndirectIndexed16, - am2PCDisplacementIndirectIndexed32, - am2DirectAddressDeferredIndexed, - am2Error5, - am2Error5, - am2Error5, - am2Error5 + &v60_device::am2PCDisplacementIndexed8, + &v60_device::am2PCDisplacementIndexed16, + &v60_device::am2PCDisplacementIndexed32, + &v60_device::am2DirectAddressIndexed, + &v60_device::am2Error5, + &v60_device::am2Error5, + &v60_device::am2Error5, + &v60_device::am2Error5, + &v60_device::am2PCDisplacementIndirectIndexed8, + &v60_device::am2PCDisplacementIndirectIndexed16, + &v60_device::am2PCDisplacementIndirectIndexed32, + &v60_device::am2DirectAddressDeferredIndexed, + &v60_device::am2Error5, + &v60_device::am2Error5, + &v60_device::am2Error5, + &v60_device::am2Error5 }; -static UINT32 (*const BAMTable2_G7a[16])(v60_state *) = +const v60_device::am_func v60_device::s_BAMTable2_G7a[16] = { - bam2PCDisplacementIndexed8, - bam2PCDisplacementIndexed16, - bam2PCDisplacementIndexed32, - bam2DirectAddressIndexed, - bam2Error5, - bam2Error5, - bam2Error5, - bam2Error5, - bam2PCDisplacementIndirectIndexed8, - bam2PCDisplacementIndirectIndexed16, - bam2PCDisplacementIndirectIndexed32, - bam2DirectAddressDeferredIndexed, - bam2Error5, - bam2Error5, - bam2Error5, - bam2Error5 + &v60_device::bam2PCDisplacementIndexed8, + &v60_device::bam2PCDisplacementIndexed16, + &v60_device::bam2PCDisplacementIndexed32, + &v60_device::bam2DirectAddressIndexed, + &v60_device::bam2Error5, + &v60_device::bam2Error5, + &v60_device::bam2Error5, + &v60_device::bam2Error5, + &v60_device::bam2PCDisplacementIndirectIndexed8, + &v60_device::bam2PCDisplacementIndirectIndexed16, + &v60_device::bam2PCDisplacementIndirectIndexed32, + &v60_device::bam2DirectAddressDeferredIndexed, + &v60_device::bam2Error5, + &v60_device::bam2Error5, + &v60_device::bam2Error5, + &v60_device::bam2Error5 }; -static UINT32 am2Group7a(v60_state *cpustate) +UINT32 v60_device::am2Group7a() { - if (!(cpustate->modval2 & 0x10)) - return am2Error4(cpustate); + if (!(m_modval2 & 0x10)) + return am2Error4(); - return AMTable2_G7a[cpustate->modval2 & 0xF](cpustate); + return (this->*s_AMTable2_G7a[m_modval2 & 0xF])(); } -static UINT32 bam2Group7a(v60_state *cpustate) +UINT32 v60_device::bam2Group7a() { - if (!(cpustate->modval2 & 0x10)) - return bam2Error4(cpustate); + if (!(m_modval2 & 0x10)) + return bam2Error4(); - return BAMTable2_G7a[cpustate->modval2 & 0xF](cpustate); + return (this->*s_BAMTable2_G7a[m_modval2 & 0xF])(); } -static UINT32 (*const AMTable2_G7[32])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable2_G7[32] = { - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2ImmediateQuick, - am2PCDisplacement8, - am2PCDisplacement16, - am2PCDisplacement32, - am2DirectAddress, - am2Immediate, - am2Error2, - am2Error2, - am2Error2, - am2PCDisplacementIndirect8, - am2PCDisplacementIndirect16, - am2PCDisplacementIndirect32, - am2DirectAddressDeferred, - am2PCDoubleDisplacement8, - am2PCDoubleDisplacement16, - am2PCDoubleDisplacement32, - am2Error2 + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2ImmediateQuick, + &v60_device::am2PCDisplacement8, + &v60_device::am2PCDisplacement16, + &v60_device::am2PCDisplacement32, + &v60_device::am2DirectAddress, + &v60_device::am2Immediate, + &v60_device::am2Error2, + &v60_device::am2Error2, + &v60_device::am2Error2, + &v60_device::am2PCDisplacementIndirect8, + &v60_device::am2PCDisplacementIndirect16, + &v60_device::am2PCDisplacementIndirect32, + &v60_device::am2DirectAddressDeferred, + &v60_device::am2PCDoubleDisplacement8, + &v60_device::am2PCDoubleDisplacement16, + &v60_device::am2PCDoubleDisplacement32, + &v60_device::am2Error2 }; -static UINT32 (*const BAMTable2_G7[32])(v60_state *) = +const v60_device::am_func v60_device::s_BAMTable2_G7[32] = { - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2Error6, - bam2PCDisplacement8, - bam2PCDisplacement16, - bam2PCDisplacement32, - bam2DirectAddress, - bam2Error6, - bam2Error2, - bam2Error2, - bam2Error2, - bam2PCDisplacementIndirect8, - bam2PCDisplacementIndirect16, - bam2PCDisplacementIndirect32, - bam2DirectAddressDeferred, - bam2PCDoubleDisplacement8, - bam2PCDoubleDisplacement16, - bam2PCDoubleDisplacement32, - bam2Error2 + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2Error6, + &v60_device::bam2PCDisplacement8, + &v60_device::bam2PCDisplacement16, + &v60_device::bam2PCDisplacement32, + &v60_device::bam2DirectAddress, + &v60_device::bam2Error6, + &v60_device::bam2Error2, + &v60_device::bam2Error2, + &v60_device::bam2Error2, + &v60_device::bam2PCDisplacementIndirect8, + &v60_device::bam2PCDisplacementIndirect16, + &v60_device::bam2PCDisplacementIndirect32, + &v60_device::bam2DirectAddressDeferred, + &v60_device::bam2PCDoubleDisplacement8, + &v60_device::bam2PCDoubleDisplacement16, + &v60_device::bam2PCDoubleDisplacement32, + &v60_device::bam2Error2 }; -static UINT32 (*const AMTable2_G6[8])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable2_G6[8] = { - am2DisplacementIndexed8, - am2DisplacementIndexed16, - am2DisplacementIndexed32, - am2RegisterIndirectIndexed, - am2DisplacementIndirectIndexed8, - am2DisplacementIndirectIndexed16, - am2DisplacementIndirectIndexed32, - am2Group7a + &v60_device::am2DisplacementIndexed8, + &v60_device::am2DisplacementIndexed16, + &v60_device::am2DisplacementIndexed32, + &v60_device::am2RegisterIndirectIndexed, + &v60_device::am2DisplacementIndirectIndexed8, + &v60_device::am2DisplacementIndirectIndexed16, + &v60_device::am2DisplacementIndirectIndexed32, + &v60_device::am2Group7a }; -static UINT32 (*const BAMTable2_G6[8])(v60_state *) = +const v60_device::am_func v60_device::s_BAMTable2_G6[8] = { - bam2DisplacementIndexed8, - bam2DisplacementIndexed16, - bam2DisplacementIndexed32, - bam2RegisterIndirectIndexed, - bam2DisplacementIndirectIndexed8, - bam2DisplacementIndirectIndexed16, - bam2DisplacementIndirectIndexed32, - bam2Group7a + &v60_device::bam2DisplacementIndexed8, + &v60_device::bam2DisplacementIndexed16, + &v60_device::bam2DisplacementIndexed32, + &v60_device::bam2RegisterIndirectIndexed, + &v60_device::bam2DisplacementIndirectIndexed8, + &v60_device::bam2DisplacementIndirectIndexed16, + &v60_device::bam2DisplacementIndirectIndexed32, + &v60_device::bam2Group7a }; -static UINT32 am2Group6(v60_state *cpustate) +UINT32 v60_device::am2Group6() { - cpustate->modval2 = OpRead8(cpustate, cpustate->modadd + 1); - return AMTable2_G6[cpustate->modval2 >> 5](cpustate); + m_modval2 = OpRead8(m_modadd + 1); + return (this->*s_AMTable2_G6[m_modval2 >> 5])(); } -static UINT32 bam2Group6(v60_state *cpustate) +UINT32 v60_device::bam2Group6() { - cpustate->modval2 = OpRead8(cpustate, cpustate->modadd + 1); - return BAMTable2_G6[cpustate->modval2 >> 5](cpustate); + m_modval2 = OpRead8(m_modadd + 1); + return (this->*s_BAMTable2_G6[m_modval2 >> 5])(); } -static UINT32 am2Group7(v60_state *cpustate) +UINT32 v60_device::am2Group7() { - return AMTable2_G7[cpustate->modval & 0x1F](cpustate); + return (this->*s_AMTable2_G7[m_modval & 0x1F])(); } -static UINT32 bam2Group7(v60_state *cpustate) +UINT32 v60_device::bam2Group7() { - return BAMTable2_G7[cpustate->modval & 0x1F](cpustate); + return (this->*s_BAMTable2_G7[m_modval & 0x1F])(); } -static UINT32 (*const AMTable2[2][8])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable2[2][8] = { { - am2Displacement8, - am2Displacement16, - am2Displacement32, - am2RegisterIndirect, - am2DisplacementIndirect8, - am2DisplacementIndirect16, - am2DisplacementIndirect32, - am2Group7 + &v60_device::am2Displacement8, + &v60_device::am2Displacement16, + &v60_device::am2Displacement32, + &v60_device::am2RegisterIndirect, + &v60_device::am2DisplacementIndirect8, + &v60_device::am2DisplacementIndirect16, + &v60_device::am2DisplacementIndirect32, + &v60_device::am2Group7 }, { - am2DoubleDisplacement8, - am2DoubleDisplacement16, - am2DoubleDisplacement32, - am2Register, - am2Autoincrement, - am2Autodecrement, - am2Group6, - am2Error1 + &v60_device::am2DoubleDisplacement8, + &v60_device::am2DoubleDisplacement16, + &v60_device::am2DoubleDisplacement32, + &v60_device::am2Register, + &v60_device::am2Autoincrement, + &v60_device::am2Autodecrement, + &v60_device::am2Group6, + &v60_device::am2Error1 } }; -static UINT32 (*const BAMTable2[2][8])(v60_state *) = +const v60_device::am_func v60_device::s_BAMTable2[2][8] = { { - bam2Displacement8, - bam2Displacement16, - bam2Displacement32, - bam2RegisterIndirect, - bam2DisplacementIndirect8, - bam2DisplacementIndirect16, - bam2DisplacementIndirect32, - bam2Group7 + &v60_device::bam2Displacement8, + &v60_device::bam2Displacement16, + &v60_device::bam2Displacement32, + &v60_device::bam2RegisterIndirect, + &v60_device::bam2DisplacementIndirect8, + &v60_device::bam2DisplacementIndirect16, + &v60_device::bam2DisplacementIndirect32, + &v60_device::bam2Group7 }, { - bam2DoubleDisplacement8, - bam2DoubleDisplacement16, - bam2DoubleDisplacement32, - bam2Error6, - bam2Autoincrement, - bam2Autodecrement, - bam2Group6, - bam2Error1 + &v60_device::bam2DoubleDisplacement8, + &v60_device::bam2DoubleDisplacement16, + &v60_device::bam2DoubleDisplacement32, + &v60_device::bam2Error6, + &v60_device::bam2Autoincrement, + &v60_device::bam2Autodecrement, + &v60_device::bam2Group6, + &v60_device::bam2Error1 } }; diff --git a/src/emu/cpu/v60/am3.c b/src/emu/cpu/v60/am3.c index 3857bb3bb4a..6de71d78e86 100644 --- a/src/emu/cpu/v60/am3.c +++ b/src/emu/cpu/v60/am3.c @@ -2,150 +2,150 @@ // AM3 Functions (for ReadAM) // ************************** -static UINT32 am3Register(v60_state *cpustate) +UINT32 v60_device::am3Register() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - SETREG8(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + SETREG8(m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - SETREG16(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalh); + SETREG16(m_reg[m_modval & 0x1F], m_modwritevalh); break; case 2: - cpustate->reg[cpustate->modval & 0x1F] = cpustate->modwritevalw; + m_reg[m_modval & 0x1F] = m_modwritevalw; break; } return 1; } -static UINT32 am3RegisterIndirect(v60_state *cpustate) +UINT32 v60_device::am3RegisterIndirect() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalh); + m_program->write_word_unaligned(m_reg[m_modval & 0x1F], m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalw); + m_program->write_dword_unaligned(m_reg[m_modval & 0x1F], m_modwritevalw); break; } return 1; } -static UINT32 am3RegisterIndirectIndexed(v60_state *cpustate) +UINT32 v60_device::am3RegisterIndirectIndexed() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_reg[m_modval2 & 0x1F] + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 2; } -static UINT32 am3Autoincrement(v60_state *cpustate) +UINT32 v60_device::am3Autoincrement() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); - cpustate->reg[cpustate->modval & 0x1F] += 1; + m_program->write_byte(m_reg[m_modval & 0x1F], m_modwritevalb); + m_reg[m_modval & 0x1F] += 1; break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalh); - cpustate->reg[cpustate->modval & 0x1F] += 2; + m_program->write_word_unaligned(m_reg[m_modval & 0x1F], m_modwritevalh); + m_reg[m_modval & 0x1F] += 2; break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalw); - cpustate->reg[cpustate->modval & 0x1F] += 4; + m_program->write_dword_unaligned(m_reg[m_modval & 0x1F], m_modwritevalw); + m_reg[m_modval & 0x1F] += 4; break; } return 1; } -static UINT32 am3Autodecrement(v60_state *cpustate) +UINT32 v60_device::am3Autodecrement() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->reg[cpustate->modval & 0x1F] -= 1; - cpustate->program->write_byte(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_reg[m_modval & 0x1F] -= 1; + m_program->write_byte(m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->reg[cpustate->modval & 0x1F] -= 2; - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalh); + m_reg[m_modval & 0x1F] -= 2; + m_program->write_word_unaligned(m_reg[m_modval & 0x1F], m_modwritevalh); break; case 2: - cpustate->reg[cpustate->modval & 0x1F] -= 4; - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalw); + m_reg[m_modval & 0x1F] -= 4; + m_program->write_dword_unaligned(m_reg[m_modval & 0x1F], m_modwritevalw); break; } return 1; } -static UINT32 am3Displacement8(v60_state *cpustate) +UINT32 v60_device::am3Displacement8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1), cpustate->modwritevalb); + m_program->write_byte(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1), cpustate->modwritevalh); + m_program->write_word_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1), m_modwritevalw); break; } return 2; } -static UINT32 am3Displacement16(v60_state *cpustate) +UINT32 v60_device::am3Displacement16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1), cpustate->modwritevalb); + m_program->write_byte(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1), cpustate->modwritevalh); + m_program->write_word_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1), m_modwritevalw); break; } return 3; } -static UINT32 am3Displacement32(v60_state *cpustate) +UINT32 v60_device::am3Displacement32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalb); + m_program->write_byte(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalh); + m_program->write_word_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1), m_modwritevalw); break; } @@ -153,54 +153,54 @@ static UINT32 am3Displacement32(v60_state *cpustate) } -static UINT32 am3DisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndexed8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 3; } -static UINT32 am3DisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndexed16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 4; } -static UINT32 am3DisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndexed32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } @@ -208,162 +208,162 @@ static UINT32 am3DisplacementIndexed32(v60_state *cpustate) } -static UINT32 am3PCDisplacement8(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacement8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1), cpustate->modwritevalb); + m_program->write_byte(PC + (INT8)OpRead8(m_modadd + 1), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1), cpustate->modwritevalh); + m_program->write_word_unaligned(PC + (INT8)OpRead8(m_modadd + 1), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1), cpustate->modwritevalw); + m_program->write_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1), m_modwritevalw); break; } return 2; } -static UINT32 am3PCDisplacement16(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacement16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1), cpustate->modwritevalb); + m_program->write_byte(PC + (INT16)OpRead16(m_modadd + 1), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1), cpustate->modwritevalh); + m_program->write_word_unaligned(PC + (INT16)OpRead16(m_modadd + 1), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1), cpustate->modwritevalw); + m_program->write_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1), m_modwritevalw); break; } return 3; } -static UINT32 am3PCDisplacement32(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacement32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalb); + m_program->write_byte(PC + OpRead32(m_modadd + 1), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalh); + m_program->write_word_unaligned(PC + OpRead32(m_modadd + 1), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalw); + m_program->write_dword_unaligned(PC + OpRead32(m_modadd + 1), m_modwritevalw); break; } return 5; } -static UINT32 am3PCDisplacementIndexed8(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndexed8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 3; } -static UINT32 am3PCDisplacementIndexed16(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndexed16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 4; } -static UINT32 am3PCDisplacementIndexed32(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndexed32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(PC + OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 6; } -static UINT32 am3DisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndirect8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)), m_modwritevalw); break; } return 2; } -static UINT32 am3DisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndirect16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)), m_modwritevalw); break; } return 3; } -static UINT32 am3DisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndirect32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)), m_modwritevalw); break; } @@ -371,108 +371,108 @@ static UINT32 am3DisplacementIndirect32(v60_state *cpustate) } -static UINT32 am3DisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndirectIndexed8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 3; } -static UINT32 am3DisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndirectIndexed16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 4; } -static UINT32 am3DisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::am3DisplacementIndirectIndexed32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval2 & 0x1F] + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval2 & 0x1F] + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 6; } -static UINT32 am3PCDisplacementIndirect8(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndirect8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)), m_modwritevalw); break; } return 2; } -static UINT32 am3PCDisplacementIndirect16(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndirect16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)), m_modwritevalw); break; } return 3; } -static UINT32 am3PCDisplacementIndirect32(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndirect32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)), m_modwritevalw); break; } @@ -480,54 +480,54 @@ static UINT32 am3PCDisplacementIndirect32(v60_state *cpustate) } -static UINT32 am3PCDisplacementIndirectIndexed8(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndirectIndexed8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 3; } -static UINT32 am3PCDisplacementIndirectIndexed16(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndirectIndexed16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 4; } -static UINT32 am3PCDisplacementIndirectIndexed32(v60_state *cpustate) +UINT32 v60_device::am3PCDisplacementIndirectIndexed32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } @@ -535,54 +535,54 @@ static UINT32 am3PCDisplacementIndirectIndexed32(v60_state *cpustate) } -static UINT32 am3DoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::am3DoubleDisplacement8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2), m_modwritevalw); break; } return 3; } -static UINT32 am3DoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::am3DoubleDisplacement16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3), m_modwritevalw); break; } return 5; } -static UINT32 am3DoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::am3DoubleDisplacement32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(m_reg[m_modval & 0x1F] + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5), m_modwritevalw); break; } @@ -590,141 +590,141 @@ static UINT32 am3DoubleDisplacement32(v60_state *cpustate) } -static UINT32 am3PCDoubleDisplacement8(v60_state *cpustate) +UINT32 v60_device::am3PCDoubleDisplacement8() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1)) + (INT8)OpRead8(cpustate, cpustate->modadd + 2), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + (INT8)OpRead8(m_modadd + 1)) + (INT8)OpRead8(m_modadd + 2), m_modwritevalw); break; } return 3; } -static UINT32 am3PCDoubleDisplacement16(v60_state *cpustate) +UINT32 v60_device::am3PCDoubleDisplacement16() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1)) + (INT16)OpRead16(cpustate, cpustate->modadd + 3), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + (INT16)OpRead16(m_modadd + 1)) + (INT16)OpRead16(m_modadd + 3), m_modwritevalw); break; } return 5; } -static UINT32 am3PCDoubleDisplacement32(v60_state *cpustate) +UINT32 v60_device::am3PCDoubleDisplacement32() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(cpustate->PC + OpRead32(cpustate, cpustate->modadd + 1)) + OpRead32(cpustate, cpustate->modadd + 5), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(PC + OpRead32(m_modadd + 1)) + OpRead32(m_modadd + 5), m_modwritevalw); break; } return 9; } -static UINT32 am3DirectAddress(v60_state *cpustate) +UINT32 v60_device::am3DirectAddress() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalb); + m_program->write_byte(OpRead32(m_modadd + 1), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalh); + m_program->write_word_unaligned(OpRead32(m_modadd + 1), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1), cpustate->modwritevalw); + m_program->write_dword_unaligned(OpRead32(m_modadd + 1), m_modwritevalw); break; } return 5; } -static UINT32 am3DirectAddressIndexed(v60_state *cpustate) +UINT32 v60_device::am3DirectAddressIndexed() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 2, cpustate->modwritevalh); + m_program->write_word_unaligned(OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 2, m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2) + cpustate->reg[cpustate->modval & 0x1F] * 4, cpustate->modwritevalw); + m_program->write_dword_unaligned(OpRead32(m_modadd + 2) + m_reg[m_modval & 0x1F] * 4, m_modwritevalw); break; } return 6; } -static UINT32 am3DirectAddressDeferred(v60_state *cpustate) +UINT32 v60_device::am3DirectAddressDeferred() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(OpRead32(m_modadd + 1)), m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 1)), m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 1)), cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 1)), m_modwritevalw); break; } return 5; } -static UINT32 am3DirectAddressDeferredIndexed(v60_state *cpustate) +UINT32 v60_device::am3DirectAddressDeferredIndexed() { - switch (cpustate->moddim) + switch (m_moddim) { case 0: - cpustate->program->write_byte(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalb); + m_program->write_byte(m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalb); break; case 1: - cpustate->program->write_word_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalh); + m_program->write_word_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalh); break; case 2: - cpustate->program->write_dword_unaligned(cpustate->program->read_dword_unaligned(OpRead32(cpustate, cpustate->modadd + 2)) + cpustate->reg[cpustate->modval & 0x1F], cpustate->modwritevalw); + m_program->write_dword_unaligned(m_program->read_dword_unaligned(OpRead32(m_modadd + 2)) + m_reg[m_modval & 0x1F], m_modwritevalw); break; } return 6; } -static UINT32 am3Immediate(v60_state *cpustate) +UINT32 v60_device::am3Immediate() { - fatalerror("CPU - AM3 - IMM (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM3 - IMM (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 am3ImmediateQuick(v60_state *cpustate) +UINT32 v60_device::am3ImmediateQuick() { - fatalerror("CPU - AM3 - IMMQ (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM3 - IMMQ (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } @@ -733,152 +733,152 @@ static UINT32 am3ImmediateQuick(v60_state *cpustate) // AM3 Tables (for ReadAMAddress) // ****************************** -static UINT32 am3Error1(v60_state *cpustate) +UINT32 v60_device::am3Error1() { - fatalerror("CPU - AM3 - 1 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM3 - 1 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 am3Error2(v60_state *cpustate) +UINT32 v60_device::am3Error2() { - fatalerror("CPU - AM3 - 2 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM3 - 2 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } #ifdef UNUSED_FUNCTION -static UINT32 am3Error3(v60_state *cpustate) +UINT32 v60_device::am3Error3() { - fatalerror("CPU - AM3 - 3 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM3 - 3 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } #endif -static UINT32 am3Error4(v60_state *cpustate) +UINT32 v60_device::am3Error4() { - fatalerror("CPU - AM3 - 4 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM3 - 4 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 am3Error5(v60_state *cpustate) +UINT32 v60_device::am3Error5() { - fatalerror("CPU - AM3 - 5 (cpustate->PC=%06x)\n", cpustate->PC); + fatalerror("CPU - AM3 - 5 (PC=%06x)\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 (*const AMTable3_G7a[16])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable3_G7a[16] = { - am3PCDisplacementIndexed8, - am3PCDisplacementIndexed16, - am3PCDisplacementIndexed32, - am3DirectAddressIndexed, - am3Error5, - am3Error5, - am3Error5, - am3Error5, - am3PCDisplacementIndirectIndexed8, - am3PCDisplacementIndirectIndexed16, - am3PCDisplacementIndirectIndexed32, - am3DirectAddressDeferredIndexed, - am3Error5, - am3Error5, - am3Error5, - am3Error5 + &v60_device::am3PCDisplacementIndexed8, + &v60_device::am3PCDisplacementIndexed16, + &v60_device::am3PCDisplacementIndexed32, + &v60_device::am3DirectAddressIndexed, + &v60_device::am3Error5, + &v60_device::am3Error5, + &v60_device::am3Error5, + &v60_device::am3Error5, + &v60_device::am3PCDisplacementIndirectIndexed8, + &v60_device::am3PCDisplacementIndirectIndexed16, + &v60_device::am3PCDisplacementIndirectIndexed32, + &v60_device::am3DirectAddressDeferredIndexed, + &v60_device::am3Error5, + &v60_device::am3Error5, + &v60_device::am3Error5, + &v60_device::am3Error5 }; -static UINT32 am3Group7a(v60_state *cpustate) +UINT32 v60_device::am3Group7a() { - if (!(cpustate->modval2 & 0x10)) - return am3Error4(cpustate); + if (!(m_modval2 & 0x10)) + return am3Error4(); - return AMTable3_G7a[cpustate->modval2 & 0xF](cpustate); + return (this->*s_AMTable3_G7a[m_modval2 & 0xF])(); } -static UINT32 (*const AMTable3_G7[32])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable3_G7[32] = { - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3ImmediateQuick, - am3PCDisplacement8, - am3PCDisplacement16, - am3PCDisplacement32, - am3DirectAddress, - am3Immediate, - am3Error2, - am3Error2, - am3Error2, - am3PCDisplacementIndirect8, - am3PCDisplacementIndirect16, - am3PCDisplacementIndirect32, - am3DirectAddressDeferred, - am3PCDoubleDisplacement8, - am3PCDoubleDisplacement16, - am3PCDoubleDisplacement32, - am3Error2 + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3ImmediateQuick, + &v60_device::am3PCDisplacement8, + &v60_device::am3PCDisplacement16, + &v60_device::am3PCDisplacement32, + &v60_device::am3DirectAddress, + &v60_device::am3Immediate, + &v60_device::am3Error2, + &v60_device::am3Error2, + &v60_device::am3Error2, + &v60_device::am3PCDisplacementIndirect8, + &v60_device::am3PCDisplacementIndirect16, + &v60_device::am3PCDisplacementIndirect32, + &v60_device::am3DirectAddressDeferred, + &v60_device::am3PCDoubleDisplacement8, + &v60_device::am3PCDoubleDisplacement16, + &v60_device::am3PCDoubleDisplacement32, + &v60_device::am3Error2 }; -static UINT32 (*const AMTable3_G6[8])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable3_G6[8] = { - am3DisplacementIndexed8, - am3DisplacementIndexed16, - am3DisplacementIndexed32, - am3RegisterIndirectIndexed, - am3DisplacementIndirectIndexed8, - am3DisplacementIndirectIndexed16, - am3DisplacementIndirectIndexed32, - am3Group7a + &v60_device::am3DisplacementIndexed8, + &v60_device::am3DisplacementIndexed16, + &v60_device::am3DisplacementIndexed32, + &v60_device::am3RegisterIndirectIndexed, + &v60_device::am3DisplacementIndirectIndexed8, + &v60_device::am3DisplacementIndirectIndexed16, + &v60_device::am3DisplacementIndirectIndexed32, + &v60_device::am3Group7a }; -static UINT32 am3Group6(v60_state *cpustate) +UINT32 v60_device::am3Group6() { - cpustate->modval2 = OpRead8(cpustate, cpustate->modadd + 1); - return AMTable3_G6[cpustate->modval2 >> 5](cpustate); + m_modval2 = OpRead8(m_modadd + 1); + return (this->*s_AMTable3_G6[m_modval2 >> 5])(); } -static UINT32 am3Group7(v60_state *cpustate) +UINT32 v60_device::am3Group7() { - return AMTable3_G7[cpustate->modval & 0x1F](cpustate); + return (this->*s_AMTable3_G7[m_modval & 0x1F])(); } -static UINT32 (*const AMTable3[2][8])(v60_state *) = +const v60_device::am_func v60_device::s_AMTable3[2][8] = { { - am3Displacement8, - am3Displacement16, - am3Displacement32, - am3RegisterIndirect, - am3DisplacementIndirect8, - am3DisplacementIndirect16, - am3DisplacementIndirect32, - am3Group7 + &v60_device::am3Displacement8, + &v60_device::am3Displacement16, + &v60_device::am3Displacement32, + &v60_device::am3RegisterIndirect, + &v60_device::am3DisplacementIndirect8, + &v60_device::am3DisplacementIndirect16, + &v60_device::am3DisplacementIndirect32, + &v60_device::am3Group7 }, { - am3DoubleDisplacement8, - am3DoubleDisplacement16, - am3DoubleDisplacement32, - am3Register, - am3Autoincrement, - am3Autodecrement, - am3Group6, - am3Error1 + &v60_device::am3DoubleDisplacement8, + &v60_device::am3DoubleDisplacement16, + &v60_device::am3DoubleDisplacement32, + &v60_device::am3Register, + &v60_device::am3Autoincrement, + &v60_device::am3Autodecrement, + &v60_device::am3Group6, + &v60_device::am3Error1 } }; diff --git a/src/emu/cpu/v60/op12.c b/src/emu/cpu/v60/op12.c index cfae254d48b..f43a3a5a5d4 100644 --- a/src/emu/cpu/v60/op12.c +++ b/src/emu/cpu/v60/op12.c @@ -2,7 +2,7 @@ * MUL* and MULU* do not set OV correctly * DIVX: the second operand should be treated as dword instead of word * GETATE, GETPTE and GETRA should not be used - * UPDPSW: cpustate->_CY and cpustate->_OV must be cleared or unchanged? I suppose + * UPDPSW: _CY and _OV must be cleared or unchanged? I suppose * cleared, like TEST being done on the mask operand. * MOVT: I cannot understand exactly what happens to the result * when an overflow occurs @@ -13,161 +13,161 @@ /* - * Macro to access data in operands decoded with ReadAMAddress(cpustate) + * Macro to access data in operands decoded with ReadAMAddress() */ -#define F12LOADOPBYTE(cs, num) \ - if ((cs)->flag##num) \ - appb = (UINT8)(cs)->reg[(cs)->op##num]; \ +#define F12LOADOPBYTE(num) \ + if (m_flag##num) \ + appb = (UINT8)m_reg[m_op##num]; \ else \ - appb = (cs)->program->read_byte((cs)->op##num); + appb = m_program->read_byte(m_op##num); -#define F12LOADOPHALF(cs, num) \ - if ((cs)->flag##num) \ - apph = (UINT16)(cs)->reg[(cs)->op##num]; \ +#define F12LOADOPHALF(num) \ + if (m_flag##num) \ + apph = (UINT16)m_reg[m_op##num]; \ else \ - apph = (cs)->program->read_word_unaligned((cs)->op##num); + apph = m_program->read_word_unaligned(m_op##num); -#define F12LOADOPWORD(cs, num) \ - if ((cs)->flag##num) \ - appw = (cs)->reg[(cs)->op##num]; \ +#define F12LOADOPWORD(num) \ + if (m_flag##num) \ + appw = m_reg[m_op##num]; \ else \ - appw = (cs)->program->read_dword_unaligned((cs)->op##num); + appw = m_program->read_dword_unaligned(m_op##num); -#define F12STOREOPBYTE(cs, num) \ - if ((cs)->flag##num) \ - SETREG8((cs)->reg[(cs)->op##num], appb); \ +#define F12STOREOPBYTE(num) \ + if (m_flag##num) \ + SETREG8(m_reg[m_op##num], appb); \ else \ - (cs)->program->write_byte((cs)->op##num, appb); + m_program->write_byte(m_op##num, appb); -#define F12STOREOPHALF(cs, num) \ - if ((cs)->flag##num) \ - SETREG16((cs)->reg[(cs)->op##num], apph); \ +#define F12STOREOPHALF(num) \ + if (m_flag##num) \ + SETREG16(m_reg[m_op##num], apph); \ else \ - (cs)->program->write_word_unaligned((cs)->op##num, apph); + m_program->write_word_unaligned(m_op##num, apph); -#define F12STOREOPWORD(cs, num) \ - if ((cs)->flag##num) \ - (cs)->reg[(cs)->op##num] = appw; \ +#define F12STOREOPWORD(num) \ + if (m_flag##num) \ + m_reg[m_op##num] = appw; \ else \ - (cs)->program->write_dword_unaligned((cs)->op##num, appw); + m_program->write_dword_unaligned(m_op##num, appw); -#define F12LOADOP1BYTE(cs) F12LOADOPBYTE(cs, 1) -#define F12LOADOP1HALF(cs) F12LOADOPHALF(cs, 1) -#define F12LOADOP1WORD(cs) F12LOADOPWORD(cs, 1) +#define F12LOADOP1BYTE() F12LOADOPBYTE(1) +#define F12LOADOP1HALF() F12LOADOPHALF(1) +#define F12LOADOP1WORD() F12LOADOPWORD(1) -#define F12LOADOP2BYTE(cs) F12LOADOPBYTE(cs, 2) -#define F12LOADOP2HALF(cs) F12LOADOPHALF(cs, 2) -#define F12LOADOP2WORD(cs) F12LOADOPWORD(cs, 2) +#define F12LOADOP2BYTE() F12LOADOPBYTE(2) +#define F12LOADOP2HALF() F12LOADOPHALF(2) +#define F12LOADOP2WORD() F12LOADOPWORD(2) -#define F12STOREOP1BYTE(cs) F12STOREOPBYTE(cs, 1) -#define F12STOREOP1HALF(cs) F12STOREOPHALF(cs, 1) -#define F12STOREOP1WORD(cs) F12STOREOPWORD(cs, 1) +#define F12STOREOP1BYTE() F12STOREOPBYTE(1) +#define F12STOREOP1HALF() F12STOREOPHALF(1) +#define F12STOREOP1WORD() F12STOREOPWORD(1) -#define F12STOREOP2BYTE(cs) F12STOREOPBYTE(cs, 2) -#define F12STOREOP2HALF(cs) F12STOREOPHALF(cs, 2) -#define F12STOREOP2WORD(cs) F12STOREOPWORD(cs, 2) +#define F12STOREOP2BYTE() F12STOREOPBYTE(2) +#define F12STOREOP2HALF() F12STOREOPHALF(2) +#define F12STOREOP2WORD() F12STOREOPWORD(2) -#define F12END(cs) \ - return (cs)->amlength1 + (cs)->amlength2 + 2; +#define F12END() \ + return m_amlength1 + m_amlength2 + 2; // Decode the first operand of the instruction and prepare // writing to the second operand. -static void F12DecodeFirstOperand(v60_state *cpustate, UINT32 (*DecodeOp1)(v60_state *), UINT8 dim1) +void v60_device::F12DecodeFirstOperand(am_func DecodeOp1, UINT8 dim1) { - cpustate->instflags = OpRead8(cpustate, cpustate->PC + 1); + m_instflags = OpRead8(PC + 1); // Check if F1 or F2 - if (cpustate->instflags & 0x80) + if (m_instflags & 0x80) { - cpustate->moddim = dim1; - cpustate->modm = cpustate->instflags & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->amlength1 = DecodeOp1(cpustate); - cpustate->op1 = cpustate->amout; - cpustate->flag1 = cpustate->amflag; + m_moddim = dim1; + m_modm = m_instflags & 0x40; + m_modadd = PC + 2; + m_amlength1 = (this->*DecodeOp1)(); + m_op1 = m_amout; + m_flag1 = m_amflag; } else { // Check D flag - if (cpustate->instflags & 0x20) + if (m_instflags & 0x20) { - cpustate->moddim = dim1; - cpustate->modm = cpustate->instflags & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->amlength1 = DecodeOp1(cpustate); - cpustate->op1 = cpustate->amout; - cpustate->flag1 = cpustate->amflag; + m_moddim = dim1; + m_modm = m_instflags & 0x40; + m_modadd = PC + 2; + m_amlength1 = (this->*DecodeOp1)(); + m_op1 = m_amout; + m_flag1 = m_amflag; } else { - if (DecodeOp1 == ReadAM) + if (DecodeOp1 == &v60_device::ReadAM) { switch (dim1) { case 0: - cpustate->op1 = (UINT8)cpustate->reg[cpustate->instflags & 0x1F]; + m_op1 = (UINT8)m_reg[m_instflags & 0x1F]; break; case 1: - cpustate->op1 = (UINT16)cpustate->reg[cpustate->instflags & 0x1F]; + m_op1 = (UINT16)m_reg[m_instflags & 0x1F]; break; case 2: - cpustate->op1 = cpustate->reg[cpustate->instflags & 0x1F]; + m_op1 = m_reg[m_instflags & 0x1F]; break; } - cpustate->flag1 = 0; + m_flag1 = 0; } else { - cpustate->flag1 = 1; - cpustate->op1 = cpustate->instflags & 0x1F; + m_flag1 = 1; + m_op1 = m_instflags & 0x1F; } - cpustate->amlength1 = 0; + m_amlength1 = 0; } } } -static void F12WriteSecondOperand(v60_state *cpustate, UINT8 dim2) +void v60_device::F12WriteSecondOperand(UINT8 dim2) { - cpustate->moddim = dim2; + m_moddim = dim2; // Check if F1 or F2 - if (cpustate->instflags & 0x80) + if (m_instflags & 0x80) { - cpustate->modm = cpustate->instflags & 0x20; - cpustate->modadd = cpustate->PC + 2 + cpustate->amlength1; - cpustate->moddim = dim2; - cpustate->amlength2 = WriteAM(cpustate); + m_modm = m_instflags & 0x20; + m_modadd = PC + 2 + m_amlength1; + m_moddim = dim2; + m_amlength2 = WriteAM(); } else { // Check D flag - if (cpustate->instflags & 0x20) + if (m_instflags & 0x20) { switch (dim2) { case 0: - SETREG8(cpustate->reg[cpustate->instflags & 0x1F], cpustate->modwritevalb); + SETREG8(m_reg[m_instflags & 0x1F], m_modwritevalb); break; case 1: - SETREG16(cpustate->reg[cpustate->instflags & 0x1F], cpustate->modwritevalh); + SETREG16(m_reg[m_instflags & 0x1F], m_modwritevalh); break; case 2: - cpustate->reg[cpustate->instflags & 0x1F] = cpustate->modwritevalw; + m_reg[m_instflags & 0x1F] = m_modwritevalw; break; } - cpustate->amlength2 = 0; + m_amlength2 = 0; } else { - cpustate->modm = cpustate->instflags & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->moddim = dim2; - cpustate->amlength2 = WriteAM(cpustate); + m_modm = m_instflags & 0x40; + m_modadd = PC + 2; + m_moddim = dim2; + m_amlength2 = WriteAM(); } } } @@ -175,1202 +175,1202 @@ static void F12WriteSecondOperand(v60_state *cpustate, UINT8 dim2) // Decode both format 1 / 2 operands -static void F12DecodeOperands(v60_state *cpustate, UINT32 (*DecodeOp1)(v60_state *), UINT8 dim1, UINT32 (*DecodeOp2)(v60_state *), UINT8 dim2) +void v60_device::F12DecodeOperands(am_func DecodeOp1, UINT8 dim1, am_func DecodeOp2, UINT8 dim2) { - UINT8 _if12 = OpRead8(cpustate, cpustate->PC + 1); + UINT8 _if12 = OpRead8(PC + 1); // Check if F1 or F2 if (_if12 & 0x80) { - cpustate->moddim = dim1; - cpustate->modm = _if12 & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->amlength1 = DecodeOp1(cpustate); - cpustate->op1 = cpustate->amout; - cpustate->flag1 = cpustate->amflag; + m_moddim = dim1; + m_modm = _if12 & 0x40; + m_modadd = PC + 2; + m_amlength1 = (this->*DecodeOp1)(); + m_op1 = m_amout; + m_flag1 = m_amflag; - cpustate->moddim = dim2; - cpustate->modm = _if12 & 0x20; - cpustate->modadd = cpustate->PC + 2 + cpustate->amlength1; - cpustate->amlength2 = DecodeOp2(cpustate); - cpustate->op2 = cpustate->amout; - cpustate->flag2 = cpustate->amflag; + m_moddim = dim2; + m_modm = _if12 & 0x20; + m_modadd = PC + 2 + m_amlength1; + m_amlength2 = (this->*DecodeOp2)(); + m_op2 = m_amout; + m_flag2 = m_amflag; } else { // Check D flag if (_if12 & 0x20) { - if (DecodeOp2 == ReadAMAddress) + if (DecodeOp2 == &v60_device::ReadAMAddress) { - cpustate->op2 = _if12 & 0x1F; - cpustate->flag2 = 1; + m_op2 = _if12 & 0x1F; + m_flag2 = 1; } else { switch (dim2) { case 0: - cpustate->op2 = (UINT8)cpustate->reg[_if12 & 0x1F]; + m_op2 = (UINT8)m_reg[_if12 & 0x1F]; break; case 1: - cpustate->op2 = (UINT16)cpustate->reg[_if12 & 0x1F]; + m_op2 = (UINT16)m_reg[_if12 & 0x1F]; break; case 2: - cpustate->op2 = cpustate->reg[_if12 & 0x1F]; + m_op2 = m_reg[_if12 & 0x1F]; break; } } - cpustate->amlength2 = 0; + m_amlength2 = 0; - cpustate->moddim = dim1; - cpustate->modm = _if12 & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->amlength1 = DecodeOp1(cpustate); - cpustate->op1 = cpustate->amout; - cpustate->flag1 = cpustate->amflag; + m_moddim = dim1; + m_modm = _if12 & 0x40; + m_modadd = PC + 2; + m_amlength1 = (this->*DecodeOp1)(); + m_op1 = m_amout; + m_flag1 = m_amflag; } else { - if (DecodeOp1 == ReadAMAddress) + if (DecodeOp1 == &v60_device::ReadAMAddress) { - cpustate->op1 = _if12 & 0x1F; - cpustate->flag1 = 1; + m_op1 = _if12 & 0x1F; + m_flag1 = 1; } else { switch (dim1) { case 0: - cpustate->op1 = (UINT8)cpustate->reg[_if12 & 0x1F]; + m_op1 = (UINT8)m_reg[_if12 & 0x1F]; break; case 1: - cpustate->op1 = (UINT16)cpustate->reg[_if12 & 0x1F]; + m_op1 = (UINT16)m_reg[_if12 & 0x1F]; break; case 2: - cpustate->op1 = cpustate->reg[_if12 & 0x1F]; + m_op1 = m_reg[_if12 & 0x1F]; break; } } - cpustate->amlength1 = 0; + m_amlength1 = 0; - cpustate->moddim = dim2; - cpustate->modm = _if12 & 0x40; - cpustate->modadd = cpustate->PC + 2 + cpustate->amlength1; - cpustate->amlength2 = DecodeOp2(cpustate); - cpustate->op2 = cpustate->amout; - cpustate->flag2 = cpustate->amflag; + m_moddim = dim2; + m_modm = _if12 & 0x40; + m_modadd = PC + 2 + m_amlength1; + m_amlength2 = (this->*DecodeOp2)(); + m_op2 = m_amout; + m_flag2 = m_amflag; } } } -static UINT32 opADDB(v60_state *cpustate) /* TRUSTED (C too!)*/ +UINT32 v60_device::opADDB() /* TRUSTED (C too!)*/ { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - ADDB(appb, (UINT8)cpustate->op1); + ADDB(appb, (UINT8)m_op1); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opADDH(v60_state *cpustate) /* TRUSTED (C too!)*/ +UINT32 v60_device::opADDH() /* TRUSTED (C too!)*/ { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - ADDW(apph, (UINT16)cpustate->op1); + ADDW(apph, (UINT16)m_op1); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opADDW(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opADDW() /* TRUSTED (C too!) */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - ADDL(appw, (UINT32)cpustate->op1); + ADDL(appw, (UINT32)m_op1); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opADDCB(v60_state *cpustate) +UINT32 v60_device::opADDCB() { UINT8 appb, temp; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - temp = ((UINT8)cpustate->op1 + (cpustate->_CY?1:0)); + temp = ((UINT8)m_op1 + (_CY?1:0)); ADDB(appb, temp); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opADDCH(v60_state *cpustate) +UINT32 v60_device::opADDCH() { UINT16 apph, temp; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - temp = ((UINT16)cpustate->op1 + (cpustate->_CY?1:0)); + temp = ((UINT16)m_op1 + (_CY?1:0)); ADDW(apph, temp); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opADDCW(v60_state *cpustate) +UINT32 v60_device::opADDCW() { UINT32 appw, temp; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - temp = cpustate->op1 + (cpustate->_CY?1:0); + temp = m_op1 + (_CY?1:0); ADDL(appw, temp); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opANDB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opANDB() /* TRUSTED */ { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - appb &= cpustate->op1; - cpustate->_OV = 0; - cpustate->_S = ((appb & 0x80) != 0); - cpustate->_Z = (appb == 0); + appb &= m_op1; + _OV = 0; + _S = ((appb & 0x80) != 0); + _Z = (appb == 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opANDH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opANDH() /* TRUSTED */ { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - apph &= cpustate->op1; - cpustate->_OV = 0; - cpustate->_S = ((apph & 0x8000) != 0); - cpustate->_Z = (apph == 0); + apph &= m_op1; + _OV = 0; + _S = ((apph & 0x8000) != 0); + _Z = (apph == 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opANDW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opANDW() /* TRUSTED */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - appw &= cpustate->op1; - cpustate->_OV = 0; - cpustate->_S = ((appw & 0x80000000) != 0); - cpustate->_Z = (appw == 0); + appw &= m_op1; + _OV = 0; + _S = ((appw & 0x80000000) != 0); + _Z = (appw == 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opCALL(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opCALL() /* TRUSTED */ { - F12DecodeOperands(cpustate, ReadAMAddress, 0,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAMAddress, 0,&v60_device::ReadAMAddress, 2); - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->AP); - cpustate->AP = cpustate->op2; + SP -= 4; + m_program->write_dword_unaligned(SP, AP); + AP = m_op2; - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC + cpustate->amlength1 + cpustate->amlength2 + 2); - cpustate->PC = cpustate->op1; + SP -= 4; + m_program->write_dword_unaligned(SP, PC + m_amlength1 + m_amlength2 + 2); + PC = m_op1; return 0; } -static UINT32 opCHKAR(v60_state *cpustate) +UINT32 v60_device::opCHKAR() { - F12DecodeOperands(cpustate, ReadAM, 0,ReadAM, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAM, 0); // No MMU and memory permissions yet @@@ - cpustate->_Z = 1; - cpustate->_CY = 0; - cpustate->_S = 0; + _Z = 1; + _CY = 0; + _S = 0; - F12END(cpustate); + F12END(); } -static UINT32 opCHKAW(v60_state *cpustate) +UINT32 v60_device::opCHKAW() { - F12DecodeOperands(cpustate, ReadAM, 0,ReadAM, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAM, 0); // No MMU and memory permissions yet @@@ - cpustate->_Z = 1; - cpustate->_CY = 0; - cpustate->_S = 0; + _Z = 1; + _CY = 0; + _S = 0; - F12END(cpustate); + F12END(); } -static UINT32 opCHKAE(v60_state *cpustate) +UINT32 v60_device::opCHKAE() { - F12DecodeOperands(cpustate, ReadAM, 0,ReadAM, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAM, 0); // No MMU and memory permissions yet @@@ - cpustate->_Z = 1; - cpustate->_CY = 0; - cpustate->_S = 0; + _Z = 1; + _CY = 0; + _S = 0; - F12END(cpustate); + F12END(); } -static UINT32 opCHLVL(v60_state *cpustate) +UINT32 v60_device::opCHLVL() { UINT32 oldPSW; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAM, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAM, 0); - if (cpustate->op1 > 3) + if (m_op1 > 3) { - fatalerror("Illegal data field on opCHLVL, cpustate->PC=%x\n", cpustate->PC); + fatalerror("Illegal data field on opCHLVL, PC=%x\n", PC); } - oldPSW = v60_update_psw_for_exception(cpustate, 0, cpustate->op1); + oldPSW = v60_update_psw_for_exception(0, m_op1); - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->op2); + SP -= 4; + m_program->write_dword_unaligned(SP, m_op2); - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, EXCEPTION_CODE_AND_SIZE(0x1800 + cpustate->op1 * 0x100, 8)); + SP -= 4; + m_program->write_dword_unaligned(SP, EXCEPTION_CODE_AND_SIZE(0x1800 + m_op1 * 0x100, 8)); - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, oldPSW); + SP -= 4; + m_program->write_dword_unaligned(SP, oldPSW); - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC + cpustate->amlength1 + cpustate->amlength2 + 2); + SP -= 4; + m_program->write_dword_unaligned(SP, PC + m_amlength1 + m_amlength2 + 2); - cpustate->PC = GETINTVECT(cpustate, 24 + cpustate->op1); + PC = GETINTVECT(24 + m_op1); return 0; } -static UINT32 opCLR1(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opCLR1() /* TRUSTED */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - cpustate->_CY = ((appw & (1 << cpustate->op1)) != 0); - cpustate->_Z = !(cpustate->_CY); + _CY = ((appw & (1 << m_op1)) != 0); + _Z = !(_CY); - appw &= ~(1 << cpustate->op1); + appw &= ~(1 << m_op1); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opCMPB(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opCMPB() /* TRUSTED (C too!) */ { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAM, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAM, 0); - appb = (UINT8)cpustate->op2; - SUBB(appb, (UINT8)cpustate->op1); + appb = (UINT8)m_op2; + SUBB(appb, (UINT8)m_op1); - F12END(cpustate); + F12END(); } -static UINT32 opCMPH(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opCMPH() /* TRUSTED (C too!) */ { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAM, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAM, 1); - apph = (UINT16)cpustate->op2; - SUBW(apph, (UINT16)cpustate->op1); + apph = (UINT16)m_op2; + SUBW(apph, (UINT16)m_op1); - F12END(cpustate); + F12END(); } -static UINT32 opCMPW(v60_state *cpustate) /* TRUSTED (C too!)*/ +UINT32 v60_device::opCMPW() /* TRUSTED (C too!)*/ { - F12DecodeOperands(cpustate, ReadAM, 2,ReadAM, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAM, 2); - SUBL(cpustate->op2, (UINT32)cpustate->op1); + SUBL(m_op2, (UINT32)m_op1); - F12END(cpustate); + F12END(); } -static UINT32 opDIVB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDIVB() /* TRUSTED */ { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - cpustate->_OV = ((appb == 0x80) && (cpustate->op1 == 0xFF)); - if (cpustate->op1 && !cpustate->_OV) - appb= (INT8)appb / (INT8)cpustate->op1; - cpustate->_Z = (appb == 0); - cpustate->_S = ((appb & 0x80) != 0); + _OV = ((appb == 0x80) && (m_op1 == 0xFF)); + if (m_op1 && !_OV) + appb= (INT8)appb / (INT8)m_op1; + _Z = (appb == 0); + _S = ((appb & 0x80) != 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opDIVH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDIVH() /* TRUSTED */ { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - cpustate->_OV = ((apph == 0x8000) && (cpustate->op1 == 0xFFFF)); - if (cpustate->op1 && !cpustate->_OV) - apph = (INT16)apph / (INT16)cpustate->op1; - cpustate->_Z = (apph == 0); - cpustate->_S = ((apph & 0x8000) != 0); + _OV = ((apph == 0x8000) && (m_op1 == 0xFFFF)); + if (m_op1 && !_OV) + apph = (INT16)apph / (INT16)m_op1; + _Z = (apph == 0); + _S = ((apph & 0x8000) != 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opDIVW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDIVW() /* TRUSTED */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - cpustate->_OV = ((appw == 0x80000000) && (cpustate->op1 == 0xFFFFFFFF)); - if (cpustate->op1 && !cpustate->_OV) - appw = (INT32)appw / (INT32)cpustate->op1; - cpustate->_Z = (appw == 0); - cpustate->_S = ((appw & 0x80000000) != 0); + _OV = ((appw == 0x80000000) && (m_op1 == 0xFFFFFFFF)); + if (m_op1 && !_OV) + appw = (INT32)appw / (INT32)m_op1; + _Z = (appw == 0); + _S = ((appw & 0x80000000) != 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opDIVX(v60_state *cpustate) +UINT32 v60_device::opDIVX() { UINT32 a, b; INT64 dv; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 3); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 3); - if (cpustate->flag2) + if (m_flag2) { - a = cpustate->reg[cpustate->op2 & 0x1F]; - b = cpustate->reg[(cpustate->op2 & 0x1F) + 1]; + a = m_reg[m_op2 & 0x1F]; + b = m_reg[(m_op2 & 0x1F) + 1]; } else { - a = cpustate->program->read_dword_unaligned(cpustate->op2); - b = cpustate->program->read_dword_unaligned(cpustate->op2 + 4); + a = m_program->read_dword_unaligned(m_op2); + b = m_program->read_dword_unaligned(m_op2 + 4); } dv = ((UINT64)b << 32) | ((UINT64)a); - a = dv / (INT64)((INT32)cpustate->op1); - b = dv % (INT64)((INT32)cpustate->op1); + a = dv / (INT64)((INT32)m_op1); + b = dv % (INT64)((INT32)m_op1); - cpustate->_S = ((a & 0x80000000) != 0); - cpustate->_Z = (a == 0); + _S = ((a & 0x80000000) != 0); + _Z = (a == 0); - if (cpustate->flag2) + if (m_flag2) { - cpustate->reg[cpustate->op2 & 0x1F] = a; - cpustate->reg[(cpustate->op2 & 0x1F) + 1] = b; + m_reg[m_op2 & 0x1F] = a; + m_reg[(m_op2 & 0x1F) + 1] = b; } else { - cpustate->program->write_dword_unaligned(cpustate->op2, a); - cpustate->program->write_dword_unaligned(cpustate->op2 + 4, b); + m_program->write_dword_unaligned(m_op2, a); + m_program->write_dword_unaligned(m_op2 + 4, b); } - F12END(cpustate); + F12END(); } -static UINT32 opDIVUX(v60_state *cpustate) +UINT32 v60_device::opDIVUX() { UINT32 a, b; UINT64 dv; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 3); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 3); - if (cpustate->flag2) + if (m_flag2) { - a = cpustate->reg[cpustate->op2 & 0x1F]; - b = cpustate->reg[(cpustate->op2 & 0x1F) + 1]; + a = m_reg[m_op2 & 0x1F]; + b = m_reg[(m_op2 & 0x1F) + 1]; } else { - a = cpustate->program->read_dword_unaligned(cpustate->op2); - b = cpustate->program->read_dword_unaligned(cpustate->op2 + 4); + a = m_program->read_dword_unaligned(m_op2); + b = m_program->read_dword_unaligned(m_op2 + 4); } dv = (UINT64)(((UINT64)b << 32) | (UINT64)a); - a = (UINT32)(dv / (UINT64)cpustate->op1); - b = (UINT32)(dv % (UINT64)cpustate->op1); + a = (UINT32)(dv / (UINT64)m_op1); + b = (UINT32)(dv % (UINT64)m_op1); - cpustate->_S = ((a & 0x80000000) != 0); - cpustate->_Z = (a == 0); + _S = ((a & 0x80000000) != 0); + _Z = (a == 0); - if (cpustate->flag2) + if (m_flag2) { - cpustate->reg[cpustate->op2 & 0x1F] = a; - cpustate->reg[(cpustate->op2 & 0x1F) + 1] = b; + m_reg[m_op2 & 0x1F] = a; + m_reg[(m_op2 & 0x1F) + 1] = b; } else { - cpustate->program->write_dword_unaligned(cpustate->op2, a); - cpustate->program->write_dword_unaligned(cpustate->op2 + 4, b); + m_program->write_dword_unaligned(m_op2, a); + m_program->write_dword_unaligned(m_op2 + 4, b); } - F12END(cpustate); + F12END(); } -static UINT32 opDIVUB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDIVUB() /* TRUSTED */ { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - cpustate->_OV = 0; - if (cpustate->op1) appb /= (UINT8)cpustate->op1; - cpustate->_Z = (appb == 0); - cpustate->_S = ((appb & 0x80) != 0); + _OV = 0; + if (m_op1) appb /= (UINT8)m_op1; + _Z = (appb == 0); + _S = ((appb & 0x80) != 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opDIVUH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDIVUH() /* TRUSTED */ { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - cpustate->_OV = 0; - if (cpustate->op1) apph /= (UINT16)cpustate->op1; - cpustate->_Z = (apph == 0); - cpustate->_S = ((apph & 0x8000) != 0); + _OV = 0; + if (m_op1) apph /= (UINT16)m_op1; + _Z = (apph == 0); + _S = ((apph & 0x8000) != 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opDIVUW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDIVUW() /* TRUSTED */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - cpustate->_OV = 0; - if (cpustate->op1) appw /= cpustate->op1; - cpustate->_Z = (appw == 0); - cpustate->_S = ((appw & 0x80000000) != 0); + _OV = 0; + if (m_op1) appw /= m_op1; + _Z = (appw == 0); + _S = ((appw & 0x80000000) != 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opINB(v60_state *cpustate) +UINT32 v60_device::opINB() { - F12DecodeFirstOperand(cpustate, ReadAMAddress, 0); - cpustate->modwritevalb = cpustate->io->read_byte(cpustate->op1); + F12DecodeFirstOperand(&v60_device::ReadAMAddress, 0); + m_modwritevalb = m_io->read_byte(m_op1); - if ( cpustate->stall_io ) + if ( m_stall_io ) { - cpustate->stall_io = 0; + m_stall_io = 0; return 0; } - F12WriteSecondOperand(cpustate, 0); - F12END(cpustate); + F12WriteSecondOperand(0); + F12END(); } -static UINT32 opINH(v60_state *cpustate) +UINT32 v60_device::opINH() { - F12DecodeFirstOperand(cpustate, ReadAMAddress, 1); - cpustate->modwritevalh = cpustate->io->read_word_unaligned(cpustate->op1); + F12DecodeFirstOperand(&v60_device::ReadAMAddress, 1); + m_modwritevalh = m_io->read_word_unaligned(m_op1); - if ( cpustate->stall_io ) + if ( m_stall_io ) { - cpustate->stall_io = 0; + m_stall_io = 0; return 0; } - F12WriteSecondOperand(cpustate, 1); - F12END(cpustate); + F12WriteSecondOperand(1); + F12END(); } -static UINT32 opINW(v60_state *cpustate) +UINT32 v60_device::opINW() { - F12DecodeFirstOperand(cpustate, ReadAMAddress, 2); - cpustate->modwritevalw = cpustate->io->read_dword_unaligned(cpustate->op1); + F12DecodeFirstOperand(&v60_device::ReadAMAddress, 2); + m_modwritevalw = m_io->read_dword_unaligned(m_op1); - if ( cpustate->stall_io ) + if ( m_stall_io ) { - cpustate->stall_io = 0; + m_stall_io = 0; return 0; } - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opLDPR(v60_state *cpustate) +UINT32 v60_device::opLDPR() { - F12DecodeOperands(cpustate, ReadAMAddress, 2,ReadAM, 2); - if (cpustate->op2 <= 28) + F12DecodeOperands(&v60_device::ReadAMAddress, 2,&v60_device::ReadAM, 2); + if (m_op2 <= 28) { - if (cpustate->flag1 &&(!(OpRead8(cpustate, cpustate->PC + 1)&0x80 && OpRead8(cpustate, cpustate->PC + 2) == 0xf4 ) )) - cpustate->reg[cpustate->op2 + 36] = cpustate->reg[cpustate->op1]; + if (m_flag1 &&(!(OpRead8(PC + 1)&0x80 && OpRead8(PC + 2) == 0xf4 ) )) + m_reg[m_op2 + 36] = m_reg[m_op1]; else - cpustate->reg[cpustate->op2 + 36] = cpustate->op1; + m_reg[m_op2 + 36] = m_op1; } else { - fatalerror("Invalid operand on LDPR cpustate->PC=%x\n", cpustate->PC); + fatalerror("Invalid operand on LDPR PC=%x\n", PC); } - F12END(cpustate); + F12END(); } -static UINT32 opLDTASK(v60_state *cpustate) +UINT32 v60_device::opLDTASK() { int i; - F12DecodeOperands(cpustate, ReadAMAddress, 2,ReadAM, 2); + F12DecodeOperands(&v60_device::ReadAMAddress, 2,&v60_device::ReadAM, 2); - v60WritePSW(cpustate, v60ReadPSW(cpustate) & 0xefffffff); + v60WritePSW(v60ReadPSW() & 0xefffffff); - cpustate->TR = cpustate->op2; + TR = m_op2; - cpustate->TKCW = cpustate->program->read_dword_unaligned(cpustate->op2); - cpustate->op2 += 4; - if(cpustate->SYCW & 0x100) { - cpustate->L0SP = cpustate->program->read_dword_unaligned(cpustate->op2); - cpustate->op2 += 4; + TKCW = m_program->read_dword_unaligned(m_op2); + m_op2 += 4; + if(SYCW & 0x100) { + L0SP = m_program->read_dword_unaligned(m_op2); + m_op2 += 4; } - if(cpustate->SYCW & 0x200) { - cpustate->L1SP = cpustate->program->read_dword_unaligned(cpustate->op2); - cpustate->op2 += 4; + if(SYCW & 0x200) { + L1SP = m_program->read_dword_unaligned(m_op2); + m_op2 += 4; } - if(cpustate->SYCW & 0x400) { - cpustate->L2SP = cpustate->program->read_dword_unaligned(cpustate->op2); - cpustate->op2 += 4; + if(SYCW & 0x400) { + L2SP = m_program->read_dword_unaligned(m_op2); + m_op2 += 4; } - if(cpustate->SYCW & 0x800) { - cpustate->L3SP = cpustate->program->read_dword_unaligned(cpustate->op2); - cpustate->op2 += 4; + if(SYCW & 0x800) { + L3SP = m_program->read_dword_unaligned(m_op2); + m_op2 += 4; } - v60ReloadStack(cpustate); + v60ReloadStack(); // 31 registers supported, _not_ 32 for(i = 0; i < 31; i++) - if(cpustate->op1 & (1 << i)) { - cpustate->reg[i] = cpustate->program->read_dword_unaligned(cpustate->op2); - cpustate->op2 += 4; + if(m_op1 & (1 << i)) { + m_reg[i] = m_program->read_dword_unaligned(m_op2); + m_op2 += 4; } // #### Ignore the virtual addressing crap. - F12END(cpustate); + F12END(); } -static UINT32 opMOVD(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVD() /* TRUSTED */ { UINT32 a, b; - F12DecodeOperands(cpustate, ReadAMAddress, 3,ReadAMAddress, 3); + F12DecodeOperands(&v60_device::ReadAMAddress, 3,&v60_device::ReadAMAddress, 3); - if (cpustate->flag1) + if (m_flag1) { - a = cpustate->reg[cpustate->op1 & 0x1F]; - b = cpustate->reg[(cpustate->op1 & 0x1F) + 1]; + a = m_reg[m_op1 & 0x1F]; + b = m_reg[(m_op1 & 0x1F) + 1]; } else { - a = cpustate->program->read_dword_unaligned(cpustate->op1); - b = cpustate->program->read_dword_unaligned(cpustate->op1 + 4); + a = m_program->read_dword_unaligned(m_op1); + b = m_program->read_dword_unaligned(m_op1 + 4); } - if (cpustate->flag2) + if (m_flag2) { - cpustate->reg[cpustate->op2 & 0x1F] = a; - cpustate->reg[(cpustate->op2 & 0x1F) + 1] = b; + m_reg[m_op2 & 0x1F] = a; + m_reg[(m_op2 & 0x1F) + 1] = b; } else { - cpustate->program->write_dword_unaligned(cpustate->op2, a); - cpustate->program->write_dword_unaligned(cpustate->op2 + 4, b); + m_program->write_dword_unaligned(m_op2, a); + m_program->write_dword_unaligned(m_op2 + 4, b); } - F12END(cpustate); + F12END(); } -static UINT32 opMOVB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVB() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 0); - cpustate->modwritevalb = (UINT8)cpustate->op1; - F12WriteSecondOperand(cpustate, 0); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 0); + m_modwritevalb = (UINT8)m_op1; + F12WriteSecondOperand(0); + F12END(); } -static UINT32 opMOVH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVH() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 1); - cpustate->modwritevalh = (UINT16)cpustate->op1; - F12WriteSecondOperand(cpustate, 1); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 1); + m_modwritevalh = (UINT16)m_op1; + F12WriteSecondOperand(1); + F12END(); } -static UINT32 opMOVW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVW() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 2); - cpustate->modwritevalw = cpustate->op1; - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 2); + m_modwritevalw = m_op1; + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opMOVEAB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVEAB() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAMAddress, 0); - cpustate->modwritevalw = cpustate->op1; - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAMAddress, 0); + m_modwritevalw = m_op1; + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opMOVEAH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVEAH() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAMAddress, 1); - cpustate->modwritevalw = cpustate->op1; - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAMAddress, 1); + m_modwritevalw = m_op1; + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opMOVEAW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVEAW() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAMAddress, 2); - cpustate->modwritevalw = cpustate->op1; - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAMAddress, 2); + m_modwritevalw = m_op1; + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opMOVSBH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVSBH() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 0); - cpustate->modwritevalh = (INT8)(cpustate->op1 & 0xFF); - F12WriteSecondOperand(cpustate, 1); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 0); + m_modwritevalh = (INT8)(m_op1 & 0xFF); + F12WriteSecondOperand(1); + F12END(); } -static UINT32 opMOVSBW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVSBW() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 0); - cpustate->modwritevalw = (INT8)(cpustate->op1 & 0xFF); - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 0); + m_modwritevalw = (INT8)(m_op1 & 0xFF); + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opMOVSHW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVSHW() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 1); - cpustate->modwritevalw = (INT16)(cpustate->op1 & 0xFFFF); - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 1); + m_modwritevalw = (INT16)(m_op1 & 0xFFFF); + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opMOVTHB(v60_state *cpustate) +UINT32 v60_device::opMOVTHB() { - F12DecodeFirstOperand(cpustate, ReadAM, 1); - cpustate->modwritevalb = (UINT8)(cpustate->op1 & 0xFF); + F12DecodeFirstOperand(&v60_device::ReadAM, 1); + m_modwritevalb = (UINT8)(m_op1 & 0xFF); // Check for overflow: the truncated bits must match the sign // of the result, otherwise overflow - if (((cpustate->modwritevalb & 0x80) == 0x80 && ((cpustate->op1 & 0xFF00) == 0xFF00)) || - ((cpustate->modwritevalb & 0x80) == 0 && ((cpustate->op1 & 0xFF00) == 0x0000))) - cpustate->_OV = 0; + if (((m_modwritevalb & 0x80) == 0x80 && ((m_op1 & 0xFF00) == 0xFF00)) || + ((m_modwritevalb & 0x80) == 0 && ((m_op1 & 0xFF00) == 0x0000))) + _OV = 0; else - cpustate->_OV = 1; + _OV = 1; - F12WriteSecondOperand(cpustate, 0); - F12END(cpustate); + F12WriteSecondOperand(0); + F12END(); } -static UINT32 opMOVTWB(v60_state *cpustate) +UINT32 v60_device::opMOVTWB() { - F12DecodeFirstOperand(cpustate, ReadAM, 2); - cpustate->modwritevalb = (UINT8)(cpustate->op1 & 0xFF); + F12DecodeFirstOperand(&v60_device::ReadAM, 2); + m_modwritevalb = (UINT8)(m_op1 & 0xFF); // Check for overflow: the truncated bits must match the sign // of the result, otherwise overflow - if (((cpustate->modwritevalb & 0x80) == 0x80 && ((cpustate->op1 & 0xFFFFFF00) == 0xFFFFFF00)) || - ((cpustate->modwritevalb & 0x80) == 0 && ((cpustate->op1 & 0xFFFFFF00) == 0x00000000))) - cpustate->_OV = 0; + if (((m_modwritevalb & 0x80) == 0x80 && ((m_op1 & 0xFFFFFF00) == 0xFFFFFF00)) || + ((m_modwritevalb & 0x80) == 0 && ((m_op1 & 0xFFFFFF00) == 0x00000000))) + _OV = 0; else - cpustate->_OV = 1; + _OV = 1; - F12WriteSecondOperand(cpustate, 0); - F12END(cpustate); + F12WriteSecondOperand(0); + F12END(); } -static UINT32 opMOVTWH(v60_state *cpustate) +UINT32 v60_device::opMOVTWH() { - F12DecodeFirstOperand(cpustate, ReadAM, 2); - cpustate->modwritevalh = (UINT16)(cpustate->op1 & 0xFFFF); + F12DecodeFirstOperand(&v60_device::ReadAM, 2); + m_modwritevalh = (UINT16)(m_op1 & 0xFFFF); // Check for overflow: the truncated bits must match the sign // of the result, otherwise overflow - if (((cpustate->modwritevalh & 0x8000) == 0x8000 && ((cpustate->op1 & 0xFFFF0000) == 0xFFFF0000)) || - ((cpustate->modwritevalh & 0x8000) == 0 && ((cpustate->op1 & 0xFFFF0000) == 0x00000000))) - cpustate->_OV = 0; + if (((m_modwritevalh & 0x8000) == 0x8000 && ((m_op1 & 0xFFFF0000) == 0xFFFF0000)) || + ((m_modwritevalh & 0x8000) == 0 && ((m_op1 & 0xFFFF0000) == 0x00000000))) + _OV = 0; else - cpustate->_OV = 1; + _OV = 1; - F12WriteSecondOperand(cpustate, 1); - F12END(cpustate); + F12WriteSecondOperand(1); + F12END(); } -static UINT32 opMOVZBH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVZBH() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 0); - cpustate->modwritevalh = (UINT16)cpustate->op1; - F12WriteSecondOperand(cpustate, 1); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 0); + m_modwritevalh = (UINT16)m_op1; + F12WriteSecondOperand(1); + F12END(); } -static UINT32 opMOVZBW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVZBW() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 0); - cpustate->modwritevalw = cpustate->op1; - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 0); + m_modwritevalw = m_op1; + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opMOVZHW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opMOVZHW() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 1); - cpustate->modwritevalw = cpustate->op1; - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12DecodeFirstOperand(&v60_device::ReadAM, 1); + m_modwritevalw = m_op1; + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opMULB(v60_state *cpustate) +UINT32 v60_device::opMULB() { UINT8 appb; UINT32 tmp; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); // @@@ OV not set!! - tmp = (INT8)appb * (INT32)(INT8)cpustate->op1; + tmp = (INT8)appb * (INT32)(INT8)m_op1; appb = tmp; - cpustate->_Z = (appb == 0); - cpustate->_S = ((appb & 0x80) != 0); - cpustate->_OV = ((tmp >> 8) != 0); + _Z = (appb == 0); + _S = ((appb & 0x80) != 0); + _OV = ((tmp >> 8) != 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opMULH(v60_state *cpustate) +UINT32 v60_device::opMULH() { UINT16 apph; UINT32 tmp; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); // @@@ OV not set!! - tmp = (INT16)apph * (INT32)(INT16)cpustate->op1; + tmp = (INT16)apph * (INT32)(INT16)m_op1; apph = tmp; - cpustate->_Z = (apph == 0); - cpustate->_S = ((apph & 0x8000) != 0); - cpustate->_OV = ((tmp >> 16) != 0); + _Z = (apph == 0); + _S = ((apph & 0x8000) != 0); + _OV = ((tmp >> 16) != 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opMULW(v60_state *cpustate) +UINT32 v60_device::opMULW() { UINT32 appw; UINT64 tmp; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); // @@@ OV not set!! - tmp = (INT32)appw * (INT64)(INT32)cpustate->op1; + tmp = (INT32)appw * (INT64)(INT32)m_op1; appw = tmp; - cpustate->_Z = (appw == 0); - cpustate->_S = ((appw & 0x80000000) != 0); - cpustate->_OV = ((tmp >> 32) != 0); + _Z = (appw == 0); + _S = ((appw & 0x80000000) != 0); + _OV = ((tmp >> 32) != 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opMULUB(v60_state *cpustate) +UINT32 v60_device::opMULUB() { UINT8 appb; UINT32 tmp; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); // @@@ OV not set!! - tmp = appb * (UINT8)cpustate->op1; + tmp = appb * (UINT8)m_op1; appb = tmp; - cpustate->_Z = (appb == 0); - cpustate->_S = ((appb & 0x80) != 0); - cpustate->_OV = ((tmp >> 8) != 0); + _Z = (appb == 0); + _S = ((appb & 0x80) != 0); + _OV = ((tmp >> 8) != 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opMULUH(v60_state *cpustate) +UINT32 v60_device::opMULUH() { UINT16 apph; UINT32 tmp; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); // @@@ OV not set!! - tmp = apph * (UINT16)cpustate->op1; + tmp = apph * (UINT16)m_op1; apph = tmp; - cpustate->_Z = (apph == 0); - cpustate->_S = ((apph & 0x8000) != 0); - cpustate->_OV = ((tmp >> 16) != 0); + _Z = (apph == 0); + _S = ((apph & 0x8000) != 0); + _OV = ((tmp >> 16) != 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opMULUW(v60_state *cpustate) +UINT32 v60_device::opMULUW() { UINT32 appw; UINT64 tmp; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); // @@@ OV not set!! - tmp = (UINT64)appw * (UINT64)cpustate->op1; + tmp = (UINT64)appw * (UINT64)m_op1; appw = tmp; - cpustate->_Z = (appw == 0); - cpustate->_S = ((appw & 0x80000000) != 0); - cpustate->_OV = ((tmp >> 32) != 0); + _Z = (appw == 0); + _S = ((appw & 0x80000000) != 0); + _OV = ((tmp >> 32) != 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opNEGB(v60_state *cpustate) /* TRUSTED (C too!)*/ +UINT32 v60_device::opNEGB() /* TRUSTED (C too!)*/ { - F12DecodeFirstOperand(cpustate, ReadAM, 0); + F12DecodeFirstOperand(&v60_device::ReadAM, 0); - cpustate->modwritevalb = 0; - SUBB(cpustate->modwritevalb, (INT8)cpustate->op1); + m_modwritevalb = 0; + SUBB(m_modwritevalb, (INT8)m_op1); - F12WriteSecondOperand(cpustate, 0); - F12END(cpustate); + F12WriteSecondOperand(0); + F12END(); } -static UINT32 opNEGH(v60_state *cpustate) /* TRUSTED (C too!)*/ +UINT32 v60_device::opNEGH() /* TRUSTED (C too!)*/ { - F12DecodeFirstOperand(cpustate, ReadAM, 1); + F12DecodeFirstOperand(&v60_device::ReadAM, 1); - cpustate->modwritevalh = 0; - SUBW(cpustate->modwritevalh, (INT16)cpustate->op1); + m_modwritevalh = 0; + SUBW(m_modwritevalh, (INT16)m_op1); - F12WriteSecondOperand(cpustate, 1); - F12END(cpustate); + F12WriteSecondOperand(1); + F12END(); } -static UINT32 opNEGW(v60_state *cpustate) /* TRUSTED (C too!)*/ +UINT32 v60_device::opNEGW() /* TRUSTED (C too!)*/ { - F12DecodeFirstOperand(cpustate, ReadAM, 2); + F12DecodeFirstOperand(&v60_device::ReadAM, 2); - cpustate->modwritevalw = 0; - SUBL(cpustate->modwritevalw, (INT32)cpustate->op1); + m_modwritevalw = 0; + SUBL(m_modwritevalw, (INT32)m_op1); - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opNOTB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opNOTB() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 0); - cpustate->modwritevalb=~cpustate->op1; + F12DecodeFirstOperand(&v60_device::ReadAM, 0); + m_modwritevalb=~m_op1; - cpustate->_OV = 0; - cpustate->_S = ((cpustate->modwritevalb & 0x80) != 0); - cpustate->_Z = (cpustate->modwritevalb == 0); + _OV = 0; + _S = ((m_modwritevalb & 0x80) != 0); + _Z = (m_modwritevalb == 0); - F12WriteSecondOperand(cpustate, 0); - F12END(cpustate); + F12WriteSecondOperand(0); + F12END(); } -static UINT32 opNOTH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opNOTH() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 1); - cpustate->modwritevalh=~cpustate->op1; + F12DecodeFirstOperand(&v60_device::ReadAM, 1); + m_modwritevalh=~m_op1; - cpustate->_OV = 0; - cpustate->_S = ((cpustate->modwritevalh & 0x8000) != 0); - cpustate->_Z = (cpustate->modwritevalh == 0); + _OV = 0; + _S = ((m_modwritevalh & 0x8000) != 0); + _Z = (m_modwritevalh == 0); - F12WriteSecondOperand(cpustate, 1); - F12END(cpustate); + F12WriteSecondOperand(1); + F12END(); } -static UINT32 opNOTW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opNOTW() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 2); - cpustate->modwritevalw=~cpustate->op1; + F12DecodeFirstOperand(&v60_device::ReadAM, 2); + m_modwritevalw=~m_op1; - cpustate->_OV = 0; - cpustate->_S = ((cpustate->modwritevalw & 0x80000000) != 0); - cpustate->_Z = (cpustate->modwritevalw == 0); + _OV = 0; + _S = ((m_modwritevalw & 0x80000000) != 0); + _Z = (m_modwritevalw == 0); - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opNOT1(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opNOT1() /* TRUSTED */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - cpustate->_CY = ((appw & (1 << cpustate->op1)) != 0); - cpustate->_Z = !(cpustate->_CY); + _CY = ((appw & (1 << m_op1)) != 0); + _Z = !(_CY); - if (cpustate->_CY) - appw &= ~(1 << cpustate->op1); + if (_CY) + appw &= ~(1 << m_op1); else - appw |= (1 << cpustate->op1); + appw |= (1 << m_op1); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opORB(v60_state *cpustate) /* TRUSTED (C too!)*/ +UINT32 v60_device::opORB() /* TRUSTED (C too!)*/ { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - ORB(appb, (UINT8)cpustate->op1); + ORB(appb, (UINT8)m_op1); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opORH(v60_state *cpustate) /* TRUSTED (C too!)*/ +UINT32 v60_device::opORH() /* TRUSTED (C too!)*/ { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - ORW(apph, (UINT16)cpustate->op1); + ORW(apph, (UINT16)m_op1); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opORW(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opORW() /* TRUSTED (C too!) */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - ORL(appw, (UINT32)cpustate->op1); + ORL(appw, (UINT32)m_op1); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opOUTB(v60_state *cpustate) +UINT32 v60_device::opOUTB() { - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 2); - cpustate->io->write_byte(cpustate->op2,(UINT8)cpustate->op1); - F12END(cpustate); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 2); + m_io->write_byte(m_op2,(UINT8)m_op1); + F12END(); } -static UINT32 opOUTH(v60_state *cpustate) +UINT32 v60_device::opOUTH() { - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 2); - cpustate->io->write_word_unaligned(cpustate->op2,(UINT16)cpustate->op1); - F12END(cpustate); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 2); + m_io->write_word_unaligned(m_op2,(UINT16)m_op1); + F12END(); } -static UINT32 opOUTW(v60_state *cpustate) +UINT32 v60_device::opOUTW() { - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); - cpustate->io->write_dword_unaligned(cpustate->op2, cpustate->op1); - F12END(cpustate); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); + m_io->write_dword_unaligned(m_op2, m_op1); + F12END(); } -static UINT32 opREMB(v60_state *cpustate) +UINT32 v60_device::opREMB() { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - cpustate->_OV = 0; - if (cpustate->op1) - appb= (INT8)appb % (INT8)cpustate->op1; - cpustate->_Z = (appb == 0); - cpustate->_S = ((appb & 0x80) != 0); + _OV = 0; + if (m_op1) + appb= (INT8)appb % (INT8)m_op1; + _Z = (appb == 0); + _S = ((appb & 0x80) != 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opREMH(v60_state *cpustate) +UINT32 v60_device::opREMH() { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - cpustate->_OV = 0; - if (cpustate->op1) - apph = (INT16)apph % (INT16)cpustate->op1; - cpustate->_Z = (apph == 0); - cpustate->_S = ((apph & 0x8000) != 0); + _OV = 0; + if (m_op1) + apph = (INT16)apph % (INT16)m_op1; + _Z = (apph == 0); + _S = ((apph & 0x8000) != 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opREMW(v60_state *cpustate) +UINT32 v60_device::opREMW() { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - cpustate->_OV = 0; - if (cpustate->op1) - appw = (INT32)appw % (INT32)cpustate->op1; - cpustate->_Z = (appw == 0); - cpustate->_S = ((appw & 0x80000000) != 0); + _OV = 0; + if (m_op1) + appw = (INT32)appw % (INT32)m_op1; + _Z = (appw == 0); + _S = ((appw & 0x80000000) != 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opREMUB(v60_state *cpustate) +UINT32 v60_device::opREMUB() { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - cpustate->_OV = 0; - if (cpustate->op1) - appb %= (UINT8)cpustate->op1; - cpustate->_Z = (appb == 0); - cpustate->_S = ((appb & 0x80) != 0); + _OV = 0; + if (m_op1) + appb %= (UINT8)m_op1; + _Z = (appb == 0); + _S = ((appb & 0x80) != 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opREMUH(v60_state *cpustate) +UINT32 v60_device::opREMUH() { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - cpustate->_OV = 0; - if (cpustate->op1) - apph %= (UINT16)cpustate->op1; - cpustate->_Z = (apph == 0); - cpustate->_S = ((apph & 0x8000) != 0); + _OV = 0; + if (m_op1) + apph %= (UINT16)m_op1; + _Z = (apph == 0); + _S = ((apph & 0x8000) != 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opREMUW(v60_state *cpustate) +UINT32 v60_device::opREMUW() { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - cpustate->_OV = 0; - if (cpustate->op1) - appw %= cpustate->op1; - cpustate->_Z = (appw == 0); - cpustate->_S = ((appw & 0x80000000) != 0); + _OV = 0; + if (m_op1) + appw %= m_op1; + _Z = (appw == 0); + _S = ((appw & 0x80000000) != 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opROTB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opROTB() /* TRUSTED */ { UINT8 appb; INT8 i, count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); if (count > 0) { for (i = 0;i < count;i++) appb = (appb << 1) | ((appb & 0x80) >> 7); - cpustate->_CY = (appb & 0x1) != 0; + _CY = (appb & 0x1) != 0; } else if (count < 0) { @@ -1378,35 +1378,35 @@ static UINT32 opROTB(v60_state *cpustate) /* TRUSTED */ for (i = 0;i < count;i++) appb = (appb >> 1) | ((appb & 0x1) << 7); - cpustate->_CY = (appb & 0x80) != 0; + _CY = (appb & 0x80) != 0; } else - cpustate->_CY = 0; + _CY = 0; - cpustate->_OV = 0; - cpustate->_S = (appb & 0x80) != 0; - cpustate->_Z = (appb == 0); + _OV = 0; + _S = (appb & 0x80) != 0; + _Z = (appb == 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opROTH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opROTH() /* TRUSTED */ { UINT16 apph; INT8 i, count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); if (count > 0) { for (i = 0;i < count;i++) apph = (apph << 1) | ((apph & 0x8000) >> 15); - cpustate->_CY = (apph & 0x1) != 0; + _CY = (apph & 0x1) != 0; } else if (count < 0) { @@ -1414,35 +1414,35 @@ static UINT32 opROTH(v60_state *cpustate) /* TRUSTED */ for (i = 0;i < count;i++) apph = (apph >> 1) | ((apph & 0x1) << 15); - cpustate->_CY = (apph & 0x8000) != 0; + _CY = (apph & 0x8000) != 0; } else - cpustate->_CY = 0; + _CY = 0; - cpustate->_OV = 0; - cpustate->_S = (apph & 0x8000) != 0; - cpustate->_Z = (apph == 0); + _OV = 0; + _S = (apph & 0x8000) != 0; + _Z = (apph == 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opROTW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opROTW() /* TRUSTED */ { UINT32 appw; INT8 i, count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); if (count > 0) { for (i = 0;i < count;i++) appw = (appw << 1) | ((appw & 0x80000000) >> 31); - cpustate->_CY = (appw & 0x1) != 0; + _CY = (appw & 0x1) != 0; } else if (count < 0) { @@ -1450,36 +1450,36 @@ static UINT32 opROTW(v60_state *cpustate) /* TRUSTED */ for (i = 0;i < count;i++) appw = (appw >> 1) | ((appw & 0x1) << 31); - cpustate->_CY = (appw & 0x80000000) != 0; + _CY = (appw & 0x80000000) != 0; } else - cpustate->_CY = 0; + _CY = 0; - cpustate->_OV = 0; - cpustate->_S = (appw & 0x80000000) != 0; - cpustate->_Z = (appw == 0); + _OV = 0; + _S = (appw & 0x80000000) != 0; + _Z = (appw == 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opROTCB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opROTCB() /* TRUSTED */ { UINT8 appb; INT8 i, cy, count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); - NORMALIZEFLAGS(cpustate); + F12LOADOP2BYTE(); + NORMALIZEFLAGS(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); if (count > 0) { for (i = 0;i < count;i++) { - cy = cpustate->_CY; - cpustate->_CY = (UINT8)((appb & 0x80) >> 7); + cy = _CY; + _CY = (UINT8)((appb & 0x80) >> 7); appb = (appb << 1) | cy; } } @@ -1488,39 +1488,39 @@ static UINT32 opROTCB(v60_state *cpustate) /* TRUSTED */ count=-count; for (i = 0;i < count;i++) { - cy = cpustate->_CY; - cpustate->_CY = (appb & 1); + cy = _CY; + _CY = (appb & 1); appb = (appb >> 1) | (cy << 7); } } else - cpustate->_CY = 0; + _CY = 0; - cpustate->_OV = 0; - cpustate->_S = (appb & 0x80) != 0; - cpustate->_Z = (appb == 0); + _OV = 0; + _S = (appb & 0x80) != 0; + _Z = (appb == 0); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opROTCH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opROTCH() /* TRUSTED */ { UINT16 apph; INT8 i, cy, count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); - NORMALIZEFLAGS(cpustate); + F12LOADOP2HALF(); + NORMALIZEFLAGS(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); if (count > 0) { for (i = 0;i < count;i++) { - cy = cpustate->_CY; - cpustate->_CY = (UINT8)((apph & 0x8000) >> 15); + cy = _CY; + _CY = (UINT8)((apph & 0x8000) >> 15); apph = (apph << 1) | cy; } } @@ -1529,39 +1529,39 @@ static UINT32 opROTCH(v60_state *cpustate) /* TRUSTED */ count=-count; for (i = 0;i < count;i++) { - cy = cpustate->_CY; - cpustate->_CY = (UINT8)(apph & 1); + cy = _CY; + _CY = (UINT8)(apph & 1); apph = (apph >> 1) | ((UINT16)cy << 15); } } else - cpustate->_CY = 0; + _CY = 0; - cpustate->_OV = 0; - cpustate->_S = (apph & 0x8000) != 0; - cpustate->_Z = (apph == 0); + _OV = 0; + _S = (apph & 0x8000) != 0; + _Z = (apph == 0); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opROTCW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opROTCW() /* TRUSTED */ { UINT32 appw; INT8 i, cy, count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); - NORMALIZEFLAGS(cpustate); + F12LOADOP2WORD(); + NORMALIZEFLAGS(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); if (count > 0) { for (i = 0;i < count;i++) { - cy = cpustate->_CY; - cpustate->_CY = (UINT8)((appw & 0x80000000) >> 31); + cy = _CY; + _CY = (UINT8)((appw & 0x80000000) >> 31); appw = (appw << 1) | cy; } } @@ -1570,146 +1570,146 @@ static UINT32 opROTCW(v60_state *cpustate) /* TRUSTED */ count=-count; for (i = 0;i < count;i++) { - cy = cpustate->_CY; - cpustate->_CY = (UINT8)(appw & 1); + cy = _CY; + _CY = (UINT8)(appw & 1); appw = (appw >> 1) | ((UINT32)cy << 31); } } else - cpustate->_CY = 0; + _CY = 0; - cpustate->_OV = 0; - cpustate->_S = (appw & 0x80000000) != 0; - cpustate->_Z = (appw == 0); + _OV = 0; + _S = (appw & 0x80000000) != 0; + _Z = (appw == 0); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opRVBIT(v60_state *cpustate) +UINT32 v60_device::opRVBIT() { - F12DecodeFirstOperand(cpustate, ReadAM, 0); + F12DecodeFirstOperand(&v60_device::ReadAM, 0); - cpustate->modwritevalb =(UINT8) - (((cpustate->op1 & (1 << 0)) << 7) | - ((cpustate->op1 & (1 << 1)) << 5) | - ((cpustate->op1 & (1 << 2)) << 3) | - ((cpustate->op1 & (1 << 3)) << 1) | - ((cpustate->op1 & (1 << 4)) >> 1) | - ((cpustate->op1 & (1 << 5)) >> 3) | - ((cpustate->op1 & (1 << 6)) >> 5) | - ((cpustate->op1 & (1 << 7)) >> 7)); + m_modwritevalb =(UINT8) + (((m_op1 & (1 << 0)) << 7) | + ((m_op1 & (1 << 1)) << 5) | + ((m_op1 & (1 << 2)) << 3) | + ((m_op1 & (1 << 3)) << 1) | + ((m_op1 & (1 << 4)) >> 1) | + ((m_op1 & (1 << 5)) >> 3) | + ((m_op1 & (1 << 6)) >> 5) | + ((m_op1 & (1 << 7)) >> 7)); - F12WriteSecondOperand(cpustate, 0); - F12END(cpustate); + F12WriteSecondOperand(0); + F12END(); } -static UINT32 opRVBYT(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opRVBYT() /* TRUSTED */ { - F12DecodeFirstOperand(cpustate, ReadAM, 2); + F12DecodeFirstOperand(&v60_device::ReadAM, 2); - cpustate->modwritevalw = ((cpustate->op1 & 0x000000FF) << 24) | - ((cpustate->op1 & 0x0000FF00) << 8) | - ((cpustate->op1 & 0x00FF0000) >> 8) | - ((cpustate->op1 & 0xFF000000) >> 24); + m_modwritevalw = ((m_op1 & 0x000000FF) << 24) | + ((m_op1 & 0x0000FF00) << 8) | + ((m_op1 & 0x00FF0000) >> 8) | + ((m_op1 & 0xFF000000) >> 24); - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opSET1(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opSET1() /* TRUSTED */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - cpustate->_CY = ((appw & (1 << cpustate->op1)) != 0); - cpustate->_Z = !(cpustate->_CY); + _CY = ((appw & (1 << m_op1)) != 0); + _Z = !(_CY); - appw |= (1 << cpustate->op1); + appw |= (1 << m_op1); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opSETF(v60_state *cpustate) +UINT32 v60_device::opSETF() { - F12DecodeFirstOperand(cpustate, ReadAM, 0); + F12DecodeFirstOperand(&v60_device::ReadAM, 0); // Normalize the flags - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - switch (cpustate->op1 & 0xF) + switch (m_op1 & 0xF) { case 0: - if (!cpustate->_OV) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (!_OV) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 1: - if (cpustate->_OV) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (_OV) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 2: - if (!cpustate->_CY) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (!_CY) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 3: - if (cpustate->_CY) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (_CY) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 4: - if (!cpustate->_Z) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (!_Z) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 5: - if (cpustate->_Z) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (_Z) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 6: - if (!(cpustate->_CY | cpustate->_Z)) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (!(_CY | _Z)) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 7: - if ((cpustate->_CY | cpustate->_Z)) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if ((_CY | _Z)) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 8: - if (!cpustate->_S) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (!_S) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 9: - if (cpustate->_S) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (_S) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 10: - cpustate->modwritevalb = 1; + m_modwritevalb = 1; break; case 11: - cpustate->modwritevalb = 0; + m_modwritevalb = 0; break; case 12: - if (!(cpustate->_S^cpustate->_OV)) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (!(_S^_OV)) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 13: - if ((cpustate->_S^cpustate->_OV)) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if ((_S^_OV)) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 14: - if (!((cpustate->_S^cpustate->_OV)|cpustate->_Z)) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (!((_S^_OV)|_Z)) m_modwritevalb = 0; + else m_modwritevalb = 1; break; case 15: - if (((cpustate->_S^cpustate->_OV)|cpustate->_Z)) cpustate->modwritevalb = 0; - else cpustate->modwritevalb = 1; + if (((_S^_OV)|_Z)) m_modwritevalb = 0; + else m_modwritevalb = 1; break; } - F12WriteSecondOperand(cpustate, 0); + F12WriteSecondOperand(0); - F12END(cpustate); + F12END(); } /* @@ -1719,8 +1719,8 @@ static UINT32 opSETF(v60_state *cpustate) tmp <<= count; \ tmp -= 1; \ tmp <<= (bitsize - (count)); \ - cpustate->_OV = (((val) & tmp) != tmp); \ - cpustate->_CY = (((val) & (1 << (count - 1))) != 0); \ + _OV = (((val) & tmp) != tmp); \ + _CY = (((val) & (1 << (count - 1))) != 0); \ } */ @@ -1734,39 +1734,39 @@ static UINT32 opSETF(v60_state *cpustate) tmp = ((1 << (count)) - 1); \ tmp <<= (bitsize - (count)); \ if (((val) >> (bitsize - 1)) & 1) \ - cpustate->_OV = (((val) & tmp) != tmp); \ + _OV = (((val) & tmp) != tmp); \ else \ - cpustate->_OV = (((val) & tmp) != 0); \ + _OV = (((val) & tmp) != 0); \ } #define SHIFTLEFT_CY(val, count, bitsize) \ - cpustate->_CY = (UINT8)(((val) >> (bitsize - count)) & 1); + _CY = (UINT8)(((val) >> (bitsize - count)) & 1); #define SHIFTARITHMETICRIGHT_OV(val, count, bitsize) \ - cpustate->_OV = 0; + _OV = 0; #define SHIFTARITHMETICRIGHT_CY(val, count, bitsize) \ - cpustate->_CY = (UINT8)(((val) >> (count - 1)) & 1); + _CY = (UINT8)(((val) >> (count - 1)) & 1); -static UINT32 opSHAB(v60_state *cpustate) +UINT32 v60_device::opSHAB() { UINT8 appb; INT8 count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); // Special case: destination unchanged, flags set if (count == 0) { - cpustate->_CY = cpustate->_OV = 0; + _CY = _OV = 0; SetSZPF_Byte(appb); } else if (count > 0) @@ -1800,27 +1800,27 @@ static UINT32 opSHAB(v60_state *cpustate) SetSZPF_Byte(appb); } -// mame_printf_debug("SHAB: %x cpustate->_CY: %d cpustate->_Z: %d cpustate->_OV: %d cpustate->_S: %d\n", appb, cpustate->_CY, cpustate->_Z, cpustate->_OV, cpustate->_S); +// mame_printf_debug("SHAB: %x _CY: %d _Z: %d _OV: %d _S: %d\n", appb, _CY, _Z, _OV, _S); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opSHAH(v60_state *cpustate) +UINT32 v60_device::opSHAH() { UINT16 apph; INT8 count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); // Special case: destination unchanged, flags set if (count == 0) { - cpustate->_CY = cpustate->_OV = 0; + _CY = _OV = 0; SetSZPF_Word(apph); } else if (count > 0) @@ -1854,27 +1854,27 @@ static UINT32 opSHAH(v60_state *cpustate) SetSZPF_Word(apph); } -// mame_printf_debug("SHAH: %x >> %d = %x cpustate->_CY: %d cpustate->_Z: %d cpustate->_OV: %d cpustate->_S: %d\n", oldval, count, apph, cpustate->_CY, cpustate->_Z, cpustate->_OV, cpustate->_S); +// mame_printf_debug("SHAH: %x >> %d = %x _CY: %d _Z: %d _OV: %d _S: %d\n", oldval, count, apph, _CY, _Z, _OV, _S); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opSHAW(v60_state *cpustate) +UINT32 v60_device::opSHAW() { UINT32 appw; INT8 count; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); // Special case: destination unchanged, flags set if (count == 0) { - cpustate->_CY = cpustate->_OV = 0; + _CY = _OV = 0; SetSZPF_Long(appw); } else if (count > 0) @@ -1908,31 +1908,31 @@ static UINT32 opSHAW(v60_state *cpustate) SetSZPF_Long(appw); } -// mame_printf_debug("SHAW: %x >> %d = %x cpustate->_CY: %d cpustate->_Z: %d cpustate->_OV: %d cpustate->_S: %d\n", oldval, count, appw, cpustate->_CY, cpustate->_Z, cpustate->_OV, cpustate->_S); +// mame_printf_debug("SHAW: %x >> %d = %x _CY: %d _Z: %d _OV: %d _S: %d\n", oldval, count, appw, _CY, _Z, _OV, _S); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opSHLB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opSHLB() /* TRUSTED */ { UINT8 appb; INT8 count; UINT32 tmp; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); if (count > 0) { // left shift flags: // carry gets the last bit shifted out, // overflow is always CLEARed - cpustate->_OV = 0; // default to no overflow + _OV = 0; // default to no overflow // now handle carry tmp = appb & 0xff; @@ -1950,7 +1950,7 @@ static UINT32 opSHLB(v60_state *cpustate) /* TRUSTED */ if (count == 0) { // special case: clear carry and overflow, do nothing else - cpustate->_CY = cpustate->_OV = 0; + _CY = _OV = 0; SetSZPF_Byte(appb); // doc. is unclear if this is true... } else @@ -1960,31 +1960,31 @@ static UINT32 opSHLB(v60_state *cpustate) /* TRUSTED */ // overflow always cleared tmp = appb & 0xff; tmp >>= ((-count) - 1); - cpustate->_CY = (UINT8)(tmp & 0x1); - cpustate->_OV = 0; + _CY = (UINT8)(tmp & 0x1); + _OV = 0; appb >>= -count; SetSZPF_Byte(appb); } } -// mame_printf_debug("SHLB: %x cpustate->_CY: %d cpustate->_Z: %d cpustate->_OV: %d cpustate->_S: %d\n", appb, cpustate->_CY, cpustate->_Z, cpustate->_OV, cpustate->_S); +// mame_printf_debug("SHLB: %x _CY: %d _Z: %d _OV: %d _S: %d\n", appb, _CY, _Z, _OV, _S); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opSHLH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opSHLH() /* TRUSTED */ { UINT16 apph; INT8 count; UINT32 tmp; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); // mame_printf_debug("apph: %x count: %d ", apph, count); if (count > 0) { @@ -1992,7 +1992,7 @@ static UINT32 opSHLH(v60_state *cpustate) /* TRUSTED */ // carry gets the last bit shifted out, // overflow is always CLEARed - cpustate->_OV = 0; + _OV = 0; // now handle carry tmp = apph & 0xffff; @@ -2010,7 +2010,7 @@ static UINT32 opSHLH(v60_state *cpustate) /* TRUSTED */ if (count == 0) { // special case: clear carry and overflow, do nothing else - cpustate->_CY = cpustate->_OV = 0; + _CY = _OV = 0; SetSZPF_Word(apph); // doc. is unclear if this is true... } else @@ -2020,38 +2020,38 @@ static UINT32 opSHLH(v60_state *cpustate) /* TRUSTED */ // overflow always cleared tmp = apph & 0xffff; tmp >>= ((-count) - 1); - cpustate->_CY = (UINT8)(tmp & 0x1); - cpustate->_OV = 0; + _CY = (UINT8)(tmp & 0x1); + _OV = 0; apph >>= -count; SetSZPF_Word(apph); } } -// mame_printf_debug("SHLH: %x cpustate->_CY: %d cpustate->_Z: %d cpustate->_OV: %d cpustate->_S: %d\n", apph, cpustate->_CY, cpustate->_Z, cpustate->_OV, cpustate->_S); +// mame_printf_debug("SHLH: %x _CY: %d _Z: %d _OV: %d _S: %d\n", apph, _CY, _Z, _OV, _S); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opSHLW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opSHLW() /* TRUSTED */ { UINT32 appw; INT8 count; UINT64 tmp; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - count = (INT8)(cpustate->op1 & 0xFF); + count = (INT8)(m_op1 & 0xFF); if (count > 0) { // left shift flags: // carry gets the last bit shifted out, // overflow is always CLEARed - cpustate->_OV = 0; + _OV = 0; // now handle carry tmp = appw & 0xffffffff; @@ -2069,7 +2069,7 @@ static UINT32 opSHLW(v60_state *cpustate) /* TRUSTED */ if (count == 0) { // special case: clear carry and overflow, do nothing else - cpustate->_CY = cpustate->_OV = 0; + _CY = _OV = 0; SetSZPF_Long(appw); // doc. is unclear if this is true... } else @@ -2079,313 +2079,313 @@ static UINT32 opSHLW(v60_state *cpustate) /* TRUSTED */ // overflow always cleared tmp = (UINT64)(appw & 0xffffffff); tmp >>= ((-count) - 1); - cpustate->_CY = (UINT8)(tmp & 0x1); - cpustate->_OV = 0; + _CY = (UINT8)(tmp & 0x1); + _OV = 0; appw >>= -count; SetSZPF_Long(appw); } } -// mame_printf_debug("SHLW: %x cpustate->_CY: %d cpustate->_Z: %d cpustate->_OV: %d cpustate->_S: %d\n", appw, cpustate->_CY, cpustate->_Z, cpustate->_OV, cpustate->_S); +// mame_printf_debug("SHLW: %x _CY: %d _Z: %d _OV: %d _S: %d\n", appw, _CY, _Z, _OV, _S); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opSTPR(v60_state *cpustate) +UINT32 v60_device::opSTPR() { - F12DecodeFirstOperand(cpustate, ReadAM, 2); - if (cpustate->op1 <= 28) - cpustate->modwritevalw = cpustate->reg[cpustate->op1 + 36]; + F12DecodeFirstOperand(&v60_device::ReadAM, 2); + if (m_op1 <= 28) + m_modwritevalw = m_reg[m_op1 + 36]; else { - fatalerror("Invalid operand on STPR cpustate->PC=%x\n", cpustate->PC); + fatalerror("Invalid operand on STPR PC=%x\n", PC); } - F12WriteSecondOperand(cpustate, 2); - F12END(cpustate); + F12WriteSecondOperand(2); + F12END(); } -static UINT32 opSUBB(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opSUBB() /* TRUSTED (C too!) */ { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - SUBB(appb, (UINT8)cpustate->op1); + SUBB(appb, (UINT8)m_op1); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opSUBH(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opSUBH() /* TRUSTED (C too!) */ { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - SUBW(apph, (UINT16)cpustate->op1); + SUBW(apph, (UINT16)m_op1); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opSUBW(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opSUBW() /* TRUSTED (C too!) */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - SUBL(appw, (UINT32)cpustate->op1); + SUBL(appw, (UINT32)m_op1); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opSUBCB(v60_state *cpustate) +UINT32 v60_device::opSUBCB() { UINT8 appb; UINT8 src; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - src = (UINT8)cpustate->op1 + (cpustate->_CY?1:0); + src = (UINT8)m_op1 + (_CY?1:0); SUBB(appb, src); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opSUBCH(v60_state *cpustate) +UINT32 v60_device::opSUBCH() { UINT16 apph; UINT16 src; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - src = (UINT16)cpustate->op1 + (cpustate->_CY?1:0); + src = (UINT16)m_op1 + (_CY?1:0); SUBW(apph, src); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opSUBCW(v60_state *cpustate) +UINT32 v60_device::opSUBCW() { UINT32 appw; UINT32 src; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - src = (UINT32)cpustate->op1 + (cpustate->_CY?1:0); + src = (UINT32)m_op1 + (_CY?1:0); SUBL(appw, src); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opTEST1(v60_state *cpustate) +UINT32 v60_device::opTEST1() { - F12DecodeOperands(cpustate, ReadAM, 2,ReadAM, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAM, 2); - cpustate->_CY = ((cpustate->op2 & (1 << cpustate->op1)) != 0); - cpustate->_Z = !(cpustate->_CY); + _CY = ((m_op2 & (1 << m_op1)) != 0); + _Z = !(_CY); - F12END(cpustate); + F12END(); } -static UINT32 opUPDPSWW(v60_state *cpustate) +UINT32 v60_device::opUPDPSWW() { - F12DecodeOperands(cpustate, ReadAM, 2,ReadAM, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAM, 2); /* can only modify condition code and control fields */ - cpustate->op2 &= 0xFFFFFF; - cpustate->op1 &= 0xFFFFFF; - v60WritePSW(cpustate, (v60ReadPSW(cpustate) & (~cpustate->op2)) | (cpustate->op1 & cpustate->op2)); + m_op2 &= 0xFFFFFF; + m_op1 &= 0xFFFFFF; + v60WritePSW((v60ReadPSW() & (~m_op2)) | (m_op1 & m_op2)); - F12END(cpustate); + F12END(); } -static UINT32 opUPDPSWH(v60_state *cpustate) +UINT32 v60_device::opUPDPSWH() { - F12DecodeOperands(cpustate, ReadAM, 2,ReadAM, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAM, 2); /* can only modify condition code fields */ - cpustate->op2 &= 0xFFFF; - cpustate->op1 &= 0xFFFF; - v60WritePSW(cpustate, (v60ReadPSW(cpustate) & (~cpustate->op2)) | (cpustate->op1 & cpustate->op2)); + m_op2 &= 0xFFFF; + m_op1 &= 0xFFFF; + v60WritePSW((v60ReadPSW() & (~m_op2)) | (m_op1 & m_op2)); - F12END(cpustate); + F12END(); } -static UINT32 opXCHB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opXCHB() /* TRUSTED */ { UINT8 appb, temp; - F12DecodeOperands(cpustate, ReadAMAddress, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAMAddress, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP1BYTE(cpustate); + F12LOADOP1BYTE(); temp = appb; - F12LOADOP2BYTE(cpustate); - F12STOREOP1BYTE(cpustate); + F12LOADOP2BYTE(); + F12STOREOP1BYTE(); appb = temp; - F12STOREOP2BYTE(cpustate); + F12STOREOP2BYTE(); - F12END(cpustate) + F12END() } -static UINT32 opXCHH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opXCHH() /* TRUSTED */ { UINT16 apph, temp; - F12DecodeOperands(cpustate, ReadAMAddress, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAMAddress, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP1HALF(cpustate); + F12LOADOP1HALF(); temp = apph; - F12LOADOP2HALF(cpustate); - F12STOREOP1HALF(cpustate); + F12LOADOP2HALF(); + F12STOREOP1HALF(); apph = temp; - F12STOREOP2HALF(cpustate); + F12STOREOP2HALF(); - F12END(cpustate) + F12END() } -static UINT32 opXCHW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opXCHW() /* TRUSTED */ { UINT32 appw, temp; - F12DecodeOperands(cpustate, ReadAMAddress, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAMAddress, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP1WORD(cpustate); + F12LOADOP1WORD(); temp = appw; - F12LOADOP2WORD(cpustate); - F12STOREOP1WORD(cpustate); + F12LOADOP2WORD(); + F12STOREOP1WORD(); appw = temp; - F12STOREOP2WORD(cpustate); + F12STOREOP2WORD(); - F12END(cpustate) + F12END() } -static UINT32 opXORB(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opXORB() /* TRUSTED (C too!) */ { UINT8 appb; - F12DecodeOperands(cpustate, ReadAM, 0,ReadAMAddress, 0); + F12DecodeOperands(&v60_device::ReadAM, 0,&v60_device::ReadAMAddress, 0); - F12LOADOP2BYTE(cpustate); + F12LOADOP2BYTE(); - XORB(appb, (UINT8)cpustate->op1); + XORB(appb, (UINT8)m_op1); - F12STOREOP2BYTE(cpustate); - F12END(cpustate); + F12STOREOP2BYTE(); + F12END(); } -static UINT32 opXORH(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opXORH() /* TRUSTED (C too!) */ { UINT16 apph; - F12DecodeOperands(cpustate, ReadAM, 1,ReadAMAddress, 1); + F12DecodeOperands(&v60_device::ReadAM, 1,&v60_device::ReadAMAddress, 1); - F12LOADOP2HALF(cpustate); + F12LOADOP2HALF(); - XORW(apph, (UINT16)cpustate->op1); + XORW(apph, (UINT16)m_op1); - F12STOREOP2HALF(cpustate); - F12END(cpustate); + F12STOREOP2HALF(); + F12END(); } -static UINT32 opXORW(v60_state *cpustate) /* TRUSTED (C too!) */ +UINT32 v60_device::opXORW() /* TRUSTED (C too!) */ { UINT32 appw; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 2); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 2); - F12LOADOP2WORD(cpustate); + F12LOADOP2WORD(); - XORL(appw, (UINT32)cpustate->op1); + XORL(appw, (UINT32)m_op1); - F12STOREOP2WORD(cpustate); - F12END(cpustate); + F12STOREOP2WORD(); + F12END(); } -static UINT32 opMULX(v60_state *cpustate) +UINT32 v60_device::opMULX() { INT32 a, b; INT64 res; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 3); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 3); - if (cpustate->flag2) + if (m_flag2) { - a = cpustate->reg[cpustate->op2 & 0x1F]; + a = m_reg[m_op2 & 0x1F]; } else { - a = cpustate->program->read_dword_unaligned(cpustate->op2); + a = m_program->read_dword_unaligned(m_op2); } - res = (INT64)a * (INT64)(INT32)cpustate->op1; + res = (INT64)a * (INT64)(INT32)m_op1; b = (INT32)((res >> 32)&0xffffffff); a = (INT32)(res & 0xffffffff); - cpustate->_S = ((b & 0x80000000) != 0); - cpustate->_Z = (a == 0 && b == 0); + _S = ((b & 0x80000000) != 0); + _Z = (a == 0 && b == 0); - if (cpustate->flag2) + if (m_flag2) { - cpustate->reg[cpustate->op2 & 0x1F] = a; - cpustate->reg[(cpustate->op2 & 0x1F) + 1] = b; + m_reg[m_op2 & 0x1F] = a; + m_reg[(m_op2 & 0x1F) + 1] = b; } else { - cpustate->program->write_dword_unaligned(cpustate->op2, a); - cpustate->program->write_dword_unaligned(cpustate->op2 + 4, b); + m_program->write_dword_unaligned(m_op2, a); + m_program->write_dword_unaligned(m_op2 + 4, b); } - F12END(cpustate); + F12END(); } -static UINT32 opMULUX(v60_state *cpustate) +UINT32 v60_device::opMULUX() { INT32 a, b; UINT64 res; - F12DecodeOperands(cpustate, ReadAM, 2,ReadAMAddress, 3); + F12DecodeOperands(&v60_device::ReadAM, 2,&v60_device::ReadAMAddress, 3); - if (cpustate->flag2) + if (m_flag2) { - a = cpustate->reg[cpustate->op2 & 0x1F]; + a = m_reg[m_op2 & 0x1F]; } else { - a = cpustate->program->read_dword_unaligned(cpustate->op2); + a = m_program->read_dword_unaligned(m_op2); } - res = (UINT64)a * (UINT64)cpustate->op1; + res = (UINT64)a * (UINT64)m_op1; b = (INT32)((res >> 32)&0xffffffff); a = (INT32)(res & 0xffffffff); - cpustate->_S = ((b & 0x80000000) != 0); - cpustate->_Z = (a == 0 && b == 0); + _S = ((b & 0x80000000) != 0); + _Z = (a == 0 && b == 0); - if (cpustate->flag2) + if (m_flag2) { - cpustate->reg[cpustate->op2 & 0x1F] = a; - cpustate->reg[(cpustate->op2 & 0x1F) + 1] = b; + m_reg[m_op2 & 0x1F] = a; + m_reg[(m_op2 & 0x1F) + 1] = b; } else { - cpustate->program->write_dword_unaligned(cpustate->op2, a); - cpustate->program->write_dword_unaligned(cpustate->op2 + 4, b); + m_program->write_dword_unaligned(m_op2, a); + m_program->write_dword_unaligned(m_op2 + 4, b); } - F12END(cpustate); + F12END(); } diff --git a/src/emu/cpu/v60/op2.c b/src/emu/cpu/v60/op2.c index defb328e425..9b4a945e869 100644 --- a/src/emu/cpu/v60/op2.c +++ b/src/emu/cpu/v60/op2.c @@ -1,353 +1,353 @@ -#define F2END(cs) \ - return 2 + (cs)->amlength1 + (cs)->amlength2; +#define F2END() \ + return 2 + m_amlength1 + m_amlength2; -#define F2LOADOPFLOAT(cs, num) \ - if ((cs)->flag##num) \ - appf = u2f((cs)->reg[(cs)->op##num]); \ +#define F2LOADOPFLOAT(num) \ + if (m_flag##num) \ + appf = u2f(m_reg[m_op##num]); \ else \ - appf = u2f((cs)->program->read_dword_unaligned((cs)->op##num)); + appf = u2f(m_program->read_dword_unaligned(m_op##num)); -#define F2STOREOPFLOAT(cs,num) \ - if ((cs)->flag##num) \ - (cs)->reg[(cs)->op##num] = f2u(appf); \ +#define F2STOREOPFLOAT(num) \ + if (m_flag##num) \ + m_reg[m_op##num] = f2u(appf); \ else \ - (cs)->program->write_dword_unaligned((cs)->op##num, f2u(appf)); + m_program->write_dword_unaligned(m_op##num, f2u(appf)); -static void F2DecodeFirstOperand(v60_state *cpustate, UINT32 (*DecodeOp1)(v60_state *), UINT8 dim1) +void v60_device::F2DecodeFirstOperand(am_func DecodeOp1, UINT8 dim1) { - cpustate->moddim = dim1; - cpustate->modm = cpustate->instflags & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->amlength1 = DecodeOp1(cpustate); - cpustate->op1 = cpustate->amout; - cpustate->flag1 = cpustate->amflag; + m_moddim = dim1; + m_modm = m_instflags & 0x40; + m_modadd = PC + 2; + m_amlength1 = (this->*DecodeOp1)(); + m_op1 = m_amout; + m_flag1 = m_amflag; } -static void F2DecodeSecondOperand(v60_state *cpustate, UINT32 (*DecodeOp2)(v60_state *), UINT8 dim2) +void v60_device::F2DecodeSecondOperand(am_func DecodeOp2, UINT8 dim2) { - cpustate->moddim = dim2; - cpustate->modm = cpustate->instflags & 0x20; - cpustate->modadd = cpustate->PC + 2 + cpustate->amlength1; - cpustate->amlength2 = DecodeOp2(cpustate); - cpustate->op2 = cpustate->amout; - cpustate->flag2 = cpustate->amflag; + m_moddim = dim2; + m_modm = m_instflags & 0x20; + m_modadd = PC + 2 + m_amlength1; + m_amlength2 = (this->*DecodeOp2)(); + m_op2 = m_amout; + m_flag2 = m_amflag; } -static void F2WriteSecondOperand(v60_state *cpustate, UINT8 dim2) +void v60_device::F2WriteSecondOperand(UINT8 dim2) { - cpustate->moddim = dim2; - cpustate->modm = cpustate->instflags & 0x20; - cpustate->modadd = cpustate->PC + 2 + cpustate->amlength1; - cpustate->amlength2 = WriteAM(cpustate); + m_moddim = dim2; + m_modm = m_instflags & 0x20; + m_modadd = PC + 2 + m_amlength1; + m_amlength2 = WriteAM(); } -static UINT32 opCVTWS(v60_state *cpustate) +UINT32 v60_device::opCVTWS() { float val; - F2DecodeFirstOperand(cpustate, ReadAM, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); // Convert to float - val = (float)(INT32)cpustate->op1; - cpustate->modwritevalw = f2u(val); + val = (float)(INT32)m_op1; + m_modwritevalw = f2u(val); - cpustate->_OV = 0; - cpustate->_CY = (val < 0.0f); - cpustate->_S = ((cpustate->modwritevalw & 0x80000000) != 0); - cpustate->_Z = (val == 0.0f); + _OV = 0; + _CY = (val < 0.0f); + _S = ((m_modwritevalw & 0x80000000) != 0); + _Z = (val == 0.0f); - F2WriteSecondOperand(cpustate, 2); - F2END(cpustate); + F2WriteSecondOperand(2); + F2END(); } -static UINT32 opCVTSW(v60_state *cpustate) +UINT32 v60_device::opCVTSW() { float val; - F2DecodeFirstOperand(cpustate, ReadAM, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); // Convert to UINT32 - val = u2f(cpustate->op1); - cpustate->modwritevalw = (UINT32)val; + val = u2f(m_op1); + m_modwritevalw = (UINT32)val; - cpustate->_OV = 0; - cpustate->_CY =(val < 0.0f); - cpustate->_S = ((cpustate->modwritevalw & 0x80000000) != 0); - cpustate->_Z = (val == 0.0f); + _OV = 0; + _CY =(val < 0.0f); + _S = ((m_modwritevalw & 0x80000000) != 0); + _Z = (val == 0.0f); - F2WriteSecondOperand(cpustate, 2); - F2END(cpustate); + F2WriteSecondOperand(2); + F2END(); } -static UINT32 opMOVFS(v60_state *cpustate) +UINT32 v60_device::opMOVFS() { - F2DecodeFirstOperand(cpustate, ReadAM, 2); - cpustate->modwritevalw = cpustate->op1; - F2WriteSecondOperand(cpustate, 2); - F2END(cpustate); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); + m_modwritevalw = m_op1; + F2WriteSecondOperand(2); + F2END(); } -static UINT32 opNEGFS(v60_state *cpustate) +UINT32 v60_device::opNEGFS() { float appf; - F2DecodeFirstOperand(cpustate, ReadAM, 2); - F2DecodeSecondOperand(cpustate, ReadAMAddress, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); + F2DecodeSecondOperand(&v60_device::ReadAMAddress, 2); - appf = -u2f(cpustate->op1); + appf = -u2f(m_op1); - cpustate->_OV = 0; - cpustate->_CY = (appf < 0.0f); - cpustate->_S = ((f2u(appf) & 0x80000000) != 0); - cpustate->_Z = (appf == 0.0f); + _OV = 0; + _CY = (appf < 0.0f); + _S = ((f2u(appf) & 0x80000000) != 0); + _Z = (appf == 0.0f); - F2STOREOPFLOAT(cpustate, 2); - F2END(cpustate) + F2STOREOPFLOAT(2); + F2END() } -static UINT32 opABSFS(v60_state *cpustate) +UINT32 v60_device::opABSFS() { float appf; - F2DecodeFirstOperand(cpustate, ReadAM, 2); - F2DecodeSecondOperand(cpustate, ReadAMAddress, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); + F2DecodeSecondOperand(&v60_device::ReadAMAddress, 2); - appf = u2f(cpustate->op1); + appf = u2f(m_op1); if(appf < 0) appf = -appf; - cpustate->_OV = 0; - cpustate->_CY = 0; - cpustate->_S = ((f2u(appf) & 0x80000000) != 0); - cpustate->_Z = (appf == 0.0f); + _OV = 0; + _CY = 0; + _S = ((f2u(appf) & 0x80000000) != 0); + _Z = (appf == 0.0f); - F2STOREOPFLOAT(cpustate, 2); - F2END(cpustate) + F2STOREOPFLOAT(2); + F2END() } -static UINT32 opADDFS(v60_state *cpustate) +UINT32 v60_device::opADDFS() { UINT32 appw; float appf; - F2DecodeFirstOperand(cpustate, ReadAM, 2); - F2DecodeSecondOperand(cpustate, ReadAMAddress, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); + F2DecodeSecondOperand(&v60_device::ReadAMAddress, 2); - F2LOADOPFLOAT(cpustate, 2); + F2LOADOPFLOAT(2); - appf += u2f(cpustate->op1); + appf += u2f(m_op1); appw = f2u(appf); - cpustate->_OV = cpustate->_CY = 0; - cpustate->_S = ((appw & 0x80000000) != 0); - cpustate->_Z = (appw == 0); + _OV = _CY = 0; + _S = ((appw & 0x80000000) != 0); + _Z = (appw == 0); - F2STOREOPFLOAT(cpustate, 2); - F2END(cpustate) + F2STOREOPFLOAT(2); + F2END() } -static UINT32 opSUBFS(v60_state *cpustate) +UINT32 v60_device::opSUBFS() { UINT32 appw; float appf; - F2DecodeFirstOperand(cpustate, ReadAM, 2); - F2DecodeSecondOperand(cpustate, ReadAMAddress, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); + F2DecodeSecondOperand(&v60_device::ReadAMAddress, 2); - F2LOADOPFLOAT(cpustate, 2); + F2LOADOPFLOAT(2); - appf -= u2f(cpustate->op1); + appf -= u2f(m_op1); appw = f2u(appf); - cpustate->_OV = cpustate->_CY = 0; - cpustate->_S = ((appw & 0x80000000) != 0); - cpustate->_Z = (appw == 0); + _OV = _CY = 0; + _S = ((appw & 0x80000000) != 0); + _Z = (appw == 0); - F2STOREOPFLOAT(cpustate, 2); - F2END(cpustate) + F2STOREOPFLOAT(2); + F2END() } -static UINT32 opMULFS(v60_state *cpustate) +UINT32 v60_device::opMULFS() { UINT32 appw; float appf; - F2DecodeFirstOperand(cpustate, ReadAM, 2); - F2DecodeSecondOperand(cpustate, ReadAMAddress, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); + F2DecodeSecondOperand(&v60_device::ReadAMAddress, 2); - F2LOADOPFLOAT(cpustate, 2); + F2LOADOPFLOAT(2); - appf *= u2f(cpustate->op1); + appf *= u2f(m_op1); appw = f2u(appf); - cpustate->_OV = cpustate->_CY = 0; - cpustate->_S = ((appw & 0x80000000) != 0); - cpustate->_Z = (appw == 0); + _OV = _CY = 0; + _S = ((appw & 0x80000000) != 0); + _Z = (appw == 0); - F2STOREOPFLOAT(cpustate, 2); - F2END(cpustate) + F2STOREOPFLOAT(2); + F2END() } -static UINT32 opDIVFS(v60_state *cpustate) +UINT32 v60_device::opDIVFS() { UINT32 appw; float appf; - F2DecodeFirstOperand(cpustate, ReadAM, 2); - F2DecodeSecondOperand(cpustate, ReadAMAddress, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); + F2DecodeSecondOperand(&v60_device::ReadAMAddress, 2); - F2LOADOPFLOAT(cpustate, 2); + F2LOADOPFLOAT(2); - appf /= u2f(cpustate->op1); + appf /= u2f(m_op1); appw = f2u(appf); - cpustate->_OV = cpustate->_CY = 0; - cpustate->_S = ((appw & 0x80000000) != 0); - cpustate->_Z = (appw == 0); + _OV = _CY = 0; + _S = ((appw & 0x80000000) != 0); + _Z = (appw == 0); - F2STOREOPFLOAT(cpustate, 2); - F2END(cpustate) + F2STOREOPFLOAT(2); + F2END() } -static UINT32 opSCLFS(v60_state *cpustate) +UINT32 v60_device::opSCLFS() { UINT32 appw; float appf; - F2DecodeFirstOperand(cpustate, ReadAM, 1); - F2DecodeSecondOperand(cpustate, ReadAMAddress, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 1); + F2DecodeSecondOperand(&v60_device::ReadAMAddress, 2); - F2LOADOPFLOAT(cpustate, 2); + F2LOADOPFLOAT(2); - if ((INT16)cpustate->op1 < 0) - appf /= 1 << -(INT16)cpustate->op1; + if ((INT16)m_op1 < 0) + appf /= 1 << -(INT16)m_op1; else - appf *= 1 << cpustate->op1; + appf *= 1 << m_op1; appw = f2u(appf); - cpustate->_OV = cpustate->_CY = 0; - cpustate->_S = ((appw & 0x80000000) != 0); - cpustate->_Z = (appw == 0); + _OV = _CY = 0; + _S = ((appw & 0x80000000) != 0); + _Z = (appw == 0); - F2STOREOPFLOAT(cpustate, 2); - F2END(cpustate) + F2STOREOPFLOAT(2); + F2END() } -static UINT32 opCMPF(v60_state *cpustate) +UINT32 v60_device::opCMPF() { float appf; - F2DecodeFirstOperand(cpustate, ReadAM, 2); - F2DecodeSecondOperand(cpustate, ReadAM, 2); + F2DecodeFirstOperand(&v60_device::ReadAM, 2); + F2DecodeSecondOperand(&v60_device::ReadAM, 2); - appf = u2f(cpustate->op2) - u2f(cpustate->op1); + appf = u2f(m_op2) - u2f(m_op1); - cpustate->_Z = (appf == 0); - cpustate->_S = (appf < 0); - cpustate->_OV = 0; - cpustate->_CY = 0; + _Z = (appf == 0); + _S = (appf < 0); + _OV = 0; + _CY = 0; - F2END(cpustate); + F2END(); } -static UINT32 op5FUNHANDLED(v60_state *cpustate) +UINT32 v60_device::op5FUNHANDLED() { - fatalerror("Unhandled 5F opcode at %08x\n", cpustate->PC); + fatalerror("Unhandled 5F opcode at %08x\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 op5CUNHANDLED(v60_state *cpustate) +UINT32 v60_device::op5CUNHANDLED() { - fatalerror("Unhandled 5C opcode at %08x\n", cpustate->PC); + fatalerror("Unhandled 5C opcode at %08x\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 (*const Op5FTable[32])(v60_state *) = +const v60_device::am_func v60_device::s_Op5FTable[32] = { - opCVTWS, - opCVTSW, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED, - op5FUNHANDLED + &v60_device::opCVTWS, + &v60_device::opCVTSW, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED, + &v60_device::op5FUNHANDLED }; -static UINT32 (*const Op5CTable[32])(v60_state *) = +const v60_device::am_func v60_device::s_Op5CTable[32] = { - opCMPF, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - opMOVFS, - opNEGFS, - opABSFS, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, + &v60_device::opCMPF, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::opMOVFS, + &v60_device::opNEGFS, + &v60_device::opABSFS, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, - opSCLFS, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - opADDFS, - opSUBFS, - opMULFS, - opDIVFS, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED, - op5CUNHANDLED + &v60_device::opSCLFS, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::opADDFS, + &v60_device::opSUBFS, + &v60_device::opMULFS, + &v60_device::opDIVFS, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED, + &v60_device::op5CUNHANDLED }; -static UINT32 op5F(v60_state *cpustate) +UINT32 v60_device::op5F() { - cpustate->instflags = OpRead8(cpustate, cpustate->PC + 1); - return Op5FTable[cpustate->instflags & 0x1F](cpustate); + m_instflags = OpRead8(PC + 1); + return (this->*s_Op5FTable[m_instflags & 0x1F])(); } -static UINT32 op5C(v60_state *cpustate) +UINT32 v60_device::op5C() { - cpustate->instflags = OpRead8(cpustate, cpustate->PC + 1); - return Op5CTable[cpustate->instflags & 0x1F](cpustate); + m_instflags = OpRead8(PC + 1); + return (this->*s_Op5CTable[m_instflags & 0x1F])(); } diff --git a/src/emu/cpu/v60/op3.c b/src/emu/cpu/v60/op3.c index 722dc81ab81..ff6d36eba87 100644 --- a/src/emu/cpu/v60/op3.c +++ b/src/emu/cpu/v60/op3.c @@ -1,639 +1,639 @@ -static UINT32 opINCB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opINCB() /* TRUSTED */ { UINT8 appb; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 0; + m_modadd = PC + 1; + m_moddim = 0; - cpustate->amlength1 = ReadAMAddress(cpustate); + m_amlength1 = ReadAMAddress(); - if (cpustate->amflag) - appb = (UINT8)cpustate->reg[cpustate->amout]; + if (m_amflag) + appb = (UINT8)m_reg[m_amout]; else - appb = cpustate->program->read_byte(cpustate->amout); + appb = m_program->read_byte(m_amout); ADDB(appb, 1); - if (cpustate->amflag) - SETREG8(cpustate->reg[cpustate->amout], appb); + if (m_amflag) + SETREG8(m_reg[m_amout], appb); else - cpustate->program->write_byte(cpustate->amout, appb); + m_program->write_byte(m_amout, appb); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opINCH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opINCH() /* TRUSTED */ { UINT16 apph; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 1; + m_modadd = PC + 1; + m_moddim = 1; - cpustate->amlength1 = ReadAMAddress(cpustate); + m_amlength1 = ReadAMAddress(); - if (cpustate->amflag) - apph = (UINT16)cpustate->reg[cpustate->amout]; + if (m_amflag) + apph = (UINT16)m_reg[m_amout]; else - apph = cpustate->program->read_word_unaligned(cpustate->amout); + apph = m_program->read_word_unaligned(m_amout); ADDW(apph, 1); - if (cpustate->amflag) - SETREG16(cpustate->reg[cpustate->amout], apph); + if (m_amflag) + SETREG16(m_reg[m_amout], apph); else - cpustate->program->write_word_unaligned(cpustate->amout, apph); + m_program->write_word_unaligned(m_amout, apph); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opINCW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opINCW() /* TRUSTED */ { UINT32 appw; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; - cpustate->amlength1 = ReadAMAddress(cpustate); + m_amlength1 = ReadAMAddress(); - if (cpustate->amflag) - appw = cpustate->reg[cpustate->amout]; + if (m_amflag) + appw = m_reg[m_amout]; else - appw = cpustate->program->read_dword_unaligned(cpustate->amout); + appw = m_program->read_dword_unaligned(m_amout); ADDL(appw, 1); - if (cpustate->amflag) - cpustate->reg[cpustate->amout] = appw; + if (m_amflag) + m_reg[m_amout] = appw; else - cpustate->program->write_dword_unaligned(cpustate->amout, appw); + m_program->write_dword_unaligned(m_amout, appw); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opDECB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDECB() /* TRUSTED */ { UINT8 appb; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 0; + m_modadd = PC + 1; + m_moddim = 0; - cpustate->amlength1 = ReadAMAddress(cpustate); + m_amlength1 = ReadAMAddress(); - if (cpustate->amflag) - appb = (UINT8)cpustate->reg[cpustate->amout]; + if (m_amflag) + appb = (UINT8)m_reg[m_amout]; else - appb = cpustate->program->read_byte(cpustate->amout); + appb = m_program->read_byte(m_amout); SUBB(appb, 1); - if (cpustate->amflag) - SETREG8(cpustate->reg[cpustate->amout], appb); + if (m_amflag) + SETREG8(m_reg[m_amout], appb); else - cpustate->program->write_byte(cpustate->amout, appb); + m_program->write_byte(m_amout, appb); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opDECH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDECH() /* TRUSTED */ { UINT16 apph; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 1; + m_modadd = PC + 1; + m_moddim = 1; - cpustate->amlength1 = ReadAMAddress(cpustate); + m_amlength1 = ReadAMAddress(); - if (cpustate->amflag) - apph = (UINT16)cpustate->reg[cpustate->amout]; + if (m_amflag) + apph = (UINT16)m_reg[m_amout]; else - apph = cpustate->program->read_word_unaligned(cpustate->amout); + apph = m_program->read_word_unaligned(m_amout); SUBW(apph, 1); - if (cpustate->amflag) - SETREG16(cpustate->reg[cpustate->amout], apph); + if (m_amflag) + SETREG16(m_reg[m_amout], apph); else - cpustate->program->write_word_unaligned(cpustate->amout, apph); + m_program->write_word_unaligned(m_amout, apph); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opDECW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opDECW() /* TRUSTED */ { UINT32 appw; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; - cpustate->amlength1 = ReadAMAddress(cpustate); + m_amlength1 = ReadAMAddress(); - if (cpustate->amflag) - appw = cpustate->reg[cpustate->amout]; + if (m_amflag) + appw = m_reg[m_amout]; else - appw = cpustate->program->read_dword_unaligned(cpustate->amout); + appw = m_program->read_dword_unaligned(m_amout); SUBL(appw, 1); - if (cpustate->amflag) - cpustate->reg[cpustate->amout] = appw; + if (m_amflag) + m_reg[m_amout] = appw; else - cpustate->program->write_dword_unaligned(cpustate->amout, appw); + m_program->write_dword_unaligned(m_amout, appw); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opJMP(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opJMP() /* TRUSTED */ { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 0; + m_modadd = PC + 1; + m_moddim = 0; // Read the address of the operand - ReadAMAddress(cpustate); + ReadAMAddress(); // It cannot be a register!! - assert(cpustate->amflag == 0); + assert(m_amflag == 0); // Jump there - cpustate->PC = cpustate->amout; + PC = m_amout; return 0; } -static UINT32 opJSR(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opJSR() /* TRUSTED */ { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 0; + m_modadd = PC + 1; + m_moddim = 0; // Read the address of the operand - cpustate->amlength1 = ReadAMAddress(cpustate); + m_amlength1 = ReadAMAddress(); // It cannot be a register!! - assert(cpustate->amflag == 0); + assert(m_amflag == 0); // Save NextPC into the stack - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC + cpustate->amlength1 + 1); + SP -= 4; + m_program->write_dword_unaligned(SP, PC + m_amlength1 + 1); // Jump there - cpustate->PC = cpustate->amout; + PC = m_amout; return 0; } -static UINT32 opPREPARE(v60_state *cpustate) /* somewhat TRUSTED */ +UINT32 v60_device::opPREPARE() /* somewhat TRUSTED */ { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; // Read the operand - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); // step 1: save frame pointer on the stack - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->FP); + SP -= 4; + m_program->write_dword_unaligned(SP, FP); - // step 2: cpustate->FP = new cpustate->SP - cpustate->FP = cpustate->SP; + // step 2: FP = new SP + FP = SP; - // step 3: cpustate->SP -= operand - cpustate->SP -= cpustate->amout; + // step 3: SP -= operand + SP -= m_amout; - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opRET(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opRET() /* TRUSTED */ { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; // Read the operand - ReadAM(cpustate); + ReadAM(); // Read return address from stack - cpustate->PC = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP +=4; + PC = m_program->read_dword_unaligned(SP); + SP +=4; - // Restore cpustate->AP from stack - cpustate->AP = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP +=4; + // Restore AP from stack + AP = m_program->read_dword_unaligned(SP); + SP +=4; // Skip stack frame - cpustate->SP += cpustate->amout; + SP += m_amout; return 0; } -static UINT32 opTRAP(v60_state *cpustate) +UINT32 v60_device::opTRAP() { UINT32 oldPSW; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 0; + m_modadd = PC + 1; + m_moddim = 0; // Read the operand - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); // Normalize the flags - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - switch ((cpustate->amout >> 4) & 0xF) + switch ((m_amout >> 4) & 0xF) { case 0: - if (!cpustate->_OV) return cpustate->amlength1 + 1; + if (!_OV) return m_amlength1 + 1; else break; case 1: - if (cpustate->_OV) return cpustate->amlength1 + 1; + if (_OV) return m_amlength1 + 1; else break; case 2: - if (!cpustate->_CY) return cpustate->amlength1 + 1; + if (!_CY) return m_amlength1 + 1; else break; case 3: - if (cpustate->_CY) return cpustate->amlength1 + 1; + if (_CY) return m_amlength1 + 1; else break; case 4: - if (!cpustate->_Z) return cpustate->amlength1 + 1; + if (!_Z) return m_amlength1 + 1; else break; case 5: - if (cpustate->_Z) return cpustate->amlength1 + 1; + if (_Z) return m_amlength1 + 1; else break; case 6: - if (!(cpustate->_CY | cpustate->_Z)) return cpustate->amlength1 + 1; + if (!(_CY | _Z)) return m_amlength1 + 1; else break; case 7: - if ((cpustate->_CY | cpustate->_Z)) return cpustate->amlength1 + 1; + if ((_CY | _Z)) return m_amlength1 + 1; else break; case 8: - if (!cpustate->_S) return cpustate->amlength1 + 1; + if (!_S) return m_amlength1 + 1; else break; case 9: - if (cpustate->_S) return cpustate->amlength1 + 1; + if (_S) return m_amlength1 + 1; else break; case 10: break; case 11: - return cpustate->amlength1 + 1; + return m_amlength1 + 1; case 12: - if (!(cpustate->_S^cpustate->_OV)) return cpustate->amlength1 + 1; + if (!(_S^_OV)) return m_amlength1 + 1; else break; case 13: - if ((cpustate->_S^cpustate->_OV)) return cpustate->amlength1 + 1; + if ((_S^_OV)) return m_amlength1 + 1; else break; case 14: - if (!((cpustate->_S^cpustate->_OV)|cpustate->_Z)) return cpustate->amlength1 + 1; + if (!((_S^_OV)|_Z)) return m_amlength1 + 1; else break; case 15: - if (((cpustate->_S^cpustate->_OV)|cpustate->_Z)) return cpustate->amlength1 + 1; + if (((_S^_OV)|_Z)) return m_amlength1 + 1; else break; } - oldPSW = v60_update_psw_for_exception(cpustate, 0, 0); + oldPSW = v60_update_psw_for_exception(0, 0); // Issue the software trap with interrupts - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, EXCEPTION_CODE_AND_SIZE(0x3000 + 0x100 * (cpustate->amout & 0xF), 4)); + SP -= 4; + m_program->write_dword_unaligned(SP, EXCEPTION_CODE_AND_SIZE(0x3000 + 0x100 * (m_amout & 0xF), 4)); - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, oldPSW); + SP -= 4; + m_program->write_dword_unaligned(SP, oldPSW); - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC + cpustate->amlength1 + 1); + SP -= 4; + m_program->write_dword_unaligned(SP, PC + m_amlength1 + 1); - cpustate->PC = GETINTVECT(cpustate, 48 + (cpustate->amout & 0xF)); + PC = GETINTVECT(48 + (m_amout & 0xF)); return 0; } -static UINT32 opRETIU(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opRETIU() /* TRUSTED */ { UINT32 newPSW; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 1; + m_modadd = PC + 1; + m_moddim = 1; // Read the operand - ReadAM(cpustate); + ReadAM(); - // Restore cpustate->PC and cpustate->PSW from stack - cpustate->PC = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP += 4; + // Restore PC and PSW from stack + PC = m_program->read_dword_unaligned(SP); + SP += 4; - newPSW = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP += 4; + newPSW = m_program->read_dword_unaligned(SP); + SP += 4; // Destroy stack frame - cpustate->SP += cpustate->amout; + SP += m_amout; - v60WritePSW(cpustate, newPSW); + v60WritePSW(newPSW); return 0; } -static UINT32 opRETIS(v60_state *cpustate) +UINT32 v60_device::opRETIS() { UINT32 newPSW; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 1; + m_modadd = PC + 1; + m_moddim = 1; // Read the operand - ReadAM(cpustate); + ReadAM(); - // Restore cpustate->PC and cpustate->PSW from stack - cpustate->PC = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP += 4; + // Restore PC and PSW from stack + PC = m_program->read_dword_unaligned(SP); + SP += 4; - newPSW = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP += 4; + newPSW = m_program->read_dword_unaligned(SP); + SP += 4; // Destroy stack frame - cpustate->SP += cpustate->amout; + SP += m_amout; - v60WritePSW(cpustate, newPSW); + v60WritePSW(newPSW); return 0; } -static UINT32 opSTTASK(v60_state *cpustate) +UINT32 v60_device::opSTTASK() { int i; UINT32 adr; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); - adr = cpustate->TR; + adr = TR; - v60WritePSW(cpustate, v60ReadPSW(cpustate) | 0x10000000); - v60SaveStack(cpustate); + v60WritePSW(v60ReadPSW() | 0x10000000); + v60SaveStack(); - cpustate->program->write_dword_unaligned(adr, cpustate->TKCW); + m_program->write_dword_unaligned(adr, TKCW); adr += 4; - if(cpustate->SYCW & 0x100) { - cpustate->program->write_dword_unaligned(adr, cpustate->L0SP); + if(SYCW & 0x100) { + m_program->write_dword_unaligned(adr, L0SP); adr += 4; } - if(cpustate->SYCW & 0x200) { - cpustate->program->write_dword_unaligned(adr, cpustate->L1SP); + if(SYCW & 0x200) { + m_program->write_dword_unaligned(adr, L1SP); adr += 4; } - if(cpustate->SYCW & 0x400) { - cpustate->program->write_dword_unaligned(adr, cpustate->L2SP); + if(SYCW & 0x400) { + m_program->write_dword_unaligned(adr, L2SP); adr += 4; } - if(cpustate->SYCW & 0x800) { - cpustate->program->write_dword_unaligned(adr, cpustate->L3SP); + if(SYCW & 0x800) { + m_program->write_dword_unaligned(adr, L3SP); adr += 4; } // 31 registers supported, _not_ 32 for(i = 0; i < 31; i++) - if(cpustate->amout & (1 << i)) { - cpustate->program->write_dword_unaligned(adr, cpustate->reg[i]); + if(m_amout & (1 << i)) { + m_program->write_dword_unaligned(adr, m_reg[i]); adr += 4; } // #### Ignore the virtual addressing crap. - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opGETPSW(v60_state *cpustate) +UINT32 v60_device::opGETPSW() { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; - cpustate->modwritevalw = v60ReadPSW(cpustate); + m_modadd = PC + 1; + m_moddim = 2; + m_modwritevalw = v60ReadPSW(); - // Write cpustate->PSW to the operand - cpustate->amlength1 = WriteAM(cpustate); + // Write PSW to the operand + m_amlength1 = WriteAM(); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opTASI(v60_state *cpustate) +UINT32 v60_device::opTASI() { UINT8 appb; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 0; + m_modadd = PC + 1; + m_moddim = 0; // Load the address of the operand - cpustate->amlength1 = ReadAMAddress(cpustate); + m_amlength1 = ReadAMAddress(); // Load UINT8 from the address - if (cpustate->amflag) - appb = (UINT8)cpustate->reg[cpustate->amout & 0x1F]; + if (m_amflag) + appb = (UINT8)m_reg[m_amout & 0x1F]; else - appb = cpustate->program->read_byte(cpustate->amout); + appb = m_program->read_byte(m_amout); // Set the flags for SUB appb, FF SUBB(appb, 0xff); // Write FF in the operand - if (cpustate->amflag) - SETREG8(cpustate->reg[cpustate->amout & 0x1F], 0xFF); + if (m_amflag) + SETREG8(m_reg[m_amout & 0x1F], 0xFF); else - cpustate->program->write_byte(cpustate->amout, 0xFF); + m_program->write_byte(m_amout, 0xFF); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opCLRTLB(v60_state *cpustate) +UINT32 v60_device::opCLRTLB() { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; // Read the operand - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); // @@@ TLB not yet emulated - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opPOPM(v60_state *cpustate) +UINT32 v60_device::opPOPM() { int i; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; // Read the bit register list - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); for (i = 0;i < 31;i++) - if (cpustate->amout & (1 << i)) + if (m_amout & (1 << i)) { - cpustate->reg[i] = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP += 4; + m_reg[i] = m_program->read_dword_unaligned(SP); + SP += 4; } - if (cpustate->amout & (1 << 31)) + if (m_amout & (1 << 31)) { - v60WritePSW(cpustate, (v60ReadPSW(cpustate) & 0xffff0000) | cpustate->program->read_word_unaligned(cpustate->SP)); - cpustate->SP += 4; + v60WritePSW((v60ReadPSW() & 0xffff0000) | m_program->read_word_unaligned(SP)); + SP += 4; } - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opPUSHM(v60_state *cpustate) +UINT32 v60_device::opPUSHM() { int i; - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; // Read the bit register list - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); - if (cpustate->amout & (1 << 31)) + if (m_amout & (1 << 31)) { - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, v60ReadPSW(cpustate)); + SP -= 4; + m_program->write_dword_unaligned(SP, v60ReadPSW()); } for (i = 0;i < 31;i++) - if (cpustate->amout & (1 << (30 - i))) + if (m_amout & (1 << (30 - i))) { - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->reg[(30 - i)]); + SP -= 4; + m_program->write_dword_unaligned(SP, m_reg[(30 - i)]); } - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opTESTB(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opTESTB() /* TRUSTED */ { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 0; + m_modadd = PC + 1; + m_moddim = 0; // Read the operand - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); - cpustate->_Z = (cpustate->amout == 0); - cpustate->_S = ((cpustate->amout & 0x80) != 0); - cpustate->_CY = 0; - cpustate->_OV = 0; + _Z = (m_amout == 0); + _S = ((m_amout & 0x80) != 0); + _CY = 0; + _OV = 0; - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opTESTH(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opTESTH() /* TRUSTED */ { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 1; + m_modadd = PC + 1; + m_moddim = 1; // Read the operand - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); - cpustate->_Z = (cpustate->amout == 0); - cpustate->_S = ((cpustate->amout & 0x8000) != 0); - cpustate->_CY = 0; - cpustate->_OV = 0; + _Z = (m_amout == 0); + _S = ((m_amout & 0x8000) != 0); + _CY = 0; + _OV = 0; - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opTESTW(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opTESTW() /* TRUSTED */ { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; // Read the operand - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); - cpustate->_Z = (cpustate->amout == 0); - cpustate->_S = ((cpustate->amout & 0x80000000) != 0); - cpustate->_CY = 0; - cpustate->_OV = 0; + _Z = (m_amout == 0); + _S = ((m_amout & 0x80000000) != 0); + _CY = 0; + _OV = 0; - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opPUSH(v60_state *cpustate) +UINT32 v60_device::opPUSH() { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; + m_modadd = PC + 1; + m_moddim = 2; - cpustate->amlength1 = ReadAM(cpustate); + m_amlength1 = ReadAM(); - cpustate->SP-=4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->amout); + SP-=4; + m_program->write_dword_unaligned(SP, m_amout); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opPOP(v60_state *cpustate) +UINT32 v60_device::opPOP() { - cpustate->modadd = cpustate->PC + 1; - cpustate->moddim = 2; - cpustate->modwritevalw = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP +=4; - cpustate->amlength1 = WriteAM(cpustate); + m_modadd = PC + 1; + m_moddim = 2; + m_modwritevalw = m_program->read_dword_unaligned(SP); + SP +=4; + m_amlength1 = WriteAM(); - return cpustate->amlength1 + 1; + return m_amlength1 + 1; } -static UINT32 opINCB_0(v60_state *cpustate) { cpustate->modm = 0; return opINCB(cpustate); } -static UINT32 opINCB_1(v60_state *cpustate) { cpustate->modm = 1; return opINCB(cpustate); } -static UINT32 opINCH_0(v60_state *cpustate) { cpustate->modm = 0; return opINCH(cpustate); } -static UINT32 opINCH_1(v60_state *cpustate) { cpustate->modm = 1; return opINCH(cpustate); } -static UINT32 opINCW_0(v60_state *cpustate) { cpustate->modm = 0; return opINCW(cpustate); } -static UINT32 opINCW_1(v60_state *cpustate) { cpustate->modm = 1; return opINCW(cpustate); } +UINT32 v60_device::opINCB_0() { m_modm = 0; return opINCB(); } +UINT32 v60_device::opINCB_1() { m_modm = 1; return opINCB(); } +UINT32 v60_device::opINCH_0() { m_modm = 0; return opINCH(); } +UINT32 v60_device::opINCH_1() { m_modm = 1; return opINCH(); } +UINT32 v60_device::opINCW_0() { m_modm = 0; return opINCW(); } +UINT32 v60_device::opINCW_1() { m_modm = 1; return opINCW(); } -static UINT32 opDECB_0(v60_state *cpustate) { cpustate->modm = 0; return opDECB(cpustate); } -static UINT32 opDECB_1(v60_state *cpustate) { cpustate->modm = 1; return opDECB(cpustate); } -static UINT32 opDECH_0(v60_state *cpustate) { cpustate->modm = 0; return opDECH(cpustate); } -static UINT32 opDECH_1(v60_state *cpustate) { cpustate->modm = 1; return opDECH(cpustate); } -static UINT32 opDECW_0(v60_state *cpustate) { cpustate->modm = 0; return opDECW(cpustate); } -static UINT32 opDECW_1(v60_state *cpustate) { cpustate->modm = 1; return opDECW(cpustate); } +UINT32 v60_device::opDECB_0() { m_modm = 0; return opDECB(); } +UINT32 v60_device::opDECB_1() { m_modm = 1; return opDECB(); } +UINT32 v60_device::opDECH_0() { m_modm = 0; return opDECH(); } +UINT32 v60_device::opDECH_1() { m_modm = 1; return opDECH(); } +UINT32 v60_device::opDECW_0() { m_modm = 0; return opDECW(); } +UINT32 v60_device::opDECW_1() { m_modm = 1; return opDECW(); } -static UINT32 opJMP_0(v60_state *cpustate) { cpustate->modm = 0; return opJMP(cpustate); } -static UINT32 opJMP_1(v60_state *cpustate) { cpustate->modm = 1; return opJMP(cpustate); } +UINT32 v60_device::opJMP_0() { m_modm = 0; return opJMP(); } +UINT32 v60_device::opJMP_1() { m_modm = 1; return opJMP(); } -static UINT32 opJSR_0(v60_state *cpustate) { cpustate->modm = 0; return opJSR(cpustate); } -static UINT32 opJSR_1(v60_state *cpustate) { cpustate->modm = 1; return opJSR(cpustate); } +UINT32 v60_device::opJSR_0() { m_modm = 0; return opJSR(); } +UINT32 v60_device::opJSR_1() { m_modm = 1; return opJSR(); } -static UINT32 opPREPARE_0(v60_state *cpustate) { cpustate->modm = 0; return opPREPARE(cpustate); } -static UINT32 opPREPARE_1(v60_state *cpustate) { cpustate->modm = 1; return opPREPARE(cpustate); } +UINT32 v60_device::opPREPARE_0() { m_modm = 0; return opPREPARE(); } +UINT32 v60_device::opPREPARE_1() { m_modm = 1; return opPREPARE(); } -static UINT32 opRET_0(v60_state *cpustate) { cpustate->modm = 0; return opRET(cpustate); } -static UINT32 opRET_1(v60_state *cpustate) { cpustate->modm = 1; return opRET(cpustate); } +UINT32 v60_device::opRET_0() { m_modm = 0; return opRET(); } +UINT32 v60_device::opRET_1() { m_modm = 1; return opRET(); } -static UINT32 opTRAP_0(v60_state *cpustate) { cpustate->modm = 0; return opTRAP(cpustate); } -static UINT32 opTRAP_1(v60_state *cpustate) { cpustate->modm = 1; return opTRAP(cpustate); } +UINT32 v60_device::opTRAP_0() { m_modm = 0; return opTRAP(); } +UINT32 v60_device::opTRAP_1() { m_modm = 1; return opTRAP(); } -static UINT32 opRETIU_0(v60_state *cpustate) { cpustate->modm = 0; return opRETIU(cpustate); } -static UINT32 opRETIU_1(v60_state *cpustate) { cpustate->modm = 1; return opRETIU(cpustate); } +UINT32 v60_device::opRETIU_0() { m_modm = 0; return opRETIU(); } +UINT32 v60_device::opRETIU_1() { m_modm = 1; return opRETIU(); } -static UINT32 opRETIS_0(v60_state *cpustate) { cpustate->modm = 0; return opRETIS(cpustate); } -static UINT32 opRETIS_1(v60_state *cpustate) { cpustate->modm = 1; return opRETIS(cpustate); } +UINT32 v60_device::opRETIS_0() { m_modm = 0; return opRETIS(); } +UINT32 v60_device::opRETIS_1() { m_modm = 1; return opRETIS(); } -static UINT32 opGETPSW_0(v60_state *cpustate) { cpustate->modm = 0; return opGETPSW(cpustate); } -static UINT32 opGETPSW_1(v60_state *cpustate) { cpustate->modm = 1; return opGETPSW(cpustate); } +UINT32 v60_device::opGETPSW_0() { m_modm = 0; return opGETPSW(); } +UINT32 v60_device::opGETPSW_1() { m_modm = 1; return opGETPSW(); } -static UINT32 opTASI_0(v60_state *cpustate) { cpustate->modm = 0; return opTASI(cpustate); } -static UINT32 opTASI_1(v60_state *cpustate) { cpustate->modm = 1; return opTASI(cpustate); } +UINT32 v60_device::opTASI_0() { m_modm = 0; return opTASI(); } +UINT32 v60_device::opTASI_1() { m_modm = 1; return opTASI(); } -static UINT32 opCLRTLB_0(v60_state *cpustate) { cpustate->modm = 0; return opCLRTLB(cpustate); } -static UINT32 opCLRTLB_1(v60_state *cpustate) { cpustate->modm = 1; return opCLRTLB(cpustate); } +UINT32 v60_device::opCLRTLB_0() { m_modm = 0; return opCLRTLB(); } +UINT32 v60_device::opCLRTLB_1() { m_modm = 1; return opCLRTLB(); } -static UINT32 opPOPM_0(v60_state *cpustate) { cpustate->modm = 0; return opPOPM(cpustate); } -static UINT32 opPOPM_1(v60_state *cpustate) { cpustate->modm = 1; return opPOPM(cpustate); } +UINT32 v60_device::opPOPM_0() { m_modm = 0; return opPOPM(); } +UINT32 v60_device::opPOPM_1() { m_modm = 1; return opPOPM(); } -static UINT32 opPUSHM_0(v60_state *cpustate) { cpustate->modm = 0; return opPUSHM(cpustate); } -static UINT32 opPUSHM_1(v60_state *cpustate) { cpustate->modm = 1; return opPUSHM(cpustate); } +UINT32 v60_device::opPUSHM_0() { m_modm = 0; return opPUSHM(); } +UINT32 v60_device::opPUSHM_1() { m_modm = 1; return opPUSHM(); } -static UINT32 opTESTB_0(v60_state *cpustate) { cpustate->modm = 0; return opTESTB(cpustate); } -static UINT32 opTESTB_1(v60_state *cpustate) { cpustate->modm = 1; return opTESTB(cpustate); } +UINT32 v60_device::opTESTB_0() { m_modm = 0; return opTESTB(); } +UINT32 v60_device::opTESTB_1() { m_modm = 1; return opTESTB(); } -static UINT32 opTESTH_0(v60_state *cpustate) { cpustate->modm = 0; return opTESTH(cpustate); } -static UINT32 opTESTH_1(v60_state *cpustate) { cpustate->modm = 1; return opTESTH(cpustate); } +UINT32 v60_device::opTESTH_0() { m_modm = 0; return opTESTH(); } +UINT32 v60_device::opTESTH_1() { m_modm = 1; return opTESTH(); } -static UINT32 opTESTW_0(v60_state *cpustate) { cpustate->modm = 0; return opTESTW(cpustate); } -static UINT32 opTESTW_1(v60_state *cpustate) { cpustate->modm = 1; return opTESTW(cpustate); } +UINT32 v60_device::opTESTW_0() { m_modm = 0; return opTESTW(); } +UINT32 v60_device::opTESTW_1() { m_modm = 1; return opTESTW(); } -static UINT32 opPUSH_0(v60_state *cpustate) { cpustate->modm = 0; return opPUSH(cpustate); } -static UINT32 opPUSH_1(v60_state *cpustate) { cpustate->modm = 1; return opPUSH(cpustate); } +UINT32 v60_device::opPUSH_0() { m_modm = 0; return opPUSH(); } +UINT32 v60_device::opPUSH_1() { m_modm = 1; return opPUSH(); } -static UINT32 opPOP_0(v60_state *cpustate) { cpustate->modm = 0; return opPOP(cpustate); } -static UINT32 opPOP_1(v60_state *cpustate) { cpustate->modm = 1; return opPOP(cpustate); } +UINT32 v60_device::opPOP_0() { m_modm = 0; return opPOP(); } +UINT32 v60_device::opPOP_1() { m_modm = 1; return opPOP(); } -static UINT32 opSTTASK_0(v60_state *cpustate) { cpustate->modm = 0; return opSTTASK(cpustate); } -static UINT32 opSTTASK_1(v60_state *cpustate) { cpustate->modm = 1; return opSTTASK(cpustate); } +UINT32 v60_device::opSTTASK_0() { m_modm = 0; return opSTTASK(); } +UINT32 v60_device::opSTTASK_1() { m_modm = 1; return opSTTASK(); } diff --git a/src/emu/cpu/v60/op4.c b/src/emu/cpu/v60/op4.c index 6332052354e..1082353b2d1 100644 --- a/src/emu/cpu/v60/op4.c +++ b/src/emu/cpu/v60/op4.c @@ -3,26 +3,26 @@ FULLY TRUSTED */ -static UINT32 opBGT8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBGT8() /* TRUSTED */ { - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - if (!((cpustate->_S ^ cpustate->_OV) | cpustate->_Z)) + if (!((_S ^ _OV) | _Z)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBGT16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBGT16() /* TRUSTED */ { - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - if (!((cpustate->_S ^ cpustate->_OV) | cpustate->_Z)) + if (!((_S ^ _OV) | _Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } @@ -30,52 +30,52 @@ static UINT32 opBGT16(v60_state *cpustate) /* TRUSTED */ } -static UINT32 opBGE8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBGE8() /* TRUSTED */ { - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - if (!(cpustate->_S ^ cpustate->_OV)) + if (!(_S ^ _OV)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBGE16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBGE16() /* TRUSTED */ { - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - if (!(cpustate->_S ^ cpustate->_OV)) + if (!(_S ^ _OV)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBLT8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBLT8() /* TRUSTED */ { - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - if ((cpustate->_S ^ cpustate->_OV)) + if ((_S ^ _OV)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBLT16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBLT16() /* TRUSTED */ { - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - if ((cpustate->_S ^ cpustate->_OV)) + if ((_S ^ _OV)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } @@ -83,271 +83,271 @@ static UINT32 opBLT16(v60_state *cpustate) /* TRUSTED */ } -static UINT32 opBLE8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBLE8() /* TRUSTED */ { - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - if (((cpustate->_S ^ cpustate->_OV) | cpustate->_Z)) + if (((_S ^ _OV) | _Z)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBLE16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBLE16() /* TRUSTED */ { - NORMALIZEFLAGS(cpustate); + NORMALIZEFLAGS(); - if (((cpustate->_S ^ cpustate->_OV) | cpustate->_Z)) + if (((_S ^ _OV) | _Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBH8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBH8() /* TRUSTED */ { - if (!(cpustate->_CY | cpustate->_Z)) + if (!(_CY | _Z)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBH16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBH16() /* TRUSTED */ { - if (!(cpustate->_CY | cpustate->_Z)) + if (!(_CY | _Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBNH8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBNH8() /* TRUSTED */ { - if ((cpustate->_CY | cpustate->_Z)) + if ((_CY | _Z)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBNH16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBNH16() /* TRUSTED */ { - if ((cpustate->_CY | cpustate->_Z)) + if ((_CY | _Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBNL8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBNL8() /* TRUSTED */ { - if (!(cpustate->_CY)) + if (!(_CY)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBNL16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBNL16() /* TRUSTED */ { - if (!(cpustate->_CY)) + if (!(_CY)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBL8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBL8() /* TRUSTED */ { - if ((cpustate->_CY)) + if ((_CY)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBL16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBL16() /* TRUSTED */ { - if ((cpustate->_CY)) + if ((_CY)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBNE8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBNE8() /* TRUSTED */ { - if (!(cpustate->_Z)) + if (!(_Z)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBNE16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBNE16() /* TRUSTED */ { - if (!(cpustate->_Z)) + if (!(_Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBE8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBE8() /* TRUSTED */ { - if ((cpustate->_Z)) + if ((_Z)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBE16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBE16() /* TRUSTED */ { - if ((cpustate->_Z)) + if ((_Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBNV8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBNV8() /* TRUSTED */ { - if (!(cpustate->_OV)) + if (!(_OV)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBNV16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBNV16() /* TRUSTED */ { - if (!(cpustate->_OV)) + if (!(_OV)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBV8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBV8() /* TRUSTED */ { - if ((cpustate->_OV)) + if ((_OV)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBV16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBV16() /* TRUSTED */ { - if ((cpustate->_OV)) + if ((_OV)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBP8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBP8() /* TRUSTED */ { - if (!(cpustate->_S)) + if (!(_S)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBP16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBP16() /* TRUSTED */ { - if (!(cpustate->_S)) + if (!(_S)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBN8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBN8() /* TRUSTED */ { - if ((cpustate->_S)) + if ((_S)) { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } return 2; } -static UINT32 opBN16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBN16() /* TRUSTED */ { - if ((cpustate->_S)) + if ((_S)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } return 3; } -static UINT32 opBR8(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBR8() /* TRUSTED */ { - cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1); + PC += (INT8)OpRead8(PC + 1); return 0; } -static UINT32 opBR16(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBR16() /* TRUSTED */ { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } -static UINT32 opBSR(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opBSR() /* TRUSTED */ { - // Save Next cpustate->PC onto the stack - cpustate->SP -= 4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC + 3); + // Save Next PC onto the stack + SP -= 4; + m_program->write_dword_unaligned(SP, PC + 3); // Jump to subroutine - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 1); + PC += (INT16)OpRead16(PC + 1); return 0; } diff --git a/src/emu/cpu/v60/op5.c b/src/emu/cpu/v60/op5.c index 6373a3ce8e1..d758edc85ae 100644 --- a/src/emu/cpu/v60/op5.c +++ b/src/emu/cpu/v60/op5.c @@ -3,83 +3,83 @@ * HALT: must add log */ -static UINT32 opBRK(v60_state *cpustate) +UINT32 v60_device::opBRK() { /* - UINT32 oldPSW = v60_update_psw_for_exception(cpustate, 0, 0); + UINT32 oldPSW = v60_update_psw_for_exception(0, 0); - cpustate->SP -=4; - cpustate->program->write_dword_unaligned(cpustate->SP, EXCEPTION_CODE_AND_SIZE(0x0d00, 4)); - cpustate->SP -=4; - cpustate->program->write_dword_unaligned(cpustate->SP, oldPSW); - cpustate->SP -=4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC + 1); - cpustate->PC = GETINTVECT(cpustate, 13); + SP -=4; + m_program->write_dword_unaligned(SP, EXCEPTION_CODE_AND_SIZE(0x0d00, 4)); + SP -=4; + m_program->write_dword_unaligned(SP, oldPSW); + SP -=4; + m_program->write_dword_unaligned(SP, PC + 1); + PC = GETINTVECT(13); */ - logerror("Skipping BRK opcode! cpustate->PC=%x", cpustate->PC); + logerror("Skipping BRK opcode! PC=%x", PC); return 1; } -static UINT32 opBRKV(v60_state *cpustate) +UINT32 v60_device::opBRKV() { - UINT32 oldPSW = v60_update_psw_for_exception(cpustate, 0, 0); + UINT32 oldPSW = v60_update_psw_for_exception(0, 0); - cpustate->SP -=4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC); - cpustate->SP -=4; - cpustate->program->write_dword_unaligned(cpustate->SP, EXCEPTION_CODE_AND_SIZE(0x1501, 4)); - cpustate->SP -=4; - cpustate->program->write_dword_unaligned(cpustate->SP, oldPSW); - cpustate->SP -=4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC + 1); - cpustate->PC = GETINTVECT(cpustate, 21); + SP -=4; + m_program->write_dword_unaligned(SP, PC); + SP -=4; + m_program->write_dword_unaligned(SP, EXCEPTION_CODE_AND_SIZE(0x1501, 4)); + SP -=4; + m_program->write_dword_unaligned(SP, oldPSW); + SP -=4; + m_program->write_dword_unaligned(SP, PC + 1); + PC = GETINTVECT(21); return 0; } -static UINT32 opCLRTLBA(v60_state *cpustate) +UINT32 v60_device::opCLRTLBA() { // @@@ TLB not yet supported - logerror("Skipping CLRTLBA opcode! cpustate->PC=%x\n", cpustate->PC); + logerror("Skipping CLRTLBA opcode! PC=%x\n", PC); return 1; } -static UINT32 opDISPOSE(v60_state *cpustate) +UINT32 v60_device::opDISPOSE() { - cpustate->SP = cpustate->FP; - cpustate->FP = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP +=4; + SP = FP; + FP = m_program->read_dword_unaligned(SP); + SP +=4; return 1; } -static UINT32 opHALT(v60_state *cpustate) +UINT32 v60_device::opHALT() { // @@@ It should wait for an interrupt to occur //logerror("HALT found: skipping"); return 1; } -static UINT32 opNOP(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opNOP() /* TRUSTED */ { return 1; } -static UINT32 opRSR(v60_state *cpustate) +UINT32 v60_device::opRSR() { - cpustate->PC = cpustate->program->read_dword_unaligned(cpustate->SP); - cpustate->SP +=4; + PC = m_program->read_dword_unaligned(SP); + SP +=4; return 0; } -static UINT32 opTRAPFL(v60_state *cpustate) +UINT32 v60_device::opTRAPFL() { - if ((cpustate->TKCW & 0x1F0) & ((v60ReadPSW(cpustate) & 0x1F00) >> 4)) + if ((TKCW & 0x1F0) & ((v60ReadPSW() & 0x1F00) >> 4)) { // @@@ FPU exception - fatalerror("Hit TRAPFL! cpustate->PC=%x\n", cpustate->PC); + fatalerror("Hit TRAPFL! PC=%x\n", PC); } return 1; diff --git a/src/emu/cpu/v60/op6.c b/src/emu/cpu/v60/op6.c index af9fa875700..7c7cff05368 100644 --- a/src/emu/cpu/v60/op6.c +++ b/src/emu/cpu/v60/op6.c @@ -3,39 +3,39 @@ FULLY TRUSTED */ -static UINT32 opTB(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opTB(int reg) /* TRUSTED */ { - if (cpustate->reg[reg] == 0) + if (m_reg[reg] == 0) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBGT(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBGT(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - NORMALIZEFLAGS(cpustate); - if ((cpustate->reg[reg] != 0) && !((cpustate->_S ^ cpustate->_OV) | cpustate->_Z)) + NORMALIZEFLAGS(); + if ((m_reg[reg] != 0) && !((_S ^ _OV) | _Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBLE(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBLE(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - NORMALIZEFLAGS(cpustate); - if ((cpustate->reg[reg] != 0) && ((cpustate->_S ^ cpustate->_OV) | cpustate->_Z)) + NORMALIZEFLAGS(); + if ((m_reg[reg] != 0) && ((_S ^ _OV) | _Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } @@ -43,54 +43,54 @@ static UINT32 opDBLE(v60_state *cpustate, int reg) /* TRUSTED */ } -static UINT32 opDBGE(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBGE(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - NORMALIZEFLAGS(cpustate); - if ((cpustate->reg[reg] != 0) && !(cpustate->_S ^ cpustate->_OV)) + NORMALIZEFLAGS(); + if ((m_reg[reg] != 0) && !(_S ^ _OV)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBLT(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBLT(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - NORMALIZEFLAGS(cpustate); - if ((cpustate->reg[reg] != 0) && (cpustate->_S ^ cpustate->_OV)) + NORMALIZEFLAGS(); + if ((m_reg[reg] != 0) && (_S ^ _OV)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBH(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBH(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && !(cpustate->_CY | cpustate->_Z)) + if ((m_reg[reg] != 0) && !(_CY | _Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBNH(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBNH(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && (cpustate->_CY | cpustate->_Z)) + if ((m_reg[reg] != 0) && (_CY | _Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } @@ -98,156 +98,156 @@ static UINT32 opDBNH(v60_state *cpustate, int reg) /* TRUSTED */ } -static UINT32 opDBL(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBL(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && (cpustate->_CY)) + if ((m_reg[reg] != 0) && (_CY)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBNL(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBNL(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && !(cpustate->_CY)) + if ((m_reg[reg] != 0) && !(_CY)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBE(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBE(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && (cpustate->_Z)) + if ((m_reg[reg] != 0) && (_Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBNE(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBNE(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && !(cpustate->_Z)) + if ((m_reg[reg] != 0) && !(_Z)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBV(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBV(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && (cpustate->_OV)) + if ((m_reg[reg] != 0) && (_OV)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBNV(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBNV(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && !(cpustate->_OV)) + if ((m_reg[reg] != 0) && !(_OV)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBN(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBN(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && (cpustate->_S)) + if ((m_reg[reg] != 0) && (_S)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBP(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBP(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if ((cpustate->reg[reg] != 0) && !(cpustate->_S)) + if ((m_reg[reg] != 0) && !(_S)) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 opDBR(v60_state *cpustate, int reg) /* TRUSTED */ +UINT32 v60_device::opDBR(int reg) /* TRUSTED */ { - cpustate->reg[reg]--; + m_reg[reg]--; - if (cpustate->reg[reg] != 0) + if (m_reg[reg] != 0) { - cpustate->PC += (INT16)OpRead16(cpustate, cpustate->PC + 2); + PC += (INT16)OpRead16(PC + 2); return 0; } return 4; } -static UINT32 (*const OpC6Table[8])(v60_state *, int reg) = /* TRUSTED */ +const v60_device::op6_func v60_device::s_OpC6Table[8] = /* TRUSTED */ { - opDBV, - opDBL, - opDBE, - opDBNH, - opDBN, - opDBR, - opDBLT, - opDBLE + &v60_device::opDBV, + &v60_device::opDBL, + &v60_device::opDBE, + &v60_device::opDBNH, + &v60_device::opDBN, + &v60_device::opDBR, + &v60_device::opDBLT, + &v60_device::opDBLE }; -static UINT32 (*const OpC7Table[8])(v60_state *, int reg) = /* TRUSTED */ +const v60_device::op6_func v60_device::s_OpC7Table[8] = /* TRUSTED */ { - opDBNV, - opDBNL, - opDBNE, - opDBH, - opDBP, - opTB, - opDBGE, - opDBGT + &v60_device::opDBNV, + &v60_device::opDBNL, + &v60_device::opDBNE, + &v60_device::opDBH, + &v60_device::opDBP, + &v60_device::opTB, + &v60_device::opDBGE, + &v60_device::opDBGT }; -static UINT32 opC6(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opC6() /* TRUSTED */ { - UINT8 appb = OpRead8(cpustate, cpustate->PC + 1); - return OpC6Table[appb >> 5](cpustate, appb & 0x1f); + UINT8 appb = OpRead8(PC + 1); + return (this->*s_OpC6Table[appb >> 5])(appb & 0x1f); } -static UINT32 opC7(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opC7() /* TRUSTED */ { - UINT8 appb = OpRead8(cpustate, cpustate->PC + 1); - return OpC7Table[appb >> 5](cpustate, appb & 0x1f); + UINT8 appb = OpRead8(PC + 1); + return (this->*s_OpC7Table[appb >> 5])(appb & 0x1f); } diff --git a/src/emu/cpu/v60/op7a.c b/src/emu/cpu/v60/op7a.c index 071681cb543..c2b0fe49ccd 100644 --- a/src/emu/cpu/v60/op7a.c +++ b/src/emu/cpu/v60/op7a.c @@ -1,25 +1,25 @@ /* - * CMPC: What happens to cpustate->_S flag if the strings are identical? + * CMPC: What happens to _S flag if the strings are identical? * I suppose that it will be cleared. And is it set or cleared * when the first one is a substring of the second? I suppose - * cleared (since cpustate->_S should be (src > dst)) + * cleared (since _S should be (src > dst)) * MOVC: Why MOVCS does not exist in downward version? - * SHCHDB / SHCHDH: cpustate->R27 is filled with the offset from the start or from the end? + * SHCHDB / SHCHDH: R27 is filled with the offset from the start or from the end? * * Strange stuff: - * SCHC opcodes does *not* modify cpustate->_Z flag as stated in V60 manual: + * SCHC opcodes does *not* modify _Z flag as stated in V60 manual: * they do the opposite (set if not found, reset if found) */ -#define F7AEND(cs) \ - return (cs)->amlength1 + (cs)->amlength2 + 4; +#define F7AEND() \ + return m_amlength1 + m_amlength2 + 4; -#define F7BEND(cs) \ - return (cs)->amlength1 + (cs)->amlength2 + 3; +#define F7BEND() \ + return m_amlength1 + m_amlength2 + 3; -#define F7CEND(cs) \ - return (cs)->amlength1 + (cs)->amlength2 + 3; +#define F7CEND() \ + return m_amlength1 + m_amlength2 + 3; #define F7BCREATEBITMASK(x) \ x = ((1 << (x)) - 1) @@ -27,272 +27,272 @@ #define F7CCREATEBITMASK(x) \ x = ((1 << (x)) - 1) -static void F7aDecodeOperands(v60_state *cpustate, UINT32 (*DecodeOp1)(v60_state *), UINT8 dim1, UINT32 (*DecodeOp2)(v60_state *), UINT8 dim2) +void v60_device::F7aDecodeOperands(am_func DecodeOp1, UINT8 dim1, am_func DecodeOp2, UINT8 dim2) { UINT8 appb; // Decode first operand - cpustate->moddim = dim1; - cpustate->modm = cpustate->subop & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->amlength1 = DecodeOp1(cpustate); - cpustate->flag1 = cpustate->amflag; - cpustate->op1 = cpustate->amout; + m_moddim = dim1; + m_modm = m_subop & 0x40; + m_modadd = PC + 2; + m_amlength1 = (this->*DecodeOp1)(); + m_flag1 = m_amflag; + m_op1 = m_amout; // Decode length - appb = OpRead8(cpustate, cpustate->PC + 2 + cpustate->amlength1); + appb = OpRead8(PC + 2 + m_amlength1); if (appb & 0x80) - cpustate->lenop1 = cpustate->reg[appb & 0x1F]; + m_lenop1 = m_reg[appb & 0x1F]; else - cpustate->lenop1 = appb; + m_lenop1 = appb; // Decode second operand - cpustate->moddim = dim2; - cpustate->modm = cpustate->subop & 0x20; - cpustate->modadd = cpustate->PC + 3 + cpustate->amlength1; - cpustate->amlength2 = DecodeOp2(cpustate); - cpustate->flag2 = cpustate->amflag; - cpustate->op2 = cpustate->amout; + m_moddim = dim2; + m_modm = m_subop & 0x20; + m_modadd = PC + 3 + m_amlength1; + m_amlength2 = (this->*DecodeOp2)(); + m_flag2 = m_amflag; + m_op2 = m_amout; // Decode length - appb = OpRead8(cpustate, cpustate->PC + 3 + cpustate->amlength1 + cpustate->amlength2); + appb = OpRead8(PC + 3 + m_amlength1 + m_amlength2); if (appb & 0x80) - cpustate->lenop2 = cpustate->reg[appb & 0x1F]; + m_lenop2 = m_reg[appb & 0x1F]; else - cpustate->lenop2 = appb; + m_lenop2 = appb; } -static void F7bDecodeFirstOperand(v60_state *cpustate, UINT32 (*DecodeOp1)(v60_state *), UINT8 dim1) +void v60_device::F7bDecodeFirstOperand(am_func DecodeOp1, UINT8 dim1) { UINT8 appb; // Decode first operand - cpustate->moddim = dim1; - cpustate->modm = cpustate->subop & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->amlength1 = DecodeOp1(cpustate); - cpustate->flag1 = cpustate->amflag; - cpustate->op1 = cpustate->amout; + m_moddim = dim1; + m_modm = m_subop & 0x40; + m_modadd = PC + 2; + m_amlength1 = (this->*DecodeOp1)(); + m_flag1 = m_amflag; + m_op1 = m_amout; // Decode ext - appb = OpRead8(cpustate, cpustate->PC + 2 + cpustate->amlength1); + appb = OpRead8(PC + 2 + m_amlength1); if (appb & 0x80) - cpustate->lenop1 = cpustate->reg[appb & 0x1F]; + m_lenop1 = m_reg[appb & 0x1F]; else - cpustate->lenop1 = appb; + m_lenop1 = appb; } -static void F7bWriteSecondOperand(v60_state *cpustate, UINT8 dim2) +void v60_device::F7bWriteSecondOperand(UINT8 dim2) { - cpustate->moddim = dim2; - cpustate->modm = cpustate->subop & 0x20; - cpustate->modadd = cpustate->PC + 3 + cpustate->amlength1; - cpustate->amlength2 = WriteAM(cpustate); + m_moddim = dim2; + m_modm = m_subop & 0x20; + m_modadd = PC + 3 + m_amlength1; + m_amlength2 = WriteAM(); } -static void F7bDecodeOperands(v60_state *cpustate, UINT32 (*DecodeOp1)(v60_state *), UINT8 dim1, UINT32 (*DecodeOp2)(v60_state *), UINT8 dim2) +void v60_device::F7bDecodeOperands(am_func DecodeOp1, UINT8 dim1, am_func DecodeOp2, UINT8 dim2) { // Decode first operand - F7bDecodeFirstOperand(cpustate, DecodeOp1, dim1); - cpustate->bamoffset1 = cpustate->bamoffset; + F7bDecodeFirstOperand(DecodeOp1, dim1); + m_bamoffset1 = m_bamoffset; // Decode second operand - cpustate->moddim = dim2; - cpustate->modm = cpustate->subop & 0x20; - cpustate->modadd = cpustate->PC + 3 + cpustate->amlength1; - cpustate->amlength2 = DecodeOp2(cpustate); - cpustate->flag2 = cpustate->amflag; - cpustate->op2 = cpustate->amout; - cpustate->bamoffset2 = cpustate->bamoffset; + m_moddim = dim2; + m_modm = m_subop & 0x20; + m_modadd = PC + 3 + m_amlength1; + m_amlength2 = (this->*DecodeOp2)(); + m_flag2 = m_amflag; + m_op2 = m_amout; + m_bamoffset2 = m_bamoffset; } -static void F7cDecodeOperands(v60_state *cpustate, UINT32 (*DecodeOp1)(v60_state *), UINT8 dim1, UINT32 (*DecodeOp2)(v60_state *), UINT8 dim2) +void v60_device::F7cDecodeOperands(am_func DecodeOp1, UINT8 dim1, am_func DecodeOp2, UINT8 dim2) { UINT8 appb; // Decode first operand - cpustate->moddim = dim1; - cpustate->modm = cpustate->subop & 0x40; - cpustate->modadd = cpustate->PC + 2; - cpustate->amlength1 = DecodeOp1(cpustate); - cpustate->flag1 = cpustate->amflag; - cpustate->op1 = cpustate->amout; + m_moddim = dim1; + m_modm = m_subop & 0x40; + m_modadd = PC + 2; + m_amlength1 = (this->*DecodeOp1)(); + m_flag1 = m_amflag; + m_op1 = m_amout; // Decode second operand - cpustate->moddim = dim2; - cpustate->modm = cpustate->subop & 0x20; - cpustate->modadd = cpustate->PC + 2 + cpustate->amlength1; - cpustate->amlength2 = DecodeOp2(cpustate); - cpustate->flag2 = cpustate->amflag; - cpustate->op2 = cpustate->amout; + m_moddim = dim2; + m_modm = m_subop & 0x20; + m_modadd = PC + 2 + m_amlength1; + m_amlength2 = (this->*DecodeOp2)(); + m_flag2 = m_amflag; + m_op2 = m_amout; // Decode ext - appb = OpRead8(cpustate, cpustate->PC + 2 + cpustate->amlength1 + cpustate->amlength2); + appb = OpRead8(PC + 2 + m_amlength1 + m_amlength2); if (appb & 0x80) - cpustate->lenop1 = cpustate->reg[appb & 0x1F]; + m_lenop1 = m_reg[appb & 0x1F]; else - cpustate->lenop1 = appb; + m_lenop1 = appb; } -#define F7CLOADOP1BYTE(cs,appb) \ - if ((cs)->flag1) \ - appb = (UINT8)((cs)->reg[(cs)->op1]&0xFF); \ +#define F7CLOADOP1BYTE(appb) \ + if (m_flag1) \ + appb = (UINT8)(m_reg[m_op1]&0xFF); \ else \ - appb = (cs)->program->read_byte((cs)->op1); + appb = m_program->read_byte(m_op1); -#define F7CLOADOP2BYTE(cs,appb) \ - if ((cs)->flag2) \ - appb = (UINT8)((cs)->reg[(cs)->op2]&0xFF); \ +#define F7CLOADOP2BYTE(appb) \ + if (m_flag2) \ + appb = (UINT8)(m_reg[m_op2]&0xFF); \ else \ - appb = (cs)->program->read_byte((cs)->op2); + appb = m_program->read_byte(m_op2); -#define F7CSTOREOP2BYTE(cs) \ - if ((cs)->flag2) \ - SETREG8((cs)->reg[(cs)->op2], appb); \ +#define F7CSTOREOP2BYTE() \ + if (m_flag2) \ + SETREG8(m_reg[m_op2], appb); \ else \ - (cs)->program->write_byte((cs)->op2, appb); + m_program->write_byte(m_op2, appb); -#define F7CSTOREOP2HALF(cs) \ - if ((cs)->flag2) \ - SETREG16((cs)->reg[(cs)->op2], apph); \ +#define F7CSTOREOP2HALF() \ + if (m_flag2) \ + SETREG16(m_reg[m_op2], apph); \ else \ - (cs)->program->write_word_unaligned((cs)->op2, apph); + m_program->write_word_unaligned(m_op2, apph); -static UINT32 opCMPSTRB(v60_state *cpustate, UINT8 bFill, UINT8 bStop) +UINT32 v60_device::opCMPSTRB(UINT8 bFill, UINT8 bStop) { UINT32 i, dest; UINT8 c1, c2; - F7aDecodeOperands(cpustate, ReadAMAddress, 0,ReadAMAddress, 0); + F7aDecodeOperands(&v60_device::ReadAMAddress, 0,&v60_device::ReadAMAddress, 0); // Filling if (bFill) { - if (cpustate->lenop1 < cpustate->lenop2) + if (m_lenop1 < m_lenop2) { - for (i = cpustate->lenop1; i < cpustate->lenop2; i++) - cpustate->program->write_byte(cpustate->op1 + i,(UINT8)cpustate->R26); + for (i = m_lenop1; i < m_lenop2; i++) + m_program->write_byte(m_op1 + i,(UINT8)R26); } - else if (cpustate->lenop2 < cpustate->lenop1) + else if (m_lenop2 < m_lenop1) { - for (i = cpustate->lenop2; i < cpustate->lenop1; i++) - cpustate->program->write_byte(cpustate->op2 + i,(UINT8)cpustate->R26); + for (i = m_lenop2; i < m_lenop1; i++) + m_program->write_byte(m_op2 + i,(UINT8)R26); } } - dest = (cpustate->lenop1 < cpustate->lenop2 ? cpustate->lenop1 : cpustate->lenop2); + dest = (m_lenop1 < m_lenop2 ? m_lenop1 : m_lenop2); - cpustate->_Z = 0; - cpustate->_S = 0; - if (bStop) cpustate->_CY = 1; + _Z = 0; + _S = 0; + if (bStop) _CY = 1; for (i = 0; i < dest; i++) { - c1 = cpustate->program->read_byte(cpustate->op1 + i); - c2 = cpustate->program->read_byte(cpustate->op2 + i); + c1 = m_program->read_byte(m_op1 + i); + c2 = m_program->read_byte(m_op2 + i); if (c1 > c2) { - cpustate->_S = 1; break; + _S = 1; break; } else if (c2 > c1) { - cpustate->_S = 0; break; + _S = 0; break; } if (bStop) - if (c1 == (UINT8)cpustate->R26 || c2 == (UINT8)cpustate->R26) + if (c1 == (UINT8)R26 || c2 == (UINT8)R26) { - cpustate->_CY = 0; + _CY = 0; break; } } - cpustate->R28 = cpustate->lenop1 + i; - cpustate->R27 = cpustate->lenop2 + i; + R28 = m_lenop1 + i; + R27 = m_lenop2 + i; if (i == dest) { - if (cpustate->lenop1 > cpustate->lenop2) - cpustate->_S = 1; - else if (cpustate->lenop2 > cpustate->lenop1) - cpustate->_S = 0; + if (m_lenop1 > m_lenop2) + _S = 1; + else if (m_lenop2 > m_lenop1) + _S = 0; else - cpustate->_Z = 1; + _Z = 1; } - F7AEND(cpustate); + F7AEND(); } -static UINT32 opCMPSTRH(v60_state *cpustate, UINT8 bFill, UINT8 bStop) +UINT32 v60_device::opCMPSTRH(UINT8 bFill, UINT8 bStop) { UINT32 i, dest; UINT16 c1, c2; - F7aDecodeOperands(cpustate, ReadAMAddress, 0,ReadAMAddress, 0); + F7aDecodeOperands(&v60_device::ReadAMAddress, 0,&v60_device::ReadAMAddress, 0); // Filling if (bFill) { - if (cpustate->lenop1 < cpustate->lenop2) + if (m_lenop1 < m_lenop2) { - for (i = cpustate->lenop1; i < cpustate->lenop2; i++) - cpustate->program->write_word_unaligned(cpustate->op1 + i * 2,(UINT16)cpustate->R26); + for (i = m_lenop1; i < m_lenop2; i++) + m_program->write_word_unaligned(m_op1 + i * 2,(UINT16)R26); } - else if (cpustate->lenop2 < cpustate->lenop1) + else if (m_lenop2 < m_lenop1) { - for (i = cpustate->lenop2; i < cpustate->lenop1; i++) - cpustate->program->write_word_unaligned(cpustate->op2 + i * 2,(UINT16)cpustate->R26); + for (i = m_lenop2; i < m_lenop1; i++) + m_program->write_word_unaligned(m_op2 + i * 2,(UINT16)R26); } } - dest = (cpustate->lenop1 < cpustate->lenop2 ? cpustate->lenop1 : cpustate->lenop2); + dest = (m_lenop1 < m_lenop2 ? m_lenop1 : m_lenop2); - cpustate->_Z = 0; - cpustate->_S = 0; - if (bStop) cpustate->_CY = 1; + _Z = 0; + _S = 0; + if (bStop) _CY = 1; for (i = 0; i < dest; i++) { - c1 = cpustate->program->read_word_unaligned(cpustate->op1 + i * 2); - c2 = cpustate->program->read_word_unaligned(cpustate->op2 + i * 2); + c1 = m_program->read_word_unaligned(m_op1 + i * 2); + c2 = m_program->read_word_unaligned(m_op2 + i * 2); if (c1 > c2) { - cpustate->_S = 1; break; + _S = 1; break; } else if (c2 > c1) { - cpustate->_S = 0; break; + _S = 0; break; } if (bStop) - if (c1 == (UINT16)cpustate->R26 || c2 == (UINT16)cpustate->R26) + if (c1 == (UINT16)R26 || c2 == (UINT16)R26) { - cpustate->_CY = 0; + _CY = 0; break; } } - cpustate->R28 = cpustate->lenop1 + i * 2; - cpustate->R27 = cpustate->lenop2 + i * 2; + R28 = m_lenop1 + i * 2; + R27 = m_lenop2 + i * 2; if (i == dest) { - if (cpustate->lenop1 > cpustate->lenop2) - cpustate->_S = 1; - else if (cpustate->lenop2 > cpustate->lenop1) - cpustate->_S = 0; + if (m_lenop1 > m_lenop2) + _S = 1; + else if (m_lenop2 > m_lenop1) + _S = 0; else - cpustate->_Z = 1; + _Z = 1; } - F7AEND(cpustate); + F7AEND(); } -static UINT32 opMOVSTRUB(v60_state *cpustate, UINT8 bFill, UINT8 bStop) /* TRUSTED (0, 0) (1, 0) */ +UINT32 v60_device::opMOVSTRUB(UINT8 bFill, UINT8 bStop) /* TRUSTED (0, 0) (1, 0) */ { UINT32 i, dest; UINT8 c1; @@ -302,67 +302,67 @@ static UINT32 opMOVSTRUB(v60_state *cpustate, UINT8 bFill, UINT8 bStop) /* TRUST // int a = 1; // } - F7aDecodeOperands(cpustate, ReadAMAddress, 0,ReadAMAddress, 0); + F7aDecodeOperands(&v60_device::ReadAMAddress, 0,&v60_device::ReadAMAddress, 0); - dest = (cpustate->lenop1 < cpustate->lenop2 ? cpustate->lenop1 : cpustate->lenop2); + dest = (m_lenop1 < m_lenop2 ? m_lenop1 : m_lenop2); for (i = 0; i < dest; i++) { - cpustate->program->write_byte(cpustate->op2 + i,(c1 = cpustate->program->read_byte(cpustate->op1 + i))); + m_program->write_byte(m_op2 + i,(c1 = m_program->read_byte(m_op1 + i))); - if (bStop && c1 == (UINT8)cpustate->R26) + if (bStop && c1 == (UINT8)R26) break; } - cpustate->R28 = cpustate->op1 + i; - cpustate->R27 = cpustate->op2 + i; + R28 = m_op1 + i; + R27 = m_op2 + i; - if (bFill && cpustate->lenop1 < cpustate->lenop2) + if (bFill && m_lenop1 < m_lenop2) { - for (;i < cpustate->lenop2; i++) - cpustate->program->write_byte(cpustate->op2 + i,(UINT8)cpustate->R26); + for (;i < m_lenop2; i++) + m_program->write_byte(m_op2 + i,(UINT8)R26); - cpustate->R27 = cpustate->op2 + i; + R27 = m_op2 + i; } - F7AEND(cpustate); + F7AEND(); } -static UINT32 opMOVSTRDB(v60_state *cpustate, UINT8 bFill, UINT8 bStop) +UINT32 v60_device::opMOVSTRDB(UINT8 bFill, UINT8 bStop) { UINT32 i, dest; UINT8 c1; - F7aDecodeOperands(cpustate, ReadAMAddress, 0,ReadAMAddress, 0); + F7aDecodeOperands(&v60_device::ReadAMAddress, 0,&v60_device::ReadAMAddress, 0); - dest = (cpustate->lenop1 < cpustate->lenop2 ? cpustate->lenop1 : cpustate->lenop2); + dest = (m_lenop1 < m_lenop2 ? m_lenop1 : m_lenop2); for (i = 0; i < dest; i++) { - cpustate->program->write_byte(cpustate->op2 + (dest - i - 1),(c1 = cpustate->program->read_byte(cpustate->op1 + (dest - i - 1)))); + m_program->write_byte(m_op2 + (dest - i - 1),(c1 = m_program->read_byte(m_op1 + (dest - i - 1)))); - if (bStop && c1 == (UINT8)cpustate->R26) + if (bStop && c1 == (UINT8)R26) break; } - cpustate->R28 = cpustate->op1 + (cpustate->lenop1 - i - 1); - cpustate->R27 = cpustate->op2 + (cpustate->lenop2 - i - 1); + R28 = m_op1 + (m_lenop1 - i - 1); + R27 = m_op2 + (m_lenop2 - i - 1); - if (bFill && cpustate->lenop1 < cpustate->lenop2) + if (bFill && m_lenop1 < m_lenop2) { - for (;i < cpustate->lenop2; i++) - cpustate->program->write_byte(cpustate->op2 + dest + (cpustate->lenop2 - i - 1),(UINT8)cpustate->R26); + for (;i < m_lenop2; i++) + m_program->write_byte(m_op2 + dest + (m_lenop2 - i - 1),(UINT8)R26); - cpustate->R27 = cpustate->op2 + (cpustate->lenop2 - i - 1); + R27 = m_op2 + (m_lenop2 - i - 1); } - F7AEND(cpustate); + F7AEND(); } -static UINT32 opMOVSTRUH(v60_state *cpustate, UINT8 bFill, UINT8 bStop) /* TRUSTED (0, 0) (1, 0) */ +UINT32 v60_device::opMOVSTRUH(UINT8 bFill, UINT8 bStop) /* TRUSTED (0, 0) (1, 0) */ { UINT32 i, dest; UINT16 c1; @@ -370,33 +370,33 @@ static UINT32 opMOVSTRUH(v60_state *cpustate, UINT8 bFill, UINT8 bStop) /* TRUST // if (bStop) // { int a = 1; } - F7aDecodeOperands(cpustate, ReadAMAddress, 1,ReadAMAddress, 1); + F7aDecodeOperands(&v60_device::ReadAMAddress, 1,&v60_device::ReadAMAddress, 1); - dest = (cpustate->lenop1 < cpustate->lenop2 ? cpustate->lenop1 : cpustate->lenop2); + dest = (m_lenop1 < m_lenop2 ? m_lenop1 : m_lenop2); for (i = 0; i < dest; i++) { - cpustate->program->write_word_unaligned(cpustate->op2 + i * 2,(c1 = cpustate->program->read_word_unaligned(cpustate->op1 + i * 2))); + m_program->write_word_unaligned(m_op2 + i * 2,(c1 = m_program->read_word_unaligned(m_op1 + i * 2))); - if (bStop && c1 == (UINT16)cpustate->R26) + if (bStop && c1 == (UINT16)R26) break; } - cpustate->R28 = cpustate->op1 + i * 2; - cpustate->R27 = cpustate->op2 + i * 2; + R28 = m_op1 + i * 2; + R27 = m_op2 + i * 2; - if (bFill && cpustate->lenop1 < cpustate->lenop2) + if (bFill && m_lenop1 < m_lenop2) { - for (;i < cpustate->lenop2; i++) - cpustate->program->write_word_unaligned(cpustate->op2 + i * 2,(UINT16)cpustate->R26); + for (;i < m_lenop2; i++) + m_program->write_word_unaligned(m_op2 + i * 2,(UINT16)R26); - cpustate->R27 = cpustate->op2 + i * 2; + R27 = m_op2 + i * 2; } - F7AEND(cpustate); + F7AEND(); } -static UINT32 opMOVSTRDH(v60_state *cpustate, UINT8 bFill, UINT8 bStop) +UINT32 v60_device::opMOVSTRDH(UINT8 bFill, UINT8 bStop) { UINT32 i, dest; UINT16 c1; @@ -404,228 +404,228 @@ static UINT32 opMOVSTRDH(v60_state *cpustate, UINT8 bFill, UINT8 bStop) // if (bFill | bStop) // { int a = 1; } - F7aDecodeOperands(cpustate, ReadAMAddress, 1,ReadAMAddress, 1); + F7aDecodeOperands(&v60_device::ReadAMAddress, 1,&v60_device::ReadAMAddress, 1); -// if (cpustate->lenop1 != cpustate->lenop2) +// if (m_lenop1 != m_lenop2) // { int a = 1; } - dest = (cpustate->lenop1 < cpustate->lenop2 ? cpustate->lenop1 : cpustate->lenop2); + dest = (m_lenop1 < m_lenop2 ? m_lenop1 : m_lenop2); for (i = 0; i < dest; i++) { - cpustate->program->write_word_unaligned(cpustate->op2 + (dest - i - 1) * 2,(c1 = cpustate->program->read_word_unaligned(cpustate->op1 + (dest - i - 1) * 2))); + m_program->write_word_unaligned(m_op2 + (dest - i - 1) * 2,(c1 = m_program->read_word_unaligned(m_op1 + (dest - i - 1) * 2))); - if (bStop && c1 == (UINT16)cpustate->R26) + if (bStop && c1 == (UINT16)R26) break; } - cpustate->R28 = cpustate->op1 + (cpustate->lenop1 - i - 1) * 2; - cpustate->R27 = cpustate->op2 + (cpustate->lenop2 - i - 1) * 2; + R28 = m_op1 + (m_lenop1 - i - 1) * 2; + R27 = m_op2 + (m_lenop2 - i - 1) * 2; - if (bFill && cpustate->lenop1 < cpustate->lenop2) + if (bFill && m_lenop1 < m_lenop2) { - for (;i < cpustate->lenop2; i++) - cpustate->program->write_word_unaligned(cpustate->op2 + (cpustate->lenop2 - i - 1) * 2,(UINT16)cpustate->R26); + for (;i < m_lenop2; i++) + m_program->write_word_unaligned(m_op2 + (m_lenop2 - i - 1) * 2,(UINT16)R26); - cpustate->R27 = cpustate->op2 + (cpustate->lenop2 - i - 1) * 2; + R27 = m_op2 + (m_lenop2 - i - 1) * 2; } - F7AEND(cpustate); + F7AEND(); } -static UINT32 opSEARCHUB(v60_state *cpustate, UINT8 bSearch) +UINT32 v60_device::opSEARCHUB(UINT8 bSearch) { UINT8 appb; UINT32 i; - F7bDecodeOperands(cpustate, ReadAMAddress, 0,ReadAM, 0); + F7bDecodeOperands(&v60_device::ReadAMAddress, 0,&v60_device::ReadAM, 0); - for (i = 0; i < cpustate->lenop1; i++) + for (i = 0; i < m_lenop1; i++) { - appb = (cpustate->program->read_byte(cpustate->op1 + i) == (UINT8)cpustate->op2); + appb = (m_program->read_byte(m_op1 + i) == (UINT8)m_op2); if ((bSearch && appb) || (!bSearch && !appb)) break; } - cpustate->R28 = cpustate->op1 + i; - cpustate->R27 = i; + R28 = m_op1 + i; + R27 = i; // This is the opposite as stated in V60 manual... - if (i != cpustate->lenop1) - cpustate->_Z = 0; + if (i != m_lenop1) + _Z = 0; else - cpustate->_Z = 1; + _Z = 1; - F7BEND(cpustate); + F7BEND(); } -static UINT32 opSEARCHUH(v60_state *cpustate, UINT8 bSearch) +UINT32 v60_device::opSEARCHUH(UINT8 bSearch) { UINT8 appb; UINT32 i; - F7bDecodeOperands(cpustate, ReadAMAddress, 1,ReadAM, 1); + F7bDecodeOperands(&v60_device::ReadAMAddress, 1,&v60_device::ReadAM, 1); - for (i = 0; i < cpustate->lenop1; i++) + for (i = 0; i < m_lenop1; i++) { - appb = (cpustate->program->read_word_unaligned(cpustate->op1 + i * 2) == (UINT16)cpustate->op2); + appb = (m_program->read_word_unaligned(m_op1 + i * 2) == (UINT16)m_op2); if ((bSearch && appb) || (!bSearch && !appb)) break; } - cpustate->R28 = cpustate->op1 + i * 2; - cpustate->R27 = i; + R28 = m_op1 + i * 2; + R27 = i; - if (i != cpustate->lenop1) - cpustate->_Z = 0; + if (i != m_lenop1) + _Z = 0; else - cpustate->_Z = 1; + _Z = 1; - F7BEND(cpustate); + F7BEND(); } -static UINT32 opSEARCHDB(v60_state *cpustate, UINT8 bSearch) +UINT32 v60_device::opSEARCHDB(UINT8 bSearch) { UINT8 appb; INT32 i; - F7bDecodeOperands(cpustate, ReadAMAddress, 0,ReadAM, 0); + F7bDecodeOperands(&v60_device::ReadAMAddress, 0,&v60_device::ReadAM, 0); - for (i = cpustate->lenop1; i >= 0; i--) + for (i = m_lenop1; i >= 0; i--) { - appb = (cpustate->program->read_byte(cpustate->op1 + i) == (UINT8)cpustate->op2); + appb = (m_program->read_byte(m_op1 + i) == (UINT8)m_op2); if ((bSearch && appb) || (!bSearch && !appb)) break; } - cpustate->R28 = cpustate->op1 + i; - cpustate->R27 = i; + R28 = m_op1 + i; + R27 = i; // This is the opposite as stated in V60 manual... - if ((UINT32)i != cpustate->lenop1) - cpustate->_Z = 0; + if ((UINT32)i != m_lenop1) + _Z = 0; else - cpustate->_Z = 1; + _Z = 1; - F7BEND(cpustate); + F7BEND(); } -static UINT32 opSEARCHDH(v60_state *cpustate, UINT8 bSearch) +UINT32 v60_device::opSEARCHDH(UINT8 bSearch) { UINT8 appb; INT32 i; - F7bDecodeOperands(cpustate, ReadAMAddress, 1,ReadAM, 1); + F7bDecodeOperands(&v60_device::ReadAMAddress, 1,&v60_device::ReadAM, 1); - for (i = cpustate->lenop1 - 1; i >= 0; i--) + for (i = m_lenop1 - 1; i >= 0; i--) { - appb = (cpustate->program->read_word_unaligned(cpustate->op1 + i * 2) == (UINT16)cpustate->op2); + appb = (m_program->read_word_unaligned(m_op1 + i * 2) == (UINT16)m_op2); if ((bSearch && appb) || (!bSearch && !appb)) break; } - cpustate->R28 = cpustate->op1 + i * 2; - cpustate->R27 = i; + R28 = m_op1 + i * 2; + R27 = i; - if ((UINT32)i != cpustate->lenop1) - cpustate->_Z = 0; + if ((UINT32)i != m_lenop1) + _Z = 0; else - cpustate->_Z = 1; + _Z = 1; - F7BEND(cpustate); + F7BEND(); } -static UINT32 opSCHCUB(v60_state *cpustate) { return opSEARCHUB(cpustate, 1); } -static UINT32 opSCHCUH(v60_state *cpustate) { return opSEARCHUH(cpustate, 1); } -static UINT32 opSCHCDB(v60_state *cpustate) { return opSEARCHDB(cpustate, 1); } -static UINT32 opSCHCDH(v60_state *cpustate) { return opSEARCHDH(cpustate, 1); } -static UINT32 opSKPCUB(v60_state *cpustate) { return opSEARCHUB(cpustate, 0); } -static UINT32 opSKPCUH(v60_state *cpustate) { return opSEARCHUH(cpustate, 0); } -static UINT32 opSKPCDB(v60_state *cpustate) { return opSEARCHDB(cpustate, 0); } -static UINT32 opSKPCDH(v60_state *cpustate) { return opSEARCHDH(cpustate, 0); } +UINT32 v60_device::opSCHCUB() { return opSEARCHUB(1); } +UINT32 v60_device::opSCHCUH() { return opSEARCHUH(1); } +UINT32 v60_device::opSCHCDB() { return opSEARCHDB(1); } +UINT32 v60_device::opSCHCDH() { return opSEARCHDH(1); } +UINT32 v60_device::opSKPCUB() { return opSEARCHUB(0); } +UINT32 v60_device::opSKPCUH() { return opSEARCHUH(0); } +UINT32 v60_device::opSKPCDB() { return opSEARCHDB(0); } +UINT32 v60_device::opSKPCDH() { return opSEARCHDH(0); } -static UINT32 opCMPCB(v60_state *cpustate) { return opCMPSTRB(cpustate, 0, 0); } -static UINT32 opCMPCH(v60_state *cpustate) { return opCMPSTRH(cpustate, 0, 0); } -static UINT32 opCMPCFB(v60_state *cpustate) { return opCMPSTRB(cpustate, 1, 0); } -static UINT32 opCMPCFH(v60_state *cpustate) { return opCMPSTRH(cpustate, 1, 0); } -static UINT32 opCMPCSB(v60_state *cpustate) { return opCMPSTRB(cpustate, 0, 1); } -static UINT32 opCMPCSH(v60_state *cpustate) { return opCMPSTRH(cpustate, 0, 1); } +UINT32 v60_device::opCMPCB() { return opCMPSTRB(0, 0); } +UINT32 v60_device::opCMPCH() { return opCMPSTRH(0, 0); } +UINT32 v60_device::opCMPCFB() { return opCMPSTRB(1, 0); } +UINT32 v60_device::opCMPCFH() { return opCMPSTRH(1, 0); } +UINT32 v60_device::opCMPCSB() { return opCMPSTRB(0, 1); } +UINT32 v60_device::opCMPCSH() { return opCMPSTRH(0, 1); } -static UINT32 opMOVCUB(v60_state *cpustate) { return opMOVSTRUB(cpustate, 0, 0); } -static UINT32 opMOVCUH(v60_state *cpustate) { return opMOVSTRUH(cpustate, 0, 0); } -static UINT32 opMOVCFUB(v60_state *cpustate) { return opMOVSTRUB(cpustate, 1, 0); } -static UINT32 opMOVCFUH(v60_state *cpustate) { return opMOVSTRUH(cpustate, 1, 0); } -static UINT32 opMOVCSUB(v60_state *cpustate) { return opMOVSTRUB(cpustate, 0, 1); } -static UINT32 opMOVCSUH(v60_state *cpustate) { return opMOVSTRUH(cpustate, 0, 1); } +UINT32 v60_device::opMOVCUB() { return opMOVSTRUB(0, 0); } +UINT32 v60_device::opMOVCUH() { return opMOVSTRUH(0, 0); } +UINT32 v60_device::opMOVCFUB() { return opMOVSTRUB(1, 0); } +UINT32 v60_device::opMOVCFUH() { return opMOVSTRUH(1, 0); } +UINT32 v60_device::opMOVCSUB() { return opMOVSTRUB(0, 1); } +UINT32 v60_device::opMOVCSUH() { return opMOVSTRUH(0, 1); } -static UINT32 opMOVCDB(v60_state *cpustate) { return opMOVSTRDB(cpustate, 0, 0); } -static UINT32 opMOVCDH(v60_state *cpustate) { return opMOVSTRDH(cpustate, 0, 0); } -static UINT32 opMOVCFDB(v60_state *cpustate) { return opMOVSTRDB(cpustate, 1, 0); } -static UINT32 opMOVCFDH(v60_state *cpustate) { return opMOVSTRDH(cpustate, 1, 0); } +UINT32 v60_device::opMOVCDB() { return opMOVSTRDB(0, 0); } +UINT32 v60_device::opMOVCDH() { return opMOVSTRDH(0, 0); } +UINT32 v60_device::opMOVCFDB() { return opMOVSTRDB(1, 0); } +UINT32 v60_device::opMOVCFDH() { return opMOVSTRDH(1, 0); } -static UINT32 opEXTBFZ(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opEXTBFZ() /* TRUSTED */ { - F7bDecodeFirstOperand(cpustate, BitReadAM, 11); + F7bDecodeFirstOperand(&v60_device::BitReadAM, 11); - F7BCREATEBITMASK(cpustate->lenop1); + F7BCREATEBITMASK(m_lenop1); - cpustate->modwritevalw = (cpustate->op1 >> cpustate->bamoffset) & cpustate->lenop1; + m_modwritevalw = (m_op1 >> m_bamoffset) & m_lenop1; - F7bWriteSecondOperand(cpustate, 2); + F7bWriteSecondOperand(2); - F7BEND(cpustate); + F7BEND(); } -static UINT32 opEXTBFS(v60_state *cpustate) /* TRUSTED */ +UINT32 v60_device::opEXTBFS() /* TRUSTED */ { - F7bDecodeFirstOperand(cpustate, BitReadAM, 11); + F7bDecodeFirstOperand(&v60_device::BitReadAM, 11); - F7BCREATEBITMASK(cpustate->lenop1); + F7BCREATEBITMASK(m_lenop1); - cpustate->modwritevalw = (cpustate->op1 >> cpustate->bamoffset) & cpustate->lenop1; - if (cpustate->modwritevalw & ((cpustate->lenop1 + 1) >> 1)) - cpustate->modwritevalw |= ~cpustate->lenop1; + m_modwritevalw = (m_op1 >> m_bamoffset) & m_lenop1; + if (m_modwritevalw & ((m_lenop1 + 1) >> 1)) + m_modwritevalw |= ~m_lenop1; - F7bWriteSecondOperand(cpustate, 2); + F7bWriteSecondOperand(2); - F7BEND(cpustate); + F7BEND(); } -static UINT32 opEXTBFL(v60_state *cpustate) +UINT32 v60_device::opEXTBFL() { UINT32 appw; - F7bDecodeFirstOperand(cpustate, BitReadAM, 11); + F7bDecodeFirstOperand(&v60_device::BitReadAM, 11); - appw = cpustate->lenop1; - F7BCREATEBITMASK(cpustate->lenop1); + appw = m_lenop1; + F7BCREATEBITMASK(m_lenop1); - cpustate->modwritevalw = (cpustate->op1 >> cpustate->bamoffset) & cpustate->lenop1; - cpustate->modwritevalw <<= 32 - appw; + m_modwritevalw = (m_op1 >> m_bamoffset) & m_lenop1; + m_modwritevalw <<= 32 - appw; - F7bWriteSecondOperand(cpustate, 2); + F7bWriteSecondOperand(2); - F7BEND(cpustate); + F7BEND(); } -static UINT32 opSCHBS(v60_state *cpustate, UINT32 bSearch1) +UINT32 v60_device::opSCHBS(UINT32 bSearch1) { UINT32 i, data; UINT32 offset; - F7bDecodeFirstOperand(cpustate, BitReadAMAddress, 10); + F7bDecodeFirstOperand(&v60_device::BitReadAMAddress, 10); // Read first UINT8 - cpustate->op1 += cpustate->bamoffset / 8; - data = cpustate->program->read_byte(cpustate->op1); - offset = cpustate->bamoffset & 7; + m_op1 += m_bamoffset / 8; + data = m_program->read_byte(m_op1); + offset = m_bamoffset & 7; // Scan bitstring - for (i = 0; i < cpustate->lenop1; i++) + for (i = 0; i < m_lenop1; i++) { // Update the work register - cpustate->R28 = cpustate->op1; + R28 = m_op1; // There is a 0 / 1 at current offset? if ((bSearch1 && (data&(1 << offset))) || @@ -638,574 +638,574 @@ static UINT32 opSCHBS(v60_state *cpustate, UINT32 bSearch1) { // Next UINT8 please offset = 0; - cpustate->op1++; - data = cpustate->program->read_byte(cpustate->op1); + m_op1++; + data = m_program->read_byte(m_op1); } } // Set zero if bit not found - cpustate->_Z = (i == cpustate->lenop1); + _Z = (i == m_lenop1); // Write to destination the final offset - cpustate->modwritevalw = i; - F7bWriteSecondOperand(cpustate, 2); + m_modwritevalw = i; + F7bWriteSecondOperand(2); - F7BEND(cpustate); + F7BEND(); } -static UINT32 opSCH0BSU(v60_state *cpustate) { return opSCHBS(cpustate, 0); } -static UINT32 opSCH1BSU(v60_state *cpustate) { return opSCHBS(cpustate, 1); } +UINT32 v60_device::opSCH0BSU() { return opSCHBS(0); } +UINT32 v60_device::opSCH1BSU() { return opSCHBS(1); } -static UINT32 opINSBFR(v60_state *cpustate) +UINT32 v60_device::opINSBFR() { UINT32 appw; - F7cDecodeOperands(cpustate, ReadAM, 2,BitReadAMAddress, 11); + F7cDecodeOperands(&v60_device::ReadAM, 2,&v60_device::BitReadAMAddress, 11); - F7CCREATEBITMASK(cpustate->lenop1); + F7CCREATEBITMASK(m_lenop1); - cpustate->op2 += cpustate->bamoffset / 8; - appw = cpustate->program->read_dword_unaligned(cpustate->op2); - cpustate->bamoffset &= 7; + m_op2 += m_bamoffset / 8; + appw = m_program->read_dword_unaligned(m_op2); + m_bamoffset &= 7; - appw &= ~(cpustate->lenop1 << cpustate->bamoffset); - appw |= (cpustate->lenop1 & cpustate->op1) << cpustate->bamoffset; + appw &= ~(m_lenop1 << m_bamoffset); + appw |= (m_lenop1 & m_op1) << m_bamoffset; - cpustate->program->write_dword_unaligned(cpustate->op2, appw); + m_program->write_dword_unaligned(m_op2, appw); - F7CEND(cpustate); + F7CEND(); } -static UINT32 opINSBFL(v60_state *cpustate) +UINT32 v60_device::opINSBFL() { UINT32 appw; - F7cDecodeOperands(cpustate, ReadAM, 2,BitReadAMAddress, 11); + F7cDecodeOperands(&v60_device::ReadAM, 2,&v60_device::BitReadAMAddress, 11); - cpustate->op1 >>= (32 - cpustate->lenop1); + m_op1 >>= (32 - m_lenop1); - F7CCREATEBITMASK(cpustate->lenop1); + F7CCREATEBITMASK(m_lenop1); - cpustate->op2 += cpustate->bamoffset / 8; - appw = cpustate->program->read_dword_unaligned(cpustate->op2); - cpustate->bamoffset &= 7; + m_op2 += m_bamoffset / 8; + appw = m_program->read_dword_unaligned(m_op2); + m_bamoffset &= 7; - appw &= ~(cpustate->lenop1 << cpustate->bamoffset); - appw |= (cpustate->lenop1 & cpustate->op1) << cpustate->bamoffset; + appw &= ~(m_lenop1 << m_bamoffset); + appw |= (m_lenop1 & m_op1) << m_bamoffset; - cpustate->program->write_dword_unaligned(cpustate->op2, appw); + m_program->write_dword_unaligned(m_op2, appw); - F7CEND(cpustate); + F7CEND(); } -static UINT32 opMOVBSD(v60_state *cpustate) +UINT32 v60_device::opMOVBSD() { UINT32 i; UINT8 srcdata, dstdata; - F7bDecodeOperands(cpustate, BitReadAMAddress, 10, BitReadAMAddress, 10); + F7bDecodeOperands(&v60_device::BitReadAMAddress, 10, &v60_device::BitReadAMAddress, 10); -// if (cpustate->lenop1 != 1) +// if (m_lenop1 != 1) // { int a = 1; } - cpustate->bamoffset1 += cpustate->lenop1 - 1; - cpustate->bamoffset2 += cpustate->lenop1 - 1; + m_bamoffset1 += m_lenop1 - 1; + m_bamoffset2 += m_lenop1 - 1; - cpustate->op1 += cpustate->bamoffset1 / 8; - cpustate->op2 += cpustate->bamoffset2 / 8; + m_op1 += m_bamoffset1 / 8; + m_op2 += m_bamoffset2 / 8; - cpustate->bamoffset1 &= 7; - cpustate->bamoffset2 &= 7; + m_bamoffset1 &= 7; + m_bamoffset2 &= 7; - srcdata = cpustate->program->read_byte(cpustate->op1); - dstdata = cpustate->program->read_byte(cpustate->op2); + srcdata = m_program->read_byte(m_op1); + dstdata = m_program->read_byte(m_op2); - for (i = 0; i < cpustate->lenop1; i++) + for (i = 0; i < m_lenop1; i++) { // Update work registers - cpustate->R28 = cpustate->op1; - cpustate->R27 = cpustate->op2; + R28 = m_op1; + R27 = m_op2; - dstdata &= ~(1 << cpustate->bamoffset2); - dstdata |= ((srcdata >> cpustate->bamoffset1) & 1) << cpustate->bamoffset2; + dstdata &= ~(1 << m_bamoffset2); + dstdata |= ((srcdata >> m_bamoffset1) & 1) << m_bamoffset2; - if (cpustate->bamoffset1 == 0) + if (m_bamoffset1 == 0) { - cpustate->bamoffset1 = 8; - cpustate->op1--; - srcdata = cpustate->program->read_byte(cpustate->op1); + m_bamoffset1 = 8; + m_op1--; + srcdata = m_program->read_byte(m_op1); } - if (cpustate->bamoffset2 == 0) + if (m_bamoffset2 == 0) { - cpustate->program->write_byte(cpustate->op2, dstdata); - cpustate->bamoffset2 = 8; - cpustate->op2--; - dstdata = cpustate->program->read_byte(cpustate->op2); + m_program->write_byte(m_op2, dstdata); + m_bamoffset2 = 8; + m_op2--; + dstdata = m_program->read_byte(m_op2); } - cpustate->bamoffset1--; - cpustate->bamoffset2--; + m_bamoffset1--; + m_bamoffset2--; } // Flush of the final data - if (cpustate->bamoffset2 != 7) - cpustate->program->write_byte(cpustate->op2, dstdata); + if (m_bamoffset2 != 7) + m_program->write_byte(m_op2, dstdata); - F7BEND(cpustate); + F7BEND(); } -static UINT32 opMOVBSU(v60_state *cpustate) +UINT32 v60_device::opMOVBSU() { UINT32 i; UINT8 srcdata, dstdata; - F7bDecodeOperands(cpustate, BitReadAMAddress, 10, BitReadAMAddress, 10); + F7bDecodeOperands(&v60_device::BitReadAMAddress, 10, &v60_device::BitReadAMAddress, 10); - cpustate->op1 += cpustate->bamoffset1 / 8; - cpustate->op2 += cpustate->bamoffset2 / 8; + m_op1 += m_bamoffset1 / 8; + m_op2 += m_bamoffset2 / 8; - cpustate->bamoffset1 &= 7; - cpustate->bamoffset2 &= 7; + m_bamoffset1 &= 7; + m_bamoffset2 &= 7; - srcdata = cpustate->program->read_byte(cpustate->op1); - dstdata = cpustate->program->read_byte(cpustate->op2); + srcdata = m_program->read_byte(m_op1); + dstdata = m_program->read_byte(m_op2); - for (i = 0; i < cpustate->lenop1; i++) + for (i = 0; i < m_lenop1; i++) { // Update work registers - cpustate->R28 = cpustate->op1; - cpustate->R27 = cpustate->op2; + R28 = m_op1; + R27 = m_op2; - dstdata &= ~(1 << cpustate->bamoffset2); - dstdata |= ((srcdata >> cpustate->bamoffset1) & 1) << cpustate->bamoffset2; + dstdata &= ~(1 << m_bamoffset2); + dstdata |= ((srcdata >> m_bamoffset1) & 1) << m_bamoffset2; - cpustate->bamoffset1++; - cpustate->bamoffset2++; - if (cpustate->bamoffset1 == 8) + m_bamoffset1++; + m_bamoffset2++; + if (m_bamoffset1 == 8) { - cpustate->bamoffset1 = 0; - cpustate->op1++; - srcdata = cpustate->program->read_byte(cpustate->op1); + m_bamoffset1 = 0; + m_op1++; + srcdata = m_program->read_byte(m_op1); } - if (cpustate->bamoffset2 == 8) + if (m_bamoffset2 == 8) { - cpustate->program->write_byte(cpustate->op2, dstdata); - cpustate->bamoffset2 = 0; - cpustate->op2++; - dstdata = cpustate->program->read_byte(cpustate->op2); + m_program->write_byte(m_op2, dstdata); + m_bamoffset2 = 0; + m_op2++; + dstdata = m_program->read_byte(m_op2); } } // Flush of the final data - if (cpustate->bamoffset2 != 0) - cpustate->program->write_byte(cpustate->op2, dstdata); + if (m_bamoffset2 != 0) + m_program->write_byte(m_op2, dstdata); - F7BEND(cpustate); + F7BEND(); } // RADM 0x20f4b8 holds the time left -static UINT32 opADDDC(v60_state *cpustate) +UINT32 v60_device::opADDDC() { UINT8 appb; UINT8 src, dst; - F7cDecodeOperands(cpustate, ReadAM, 0, ReadAMAddress, 0); + F7cDecodeOperands(&v60_device::ReadAM, 0, &v60_device::ReadAMAddress, 0); - if (cpustate->lenop1 != 0) + if (m_lenop1 != 0) { - logerror("ADDDC %x (pat: %x)\n", cpustate->op1, cpustate->lenop1); + logerror("ADDDC %x (pat: %x)\n", m_op1, m_lenop1); } - F7CLOADOP2BYTE(cpustate, appb); + F7CLOADOP2BYTE(appb); - src = (UINT8)(cpustate->op1 >> 4) * 10 + (UINT8)(cpustate->op1 & 0xF); + src = (UINT8)(m_op1 >> 4) * 10 + (UINT8)(m_op1 & 0xF); dst = (appb >> 4) * 10 + (appb & 0xF); - appb = src + dst + (cpustate->_CY?1:0); + appb = src + dst + (_CY?1:0); if (appb >= 100) { appb -= 100; - cpustate->_CY = 1; + _CY = 1; } else - cpustate->_CY = 0; + _CY = 0; // compute z flag: // cleared if result non-zero or carry generated // unchanged otherwise - if (appb != 0 || cpustate->_CY) - cpustate->_Z = 0; + if (appb != 0 || _CY) + _Z = 0; appb = ((appb / 10) << 4) | (appb % 10); - F7CSTOREOP2BYTE(cpustate); - F7CEND(cpustate); + F7CSTOREOP2BYTE(); + F7CEND(); } -static UINT32 opSUBDC(v60_state *cpustate) +UINT32 v60_device::opSUBDC() { INT8 appb; UINT32 src, dst; - F7cDecodeOperands(cpustate, ReadAM, 0, ReadAMAddress, 0); + F7cDecodeOperands(&v60_device::ReadAM, 0, &v60_device::ReadAMAddress, 0); - if (cpustate->lenop1 != 0) + if (m_lenop1 != 0) { - logerror("SUBDC %x (pat: %x)\n", cpustate->op1, cpustate->lenop1); + logerror("SUBDC %x (pat: %x)\n", m_op1, m_lenop1); } - F7CLOADOP2BYTE(cpustate, appb); + F7CLOADOP2BYTE(appb); - src = (UINT32)(cpustate->op1 >> 4) * 10 + (UINT32)(cpustate->op1 & 0xF); + src = (UINT32)(m_op1 >> 4) * 10 + (UINT32)(m_op1 & 0xF); dst = ((appb & 0xF0) >> 4) * 10 + (appb & 0xF); // Note that this APPB must be SIGNED! - appb = (INT32)dst - (INT32)src - (cpustate->_CY?1:0); + appb = (INT32)dst - (INT32)src - (_CY?1:0); if (appb < 0) { appb += 100; - cpustate->_CY = 1; + _CY = 1; } else - cpustate->_CY = 0; + _CY = 0; // compute z flag: // cleared if result non-zero or carry generated // unchanged otherwise - if (appb != 0 || cpustate->_CY) - cpustate->_Z = 0; + if (appb != 0 || _CY) + _Z = 0; appb = ((appb / 10) << 4) | (appb % 10); - F7CSTOREOP2BYTE(cpustate); - F7CEND(cpustate); + F7CSTOREOP2BYTE(); + F7CEND(); } -static UINT32 opSUBRDC(v60_state *cpustate) +UINT32 v60_device::opSUBRDC() { INT8 appb; UINT32 src, dst; - F7cDecodeOperands(cpustate, ReadAM, 0, ReadAMAddress, 0); + F7cDecodeOperands(&v60_device::ReadAM, 0, &v60_device::ReadAMAddress, 0); - if (cpustate->lenop1 != 0) + if (m_lenop1 != 0) { - logerror("SUBRDC %x (pat: %x)\n", cpustate->op1, cpustate->lenop1); + logerror("SUBRDC %x (pat: %x)\n", m_op1, m_lenop1); } - F7CLOADOP2BYTE(cpustate, appb); + F7CLOADOP2BYTE(appb); - src = (UINT32)(cpustate->op1 >> 4) * 10 + (UINT32)(cpustate->op1 & 0xF); + src = (UINT32)(m_op1 >> 4) * 10 + (UINT32)(m_op1 & 0xF); dst = ((appb & 0xF0) >> 4) * 10 + (appb & 0xF); // Note that this APPB must be SIGNED! - appb = (INT32)src - (INT32)dst - (cpustate->_CY?1:0); + appb = (INT32)src - (INT32)dst - (_CY?1:0); if (appb < 0) { appb += 100; - cpustate->_CY = 1; + _CY = 1; } else - cpustate->_CY = 0; + _CY = 0; // compute z flag: // cleared if result non-zero or carry generated // unchanged otherwise - if (appb != 0 || cpustate->_CY) - cpustate->_Z = 0; + if (appb != 0 || _CY) + _Z = 0; appb = ((appb / 10) << 4) | (appb % 10); - F7CSTOREOP2BYTE(cpustate); - F7CEND(cpustate); + F7CSTOREOP2BYTE(); + F7CEND(); } -static UINT32 opCVTDPZ(v60_state *cpustate) +UINT32 v60_device::opCVTDPZ() { UINT16 apph; - F7cDecodeOperands(cpustate, ReadAM, 0, ReadAMAddress, 1); + F7cDecodeOperands(&v60_device::ReadAM, 0, &v60_device::ReadAMAddress, 1); - apph = (UINT16)(((cpustate->op1 >> 4) & 0xF) | ((cpustate->op1 & 0xF) << 8)); - apph |= (cpustate->lenop1); - apph |= (cpustate->lenop1 << 8); + apph = (UINT16)(((m_op1 >> 4) & 0xF) | ((m_op1 & 0xF) << 8)); + apph |= (m_lenop1); + apph |= (m_lenop1 << 8); // Z flag is unchanged if src is zero, cleared otherwise - if (cpustate->op1 != 0) cpustate->_Z = 0; + if (m_op1 != 0) _Z = 0; - F7CSTOREOP2HALF(cpustate); - F7CEND(cpustate); + F7CSTOREOP2HALF(); + F7CEND(); } -static UINT32 opCVTDZP(v60_state *cpustate) +UINT32 v60_device::opCVTDZP() { UINT8 appb; - F7cDecodeOperands(cpustate, ReadAM, 1, ReadAMAddress, 0); + F7cDecodeOperands(&v60_device::ReadAM, 1, &v60_device::ReadAMAddress, 0); - if ((cpustate->op1 & 0xF0) != (cpustate->lenop1 & 0xF0) || ((cpustate->op1 >> 8) & 0xF0) != (cpustate->lenop1 & 0xF0)) + if ((m_op1 & 0xF0) != (m_lenop1 & 0xF0) || ((m_op1 >> 8) & 0xF0) != (m_lenop1 & 0xF0)) { // Decimal exception logerror("CVTD.ZP Decimal exception #1!\n"); } - if ((cpustate->op1 & 0xF) > 9 || ((cpustate->op1 >> 8) & 0xF) > 9) + if ((m_op1 & 0xF) > 9 || ((m_op1 >> 8) & 0xF) > 9) { // Decimal exception logerror("CVTD.ZP Decimal exception #2!\n"); } - appb = (UINT8)(((cpustate->op1 >> 8) & 0xF) | ((cpustate->op1 & 0xF) << 4)); - if (appb != 0) cpustate->_Z = 0; + appb = (UINT8)(((m_op1 >> 8) & 0xF) | ((m_op1 & 0xF) << 4)); + if (appb != 0) _Z = 0; - F7CSTOREOP2BYTE(cpustate); - F7CEND(cpustate); + F7CSTOREOP2BYTE(); + F7CEND(); } -static UINT32 op58UNHANDLED(v60_state *cpustate) +UINT32 v60_device::op58UNHANDLED() { - fatalerror("Unhandled 58 opcode at cpustate->PC: /%06x\n", cpustate->PC); + fatalerror("Unhandled 58 opcode at PC: /%06x\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 op5AUNHANDLED(v60_state *cpustate) +UINT32 v60_device::op5AUNHANDLED() { - fatalerror("Unhandled 5A opcode at cpustate->PC: /%06x\n", cpustate->PC); + fatalerror("Unhandled 5A opcode at PC: /%06x\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 op5BUNHANDLED(v60_state *cpustate) +UINT32 v60_device::op5BUNHANDLED() { - fatalerror("Unhandled 5B opcode at cpustate->PC: /%06x\n", cpustate->PC); + fatalerror("Unhandled 5B opcode at PC: /%06x\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 op5DUNHANDLED(v60_state *cpustate) +UINT32 v60_device::op5DUNHANDLED() { - fatalerror("Unhandled 5D opcode at cpustate->PC: /%06x\n", cpustate->PC); + fatalerror("Unhandled 5D opcode at PC: /%06x\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 op59UNHANDLED(v60_state *cpustate) +UINT32 v60_device::op59UNHANDLED() { - fatalerror("Unhandled 59 opcode at cpustate->PC: /%06x\n", cpustate->PC); + fatalerror("Unhandled 59 opcode at PC: /%06x\n", PC); return 0; /* never reached, fatalerror won't return */ } -static UINT32 (*const Op59Table[32])(v60_state *) = +const v60_device::am_func v60_device::s_Op59Table[32] = { - opADDDC, - opSUBDC, - opSUBRDC, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - opCVTDPZ, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - opCVTDZP, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED, - op59UNHANDLED + &v60_device::opADDDC, + &v60_device::opSUBDC, + &v60_device::opSUBRDC, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::opCVTDPZ, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::opCVTDZP, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED, + &v60_device::op59UNHANDLED }; -static UINT32 (*const Op5BTable[32])(v60_state *) = +const v60_device::am_func v60_device::s_Op5BTable[32] = { - opSCH0BSU, - op5BUNHANDLED, - opSCH1BSU, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - opMOVBSU, - opMOVBSD, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED, - op5BUNHANDLED + &v60_device::opSCH0BSU, + &v60_device::op5BUNHANDLED, + &v60_device::opSCH1BSU, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::opMOVBSU, + &v60_device::opMOVBSD, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED, + &v60_device::op5BUNHANDLED }; -static UINT32 (*const Op5DTable[32])(v60_state *) = +const v60_device::am_func v60_device::s_Op5DTable[32] = { - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - opEXTBFS, - opEXTBFZ, - opEXTBFL, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - opINSBFR, - opINSBFL, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED, - op5DUNHANDLED + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::opEXTBFS, + &v60_device::opEXTBFZ, + &v60_device::opEXTBFL, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::opINSBFR, + &v60_device::opINSBFL, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED, + &v60_device::op5DUNHANDLED }; -static UINT32 (*const Op58Table[32])(v60_state *) = +const v60_device::am_func v60_device::s_Op58Table[32] = { - opCMPCB, - opCMPCFB, - opCMPCSB, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - opMOVCUB, - opMOVCDB, - opMOVCFUB, - opMOVCFDB, - opMOVCSUB, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - opSCHCUB, - opSCHCDB, - opSKPCUB, - opSKPCDB, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED, - op58UNHANDLED + &v60_device::opCMPCB, + &v60_device::opCMPCFB, + &v60_device::opCMPCSB, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::opMOVCUB, + &v60_device::opMOVCDB, + &v60_device::opMOVCFUB, + &v60_device::opMOVCFDB, + &v60_device::opMOVCSUB, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::opSCHCUB, + &v60_device::opSCHCDB, + &v60_device::opSKPCUB, + &v60_device::opSKPCDB, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED, + &v60_device::op58UNHANDLED }; -static UINT32 (*const Op5ATable[32])(v60_state *) = +const v60_device::am_func v60_device::s_Op5ATable[32] = { - opCMPCH, - opCMPCFH, - opCMPCSH, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - opMOVCUH, - opMOVCDH, - opMOVCFUH, - opMOVCFDH, - opMOVCSUH, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - opSCHCUH, - opSCHCDH, - opSKPCUH, - opSKPCDH, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED, - op5AUNHANDLED + &v60_device::opCMPCH, + &v60_device::opCMPCFH, + &v60_device::opCMPCSH, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::opMOVCUH, + &v60_device::opMOVCDH, + &v60_device::opMOVCFUH, + &v60_device::opMOVCFDH, + &v60_device::opMOVCSUH, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::opSCHCUH, + &v60_device::opSCHCDH, + &v60_device::opSKPCUH, + &v60_device::opSKPCDH, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED, + &v60_device::op5AUNHANDLED }; -static UINT32 op58(v60_state *cpustate) +UINT32 v60_device::op58() { - cpustate->subop = OpRead8(cpustate, cpustate->PC + 1); + m_subop = OpRead8(PC + 1); - return Op58Table[cpustate->subop & 0x1F](cpustate); + return (this->*s_Op58Table[m_subop & 0x1F])(); } -static UINT32 op5A(v60_state *cpustate) +UINT32 v60_device::op5A() { - cpustate->subop = OpRead8(cpustate, cpustate->PC + 1); + m_subop = OpRead8(PC + 1); - return Op5ATable[cpustate->subop & 0x1F](cpustate); + return (this->*s_Op5ATable[m_subop & 0x1F])(); } -static UINT32 op5B(v60_state *cpustate) +UINT32 v60_device::op5B() { - cpustate->subop = OpRead8(cpustate, cpustate->PC + 1); + m_subop = OpRead8(PC + 1); - return Op5BTable[cpustate->subop & 0x1F](cpustate); + return (this->*s_Op5BTable[m_subop & 0x1F])(); } -static UINT32 op5D(v60_state *cpustate) +UINT32 v60_device::op5D() { - cpustate->subop = OpRead8(cpustate, cpustate->PC + 1); + m_subop = OpRead8(PC + 1); - return Op5DTable[cpustate->subop & 0x1F](cpustate); + return (this->*s_Op5DTable[m_subop & 0x1F])(); } -static UINT32 op59(v60_state *cpustate) +UINT32 v60_device::op59() { - cpustate->subop = OpRead8(cpustate, cpustate->PC + 1); + m_subop = OpRead8(PC + 1); - return Op59Table[cpustate->subop & 0x1F](cpustate); + return (this->*s_Op59Table[m_subop & 0x1F])(); } diff --git a/src/emu/cpu/v60/optable.c b/src/emu/cpu/v60/optable.c index 91f4bb06fc8..0f7e0dd96fa 100644 --- a/src/emu/cpu/v60/optable.c +++ b/src/emu/cpu/v60/optable.c @@ -1,259 +1,259 @@ -static UINT32 (*const OpCodeTable[256])(v60_state *cpustate) = +const v60_device::am_func v60_device::s_OpCodeTable[256] = { - /* 0x00 */ opHALT, - /* 0x01 */ opLDTASK, - /* 0x02 */ opSTPR, - /* 0x03 */ opUNHANDLED, - /* 0x04 */ opUNHANDLED, - /* 0x05 */ opUNHANDLED, - /* 0x06 */ opUNHANDLED, - /* 0x07 */ opUNHANDLED, - /* 0x08 */ opRVBIT, - /* 0x09 */ opMOVB, - /* 0x0a */ opMOVSBH, - /* 0x0b */ opMOVZBH, - /* 0x0c */ opMOVSBW, - /* 0x0d */ opMOVZBW, - /* 0x0e */ opUNHANDLED, - /* 0x0f */ opUNHANDLED, - /* 0x10 */ opCLRTLBA, - /* 0x11 */ opUNHANDLED, - /* 0x12 */ opLDPR, - /* 0x13 */ opUPDPSWW, - /* 0x14 */ opUNHANDLED, - /* 0x15 */ opUNHANDLED, - /* 0x16 */ opUNHANDLED, - /* 0x17 */ opUNHANDLED, - /* 0x18 */ opUNHANDLED, - /* 0x19 */ opMOVTHB, - /* 0x1a */ opUNHANDLED, - /* 0x1b */ opMOVH, - /* 0x1c */ opMOVSHW, - /* 0x1d */ opMOVZHW, - /* 0x1e */ opUNHANDLED, - /* 0x1f */ opUNHANDLED, - /* 0x20 */ opINB, - /* 0x21 */ opOUTB, - /* 0x22 */ opINH, - /* 0x23 */ opOUTH, - /* 0x24 */ opINW, - /* 0x25 */ opOUTW, - /* 0x26 */ opUNHANDLED, - /* 0x27 */ opUNHANDLED, - /* 0x28 */ opUNHANDLED, - /* 0x29 */ opMOVTWB, - /* 0x2a */ opUNHANDLED, - /* 0x2b */ opMOVTWH, - /* 0x2c */ opRVBYT, - /* 0x2d */ opMOVW, - /* 0x2e */ opUNHANDLED, - /* 0x2f */ opUNHANDLED, - /* 0x30 */ opUNHANDLED, - /* 0x31 */ opUNHANDLED, - /* 0x32 */ opUNHANDLED, - /* 0x33 */ opUNHANDLED, - /* 0x34 */ opUNHANDLED, - /* 0x35 */ opUNHANDLED, - /* 0x36 */ opUNHANDLED, - /* 0x37 */ opUNHANDLED, - /* 0x38 */ opNOTB, - /* 0x39 */ opNEGB, - /* 0x3a */ opNOTH, - /* 0x3b */ opNEGH, - /* 0x3c */ opNOTW, - /* 0x3d */ opNEGW, - /* 0x3e */ opUNHANDLED, - /* 0x3f */ opMOVD, - /* 0x40 */ opMOVEAB, - /* 0x41 */ opXCHB, - /* 0x42 */ opMOVEAH, - /* 0x43 */ opXCHH, - /* 0x44 */ opMOVEAW, - /* 0x45 */ opXCHW, - /* 0x46 */ opUNHANDLED, - /* 0x47 */ opSETF, - /* 0x48 */ opBSR, - /* 0x49 */ opCALL, - /* 0x4a */ opUPDPSWH, - /* 0x4b */ opCHLVL, - /* 0x4c */ opUNHANDLED, - /* 0x4d */ opCHKAR, - /* 0x4e */ opCHKAW, - /* 0x4f */ opCHKAE, - /* 0x50 */ opREMB, - /* 0x51 */ opREMUB, - /* 0x52 */ opREMH, - /* 0x53 */ opREMUH, - /* 0x54 */ opREMW, - /* 0x55 */ opREMUW, - /* 0x56 */ opUNHANDLED, - /* 0x57 */ opUNHANDLED, - /* 0x58 */ op58, - /* 0x59 */ op59, - /* 0x5a */ op5A, - /* 0x5b */ op5B, - /* 0x5c */ op5C, - /* 0x5d */ op5D, - /* 0x5e */ opUNHANDLED, - /* 0x5f */ op5F, - /* 0x60 */ opBV8, - /* 0x61 */ opBNV8, - /* 0x62 */ opBL8, - /* 0x63 */ opBNL8, - /* 0x64 */ opBE8, - /* 0x65 */ opBNE8, - /* 0x66 */ opBNH8, - /* 0x67 */ opBH8, - /* 0x68 */ opBN8, - /* 0x69 */ opBP8, - /* 0x6a */ opBR8, - /* 0x6b */ opUNHANDLED, - /* 0x6C */ opBLT8, - /* 0x6c */ opBGE8, - /* 0x6e */ opBLE8, - /* 0x6f */ opBGT8, - /* 0x70 */ opBV16, - /* 0x71 */ opBNV16, - /* 0x72 */ opBL16, - /* 0x73 */ opBNL16, - /* 0x74 */ opBE16, - /* 0x75 */ opBNE16, - /* 0x76 */ opBNH16, - /* 0x77 */ opBH16, - /* 0x78 */ opBN16, - /* 0x79 */ opBP16, - /* 0x7a */ opBR16, - /* 0x7b */ opUNHANDLED, - /* 0x7c */ opBLT16, - /* 0x7d */ opBGE16, - /* 0x7e */ opBLE16, - /* 0x7f */ opBGT16, - /* 0x80 */ opADDB, - /* 0x81 */ opMULB, - /* 0x82 */ opADDH, - /* 0x83 */ opMULH, - /* 0x84 */ opADDW, - /* 0x85 */ opMULW, - /* 0x86 */ opMULX, - /* 0x87 */ opTEST1, - /* 0x88 */ opORB, - /* 0x89 */ opROTB, - /* 0x8a */ opORH, - /* 0x8b */ opROTH, - /* 0x8c */ opORW, - /* 0x8d */ opROTW, - /* 0x8e */ opUNHANDLED, - /* 0x8f */ opUNHANDLED, - /* 0x90 */ opADDCB, - /* 0x91 */ opMULUB, - /* 0x92 */ opADDCH, - /* 0x93 */ opMULUH, - /* 0x94 */ opADDCW, - /* 0x95 */ opMULUW, - /* 0x96 */ opMULUX, - /* 0x97 */ opSET1, - /* 0x98 */ opSUBCB, - /* 0x99 */ opROTCB, - /* 0x9a */ opSUBCH, - /* 0x9b */ opROTCH, - /* 0x9c */ opSUBCW, - /* 0x9d */ opROTCW, - /* 0x9e */ opUNHANDLED, - /* 0x9f */ opUNHANDLED, - /* 0xa0 */ opANDB, - /* 0xa1 */ opDIVB, - /* 0xa2 */ opANDH, - /* 0xa3 */ opDIVH, - /* 0xa4 */ opANDW, - /* 0xa5 */ opDIVW, - /* 0xa6 */ opDIVX, - /* 0xa7 */ opCLR1, - /* 0xa8 */ opSUBB, - /* 0xa9 */ opSHLB, - /* 0xaa */ opSUBH, - /* 0xab */ opSHLH, - /* 0xac */ opSUBW, - /* 0xad */ opSHLW, - /* 0xae */ opUNHANDLED, - /* 0xaf */ opUNHANDLED, - /* 0xb0 */ opXORB, - /* 0xb1 */ opDIVUB, - /* 0xb2 */ opXORH, - /* 0xb3 */ opDIVUH, - /* 0xb4 */ opXORW, - /* 0xb5 */ opDIVUW, - /* 0xb6 */ opDIVUX, - /* 0xb7 */ opNOT1, - /* 0xb8 */ opCMPB, - /* 0xb9 */ opSHAB, - /* 0xba */ opCMPH, - /* 0xbb */ opSHAH, - /* 0xbc */ opCMPW, - /* 0xbd */ opSHAW, - /* 0xbe */ opUNHANDLED, - /* 0xbf */ opUNHANDLED, - /* 0xc0 */ opUNHANDLED, - /* 0xc1 */ opUNHANDLED, - /* 0xc2 */ opUNHANDLED, - /* 0xc3 */ opUNHANDLED, - /* 0xc4 */ opUNHANDLED, - /* 0xc5 */ opUNHANDLED, - /* 0xc6 */ opC6, - /* 0xc7 */ opC7, - /* 0xc8 */ opBRK, - /* 0xc9 */ opBRKV, - /* 0xca */ opRSR, - /* 0xcb */ opTRAPFL, - /* 0xcc */ opDISPOSE, - /* 0xcd */ opNOP, - /* 0xce */ opUNHANDLED, - /* 0xcf */ opUNHANDLED, - /* 0xd0 */ opDECB_0, - /* 0xd1 */ opDECB_1, - /* 0xd2 */ opDECH_0, - /* 0xd3 */ opDECH_1, - /* 0xd4 */ opDECW_0, - /* 0xd5 */ opDECW_1, - /* 0xd6 */ opJMP_0, - /* 0xd7 */ opJMP_1, - /* 0xd8 */ opINCB_0, - /* 0xd9 */ opINCB_1, - /* 0xda */ opINCH_0, - /* 0xdb */ opINCH_1, - /* 0xdc */ opINCW_0, - /* 0xdd */ opINCW_1, - /* 0xde */ opPREPARE_0, - /* 0xdf */ opPREPARE_1, - /* 0xe0 */ opTASI_0, - /* 0xe1 */ opTASI_1, - /* 0xe2 */ opRET_0, - /* 0xe3 */ opRET_1, - /* 0xe4 */ opPOPM_0, - /* 0xe5 */ opPOPM_1, - /* 0xe6 */ opPOP_0, - /* 0xe7 */ opPOP_1, - /* 0xe8 */ opJSR_0, - /* 0xe9 */ opJSR_1, - /* 0xea */ opRETIU_0, - /* 0xeb */ opRETIU_1, - /* 0xec */ opPUSHM_0, - /* 0xed */ opPUSHM_1, - /* 0xee */ opPUSH_0, - /* 0xef */ opPUSH_1, - /* 0xf0 */ opTESTB_0, - /* 0xf1 */ opTESTB_1, - /* 0xf2 */ opTESTH_0, - /* 0xf3 */ opTESTH_1, - /* 0xf4 */ opTESTW_0, - /* 0xf5 */ opTESTW_1, - /* 0xf6 */ opGETPSW_0, - /* 0xf7 */ opGETPSW_1, - /* 0xf8 */ opTRAP_0, - /* 0xf9 */ opTRAP_1, - /* 0xfa */ opRETIS_0, - /* 0xfb */ opRETIS_1, - /* 0xfc */ opSTTASK_0, - /* 0xfd */ opSTTASK_1, - /* 0xfe */ opCLRTLB_0, - /* 0xff */ opCLRTLB_1, + /* 0x00 */ &v60_device::opHALT, + /* 0x01 */ &v60_device::opLDTASK, + /* 0x02 */ &v60_device::opSTPR, + /* 0x03 */ &v60_device::opUNHANDLED, + /* 0x04 */ &v60_device::opUNHANDLED, + /* 0x05 */ &v60_device::opUNHANDLED, + /* 0x06 */ &v60_device::opUNHANDLED, + /* 0x07 */ &v60_device::opUNHANDLED, + /* 0x08 */ &v60_device::opRVBIT, + /* 0x09 */ &v60_device::opMOVB, + /* 0x0a */ &v60_device::opMOVSBH, + /* 0x0b */ &v60_device::opMOVZBH, + /* 0x0c */ &v60_device::opMOVSBW, + /* 0x0d */ &v60_device::opMOVZBW, + /* 0x0e */ &v60_device::opUNHANDLED, + /* 0x0f */ &v60_device::opUNHANDLED, + /* 0x10 */ &v60_device::opCLRTLBA, + /* 0x11 */ &v60_device::opUNHANDLED, + /* 0x12 */ &v60_device::opLDPR, + /* 0x13 */ &v60_device::opUPDPSWW, + /* 0x14 */ &v60_device::opUNHANDLED, + /* 0x15 */ &v60_device::opUNHANDLED, + /* 0x16 */ &v60_device::opUNHANDLED, + /* 0x17 */ &v60_device::opUNHANDLED, + /* 0x18 */ &v60_device::opUNHANDLED, + /* 0x19 */ &v60_device::opMOVTHB, + /* 0x1a */ &v60_device::opUNHANDLED, + /* 0x1b */ &v60_device::opMOVH, + /* 0x1c */ &v60_device::opMOVSHW, + /* 0x1d */ &v60_device::opMOVZHW, + /* 0x1e */ &v60_device::opUNHANDLED, + /* 0x1f */ &v60_device::opUNHANDLED, + /* 0x20 */ &v60_device::opINB, + /* 0x21 */ &v60_device::opOUTB, + /* 0x22 */ &v60_device::opINH, + /* 0x23 */ &v60_device::opOUTH, + /* 0x24 */ &v60_device::opINW, + /* 0x25 */ &v60_device::opOUTW, + /* 0x26 */ &v60_device::opUNHANDLED, + /* 0x27 */ &v60_device::opUNHANDLED, + /* 0x28 */ &v60_device::opUNHANDLED, + /* 0x29 */ &v60_device::opMOVTWB, + /* 0x2a */ &v60_device::opUNHANDLED, + /* 0x2b */ &v60_device::opMOVTWH, + /* 0x2c */ &v60_device::opRVBYT, + /* 0x2d */ &v60_device::opMOVW, + /* 0x2e */ &v60_device::opUNHANDLED, + /* 0x2f */ &v60_device::opUNHANDLED, + /* 0x30 */ &v60_device::opUNHANDLED, + /* 0x31 */ &v60_device::opUNHANDLED, + /* 0x32 */ &v60_device::opUNHANDLED, + /* 0x33 */ &v60_device::opUNHANDLED, + /* 0x34 */ &v60_device::opUNHANDLED, + /* 0x35 */ &v60_device::opUNHANDLED, + /* 0x36 */ &v60_device::opUNHANDLED, + /* 0x37 */ &v60_device::opUNHANDLED, + /* 0x38 */ &v60_device::opNOTB, + /* 0x39 */ &v60_device::opNEGB, + /* 0x3a */ &v60_device::opNOTH, + /* 0x3b */ &v60_device::opNEGH, + /* 0x3c */ &v60_device::opNOTW, + /* 0x3d */ &v60_device::opNEGW, + /* 0x3e */ &v60_device::opUNHANDLED, + /* 0x3f */ &v60_device::opMOVD, + /* 0x40 */ &v60_device::opMOVEAB, + /* 0x41 */ &v60_device::opXCHB, + /* 0x42 */ &v60_device::opMOVEAH, + /* 0x43 */ &v60_device::opXCHH, + /* 0x44 */ &v60_device::opMOVEAW, + /* 0x45 */ &v60_device::opXCHW, + /* 0x46 */ &v60_device::opUNHANDLED, + /* 0x47 */ &v60_device::opSETF, + /* 0x48 */ &v60_device::opBSR, + /* 0x49 */ &v60_device::opCALL, + /* 0x4a */ &v60_device::opUPDPSWH, + /* 0x4b */ &v60_device::opCHLVL, + /* 0x4c */ &v60_device::opUNHANDLED, + /* 0x4d */ &v60_device::opCHKAR, + /* 0x4e */ &v60_device::opCHKAW, + /* 0x4f */ &v60_device::opCHKAE, + /* 0x50 */ &v60_device::opREMB, + /* 0x51 */ &v60_device::opREMUB, + /* 0x52 */ &v60_device::opREMH, + /* 0x53 */ &v60_device::opREMUH, + /* 0x54 */ &v60_device::opREMW, + /* 0x55 */ &v60_device::opREMUW, + /* 0x56 */ &v60_device::opUNHANDLED, + /* 0x57 */ &v60_device::opUNHANDLED, + /* 0x58 */ &v60_device::op58, + /* 0x59 */ &v60_device::op59, + /* 0x5a */ &v60_device::op5A, + /* 0x5b */ &v60_device::op5B, + /* 0x5c */ &v60_device::op5C, + /* 0x5d */ &v60_device::op5D, + /* 0x5e */ &v60_device::opUNHANDLED, + /* 0x5f */ &v60_device::op5F, + /* 0x60 */ &v60_device::opBV8, + /* 0x61 */ &v60_device::opBNV8, + /* 0x62 */ &v60_device::opBL8, + /* 0x63 */ &v60_device::opBNL8, + /* 0x64 */ &v60_device::opBE8, + /* 0x65 */ &v60_device::opBNE8, + /* 0x66 */ &v60_device::opBNH8, + /* 0x67 */ &v60_device::opBH8, + /* 0x68 */ &v60_device::opBN8, + /* 0x69 */ &v60_device::opBP8, + /* 0x6a */ &v60_device::opBR8, + /* 0x6b */ &v60_device::opUNHANDLED, + /* 0x6C */ &v60_device::opBLT8, + /* 0x6c */ &v60_device::opBGE8, + /* 0x6e */ &v60_device::opBLE8, + /* 0x6f */ &v60_device::opBGT8, + /* 0x70 */ &v60_device::opBV16, + /* 0x71 */ &v60_device::opBNV16, + /* 0x72 */ &v60_device::opBL16, + /* 0x73 */ &v60_device::opBNL16, + /* 0x74 */ &v60_device::opBE16, + /* 0x75 */ &v60_device::opBNE16, + /* 0x76 */ &v60_device::opBNH16, + /* 0x77 */ &v60_device::opBH16, + /* 0x78 */ &v60_device::opBN16, + /* 0x79 */ &v60_device::opBP16, + /* 0x7a */ &v60_device::opBR16, + /* 0x7b */ &v60_device::opUNHANDLED, + /* 0x7c */ &v60_device::opBLT16, + /* 0x7d */ &v60_device::opBGE16, + /* 0x7e */ &v60_device::opBLE16, + /* 0x7f */ &v60_device::opBGT16, + /* 0x80 */ &v60_device::opADDB, + /* 0x81 */ &v60_device::opMULB, + /* 0x82 */ &v60_device::opADDH, + /* 0x83 */ &v60_device::opMULH, + /* 0x84 */ &v60_device::opADDW, + /* 0x85 */ &v60_device::opMULW, + /* 0x86 */ &v60_device::opMULX, + /* 0x87 */ &v60_device::opTEST1, + /* 0x88 */ &v60_device::opORB, + /* 0x89 */ &v60_device::opROTB, + /* 0x8a */ &v60_device::opORH, + /* 0x8b */ &v60_device::opROTH, + /* 0x8c */ &v60_device::opORW, + /* 0x8d */ &v60_device::opROTW, + /* 0x8e */ &v60_device::opUNHANDLED, + /* 0x8f */ &v60_device::opUNHANDLED, + /* 0x90 */ &v60_device::opADDCB, + /* 0x91 */ &v60_device::opMULUB, + /* 0x92 */ &v60_device::opADDCH, + /* 0x93 */ &v60_device::opMULUH, + /* 0x94 */ &v60_device::opADDCW, + /* 0x95 */ &v60_device::opMULUW, + /* 0x96 */ &v60_device::opMULUX, + /* 0x97 */ &v60_device::opSET1, + /* 0x98 */ &v60_device::opSUBCB, + /* 0x99 */ &v60_device::opROTCB, + /* 0x9a */ &v60_device::opSUBCH, + /* 0x9b */ &v60_device::opROTCH, + /* 0x9c */ &v60_device::opSUBCW, + /* 0x9d */ &v60_device::opROTCW, + /* 0x9e */ &v60_device::opUNHANDLED, + /* 0x9f */ &v60_device::opUNHANDLED, + /* 0xa0 */ &v60_device::opANDB, + /* 0xa1 */ &v60_device::opDIVB, + /* 0xa2 */ &v60_device::opANDH, + /* 0xa3 */ &v60_device::opDIVH, + /* 0xa4 */ &v60_device::opANDW, + /* 0xa5 */ &v60_device::opDIVW, + /* 0xa6 */ &v60_device::opDIVX, + /* 0xa7 */ &v60_device::opCLR1, + /* 0xa8 */ &v60_device::opSUBB, + /* 0xa9 */ &v60_device::opSHLB, + /* 0xaa */ &v60_device::opSUBH, + /* 0xab */ &v60_device::opSHLH, + /* 0xac */ &v60_device::opSUBW, + /* 0xad */ &v60_device::opSHLW, + /* 0xae */ &v60_device::opUNHANDLED, + /* 0xaf */ &v60_device::opUNHANDLED, + /* 0xb0 */ &v60_device::opXORB, + /* 0xb1 */ &v60_device::opDIVUB, + /* 0xb2 */ &v60_device::opXORH, + /* 0xb3 */ &v60_device::opDIVUH, + /* 0xb4 */ &v60_device::opXORW, + /* 0xb5 */ &v60_device::opDIVUW, + /* 0xb6 */ &v60_device::opDIVUX, + /* 0xb7 */ &v60_device::opNOT1, + /* 0xb8 */ &v60_device::opCMPB, + /* 0xb9 */ &v60_device::opSHAB, + /* 0xba */ &v60_device::opCMPH, + /* 0xbb */ &v60_device::opSHAH, + /* 0xbc */ &v60_device::opCMPW, + /* 0xbd */ &v60_device::opSHAW, + /* 0xbe */ &v60_device::opUNHANDLED, + /* 0xbf */ &v60_device::opUNHANDLED, + /* 0xc0 */ &v60_device::opUNHANDLED, + /* 0xc1 */ &v60_device::opUNHANDLED, + /* 0xc2 */ &v60_device::opUNHANDLED, + /* 0xc3 */ &v60_device::opUNHANDLED, + /* 0xc4 */ &v60_device::opUNHANDLED, + /* 0xc5 */ &v60_device::opUNHANDLED, + /* 0xc6 */ &v60_device::opC6, + /* 0xc7 */ &v60_device::opC7, + /* 0xc8 */ &v60_device::opBRK, + /* 0xc9 */ &v60_device::opBRKV, + /* 0xca */ &v60_device::opRSR, + /* 0xcb */ &v60_device::opTRAPFL, + /* 0xcc */ &v60_device::opDISPOSE, + /* 0xcd */ &v60_device::opNOP, + /* 0xce */ &v60_device::opUNHANDLED, + /* 0xcf */ &v60_device::opUNHANDLED, + /* 0xd0 */ &v60_device::opDECB_0, + /* 0xd1 */ &v60_device::opDECB_1, + /* 0xd2 */ &v60_device::opDECH_0, + /* 0xd3 */ &v60_device::opDECH_1, + /* 0xd4 */ &v60_device::opDECW_0, + /* 0xd5 */ &v60_device::opDECW_1, + /* 0xd6 */ &v60_device::opJMP_0, + /* 0xd7 */ &v60_device::opJMP_1, + /* 0xd8 */ &v60_device::opINCB_0, + /* 0xd9 */ &v60_device::opINCB_1, + /* 0xda */ &v60_device::opINCH_0, + /* 0xdb */ &v60_device::opINCH_1, + /* 0xdc */ &v60_device::opINCW_0, + /* 0xdd */ &v60_device::opINCW_1, + /* 0xde */ &v60_device::opPREPARE_0, + /* 0xdf */ &v60_device::opPREPARE_1, + /* 0xe0 */ &v60_device::opTASI_0, + /* 0xe1 */ &v60_device::opTASI_1, + /* 0xe2 */ &v60_device::opRET_0, + /* 0xe3 */ &v60_device::opRET_1, + /* 0xe4 */ &v60_device::opPOPM_0, + /* 0xe5 */ &v60_device::opPOPM_1, + /* 0xe6 */ &v60_device::opPOP_0, + /* 0xe7 */ &v60_device::opPOP_1, + /* 0xe8 */ &v60_device::opJSR_0, + /* 0xe9 */ &v60_device::opJSR_1, + /* 0xea */ &v60_device::opRETIU_0, + /* 0xeb */ &v60_device::opRETIU_1, + /* 0xec */ &v60_device::opPUSHM_0, + /* 0xed */ &v60_device::opPUSHM_1, + /* 0xee */ &v60_device::opPUSH_0, + /* 0xef */ &v60_device::opPUSH_1, + /* 0xf0 */ &v60_device::opTESTB_0, + /* 0xf1 */ &v60_device::opTESTB_1, + /* 0xf2 */ &v60_device::opTESTH_0, + /* 0xf3 */ &v60_device::opTESTH_1, + /* 0xf4 */ &v60_device::opTESTW_0, + /* 0xf5 */ &v60_device::opTESTW_1, + /* 0xf6 */ &v60_device::opGETPSW_0, + /* 0xf7 */ &v60_device::opGETPSW_1, + /* 0xf8 */ &v60_device::opTRAP_0, + /* 0xf9 */ &v60_device::opTRAP_1, + /* 0xfa */ &v60_device::opRETIS_0, + /* 0xfb */ &v60_device::opRETIS_1, + /* 0xfc */ &v60_device::opSTTASK_0, + /* 0xfd */ &v60_device::opSTTASK_1, + /* 0xfe */ &v60_device::opCLRTLB_0, + /* 0xff */ &v60_device::opCLRTLB_1, }; diff --git a/src/emu/cpu/v60/v60.c b/src/emu/cpu/v60/v60.c index a1f76b74b93..41af2104c61 100644 --- a/src/emu/cpu/v60/v60.c +++ b/src/emu/cpu/v60/v60.c @@ -7,19 +7,68 @@ #include "debugger.h" #include "v60.h" +const device_type V60 = &device_creator; +const device_type V70 = &device_creator; + + +v60_device::v60_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : cpu_device(mconfig, V60, "V60", tag, owner, clock, "v60", __FILE__) + , m_program_config("program", ENDIANNESS_LITTLE, 16, 24, 0) + , m_io_config("io", ENDIANNESS_LITTLE, 16, 24, 0) + , m_fetch_xor(BYTE_XOR_LE(0)) + , m_start_pc(0xfffff0) +{ + // Set m_PIR (Processor ID) for NEC m_ LSB is reserved to NEC, + // so I don't know what it contains. + m_reg[45] = 0x00006000; +} + + +v60_device::v60_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source) + : cpu_device(mconfig, type, name, tag, owner, clock, shortname, source) + , m_program_config("program", ENDIANNESS_LITTLE, 32, 32, 0) + , m_io_config("io", ENDIANNESS_LITTLE, 16, 24, 0) + , m_fetch_xor(BYTE4_XOR_LE(0)) + , m_start_pc(0xfffffff0) +{ + // Set m_PIR (Processor ID) for NEC v70. LSB is reserved to NEC, + // so I don't know what it contains. + m_reg[45] = 0x00007000; +} + +v70_device::v70_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : v60_device(mconfig, V70, "V70", tag, owner, clock, "v70", __FILE__) +{ +} + + +offs_t v60_device::disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) +{ + extern CPU_DISASSEMBLE( v60 ); + return CPU_DISASSEMBLE_NAME(v60)(this, buffer, pc, oprom, opram, options); +} + + +offs_t v70_device::disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) +{ + extern CPU_DISASSEMBLE( v70 ); + return CPU_DISASSEMBLE_NAME(v70)(this, buffer, pc, oprom, opram, options); +} + + // memory accessors #if defined(LSB_FIRST) && !defined(ALIGN_INTS) -#define OpRead8(s, a) ((s)->direct->read_decrypted_byte(a)) -#define OpRead16(s, a) ((s)->direct->read_decrypted_word(a)) -#define OpRead32(s, a) ((s)->direct->read_decrypted_dword(a)) +#define OpRead8(a) (m_direct->read_decrypted_byte(a)) +#define OpRead16(a) (m_direct->read_decrypted_word(a)) +#define OpRead32(a) (m_direct->read_decrypted_dword(a)) #else -#define OpRead8(s, a) ((s)->direct->read_decrypted_byte((a), (s)->fetch_xor)) -#define OpRead16(s, a) (((s)->direct->read_decrypted_byte(((a)+0), (s)->fetch_xor) << 0) | \ - ((s)->direct->read_decrypted_byte(((a)+1), (s)->fetch_xor) << 8)) -#define OpRead32(s, a) (((s)->direct->read_decrypted_byte(((a)+0), (s)->fetch_xor) << 0) | \ - ((s)->direct->read_decrypted_byte(((a)+1), (s)->fetch_xor) << 8) | \ - ((s)->direct->read_decrypted_byte(((a)+2), (s)->fetch_xor) << 16) | \ - ((s)->direct->read_decrypted_byte(((a)+3), (s)->fetch_xor) << 24)) +#define OpRead8(a) (m_direct->read_decrypted_byte((a), m_fetch_xor)) +#define OpRead16(a) ((m_direct->read_decrypted_byte(((a)+0), m_fetch_xor) << 0) | \ + (m_direct->read_decrypted_byte(((a)+1), m_fetch_xor) << 8)) +#define OpRead32(a) ((m_direct->read_decrypted_byte(((a)+0), m_fetch_xor) << 0) | \ + (m_direct->read_decrypted_byte(((a)+1), m_fetch_xor) << 8) | \ + (m_direct->read_decrypted_byte(((a)+2), m_fetch_xor) << 16) | \ + (m_direct->read_decrypted_byte(((a)+3), m_fetch_xor) << 24)) #endif @@ -29,36 +78,36 @@ // parameter x = result, y = source 1, z = source 2 -#define SetOFL_Add(x, y,z) (cpustate->_OV = (((x) ^ (y)) & ((x) ^ (z)) & 0x80000000) ? 1: 0) -#define SetOFW_Add(x, y,z) (cpustate->_OV = (((x) ^ (y)) & ((x) ^ (z)) & 0x8000) ? 1 : 0) -#define SetOFB_Add(x, y,z) (cpustate->_OV = (((x) ^ (y)) & ((x) ^ (z)) & 0x80) ? 1 : 0) +#define SetOFL_Add(x, y,z) (_OV = (((x) ^ (y)) & ((x) ^ (z)) & 0x80000000) ? 1: 0) +#define SetOFW_Add(x, y,z) (_OV = (((x) ^ (y)) & ((x) ^ (z)) & 0x8000) ? 1 : 0) +#define SetOFB_Add(x, y,z) (_OV = (((x) ^ (y)) & ((x) ^ (z)) & 0x80) ? 1 : 0) -#define SetOFL_Sub(x, y,z) (cpustate->_OV = (((z) ^ (y)) & ((z) ^ (x)) & 0x80000000) ? 1 : 0) -#define SetOFW_Sub(x, y,z) (cpustate->_OV = (((z) ^ (y)) & ((z) ^ (x)) & 0x8000) ? 1 : 0) -#define SetOFB_Sub(x, y,z) (cpustate->_OV = (((z) ^ (y)) & ((z) ^ (x)) & 0x80) ? 1 : 0) +#define SetOFL_Sub(x, y,z) (_OV = (((z) ^ (y)) & ((z) ^ (x)) & 0x80000000) ? 1 : 0) +#define SetOFW_Sub(x, y,z) (_OV = (((z) ^ (y)) & ((z) ^ (x)) & 0x8000) ? 1 : 0) +#define SetOFB_Sub(x, y,z) (_OV = (((z) ^ (y)) & ((z) ^ (x)) & 0x80) ? 1 : 0) -#define SetCFB(x) {cpustate->_CY = ((x) & 0x100) ? 1 : 0; } -#define SetCFW(x) {cpustate->_CY = ((x) & 0x10000) ? 1 : 0; } -#define SetCFL(x) {cpustate->_CY = ((x) & (((UINT64)1) << 32)) ? 1 : 0; } +#define SetCFB(x) {_CY = ((x) & 0x100) ? 1 : 0; } +#define SetCFW(x) {_CY = ((x) & 0x10000) ? 1 : 0; } +#define SetCFL(x) {_CY = ((x) & (((UINT64)1) << 32)) ? 1 : 0; } -#define SetSF(x) (cpustate->_S = (x)) -#define SetZF(x) (cpustate->_Z = (x)) +#define SetSF(x) (_S = (x)) +#define SetZF(x) (_Z = (x)) -#define SetSZPF_Byte(x) {cpustate->_Z = ((UINT8)(x) == 0); cpustate->_S = ((x)&0x80) ? 1 : 0; } -#define SetSZPF_Word(x) {cpustate->_Z = ((UINT16)(x) == 0); cpustate->_S = ((x)&0x8000) ? 1 : 0; } -#define SetSZPF_Long(x) {cpustate->_Z = ((UINT32)(x) == 0); cpustate->_S = ((x)&0x80000000) ? 1 : 0; } +#define SetSZPF_Byte(x) {_Z = ((UINT8)(x) == 0); _S = ((x)&0x80) ? 1 : 0; } +#define SetSZPF_Word(x) {_Z = ((UINT16)(x) == 0); _S = ((x)&0x8000) ? 1 : 0; } +#define SetSZPF_Long(x) {_Z = ((UINT32)(x) == 0); _S = ((x)&0x80000000) ? 1 : 0; } -#define ORB(dst, src) { (dst) |= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Byte(dst); } -#define ORW(dst, src) { (dst) |= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Word(dst); } -#define ORL(dst, src) { (dst) |= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Long(dst); } +#define ORB(dst, src) { (dst) |= (src); _CY = _OV = 0; SetSZPF_Byte(dst); } +#define ORW(dst, src) { (dst) |= (src); _CY = _OV = 0; SetSZPF_Word(dst); } +#define ORL(dst, src) { (dst) |= (src); _CY = _OV = 0; SetSZPF_Long(dst); } -#define ANDB(dst, src) { (dst) &= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Byte(dst); } -#define ANDW(dst, src) { (dst) &= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Word(dst); } -#define ANDL(dst, src) { (dst) &= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Long(dst); } +#define ANDB(dst, src) { (dst) &= (src); _CY = _OV = 0; SetSZPF_Byte(dst); } +#define ANDW(dst, src) { (dst) &= (src); _CY = _OV = 0; SetSZPF_Word(dst); } +#define ANDL(dst, src) { (dst) &= (src); _CY = _OV = 0; SetSZPF_Long(dst); } -#define XORB(dst, src) { (dst) ^= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Byte(dst); } -#define XORW(dst, src) { (dst) ^= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Word(dst); } -#define XORL(dst, src) { (dst) ^= (src); cpustate->_CY = cpustate->_OV = 0; SetSZPF_Long(dst); } +#define XORB(dst, src) { (dst) ^= (src); _CY = _OV = 0; SetSZPF_Byte(dst); } +#define XORW(dst, src) { (dst) ^= (src); _CY = _OV = 0; SetSZPF_Word(dst); } +#define XORL(dst, src) { (dst) ^= (src); _CY = _OV = 0; SetSZPF_Long(dst); } #define SUBB(dst, src) { unsigned res = (dst) - (src); SetCFB(res); SetOFB_Sub(res, src, dst); SetSZPF_Byte(res); dst = (UINT8)res; } #define SUBW(dst, src) { unsigned res = (dst) - (src); SetCFW(res); SetOFW_Sub(res, src, dst); SetSZPF_Word(res); dst = (UINT16)res; } @@ -71,65 +120,6 @@ #define SETREG8(a, b) (a) = ((a) & ~0xff) | ((b) & 0xff) #define SETREG16(a, b) (a) = ((a) & ~0xffff) | ((b) & 0xffff) -struct v60_flags -{ - UINT8 CY; - UINT8 OV; - UINT8 S; - UINT8 Z; -}; - -// v60 Register Inside (Hm... It's not a pentium inside :-))) ) -struct v60_state -{ - offs_t fetch_xor; - offs_t start_pc; - UINT32 reg[68]; - v60_flags flags; - UINT8 irq_line; - UINT8 nmi_line; - device_irq_acknowledge_callback irq_cb; - legacy_cpu_device * device; - address_space *program; - direct_read_data * direct; - address_space *io; - UINT32 PPC; - int icount; - int stall_io; - - UINT32 op1, op2; - UINT8 flag1, flag2; - UINT8 instflags; - UINT32 lenop1, lenop2; - UINT8 subop; - UINT32 bamoffset1, bamoffset2; - - // Output variables for ReadAMAddress(cpustate) - UINT8 amflag; - UINT32 amout; - UINT32 bamoffset; - - // Appo temp var - UINT32 amlength1, amlength2; - - // Global vars used by AM functions - UINT32 modadd; - UINT8 modm; - UINT8 modval; - UINT8 modval2; - UINT8 modwritevalb; - UINT16 modwritevalh; - UINT32 modwritevalw; - UINT8 moddim; -}; - -INLINE v60_state *get_safe_token(device_t *device) -{ - assert(device != NULL); - assert(device->type() == V60 || - device->type() == V70); - return (v60_state *)downcast(device)->token(); -} /* * Prevent warnings on NetBSD. All identifiers beginning with an underscore @@ -139,165 +129,163 @@ INLINE v60_state *get_safe_token(device_t *device) */ #undef _S -#define _CY flags.CY -#define _OV flags.OV -#define _S flags.S -#define _Z flags.Z +#define _CY m_flags.CY +#define _OV m_flags.OV +#define _S m_flags.S +#define _Z m_flags.Z // Defines of all v60 register... -#define R0 reg[0] -#define R1 reg[1] -#define R2 reg[2] -#define R3 reg[3] -#define R4 reg[4] -#define R5 reg[5] -#define R6 reg[6] -#define R7 reg[7] -#define R8 reg[8] -#define R9 reg[9] -#define R10 reg[10] -#define R11 reg[11] -#define R12 reg[12] -#define R13 reg[13] -#define R14 reg[14] -#define R15 reg[15] -#define R16 reg[16] -#define R17 reg[17] -#define R18 reg[18] -#define R19 reg[19] -#define R20 reg[20] -#define R21 reg[21] -#define R22 reg[22] -#define R23 reg[23] -#define R24 reg[24] -#define R25 reg[25] -#define R26 reg[26] -#define R27 reg[27] -#define R28 reg[28] -#define AP reg[29] -#define FP reg[30] -#define SP reg[31] +#define R0 m_reg[0] +#define R1 m_reg[1] +#define R2 m_reg[2] +#define R3 m_reg[3] +#define R4 m_reg[4] +#define R5 m_reg[5] +#define R6 m_reg[6] +#define R7 m_reg[7] +#define R8 m_reg[8] +#define R9 m_reg[9] +#define R10 m_reg[10] +#define R11 m_reg[11] +#define R12 m_reg[12] +#define R13 m_reg[13] +#define R14 m_reg[14] +#define R15 m_reg[15] +#define R16 m_reg[16] +#define R17 m_reg[17] +#define R18 m_reg[18] +#define R19 m_reg[19] +#define R20 m_reg[20] +#define R21 m_reg[21] +#define R22 m_reg[22] +#define R23 m_reg[23] +#define R24 m_reg[24] +#define R25 m_reg[25] +#define R26 m_reg[26] +#define R27 m_reg[27] +#define R28 m_reg[28] +#define AP m_reg[29] +#define FP m_reg[30] +#define SP m_reg[31] -#define PC reg[32] -#define PSW reg[33] +#define PC m_reg[32] +#define PSW m_reg[33] // Privileged registers -#define ISP reg[36] -#define L0SP reg[37] -#define L1SP reg[38] -#define L2SP reg[39] -#define L3SP reg[40] -#define SBR reg[41] -#define TR reg[42] -#define SYCW reg[43] -#define TKCW reg[44] -#define PIR reg[45] +#define ISP m_reg[36] +#define L0SP m_reg[37] +#define L1SP m_reg[38] +#define L2SP m_reg[39] +#define L3SP m_reg[40] +#define SBR m_reg[41] +#define TR m_reg[42] +#define SYCW m_reg[43] +#define TKCW m_reg[44] +#define PIR m_reg[45] //10-14 reserved -#define PSW2 reg[51] -#define ATBR0 reg[52] -#define ATLR0 reg[53] -#define ATBR1 reg[54] -#define ATLR1 reg[55] -#define ATBR2 reg[56] -#define ATLR2 reg[57] -#define ATBR3 reg[58] -#define ATLR3 reg[59] -#define TRMODE reg[60] -#define ADTR0 reg[61] -#define ADTR1 reg[62] -#define ADTMR0 reg[63] -#define ADTMR1 reg[64] +#define PSW2 m_reg[51] +#define ATBR0 m_reg[52] +#define ATLR0 m_reg[53] +#define ATBR1 m_reg[54] +#define ATLR1 m_reg[55] +#define ATBR2 m_reg[56] +#define ATLR2 m_reg[57] +#define ATBR3 m_reg[58] +#define ATLR3 m_reg[59] +#define TRMODE m_reg[60] +#define ADTR0 m_reg[61] +#define ADTR1 m_reg[62] +#define ADTMR0 m_reg[63] +#define ADTMR1 m_reg[64] //29-31 reserved // Defines... -#define NORMALIZEFLAGS(cs) \ +#define NORMALIZEFLAGS() \ { \ - (cs)->_S = (cs)->_S ? 1 : 0; \ - (cs)->_OV = (cs)->_OV ? 1 : 0; \ - (cs)->_Z = (cs)->_Z ? 1 : 0; \ - (cs)->_CY = (cs)->_CY ? 1 : 0; \ + _S = _S ? 1 : 0; \ + _OV = _OV ? 1 : 0; \ + _Z = _Z ? 1 : 0; \ + _CY = _CY ? 1 : 0; \ } -static void v60_try_irq(v60_state *cpustate); - -INLINE void v60SaveStack(v60_state *cpustate) +void v60_device::v60SaveStack() { - if (cpustate->PSW & 0x10000000) - cpustate->ISP = cpustate->SP; + if (PSW & 0x10000000) + ISP = SP; else - cpustate->reg[37 + ((cpustate->PSW >> 24) & 3)] = cpustate->SP; + m_reg[37 + ((PSW >> 24) & 3)] = SP; } -INLINE void v60ReloadStack(v60_state *cpustate) +void v60_device::v60ReloadStack() { - if (cpustate->PSW & 0x10000000) - cpustate->SP = cpustate->ISP; + if (PSW & 0x10000000) + SP = ISP; else - cpustate->SP = cpustate->reg[37 + ((cpustate->PSW >> 24) & 3)]; + SP = m_reg[37 + ((PSW >> 24) & 3)]; } -INLINE UINT32 v60ReadPSW(v60_state *cpustate) +UINT32 v60_device::v60ReadPSW() { - cpustate->PSW &= 0xfffffff0; - cpustate->PSW |= (cpustate->_Z?1:0) | (cpustate->_S?2:0) | (cpustate->_OV?4:0) | (cpustate->_CY?8:0); - return cpustate->PSW; + PSW &= 0xfffffff0; + PSW |= (_Z?1:0) | (_S?2:0) | (_OV?4:0) | (_CY?8:0); + return PSW; } -INLINE void v60WritePSW(v60_state *cpustate, UINT32 newval) +void v60_device::v60WritePSW(UINT32 newval) { /* determine if we need to save / restore the stacks */ int updateStack = 0; /* if the interrupt state is changing, we definitely need to update */ - if ((newval ^ cpustate->PSW) & 0x10000000) + if ((newval ^ PSW) & 0x10000000) updateStack = 1; /* if we are not in interrupt mode and the level is changing, we also must update */ - else if (!(cpustate->PSW & 0x10000000) && ((newval ^ cpustate->PSW) & 0x03000000)) + else if (!(PSW & 0x10000000) && ((newval ^ PSW) & 0x03000000)) updateStack = 1; /* save the previous stack value */ if (updateStack) - v60SaveStack(cpustate); + v60SaveStack(); /* set the new value and update the flags */ - cpustate->PSW = newval; - cpustate->_Z = (UINT8)(cpustate->PSW & 1); - cpustate->_S = (UINT8)(cpustate->PSW & 2); - cpustate->_OV = (UINT8)(cpustate->PSW & 4); - cpustate->_CY = (UINT8)(cpustate->PSW & 8); + PSW = newval; + _Z = (UINT8)(PSW & 1); + _S = (UINT8)(PSW & 2); + _OV = (UINT8)(PSW & 4); + _CY = (UINT8)(PSW & 8); /* fetch the new stack value */ if (updateStack) - v60ReloadStack(cpustate); + v60ReloadStack(); } -INLINE UINT32 v60_update_psw_for_exception(v60_state *cpustate, int is_interrupt, int target_level) +UINT32 v60_device::v60_update_psw_for_exception(int is_interrupt, int target_level) { - UINT32 oldPSW = v60ReadPSW(cpustate); + UINT32 oldPSW = v60ReadPSW(); UINT32 newPSW = oldPSW; // Change to interrupt context - newPSW &= ~(3 << 24); // cpustate->PSW.EL = 0 + newPSW &= ~(3 << 24); // PSW.EL = 0 newPSW |= target_level << 24; // set target level - newPSW &= ~(1 << 18); // cpustate->PSW.IE = 0 - newPSW &= ~(1 << 16); // cpustate->PSW.TE = 0 - newPSW &= ~(1 << 27); // cpustate->PSW.TP = 0 - newPSW &= ~(1 << 17); // cpustate->PSW.AE = 0 - newPSW &= ~(1 << 29); // cpustate->PSW.EM = 0 + newPSW &= ~(1 << 18); // PSW.IE = 0 + newPSW &= ~(1 << 16); // PSW.TE = 0 + newPSW &= ~(1 << 27); // PSW.TP = 0 + newPSW &= ~(1 << 17); // PSW.AE = 0 + newPSW &= ~(1 << 29); // PSW.EM = 0 if (is_interrupt) - newPSW |= (1 << 28);// cpustate->PSW.IS = 1 - newPSW |= (1 << 31); // cpustate->PSW.ASA = 1 - v60WritePSW(cpustate, newPSW); + newPSW |= (1 << 28);// PSW.IS = 1 + newPSW |= (1 << 31); // PSW.ASA = 1 + v60WritePSW(newPSW); return oldPSW; } -#define GETINTVECT(cs, nint) (cs)->program->read_dword(((cs)->SBR & ~0xfff) + (nint) * 4) +#define GETINTVECT(nint) m_program->read_dword((SBR & ~0xfff) + (nint) * 4) #define EXCEPTION_CODE_AND_SIZE(code, size) (((code) << 16) | (size)) @@ -313,454 +301,250 @@ INLINE UINT32 v60_update_psw_for_exception(v60_state *cpustate, int is_interrupt #include "op6.c" #include "op7a.c" -static UINT32 opUNHANDLED(v60_state *cpustate) +UINT32 v60_device::opUNHANDLED() { - fatalerror("Unhandled OpCode found : %02x at %08x\n", OpRead16(cpustate, cpustate->PC), cpustate->PC); + fatalerror("Unhandled OpCode found : %02x at %08x\n", OpRead16(PC), PC); return 0; /* never reached, fatalerror won't return */ } // Opcode jump table #include "optable.c" -static void base_init(legacy_cpu_device *device, device_irq_acknowledge_callback irqcallback) +void v60_device::device_start() { - v60_state *cpustate = get_safe_token(device); + m_stall_io = 0; + m_irq_line = CLEAR_LINE; + m_nmi_line = CLEAR_LINE; - cpustate->stall_io = 0; - cpustate->irq_cb = irqcallback; - cpustate->device = device; - cpustate->irq_line = CLEAR_LINE; - cpustate->nmi_line = CLEAR_LINE; + for ( int i = 0; i < 68; i++ ) + { + // Don't set SP (31), PCi (32), PSW (33), SBR (41), SYCW (43), TKCW (44), PIR (45), PSW2 (51) + if ( i != 31 && i != 32 && i != 33 && i != 41 && i != 43 && i != 44 && i != 45 && i != 51 ) + { + m_reg[i] = 0; + } + } - device->save_item(NAME(cpustate->reg)); - device->save_item(NAME(cpustate->irq_line)); - device->save_item(NAME(cpustate->nmi_line)); - device->save_item(NAME(cpustate->PPC)); - device->save_item(NAME(cpustate->_CY)); - device->save_item(NAME(cpustate->_OV)); - device->save_item(NAME(cpustate->_S)); - device->save_item(NAME(cpustate->_Z)); + m_flags.CY = 0; + m_flags.OV = 0; + m_flags.S = 0; + m_flags.Z = 0; + + m_op1 = 0; + m_op2 = 0; + m_flag1 = 0; + m_flag2 = 0; + m_instflags = 0; + m_lenop1 = 0; + m_lenop2 = 0; + m_subop = 0; + m_bamoffset1 = 0; + m_bamoffset2 = 0; + m_amflag = 0; + m_amout = 0; + m_bamoffset = 0; + m_amlength1 = 0; + m_amlength2 = 0; + m_modadd = 0; + m_modm = 0; + m_modval = 0; + m_modval2 = 0; + m_modwritevalb = 0; + m_modwritevalh = 0; + m_modwritevalw = 0; + m_moddim = 0; + + m_program = &space(AS_PROGRAM); + m_direct = &m_program->direct(); + m_io = &space(AS_IO); + + save_item(NAME(m_reg)); + save_item(NAME(m_irq_line)); + save_item(NAME(m_nmi_line)); + save_item(NAME(m_PPC)); + save_item(NAME(_CY)); + save_item(NAME(_OV)); + save_item(NAME(_S)); + save_item(NAME(_Z)); + + state_add( V60_R0, "R0", R0).formatstr("%08X"); + state_add( V60_R1, "R1", R1).formatstr("%08X"); + state_add( V60_R2, "R2", R2).formatstr("%08X"); + state_add( V60_R3, "R3", R3).formatstr("%08X"); + state_add( V60_R4, "R4", R4).formatstr("%08X"); + state_add( V60_R5, "R5", R5).formatstr("%08X"); + state_add( V60_R6, "R6", R6).formatstr("%08X"); + state_add( V60_R7, "R7", R7).formatstr("%08X"); + state_add( V60_R8, "R8", R8).formatstr("%08X"); + state_add( V60_R9, "R9", R9).formatstr("%08X"); + state_add( V60_R10, "R10", R10).formatstr("%08X"); + state_add( V60_R11, "R11", R11).formatstr("%08X"); + state_add( V60_R12, "R12", R12).formatstr("%08X"); + state_add( V60_R13, "R13", R13).formatstr("%08X"); + state_add( V60_R14, "R14", R14).formatstr("%08X"); + state_add( V60_R15, "R15", R15).formatstr("%08X"); + state_add( V60_R16, "R16", R16).formatstr("%08X"); + state_add( V60_R17, "R17", R17).formatstr("%08X"); + state_add( V60_R18, "R18", R18).formatstr("%08X"); + state_add( V60_R19, "R19", R19).formatstr("%08X"); + state_add( V60_R20, "R20", R20).formatstr("%08X"); + state_add( V60_R21, "R21", R21).formatstr("%08X"); + state_add( V60_R22, "R22", R22).formatstr("%08X"); + state_add( V60_R23, "R23", R23).formatstr("%08X"); + state_add( V60_R24, "R24", R24).formatstr("%08X"); + state_add( V60_R25, "R25", R25).formatstr("%08X"); + state_add( V60_R26, "R26", R26).formatstr("%08X"); + state_add( V60_R27, "R27", R27).formatstr("%08X"); + state_add( V60_R28, "R28", R28).formatstr("%08X"); + state_add( V60_AP, "AP", AP).formatstr("%08X"); + state_add( V60_FP, "FP", FP).formatstr("%08X"); + state_add( V60_SP, "SP", SP).formatstr("%08X"); + state_add( V60_PC, "PC", PC).formatstr("%08X"); + state_add( V60_PSW, "PSW", m_debugger_temp).callimport().callexport().formatstr("%08X"); + state_add( V60_ISP, "ISP", ISP).formatstr("%08X"); + state_add( V60_L0SP, "L0SP", L0SP).formatstr("%08X"); + state_add( V60_L1SP, "L1SP", L1SP).formatstr("%08X"); + state_add( V60_L2SP, "L2SP", L2SP).formatstr("%08X"); + state_add( V60_L3SP, "L3SP", L3SP).formatstr("%08X"); + state_add( V60_SBR, "SBR", SBR).formatstr("%08X"); + state_add( V60_TR, "TR", TR).formatstr("%08X"); + state_add( V60_SYCW, "SYCW", SYCW).formatstr("%08X"); + state_add( V60_TKCW, "TKCW", TKCW).formatstr("%08X"); + state_add( V60_PIR, "PIR", PIR).formatstr("%08X"); + state_add( V60_PSW2, "PSW2", PSW2).formatstr("%08X"); + state_add( V60_ATBR0, "ATBR0", ATBR0).formatstr("%08X"); + state_add( V60_ATLR0, "ATLR0", ATLR0).formatstr("%08X"); + state_add( V60_ATBR1, "ATBR1", ATBR1).formatstr("%08X"); + state_add( V60_ATLR1, "ATLR1", ATLR1).formatstr("%08X"); + state_add( V60_ATBR2, "ATBR2", ATBR2).formatstr("%08X"); + state_add( V60_ATLR2, "ATLR2", ATLR2).formatstr("%08X"); + state_add( V60_ATBR3, "ATBR3", ATBR3).formatstr("%08X"); + state_add( V60_ATLR3, "ATLR3", ATLR3).formatstr("%08X"); + state_add( V60_TRMODE, "TRMODE", TRMODE).formatstr("%08X"); + state_add( V60_ADTR0, "ADTR0", ADTR0).formatstr("%08X"); + state_add( V60_ADTR1, "ADTR1", ADTR1).formatstr("%08X"); + state_add( V60_ADTMR0, "ADTMR0", ADTMR0).formatstr("%08X"); + state_add( V60_ADTMR1, "ADTMR1", ADTMR1).formatstr("%08X"); + + state_add( STATE_GENPC, "GENPC", PC).noshow(); + state_add( STATE_GENPCBASE, "GENPCBASE", m_PPC ).noshow(); + state_add( STATE_GENSP, "GENSP", SP ).noshow(); + state_add( STATE_GENFLAGS, "GENFLAGS", m_debugger_temp).noshow(); + + m_icountptr = &m_icount; } -static CPU_INIT( v60 ) + +void v60_device::state_export(const device_state_entry &entry) { - v60_state *cpustate = get_safe_token(device); - - base_init(device, irqcallback); - // Set cpustate->PIR (Processor ID) for NEC cpustate-> LSB is reserved to NEC, - // so I don't know what it contains. - cpustate->PIR = 0x00006000; - cpustate->fetch_xor = BYTE_XOR_LE(0); - cpustate->start_pc = 0xfffff0; - cpustate->device = device; - cpustate->program = &device->space(AS_PROGRAM); - cpustate->direct = &cpustate->program->direct(); - cpustate->io = &device->space(AS_IO); -} - -static CPU_INIT( v70 ) -{ - v60_state *cpustate = get_safe_token(device); - - base_init(device, irqcallback); - // Set cpustate->PIR (Processor ID) for NEC v70. LSB is reserved to NEC, - // so I don't know what it contains. - cpustate->PIR = 0x00007000; - cpustate->fetch_xor = BYTE4_XOR_LE(0); - cpustate->start_pc = 0xfffffff0; - cpustate->device = device; - cpustate->program = &device->space(AS_PROGRAM); - cpustate->direct = &cpustate->program->direct(); - cpustate->io = &device->space(AS_IO); -} - -static CPU_RESET( v60 ) -{ - v60_state *cpustate = get_safe_token(device); - - cpustate->PSW = 0x10000000; - cpustate->PC = cpustate->start_pc; - cpustate->SBR = 0x00000000; - cpustate->SYCW = 0x00000070; - cpustate->TKCW = 0x0000e000; - cpustate->PSW2 = 0x0000f002; - - cpustate->_CY = 0; - cpustate->_OV = 0; - cpustate->_S = 0; - cpustate->_Z = 0; -} - -static CPU_EXIT( v60 ) -{ -} - -void v60_stall(device_t *device) -{ - v60_state *cpustate = get_safe_token(device); - cpustate->stall_io = 1; -} - -static void v60_do_irq(v60_state *cpustate, int vector) -{ - UINT32 oldPSW = v60_update_psw_for_exception(cpustate, 1, 0); - - // Push cpustate->PC and cpustate->PSW onto the stack - cpustate->SP-=4; - cpustate->program->write_dword_unaligned(cpustate->SP, oldPSW); - cpustate->SP-=4; - cpustate->program->write_dword_unaligned(cpustate->SP, cpustate->PC); - - // Jump to vector for user interrupt - cpustate->PC = GETINTVECT(cpustate, vector); -} - -static void v60_try_irq(v60_state *cpustate) -{ - if(cpustate->irq_line == CLEAR_LINE) - return; - if((cpustate->PSW & (1 << 18)) != 0) { - int vector; - if(cpustate->irq_line != ASSERT_LINE) - cpustate->irq_line = CLEAR_LINE; - - vector = cpustate->irq_cb(cpustate->device, 0); - - v60_do_irq(cpustate, vector + 0x40); + switch (entry.index()) + { + case V60_PSW: + m_debugger_temp = v60ReadPSW(); + break; } } -static void set_irq_line(v60_state *cpustate, int irqline, int state) + +void v60_device::state_import(const device_state_entry &entry) +{ + switch (entry.index()) + { + case V60_PSW: + v60WritePSW( m_debugger_temp ); + break; + } +} + + +void v60_device::device_reset() +{ + PSW = 0x10000000; + PC = m_start_pc; + SBR = 0x00000000; + SYCW = 0x00000070; + TKCW = 0x0000e000; + PSW2 = 0x0000f002; + + _CY = 0; + _OV = 0; + _S = 0; + _Z = 0; +} + + +void v60_device::stall() +{ + m_stall_io = 1; +} + + +void v60_device::v60_do_irq(int vector) +{ + UINT32 oldPSW = v60_update_psw_for_exception(1, 0); + + // Push PC and PSW onto the stack + SP-=4; + m_program->write_dword_unaligned(SP, oldPSW); + SP-=4; + m_program->write_dword_unaligned(SP, PC); + + // Jump to vector for user interrupt + PC = GETINTVECT(vector); +} + +void v60_device::v60_try_irq() +{ + if(m_irq_line == CLEAR_LINE) + return; + if((PSW & (1 << 18)) != 0) { + int vector; + if(m_irq_line != ASSERT_LINE) + m_irq_line = CLEAR_LINE; + + vector = standard_irq_callback(0); + + v60_do_irq(vector + 0x40); + } +} + +void v60_device::execute_set_input(int irqline, int state) { if(irqline == INPUT_LINE_NMI) { switch(state) { case ASSERT_LINE: - if(cpustate->nmi_line == CLEAR_LINE) { - cpustate->nmi_line = ASSERT_LINE; - v60_do_irq(cpustate, 2); + if(m_nmi_line == CLEAR_LINE) { + m_nmi_line = ASSERT_LINE; + v60_do_irq(2); } break; case CLEAR_LINE: - cpustate->nmi_line = CLEAR_LINE; + m_nmi_line = CLEAR_LINE; break; } } else { - cpustate->irq_line = state; - v60_try_irq(cpustate); + m_irq_line = state; + v60_try_irq(); } } // Actual cycles / instruction is unknown -static CPU_EXECUTE( v60 ) +void v60_device::execute_run() { - v60_state *cpustate = get_safe_token(device); + if (m_irq_line != CLEAR_LINE) + v60_try_irq(); - if (cpustate->irq_line != CLEAR_LINE) - v60_try_irq(cpustate); - - while (cpustate->icount > 0) + while (m_icount > 0) { UINT32 inc; - cpustate->PPC = cpustate->PC; - debugger_instruction_hook(device, cpustate->PC); - cpustate->icount -= 8; /* fix me -- this is just an average */ - inc = OpCodeTable[OpRead8(cpustate, cpustate->PC)](cpustate); - cpustate->PC += inc; - if (cpustate->irq_line != CLEAR_LINE) - v60_try_irq(cpustate); + m_PPC = PC; + debugger_instruction_hook(this, PC); + m_icount -= 8; /* fix me -- this is just an average */ + inc = (this->*s_OpCodeTable[OpRead8(PC)])(); + PC += inc; + if (m_irq_line != CLEAR_LINE) + v60_try_irq(); } } - -CPU_DISASSEMBLE( v60 ); -CPU_DISASSEMBLE( v70 ); - - -/************************************************************************** - * Generic set_info - **************************************************************************/ - -static CPU_SET_INFO( v60 ) -{ - v60_state *cpustate = get_safe_token(device); - - switch (state) - { - /* --- the following bits of info are set as 64-bit signed integers --- */ - case CPUINFO_INT_INPUT_STATE + 0: set_irq_line(cpustate, 0, info->i); break; - case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI: set_irq_line(cpustate, INPUT_LINE_NMI, info->i);break; - - case CPUINFO_INT_PC: cpustate->PC = info->i; break; - case CPUINFO_INT_SP: cpustate->SP = info->i; break; - - case CPUINFO_INT_REGISTER + V60_R0: cpustate->R0 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R1: cpustate->R1 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R2: cpustate->R2 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R3: cpustate->R3 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R4: cpustate->R4 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R5: cpustate->R5 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R6: cpustate->R6 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R7: cpustate->R7 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R8: cpustate->R8 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R9: cpustate->R9 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R10: cpustate->R10 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R11: cpustate->R11 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R12: cpustate->R12 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R13: cpustate->R13 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R14: cpustate->R14 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R15: cpustate->R15 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R16: cpustate->R16 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R17: cpustate->R17 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R18: cpustate->R18 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R19: cpustate->R19 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R20: cpustate->R20 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R21: cpustate->R21 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R22: cpustate->R22 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R23: cpustate->R23 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R24: cpustate->R24 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R25: cpustate->R25 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R26: cpustate->R26 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R27: cpustate->R27 = info->i; break; - case CPUINFO_INT_REGISTER + V60_R28: cpustate->R28 = info->i; break; - case CPUINFO_INT_REGISTER + V60_AP: cpustate->AP = info->i; break; - case CPUINFO_INT_REGISTER + V60_FP: cpustate->FP = info->i; break; - case CPUINFO_INT_REGISTER + V60_SP: cpustate->SP = info->i; break; - case CPUINFO_INT_REGISTER + V60_PC: cpustate->PC = info->i; break; - case CPUINFO_INT_REGISTER + V60_PSW: v60WritePSW(cpustate, info->i); break; - case CPUINFO_INT_REGISTER + V60_ISP: cpustate->ISP = info->i; break; - case CPUINFO_INT_REGISTER + V60_L0SP: cpustate->L0SP = info->i; break; - case CPUINFO_INT_REGISTER + V60_L1SP: cpustate->L1SP = info->i; break; - case CPUINFO_INT_REGISTER + V60_L2SP: cpustate->L2SP = info->i; break; - case CPUINFO_INT_REGISTER + V60_L3SP: cpustate->L3SP = info->i; break; - case CPUINFO_INT_REGISTER + V60_SBR: cpustate->SBR = info->i; break; - case CPUINFO_INT_REGISTER + V60_TR: cpustate->TR = info->i; break; - case CPUINFO_INT_REGISTER + V60_SYCW: cpustate->SYCW = info->i; break; - case CPUINFO_INT_REGISTER + V60_TKCW: cpustate->TKCW = info->i; break; - case CPUINFO_INT_REGISTER + V60_PIR: cpustate->PIR = info->i; break; - case CPUINFO_INT_REGISTER + V60_PSW2: cpustate->PSW2 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ATBR0: cpustate->ATBR0 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ATLR0: cpustate->ATLR0 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ATBR1: cpustate->ATBR1 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ATLR1: cpustate->ATLR1 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ATBR2: cpustate->ATBR2 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ATLR2: cpustate->ATLR2 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ATBR3: cpustate->ATBR3 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ATLR3: cpustate->ATLR3 = info->i; break; - case CPUINFO_INT_REGISTER + V60_TRMODE: cpustate->TRMODE = info->i; break; - case CPUINFO_INT_REGISTER + V60_ADTR0: cpustate->ADTR0 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ADTR1: cpustate->ADTR1 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ADTMR0: cpustate->ADTMR0 = info->i; break; - case CPUINFO_INT_REGISTER + V60_ADTMR1: cpustate->ADTMR1 = info->i; break; - } -} - - - -/************************************************************************** - * Generic get_info - **************************************************************************/ - -CPU_GET_INFO( v60 ) -{ - v60_state *cpustate = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL; - - switch (state) - { - /* --- the following bits of info are returned as 64-bit signed integers --- */ - case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(v60_state); break; - case CPUINFO_INT_INPUT_LINES: info->i = 1; break; - case CPUINFO_INT_DEFAULT_IRQ_VECTOR: info->i = 0; break; - case CPUINFO_INT_ENDIANNESS: info->i = ENDIANNESS_LITTLE; break; - case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break; - case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break; - case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 1; break; - case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 22; break; - case CPUINFO_INT_MIN_CYCLES: info->i = 1; break; - case CPUINFO_INT_MAX_CYCLES: info->i = 1; break; - - case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 16; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 24; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = 0; break; - case CPUINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 0; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 0; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_DATA: info->i = 0; break; - case CPUINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 16; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 24; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_IO: info->i = 0; break; - - case CPUINFO_INT_INPUT_STATE + 0: info->i = cpustate->irq_line; break; - case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI: info->i = cpustate->nmi_line; break; - - case CPUINFO_INT_PREVIOUSPC: info->i = cpustate->PPC; break; - - case CPUINFO_INT_REGISTER + V60_R0: info->i = cpustate->R0; break; - case CPUINFO_INT_REGISTER + V60_R1: info->i = cpustate->R1; break; - case CPUINFO_INT_REGISTER + V60_R2: info->i = cpustate->R2; break; - case CPUINFO_INT_REGISTER + V60_R3: info->i = cpustate->R3; break; - case CPUINFO_INT_REGISTER + V60_R4: info->i = cpustate->R4; break; - case CPUINFO_INT_REGISTER + V60_R5: info->i = cpustate->R5; break; - case CPUINFO_INT_REGISTER + V60_R6: info->i = cpustate->R6; break; - case CPUINFO_INT_REGISTER + V60_R7: info->i = cpustate->R7; break; - case CPUINFO_INT_REGISTER + V60_R8: info->i = cpustate->R8; break; - case CPUINFO_INT_REGISTER + V60_R9: info->i = cpustate->R9; break; - case CPUINFO_INT_REGISTER + V60_R10: info->i = cpustate->R10; break; - case CPUINFO_INT_REGISTER + V60_R11: info->i = cpustate->R11; break; - case CPUINFO_INT_REGISTER + V60_R12: info->i = cpustate->R12; break; - case CPUINFO_INT_REGISTER + V60_R13: info->i = cpustate->R13; break; - case CPUINFO_INT_REGISTER + V60_R14: info->i = cpustate->R14; break; - case CPUINFO_INT_REGISTER + V60_R15: info->i = cpustate->R15; break; - case CPUINFO_INT_REGISTER + V60_R16: info->i = cpustate->R16; break; - case CPUINFO_INT_REGISTER + V60_R17: info->i = cpustate->R17; break; - case CPUINFO_INT_REGISTER + V60_R18: info->i = cpustate->R18; break; - case CPUINFO_INT_REGISTER + V60_R19: info->i = cpustate->R19; break; - case CPUINFO_INT_REGISTER + V60_R20: info->i = cpustate->R20; break; - case CPUINFO_INT_REGISTER + V60_R21: info->i = cpustate->R21; break; - case CPUINFO_INT_REGISTER + V60_R22: info->i = cpustate->R22; break; - case CPUINFO_INT_REGISTER + V60_R23: info->i = cpustate->R23; break; - case CPUINFO_INT_REGISTER + V60_R24: info->i = cpustate->R24; break; - case CPUINFO_INT_REGISTER + V60_R25: info->i = cpustate->R25; break; - case CPUINFO_INT_REGISTER + V60_R26: info->i = cpustate->R26; break; - case CPUINFO_INT_REGISTER + V60_R27: info->i = cpustate->R27; break; - case CPUINFO_INT_REGISTER + V60_R28: info->i = cpustate->R28; break; - case CPUINFO_INT_REGISTER + V60_AP: info->i = cpustate->AP; break; - case CPUINFO_INT_REGISTER + V60_FP: info->i = cpustate->FP; break; - case CPUINFO_INT_SP: - case CPUINFO_INT_REGISTER + V60_SP: info->i = cpustate->SP; break; - case CPUINFO_INT_PC: - case CPUINFO_INT_REGISTER + V60_PC: info->i = cpustate->PC; break; - case CPUINFO_INT_REGISTER + V60_PSW: info->i = v60ReadPSW(cpustate); break; - case CPUINFO_INT_REGISTER + V60_ISP: info->i = cpustate->ISP; break; - case CPUINFO_INT_REGISTER + V60_L0SP: info->i = cpustate->L0SP; break; - case CPUINFO_INT_REGISTER + V60_L1SP: info->i = cpustate->L1SP; break; - case CPUINFO_INT_REGISTER + V60_L2SP: info->i = cpustate->L2SP; break; - case CPUINFO_INT_REGISTER + V60_L3SP: info->i = cpustate->L3SP; break; - case CPUINFO_INT_REGISTER + V60_SBR: info->i = cpustate->SBR; break; - case CPUINFO_INT_REGISTER + V60_TR: info->i = cpustate->TR; break; - case CPUINFO_INT_REGISTER + V60_SYCW: info->i = cpustate->SYCW; break; - case CPUINFO_INT_REGISTER + V60_TKCW: info->i = cpustate->TKCW; break; - case CPUINFO_INT_REGISTER + V60_PIR: info->i = cpustate->PIR; break; - case CPUINFO_INT_REGISTER + V60_PSW2: info->i = cpustate->PSW2; break; - case CPUINFO_INT_REGISTER + V60_ATBR0: info->i = cpustate->ATBR0; break; - case CPUINFO_INT_REGISTER + V60_ATLR0: info->i = cpustate->ATLR0; break; - case CPUINFO_INT_REGISTER + V60_ATBR1: info->i = cpustate->ATBR1; break; - case CPUINFO_INT_REGISTER + V60_ATLR1: info->i = cpustate->ATLR1; break; - case CPUINFO_INT_REGISTER + V60_ATBR2: info->i = cpustate->ATBR2; break; - case CPUINFO_INT_REGISTER + V60_ATLR2: info->i = cpustate->ATLR2; break; - case CPUINFO_INT_REGISTER + V60_ATBR3: info->i = cpustate->ATBR3; break; - case CPUINFO_INT_REGISTER + V60_ATLR3: info->i = cpustate->ATLR3; break; - case CPUINFO_INT_REGISTER + V60_TRMODE: info->i = cpustate->TRMODE; break; - case CPUINFO_INT_REGISTER + V60_ADTR0: info->i = cpustate->ADTR0; break; - case CPUINFO_INT_REGISTER + V60_ADTR1: info->i = cpustate->ADTR1; break; - case CPUINFO_INT_REGISTER + V60_ADTMR0: info->i = cpustate->ADTMR0; break; - case CPUINFO_INT_REGISTER + V60_ADTMR1: info->i = cpustate->ADTMR1; break; - - /* --- the following bits of info are returned as pointers to data or functions --- */ - case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(v60); break; - case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(v60); break; - case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(v60); break; - case CPUINFO_FCT_EXIT: info->exit = CPU_EXIT_NAME(v60); break; - case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(v60); break; - case CPUINFO_FCT_BURN: info->burn = NULL; break; - case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(v60); break; - case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->icount; break; - - /* --- the following bits of info are returned as NULL-terminated strings --- */ - case CPUINFO_STR_NAME: strcpy(info->s, "V60"); break; - case CPUINFO_STR_SHORTNAME: strcpy(info->s, "v60"); break; - case CPUINFO_STR_FAMILY: strcpy(info->s, "NEC V60"); break; - case CPUINFO_STR_VERSION: strcpy(info->s, "1.0"); break; - case CPUINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; - case CPUINFO_STR_CREDITS: strcpy(info->s, "Farfetch'd and R.Belmont"); break; - - case CPUINFO_STR_FLAGS: strcpy(info->s, " "); break; - - case CPUINFO_STR_REGISTER + V60_R0: sprintf(info->s, "R0:%08X", cpustate->R0); break; - case CPUINFO_STR_REGISTER + V60_R1: sprintf(info->s, "R1:%08X", cpustate->R1); break; - case CPUINFO_STR_REGISTER + V60_R2: sprintf(info->s, "R2:%08X", cpustate->R2); break; - case CPUINFO_STR_REGISTER + V60_R3: sprintf(info->s, "R3:%08X", cpustate->R3); break; - case CPUINFO_STR_REGISTER + V60_R4: sprintf(info->s, "R4:%08X", cpustate->R4); break; - case CPUINFO_STR_REGISTER + V60_R5: sprintf(info->s, "R5:%08X", cpustate->R5); break; - case CPUINFO_STR_REGISTER + V60_R6: sprintf(info->s, "R6:%08X", cpustate->R6); break; - case CPUINFO_STR_REGISTER + V60_R7: sprintf(info->s, "R7:%08X", cpustate->R7); break; - case CPUINFO_STR_REGISTER + V60_R8: sprintf(info->s, "R8:%08X", cpustate->R8); break; - case CPUINFO_STR_REGISTER + V60_R9: sprintf(info->s, "R9:%08X", cpustate->R9); break; - case CPUINFO_STR_REGISTER + V60_R10: sprintf(info->s, "R10:%08X", cpustate->R10); break; - case CPUINFO_STR_REGISTER + V60_R11: sprintf(info->s, "R11:%08X", cpustate->R11); break; - case CPUINFO_STR_REGISTER + V60_R12: sprintf(info->s, "R12:%08X", cpustate->R12); break; - case CPUINFO_STR_REGISTER + V60_R13: sprintf(info->s, "R13:%08X", cpustate->R13); break; - case CPUINFO_STR_REGISTER + V60_R14: sprintf(info->s, "R14:%08X", cpustate->R14); break; - case CPUINFO_STR_REGISTER + V60_R15: sprintf(info->s, "R15:%08X", cpustate->R15); break; - case CPUINFO_STR_REGISTER + V60_R16: sprintf(info->s, "R16:%08X", cpustate->R16); break; - case CPUINFO_STR_REGISTER + V60_R17: sprintf(info->s, "R17:%08X", cpustate->R17); break; - case CPUINFO_STR_REGISTER + V60_R18: sprintf(info->s, "R18:%08X", cpustate->R18); break; - case CPUINFO_STR_REGISTER + V60_R19: sprintf(info->s, "R19:%08X", cpustate->R19); break; - case CPUINFO_STR_REGISTER + V60_R20: sprintf(info->s, "R20:%08X", cpustate->R20); break; - case CPUINFO_STR_REGISTER + V60_R21: sprintf(info->s, "R21:%08X", cpustate->R21); break; - case CPUINFO_STR_REGISTER + V60_R22: sprintf(info->s, "R22:%08X", cpustate->R22); break; - case CPUINFO_STR_REGISTER + V60_R23: sprintf(info->s, "R23:%08X", cpustate->R23); break; - case CPUINFO_STR_REGISTER + V60_R24: sprintf(info->s, "R24:%08X", cpustate->R24); break; - case CPUINFO_STR_REGISTER + V60_R25: sprintf(info->s, "R25:%08X", cpustate->R25); break; - case CPUINFO_STR_REGISTER + V60_R26: sprintf(info->s, "R26:%08X", cpustate->R26); break; - case CPUINFO_STR_REGISTER + V60_R27: sprintf(info->s, "R27:%08X", cpustate->R27); break; - case CPUINFO_STR_REGISTER + V60_R28: sprintf(info->s, "R28:%08X", cpustate->R28); break; - case CPUINFO_STR_REGISTER + V60_AP: sprintf(info->s, "AP:%08X", cpustate->AP); break; - case CPUINFO_STR_REGISTER + V60_FP: sprintf(info->s, "FP:%08X", cpustate->FP); break; - case CPUINFO_STR_REGISTER + V60_SP: sprintf(info->s, "SP:%08X", cpustate->SP); break; - case CPUINFO_STR_REGISTER + V60_PC: sprintf(info->s, "PC:%08X", cpustate->PC); break; - case CPUINFO_STR_REGISTER + V60_PSW: sprintf(info->s, "PSW:%08X", v60ReadPSW(cpustate)); break; - case CPUINFO_STR_REGISTER + V60_ISP: sprintf(info->s, "ISP:%08X", cpustate->ISP); break; - case CPUINFO_STR_REGISTER + V60_L0SP: sprintf(info->s, "L0SP:%08X", cpustate->L0SP); break; - case CPUINFO_STR_REGISTER + V60_L1SP: sprintf(info->s, "L1SP:%08X", cpustate->L1SP); break; - case CPUINFO_STR_REGISTER + V60_L2SP: sprintf(info->s, "L2SP:%08X", cpustate->L2SP); break; - case CPUINFO_STR_REGISTER + V60_L3SP: sprintf(info->s, "L3SP:%08X", cpustate->L3SP); break; - case CPUINFO_STR_REGISTER + V60_SBR: sprintf(info->s, "SBR:%08X", cpustate->SBR); break; - case CPUINFO_STR_REGISTER + V60_TR: sprintf(info->s, "TR:%08X", cpustate->TR); break; - case CPUINFO_STR_REGISTER + V60_SYCW: sprintf(info->s, "SYCW:%08X", cpustate->SYCW); break; - case CPUINFO_STR_REGISTER + V60_TKCW: sprintf(info->s, "TKCW:%08X", cpustate->TKCW); break; - case CPUINFO_STR_REGISTER + V60_PIR: sprintf(info->s, "PIR:%08X", cpustate->PIR); break; - case CPUINFO_STR_REGISTER + V60_PSW2: sprintf(info->s, "PSW2:%08X", cpustate->PSW2); break; - case CPUINFO_STR_REGISTER + V60_ATBR0: sprintf(info->s, "ATBR0:%08X", cpustate->ATBR0); break; - case CPUINFO_STR_REGISTER + V60_ATLR0: sprintf(info->s, "ATLR0:%08X", cpustate->ATLR0); break; - case CPUINFO_STR_REGISTER + V60_ATBR1: sprintf(info->s, "ATBR1:%08X", cpustate->ATBR1); break; - case CPUINFO_STR_REGISTER + V60_ATLR1: sprintf(info->s, "ATLR1:%08X", cpustate->ATLR1); break; - case CPUINFO_STR_REGISTER + V60_ATBR2: sprintf(info->s, "ATBR2:%08X", cpustate->ATBR2); break; - case CPUINFO_STR_REGISTER + V60_ATLR2: sprintf(info->s, "ATLR2:%08X", cpustate->ATLR2); break; - case CPUINFO_STR_REGISTER + V60_ATBR3: sprintf(info->s, "ATBR3:%08X", cpustate->ATBR3); break; - case CPUINFO_STR_REGISTER + V60_ATLR3: sprintf(info->s, "ATLR3:%08X", cpustate->ATLR3); break; - case CPUINFO_STR_REGISTER + V60_TRMODE: sprintf(info->s, "TRMODE:%08X", cpustate->TRMODE); break; - case CPUINFO_STR_REGISTER + V60_ADTR0: sprintf(info->s, "ADTR0:%08X", cpustate->ADTR0); break; - case CPUINFO_STR_REGISTER + V60_ADTR1: sprintf(info->s, "ADTR1:%08X", cpustate->ADTR1); break; - case CPUINFO_STR_REGISTER + V60_ADTMR0: sprintf(info->s, "ADTMR0:%08X", cpustate->ADTMR0); break; - case CPUINFO_STR_REGISTER + V60_ADTMR1: sprintf(info->s, "ADTMR1:%08X", cpustate->ADTMR1); break; - } -} - - -/************************************************************************** - * CPU-specific set_info - **************************************************************************/ - -CPU_GET_INFO( v70 ) -{ - switch (state) - { - /* --- the following bits of info are returned as 64-bit signed integers --- */ - case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 32; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 32; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = 0; break; - - /* --- the following bits of info are returned as pointers to data or functions --- */ - case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(v70); break; - case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(v70); break; - - /* --- the following bits of info are returned as NULL-terminated strings --- */ - case CPUINFO_STR_NAME: strcpy(info->s, "V70"); break; - case CPUINFO_STR_SHORTNAME: strcpy(info->s, "v70"); break; - - default: CPU_GET_INFO_CALL(v60); break; - } -} - -DEFINE_LEGACY_CPU_DEVICE(V60, v60); -DEFINE_LEGACY_CPU_DEVICE(V70, v70); diff --git a/src/emu/cpu/v60/v60.h b/src/emu/cpu/v60/v60.h index 35b653aed26..c9392289618 100644 --- a/src/emu/cpu/v60/v60.h +++ b/src/emu/cpu/v60/v60.h @@ -77,9 +77,716 @@ enum V60_REGMAX }; -void v60_stall(device_t *device); -DECLARE_LEGACY_CPU_DEVICE(V60, v60); -DECLARE_LEGACY_CPU_DEVICE(V70, v70); +class v60_device : public cpu_device +{ +public: + // construction/destruction + v60_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + v60_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source); + + void stall(); + +protected: + // device-level overrides + virtual void device_start(); + virtual void device_reset(); + + // device_execute_interface overrides + virtual UINT32 execute_min_cycles() const { return 1; } + virtual UINT32 execute_max_cycles() const { return 1; } + virtual UINT32 execute_input_lines() const { return 1; } + virtual void execute_run(); + virtual void execute_set_input(int inputnum, int state); + + // device_memory_interface overrides + virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : NULL ); } + + // device_state_interface overrides + virtual void state_import(const device_state_entry &entry); + virtual void state_export(const device_state_entry &entry); + + // device_disasm_interface overrides + virtual UINT32 disasm_min_opcode_bytes() const { return 1; } + virtual UINT32 disasm_max_opcode_bytes() const { return 22; } + virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options); + +private: + typedef UINT32 (v60_device::*am_func)(); + typedef UINT32 (v60_device::*op6_func)(int reg); + + static const am_func s_AMTable1_G7a[16]; + static const am_func s_BAMTable1_G7a[16]; + static const am_func s_AMTable1_G7[32]; + static const am_func s_BAMTable1_G7[32]; + static const am_func s_AMTable1_G6[8]; + static const am_func s_BAMTable1_G6[8]; + static const am_func s_AMTable1[2][8]; + static const am_func s_BAMTable1[2][8]; + static const am_func s_AMTable2_G7a[16]; + static const am_func s_BAMTable2_G7a[16]; + static const am_func s_AMTable2_G7[32]; + static const am_func s_BAMTable2_G7[32]; + static const am_func s_AMTable2_G6[8]; + static const am_func s_BAMTable2_G6[8]; + static const am_func s_AMTable2[2][8]; + static const am_func s_BAMTable2[2][8]; + static const am_func s_AMTable3_G7a[16]; + static const am_func s_AMTable3_G7[32]; + static const am_func s_AMTable3_G6[8]; + static const am_func s_AMTable3[2][8]; + static const am_func s_Op5FTable[32]; + static const am_func s_Op5CTable[32]; + static const op6_func s_OpC6Table[8]; + static const op6_func s_OpC7Table[8]; + static const am_func s_Op59Table[32]; + static const am_func s_Op5BTable[32]; + static const am_func s_Op5DTable[32]; + static const am_func s_Op58Table[32]; + static const am_func s_Op5ATable[32]; + static const am_func s_OpCodeTable[256]; + + address_space_config m_program_config; + address_space_config m_io_config; + + offs_t m_fetch_xor; + offs_t m_start_pc; + UINT32 m_reg[68]; + struct { + UINT8 CY; + UINT8 OV; + UINT8 S; + UINT8 Z; + } m_flags; + UINT8 m_irq_line; + UINT8 m_nmi_line; + address_space *m_program; + direct_read_data * m_direct; + address_space *m_io; + UINT32 m_PPC; + int m_icount; + int m_stall_io; + + UINT32 m_op1, m_op2; + UINT8 m_flag1, m_flag2; + UINT8 m_instflags; + UINT32 m_lenop1, m_lenop2; + UINT8 m_subop; + UINT32 m_bamoffset1, m_bamoffset2; + + // Output variables for ReadAMAddress(cpustate) + UINT8 m_amflag; + UINT32 m_amout; + UINT32 m_bamoffset; + + // Appo temp var + UINT32 m_amlength1, m_amlength2; + + // Global vars used by AM functions + UINT32 m_modadd; + UINT8 m_modm; + UINT8 m_modval; + UINT8 m_modval2; + UINT8 m_modwritevalb; + UINT16 m_modwritevalh; + UINT32 m_modwritevalw; + UINT8 m_moddim; + + UINT32 m_debugger_temp; + + + inline void v60SaveStack(); + inline void v60ReloadStack(); + inline UINT32 v60ReadPSW(); + inline void v60WritePSW(UINT32 newval); + inline UINT32 v60_update_psw_for_exception(int is_interrupt, int target_level); + + UINT32 am1Register(); + UINT32 am1RegisterIndirect(); + UINT32 bam1RegisterIndirect(); + UINT32 am1RegisterIndirectIndexed(); + UINT32 bam1RegisterIndirectIndexed(); + UINT32 am1Autoincrement(); + UINT32 bam1Autoincrement(); + UINT32 am1Autodecrement(); + UINT32 bam1Autodecrement(); + UINT32 am1Displacement8(); + UINT32 bam1Displacement8(); + UINT32 am1Displacement16(); + UINT32 bam1Displacement16(); + UINT32 am1Displacement32(); + UINT32 bam1Displacement32(); + UINT32 am1DisplacementIndexed8(); + UINT32 bam1DisplacementIndexed8(); + UINT32 am1DisplacementIndexed16(); + UINT32 bam1DisplacementIndexed16(); + UINT32 am1DisplacementIndexed32(); + UINT32 bam1DisplacementIndexed32(); + UINT32 am1PCDisplacement8(); + UINT32 bam1PCDisplacement8(); + UINT32 am1PCDisplacement16(); + UINT32 bam1PCDisplacement16(); + UINT32 am1PCDisplacement32(); + UINT32 bam1PCDisplacement32(); + UINT32 am1PCDisplacementIndexed8(); + UINT32 bam1PCDisplacementIndexed8(); + UINT32 am1PCDisplacementIndexed16(); + UINT32 bam1PCDisplacementIndexed16(); + UINT32 am1PCDisplacementIndexed32(); + UINT32 bam1PCDisplacementIndexed32(); + UINT32 am1DisplacementIndirect8(); + UINT32 bam1DisplacementIndirect8(); + UINT32 am1DisplacementIndirect16(); + UINT32 bam1DisplacementIndirect16(); + UINT32 am1DisplacementIndirect32(); + UINT32 bam1DisplacementIndirect32(); + UINT32 am1DisplacementIndirectIndexed8(); + UINT32 bam1DisplacementIndirectIndexed8(); + UINT32 am1DisplacementIndirectIndexed16(); + UINT32 bam1DisplacementIndirectIndexed16(); + UINT32 am1DisplacementIndirectIndexed32(); + UINT32 bam1DisplacementIndirectIndexed32(); + UINT32 am1PCDisplacementIndirect8(); + UINT32 bam1PCDisplacementIndirect8(); + UINT32 am1PCDisplacementIndirect16(); + UINT32 bam1PCDisplacementIndirect16(); + UINT32 am1PCDisplacementIndirect32(); + UINT32 bam1PCDisplacementIndirect32(); + UINT32 am1PCDisplacementIndirectIndexed8(); + UINT32 bam1PCDisplacementIndirectIndexed8(); + UINT32 am1PCDisplacementIndirectIndexed16(); + UINT32 bam1PCDisplacementIndirectIndexed16(); + UINT32 am1PCDisplacementIndirectIndexed32(); + UINT32 bam1PCDisplacementIndirectIndexed32(); + UINT32 am1DoubleDisplacement8(); + UINT32 bam1DoubleDisplacement8(); + UINT32 am1DoubleDisplacement16(); + UINT32 bam1DoubleDisplacement16(); + UINT32 am1DoubleDisplacement32(); + UINT32 bam1DoubleDisplacement32(); + UINT32 am1PCDoubleDisplacement8(); + UINT32 bam1PCDoubleDisplacement8(); + UINT32 am1PCDoubleDisplacement16(); + UINT32 bam1PCDoubleDisplacement16(); + UINT32 am1PCDoubleDisplacement32(); + UINT32 bam1PCDoubleDisplacement32(); + UINT32 am1DirectAddress(); + UINT32 bam1DirectAddress(); + UINT32 am1DirectAddressIndexed(); + UINT32 bam1DirectAddressIndexed(); + UINT32 am1DirectAddressDeferred(); + UINT32 bam1DirectAddressDeferred(); + UINT32 am1DirectAddressDeferredIndexed(); + UINT32 bam1DirectAddressDeferredIndexed(); + UINT32 am1Immediate(); + UINT32 am1ImmediateQuick(); + UINT32 am1Error1(); + UINT32 bam1Error1(); + UINT32 am1Error2(); + UINT32 bam1Error2(); + UINT32 am1Error3(); + UINT32 bam1Error3(); + UINT32 am1Error4(); + UINT32 bam1Error4(); + UINT32 am1Error5(); + UINT32 bam1Error5(); + UINT32 bam1Error6(); + UINT32 am1Group7a(); + UINT32 bam1Group7a(); + UINT32 am1Group6(); + UINT32 bam1Group6(); + UINT32 am1Group7(); + UINT32 bam1Group7(); + UINT32 am2Register(); + UINT32 am2RegisterIndirect(); + UINT32 bam2RegisterIndirect(); + UINT32 am2RegisterIndirectIndexed(); + UINT32 bam2RegisterIndirectIndexed(); + UINT32 am2Autoincrement(); + UINT32 bam2Autoincrement(); + UINT32 am2Autodecrement(); + UINT32 bam2Autodecrement(); + UINT32 am2Displacement8(); + UINT32 bam2Displacement8(); + UINT32 am2Displacement16(); + UINT32 bam2Displacement16(); + UINT32 am2Displacement32(); + UINT32 bam2Displacement32(); + UINT32 am2DisplacementIndexed8(); + UINT32 bam2DisplacementIndexed8(); + UINT32 am2DisplacementIndexed16(); + UINT32 bam2DisplacementIndexed16(); + UINT32 am2DisplacementIndexed32(); + UINT32 bam2DisplacementIndexed32(); + UINT32 am2PCDisplacement8(); + UINT32 bam2PCDisplacement8(); + UINT32 am2PCDisplacement16(); + UINT32 bam2PCDisplacement16(); + UINT32 am2PCDisplacement32(); + UINT32 bam2PCDisplacement32(); + UINT32 am2PCDisplacementIndexed8(); + UINT32 bam2PCDisplacementIndexed8(); + UINT32 am2PCDisplacementIndexed16(); + UINT32 bam2PCDisplacementIndexed16(); + UINT32 am2PCDisplacementIndexed32(); + UINT32 bam2PCDisplacementIndexed32(); + UINT32 am2DisplacementIndirect8(); + UINT32 bam2DisplacementIndirect8(); + UINT32 am2DisplacementIndirect16(); + UINT32 bam2DisplacementIndirect16(); + UINT32 am2DisplacementIndirect32(); + UINT32 bam2DisplacementIndirect32(); + UINT32 am2DisplacementIndirectIndexed8(); + UINT32 bam2DisplacementIndirectIndexed8(); + UINT32 am2DisplacementIndirectIndexed16(); + UINT32 bam2DisplacementIndirectIndexed16(); + UINT32 am2DisplacementIndirectIndexed32(); + UINT32 bam2DisplacementIndirectIndexed32(); + UINT32 am2PCDisplacementIndirect8(); + UINT32 bam2PCDisplacementIndirect8(); + UINT32 am2PCDisplacementIndirect16(); + UINT32 bam2PCDisplacementIndirect16(); + UINT32 am2PCDisplacementIndirect32(); + UINT32 bam2PCDisplacementIndirect32(); + UINT32 am2PCDisplacementIndirectIndexed8(); + UINT32 bam2PCDisplacementIndirectIndexed8(); + UINT32 am2PCDisplacementIndirectIndexed16(); + UINT32 bam2PCDisplacementIndirectIndexed16(); + UINT32 am2PCDisplacementIndirectIndexed32(); + UINT32 bam2PCDisplacementIndirectIndexed32(); + UINT32 am2DoubleDisplacement8(); + UINT32 bam2DoubleDisplacement8(); + UINT32 am2DoubleDisplacement16(); + UINT32 bam2DoubleDisplacement16(); + UINT32 am2DoubleDisplacement32(); + UINT32 bam2DoubleDisplacement32(); + UINT32 am2PCDoubleDisplacement8(); + UINT32 bam2PCDoubleDisplacement8(); + UINT32 am2PCDoubleDisplacement16(); + UINT32 bam2PCDoubleDisplacement16(); + UINT32 am2PCDoubleDisplacement32(); + UINT32 bam2PCDoubleDisplacement32(); + UINT32 am2DirectAddress(); + UINT32 bam2DirectAddress(); + UINT32 am2DirectAddressIndexed(); + UINT32 bam2DirectAddressIndexed(); + UINT32 am2DirectAddressDeferred(); + UINT32 bam2DirectAddressDeferred(); + UINT32 am2DirectAddressDeferredIndexed(); + UINT32 bam2DirectAddressDeferredIndexed(); + UINT32 am2Immediate(); + UINT32 am2ImmediateQuick(); + UINT32 am2Error1(); + UINT32 am2Error2(); + UINT32 am2Error3(); + UINT32 am2Error4(); + UINT32 am2Error5(); + UINT32 bam2Error1(); + UINT32 bam2Error2(); + UINT32 bam2Error3(); + UINT32 bam2Error4(); + UINT32 bam2Error5(); + UINT32 bam2Error6(); + UINT32 am2Group7a(); + UINT32 bam2Group7a(); + UINT32 am2Group6(); + UINT32 bam2Group6(); + UINT32 am2Group7(); + UINT32 bam2Group7(); + UINT32 am3Register(); + UINT32 am3RegisterIndirect(); + UINT32 am3RegisterIndirectIndexed(); + UINT32 am3Autoincrement(); + UINT32 am3Autodecrement(); + UINT32 am3Displacement8(); + UINT32 am3Displacement16(); + UINT32 am3Displacement32(); + UINT32 am3DisplacementIndexed8(); + UINT32 am3DisplacementIndexed16(); + UINT32 am3DisplacementIndexed32(); + UINT32 am3PCDisplacement8(); + UINT32 am3PCDisplacement16(); + UINT32 am3PCDisplacement32(); + UINT32 am3PCDisplacementIndexed8(); + UINT32 am3PCDisplacementIndexed16(); + UINT32 am3PCDisplacementIndexed32(); + UINT32 am3DisplacementIndirect8(); + UINT32 am3DisplacementIndirect16(); + UINT32 am3DisplacementIndirect32(); + UINT32 am3DisplacementIndirectIndexed8(); + UINT32 am3DisplacementIndirectIndexed16(); + UINT32 am3DisplacementIndirectIndexed32(); + UINT32 am3PCDisplacementIndirect8(); + UINT32 am3PCDisplacementIndirect16(); + UINT32 am3PCDisplacementIndirect32(); + UINT32 am3PCDisplacementIndirectIndexed8(); + UINT32 am3PCDisplacementIndirectIndexed16(); + UINT32 am3PCDisplacementIndirectIndexed32(); + UINT32 am3DoubleDisplacement8(); + UINT32 am3DoubleDisplacement16(); + UINT32 am3DoubleDisplacement32(); + UINT32 am3PCDoubleDisplacement8(); + UINT32 am3PCDoubleDisplacement16(); + UINT32 am3PCDoubleDisplacement32(); + UINT32 am3DirectAddress(); + UINT32 am3DirectAddressIndexed(); + UINT32 am3DirectAddressDeferred(); + UINT32 am3DirectAddressDeferredIndexed(); + UINT32 am3Immediate(); + UINT32 am3ImmediateQuick(); + UINT32 am3Error1(); + UINT32 am3Error2(); + UINT32 am3Error3(); + UINT32 am3Error4(); + UINT32 am3Error5(); + UINT32 am3Group7a(); + UINT32 am3Group6(); + UINT32 am3Group7(); + UINT32 ReadAM(); + UINT32 BitReadAM(); + UINT32 ReadAMAddress(); + UINT32 BitReadAMAddress(); + UINT32 WriteAM(); + void F12DecodeFirstOperand(am_func DecodeOp1, UINT8 dim1); + void F12WriteSecondOperand(UINT8 dim2); + void F12DecodeOperands(am_func DecodeOp1, UINT8 dim1, am_func DecodeOp2, UINT8 dim2); + UINT32 opADDB(); + UINT32 opADDH(); + UINT32 opADDW(); + UINT32 opADDCB(); + UINT32 opADDCH(); + UINT32 opADDCW(); + UINT32 opANDB(); + UINT32 opANDH(); + UINT32 opANDW(); + UINT32 opCALL(); + UINT32 opCHKAR(); + UINT32 opCHKAW(); + UINT32 opCHKAE(); + UINT32 opCHLVL(); + UINT32 opCLR1(); + UINT32 opCMPB(); + UINT32 opCMPH(); + UINT32 opCMPW(); + UINT32 opDIVB(); + UINT32 opDIVH(); + UINT32 opDIVW(); + UINT32 opDIVX(); + UINT32 opDIVUX(); + UINT32 opDIVUB(); + UINT32 opDIVUH(); + UINT32 opDIVUW(); + UINT32 opINB(); + UINT32 opINH(); + UINT32 opINW(); + UINT32 opLDPR(); + UINT32 opLDTASK(); + UINT32 opMOVD(); + UINT32 opMOVB(); + UINT32 opMOVH(); + UINT32 opMOVW(); + UINT32 opMOVEAB(); + UINT32 opMOVEAH(); + UINT32 opMOVEAW(); + UINT32 opMOVSBH(); + UINT32 opMOVSBW(); + UINT32 opMOVSHW(); + UINT32 opMOVTHB(); + UINT32 opMOVTWB(); + UINT32 opMOVTWH(); + UINT32 opMOVZBH(); + UINT32 opMOVZBW(); + UINT32 opMOVZHW(); + UINT32 opMULB(); + UINT32 opMULH(); + UINT32 opMULW(); + UINT32 opMULUB(); + UINT32 opMULUH(); + UINT32 opMULUW(); + UINT32 opNEGB(); + UINT32 opNEGH(); + UINT32 opNEGW(); + UINT32 opNOTB(); + UINT32 opNOTH(); + UINT32 opNOTW(); + UINT32 opNOT1(); + UINT32 opORB(); + UINT32 opORH(); + UINT32 opORW(); + UINT32 opOUTB(); + UINT32 opOUTH(); + UINT32 opOUTW(); + UINT32 opREMB(); + UINT32 opREMH(); + UINT32 opREMW(); + UINT32 opREMUB(); + UINT32 opREMUH(); + UINT32 opREMUW(); + UINT32 opROTB(); + UINT32 opROTH(); + UINT32 opROTW(); + UINT32 opROTCB(); + UINT32 opROTCH(); + UINT32 opROTCW(); + UINT32 opRVBIT(); + UINT32 opRVBYT(); + UINT32 opSET1(); + UINT32 opSETF(); + UINT32 opSHAB(); + UINT32 opSHAH(); + UINT32 opSHAW(); + UINT32 opSHLB(); + UINT32 opSHLH(); + UINT32 opSHLW(); + UINT32 opSTPR(); + UINT32 opSUBB(); + UINT32 opSUBH(); + UINT32 opSUBW(); + UINT32 opSUBCB(); + UINT32 opSUBCH(); + UINT32 opSUBCW(); + UINT32 opTEST1(); + UINT32 opUPDPSWW(); + UINT32 opUPDPSWH(); + UINT32 opXCHB(); + UINT32 opXCHH(); + UINT32 opXCHW(); + UINT32 opXORB(); + UINT32 opXORH(); + UINT32 opXORW(); + UINT32 opMULX(); + UINT32 opMULUX(); + void F2DecodeFirstOperand(am_func DecodeOp1, UINT8 dim1); + void F2DecodeSecondOperand(am_func DecodeOp2, UINT8 dim2); + void F2WriteSecondOperand(UINT8 dim2); + UINT32 opCVTWS(); + UINT32 opCVTSW(); + UINT32 opMOVFS(); + UINT32 opNEGFS(); + UINT32 opABSFS(); + UINT32 opADDFS(); + UINT32 opSUBFS(); + UINT32 opMULFS(); + UINT32 opDIVFS(); + UINT32 opSCLFS(); + UINT32 opCMPF(); + UINT32 op5FUNHANDLED(); + UINT32 op5CUNHANDLED(); + UINT32 op5F(); + UINT32 op5C(); + UINT32 opINCB(); + UINT32 opINCH(); + UINT32 opINCW(); + UINT32 opDECB(); + UINT32 opDECH(); + UINT32 opDECW(); + UINT32 opJMP(); + UINT32 opJSR(); + UINT32 opPREPARE(); + UINT32 opRET(); + UINT32 opTRAP(); + UINT32 opRETIU(); + UINT32 opRETIS(); + UINT32 opSTTASK(); + UINT32 opGETPSW(); + UINT32 opTASI(); + UINT32 opCLRTLB(); + UINT32 opPOPM(); + UINT32 opPUSHM(); + UINT32 opTESTB(); + UINT32 opTESTH(); + UINT32 opTESTW(); + UINT32 opPUSH(); + UINT32 opPOP(); + UINT32 opINCB_0(); + UINT32 opINCB_1(); + UINT32 opINCH_0(); + UINT32 opINCH_1(); + UINT32 opINCW_0(); + UINT32 opINCW_1(); + UINT32 opDECB_0(); + UINT32 opDECB_1(); + UINT32 opDECH_0(); + UINT32 opDECH_1(); + UINT32 opDECW_0(); + UINT32 opDECW_1(); + UINT32 opJMP_0(); + UINT32 opJMP_1(); + UINT32 opJSR_0(); + UINT32 opJSR_1(); + UINT32 opPREPARE_0(); + UINT32 opPREPARE_1(); + UINT32 opRET_0(); + UINT32 opRET_1(); + UINT32 opTRAP_0(); + UINT32 opTRAP_1(); + UINT32 opRETIU_0(); + UINT32 opRETIU_1(); + UINT32 opRETIS_0(); + UINT32 opRETIS_1(); + UINT32 opGETPSW_0(); + UINT32 opGETPSW_1(); + UINT32 opTASI_0(); + UINT32 opTASI_1(); + UINT32 opCLRTLB_0(); + UINT32 opCLRTLB_1(); + UINT32 opPOPM_0(); + UINT32 opPOPM_1(); + UINT32 opPUSHM_0(); + UINT32 opPUSHM_1(); + UINT32 opTESTB_0(); + UINT32 opTESTB_1(); + UINT32 opTESTH_0(); + UINT32 opTESTH_1(); + UINT32 opTESTW_0(); + UINT32 opTESTW_1(); + UINT32 opPUSH_0(); + UINT32 opPUSH_1(); + UINT32 opPOP_0(); + UINT32 opPOP_1(); + UINT32 opSTTASK_0(); + UINT32 opSTTASK_1(); + UINT32 opBGT8(); + UINT32 opBGT16(); + UINT32 opBGE8(); + UINT32 opBGE16(); + UINT32 opBLT8(); + UINT32 opBLT16(); + UINT32 opBLE8(); + UINT32 opBLE16(); + UINT32 opBH8(); + UINT32 opBH16(); + UINT32 opBNH8(); + UINT32 opBNH16(); + UINT32 opBNL8(); + UINT32 opBNL16(); + UINT32 opBL8(); + UINT32 opBL16(); + UINT32 opBNE8(); + UINT32 opBNE16(); + UINT32 opBE8(); + UINT32 opBE16(); + UINT32 opBNV8(); + UINT32 opBNV16(); + UINT32 opBV8(); + UINT32 opBV16(); + UINT32 opBP8(); + UINT32 opBP16(); + UINT32 opBN8(); + UINT32 opBN16(); + UINT32 opBR8(); + UINT32 opBR16(); + UINT32 opBSR(); + UINT32 opBRK(); + UINT32 opBRKV(); + UINT32 opCLRTLBA(); + UINT32 opDISPOSE(); + UINT32 opHALT(); + UINT32 opNOP(); + UINT32 opRSR(); + UINT32 opTRAPFL(); + UINT32 opTB(int reg); + UINT32 opDBGT(int reg); + UINT32 opDBLE(int reg); + UINT32 opDBGE(int reg); + UINT32 opDBLT(int reg); + UINT32 opDBH(int reg); + UINT32 opDBNH(int reg); + UINT32 opDBL(int reg); + UINT32 opDBNL(int reg); + UINT32 opDBE(int reg); + UINT32 opDBNE(int reg); + UINT32 opDBV(int reg); + UINT32 opDBNV(int reg); + UINT32 opDBN(int reg); + UINT32 opDBP(int reg); + UINT32 opDBR(int reg); + UINT32 opC6(); + UINT32 opC7(); + void F7aDecodeOperands(am_func DecodeOp1, UINT8 dim1, am_func DecodeOp2, UINT8 dim2); + void F7bDecodeFirstOperand(am_func DecodeOp1, UINT8 dim1); + void F7bWriteSecondOperand(UINT8 dim2); + void F7bDecodeOperands(am_func DecodeOp1, UINT8 dim1, am_func DecodeOp2, UINT8 dim2); + void F7cDecodeOperands(am_func DecodeOp1, UINT8 dim1, am_func DecodeOp2, UINT8 dim2); + UINT32 opCMPSTRB(UINT8 bFill, UINT8 bStop); + UINT32 opCMPSTRH(UINT8 bFill, UINT8 bStop); + UINT32 opMOVSTRUB(UINT8 bFill, UINT8 bStop); + UINT32 opMOVSTRDB(UINT8 bFill, UINT8 bStop); + UINT32 opMOVSTRUH(UINT8 bFill, UINT8 bStop); + UINT32 opMOVSTRDH(UINT8 bFill, UINT8 bStop); + UINT32 opSEARCHUB(UINT8 bSearch); + UINT32 opSEARCHUH(UINT8 bSearch); + UINT32 opSEARCHDB(UINT8 bSearch); + UINT32 opSEARCHDH(UINT8 bSearch); + UINT32 opSCHCUB(); + UINT32 opSCHCUH(); + UINT32 opSCHCDB(); + UINT32 opSCHCDH(); + UINT32 opSKPCUB(); + UINT32 opSKPCUH(); + UINT32 opSKPCDB(); + UINT32 opSKPCDH(); + UINT32 opCMPCB(); + UINT32 opCMPCH(); + UINT32 opCMPCFB(); + UINT32 opCMPCFH(); + UINT32 opCMPCSB(); + UINT32 opCMPCSH(); + UINT32 opMOVCUB(); + UINT32 opMOVCUH(); + UINT32 opMOVCFUB(); + UINT32 opMOVCFUH(); + UINT32 opMOVCSUB(); + UINT32 opMOVCSUH(); + UINT32 opMOVCDB(); + UINT32 opMOVCDH(); + UINT32 opMOVCFDB(); + UINT32 opMOVCFDH(); + UINT32 opEXTBFZ(); + UINT32 opEXTBFS(); + UINT32 opEXTBFL(); + UINT32 opSCHBS(UINT32 bSearch1); + UINT32 opSCH0BSU(); + UINT32 opSCH1BSU(); + UINT32 opINSBFR(); + UINT32 opINSBFL(); + UINT32 opMOVBSD(); + UINT32 opMOVBSU(); + UINT32 opADDDC(); + UINT32 opSUBDC(); + UINT32 opSUBRDC(); + UINT32 opCVTDPZ(); + UINT32 opCVTDZP(); + UINT32 op58UNHANDLED(); + UINT32 op5AUNHANDLED(); + UINT32 op5BUNHANDLED(); + UINT32 op5DUNHANDLED(); + UINT32 op59UNHANDLED(); + UINT32 op58(); + UINT32 op5A(); + UINT32 op5B(); + UINT32 op5D(); + UINT32 op59(); + UINT32 opUNHANDLED(); + void v60_do_irq(int vector); + void v60_try_irq(); + +}; + + +class v70_device : public v60_device +{ +public: + // construction/destruction + v70_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + +protected: + virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options); +}; + + +extern const device_type V60; +extern const device_type V70; + #endif /* __V60_H__ */ diff --git a/src/mame/includes/model1.h b/src/mame/includes/model1.h index a108bf97e59..a70fb720de5 100644 --- a/src/mame/includes/model1.h +++ b/src/mame/includes/model1.h @@ -1,5 +1,6 @@ #include "audio/dsbz80.h" #include "audio/segam1audio.h" +#include "cpu/v60/v60.h" typedef void (*tgp_func)(running_machine &machine); @@ -21,7 +22,7 @@ public: m_display_list1(*this, "display_list1"), m_color_xlat(*this, "color_xlat"){ } - required_device m_maincpu; // V60 + required_device m_maincpu; // V60 required_device m_m1audio; // Model 1 standard sound board optional_device m_dsbz80; // Digital Sound Board optional_device m_tgp; diff --git a/src/mame/machine/model1.c b/src/mame/machine/model1.c index e0154fb2ece..6fb232bf5da 100644 --- a/src/mame/machine/model1.c +++ b/src/mame/machine/model1.c @@ -2099,7 +2099,7 @@ static UINT32 copro_fifoout_pop(address_space &space) if (state->m_copro_fifoout_num == 0) { // Reading from empty FIFO causes the v60 to enter wait state - v60_stall(state->m_maincpu); + state->m_maincpu->stall(); space.machine().scheduler().synchronize();