diff options
Diffstat (limited to 'src/devices/cpu/arcompact/arcompact.cpp')
-rw-r--r-- | src/devices/cpu/arcompact/arcompact.cpp | 2885 |
1 files changed, 2812 insertions, 73 deletions
diff --git a/src/devices/cpu/arcompact/arcompact.cpp b/src/devices/cpu/arcompact/arcompact.cpp index c35798e5b94..7b13e7eafe2 100644 --- a/src/devices/cpu/arcompact/arcompact.cpp +++ b/src/devices/cpu/arcompact/arcompact.cpp @@ -1,10 +1,9 @@ // license:BSD-3-Clause // copyright-holders:David Haywood /*********************************\ - ARCompact Core - The following procesors use the ARCompact instruction set + The following processors use the ARCompact instruction set - ARCtangent-A5 - ARC 600 @@ -13,53 +12,222 @@ (this is a skeleton core) ARCompact is a 32-bit CPU that freely mixes 32-bit and 16-bit instructions - various user customizations could be made as with the ARC A4 based processors + + Various user customizations could be made as with the ARC A4 based processors these include custom instructions and registers. \*********************************/ #include "emu.h" -#include "debugger.h" -#include "arcompact.h" +#include "arcompact_helper.ipp" + #include "arcompactdasm.h" DEFINE_DEVICE_TYPE(ARCA5, arcompact_device, "arc_a5", "Argonaut ARCtangent A5") +uint32_t arcompact_device::arcompact_auxreg002_LPSTART_r() { return m_LP_START & 0xfffffffe; } +void arcompact_device::arcompact_auxreg002_LPSTART_w(uint32_t data) { m_LP_START = data & 0xfffffffe; } +uint32_t arcompact_device::arcompact_auxreg003_LPEND_r() { return m_LP_END & 0xfffffffe; } +void arcompact_device::arcompact_auxreg003_LPEND_w(uint32_t data) { m_LP_END = data & 0xfffffffe; } -READ32_MEMBER( arcompact_device::arcompact_auxreg002_LPSTART_r) { return m_LP_START&0xfffffffe; } -WRITE32_MEMBER(arcompact_device::arcompact_auxreg002_LPSTART_w) { m_LP_START = data&0xfffffffe; } -READ32_MEMBER( arcompact_device::arcompact_auxreg003_LPEND_r) { return m_LP_END&0xfffffffe; } -WRITE32_MEMBER(arcompact_device::arcompact_auxreg003_LPEND_w) { m_LP_END = data&0xfffffffe; } +uint32_t arcompact_device::arcompact_auxreg00a_STATUS32_r() { return m_status32; } -READ32_MEMBER( arcompact_device::arcompact_auxreg00a_STATUS32_r) { return 0xffffdead; /*m_status32;*/ } +uint32_t arcompact_device::arcompact_auxreg00b_STATUS32_L1_r() { return m_status32_l1; } +uint32_t arcompact_device::arcompact_auxreg00c_STATUS32_L2_r() { return m_status32_l2; } +void arcompact_device::arcompact_auxreg00b_STATUS32_L1_w(uint32_t data) { m_status32_l1 = data; } +void arcompact_device::arcompact_auxreg00c_STATUS32_L2_w(uint32_t data) { m_status32_l2 = data; } + +void arcompact_device::arcompact_auxreg012_MULHI_w(uint32_t data) +{ + // The regular multiply result registers (r56 - MLO, r57 - MMID and r58 - MHI) are read-only + // this optional extension allows the program to directly set the value of MHI + // so that it's state can be restored + // + // (although the Leapster BIOS tries to write MMID directly when doing such a restoration + // despite otherwise going through the recommended procedure of multiplying the lower result + // by 1 to restore MLO and writing to this AUX address to restore MHI) + m_regs[REG_MHI] = data; +} -READ32_MEMBER( arcompact_device::arcompact_auxreg025_INTVECTORBASE_r) { return m_INTVECTORBASE&0xfffffc00; } -WRITE32_MEMBER(arcompact_device::arcompact_auxreg025_INTVECTORBASE_w) { m_INTVECTORBASE = data&0xfffffc00; } +uint32_t arcompact_device::arcompact_auxreg043_AUX_IRQ_LV12_r() +{ + logerror("%s: arcompact_auxreg043_AUX_IRQ_LV12_r\n", machine().describe_context()); + return m_AUX_IRQ_LV12; +} +void arcompact_device::arcompact_auxreg043_AUX_IRQ_LV12_w(uint32_t data) +{ + logerror("%s: arcompact_auxreg043_AUX_IRQ_LV12_w %08x\n", machine().describe_context(), data); + if (data & 0x00000001) m_AUX_IRQ_LV12 &= ~0x00000001; + if (data & 0x00000002) m_AUX_IRQ_LV12 &= ~0x00000002; +} +uint32_t arcompact_device::arcompact_auxreg025_INTVECTORBASE_r() { return m_INTVECTORBASE & 0xfffffc00; } -void arcompact_device::arcompact_auxreg_map(address_map &map) +void arcompact_device::arcompact_auxreg025_INTVECTORBASE_w(uint32_t data) { + logerror("%s: m_INTVECTORBASE write %08x\n", machine().describe_context(), data); + m_INTVECTORBASE = data & 0xfffffc00; +} + +uint32_t arcompact_device::arcompact_auxreg012_TIMER0_r(offs_t offset) +{ + switch (offset) + { + case 0x00: + logerror("%s: TIMER0 COUNT read\n", machine().describe_context()); + return m_timer[0][0]; + case 0x01: + logerror("%s: TIMER0 CONTROL read\n", machine().describe_context()); + return m_timer[0][1]; + case 0x02: + logerror("%s: TIMER0 LIMIT read\n", machine().describe_context()); + return m_timer[0][2]; + } + return 0x00; +} + +uint32_t arcompact_device::arcompact_auxreg100_TIMER1_r(offs_t offset) +{ + switch (offset) + { + case 0x00: + logerror("%s: TIMER1 COUNT read\n", machine().describe_context()); + return m_timer[1][0]; + case 0x01: + logerror("%s: TIMER1 CONTROL read\n", machine().describe_context()); + return m_timer[1][1]; + case 0x02: + logerror("%s: TIMER1 LIMIT read\n", machine().describe_context()); + return m_timer[1][2]; + } + return 0x00; +} + +void arcompact_device::arcompact_auxreg012_TIMER0_w(offs_t offset, uint32_t data) +{ + switch (offset) + { + case 0x00: + m_timer[0][0] = data; + logerror("%s: TIMER0 COUNT write %08x\n", machine().describe_context(), data); + break; + case 0x01: + m_timer[0][1] = data; + logerror("%s: TIMER0 CONTROL write %08x\n", machine().describe_context(), data); + break; + case 0x02: + m_timer[0][2] = data; + logerror("%s: TIMER0 LIMIT write %08x\n", machine().describe_context(), data); + break; + } +} + +void arcompact_device::arcompact_auxreg100_TIMER1_w(offs_t offset, uint32_t data) +{ + switch (offset) + { + case 0x00: + m_timer[1][0] = data; + logerror("%s: TIMER1 COUNT write %08x\n", machine().describe_context(), data); + break; + case 0x01: + m_timer[1][1] = data; + logerror("%s: TIMER1 CONTROL write %08x\n", machine().describe_context(), data); + break; + case 0x02: + m_timer[1][2] = data; + logerror("%s: TIMER1 LIMIT write %08x\n", machine().describe_context(), data); + break; + } +} + +uint32_t arcompact_device::arcompact_auxreg200_AUX_IRQ_LVL_r() +{ + logerror("%s: arcompact_auxreg200_AUX_IRQ_LVL_r\n", machine().describe_context()); + return 0; +} + +void arcompact_device::arcompact_auxreg200_AUX_IRQ_LVL_w(uint32_t data) +{ + logerror("%s: arcompact_auxreg200_AUX_IRQ_LVL_w %08x\n", machine().describe_context(), data); + m_AUX_IRQ_LEV = data; +} + + + +void arcompact_device::arcompact_auxreg_map(address_map& map) +{ + //map(0x000000000, 0x000000000) // STATUS register in ARCtangent-A4 format (legacy) + //map(0x000000001, 0x000000001) // SEMAPHORE (for multi-cpu comms) map(0x000000002, 0x000000002).rw(FUNC(arcompact_device::arcompact_auxreg002_LPSTART_r), FUNC(arcompact_device::arcompact_auxreg002_LPSTART_w)); map(0x000000003, 0x000000003).rw(FUNC(arcompact_device::arcompact_auxreg003_LPEND_r), FUNC(arcompact_device::arcompact_auxreg003_LPEND_w)); - map(0x000000009, 0x000000009).r(FUNC(arcompact_device::arcompact_auxreg00a_STATUS32_r)); // r/o + //map(0x000000004, 0x000000004) // IDENTITY (processor ID register) + //map(0x000000005, 0x000000005) // DEBUG (various flags, including SLEEP) + //map(0x000000006, 0x000000006) // PC (alt way of reading current PC) + map(0x00000000a, 0x00000000a).r(FUNC(arcompact_device::arcompact_auxreg00a_STATUS32_r)); // r/o + map(0x00000000b, 0x00000000b).rw(FUNC(arcompact_device::arcompact_auxreg00b_STATUS32_L1_r), FUNC(arcompact_device::arcompact_auxreg00b_STATUS32_L1_w)); + map(0x00000000c, 0x00000000c).rw(FUNC(arcompact_device::arcompact_auxreg00c_STATUS32_L2_r), FUNC(arcompact_device::arcompact_auxreg00c_STATUS32_L2_w)); + + map(0x000000012, 0x000000012).w(FUNC(arcompact_device::arcompact_auxreg012_MULHI_w)); + + map(0x000000021, 0x000000023).rw(FUNC(arcompact_device::arcompact_auxreg012_TIMER0_r), FUNC(arcompact_device::arcompact_auxreg012_TIMER0_w)); + map(0x000000025, 0x000000025).rw(FUNC(arcompact_device::arcompact_auxreg025_INTVECTORBASE_r), FUNC(arcompact_device::arcompact_auxreg025_INTVECTORBASE_w)); -} -#define AUX_SPACE_ADDRESS_WIDTH 32 // IO space is 32 bits of dwords + //map(0x000000041, 0x000000041) // AUX_MACMODE (used by optional maths extensions) + + map(0x000000043, 0x000000043).rw(FUNC(arcompact_device::arcompact_auxreg043_AUX_IRQ_LV12_r), FUNC(arcompact_device::arcompact_auxreg043_AUX_IRQ_LV12_w)); -arcompact_device::arcompact_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) + // these registers can be used to check which optional capabilities any given CPU was built with + //map(0x000000060, 0x000000060) // BCR_VER - Build Configuration Registers Version + //map(0x000000063, 0x000000063) // BTA_LINK_BUILD - Build configuration for BTA Registers + //map(0x000000065, 0x000000065) // EA_BUILD - Build configuration for Extended Arithmetic + //map(0x000000068, 0x000000068) // VECBASE_AC_BUILD - Build configuration for Interrupts + //map(0x00000006e, 0x00000006e) // RF_BUILD - Build configuration for Core Registers + //map(0x000000075, 0x000000075) // TIMER_BUILD - Build configuration for Processor Timers + //map(0x00000007b, 0x00000007b) // MULTIPLY_BUILD - Build configuration for Multiply + //map(0x00000007c, 0x00000007c) // SWAP_BUILD - Build configuration for Swap + //map(0x00000007d, 0x00000007d) // NORM_BUILD - Build configuration for Normalize + //map(0x00000007e, 0x00000007e) // MINMAX_BUILD - Build configuration for Min/Max + //map(0x00000007f, 0x00000007f) // BARREL_BUILD - Build configuration for Barrel Shift + + map(0x000000100, 0x000000102).rw(FUNC(arcompact_device::arcompact_auxreg100_TIMER1_r), FUNC(arcompact_device::arcompact_auxreg100_TIMER1_w)); + + map(0x000000200, 0x000000200).rw(FUNC(arcompact_device::arcompact_auxreg200_AUX_IRQ_LVL_r), FUNC(arcompact_device::arcompact_auxreg200_AUX_IRQ_LVL_w)); + //map(0x000000201, 0x000000201) // AUX_IRQ_HINT + + // below are ARC700 registers + //map(0x000000400, 0x000000400) // ERET + //map(0x000000401, 0x000000401) // ERBTA + //map(0x000000402, 0x000000402) // ERSTATUS + //map(0x000000403, 0x000000403) // ECR + //map(0x000000404, 0x000000404) // EFA + //map(0x00000040a, 0x00000040a) // ICAUSE1 + //map(0x00000040b, 0x00000040b) // ICAUSE2 + //map(0x00000040c, 0x00000040c) // AUX_IENABLE + //map(0x00000040d, 0x00000040d) // AUX_ITRIGGER + //map(0x000000410, 0x000000410) // XPU + //map(0x000000412, 0x000000412) // BTA + //map(0x000000413, 0x000000413) // BTA_L1 + //map(0x000000414, 0x000000414) // BTA_L2 + //map(0x000000415, 0x000000415) // AUX_IRQ_PULSE_CANCEL + //map(0x000000416, 0x000000416) // AUX_IRQ_PENDING +} + +arcompact_device::arcompact_device(const machine_config& mconfig, const char* tag, device_t* owner, uint32_t clock) : cpu_device(mconfig, ARCA5, tag, owner, clock) - , m_program_config("program", ENDIANNESS_LITTLE, 32, 32, 0) // some docs describe these as 'middle endian'?! - , m_io_config( "io", ENDIANNESS_LITTLE, 32, AUX_SPACE_ADDRESS_WIDTH, -2, address_map_constructor(FUNC(arcompact_device::arcompact_auxreg_map), this)) + , m_program_config("program", ENDIANNESS_LITTLE, 32, 32, 0) // some docs describe these as 'middle endian' + , m_io_config("io", ENDIANNESS_LITTLE, 32, 32, -2, address_map_constructor(FUNC(arcompact_device::arcompact_auxreg_map), this)) + , m_default_vector_base(0) { } device_memory_interface::space_config_vector arcompact_device::memory_space_config() const { - return space_config_vector { + return space_config_vector{ std::make_pair(AS_PROGRAM, &m_program_config), std::make_pair(AS_IO, &m_io_config) }; @@ -94,21 +262,40 @@ void arcompact_device::device_start() m_program = &space(AS_PROGRAM); m_io = &space(AS_IO); - state_add( ARCOMPACT_PC, "PC", m_debugger_temp).callimport().callexport().formatstr("%08X"); + state_add(ARCOMPACT_PC, "PC", m_debugger_temp).callimport().callexport().formatstr("%08X"); - state_add( ARCOMPACT_STATUS32, "STATUS32", m_debugger_temp).callimport().callexport().formatstr("%08X"); - state_add( ARCOMPACT_LP_START, "LP_START", m_debugger_temp).callimport().callexport().formatstr("%08X"); - state_add( ARCOMPACT_LP_END, "LP_END", m_debugger_temp).callimport().callexport().formatstr("%08X"); + state_add(ARCOMPACT_STATUS32, "STATUS32", m_debugger_temp).callimport().callexport().formatstr("%08X"); + state_add(ARCOMPACT_LP_START, "LP_START", m_debugger_temp).callimport().callexport().formatstr("%08X"); + state_add(ARCOMPACT_LP_END, "LP_END", m_debugger_temp).callimport().callexport().formatstr("%08X"); state_add(STATE_GENPCBASE, "CURPC", m_debugger_temp).callimport().callexport().noshow(); for (int i = 0x100; i < 0x140; i++) { - state_add(i, arcompact_disassembler::regnames[i-0x100], m_debugger_temp).callimport().callexport().formatstr("%08X"); + state_add(i, arcompact_disassembler::regnames[i - 0x100], m_debugger_temp).callimport().callexport().formatstr("%08X"); } + m_irq_pending = false; set_icountptr(m_icount); + + save_item(NAME(m_pc)); + save_item(NAME(m_regs)); + save_item(NAME(m_delayactive)); + save_item(NAME(m_delaylinks)); + save_item(NAME(m_delayjump)); + save_item(NAME(m_allow_loop_check)); + save_item(NAME(m_irq_pending)); + save_item(NAME(m_status32)); + save_item(NAME(m_status32_l1)); + save_item(NAME(m_status32_l2)); + save_item(NAME(m_debug)); + save_item(NAME(m_timer)); + save_item(NAME(m_LP_START)); + save_item(NAME(m_LP_END)); + save_item(NAME(m_INTVECTORBASE)); + save_item(NAME(m_AUX_IRQ_LV12)); + save_item(NAME(m_AUX_IRQ_LEV)); } @@ -117,34 +304,33 @@ void arcompact_device::device_start() // to a known location where it can be read //------------------------------------------------- -void arcompact_device::state_export(const device_state_entry &entry) +void arcompact_device::state_export(const device_state_entry& entry) { int index = entry.index(); switch (index) { - case ARCOMPACT_PC: - case STATE_GENPCBASE: - m_debugger_temp = m_pc; - break; - - case ARCOMPACT_STATUS32: - m_debugger_temp = m_status32; - break; - case ARCOMPACT_LP_START: - m_debugger_temp = m_LP_START; - break; - case ARCOMPACT_LP_END: - m_debugger_temp = m_LP_END; - break; + case ARCOMPACT_PC: + case STATE_GENPCBASE: + m_debugger_temp = m_pc; + break; - default: - if ((index >= 0x100) && (index < 0x140)) - { - m_debugger_temp = m_regs[index - 0x100]; - } - break; + case ARCOMPACT_STATUS32: + m_debugger_temp = m_status32; + break; + case ARCOMPACT_LP_START: + m_debugger_temp = m_LP_START; + break; + case ARCOMPACT_LP_END: + m_debugger_temp = m_LP_END; + break; + default: + if ((index >= 0x100) && (index < 0x140)) + { + m_debugger_temp = m_regs[index - 0x100]; + } + break; } } @@ -154,57 +340,2610 @@ void arcompact_device::state_export(const device_state_entry &entry) // after it has been set //------------------------------------------------- -void arcompact_device::state_import(const device_state_entry &entry) +void arcompact_device::state_import(const device_state_entry& entry) { int index = entry.index(); switch (index) { - case ARCOMPACT_PC: - case STATE_GENPCBASE: - m_pc = (m_debugger_temp & 0xfffffffe); - break; - - case ARCOMPACT_STATUS32: - m_status32 = m_debugger_temp; - break; - case ARCOMPACT_LP_START: - m_LP_START = m_debugger_temp; - break; - case ARCOMPACT_LP_END: - m_LP_END = m_debugger_temp; - break; - - default: - if ((index >= 0x100) && (index < 0x140)) - { - m_regs[index - 0x100] = m_debugger_temp; - } - break; + case ARCOMPACT_PC: + case STATE_GENPCBASE: + m_pc = (m_debugger_temp & 0xfffffffe); + break; + + case ARCOMPACT_STATUS32: + m_status32 = m_debugger_temp; + break; + case ARCOMPACT_LP_START: + m_LP_START = m_debugger_temp; + break; + case ARCOMPACT_LP_END: + m_LP_END = m_debugger_temp; + break; + + default: + if ((index >= 0x100) && (index < 0x140)) + { + m_regs[index - 0x100] = m_debugger_temp; + } + break; } } void arcompact_device::device_reset() { - m_pc = 0x00000000; + m_pc = m_INTVECTORBASE = m_default_vector_base; - m_delayactive = 0; + m_delayactive = false; m_delayjump = 0x00000000; + m_irq_pending = false; - for (auto & elem : m_regs) + for (auto& elem : m_regs) elem = 0; m_status32 = 0; + m_status32_l1 = 0; + m_status32_l2 = 0; + m_debug = 0; + m_LP_START = 0; m_LP_END = 0; - m_INTVECTORBASE = 0; + m_AUX_IRQ_LV12 = 0; + m_AUX_IRQ_LEV = 0x000000c0; // only 2 interrupts are set to 'medium' priority (level 2) by default. + m_allow_loop_check = true; + + for (int t = 0; t < 2; t++) + for (int r = 0; r < 3; r++) + m_timer[t][r] = 0x00; } /*****************************************************************************/ - void arcompact_device::execute_set_input(int irqline, int state) { + if (state == ASSERT_LINE) + m_irq_pending = true; + else + m_irq_pending = false; +} + +/*****************************************************************************/ + +uint32_t arcompact_device::get_instruction(uint32_t op) +{ + uint8_t instruction = ((op & 0xf800) >> 11); + + if (instruction < 0x0c) + { + op <<= 16; + op |= READ16((m_pc + 2)); + + switch (instruction & 0x3f) // 32-bit instructions (with optional extra dword for immediate data) + { + default: return -1; + case 0x00: // Bcc + { + uint8_t subinstr = (op & 0x00010000) >> 16; + + switch (subinstr & 0x01) + { + default: return -1; + case 0x00: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// B<cc><.d> s21 0000 0sss ssss sss0 SSSS SSSS SSNQ QQQQ +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_B_cc_D_s21(op); // Branch Conditionally + } + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// B<.d> s25 0000 0sss ssss sss1 SSSS SSSS SSNR tttt +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_B_D_s25(op); // Branch Unconditionally Far + } + } + } + case 0x01: // BLcc/BRcc + { + uint8_t subinstr = (op & 0x00010000) >> 16; + switch (subinstr & 0x01) + { + default: return -1; + case 0x00: // Branch & Link + { + uint8_t subinstr2 = (op & 0x00020000) >> 17; + switch (subinstr2) + { + default: return -1; + case 0x00: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BL<.cc><.d> s21 0000 1sss ssss ss00 SSSS SSSS SSNQ QQQQ +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BL_cc_d_s21(op); // Branch and Link Conditionally + } + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BL<.d> s25 0000 1sss ssss ss10 SSSS SSSS SSNR tttt +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BL_d_s25(op); // Branch and Link Unconditional Far + } + } + } + case 0x01: // Branch on Compare + { + uint8_t subinstr2 = (op & 0x00000010) >> 4; + + switch (subinstr2) + { + default: return -1; + case 0x00: // Branch on Compare Register-Register + { + uint8_t subinstr3 = op & 0x0000000f; + switch (subinstr3) + { + case 0x00: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BREQ<.d> b,c,s9 0000 1bbb ssss sss1 SBBB CCCC CCN0 0000 +// BREQ b,limm,s9 0000 1bbb ssss sss1 SBBB 1111 1000 0000 (+ Limm) +// BREQ limm,c,s9 0000 1110 ssss sss1 S111 CCCC CC00 0000 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_reg(op, 0); // BREQ (reg-reg) + } + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRNE<.d> b,c,s9 0000 1bbb ssss sss1 SBBB CCCC CCN0 0001 +// BRNE b,limm,s9 0000 1bbb ssss sss1 SBBB 1111 1000 0001 (+ Limm) +// BRNE limm,c,s9 0000 1110 ssss sss1 S111 CCCC CC00 0001 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_reg(op, 1); // BRNE (reg-reg) + } + case 0x02: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRLT<.d> b,c,s9 0000 1bbb ssss sss1 SBBB CCCC CCN0 0010 +// BRLT b,limm,s9 0000 1bbb ssss sss1 SBBB 1111 1000 0010 (+ Limm) +// BRLT limm,c,s9 0000 1110 ssss sss1 S111 CCCC CC00 0010 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_reg(op, 2); // BRLT (reg-reg) + } + case 0x03: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRGE<.d> b,c,s9 0000 1bbb ssss sss1 SBBB CCCC CCN0 0011 +// BRGE b,limm,s9 0000 1bbb ssss sss1 SBBB 1111 1000 0011 (+ Limm) +// BRGE limm,c,s9 0000 1110 ssss sss1 S111 CCCC CC00 0011 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_reg(op, 3); // BRGE (reg-reg) + } + case 0x04: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRLO<.d> b,c,s9 0000 1bbb ssss sss1 SBBB CCCC CCN0 0100 +// BRLO b,limm,s9 0000 1bbb ssss sss1 SBBB 1111 1000 0100 (+ Limm) +// BRLO limm,c,s9 0000 1110 ssss sss1 S111 CCCC CC00 0100 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_reg(op, 4); // BRLO (reg-reg) + } + case 0x05: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRHS b,limm,s9 0000 1bbb ssss sss1 SBBB 1111 1000 0101 (+ Limm) +// BRHS limm,c,s9 0000 1110 ssss sss1 S111 CCCC CC00 0101 (+ Limm) +// BRHS<.d> b,c,s9 0000 1bbb ssss sss1 SBBB CCCC CCN0 0101 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_reg(op, 5); // BRHS (reg-reg) + } + case 0x0e: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BBIT0<.d> b,c,s9 0000 1bbb ssss sss1 SBBB CCCC CCN0 1110 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_reg(op, 6); // BBIT0 (reg-reg) + } + case 0x0f: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BBIT1<.d> b,c,s9 0000 1bbb ssss sss1 SBBB CCCC CCN0 1111 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_reg(op, 7); // BBIT1 (reg-reg) + } + default: + { + // 0x06 - 0x0d + return arcompact_handle_reserved(instruction, subinstr, subinstr2, subinstr3, op); // illegal + } + } + } + case 0x01: // Branch on Compare/Bit Test Register-Immediate + { + uint8_t subinstr3 = op & 0x0000000f; + switch (subinstr3) + { + case 0x00: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BREQ<.d> b,u6,s9 0000 1bbb ssss sss1 SBBB UUUU UUN1 0000 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_imm(op, 0); // BREQ (reg-imm) + } + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRNE<.d> b,u6,s9 0000 1bbb ssss sss1 SBBB UUUU UUN1 0001 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_imm(op, 1); // BRNE (reg-imm) + } + case 0x02: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRLT<.d> b,u6,s9 0000 1bbb ssss sss1 SBBB UUUU UUN1 0010 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_imm(op, 2); // BRLT (reg-imm) + } + case 0x03: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRGE<.d> b,u6,s9 0000 1bbb ssss sss1 SBBB UUUU UUN1 0011 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_imm(op, 3); // BRGE (reg-imm) + } + case 0x04: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRLO<.d> b,u6,s9 0000 1bbb ssss sss1 SBBB UUUU UUN1 0100 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_imm(op, 4); // BRLO (reg-imm) + } + case 0x05: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BRHS<.d> b,u6,s9 0000 1bbb ssss sss1 SBBB UUUU UUN1 0101 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_imm(op, 5); // BRHS (reg-imm) + } + case 0x0e: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BBIT0<.d> b,u6,s9 0000 1bbb ssss sss1 SBBB uuuu uuN1 1110 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_imm(op, 6); // BBIT0 (reg-imm) + } + case 0x0f: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BBIT1<.d> b,u6,s9 0000 1bbb ssss sss1 SBBB uuuu uuN1 1111 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRxx_reg_imm(op, 7); // BBIT1 (reg-imm) + } + default: + { + // 0x06 - 0x0d + return arcompact_handle_reserved(instruction, subinstr, subinstr2, subinstr3, op); // illegal + } + } + } + } + } + } + } + case 0x02: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I +// LD<zz><.x><.aa><.di> a,[b,s9] 0001 0bbb ssss ssss SBBB DaaZ ZXAA AAAA +// LD<zz><.x><.di> a,[limm] 0001 0110 0000 0000 0111 DRRZ ZXAA AAAA (+ Limm) +// LD<zz><.x><.aa><.di> 0,[b,s9] 0001 0bbb ssss ssss SBBB DaaZ ZX11 1110 +// LD<zz><.x><.di> 0,[limm] 0001 0110 0000 0000 0111 DRRZ ZX11 1110 (+ Limm) +// +// PREFETCH<.aa> [b,s9] 0001 0bbb ssss ssss SBBB 0aa0 0011 1110 +// PREFETCH [limm] 0001 0110 0000 0000 0111 0RR0 0011 1110 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_LD_r_o(op); // LD r+o + } + case 0x03: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I +// ST<zz><.aa><.di> c,[b,s9] 0001 1bbb ssss ssss SBBB CCCC CCDa aZZR +// ST<zz><.di> c,[limm] 0001 1110 0000 0000 0111 CCCC CCDR RZZR (+ Limm) +// ST<zz><.aa><.di> limm,[b,s9] 0001 1bbb ssss ssss SBBB 1111 10Da aZZR (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_ST_r_o(op); // ST r+o + } + case 0x04: // op a,b,c (basecase) + { + uint8_t subinstr = (op & 0x003f0000) >> 16; + + switch (subinstr & 0x3f) + { + case 0x00: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// ADD<.f> a,b,c 0010 0bbb 0000 0000 FBBB CCCC CCAA AAAA +// ADD<.f> a,b,u6 0010 0bbb 0100 0000 FBBB uuuu uuAA AAAA +// ADD<.f> b,b,s12 0010 0bbb 1000 0000 FBBB ssss ssSS SSSS +// ADD<.cc><.f> b,b,c 0010 0bbb 1100 0000 FBBB CCCC CC0Q QQQQ +// ADD<.cc><.f> b,b,u6 0010 0bbb 1100 0000 FBBB uuuu uu1Q QQQQ +// ADD<.f> a,limm,c 0010 0110 0000 0000 F111 CCCC CCAA AAAA (+ Limm) +// ADD<.f> a,b,limm 0010 0bbb 0000 0000 FBBB 1111 10AA AAAA (+ Limm) +// ADD<.cc><.f> b,b,limm 0010 0bbb 1100 0000 FBBB 1111 100Q QQQQ (+ Limm) +// +// ADD<.f> 0,b,c 0010 0bbb 0000 0000 FBBB CCCC CC11 1110 +// ADD<.f> 0,b,u6 0010 0bbb 0100 0000 FBBB uuuu uu11 1110 +// ADD<.f> 0,b,limm 0010 0bbb 0000 0000 FBBB 1111 1011 1110 (+ Limm) +// ADD<.cc><.f> 0,limm,c 0010 0110 1100 0000 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ADD_do_op); // ADD + } + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// ADC<.f> a,b,c 0010 0bbb 0000 0001 FBBB CCCC CCAA AAAA +// ADC<.f> a,b,u6 0010 0bbb 0100 0001 FBBB uuuu uuAA AAAA +// ADC<.f> b,b,s12 0010 0bbb 1000 0001 FBBB ssss ssSS SSSS +// ADC<.cc><.f> b,b,c 0010 0bbb 1100 0001 FBBB CCCC CC0Q QQQQ +// ADC<.cc><.f> b,b,u6 0010 0bbb 1100 0001 FBBB uuuu uu1Q QQQQ +// ADC<.f> a,limm,c 0010 0110 0000 0001 F111 CCCC CCAA AAAA (+ Limm) +// ADC<.f> a,b,limm 0010 0bbb 0000 0001 FBBB 1111 10AA AAAA (+ Limm) +// ADC<.cc><.f> b,b,limm 0010 0bbb 1100 0001 FBBB 1111 100Q QQQQ (+ Limm) +// +// ADC<.f> 0,b,c 0010 0bbb 0000 0001 FBBB CCCC CC11 1110 +// ADC<.f> 0,b,u6 0010 0bbb 0100 0001 FBBB uuuu uu11 1110 +// ADC<.f> 0,b,limm 0010 0bbb 0000 0001 FBBB 1111 1011 1110 (+ Limm) +// ADC<.cc><.f> 0,limm,c 0010 0110 1100 0001 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ADC_do_op); // ADC + } + case 0x02: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// SUB<.f> a,b,c 0010 0bbb 0000 0010 FBBB CCCC CCAA AAAA +// SUB<.f> a,b,u6 0010 0bbb 0100 0010 FBBB uuuu uuAA AAAA +// SUB<.f> b,b,s12 0010 0bbb 1000 0010 FBBB ssss ssSS SSSS +// SUB<.cc><.f> b,b, c 0010 0bbb 1100 0010 FBBB CCCC CC0Q QQQQ +// SUB<.cc><.f> b,b,u6 0010 0bbb 1100 0010 FBBB uuuu uu1Q QQQQ +// SUB<.f> a,limm,c 0010 0110 0000 0010 F111 CCCC CCAA AAAA (+ Limm) +// SUB<.f> a,b,limm 0010 0bbb 0000 0010 FBBB 1111 10AA AAAA (+ Limm) +// SUB<.cc><.f> b,b,limm 0010 0bbb 1100 0010 FBBB 1111 100Q QQQQ (+ Limm) +// +// SUB <.f> 0,b,c 0010 0bbb 0000 0010 FBBB CCCC CC11 1110 +// SUB <.f> 0,b,u6 0010 0bbb 0100 0010 FBBB uuuu uu11 1110 +// SUB <.f> 0,b,limm 0010 0bbb 0000 0010 FBBB 1111 1011 1110 (+ Limm) +// SUB <.cc><.f> 0,limm,c 0010 0110 1100 0010 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_SUB_do_op); // SUB + } + case 0x03: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// SBC<.f> a,b,c 0010 0bbb 0000 0011 FBBB CCCC CCAA AAAA +// SBC<.f> a,b,u6 0010 0bbb 0100 0011 FBBB uuuu uuAA AAAA +// SBC<.f> b,b,s12 0010 0bbb 1000 0011 FBBB ssss ssSS SSSS +// SBC<.cc><.f> b,b,c 0010 0bbb 1100 0011 FBBB CCCC CC0Q QQQQ +// SBC<.cc><.f> b,b,u6 0010 0bbb 1100 0011 FBBB uuuu uu1Q QQQQ +// SBC<.f> a,limm,c 0010 0110 0000 0011 F111 CCCC CCAA AAAA (+ Limm) +// SBC<.f> a,b,limm 0010 0bbb 0000 0011 FBBB 1111 10AA AAAA (+ Limm) +// SBC<.cc><.f> b,b,limm 0010 0bbb 1100 0011 FBBB 1111 100Q QQQQ (+ Limm) +// +// SBC<.f> 0,b,c 0010 0bbb 0000 0011 FBBB CCCC CC11 1110 +// SBC<.f> 0,b,u6 0010 0bbb 0100 0011 FBBB uuuu uu11 1110 +// SBC<.f> 0,b,limm 0010 0bbb 0000 0011 FBBB 1111 1011 1110 (+ Limm) +// SBC<.cc><.f> 0,limm,c 0010 0110 1100 0011 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_SBC_do_op); // SBC + } + case 0x04: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// AND<.f> a,b,c 0010 0bbb 0000 0100 FBBB CCCC CCAA AAAA +// AND<.f> a,b,u6 0010 0bbb 0100 0100 FBBB uuuu uuAA AAAA +// AND<.f> b,b,s12 0010 0bbb 1000 0100 FBBB ssss ssSS SSSS +// AND<.cc><.f> b,b,c 0010 0bbb 1100 0100 FBBB CCCC CC0Q QQQQ +// AND<.cc><.f> b,b,u6 0010 0bbb 1100 0100 FBBB uuuu uu1Q QQQQ +// AND<.f> a,limm,c 0010 0110 0000 0100 F111 CCCC CCAA AAAA (+ Limm) +// AND<.f> a,b,limm 0010 0bbb 0000 0100 FBBB 1111 10AA AAAA (+ Limm) +// AND<.cc><.f> b,b,limm 0010 0bbb 1100 0100 FBBB 1111 100Q QQQQ (+ Limm) +// +// AND<.f> 0,b,c 0010 0bbb 0000 0100 FBBB CCCC CC11 1110 +// AND<.f> 0,b,u6 0010 0bbb 0100 0100 FBBB uuuu uu11 1110 +// AND<.f> 0,b,limm 0010 0bbb 0000 0100 FBBB 1111 1011 1110 (+ Limm) +// AND<.cc><.f> 0,limm,c 0010 0110 1100 0100 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_AND_do_op); // AND + } + case 0x05: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// OR<.f> a,b,c 0010 0bbb 0000 0101 FBBB CCCC CCAA AAAA +// OR<.f> a,b,u6 0010 0bbb 0100 0101 FBBB uuuu uuAA AAAA +// OR<.f> b,b,s12 0010 0bbb 1000 0101 FBBB ssss ssSS SSSS +// OR<.cc><.f> b,b,c 0010 0bbb 1100 0101 FBBB CCCC CC0Q QQQQ +// OR<.cc><.f> b,b,u6 0010 0bbb 1100 0101 FBBB uuuu uu1Q QQQQ +// OR<.f> a,limm,c 0010 0110 0000 0101 F111 CCCC CCAA AAAA (+ Limm) +// OR<.f> a,b,limm 0010 0bbb 0000 0101 FBBB 1111 10AA AAAA (+ Limm) +// OR<.cc><.f> b,b,limm 0010 0bbb 1100 0101 FBBB 1111 100Q QQQQ (+ Limm) +// +// OR<.f> 0,b,c 0010 0bbb 0000 0101 FBBB CCCC CC11 1110 +// OR<.f> 0,b,u6 0010 0bbb 0100 0101 FBBB uuuu uu11 1110 +// OR<.f> 0,b,limm 0010 0bbb 0000 0101 FBBB 1111 1011 1110 (+ Limm) +// OR<.cc><.f> 0,limm,c 0010 0110 1100 010 1 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_OR_do_op); // OR + } + case 0x06: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// BIC<.f> a,b,c 0010 0bbb 0000 0110 FBBB CCCC CCAA AAAA +// BIC<.f> a,b,u6 0010 0bbb 0100 0110 FBBB uuuu uuAA AAAA +// BIC<.f> b,b,s12 0010 0bbb 1000 0110 FBBB ssss ssSS SSSS +// BIC<.cc><.f> b,b,c 0010 0bbb 1100 0110 FBBB CCCC CC0Q QQQQ +// BIC<.cc><.f> b,b,u6 0010 0bbb 1100 0110 FBBB uuuu uu1Q QQQQ +// BIC<.f> a,limm,c 0010 0110 0000 0110 F111 CCCC CCAA AAAA (+ Limm) +// BIC<.f> a,b,limm 0010 0bbb 0000 0110 FBBB 1111 10AA AAAA (+ Limm) +// BIC<.cc><.f> b,b,limm 0010 0bbb 1100 0110 FBBB 1111 100Q QQQQ (+ Limm) +// +// BIC<.f> 0,b,c 0010 0bbb 0000 0110 FBBB CCCC CC11 1110 +// BIC<.f> 0,b,u6 0010 0bbb 0100 0110 FBBB uuuu uu11 1110 +// BIC<.f> 0,b,limm 0010 0bbb 0000 0110 FBBB 1111 1011 1110 (+ Limm) +// BIC<.cc><.f> 0,limm,c 0010 0110 1100 0110 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_BIC_do_op); // BIC + } + case 0x07: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// XOR<.f> a,b,c 0010 0bbb 0000 0111 FBBB CCCC CCAA AAAA +// XOR<.f> a,b,u6 0010 0bbb 0100 0111 FBBB uuuu uuAA AAAA +// XOR<.f> b,b,s12 0010 0bbb 1000 0111 FBBB ssss ssSS SSSS +// XOR<.cc><.f> b,b,c 0010 0bbb 1100 0111 FBBB CCCC CC0Q QQQQ +// XOR<.cc><.f> b,b,u6 0010 0bbb 1100 0111 FBBB uuuu uu1Q QQQQ +// XOR<.f> a,limm,c 0010 0110 0000 0111 F111 CCCC CCAA AAAA (+ Limm) +// XOR<.f> a,b,limm 0010 0bbb 0000 0111 FBBB 1111 10AA AAAA (+ Limm) +// XOR<.cc><.f> b,b,limm 0010 0bbb 1100 0111 FBBB 1111 100Q QQQQ (+ Limm) +// +// XOR<.f> 0,b,c 0010 0bbb 0000 0111 FBBB CCCC CC11 1110 +// XOR<.f> 0,b,u6 0010 0bbb 0100 0111 FBBB uuuu uu11 1110 +// XOR<.f> 0,b,limm 0010 0bbb 0000 0111 FBBB 1111 1011 1110 (+ Limm) +// XOR<.cc><.f> 0,limm,c 0010 0110 1100 0111 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_XOR_do_op); // XOR + } + case 0x08: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// MAX<.f> a,b,c 0010 0bbb 0000 1000 FBBB CCCC CCAA AAAA +// MAX<.f> a,b,u6 0010 0bbb 0100 1000 FBBB uuuu uuAA AAAA +// MAX<.f> b,b,s12 0010 0bbb 1000 1000 FBBB ssss ssSS SSSS +// MAX<.cc><.f> b,b,c 0010 0bbb 1100 1000 FBBB CCCC CC0Q QQQQ +// MAX<.cc><.f> b,b,u6 0010 0bbb 1100 1000 FBBB uuuu uu1Q QQQQ +// MAX<.f> a,limm,c 0010 0110 0000 1000 F111 CCCC CCAA AAAA (+ Limm) +// MAX<.f> a,b,limm 0010 0bbb 0000 1000 FBBB 1111 10AA AAAA (+ Limm) +// MAX<.cc><.f> b,b,limm 0010 0bbb 1100 1000 FBBB 1111 100Q QQQQ (+ Limm) +// +// MAX<.f> 0,b,c 0010 0bbb 0000 1000 FBBB CCCC CC11 1110 +// MAX<.f> 0,b,u6 0010 0bbb 0100 1000 FBBB uuuu uu11 1110 +// MAX<.f> 0,b,limm 0010 0bbb 0000 1000 FBBB 1111 1011 1110 (+ Limm) +// MAX<.cc><.f> 0,limm,c 0010 0110 1100 1000 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_MAX_do_op); // MAX + } + case 0x09: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// MIN<.f> a,b,c 0010 0bbb 0000 1001 FBBB CCCC CCAA AAAA +// MIN<.f> a,b,u6 0010 0bbb 0100 1001 FBBB uuuu uuAA AAAA +// MIN<.f> b,b,s12 0010 0bbb 1000 1001 FBBB ssss ssSS SSSS +// MIN<.cc><.f> b,b,c 0010 0bbb 1100 1001 FBBB CCCC CC0Q QQQQ +// MIN<.cc><.f> b,b,u6 0010 0bbb 1100 1001 FBBB uuuu uu1Q QQQQ +// MIN<.f> a,limm,c 0010 0110 0000 1001 F111 CCCC CCAA AAAA (+ Limm) +// MIN<.f> a,b,limm 0010 0bbb 0000 1001 FBBB 1111 10AA AAAA (+ Limm) +// MIN<.cc><.f> b,b,limm 0010 0bbb 1100 1001 FBBB 1111 100Q QQQQ (+ Limm) +// +// MIN<.f> 0,b,c 0010 0bbb 0000 1001 FBBB CCCC CC11 1110 +// MIN<.f> 0,b,u6 0010 0bbb 0100 1001 FBBB uuuu uu11 1110 +// MIN<.f> 0,b,limm 0010 0bbb 0000 1001 FBBB 1111 1011 1110 (+ Limm) +// MIN<.cc><.f> 0,limm,c 0010 0110 1100 1001 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_MIN_do_op); // MIN + } + case 0x0a: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// MOV<.f> b,s12 0010 0bbb 1000 1010 FBBB ssss ssSS SSSS +// MOV<.cc><.f> b,c 0010 0bbb 1100 1010 FBBB CCCC CC0Q QQQQ +// MOV<.cc><.f> b,u6 0010 0bbb 1100 1010 FBBB uuuu uu1Q QQQQ +// MOV<.cc><.f> b,limm 0010 0bbb 1100 1010 FBBB 1111 100Q QQQQ (+ Limm) +// +// MOV<.f> 0,s12 0010 0110 1000 1010 F111 ssss ssSS SSSS +// MOV<.cc><.f> 0,c 0010 0110 1100 1010 F111 CCCC CC0Q QQQQ +// MOV<.cc><.f> 0,u6 0010 0110 1100 1010 F111 uuuu uu1Q QQQQ +// MOV<.cc><.f> 0,limm 0010 0110 1100 1010 F111 1111 100Q QQQQ (+ Limm) +// +// NOP 0010 0110 0100 1010 0111 0000 0000 0000 (NOP is a custom encoded MOV?) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_MOV(op); // MOV + } + case 0x0b: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// TST b,s12 0010 0bbb 1000 1011 1BBB ssss ssSS SSSS +// TST<.cc> b,c 0010 0bbb 1100 1011 1BBB CCCC CC0Q QQQQ +// TST<.cc> b,u6 0010 0bbb 1100 1011 1BBB uuuu uu1Q QQQQ +// TST<.cc> b,limm 0010 0bbb 1100 1011 1BBB 1111 100Q QQQQ (+ Limm) +// TST<.cc> limm,c 0010 0110 1100 1011 1111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_nowriteback_forced_flag(op, handleop32_TST_do_op); // TST + } + case 0x0c: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// CMP b,s12 0010 0bbb 1000 1100 1BBB ssss ssSS SSSS +// CMP<.cc> b,c 0010 0bbb 1100 1100 1BBB CCCC CC0Q QQQQ +// CMP<.cc> b,u6 0010 0bbb 1100 1100 1BBB uuuu uu1Q QQQQ +// CMP<.cc> b,limm 0010 0bbb 1100 1100 1BBB 1111 100Q QQQQ (+ Limm) +// CMP<.cc> limm,c 0010 0110 1100 1100 1111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_nowriteback_forced_flag(op, handleop32_CMP_do_op); // CMP + } + case 0x0d: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// RCMP b,s12 0010 0bbb 1000 1101 1BBB ssss ssSS SSSS +// RCMP<.cc> b,c 0010 0bbb 1100 1101 1BBB CCCC CC0Q QQQQ +// RCMP<.cc> b,u6 0010 0bbb 1100 1101 1BBB uuuu uu1Q QQQQ +// RCMP<.cc> b,limm 0010 0bbb 1100 1101 1BBB 1111 100Q QQQQ (+ Limm) +// RCMP<.cc> limm,c 0010 0110 1100 1101 1111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_nowriteback_forced_flag(op, handleop32_RCMP_do_op); // RCMP + } + case 0x0e: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// RSUB<.f> a,b,c 0010 0bbb 0000 1110 FBBB CCCC CCAA AAAA +// RSUB<.f> a,b,u6 0010 0bbb 0100 1110 FBBB uuuu uuAA AAAA +// NEG<.f> a,b 0010 0bbb 0100 1110 FBBB 0000 00AA AAAA (NEG is an alias) +// +// RSUB<.f> b,b,s12 0010 0bbb 1000 1110 FBBB ssss ssSS SSSS +// RSUB<.cc><.f> b,b,c 0010 0bbb 1100 1110 FBBB CCCC CC0Q QQQQ +// RSUB<.cc><.f> b,b,u6 0010 0bbb 1100 1110 FBBB uuuu uu1Q QQQQ +// NEG<.cc><.f> b,b 0010 0bbb 1100 1110 FBBB 0000 001Q QQQQ (NEG is an alias) +// +// RSUB<.f> a,limm,c 0010 0110 0000 1110 F111 CCCC CCAA AAAA (+ Limm) +// RSUB<.f> a,b,limm 0010 0bbb 0000 1110 FBBB 1111 10AA AAAA (+ Limm) +// RSUB<.cc><.f> b,b,limm 0010 0bbb 1100 1110 FBBB 1111 100Q QQQQ (+ Limm) +// +// RSUB<.f> 0,b,c 0010 0bbb 0000 1110 FBBB CCCC CC11 1110 +// RSUB<.f> 0,b,u6 0010 0bbb 0100 1110 FBBB uuuu uu11 1110 +// RSUB<.f> 0,b,limm 0010 0bbb 0000 1110 FBBB 1111 1011 1110 (+ Limm) +// RSUB<.cc><.f> 0,limm,c 0010 0110 1100 1110 F111 CCCC CC0Q QQQQ (+ Limm) +// +// IIII I SS SSSS +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_RSUB_do_op); // RSUB + } + case 0x0f: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BSET<.f> a,b,c 0010 0bbb 0000 1111 FBBB CCCC CCAA AAAA +// BSET<.f> a,b,u6 0010 0bbb 0100 1111 FBBB uuuu uuAA AAAA +// BSET<.cc><.f> b,b,c 0010 0bbb 1100 1111 FBBB CCCC CC0Q QQQQ +// BSET<.cc><.f> b,b,u6 0010 0bbb 1100 1111 FBBB uuuu uu1Q QQQQ +// BSET<.f> a,limm,c 0010 0110 0000 1111 F111 CCCC CCAA AAAA (+ Limm) +// +// BSET<.f> 0,b,c 0010 0bbb 0000 1111 FBBB CCCC CC11 1110 +// BSET<.f> 0,b,u6 0010 0bbb 0100 1111 FBBB uuuu uu11 1110 +// BSET<.cc><.f> 0,limm,c 0010 0110 1100 1111 F110 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_BSET_do_op); // BSET + } + case 0x10: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BCLR<.f> a,b,c 0010 0bbb 0001 0000 FBBB CCCC CCAA AAAA +// BCLR<.f> a,b,u6 0010 0bbb 0101 0000 FBBB uuuu uuAA AAAA +// BCLR<.cc><.f> b,b,c 0010 0bbb 1101 0000 FBBB CCCC CC0Q QQQQ +// BCLR<.cc><.f> b,b,u6 0010 0bbb 1101 0000 FBBB uuuu uu1Q QQQQ +// BCLR<.f> a,limm,c 0010 0110 0001 0000 F111 CCCC CCAA AAAA (+ Limm) +// +// BCLR<.f> 0,b,c 0010 0bbb 0001 0000 FBBB CCCC CC11 1110 +// BCLR<.f> 0,b,u6 0010 0bbb 0101 0000 FBBB uuuu uu11 1110 +// BCLR<.cc><.f> 0,limm,c 0010 0110 1101 0000 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_BCLR_do_op); // BCLR + } + case 0x11: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BTST<.cc> b,c 0010 0bbb 1101 0001 1BBB CCCC CC0Q QQQQ +// BTST<.cc> b,u6 0010 0bbb 1101 0001 1BBB uuuu uu1Q QQQQ +// BTST<.cc> limm,c 0010 0110 1101 0001 1111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_nowriteback_forced_flag(op, handleop32_BTST_do_op); // BTST + } + case 0x12: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BXOR<.f> a,b,c 0010 0bbb 0001 0010 FBBB CCCC CCAA AAAA +// BXOR<.f> a,b,u6 0010 0bbb 0101 0010 FBBB uuuu uuAA AAAA +// BXOR<.cc><.f> b,b,c 0010 0bbb 1101 0010 FBBB CCCC CC0Q QQQQ +// BXOR<.cc><.f> b,b,u6 0010 0bbb 1101 0010 FBBB uuuu uu1Q QQQQ +// BXOR<.f> a,limm,c 0010 0110 0001 0010 F111 CCCC CCAA AAAA (+ Limm) +// +// BXOR<.f> 0,b,c 0010 0bbb 0001 0010 FBBB CCCC CC11 1110 +// BXOR<.f> 0,b,u6 0010 0bbb 0101 0010 FBBB uuuu uu11 1110 +// BXOR<.cc><.f> 0,limm,c 0010 0110 1101 0010 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_BXOR_do_op); // BXOR + } + case 0x13: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// BMSK<.f> a,b,c 0010 0bbb 0001 0011 FBBB CCCC CCAA AAAA +// BMSK<.f> a,b,u6 0010 0bbb 0101 0011 FBBB uuuu uuAA AAAA +// BMSK<.cc><.f> b,b,c 0010 0bbb 1101 0011 FBBB CCCC CC0Q QQQQ +// BMSK<.cc><.f> b,b,u6 0010 0bbb 1101 0011 FBBB uuuu uu1Q QQQQ +// BMSK<.f> a,limm,c 0010 0110 0001 0011 F111 CCCC CCAA AAAA (+ Limm) +// +// BMSK<.f> 0,b,c 0010 0bbb 0001 0011 FBBB CCCC CC11 1110 +// BMSK<.f> 0,b,u6 0010 0bbb 0101 0011 FBBB uuuu uu11 1110 +// BMSK<.cc><.f> 0,limm,c 0010 0110 1101 0011 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_BMSK_do_op); // BMSK + } + case 0x14: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// ADD1<.f> a,b,c 0010 0bbb 0001 0100 FBBB CCCC CCAA AAAA +// ADD1<.f> a,b,u6 0010 0bbb 0101 0100 FBBB uuuu uuAA AAAA +// ADD1<.f> b,b,s12 0010 0bbb 1001 0100 FBBB ssss ssSS SSSS +// ADD1<.cc><.f> b,b,c 0010 0bbb 1101 0100 FBBB CCCC CC0Q QQQQ +// ADD1<.cc><.f> b,b,u6 0010 0bbb 1101 0100 FBBB uuuu uu1Q QQQQ +// ADD1<.f> a,limm,c 0010 0110 0001 0100 F111 CCCC CCAA AAAA (+ Limm) +// ADD1<.f> a,b,limm 0010 0bbb 0001 0100 FBBB 1111 10AA AAAA (+ Limm) +// ADD1<.cc><.f> b,b,limm 0010 0bbb 1101 0100 FBBB 1111 100Q QQQQ (+ Limm) +// +// ADD1<.f> 0,b,c 0010 0bbb 0001 0100 FBBB CCCC CC11 1110 +// ADD1<.f> 0,b,u6 0010 0bbb 0101 0100 FBBB uuuu uu11 1110 +// ADD1<.f> 0,b,limm 0010 0bbb 0001 0100 FBBB 1111 1011 1110 (+ Limm) +// ADD1<.cc><.f> 0,limm,c 0010 0110 1101 0100 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ADD1_do_op); // ADD1 + } + case 0x15: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// ADD2<.f> a,b,c 0010 0bbb 0001 0101 FBBB CCCC CCAA AAAA +// ADD2<.f> a,b,u6 0010 0bbb 0101 0101 FBBB uuuu uuAA AAAA +// ADD2<.f> b,b,s12 0010 0bbb 1001 0101 FBBB ssss ssSS SSSS +// ADD2<.cc><.f> b,b,c 0010 0bbb 1101 0101 FBBB CCCC CC0Q QQQQ +// ADD2<.cc><.f> b,b,u6 0010 0bbb 1101 0101 FBBB uuuu uu1Q QQQQ +// ADD2<.f> a,limm,c 0010 0110 0001 0101 F111 CCCC CCAA AAAA (+ Limm) +// ADD2<.f> a,b,limm 0010 0bbb 0001 0101 FBBB 1111 10AA AAAA (+ Limm) +// ADD2<.cc><.f> b,b,limm 0010 0bbb 1101 0101 FBBB 1111 100Q QQQQ (+ Limm) +// +// ADD2<.f> 0,b,c 0010 0bbb 0001 0101 FBBB CCCC CC11 1110 +// ADD2<.f> 0,b,u6 0010 0bbb 0101 0101 FBBB uuuu uu11 1110 +// ADD2<.f> 0,b,limm 0010 0bbb 0001 0101 FBBB 1111 1011 1110 (+ Limm) +// ADD2<.cc><.f> 0,limm,c 0010 0110 1101 0101 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ADD2_do_op); // ADD2 + } + case 0x16: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// ADD3<.f> a,b,c 0010 0bbb 0001 0110 FBBB CCCC CCAA AAAA +// ADD3<.f> a,b,u6 0010 0bbb 0101 0110 FBBB uuuu uuAA AAAA +// ADD3<.f> b,b,s12 0010 0bbb 1001 0110 FBBB ssss ssSS SSSS +// ADD3<.cc><.f> b,b,c 0010 0bbb 1101 0110 FBBB CCCC CC0Q QQQQ +// ADD3<.cc><.f> b,b,u6 0010 0bbb 1101 0110 FBBB uuuu uu1Q QQQQ +// ADD3<.f> a,limm,c 0010 0110 0001 0110 F111 CCCC CCAA AAAA (+ Limm) +// ADD3<.f> a,b,limm 0010 0bbb 0001 0110 FBBB 1111 10AA AAAA (+ Limm) +// ADD3<.cc><.f> b,b,limm 0010 0bbb 1101 0110 FBBB 1111 100Q QQQQ (+ Limm) +// +// ADD3<.f> 0,b,c 0010 0bbb 0001 0110 FBBB CCCC CC11 1110 +// ADD3<.f> 0,b,u6 0010 0bbb 0101 0110 FBBB uuuu uu11 1110 +// ADD3<.f> 0,b,limm 0010 0bbb 0001 0110 FBBB 1111 1011 1110 (+ Limm) +// ADD3<.cc><.f> 0,limm,c 0010 0110 1101 0110 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ADD3_do_op); // ADD3 + } + case 0x17: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// SUB1<.f> a,b,c 0010 0bbb 0001 0111 FBBB CCCC CCAA AAAA +// SUB1<.f> a,b,u6 0010 0bbb 0101 0111 FBBB uuuu uuAA AAAA +// SUB1<.f> b,b,s12 0010 0bbb 1001 0111 FBBB ssss ssSS SSSS +// SUB1<.cc><.f> b,b,c 0010 0bbb 1101 0111 FBBB CCCC CC0Q QQQQ +// SUB1<.cc><.f> b,b,u6 0010 0bbb 1101 0111 FBBB uuuu uu1Q QQQQ +// SUB1<.f> a,limm,c 0010 0110 0001 0111 F111 CCCC CCAA AAAA (+ Limm) +// SUB1<.f> a,b,limm 0010 0bbb 0001 0111 FBBB 1111 10AA AAAA (+ Limm) +// SUB1<.cc><.f> b,b,limm 0010 0bbb 1101 0111 FBBB 1111 100Q QQQQ (+ Limm) +// +// SUB1<.f> 0,b,c 0010 0bbb 0001 0111 FBBB CCCC CC11 1110 +// SUB1<.f> 0,b,u6 0010 0bbb 0101 0111 FBBB uuuu uu11 1110 +// SUB1<.f> 0,b,limm 0010 0bbb 0001 0111 FBBB 1111 1011 1110 (+ Limm) +// SUB1<.cc><.f> 0,limm,c 0010 0110 1101 0111 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_SUB1_do_op); // SUB1 + } + case 0x18: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// SUB2<.f> a,b,c 0010 0bbb 0001 1000 FBBB CCCC CCAA AAAA +// SUB2<.f> a,b,u6 0010 0bbb 0101 1000 FBBB uuuu uuAA AAAA +// SUB2<.f> b,b,s12 0010 0bbb 1001 1000 FBBB ssss ssSS SSSS +// SUB2<.cc><.f> b,b,c 0010 0bbb 1101 1000 FBBB CCCC CC0Q QQQQ +// SUB2<.cc><.f> b,b,u6 0010 0bbb 1101 1000 FBBB uuuu uu1Q QQQQ +// SUB2<.f> a,limm,c 0010 0110 0001 1000 F111 CCCC CCAA AAAA (+ Limm) +// SUB2<.f> a,b,limm 0010 0bbb 0001 1000 FBBB 1111 10AA AAAA (+ Limm) +// SUB2<.cc><.f> b,b,limm 0010 0bbb 1101 1000 FBBB 1111 100Q QQQQ (+ Limm) +// +// SUB2<.f> 0,b,c 0010 0bbb 0001 1000 FBBB CCCC CC11 1110 +// SUB2<.f> 0,b,u6 0010 0bbb 0101 1000 FBBB uuuu uu11 1110 +// SUB2<.f> 0,b,limm 0010 0bbb 0001 1000 FBBB 1111 1011 1110 (+ Limm) +// SUB2<.cc><.f> 0,limm,c 0010 0110 1101 1000 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_SUB2_do_op); // SUB2 + } + case 0x19: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// SUB3<.f> a,b,c 0010 0bbb 0001 1001 FBBB CCCC CCAA AAAA +// SUB3<.f> a,b,u6 0010 0bbb 0101 1001 FBBB uuuu uuAA AAAA +// SUB3<.f> b,b,s12 0010 0bbb 1001 1001 FBBB ssss ssSS SSSS +// SUB3<.cc><.f> b,b,c 0010 0bbb 1101 1001 FBBB CCCC CC0Q QQQQ +// SUB3<.cc><.f> b,b,u6 0010 0bbb 1101 1001 FBBB uuuu uu1Q QQQQ +// SUB3<.f> a,limm,c 0010 0110 0001 1001 F111 CCCC CCAA AAAA (+ Limm) +// SUB3<.f> a,b,limm 0010 0bbb 0001 1001 FBBB 1111 10AA AAAA (+ Limm) +// SUB3<.cc><.f> b,b,limm 0010 0bbb 1101 1001 FBBB 1111 100Q QQQQ (+ Limm) +// +// SUB3<.f> 0,b,c 0010 0bbb 0001 1001 FBBB CCCC CC11 1110 +// SUB3<.f> 0,b,u6 0010 0bbb 0101 1001 FBBB uuuu uu11 1110 +// SUB3<.f> 0,limm,c 0010 0110 0001 1001 F111 CCCC CC11 1110 (+ Limm) +// SUB3<.cc><.f> 0,limm,c 0010 0110 1101 1001 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_SUB3_do_op); // SUB3 + } + case 0x1a: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// MPY<.f> a,b,c 0010 0bbb 0001 1010 FBBB CCCC CCAA AAAA +// MPY<.f> a,b,u6 0010 0bbb 0101 1010 FBBB uuuu uuAA AAAA +// MPY<.f> b,b,s12 0010 0bbb 1001 1010 FBBB ssss ssSS SSSS +// MPY<.cc><.f> b,b,c 0010 0bbb 1101 1010 FBBB CCCC CC0Q QQQQ +// MPY<.cc><.f> b,b,u6 0010 0bbb 1101 1010 FBBB uuuu uu1Q QQQQ +// MPY<.f> a,limm,c 0010 0110 0001 1010 F111 CCCC CCAA AAAA (+ Limm) +// MPY<.f> a,b,limm 0010 0bbb 0001 1010 FBBB 1111 10AA AAAA (+ Limm) +// MPY<.cc><.f> b,b,limm 0010 0bbb 1101 1010 FBBB 1111 100Q QQQQ (+ Limm) +// +// MPY<.f> 0,b,c 0010 0bbb 0001 1010 FBBB CCCC CC11 1110 +// MPY<.f> 0,b,u6 0010 0bbb 0101 1010 FBBB uuuu uu11 1110 +// MPY<.cc><.f> 0,limm,c 0010 0110 1101 1010 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_MPY_do_op); // MPY * + } + case 0x1b: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// MPYH<.f> a,b,c 0010 0bbb 0001 1011 FBBB CCCC CCAA AAAA +// MPYH<.f> a,b,u6 0010 0bbb 0101 1011 FBBB uuuu uuAA AAAA +// MPYH<.f> b,b,s12 0010 0bbb 1001 1011 FBBB ssss ssSS SSSS +// MPYH<.cc><.f> b,b,c 0010 0bbb 1101 1011 FBBB CCCC CC0Q QQQQ +// MPYH<.cc><.f> b,b,u6 0010 0bbb 1101 1011 FBBB uuuu uu1Q QQQQ +// MPYH<.f> a,limm,c 0010 0110 0001 1011 F111 CCCC CCAA AAAA (+ Limm) +// MPYH<.f> a,b,limm 0010 0bbb 0001 1010 FBBB 1111 10AA AAAA (+ Limm) +// MPYH<.cc><.f> b,b,limm 0010 0bbb 1101 1011 FBBB 1111 100Q QQQQ (+ Limm) +// +// MPYH<.f> 0,b,c 0010 0bbb 0001 1011 FBBB CCCC CC11 1110 +// MPYH<.f> 0,b,u6 0010 0bbb 0101 1011 FBBB uuuu uu11 1110 +// MPYH<.cc><.f> 0,limm,c 0010 0110 1101 1011 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_MPYH_do_op); // MPYH * + } + case 0x1c: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// MPYHU<.f> a,b,c 0010 0bbb 0001 1100 FBBB CCCC CCAA AAAA +// MPYHU<.f> a,b,u6 0010 0bbb 0101 1100 FBBB uuuu uuAA AAAA +// MPYHU<.f> b,b,s12 0010 0bbb 1001 1100 FBBB ssss ssSS SSSS +// MPYHU<.cc><.f> b,b,c 0010 0bbb 1101 1100 FBBB CCCC CC0Q QQQQ +// MPYHU<.cc><.f> b,b,u6 0010 0bbb 1101 1100 FBBB uuuu uu1Q QQQQ +// MPYHU<.f> a,limm,c 0010 0110 0001 1100 F111 CCCC CCAA AAAA (+ Limm) +// MPYHU<.f> a,b,limm 0010 0bbb 0001 1100 FBBB 1111 10AA AAAA (+ Limm) +// MPYHU<.cc><.f> b,b,limm 0010 0bbb 1101 1100 FBBB 1111 100Q QQQQ (+ Limm) +// +// MPYHU<.f> 0,b,c 0010 0bbb 0001 1100 FBBB CCCC CC11 1110 +// MPYHU<.f> 0,b,u6 0010 0bbb 0101 1100 FBBB uuuu uu11 1110 +// MPYHU<.cc><.f> 0,limm,c 0010 0110 1101 1100 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_MPYHU_do_op); // MPYHU * + } + case 0x1d: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// MPYU<.f> a,b,c 0010 0bbb 0001 1101 FBBB CCCC CCAA AAAA +// MPYU<.f> a,b,u6 0010 0bbb 0101 1101 FBBB uuuu uuAA AAAA +// MPYU<.f> b,b,s12 0010 0bbb 1001 1101 FBBB ssss ssSS SSSS +// MPYU<.cc><.f> b,b,c 0010 0bbb 1101 1101 FBBB CCCC CC0Q QQQQ +// MPYU<.cc><.f> b,b,u6 0010 0bbb 1101 1101 FBBB uuuu uu1Q QQQQ +// MPYU<.f> a,limm,c 0010 0110 0001 1101 F111 CCCC CCAA AAAA (+ Limm) +// MPYU<.f> a,b,limm 0010 0bbb 0001 1101 FBBB 1111 10AA AAAA (+ Limm) +// MPYU<.cc><.f> b,b,limm 0010 0bbb 1101 1101 FBBB 1111 100Q QQQQ (+ Limm) +// +// MPYU<.f> 0,b,c 0010 0bbb 0001 1101 FBBB CCCC CC11 1110 +// MPYU<.f> 0,b,u6 0010 0bbb 0101 1101 FBBB uuuu uu11 1110 +// MPYU<.cc><.f> 0,limm,c 0010 0110 1101 1101 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_MPYU_do_op); // MPYU * + } + case 0x20: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// Jcc [c] 0010 0RRR 1110 0000 0RRR CCCC CC0Q QQQQ +// Jcc limm 0010 0RRR 1110 0000 0RRR 1111 100Q QQQQ (+ Limm) +// Jcc u6 0010 0RRR 1110 0000 0RRR uuuu uu1Q QQQQ +// Jcc.F [ilink1] 0010 0RRR 1110 0000 1RRR 0111 010Q QQQQ +// Jcc.F [ilink2] 0010 0RRR 1110 0000 1RRR 0111 100Q QQQQ +// IIII I SS SSSS +// J [c] 0010 0RRR 0010 0000 0RRR CCCC CCRR RRRR +// J.F [ilink1] 0010 0RRR 0010 0000 1RRR 0111 01RR RRRR +// J.F [ilink2] 0010 0RRR 0010 0000 1RRR 0111 10RR RRRR +// J limm 0010 0RRR 0010 0000 0RRR 1111 10RR RRRR (+ Limm) +// J u6 0010 0RRR 0110 0000 0RRR uuuu uuRR RRRR +// J s12 0010 0RRR 1010 0000 0RRR ssss ssSS SSSS +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_J(op, false, false); // Jcc + } + case 0x21: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// Jcc.D u6 0010 0RRR 1110 0001 0RRR uuuu uu1Q QQQQ +// Jcc.D [c] 0010 0RRR 1110 0001 0RRR CCCC CC0Q QQQQ +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// J.D [c] 0010 0RRR 0010 0001 0RRR CCCC CCRR RRRR +// J.D u6 0010 0RRR 0110 0001 0RRR uuuu uuRR RRRR +// J.D s12 0010 0RRR 1010 0001 0RRR ssss ssSS SSSS +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + return handleop32_J(op, true, false); // Jcc.D + } + case 0x22: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// JLcc [c] 0010 0RRR 1110 0010 0RRR CCCC CC0Q QQQQ +// JLcc limm 0010 0RRR 1110 0010 0RRR 1111 100Q QQQQ (+ Limm) +// JLcc u6 0010 0RRR 1110 0010 0RRR uuuu uu1Q QQQQ +// JL [c] 0010 0RRR 0010 0010 0RRR CCCC CCRR RRRR +// JL limm 0010 0RRR 0010 0010 0RRR 1111 10RR RRRR (+ Limm) +// JL u6 0010 0RRR 0110 0010 0RRR uuuu uuRR RRRR +// JL s12 0010 0RRR 1010 0010 0RRR ssss ssSS SSSS +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_J(op, false, true); // JLcc + } + case 0x23: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// JLcc.D u6 0010 0RRR 1110 0011 0RRR uuuu uu1Q QQQQ +// JLcc.D [c] 0010 0RRR 1110 0011 0RRR CCCC CC0Q QQQQ +// JL.D [c] 0010 0RRR 0010 0011 0RRR CCCC CCRR RRRR +// JL.D u6 0010 0RRR 0110 0011 0RRR uuuu uuRR RRRR +// JL.D s12 0010 0RRR 1010 0011 0RRR ssss ssSS SSSS +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_J(op, true, true); // JLcc.D + } + case 0x28: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// LP<cc> u7 0010 0RRR 1110 1000 0RRR uuuu uu1Q QQQQ +// LP s13 0010 0RRR 1010 1000 0RRR ssss ssSS SSSS +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_LP(op); // LPcc + } + case 0x29: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// FLAG<.cc> c 0010 0rrr 1110 1001 0RRR CCCC CC0Q QQQQ +// FLAG<.cc> u6 0010 0rrr 1110 1001 0RRR uuuu uu1Q QQQQ +// FLAG<.cc> limm 0010 0rrr 1110 1001 0RRR 1111 100Q QQQQ (+ Limm) +// FLAG s12 0010 0rrr 1010 1001 0RRR ssss ssSS SSSS +// FLAG c (unknown format) 0010 0000 0010 1001 0000 0000 0100 0000 (Leapster BIOS encodes like this? unless it's customized and isn't FLAG?) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_FLAG(op); // FLAG + } + case 0x2a: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// LR b,[c] 0010 0bbb 0010 1010 0BBB CCCC CCRR RRRR +// LR b,[limm] 0010 0bbb 0010 1010 0BBB 1111 10RR RRRR (+ Limm) +// LR b,[u6] 0010 0bbb 0110 1010 0BBB uuuu uu00 0000 +// LR b,[s12] 0010 0bbb 1010 1010 0BBB ssss ssSS SSSS +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_LR(op); // LR + } + case 0x2b: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// SR b,[c] 0010 0bbb 0010 1011 0BBB CCCC CCRR RRRR +// SR b,[limm] 0010 0bbb 0010 1011 0BBB 1111 10RR RRRR (+ Limm) +// SR b,[u6] 0010 0bbb 0110 1011 0BBB uuuu uu00 0000 +// SR b,[s12] 0010 0bbb 1010 1011 0BBB ssss ssSS SSSS +// SR limm,[c] 0010 0110 0010 1011 0111 CCCC CCRR RRRR (+ Limm) +// SR limm,[u6] 0010 0110 0110 1011 0111 uuuu uu00 0000 +// SR limm,[s12] 0010 0110 1010 1011 0111 ssss ssSS SSSS (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_SR(op); // SR + } + case 0x2f: // Sub Opcode + { + uint8_t subinstr2 = op & 0x0000003f; + switch (subinstr2 & 0x3f) + { + case 0x00: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// ASL<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 0000 +// ASL<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 0000 +// ASL<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 0000 (+ Limm) +// +// ASL<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 0000 +// ASL<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 0000 +// ASL<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 0000 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_ASL_single_do_op); // ASL + } + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// ASR<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 0001 +// ASR<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 0001 +// ASR<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 0001 (+ Limm) +// +// ASR<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 0001 +// ASR<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 0001 +// ASR<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 0001 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_ASR_single_do_op); // ASR + } + case 0x02: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// LSR<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 0010 +// LSR<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 0010 +// LSR<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 0010 (+ Limm) +// +// LSR<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 0010 +// LSR<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 0010 +// LSR<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 0010 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_LSR_single_do_op); // LSR + } + case 0x03: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// ROR<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 0011 +// ROR<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 0011 +// ROR<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 0011 (+ Limm) +// +// ROR<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 0011 +// ROR<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 0011 +// ROR<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 0011 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_ROR_do_op); // ROR + } + case 0x04: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// RRC<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 0100 +// RRC<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 0100 +// RRC<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 0100 (+ Limm) +// +// RRC<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 0100 +// RRC<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 0100 +// RRC<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 0100 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_RRC_do_op); // RRC + } + case 0x05: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// SEXB<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 0101 +// SEXB<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 0101 +// SEXB<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 0101 (+ Limm) +// +// SEXB<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 0101 +// SEXB<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 0101 +// SEXB<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 0101 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_SEXB_do_op); // SEXB + } + case 0x06: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// SEXW<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 0110 +// SEXW<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 0110 +// SEXW<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 0110 (+ Limm) +// +// SEXW<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 0110 +// SEXW<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 0110 +// SEXW<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 0110 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_SEXW_do_op); // SEXW + } + case 0x07: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// EXTB<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 0111 +// EXTB<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 0111 +// EXTB<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 0111 (+ Limm) +// +// EXTB<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 0111 +// EXTB<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 0111 +// EXTB<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 0111 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_EXTB_do_op); // EXTB + } + case 0x08: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// EXTW<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 1000 +// EXTW<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 1000 +// EXTW<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 1000 (+ Limm) +// +// EXTW<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 1000 +// EXTW<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 1000 +// EXTW<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 1000 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_EXTW_do_op); // EXTW + } + case 0x09: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// ABS<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 1001 +// ABS<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 1001 +// ABS<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 1001 (+ Limm) +// +// ABS<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 1001 +// ABS<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 1001 +// ABS<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 1001 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_ABS_do_op); // ABS + } + case 0x0a: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// NOT<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 1010 +// NOT<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 1010 +// NOT<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 1010 (+ Limm) +// +// NOT<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 1010 +// NOT<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 1010 +// NOT<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 1010 (+ Limm) +// +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_NOT_do_op); // NOT + } + case 0x0b: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// RLC<.f> b,c 0010 0bbb 0010 1111 FBBB CCCC CC00 1011 +// RLC<.f> b,u6 0010 0bbb 0110 1111 FBBB uuuu uu00 1011 +// RLC<.f> b,limm 0010 0bbb 0010 1111 FBBB 1111 1000 1011 (+ Limm) +// +// RLC<.f> 0,c 0010 0110 0010 1111 F111 CCCC CC00 1011 +// RLC<.f> 0,u6 0010 0110 0110 1111 F111 uuuu uu00 1011 +// RLC<.f> 0,limm 0010 0110 0010 1111 F111 1111 1000 1011 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_RLC_do_op); // RLC + } + case 0x0c: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS ss ssss +// EX<.di> b,[c] 0010 0bbb 0010 1111 DBBB CCCC CC00 1100 +// EX<.di> b,[u6] 0010 0bbb 0110 1111 DBBB uuuu uu00 1100 +// EX<.di> b,[limm] 0010 0bbb 0010 1111 DBBB 1111 1000 1100 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_EX(op); // EX + } + case 0x3f: // ZOPs (Zero Operand Opcodes) + { + uint8_t subinstr3 = (op & 0x07000000) >> 24; + subinstr3 |= ((op & 0x00007000) >> 12) << 3; + + switch (subinstr3 & 0x3f) + { + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I$$$ SS SSSS $$$ ss ssss +// SLEEP <u6> 0010 0001 0110 1111 0000 uuuu uu11 1111 +// SLEEP c 0010 0001 0010 1111 0000 CCCC CC11 1111 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_SLEEP(op); // SLEEP + } + case 0x02: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I$$$ SS SSSS $$$ ss ssss +// SWI/TRAP0 0010 0010 0110 1111 0000 0000 0011 1111 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_SWI(op); // SWI / TRAP0 + } + case 0x03: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I$$$ SS SSSS $$$ ss ssss +// SYNC 0010 0011 0110 1111 0000 0000 0011 1111 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_SYNC(op); // SYNC + } + case 0x04: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I$$$ SS SSSS $$$ ss ssss +// RTIE 0010 0100 0110 1111 0000 0000 0011 1111 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_RTIE(op); // RTIE + } + case 0x05: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I$$$ SS SSSS $$$ ss ssss +// BRK 0010 0101 0110 1111 0000 0000 0011 1111 +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_BRK(op); // BRK + } + + default: + { + // 0x00, 0x06-0x3f + return arcompact_handle_illegal(instruction, subinstr, subinstr2, subinstr3, op); // illegal + } + } + } + default: + { + // 0x0d - 0x3e + return arcompact_handle_illegal(instruction, subinstr, subinstr2, op); // illegal + } + } + } + +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// LD<zz><.x><.aa><.di> a,[b,c] 0010 0bbb aa11 0ZZX DBBB CCCC CCAA AAAA +// LD<zz><.x><.aa><.di> 0,[b,c] 0010 0bbb aa11 0ZZX DBBB CCCC CC11 1110 +// PREFETCH<.aa> [b,c] 0010 0bbb aa11 0000 0BBB CCCC CC11 1110 (prefetch is an alias) +// +// LD<zz><.x><.aa><.di> a,[b,limm] 0010 0bbb aa11 0ZZX DBBB 1111 10AA AAAA (+ Limm) +// LD<zz><.x><.aa><.di> 0,[b,limm] 0010 0bbb aa11 0ZZX DBBB 1111 1011 1110 (+ Limm) +// PREFETCH<.aa> [b,limm] 0010 0bbb aa11 0000 0BBB 1111 1011 1110 (+ Limm) (prefetch is an alias) +// +// LD<zz><.x><.di> a,[limm,c] 0010 0110 RR11 0ZZX D111 CCCC CCAA AAAA (+ Limm) +// LD<zz><.x><.di> 0,[limm,c] 0010 0110 RR11 0ZZX D111 CCCC CC11 1110 (+ Limm) +// PREFETCH [limm,c] 0010 0110 RR11 0000 0111 CCCC CC11 1110 (+ Limm) (prefetch is an alias) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: + { + return handleop32_LDrr(op, (op >> 17) & 3, (op >> 16) & 1); // LD r-r + } + default: + { + return arcompact_handle_illegal(instruction, subinstr, op); // illegal + } + } + } + case 0x05: // op a,b,c (05 ARC ext) + { + uint8_t subinstr = (op & 0x003f0000) >> 16; + + switch (subinstr) + { + case 0x00: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IIII I SS SSSS +// ASL<.f> a,b,c 0010 1bbb 0000 0000 FBBB CCCC CCAA AAAA +// ASL<.f> a,b,u6 0010 1bbb 0100 0000 FBBB uuuu uuAA AAAA +// ASL<.f> b,b,s12 0010 1bbb 1000 0000 FBBB ssss ssSS SSSS +// ASL<.cc><.f> b,b,c 0010 1bbb 1100 0000 FBBB CCCC CC0Q QQQQ +// ASL<.cc><.f> b,b,u6 0010 1bbb 1100 0000 FBBB uuuu uu1Q QQQQ +// ASL<.f> a,limm,c 0010 1110 0000 0000 F111 CCCC CCAA AAAA (+ Limm) +// ASL<.f> a,b,limm 0010 1bbb 0000 0000 FBBB 1111 10AA AAAA (+ Limm) +// ASL<.cc><.f> b,b,limm 0010 1bbb 1100 0000 FBBB 1111 100Q QQQQ (+ Limm) +// +// ASL<.f> 0,b,c 0010 1bbb 0000 0000 FBBB CCCC CC11 1110 +// ASL<.f> 0,b,u6 0010 1bbb 0100 0000 FBBB uuuu uu11 1110 +// ASL<.cc><.f> 0,limm,c 0010 1110 1100 0000 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ASL_multiple_do_op); // ASL + } + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// LSR<.f> a,b,c 0010 1bbb 0000 0001 FBBB CCCC CCAA AAAA +// LSR<.f> a,b,u6 0010 1bbb 0100 0001 FBBB uuuu uuAA AAAA +// LSR<.f> b,b,s12 0010 1bbb 1000 0001 FBBB ssss ssSS SSSS +// LSR<.cc><.f> b,b,c 0010 1bbb 1100 0001 FBBB CCCC CC0Q QQQQ +// LSR<.cc><.f> b,b,u6 0010 1bbb 1100 0001 FBBB uuuu uu1Q QQQQ +// LSR<.f> a,limm,c 0010 1110 0000 0001 F111 CCCC CCAA AAAA (+ Limm) +// LSR<.f> a,b,limm 0010 1bbb 0000 0001 FBBB 1111 10AA AAAA (+ Limm) +// LSR<.cc><.f> b,b,limm 0010 1bbb 1100 0001 FBBB 1111 100Q QQQQ (+ Limm) +// +// LSR<.f> 0,b,c 0010 1bbb 0000 0001 FBBB CCCC CC11 1110 +// LSR<.f> 0,b,u6 0010 1bbb 0100 0001 FBBB uuuu uu11 1110 +// LSR<.cc><.f> 0,limm,c 0010 1110 1100 0001 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_LSR_multiple_do_op); // LSR + } + case 0x02: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// ASR<.f> a,b,c 0010 1bbb 0000 0010 FBBB CCCC CCAA AAAA +// ASR<.f> a,b,u6 0010 1bbb 0100 0010 FBBB uuuu uuAA AAAA +// ASR<.f> b,b,s12 0010 1bbb 1000 0010 FBBB ssss ssSS SSSS +// ASR<.cc><.f> b,b,c 0010 1bbb 1100 0010 FBBB CCCC CC0Q QQQQ +// ASR<.cc><.f> b,b,u6 0010 1bbb 1100 0010 FBBB uuuu uu1Q QQQQ +// ASR<.f> a,limm,c 0010 1110 0000 0010 F111 CCCC CCAA AAAA (+ Limm) +// ASR<.f> a,b,limm 0010 1bbb 0000 0010 FBBB 1111 10AA AAAA (+ Limm) +// ASR<.cc><.f> b,b,limm 0010 1bbb 1100 0010 FBBB 1111 100Q QQQQ (+ Limm) +// +// ASR<.f> 0,b,c 0010 1bbb 0000 0010 FBBB CCCC CC11 1110 +// ASR<.f> 0,b,u6 0010 1bbb 0100 0010 FBBB uuuu uu11 1110 +// ASR<.cc><.f> 0,limm,c 0010 1110 1100 0010 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ASR_multiple_do_op); // ASR + } + case 0x03: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// ROR<.f> a,b,c 0010 1bbb 0000 0011 FBBB CCCC CCAA AAAA +// ROR<.f> a,b,u6 0010 1bbb 0100 0011 FBBB uuuu uuAA AAAA +// ROR<.f> b,b,s12 0010 1bbb 1000 0011 FBBB ssss ssSS SSSS +// ROR<.cc><.f> b,b,c 0010 1bbb 1100 0011 FBBB CCCC CC0Q QQQQ +// ROR<.cc><.f> b,b,u6 0010 1bbb 1100 0011 FBBB uuuu uu1Q QQQQ +// ROR<.f> a,limm,c 0010 1110 0000 0011 F111 CCCC CCAA AAAA (+ Limm) +// ROR<.f> a,b,limm 0010 1bbb 0000 0011 FBBB 1111 10AA AAAA (+ Limm) +// ROR<.cc><.f> b,b,limm 0010 1bbb 1100 0011 FBBB 1111 100Q QQQQ (+ Limm) +// +// ROR<.f> 0,b,c 0010 1bbb 0000 0011 FBBB CCCC CC11 1110 +// ROR<.f> 0,b,u6 0010 1bbb 0100 0011 FBBB uuuu uu11 1110 +// ROR<.cc><.f> 0,limm,c 0010 1110 1100 0011 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ROR_multiple_do_op); // ROR + } + case 0x04: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// MUL64 <0,>b,c 0010 1bbb 0000 0100 0BBB CCCC CC11 1110 +// MUL64 <0,>b,u6 0010 1bbb 0100 0100 0BBB uuuu uu11 1110 +// MUL64 <0,>b,s12 0010 1bbb 1000 0100 0BBB ssss ssSS SSSS +// MUL64 <0,>limm,c 0010 1110 0000 0100 0111 CCCC CC11 1110 (+ Limm) +// +// MUL64<.cc> <0,>b,c 0010 1bbb 1100 0100 0BBB CCCC CC0Q QQQQ +// MUL64<.cc> <0,>b,u6 0010 1bbb 1100 0100 0BBB uuuu uu1Q QQQQ +// MUL64<.cc> <0,>limm,c 0010 1110 1100 0100 0111 CCCC CC0Q QQQQ (+ Limm) +// MUL64<.cc> <0,>b,limm 0010 1bbb 1100 0100 0BBB 1111 100Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_MULx64(op, handleop32_MUL64_do_op); // MUL64 + } + case 0x05: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// MULU64 <0,>b,c 0010 1bbb 0000 0101 0BBB CCCC CC11 1110 +// MULU64 <0,>b,u6 0010 1bbb 0100 0101 0BBB uuuu uu11 1110 +// MULU64 <0,>b,s12 0010 1bbb 1000 0101 0BBB ssss ssSS SSSS +// MULU64 <0,>limm,c 0010 1110 0000 0101 0111 CCCC CC11 1110 (+ Limm) +// +// MULU64<.cc> <0,>b,c 0010 1bbb 1100 0101 0BBB CCCC CC0Q QQQQ +// MULU64<.cc> <0,>b,u6 0010 1bbb 1100 0101 0BBB uuuu uu1Q QQQQ +// MULU64<.cc> <0,>limm,c 0010 1110 1100 0101 0111 CCCC CC0Q QQQQ (+ Limm) +// MULU64<.cc> <0,>b,limm 0010 1bbb 1100 0101 0BBB 1111 100Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_MULx64(op, handleop32_MULU64_do_op); // MULU64 + } + case 0x06: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Extended Arithmetic (optional on ARCtangent-A5, ARC600, built in on ARC700) +// ADDS - Add and Saturate +// +// ADDS<.f> a,b,c 0010 1bbb 0000 0110 FBBB CCCC CCAA AAAA +// ADDS<.f> a,b,u6 0010 1bbb 0100 0110 FBBB uuuu uuAA AAAA +// ADDS<.f> b,b,s12 0010 1bbb 1000 0110 FBBB ssss ssSS SSSS +// ADDS<.cc><.f> b,b,c 0010 1bbb 1100 0110 FBBB CCCC CC0Q QQQQ +// ADDS<.cc><.f> b,b,u6 0010 1bbb 1100 0110 FBBB uuuu uu1Q QQQQ +// ADDS<.f> a,limm,c 0010 1110 0000 0110 F111 CCCC CCAA AAAA (+ Limm) +// ADDS<.f> a,b,limm 0010 1bbb 0000 0110 FBBB 1111 10AA AAAA (+ Limm) +// ADDS<.cc><.f> b,b,limm 0010 1bbb 1100 0110 FBBB 1111 10QQ QQQQ (+ Limm) +// +// ADDS<.f> 0,b,c 0010 1bbb 0000 0110 FBBB CCCC CC11 1110 +// ADDS<.f> 0,b,u6 0010 1bbb 0100 0110 FBBB uuuu uu11 1110 +// ADDS<.f> 0,b,limm 0010 1bbb 0000 0110 FBBB 1111 1011 1110 (+ Limm) +// ADDS<.cc><.f> 0,limm,c 0010 1110 1100 0110 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ADDS_do_op); // ADDS + } + case 0x07: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Extended Arithmetic (optional on ARCtangent-A5, ARC600, built in on ARC700) +// SUBS - Subtract and Saturate +// +// SUBS<.f> a,b,c 0010 1bbb 0000 0111 FBBB CCCC CCAA AAAA +// SUBS<.f> a,b,u6 0010 1bbb 0100 0111 FBBB uuuu uuAA AAAA +// SUBS<.f> b,b,s12 0010 1bbb 1000 0111 FBBB ssss ssSS SSSS +// SUBS<.cc><.f> b,b,c 0010 1bbb 1100 0111 FBBB CCCC CC0Q QQQQ +// SUBS<.cc><.f> b,b,u6 0010 1bbb 1100 0111 FBBB uuuu uu1Q QQQQ +// SUBS<.f> a,limm,c 0010 1110 0000 0111 F111 CCCC CCAA AAAA (+ Limm) +// SUBS<.f> a,b,limm 0010 1bbb 0000 0111 FBBB 1111 10AA AAAA (+ Limm) +// SUBS<.cc><.f> b,b,limm 0010 1bbb 1100 0111 FBBB 1111 10QQ QQQQ (+ Limm) +// +// SUBS<.f> 0,b,c 0010 1bbb 0000 0111 FBBB CCCC CC11 1110 +// SUBS<.f> 0,b,u6 0010 1bbb 0100 0111 FBBB uuuu uu11 1110 +// SUBS<.f> 0,b,limm 0010 1bbb 0000 0111 FBBB 1111 1011 1110 (+ Limm) +// SUBS<.cc><.f> 0,limm,c 0010 1110 1100 0111 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_SUBS_do_op); // SUBS + } + case 0x08: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Extended Arithmetic (optional on ARCtangent-A5, ARC600, built in on ARC700) +// DIVAW - Division Assist +// +// DIVAW a,b,c 0010 1bbb 0000 1000 0BBB CCCC CCAA AAAA +// DIVAW a,b,u6 0010 1bbb 0100 1000 0BBB uuuu uuAA AAAA +// DIVAW b,b,s12 0010 1bbb 1000 1000 0BBB ssss ssSS SSSS +// DIVAW<.cc> b,b,c 0010 1bbb 1100 1000 0BBB CCCC CC0Q QQQQ +// DIVAW<.cc> b,b,u6 0010 1bbb 1100 1000 0BBB uuuu uu1Q QQQQ +// DIVAW a,limm,c 0010 1110 0000 1000 0111 CCCC CCAA AAAA (+ Limm) +// DIVAW a,b,limm 0010 1bbb 0000 1000 0BBB 1111 10AA AAAA (+ Limm) +// DIVAW<.cc> b,b,limm 0010 1bbb 1100 1000 0BBB 1111 10QQ QQQQ (+ Limm) +// +// DIVAW 0,b,c 0010 1bbb 0000 1000 0BBB CCCC CC11 1110 +// DIVAW 0,b,u6 0010 1bbb 0100 1000 0BBB uuuu uu11 1110 +// DIVAW<.cc> 0,limm,c 0010 1110 1100 1000 0111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_DIVAW_do_op); // DIVAW + } + case 0x0a: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Extended Arithmetic (optional ARCtangent-A5, ARC600, built in on ARC700) +// ASLS - Arithmetic Shift Left and Saturate (with negative shift value support) +// +// IIII I SS SSSS +// ASLS<.f> a,b,c 0010 1bbb 0000 1010 FBBB CCCC CCAA AAAA +// ASLS<.f> a,b,u6 0010 1bbb 0100 1010 FBBB uuuu uuAA AAAA +// ASLS<.f> b,b,s12 0010 1bbb 1000 1010 FBBB ssss ssSS SSSS +// ASLS<.cc><.f> b,b,c 0010 1bbb 1100 1010 FBBB CCCC CC0Q QQQQ +// ASLS<.cc><.f> b,b,u6 0010 1bbb 1100 1010 FBBB uuuu uu1Q QQQQ +// ASLS<.f> a,limm,c 0010 1110 0000 1010 F111 CCCC CCAA AAAA (+ Limm) +// ASLS<.f> a,b,limm 0010 1bbb 0000 1010 FBBB 1111 10AA AAAA (+ Limm) +// ASLS<.cc><.f> b,b,limm 0010 1bbb 1100 1010 FBBB 1111 10QQ QQQQ (+ Limm) +// ASLS<.f> 0,b,c 0010 1bbb 0000 1010 FBBB CCCC CC11 1110 +// ASLS<.f> 0,b,u6 0010 1bbb 0100 1010 FBBB uuuu uu11 1110 +// ASLS<.cc><.f> 0,limm,c 0010 1110 1100 1010 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ASLS_do_op); // ASLS + } + case 0x0b: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Extended Arithmetic (optional ARCtangent-A5, ARC600, built in on ARC700) +// ASRS - Arithmetic Shift Right and Saturate (with negative shift value support) +// +// ASRS<.f> a,b,c 0010 1bbb 0000 1011 FBBB CCCC CCAA AAAA +// ASRS<.f> a,b,u6 0010 1bbb 0100 1011 FBBB uuuu uuAA AAAA +// ASRS<.f> b,b,s12 0010 1bbb 1000 1011 FBBB ssss ssSS SSSS +// ASRS<.cc><.f> b,b,c 0010 1bbb 1100 1011 FBBB CCCC CC0Q QQQQ +// ASRS<.cc><.f> b,b,u6 0010 1bbb 1100 1011 FBBB uuuu uu1Q QQQQ +// ASRS<.f> a,limm,c 0010 1110 0000 1011 F111 CCCC CCAA AAAA (+ Limm) +// ASRS<.f> a,b,limm 0010 1bbb 0000 1011 FBBB 1111 10AA AAAA (+ Limm) +// ASRS<.cc><.f> b,b,limm 0010 1bbb 1100 1011 FBBB 1111 10QQ QQQQ (+ Limm) +// +// ASRS<.f> 0,b,c 0010 1bbb 0000 1011 FBBB CCCC CC11 1110 +// ASRS<.f> 0,b,u6 0010 1bbb 0100 1011 FBBB uuuu uu11 1110 +// ASRS<.cc><.f> 0,limm,c 0010 1110 1100 1011 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ASRS_do_op); // ASRS + } + case 0x0c: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Unknown Extension Op +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_UNKNOWN_05_0c_do_op); + } + case 0x10: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Unknown Extension Op +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_UNKNOWN_05_10_do_op); + } + case 0x14: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Unknown Extension Op +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_UNKNOWN_05_14_do_op); + } + case 0x28: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Extended Arithmetic (optional ARCtangent-A5, ARC600, built in on ARC700) +// ADDSDW - Dual 16-bit Add and Saturate +// +// ADDSDW<.f> a,b,c 0010 1bbb 0010 1000 FBBB CCCC CCAA AAAA +// ADDSDW<.f> a,b,u6 0010 1bbb 0110 1000 FBBB uuuu uuAA AAAA +// ADDSDW<.f> b,b,s12 0010 1bbb 1010 1000 FBBB ssss ssSS SSSS +// ADDSDW<.cc><.f> b,b,c 0010 1bbb 1110 1000 FBBB CCCC CC0Q QQQQ +// ADDSDW<.cc><.f> b,b,u6 0010 1bbb 1110 1000 FBBB uuuu uu1Q QQQQ +// ADDSDW<.f> a,limm,c 0010 1110 0010 1000 F111 CCCC CCAA AAAA (+ Limm) +// ADDSDW<.f> a,b,limm 0010 1bbb 0010 1000 FBBB 1111 10AA AAAA (+ Limm) +// ADDSDW<.cc><.f> b,b,limm 0010 1bbb 1110 1000 FBBB 1111 10QQ QQQQ (+ Limm) +// +// ADDSDW<.f> 0,b,c 0010 1bbb 0010 1000 FBBB CCCC CC11 1110 +// ADDSDW<.f> 0,b,u6 0010 1bbb 0110 1000 FBBB uuuu uu11 1110 +// ADDSDW<.cc><.f> 0,limm,c 0010 1110 1110 1000 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_ADDSDW_do_op); // ADDSDW + } + case 0x29: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Extended Arithmetic (optional ARCtangent-A5, ARC600, built in on ARC700) +// SUBSDW - Dual 16-bit Subtract and Saturate +// +// SUBSDW<.f> a,b,c 0010 1bbb 0010 1001 FBBB CCCC CCAA AAAA +// SUBSDW<.f> a,b,u6 0010 1bbb 0110 1001 FBBB uuuu uuAA AAAA +// SUBSDW<.f> b,b,s12 0010 1bbb 1010 1001 FBBB ssss ssSS SSSS +// SUBSDW<.cc><.f> b,b,c 0010 1bbb 1110 1001 FBBB CCCC CC0Q QQQQ +// SUBSDW<.cc><.f> b,b,u6 0010 1bbb 1110 1001 FBBB uuuu uu1Q QQQQ +// SUBSDW<.f> a,limm,c 0010 1110 0010 1001 F111 CCCC CCAA AAAA (+ Limm) +// SUBSDW<.f> a,b,limm 0010 1bbb 0010 1001 FBBB 1111 10AA AAAA (+ Limm) +// SUBSDW<.cc><.f> b,b,limm 0010 1bbb 1110 1001 FBBB 1111 10QQ QQQQ (+ Limm) +// +// SUBSDW<.f> 0,b,c 0010 1bbb 0010 1001 FBBB CCCC CC11 1110 +// SUBSDW<.f> 0,b,u6 0010 1bbb 0110 1001 FBBB uuuu uu11 1110 +// SUBSDW<.cc><.f> 0,limm,c 0010 1110 1110 1001 F111 CCCC CC0Q QQQQ (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general(op, handleop32_SUBSDW_do_op); // SUBSDW + } + case 0x2f: // SOPs + { + uint8_t subinstr2 = op & 0x0000003f; + switch (subinstr2) + { + case 0x00: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// SWAP<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 0000 +// SWAP<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 0000 +// SWAP<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 0000 (+ Limm) +// +// SWAP<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 0000 +// SWAP<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 0000 +// SWAP<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 0000 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_SWAP_do_op); // SWAP + } + case 0x01: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// NORM<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 0001 +// NORM<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 0001 +// NORM<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 0001 (+ Limm) +// +// NORM<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 0001 +// NORM<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 0001 +// NORM<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 0001 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_NORM_do_op); // NORM + } + case 0x02: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// SAT16<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 0010 +// SAT16<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 0010 +// SAT16<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 0010 (+ Limm) +// +// SAT16<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 0010 +// SAT16<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 0010 +// SAT16<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 0010 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_SAT16_do_op); // SAT16 + } + case 0x03: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// RND16<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 0011 +// RND16<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 0011 +// RND16<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 0011 (+ Limm) +// +// RND16<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 0011 +// RND16<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 0011 +// RND16<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 0011 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_RND16_do_op); // RND16 + } + case 0x04: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// ABSSW<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 0100 +// ABSSW<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 0100 +// ABSSW<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 0100 (+ Limm) +// +// ABSSW<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 0100 +// ABSSW<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 0100 +// ABSSW<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 0100 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_ABSSW_do_op); // ABSSW + } + case 0x05: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// ABSS<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 0101 +// ABSS<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 0101 +// ABSS<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 0101 (+ Limm) +// +// ABSS<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 0101 +// ABSS<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 0101 +// ABSS<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 0101 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_ABSS_do_op); // ABSS + } + case 0x06: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// NEGSW<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 0110 +// NEGSW<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 0110 +// NEGSW<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 0110 (+ Limm) +// +// NEGSW<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 0110 +// NEGSW<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 0110 +// NEGSW<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 0110 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_NEGSW_do_op); // NEGSW + } + case 0x07: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// NEGS<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 0111 +// NEGS<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 0111 +// NEGS<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 0111 (+ Limm) +// +// NEGS<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 0111 +// NEGS<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 0111 +// NEGS<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 0111 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_NEGS_do_op); // NEGS + } + case 0x08: + { +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// NORMW<.f> b,c 0010 1bbb 0010 1111 FBBB CCCC CC00 1000 +// NORMW<.f> b,u6 0010 1bbb 0110 1111 FBBB uuuu uu00 1000 +// NORMW<.f> b,limm 0010 1bbb 0010 1111 FBBB 1111 1000 1000 (+ Limm) +// +// NORMW<.f> 0,c 0010 1110 0010 1111 F111 CCCC CC00 1000 +// NORMW<.f> 0,u6 0010 1110 0110 1111 F111 uuuu uu00 1000 +// NORMW<.f> 0,limm 0010 1110 0010 1111 F111 1111 1000 1000 (+ Limm) +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + return handleop32_general_SOP_group(op, handleop32_NORMW_do_op); // NORMW + } + case 0x3f: // ZOPs (Zero Operand Opcodes) + { + uint8_t subinstr3 = (op & 0x07000000) >> 24; + subinstr3 |= ((op & 0x00007000) >> 12) << 3; + + switch (subinstr3) + { + default: + { + return arcompact_handle_illegal(instruction, subinstr, subinstr2, subinstr3, op); // illegal + } + } + } + default: + { + return arcompact_handle_illegal(instruction, subinstr, subinstr2, op); // illegal + } + } + } + default: + { + return arcompact_handle_illegal(instruction, subinstr, op); // illegal + } + + } + } + case 0x06: return handleop32_ARC_EXT06(op); // op a,b,c (06 ARC ext) + case 0x07: return handleop32_USER_EXT07(op); // op a,b,c (07 User ext) + case 0x08: return handleop32_USER_EXT08(op); // op a,b,c (08 User ext) + case 0x09: return handleop32_MARKET_EXT09(op); // op a,b,c (09 Market ext) + case 0x0a: return handleop32_MARKET_EXT0a(op); // op a,b,c (0a Market ext) + case 0x0b: return handleop32_MARKET_EXT0b(op); // op a,b,c (0b Market ext) + } + } + else + { + switch (instruction) // 16-bit instructions + { + default: return -1; + case 0x0c: // Load/Add reg-reg + { + uint8_t subinstr = (op & 0x0018) >> 3; + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII I S S +// LD_S a,[b,c] 0110 0bbb ccc0 0aaa +// ####################################################################################################################### + return handleop_LD_S_a_b_c(op); // LD_S a,[b,c] + } + case 0x01: + { +// ####################################################################################################################### +// IIII I S S +// LDB_S a,[b,c] 0110 0bbb ccc0 1aaa +// ####################################################################################################################### + return handleop_LDB_S_a_b_c(op); // LDB_S a,[b,c] + } + case 0x02: + { +// ####################################################################################################################### +// IIII I S S +// LDW_S a,[b,c] 0110 0bbb ccc1 0aaa +// ####################################################################################################################### + return handleop_LDW_S_a_b_c(op); // LDW_S a,[b,c] + } + case 0x03: + { +// ####################################################################################################################### +// IIII I S S +// ADD_S a,b,c 0110 0bbb ccc1 1aaa +// ####################################################################################################################### + return handleop_ADD_S_a_b_c(op); // ADD_S a,b,c + } + } + } + case 0x0d: // Add/Sub/Shft imm + { + uint8_t subinstr = (op & 0x0018) >> 3; + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// ADD_S c,b,u3 0110 1bbb ccc0 0uuu +// ####################################################################################################################### + return handleop_ADD_S_c_b_u3(op); // ADD_S c,b,u3 + } + case 0x01: + { +// ####################################################################################################################### +// SUB_S c,b,u3 0110 1bbb ccc0 1uuu +// ####################################################################################################################### + return handleop_SUB_S_c_b_u3(op); // SUB_S c,b,u3 + } + case 0x02: + { +// ####################################################################################################################### +// IIII I S S +// ASL_S c,b,u3 0110 1bbb ccc1 0uuu +// ####################################################################################################################### + return handleop_ASL_S_c_b_u3(op); // ASL_S c,b,u3 + } + case 0x03: + { +// ####################################################################################################################### +// IIII I S S +// ASR_S c,b,u3 0110 1bbb ccc1 1uuu +// ####################################################################################################################### + return handleop_ASR_S_c_b_u3(op); // ASR_S c,b,u3 + } + } + } + case 0x0e: // Mov/Cmp/Add + { + uint8_t subinstr = (op & 0x0018) >> 3; + + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII I S S +// ADD_S b,b,h 0111 0bbb hhh0 0HHH +// ADD_S b,b,limm 0111 0bbb 1100 0111 (+ Limm) +// ####################################################################################################################### + return handleop_ADD_S_b_b_h_or_limm(op); // ADD_S b,b,h or ADD_S b,b,limm + } + case 0x01: + { +// ####################################################################################################################### +// IIII I S S +// MOV_S b,h 0111 0bbb hhh0 1HHH +// MOV_S b,limm 0111 0bbb 1100 1111 (+ Limm) +// ####################################################################################################################### + return handleop_MOV_S_b_h_or_limm(op); // MOV_S b,h or MOV_S b,limm + } + case 0x02: + { +// ####################################################################################################################### +// IIII I S S +// CMP_S b,h 0111 0bbb hhh1 0HHH +// CMP_S b,limm 0111 0bbb 1101 0111 (+ Limm) +// ####################################################################################################################### + return handleop_CMP_S_b_h_or_limm(op); // CMP_S b,h or CMP_S b,limm + } + case 0x03: + { +// ####################################################################################################################### +// IIII I S S +// MOV_S h,b 0111 0bbb hhh1 1HHH +// ####################################################################################################################### + return handleop_MOV_S_h_b(op); // MOV_S h,b + } + } + } + case 0x0f: // op_S b,b,c (single 16-bit ops) + { + uint8_t subinstr = op & 0x01f; + + switch (subinstr) + { + case 0x00: // SOPs + { + uint8_t subinstr2 = (op & 0x00e0) >> 5; + + switch (subinstr2) + { + case 0x00: + { +// ####################################################################################################################### +// IIII I sssS SSSS +// J_S [b] 0111 1bbb 0000 0000 +// ####################################################################################################################### + return handleop_J_S_b(op); // J_S [b] + } + case 0x01: + { +// ####################################################################################################################### +// IIII I sssS SSSS +// J_S.D [b] 0111 1bbb 0010 0000 +// ####################################################################################################################### + return handleop_J_S_D_b(op); // J_S.D [b] + } + case 0x02: + { +// ####################################################################################################################### +// IIII I sssS SSSS +// JL_S [b] 0111 1bbb 0100 0000 +// ####################################################################################################################### + return handleop_JL_S_b(op); // JL_S [b] + } + case 0x03: + { +// ####################################################################################################################### +// IIII I sssS SSSS +// JL_S.D [b] 0111 1bbb 0110 0000 +// ####################################################################################################################### + return handleop_JL_S_D_b(op); // JL_S.D [b] + } + case 0x06: + { +// ####################################################################################################################### +// SUB_S.NE b,b,b 0111 1bbb 1100 0000 +// IIII I sssS SSSS +// ####################################################################################################################### + return handleop_SUB_S_NE_b_b_b(op); // SUB_S.NE b,b,b + } + case 0x07: // ZOPs + { + uint8_t subinstr3 = (op & 0x0700) >> 8; + + switch (subinstr3) + { + case 0x00: + { +// ####################################################################################################################### +// IIII I$$$ sssS SSSS +// NOP_S 0111 1000 1110 0000 +// ####################################################################################################################### + return handleop_NOP_S(op); // NOP_S + } + case 0x01: + { +// ####################################################################################################################### +// IIII I$$$ sssS SSSS +// UNIMP_S 0111 1001 1110 0000 +// ####################################################################################################################### + return handleop_UNIMP_S(op); // UNIMP_S + } + case 0x04: + { +// ####################################################################################################################### +// IIII I$$$ sssS SSSS +// JEQ_S [blink] 0111 1100 1110 0000 +// ####################################################################################################################### + return handleop_JEQ_S_blink(op); // JEQ_S [BLINK] + } + case 0x05: + { +// ####################################################################################################################### +// IIII I$$$ sssS SSSS +// JNE_S [blink] 0111 1101 1110 0000 +// ####################################################################################################################### + return handleop_JNE_S_blink(op); // JNE_S [BLINK] + } + case 0x06: + { +// ####################################################################################################################### +// IIII I$$$ sssS SSSS +// J_S [blink] 0111 1110 1110 0000 +// ####################################################################################################################### + return handleop_J_S_blink(op); // J_S [BLINK] + } + case 0x07: + { +// ####################################################################################################################### +// IIII I$$$ sssS SSSS +// J_S.D [blink] 0111 1111 1110 0000 +// ####################################################################################################################### + return handleop_J_S_D_blink(op); // J_S.D [BLINK] + } + + default: // 0x02, 0x03 + { + return arcompact_handle_illegal(instruction,subinstr, subinstr2, subinstr3, op); + } + } + } + default: // 0x04, 0x05 + { + return arcompact_handle_illegal(instruction,subinstr, subinstr2, op); + } + } + } + case 0x02: + { +// ####################################################################################################################### +// IIII I S SSSS +// SUB_S b,b,c 0111 1bbb ccc0 0010 +// ####################################################################################################################### + return handleop_SUB_S_b_b_c(op); // SUB_S b,b,c + } + case 0x04: + { +// ####################################################################################################################### +// IIII I S SSSS +// AND_S b,b,c 0111 1bbb ccc0 0100 +// ####################################################################################################################### + return handleop_AND_S_b_b_c(op); // AND_S b,b,c + } + case 0x05: + { +// ####################################################################################################################### +// IIII I S SSSS +// OR_S b,b,c 0111 1bbb ccc0 0101 +// ####################################################################################################################### + return handleop_OR_S_b_b_c(op); // OR_S b,b,c + } + case 0x06: + { +// ####################################################################################################################### +// IIII I S SSSS +// BIC_S b,b,c 0111 1bbb ccc0 0110 +// ####################################################################################################################### + return handleop_BIC_S_b_b_c(op); // BIC_S b,b,c + } + case 0x07: + { +// ####################################################################################################################### +// IIII I S SSSS +// XOR_S b,b,c 0111 1bbb ccc0 0111 +// ####################################################################################################################### + return handleop_XOR_S_b_b_c(op); // XOR_S b,b,c + } + case 0x0b: + { +// ####################################################################################################################### +// IIII I S SSSS +// TST_S b,c 0111 1bbb ccc0 1011 +// ####################################################################################################################### + return handleop_TST_S_b_c(op); // TST_S b,c + } + case 0x0c: + { +// ####################################################################################################################### +// IIII I S SSSS +// MUL64_S <0,>b,c 0111 1bbb ccc0 1100 +// ####################################################################################################################### + return handleop_MUL64_S_0_b_c(op); // MUL64_S <0,>b,c + } + case 0x0d: + { + +// ####################################################################################################################### +// IIII I S SSSS +// SEXB_S b,c 0111 1bbb ccc0 1101 +// ####################################################################################################################### + return handleop_SEXB_S_b_c(op); // SEXB_S b,c + } + case 0x0e: + { +// ####################################################################################################################### +// IIII I S SSSS +// SEXW_S b,c 0111 1bbb ccc0 1110 +// ####################################################################################################################### + return handleop_SEXW_S_b_c(op); // SEXW_S b,c + } + case 0x0f: + { +// ####################################################################################################################### +// IIII I S SSSS +// EXTB_S b,c 0111 1bbb ccc0 1111 +// ####################################################################################################################### + return handleop_EXTB_S_b_c(op); // EXTB_S b,c + } + case 0x10: + { +// ####################################################################################################################### +// IIII I S SSSS +// EXTW_S b,c 0111 1bbb ccc1 0000 +// ####################################################################################################################### + return handleop_EXTW_S_b_c(op); // EXTW_S b,c + } + case 0x11: + { +// ####################################################################################################################### +// IIII I S SSSS +// ABS_S b,c 0111 1bbb ccc1 0001 +// ####################################################################################################################### + return handleop_ABS_S_b_c(op); // ABS_S b,c + } + case 0x12: + { +// ####################################################################################################################### +// IIII I S SSSS +// NOT_S b,c 0111 1bbb ccc1 0010 +// ####################################################################################################################### + return handleop_NOT_S_b_c(op); // NOT_S b,c + } + case 0x13: + { +// ####################################################################################################################### +// IIII I S SSSS +// NEG_S b,c 0111 1bbb ccc1 0011 +// ####################################################################################################################### + return handleop_NEG_S_b_c(op); // NEG_S b,c + } + case 0x14: + { +// ####################################################################################################################### +// IIII I S SSSS +// ADD1_S b,b,c 0111 1bbb ccc1 0100 +// ####################################################################################################################### + return handleop_ADD1_S_b_b_c(op); // ADD1_S b,b,c + } + case 0x15: + { +// ####################################################################################################################### +// IIII I S SSSS +// ADD2_S b,b,c 0111 1bbb ccc1 0101 +// ####################################################################################################################### + return handleop_ADD2_S_b_b_c(op); // ADD2_S b,b,c + } + case 0x16: + { +// ####################################################################################################################### +// IIII I S SSSS +// ADD3_S b,b,c 0111 1bbb ccc1 0110 +// ####################################################################################################################### + return handleop_ADD3_S_b_b_c(op); // ADD3_S b,b,c + } + case 0x18: + { +// ####################################################################################################################### +// IIII I S SSSS +// ASL_S b,b,c 0111 1bbb ccc1 1000 +// ####################################################################################################################### + return handleop_ASL_S_b_b_c_multiple(op); // ASL_S b,b,c (multiple) + } + case 0x19: + { +// ####################################################################################################################### +// IIII I S SSSS +// LSR_S b,b,c 0111 1bbb ccc1 1001 +// ####################################################################################################################### + return handleop_LSR_S_b_b_c_multiple(op); // LSR_S b,b,c (multiple) + } + case 0x1a: + { +// ####################################################################################################################### +// IIII I S SSSS +// ASR_S b,b,c 0111 1bbb ccc1 1010 +// ####################################################################################################################### + return handleop_ASR_S_b_b_c_multiple(op); // ASR_S b,b,c (multiple) + } + case 0x1b: + { +// ####################################################################################################################### +// IIII I S SSSS +// ASL_S b,c 0111 1bbb ccc1 1011 +// ####################################################################################################################### + return handleop_ASL_S_b_c_single(op); // ASL_S b,c (single) + } + case 0x1c: + { +// ####################################################################################################################### +// IIII I S SSSS +// ASR_S b,c 0111 1bbb ccc1 1100 +// ####################################################################################################################### + return handleop_ASR_S_b_c_single(op); // ASR_S b,c (single) + } + case 0x1d: + { +// ####################################################################################################################### +// IIII I S SSSS +// LSR_S b,c 0111 1bbb ccc1 1101 +// ####################################################################################################################### + return handleop_LSR_S_b_c_single(op); // LSR_S b,c (single) + } + case 0x1e: + { +// ####################################################################################################################### +// IIII I S SSSS +// TRAP_S u6 0111 1uuu uuu1 1110 +// ####################################################################################################################### + return handleop_TRAP_S_u6(op); // TRAP_S u6 (not a5?) + } + case 0x1f: + { + uint8_t subinstr2 = (op & 0x07e0) >> 5; + if (subinstr2 == 0x3f) + { +// ####################################################################################################################### +// IIII Isss sssS SSSS +// BRK_S 0111 1111 1111 1111 +// ####################################################################################################################### + return handleop_BRK_S(op); // BRK_S ( 0x7fff only? ) + } + else + { + return arcompact_handle_illegal(instruction,subinstr,subinstr2, op); + } + } + default: // 0x01, 0x03, 0x08, 0x09, 0x0a, 0x17 + { + return arcompact_handle_illegal(instruction, subinstr, op); + } + } + } + case 0x10: + { +// ####################################################################################################################### +// IIII I +// LD_S c,[b,u7] 1000 0bbb cccu uuuu +// ####################################################################################################################### + return handleop_LD_S_c_b_u7(op); // LD_S c,[b,u7] + } + case 0x11: + { +// ####################################################################################################################### +// IIII I +// LDB_S c,[b,u5] 1000 1bbb cccu uuuu +// ####################################################################################################################### + return handleop_LDB_S_c_b_u5(op); // LDB_S c,[b,u5] + } + case 0x12: + { +// ####################################################################################################################### +// IIII I +// LDW_S c,[b,u6] 1001 0bbb cccu uuuu +// ####################################################################################################################### + return handleop_LDW_S_c_b_u6(op); // LDW_S c,[b,u6] + } + case 0x13: + { +// ####################################################################################################################### +// IIII I +// LDW_S.X c,[b,u6] 1001 1bbb cccu uuuu +// ####################################################################################################################### + return handleop_LDW_S_X_c_b_u6(op); // LDW_S.X c,[b,u6] + } + case 0x14: + { +// ####################################################################################################################### +// IIII I +// ST_S c,[b,u7] 1010 0bbb cccu uuuu +// ####################################################################################################################### + return handleop_ST_S_c_b_u7(op); // ST_S c,[b,u7] + } + case 0x15: + { +// ####################################################################################################################### +// IIII I +// STB_S c,[b,u5] 1010 1bbb cccu uuuu +// ####################################################################################################################### + return handleop_STB_S_c_b_u5(op); // STB_S + } + case 0x16: + { +// ####################################################################################################################### +// IIII I +// STW_S c,[b,u6] 1011 0bbb cccu uuuu +// ####################################################################################################################### + return handleop_STW_S_c_b_u6(op); // STW_S + } + case 0x17: // Shift/Sub/Bit + { + uint8_t subinstr = (op & 0x00e0) >> 5; + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII I SSS +// ASL_S b,b,u5 1011 1bbb 000u uuuu +// ####################################################################################################################### + return handleop_ASL_S_b_b_u5(op); // ASL_S b,b,u5 + } + case 0x01: + { +// ####################################################################################################################### +// IIII I SSS +// LSR_S b,b,u5 1011 1bbb 001u uuuu +// ####################################################################################################################### + return handleop_LSR_S_b_b_u5(op); // LSR_S b,b,u5 + } + case 0x02: + { +// ####################################################################################################################### +// IIII I SSS +// ASR_S b,b,u5 1011 1bbb 010u uuuu +// ####################################################################################################################### + return handleop_ASR_S_b_b_u5(op); // ASR_S b,b,u5 + } + case 0x03: + { +// ####################################################################################################################### +// IIII I SSS +// SUB_S b,b,u5 1011 1bbb 011u uuuu +// ####################################################################################################################### + return handleop_SUB_S_b_b_u5(op); // SUB_S b,b,u5 + } + case 0x04: + { +// ####################################################################################################################### +// IIII I SSS +// BSET_S b,b,u5 1011 1bbb 100u uuuu +// ####################################################################################################################### + return handleop_BSET_S_b_b_u5(op); // BSET_S b,b,u5 + } + case 0x05: + { +// ####################################################################################################################### +// IIII I SSS +// BCLR_S b,b,u5 1011 1bbb 101u uuuu +// ####################################################################################################################### + return handleop_BCLR_S_b_b_u5(op); // BCLR_S b,b,u5 + } + case 0x06: + { +// ####################################################################################################################### +// IIII I SSS +// BMSK_S b,b,u5 1011 1bbb 110u uuuu +// ####################################################################################################################### + return handleop_BMSK_S_b_b_u5(op); // BMSK_S b,b,u5 + } + case 0x07: + { +// ####################################################################################################################### +// IIII I SSS +// BTST_S b,u5 1011 1bbb 111u uuuu +// ####################################################################################################################### + return handleop_BTST_S_b_u5(op); // BTST_S b,u5 + } + } + } + case 0x18: // Stack Instr + { + uint8_t subinstr = (op & 0x00e0) >> 5; + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII I SSS +// LD_S b,[sp,u7] 1100 0bbb 000u uuuu +// ####################################################################################################################### + return handleop_LD_S_b_sp_u7(op); // LD_S b,[sp,u7] + } + case 0x01: + { +// ####################################################################################################################### +// IIII I SSS +// LDB_S b,[sp,u7] 1100 0bbb 001u uuuu +// ####################################################################################################################### + return handleop_LDB_S_b_sp_u7(op); // LDB_S b,[sp,u7] + } + case 0x02: + { +// ####################################################################################################################### +// IIII I SSS +// ST_S b,[sp,u7] 1100 0bbb 010u uuuu +// ####################################################################################################################### + return handleop_ST_S_b_sp_u7(op); // ST_S b,[sp,u7] + } + case 0x03: + { +// ####################################################################################################################### +// IIII I SSS +// STB_S b,[sp,u7] 1100 0bbb 011u uuuu +// ####################################################################################################################### + return handleop_STB_S_b_sp_u7(op); // STB_S b,[sp,u7] + } + case 0x04: + { +// ####################################################################################################################### +// IIII I SSS +// ADD_S b,sp,u7 1100 0bbb 100u uuuu +// ####################################################################################################################### + return handleop_ADD_S_b_sp_u7(op); // ADD_S b,sp,u7 + } + + case 0x05: // subtable 18_05 + { + uint8_t subinstr2 = (op & 0x0700) >> 8; + switch (subinstr2) + { + case 0x00: + { +// ####################################################################################################################### +// IIII Isss SSS +// ADD_S sp,sp,u7 1100 0000 101u uuuu +// ####################################################################################################################### + return handleop_ADD_S_sp_sp_u7(op); // ADD_S sp,sp,u7 + } + case 0x01: + { +// ####################################################################################################################### +// IIII Isss SSS +// SUB_S sp,sp,u7 1100 0001 101u uuuu +// ####################################################################################################################### + return handleop_SUB_S_sp_sp_u7(op); // SUB_S sp,sp,u7 + } + default: return arcompact_handle_illegal(instruction,subinstr,subinstr2, op); + } + } + case 0x06: // subtable 18_06 + { + uint8_t subinstr2 = op & 0x001f; + switch (subinstr2) + { + case 0x01: + { +// ####################################################################################################################### +// IIII I SSSs ssss +// POP_S b 1100 0bbb 1100 0001 +// ####################################################################################################################### + return handleop_POP_S_b(op); // POP_S b + } + case 0x11: + { +// ####################################################################################################################### +// IIII I SSSs ssss +// POP_S blink 1100 0RRR 1101 0001 +// ####################################################################################################################### + return handleop_POP_S_blink(op); // POP_S blink + } + default: return arcompact_handle_illegal(instruction,subinstr,subinstr2, op); + } + } + case 0x07: // subtable 18_07 + { + uint8_t subinstr2 = op & 0x001f; + + switch (subinstr2) + { + case 0x01: + { +// ####################################################################################################################### +// IIII I SSSs ssss +// PUSH_S b 1100 0bbb 1110 0001 +// ####################################################################################################################### + return handleop_PUSH_S_b(op); // PUSH_S b + } + case 0x11: + { +// ####################################################################################################################### +// IIII I SSSs ssss +// PUSH_S blink 1100 0RRR 1111 0001 +// ####################################################################################################################### + return handleop_PUSH_S_blink(op); // PUSH_S blink + } + default: return arcompact_handle_illegal(instruction,subinstr,subinstr2, op); + } + } + } + } + case 0x19: // GP Instr + { + uint8_t subinstr = (op & 0x0600) >> 9; + + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII ISS +// LD_S r0,[gp,s11] 1100 100s ssss ssss +// ####################################################################################################################### + return handleop_LD_S_r0_gp_s11(op); // LD_S r0,[gp,s11] + } + case 0x01: + { +// ####################################################################################################################### +// IIII ISS +// LDB_S r0,[gp,s9] 1100 101s ssss ssss +// ####################################################################################################################### + return handleop_LDB_S_r0_gp_s9(op); // LDB_S r0,[gp,s9] + } + case 0x02: + { +// ####################################################################################################################### +// IIII ISS +// LDW_S r0,[gp,s10] 1100 110s ssss ssss +// ####################################################################################################################### + return handleop_LDW_S_r0_gp_s10(op); // LDW_S r0,[gp,s10] + } + case 0x03: + { +// ####################################################################################################################### +// IIII ISS +// ADD_S r0,gp,s11 1100 111s ssss ssss +// ####################################################################################################################### + return handleop_ADD_S_r0_gp_s11(op); // ADD_S r0,gp,s11 + } + } + } + case 0x1a: + { +// ####################################################################################################################### +// IIII I +// LD_S b,[pcl,u10] 1101 0bbb uuuu uuuu +// ####################################################################################################################### + return handleop_LD_S_b_pcl_u10(op); // LD_S b,[pcl,u10] + } + + case 0x1b: + { +// ####################################################################################################################### +// IIII I +// MOV_S b,u8 1101 1bbb uuuu uuuu +// ####################################################################################################################### + return handleop_MOV_S_b_u8(op); // MOV_S b, u8 + } + + case 0x1c: // ADD_S/CMP_S + { + uint8_t subinstr = (op & 0x0080) >> 7; + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII I s +// ADD_S b,b,u7 1110 0bbb 0uuu uuuu +// ####################################################################################################################### + return handleop_ADD_S_b_b_u7(op); // ADD_S b, b, u7 + } + case 0x01: + { +// ####################################################################################################################### +// IIII I s +// CMP_S b,u7 1110 0bbb 1uuu uuuu +// ####################################################################################################################### + return handleop_CMP_S_b_u7(op); // CMP_S b, u7 + } + } + } + case 0x1d: // BRcc_S + { + uint8_t subinstr = (op & 0x0080) >> 7; + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII I s +// BREQ_S b,0,s8 1110 1bbb 0sss ssss +// ####################################################################################################################### + return handleop_BREQ_S_b_0_s8(op); // BREQ_S b,0,s8 + } + case 0x01: + { +// ####################################################################################################################### +// IIII I s +// BRNE_S b,0,s8 1110 1bbb 1sss ssss +// ####################################################################################################################### + return handleop_BRNE_S_b_0_s8(op); // BRNE_S b,0,s8 + } + } + } + case 0x1e: // Bcc_S + { + uint8_t subinstr = (op & 0x0600) >> 9; + switch (subinstr) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII ISS +// B_S s10 1111 000s ssss ssss +// ####################################################################################################################### + return handleop_B_S_s10(op); // B_S s10 + } + case 0x01: + { +// ####################################################################################################################### +// IIII ISS +// BEQ_S s10 1111 001s ssss ssss +// ####################################################################################################################### + return handleop_BEQ_S_s10(op); // BEQ_S s10 + } + case 0x02: + { +// ####################################################################################################################### +// IIII ISS +// BNE_S s10 1111 010s ssss ssss +// ####################################################################################################################### + return handleop_BNE_S_s10(op); // BNE_S s10 + } + case 0x03: // Bcc_S + { + uint8_t subinstr2 = (op & 0x01c0) >> 6; + switch (subinstr2) + { + default: return -1; + case 0x00: + { +// ####################################################################################################################### +// IIII ISSs ss +// BGT_S s7 1111 0110 00ss ssss +// ####################################################################################################################### + return handleop_BGT_S_s7(op); // BGT_S s7 + } + case 0x01: + { +// ####################################################################################################################### +// IIII ISSs ss +// BGE_S s7 1111 0110 01ss ssss +// ####################################################################################################################### + return handleop_BGE_S_s7(op); // BGE_S s7 + } + case 0x02: + { +// ####################################################################################################################### +// IIII ISSs ss +// BLT_S s7 1111 0110 10ss ssss +// ####################################################################################################################### + return handleop_BLT_S_s7(op); // BLT_S s7 + } + case 0x03: + { +// ####################################################################################################################### +// IIII ISSs ss +// BLE_S s7 1111 0110 11ss ssss +// ####################################################################################################################### + return handleop_BLE_S_s7(op); // BLE_S s7 + } + case 0x04: + { +// ####################################################################################################################### +// IIII ISSs ss +// BHI_S s7 1111 0111 00ss ssss +// ####################################################################################################################### + return handleop_BHI_S_s7(op); // BHI_S s7 + } + case 0x05: + { +// ####################################################################################################################### +// IIII ISSs ss +// BHS_S s7 1111 0111 01ss ssss +// ####################################################################################################################### + return handleop_BHS_S_s7(op); // BHS_S s7 + } + case 0x06: + { +// ####################################################################################################################### +// IIII ISSs ss +// BLO_S s7 1111 0111 10ss ssss +// ####################################################################################################################### + return handleop_BLO_S_s7(op); // BLO_S s7 + } + + case 0x07: + { +// ####################################################################################################################### +// IIII ISSs ss +// BLS_S s7 1111 0111 11ss ssss +// ####################################################################################################################### + return handleop_BLS_S_s7(op); // BLS_S s7 + } + } + } + } + } + case 0x1f: + { +// ####################################################################################################################### +// IIII I +// BL_S s13 1111 1sss ssss ssss +// ####################################################################################################################### + return handleop_BL_S_s13(op); // BL_S s13 + } + } + } + return 0; } |