diff options
-rw-r--r-- | scripts/src/cpu.lua | 4 | ||||
-rw-r--r-- | src/devices/cpu/f2mc16/f2mc16.cpp | 4 | ||||
-rw-r--r-- | src/devices/cpu/f2mc16/f2mc16d.cpp | 1639 | ||||
-rw-r--r-- | src/devices/cpu/f2mc16/f2mc16d.h | 62 | ||||
-rw-r--r-- | src/devices/cpu/f2mc16/f2mc16dasm.cpp | 2168 | ||||
-rw-r--r-- | src/devices/cpu/f2mc16/f2mc16dasm.h | 28 | ||||
-rw-r--r-- | src/tools/unidasm.cpp | 2 |
7 files changed, 1706 insertions, 2201 deletions
diff --git a/scripts/src/cpu.lua b/scripts/src/cpu.lua index fa655d8b60b..de81507f8a9 100644 --- a/scripts/src/cpu.lua +++ b/scripts/src/cpu.lua @@ -3218,8 +3218,8 @@ if CPUS["F2MC16"] then end if opt_tool(CPUS, "F2MC16") then - table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/f2mc16/f2mc16dasm.cpp") - table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/f2mc16/f2mc16dasm.h") + table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/f2mc16/f2mc16d.cpp") + table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/f2mc16/f2mc16d.h") end -------------------------------------------------- diff --git a/src/devices/cpu/f2mc16/f2mc16.cpp b/src/devices/cpu/f2mc16/f2mc16.cpp index 9726bdf976a..dfd6c4fc0a2 100644 --- a/src/devices/cpu/f2mc16/f2mc16.cpp +++ b/src/devices/cpu/f2mc16/f2mc16.cpp @@ -16,7 +16,7 @@ #include "emu.h" #include "f2mc16.h" -#include "f2mc16dasm.h" +#include "f2mc16d.h" // device type definitions DEFINE_DEVICE_TYPE(F2MC16, f2mc16_device, "f2mc16", "Fujitsu Micro F2MC-16") @@ -2034,7 +2034,7 @@ void f2mc16_device::opcodes_ea70(u8 operand) // ADDL A, RLx case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: m_acc = doADD_32(m_acc, read_rlX((operand>>1) & 3)); - m_pc += 3; + m_pc += 2; m_icount -= 7; break; diff --git a/src/devices/cpu/f2mc16/f2mc16d.cpp b/src/devices/cpu/f2mc16/f2mc16d.cpp new file mode 100644 index 00000000000..167ec0832de --- /dev/null +++ b/src/devices/cpu/f2mc16/f2mc16d.cpp @@ -0,0 +1,1639 @@ +// license:BSD-3-Clause +// copyright-holders:AJR +/*************************************************************************** + + Fujitsu F²MC-16 family disassembler + +***************************************************************************/ + +#include "emu.h" +#include "f2mc16d.h" + +f2mc16_disassembler::f2mc16_disassembler() + : util::disasm_interface() +{ +} + +const std::string_view f2mc16_disassembler::s_segment_prefixes[4] = +{ + "PCB", "DTB", "ADB", "SPB" +}; + +const std::string_view f2mc16_disassembler::s_segment_registers[6] = +{ + "DTB", "ADB", "SSB", "USB", "DPR", "SPB" +}; + +const std::string_view f2mc16_disassembler::s_bit_ops[8] = +{ + "MOVB", "MOVB", + "CLRB", "SETB", + "BBC", "BBS", + "WBTS", "WBTC" +}; + +const std::string_view f2mc16_disassembler::s_movs_ops[4] = +{ + "MOVSI", "MOVSD", "MOVSWI", "MOVSWD" +}; + +const std::string_view f2mc16_disassembler::s_sceq_ops[4] = +{ + "SCEQI", "SCEQD", "SCWEQI", "SCWEQD" +}; + +const std::string_view f2mc16_disassembler::s_shift_ops[3][4] = +{ + { "LSLW", "???", "ASRW", "LSRW" }, + { "LSLL", "???", "ASRL", "LSRL" }, + { "LSL", "NRML", "ASR", "LSR" } +}; + +const std::string_view f2mc16_disassembler::s_movp_ops[4] = +{ + "MOVP", "MOVPX", "MOVPW", "MOVPL" +}; + +const std::string_view f2mc16_disassembler::s_bcc_ops[16] = +{ + "BZ", "BNZ", + "BC", "BNC", + "BN", "BP", + "BV", "BNV", + "BT", "BNT", + "BLT", "BGE", + "BLE", "BGT", + "BLS", "BHI" +}; + +offs_t f2mc16_disassembler::opcode_alignment() const +{ + return 1; +} + +u32 f2mc16_disassembler::interface_flags() const +{ + return PAGED; +} + +u32 f2mc16_disassembler::page_address_bits() const +{ + return 16; +} + +void f2mc16_disassembler::format_imm4(std::ostream &stream, u8 x) +{ + if (x > 9) + util::stream_format(stream, "#0x%X", x); + else + util::stream_format(stream, "#%d", x); +} + +void f2mc16_disassembler::format_imm8(std::ostream &stream, u8 x) +{ + util::stream_format(stream, "#0x%02X", x); +} + +void f2mc16_disassembler::format_imm16(std::ostream &stream, u16 x) +{ + util::stream_format(stream, "#0x%04X", x); +} + +void f2mc16_disassembler::format_imm32(std::ostream &stream, u32 x) +{ + util::stream_format(stream, "#0x%08X", x); +} + +void f2mc16_disassembler::format_imm_signed(std::ostream &stream, s32 x) +{ + stream << '#'; + if (x < 0) + { + stream << '-'; + x = -x; + } + if (u32(x) > 9) + util::stream_format(stream, "0x%X", u32(x)); + else + util::stream_format(stream, "%d", x); +} + +void f2mc16_disassembler::format_dir(std::ostream &stream, u8 segm, u8 addr) +{ + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + util::stream_format(stream, "S:0x%02X", addr); +} + +void f2mc16_disassembler::format_io(std::ostream &stream, u8 addr) +{ + util::stream_format(stream, "I:0x%02X", addr); +} + +void f2mc16_disassembler::format_addr16(std::ostream &stream, u8 segm, u16 addr) +{ + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + else + stream << "D:"; + util::stream_format(stream, "0x%04X", addr); +} + +void f2mc16_disassembler::format_dst16(std::ostream &stream, u16 addr) +{ + util::stream_format(stream, "0x%04X", addr); +} + +void f2mc16_disassembler::format_addr24(std::ostream &stream, u32 addr) +{ + util::stream_format(stream, "0x%06X", addr); +} + +void f2mc16_disassembler::format_rel(std::ostream &stream, offs_t pc, s8 disp) +{ + util::stream_format(stream, "0x%04X", (pc + disp) & 0xffff); +} + +void f2mc16_disassembler::format_rwdisp8(std::ostream &stream, u8 r, u8 segm, s8 disp) +{ + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + util::stream_format(stream, "@RW%d", r); + if (disp < 0) + { + stream << '-'; + disp = -disp; + } + else + stream << '+'; + if (u8(disp) > 9) + stream << "0x"; + util::stream_format(stream, "%X", u8(disp)); +} + +void f2mc16_disassembler::format_rwdisp16(std::ostream &stream, u8 r, u8 segm, u16 disp) +{ + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + util::stream_format(stream, "@RW%d+0x%04X", r, disp); +} + +void f2mc16_disassembler::format_rldisp8(std::ostream &stream, u8 r, s8 disp) +{ + util::stream_format(stream, "@RL%d", r); + if (disp < 0) + { + stream << '-'; + disp = -disp; + } + else + stream << '+'; + if (u8(disp) > 9) + stream << "0x"; + util::stream_format(stream, "%X", u8(disp)); +} + +void f2mc16_disassembler::format_spdisp8(std::ostream &stream, s8 disp) +{ + stream << "@SP"; + if (disp < 0) + { + stream << '-'; + disp = -disp; + } + else + stream << '+'; + if (u8(disp) > 9) + stream << "0x"; + util::stream_format(stream, "%X", u8(disp)); +} + +void f2mc16_disassembler::format_pcdisp16(std::ostream &stream, s16 disp) +{ + if (disp < 0) + { + stream << "@PC-"; + disp = -disp; + } + else + stream << "@PC+"; + if (u16(disp) > 9) + stream << "0x"; + util::stream_format(stream, "%X", u16(disp)); +} + +void f2mc16_disassembler::format_rlist(std::ostream &stream, u8 rlst) +{ + stream << '('; + + bool first = true; + int last = -1; + for (int i = 0; i <= 8; i++) + { + if (i != 8 && BIT(rlst, i)) + { + if (last == -1) + last = i; + } + else if (last != -1) + { + if (first) + first = false; + else + stream << ','; + util::stream_format(stream, "RW%d", last); + if (last != i - 1) + util::stream_format(stream, "-RW%d", i - 1); + last = -1; + } + } + + stream << ')'; +} + +u32 f2mc16_disassembler::dasm_ea8(std::ostream &stream, offs_t pc, u8 op2, u8 segm, const f2mc16_disassembler::data_buffer &opcodes) +{ + op2 &= 0x1f; + if (op2 < 0x08) + { + util::stream_format(stream, "R%d", op2); + return 0; + } + else if (op2 < 0x10) + { + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + util::stream_format(stream, "@RW%d", op2 & 0x03); + if (op2 >= 0x0c) + stream << '+'; + return 0; + } + else if (op2 < 0x18) + { + format_rwdisp8(stream, op2 & 0x07, segm, opcodes.r8(pc)); + return 1; + } + else if (op2 < 0x1c) + { + format_rwdisp16(stream, op2 & 0x03, segm, opcodes.r16(pc)); + return 2; + } + else if (op2 < 0x1e) + { + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + util::stream_format(stream, "@RW%d+RW7", op2 & 0x01); + return 0; + } + else if (op2 == 0x1e) + { + format_pcdisp16(stream, s16(opcodes.r16(pc))); + return 2; + } + else + { + format_addr16(stream, segm, opcodes.r16(pc)); + return 2; + } +} + +u32 f2mc16_disassembler::dasm_ea16(std::ostream &stream, offs_t pc, u8 op2, u8 segm, const f2mc16_disassembler::data_buffer &opcodes) +{ + if ((op2 & 0x18) == 0) + { + util::stream_format(stream, "RW%d", op2 & 0x07); + return 0; + } + else + return dasm_ea8(stream, pc, op2, segm, opcodes); +} + +u32 f2mc16_disassembler::dasm_ea32(std::ostream &stream, offs_t pc, u8 op2, u8 segm, const f2mc16_disassembler::data_buffer &opcodes) +{ + if ((op2 & 0x18) == 0) + { + util::stream_format(stream, "RL%d", BIT(op2, 1, 2)); + return 0; + } + else + return dasm_ea8(stream, pc, op2, segm, opcodes); +} + +offs_t f2mc16_disassembler::dasm_bitop(std::ostream &stream, offs_t pc, u32 bytes, u8 segm, const f2mc16_disassembler::data_buffer &opcodes) +{ + u8 op2 = opcodes.r8(pc + bytes++); + if (op2 >= 0xf8) + { + util::stream_format(stream, "%-8s", "SBBS"); + format_addr16(stream, segm, opcodes.r16(pc + bytes)); + util::stream_format(stream, ":%d, ", op2 & 0x07); + format_rel(stream, pc + bytes + 3, opcodes.r8(pc + bytes + 2)); + bytes += 3; + } + else if ((op2 & 0x18) != 0x10 && (op2 & 0xc8) != 0xc8) + { + util::stream_format(stream, "%-8s", s_bit_ops[BIT(op2, 5, 3)]); + if (op2 < 0x20) + stream << "A, "; + if (BIT(op2, 4)) + { + format_addr16(stream, segm, opcodes.r16(pc + bytes)); + bytes += 2; + } + else if (BIT(op2, 3)) + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + else + format_io(stream, opcodes.r8(pc + bytes++)); + util::stream_format(stream, ":%d", op2 & 0x07); + if ((op2 & 0xc0) == 0x80) + { + stream << ", "; + format_rel(stream, pc + bytes + 1, opcodes.r8(pc + bytes)); + ++bytes; + } + else if ((op2 & 0xe0) == 0x20) + stream << ", A"; + } + else + { + util::stream_format(stream, "%-8s0x%02X", ".DATA.B", segm != 0 ? segm : 0x6c); + return 1 | SUPPORTED; + } + return bytes | SUPPORTED; +} + +offs_t f2mc16_disassembler::dasm_movm(std::ostream &stream, offs_t pc, u32 bytes, u8 segm, const f2mc16_disassembler::data_buffer &opcodes) +{ + // 16F only? + u8 op2 = opcodes.r8(pc + bytes++); + util::stream_format(stream, "%-8s", BIT(op2, 6) ? "MOVMW" : "MOVM"); + if (op2 < 0x80) + { + if (BIT(op2, 5)) + stream << "@A"; + else + { + format_addr16(stream, segm, opcodes.r16(pc + bytes)); + bytes += 2; + } + stream << ", "; + } + if ((op2 & 0x18) == 0) + util::stream_format(stream, "@RL%d", BIT(op2, 1, 2)); + else + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + if (op2 >= 0x80) + { + stream << ", "; + if (BIT(op2, 5)) + stream << "@A"; + else + { + format_addr16(stream, segm, opcodes.r16(pc + bytes)); + bytes += 2; + } + } + stream << ", "; + format_imm8(stream, opcodes.r8(pc + bytes++)); + return bytes | SUPPORTED; +} + +offs_t f2mc16_disassembler::dasm_cstrop(std::ostream &stream, offs_t pc, u32 bytes, u8 segm, const f2mc16_disassembler::data_buffer &opcodes) +{ + u8 op2 = opcodes.r8(pc + bytes++); + if (op2 < 0x40) + util::stream_format(stream, "%-8s%s, %s", s_movs_ops[BIT(op2, 4, 2)], s_segment_prefixes[BIT(op2, 2, 2)], s_segment_prefixes[BIT(op2, 0, 2)]); + else if (op2 < 0x60) + { + // 16F only? + util::stream_format(stream, "%-8s", BIT(op2, 4) ? "MOVMW" : "MOVM"); + format_addr16(stream, 0x04 | BIT(op2, 2, 2), opcodes.r16(pc + bytes)); + stream << ", "; + format_addr16(stream, 0x04 | BIT(op2, 0, 2), opcodes.r16(pc + bytes + 2)); + stream << ", "; + format_imm8(stream, opcodes.r16(pc + bytes + 4)); + bytes += 5; + } + else if ((op2 & 0xcc) == 0x80) + util::stream_format(stream, "%-8s%s", s_sceq_ops[BIT(op2, 4, 2)], s_segment_prefixes[BIT(op2, 0, 2)]); + else if ((op2 & 0xec) == 0xc0) + util::stream_format(stream, "%-8s%s", op2 >= 0xe0 ? "FILSWI" : "FILSI", s_segment_prefixes[BIT(op2, 0, 2)]); + else + { + util::stream_format(stream, "%-8s0x%02X", ".DATA.B", segm != 0 ? segm : 0x6e); + return 1 | SUPPORTED; + } + return bytes | SUPPORTED; +} + +offs_t f2mc16_disassembler::dasm_op6f(std::ostream &stream, offs_t pc, u32 bytes, u8 segm, const f2mc16_disassembler::data_buffer &opcodes) +{ + u8 op2 = opcodes.r8(pc + bytes++); + switch (op2) + { + case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: + util::stream_format(stream, "%-8sA, %s", "MOV", s_segment_registers[op2]); + break; + + case 0x05: case 0x0d: + util::stream_format(stream, "%-8sA, ", BIT(op2, 3) ? "MOVW" : "MOV"); + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + stream << "@A"; + break; + + case 0x06: + util::stream_format(stream, "%-8sA, PCB", "MOV"); + break; + + case 0x07: + util::stream_format(stream, "%-8sA", "ROLC"); + break; + + case 0x08: case 0x0a: case 0x0b: + case 0x18: case 0x1a: case 0x1b: + case 0x28: case 0x2a: case 0x2b: // all 16F only? + util::stream_format(stream, "%-8sA, ", s_shift_ops[BIT(op2, 4, 2)][BIT(op2, 0, 2)]); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x09: // 16F only? + util::stream_format(stream, "%-8sA, SPB", "MOV"); + break; + + case 0x0c: case 0x0e: case 0x0f: + case 0x1c: case 0x1e: case 0x1f: + case 0x2c: case 0x2d: case 0x2e: case 0x2f: + util::stream_format(stream, "%-8sA, R0", s_shift_ops[BIT(op2, 4, 2)][BIT(op2, 0, 2)]); + break; + + case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: + util::stream_format(stream, "%-8s%s, A", "MOV", s_segment_registers[op2 & 0x07]); + break; + + case 0x15: case 0x1d: + util::stream_format(stream, "%-8sAL, ", BIT(op2, 3) ? "MOVW" : "MOV"); + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + stream << "@AH"; + break; + + case 0x16: + util::stream_format(stream, "%-8sA, ", "MOVX"); + if (segm != 0) + util::stream_format(stream, "%s:", s_segment_prefixes[segm & 0x03]); + stream << "@A"; + break; + + case 0x17: + util::stream_format(stream, "%-8sA", "RORC"); + break; + + case 0x19: // 16F only? + util::stream_format(stream, "%-8sSPB, A", "MOV"); + break; + + case 0x20: case 0x22: case 0x24: case 0x26: + case 0x21: case 0x23: case 0x25: case 0x27: // defined as aliases on 16F only? + util::stream_format(stream, "%-8sA, ", "MOVX"); + format_rldisp8(stream, BIT(op2, 1, 2), opcodes.r8(pc + bytes++)); + break; + + case 0x29: // 16F only? + stream << "RETIQ"; + return bytes | STEP_OUT | SUPPORTED; + + case 0x30: case 0x32: case 0x34: case 0x36: case 0x38: case 0x3a: case 0x3c: case 0x3e: + case 0x31: case 0x33: case 0x35: case 0x37: case 0x39: case 0x3b: case 0x3d: case 0x3f: // defined as aliases on 16F only? + util::stream_format(stream, "%-8s", BIT(op2, 3) ? "MOVW" : "MOV"); + format_rldisp8(stream, BIT(op2, 1, 2), opcodes.r8(pc + bytes++)); + stream << ", A"; + break; + + case 0x40: case 0x42: case 0x44: case 0x46: case 0x48: case 0x4a: case 0x4c: case 0x4e: + case 0x41: case 0x43: case 0x45: case 0x47: case 0x49: case 0x4b: case 0x4d: case 0x4f: // defined as aliases on 16F only? + util::stream_format(stream, "%-8sA, ", BIT(op2, 3) ? "MOVW" : "MOV"); + format_rldisp8(stream, BIT(op2, 1, 2), opcodes.r8(pc + bytes++)); + break; + + case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: // 16F only? + util::stream_format(stream, "%-8s%s, ", "MOV", s_segment_registers[op2 & 0x07]); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x56: case 0x57: // 16F only? + util::stream_format(stream, "%-8sSPC%c, ", "MOVW", BIT(op2, 0) ? 'L' : 'U'); + format_imm8(stream, opcodes.r16(pc + bytes)); + bytes += 2; + break; + + case 0x58: case 0x59: case 0x5a: case 0x5b: // 16F only? + util::stream_format(stream, "%-8sA, @A", s_movp_ops[op2 & 0x03]); + break; + + case 0x5c: // 16F only? + util::stream_format(stream, "%-8sA", "BTSCN"); + break; + + case 0x5d: // 16F only? + stream << "SETSPC"; + break; + + case 0x5e: // 16F only? + util::stream_format(stream, "%-8sA", "BTSCNS"); + break; + + case 0x5f: // 16F only? + util::stream_format(stream, "%-8sA", "BTSCND"); + break; + + case 0x60: // 16F only? + util::stream_format(stream, "%-8sA, ", "MOV"); + format_spdisp8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x61: // 16F only? + util::stream_format(stream, "%-8sA, ", "MOVX"); + format_spdisp8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x62: // 16F only? + util::stream_format(stream, "%-8sA, ", "MOVW"); + format_spdisp8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x63: // 16F only? + util::stream_format(stream, "%-8sA, ", "MOVL"); + format_spdisp8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x64: // 16F only? + util::stream_format(stream, "%-8s", "MOV"); + format_spdisp8(stream, opcodes.r8(pc + bytes++)); + stream << ", A"; + break; + + case 0x65: // 16F only? + util::stream_format(stream, "%-8sSP, ", "MOVW"); + format_imm16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + break; + + case 0x66: // 16F only? + util::stream_format(stream, "%-8s", "MOVW"); + format_spdisp8(stream, opcodes.r8(pc + bytes++)); + stream << ", A"; + break; + + case 0x67: // 16F only? + util::stream_format(stream, "%-8s", "MOVL"); + format_spdisp8(stream, opcodes.r8(pc + bytes++)); + stream << ", A"; + break; + + case 0x68: case 0x69: case 0x6a: case 0x6b: // 16F only? + util::stream_format(stream, "%-8sA, ", s_movp_ops[op2 & 0x03]); + format_addr24(stream, opcodes.r16(pc + bytes) | u32(opcodes.r8(pc + bytes + 2)) << 16); + bytes += 3; + break; + + case 0x6c: case 0x6e: case 0x6f: // 16F only? + util::stream_format(stream, "%-8s", s_movp_ops[op2 & 0x03]); + format_addr24(stream, opcodes.r16(pc + bytes) | u32(opcodes.r8(pc + bytes + 2)) << 16); + stream << ", A"; + bytes += 3; + break; + + case 0x6d: // 16F only? + stream << "CLRSPC"; + break; + + case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: // 16F only? + util::stream_format(stream, "%-8s@A, RL%d", "MOVPL", BIT(op2, 1, 2)); + break; + + case 0x78: // 16F, 16FX, 16LX only? + util::stream_format(stream, "%-8sA", "MUL"); + break; + + case 0x79: // 16F, 16FX, 16LX only? + util::stream_format(stream, "%-8sA", "MULW"); + break; + + case 0x7a: // 16F, 16FX, 16LX only? + util::stream_format(stream, "%-8sA", "DIV"); + break; + + case 0x7b: // 16F only? + util::stream_format(stream, "%-8sA", "ABS"); + break; + + case 0x7c: // 16F only? + util::stream_format(stream, "%-8sA", "ABSW"); + break; + + case 0x7d: // 16F only? + util::stream_format(stream, "%-8sA", "ABSL"); + break; + + case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: // 16F only? + util::stream_format(stream, "%-8s@A, R%d", "MOVP", op2 & 0x07); + break; + + case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f: // 16F only? + util::stream_format(stream, "%-8s@A, RW%d", "MOVPW", op2 & 0x07); + break; + + default: + util::stream_format(stream, "%-8s0x%02X", ".DATA.B", segm != 0 ? segm : 0x6f); + return 1 | SUPPORTED; + } + + return bytes | SUPPORTED; +} + +offs_t f2mc16_disassembler::dasm_eainst(std::ostream &stream, offs_t pc, u32 bytes, u8 op1, u8 segm, const f2mc16_disassembler::data_buffer &opcodes) +{ + u8 op2 = opcodes.r8(pc + bytes++); + switch ((op1 & 0x0f) | (op2 & 0xe0)) + { + case 0x00: + util::stream_format(stream, "%-8sA, ", "ADDL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x20: + util::stream_format(stream, "%-8sA, ", "SUBL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x40: + util::stream_format(stream, "%-8s", "CWBNE"); + if ((op2 & 0x1e) == 0x0e) + stream << "(use prohibited)"; + else + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", "; + format_imm16(stream, opcodes.r16(pc + bytes)); + stream << ", "; + format_rel(stream, pc + bytes + 3, opcodes.r8(pc + bytes + 2)); + bytes += 3; + break; + + case 0x60: + util::stream_format(stream, "%-8sA, ", "CMPL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x80: + util::stream_format(stream, "%-8sA, ", "ANDL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xa0: + util::stream_format(stream, "%-8sA, ", "ORL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xc0: + util::stream_format(stream, "%-8sA, ", "XORL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xe0: + util::stream_format(stream, "%-8s", "CBNE"); + if ((op2 & 0x1e) == 0x0e) + stream << "(use prohibited)"; + else + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", "; + format_imm8(stream, opcodes.r8(pc + bytes)); + stream << ", "; + format_rel(stream, pc + bytes + 2, opcodes.r8(pc + bytes + 1)); + bytes += 2; + break; + + case 0x01: + util::stream_format(stream, "%-8s@", "JMPP"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x21: + util::stream_format(stream, "%-8s@", "CALLP"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + return bytes | STEP_OVER | SUPPORTED; + + case 0x41: + util::stream_format(stream, "%-8s", "INCL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x61: + util::stream_format(stream, "%-8s", "DECL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x81: + util::stream_format(stream, "%-8sA, ", "MOVL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xa1: + util::stream_format(stream, "%-8s", "MOVL"); + bytes += dasm_ea32(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xc1: + util::stream_format(stream, "%-8s", "MOV"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", "; + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0xe1: + util::stream_format(stream, "%-8sA, ", "MOVEA"); + bytes += dasm_ea16(stream, pc + bytes, op2, 0, opcodes); + break; + + case 0x02: + util::stream_format(stream, "%-8s", "ROLC"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x22: + util::stream_format(stream, "%-8s", "RORC"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x42: + util::stream_format(stream, "%-8s", "INC"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x62: + util::stream_format(stream, "%-8s", "DEC"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x82: + util::stream_format(stream, "%-8sA, ", "MOV"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xa2: + util::stream_format(stream, "%-8s", "MOV"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xc2: + util::stream_format(stream, "%-8sA, ", "MOVX"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xe2: + util::stream_format(stream, "%-8sA, ", "XCH"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x03: + util::stream_format(stream, "%-8s@", "JMP"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x23: + util::stream_format(stream, "%-8s@", "CALL"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + return bytes | STEP_OVER | SUPPORTED; + + case 0x43: + util::stream_format(stream, "%-8s", "INCW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x63: + util::stream_format(stream, "%-8s", "DECW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x83: + util::stream_format(stream, "%-8sA, ", "MOVW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xa3: + util::stream_format(stream, "%-8s", "MOVW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xc3: + util::stream_format(stream, "%-8s", "MOVW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", "; + format_imm16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + break; + + case 0xe3: + util::stream_format(stream, "%-8sA, ", "XCHW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x04: + util::stream_format(stream, "%-8sA, ", "ADD"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x24: + util::stream_format(stream, "%-8sA, ", "SUB"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x44: + util::stream_format(stream, "%-8sA, ", "ADDC"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x64: + util::stream_format(stream, "%-8sA, ", "CMP"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x84: + util::stream_format(stream, "%-8sA, ", "AND"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xa4: + util::stream_format(stream, "%-8sA, ", "OR"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xc4: + util::stream_format(stream, "%-8sA, ", "XOR"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xe4: + util::stream_format(stream, "%-8s", "DBNZ"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", "; + format_rel(stream, pc + bytes + 1, opcodes.r8(pc + bytes)); + ++bytes; + break; + + case 0x05: + util::stream_format(stream, "%-8s", "ADD"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0x25: + util::stream_format(stream, "%-8s", "SUB"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0x45: + util::stream_format(stream, "%-8sA, ", "SUBC"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x65: + util::stream_format(stream, "%-8s", "NEG"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x85: + util::stream_format(stream, "%-8s", "AND"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xa5: + util::stream_format(stream, "%-8s", "OR"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xc5: + util::stream_format(stream, "%-8s", "XOR"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xe5: + util::stream_format(stream, "%-8s", "NOT"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x06: + util::stream_format(stream, "%-8sA, ", "ADDW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x26: + util::stream_format(stream, "%-8sA, ", "SUBW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x46: + util::stream_format(stream, "%-8sA, ", "ADDCW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x66: + util::stream_format(stream, "%-8sA, ", "CMPW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x86: + util::stream_format(stream, "%-8sA, ", "ANDW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xa6: + util::stream_format(stream, "%-8sA, ", "ORW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xc6: + util::stream_format(stream, "%-8sA, ", "XORW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xe6: + util::stream_format(stream, "%-8s", "DWBNZ"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", "; + format_rel(stream, pc + bytes + 1, opcodes.r8(pc + bytes)); + ++bytes; + break; + + case 0x07: + util::stream_format(stream, "%-8s", "ADDW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0x27: + util::stream_format(stream, "%-8s", "SUBW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0x47: + util::stream_format(stream, "%-8sA, ", "SUBCW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x67: + util::stream_format(stream, "%-8s", "NEGW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x87: + util::stream_format(stream, "%-8s", "ANDW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xa7: + util::stream_format(stream, "%-8s", "ORW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xc7: + util::stream_format(stream, "%-8s", "XORW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + stream << ", A"; + break; + + case 0xe7: + util::stream_format(stream, "%-8s", "NOTW"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x08: case 0x48: // MUL is 16F, 16FX, 16LX only? + util::stream_format(stream, "%-8sA, ", BIT(op2, 6) ? "MUL" : "MULU"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x28: case 0x68: // MULW is 16F, 16FX, 16LX only? + util::stream_format(stream, "%-8sA, ", BIT(op2, 6) ? "MULW" : "MULUW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0x88: case 0xc8: // DIV is 16F, 16FX, 16LX only? + util::stream_format(stream, "%-8sA, ", BIT(op2, 6) ? "DIV" : "DIVU"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + + case 0xa8: case 0xe8: // DIVW is 16F, 16FX, 16LX only? + util::stream_format(stream, "%-8sA, ", BIT(op2, 6) ? "DIVW" : "DIVUW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + + default: + util::stream_format(stream, "%-8s0x%02X", ".DATA.B", segm != 0 ? segm : op1); + return 1 | SUPPORTED; + } + + return bytes | SUPPORTED; +} + +offs_t f2mc16_disassembler::disassemble(std::ostream &stream, offs_t pc, const f2mc16_disassembler::data_buffer &opcodes, const f2mc16_disassembler::data_buffer ¶ms) +{ + u8 op = opcodes.r8(pc); + u8 segm = 0; + u32 bytes = 1; + if ((op & 0xfc) == 0x04) + { + segm = op; + op = opcodes.r8(pc + 1); + ++bytes; + } + + if (op >= 0xf0) + { + util::stream_format(stream, "%-8s", s_bcc_ops[op & 0x0f]); + format_rel(stream, pc + bytes + 1, opcodes.r8(pc + bytes)); + ++bytes; + } + else if (op >= 0xe0) + { + util::stream_format(stream, "%-8s#%d", "CALLV", op & 0x0f); + return bytes | STEP_OVER | SUPPORTED; + } + else if (op >= 0xd0) + { + util::stream_format(stream, "%-8sA, ", "MOVN"); + format_imm4(stream, op & 0x0f); + } + else if (op >= 0xc8) + { + util::stream_format(stream, "%-8s", "MOVW"); + format_rwdisp8(stream, op & 0x07, segm, opcodes.r8(pc + bytes++)); + stream << ", A"; + } + else if (op >= 0xc0) + { + util::stream_format(stream, "%-8sA, ", "MOVX"); + format_rwdisp8(stream, op & 0x07, segm, opcodes.r8(pc + bytes++)); + } + else if (op >= 0xb8) + { + util::stream_format(stream, "%-8sA, ", "MOVW"); + format_rwdisp8(stream, op & 0x07, segm, opcodes.r8(pc + bytes++)); + } + else if (op >= 0xb0) + util::stream_format(stream, "%-8sA, R%d", "MOVX", op & 0x07); + else if (op >= 0xa8) + { + util::stream_format(stream, "%-8sRW%d, ", "MOVW", op & 0x07); + format_imm16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + } + else if (op >= 0xa0) + { + util::stream_format(stream, "%-8sR%d, ", "MOV", op & 0x07); + format_imm8(stream, opcodes.r8(pc + bytes++)); + } + else if (op >= 0x98) + util::stream_format(stream, "%-8sRW%d, A", "MOVW", op & 0x07); + else if (op >= 0x90) + util::stream_format(stream, "%-8sR%d, A", "MOV", op & 0x07); + else if (op >= 0x88) + util::stream_format(stream, "%-8sA, RW%d", "MOVW", op & 0x07); + else if (op >= 0x80) + util::stream_format(stream, "%-8sA, R%d", "MOV", op & 0x07); + else switch (op) + { + case 0x00: + stream << "NOP"; + break; + + case 0x01: + stream << "INT9"; + return bytes | STEP_OVER | SUPPORTED; + + case 0x02: + util::stream_format(stream, "%-8sA", "ADDDC"); + break; + + case 0x03: + util::stream_format(stream, "%-8sA", "NEG"); + break; + + case 0x08: + util::stream_format(stream, "%-8s", "LINK"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x09: + stream << "UNLINK"; + break; + + case 0x0a: + util::stream_format(stream, "%-8sRP, ", "MOV"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x0b: + util::stream_format(stream, "%-8sA", "NEGW"); + break; + + case 0x0c: case 0x0e: case 0x0f: + util::stream_format(stream, "%-8sA", s_shift_ops[0][BIT(op, 0, 2)]); + break; + + case 0x0d: + stream << "INTE"; + return bytes | STEP_OVER | SUPPORTED; + + case 0x10: + stream << "CMR"; + break; + + case 0x11: + stream << "NCC"; + break; + + case 0x12: + util::stream_format(stream, "%-8sA", "SUBDC"); + break; + + case 0x13: + util::stream_format(stream, "%-8s@A", "JCTX"); + break; + + case 0x14: case 0x1c: + stream << "EXT"; + if (BIT(op, 3)) + stream << 'W'; + break; + + case 0x15: case 0x1d: + stream << "ZEXT"; + if (BIT(op, 3)) + stream << 'W'; + break; + + case 0x16: case 0x1e: + stream << "SWAP"; + if (BIT(op, 3)) + stream << 'W'; + break; + + case 0x17: case 0x1f: + util::stream_format(stream, "%-8s", "ADDSP"); + if (BIT(op, 3)) + { + format_imm_signed(stream, s32(s16(opcodes.r16(pc + bytes)))); + bytes += 2; + } + else + format_imm_signed(stream, s32(s8(opcodes.r8(pc + bytes++)))); + break; + + case 0x18: + util::stream_format(stream, "%-8sA, ", "ADDL"); + format_imm_signed(stream, s32(opcodes.r32(pc + bytes))); + bytes += 4; + break; + + case 0x19: + util::stream_format(stream, "%-8sA, ", "SUBL"); + format_imm_signed(stream, s32(opcodes.r32(pc + bytes))); + bytes += 4; + break; + + case 0x1a: + util::stream_format(stream, "%-8sILM, ", "MOV"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x1b: + util::stream_format(stream, "%-8sA, ", "CMPL"); + format_imm_signed(stream, s32(opcodes.r32(pc + bytes))); + bytes += 4; + break; + + case 0x20: case 0x30: + util::stream_format(stream, "%-8sA, ", "ADD"); + if (BIT(op, 4)) + format_imm_signed(stream, s32(s8(opcodes.r8(pc + bytes++)))); + else + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + break; + + case 0x21: case 0x31: + util::stream_format(stream, "%-8sA, ", "SUB"); + if (BIT(op, 4)) + format_imm_signed(stream, s32(s8(opcodes.r8(pc + bytes++)))); + else + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + break; + + case 0x22: + util::stream_format(stream, "%-8sA", "ADDC"); + break; + + case 0x23: case 0x33: + util::stream_format(stream, "%-8sA", "CMP"); + if (BIT(op, 4)) + { + stream << ", "; + format_imm_signed(stream, s32(s8(opcodes.r8(pc + bytes++)))); + } + break; + + case 0x24: + util::stream_format(stream, "%-8sCCR, ", "AND"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x25: + util::stream_format(stream, "%-8sCCR, ", "OR"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x26: + util::stream_format(stream, "%-8sA", "DIVU"); + break; + + case 0x27: + util::stream_format(stream, "%-8sA", "MULU"); + break; + + case 0x28: case 0x38: + util::stream_format(stream, "%-8sA", "ADDW"); + if (BIT(op, 4)) + { + stream << ", "; + format_imm_signed(stream, s32(s16(opcodes.r16(pc + bytes)))); + bytes += 2; + } + break; + + case 0x29: case 0x39: + util::stream_format(stream, "%-8sA", "SUBW"); + if (BIT(op, 4)) + { + stream << ", "; + format_imm_signed(stream, s32(s16(opcodes.r16(pc + bytes)))); + bytes += 2; + } + break; + + case 0x2a: + util::stream_format(stream, "%-8sA, ", "CBNE"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + stream << ", "; + format_rel(stream, pc + bytes + 1, opcodes.r8(pc + bytes)); + ++bytes; + break; + + case 0x2b: case 0x3b: + util::stream_format(stream, "%-8sA", "CMPW"); + if (BIT(op, 4)) + { + stream << ", "; + format_imm_signed(stream, s32(s16(opcodes.r16(pc + bytes)))); + bytes += 2; + } + break; + + case 0x2c: case 0x3c: + util::stream_format(stream, "%-8sA", "ANDW"); + if (BIT(op, 4)) + { + stream << ", "; + format_imm16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + } + break; + + case 0x2d: case 0x3d: + util::stream_format(stream, "%-8sA", "ORW"); + if (BIT(op, 4)) + { + stream << ", "; + format_imm16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + } + break; + + case 0x2e: case 0x3e: + util::stream_format(stream, "%-8sA", "XORW"); + if (BIT(op, 4)) + { + stream << ", "; + format_imm16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + } + break; + + case 0x2f: + util::stream_format(stream, "%-8sA", "MULUW"); + break; + + case 0x32: + util::stream_format(stream, "%-8sA", "SUBC"); + break; + + case 0x34: + util::stream_format(stream, "%-8sA, ", "AND"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x35: + util::stream_format(stream, "%-8sA, ", "OR"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x36: + util::stream_format(stream, "%-8sA, ", "XOR"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x37: + util::stream_format(stream, "%-8sA", "NOT"); + break; + + case 0x3a: + util::stream_format(stream, "%-8sA, ", "CWBNE"); + format_imm16(stream, opcodes.r16(pc + bytes)); + stream << ", "; + format_rel(stream, pc + bytes + 3, opcodes.r8(pc + bytes + 2)); + bytes += 3; + break; + + case 0x3f: + util::stream_format(stream, "%-8sA", "NOTW"); + break; + + case 0x40: case 0x50: + util::stream_format(stream, "%-8sA, ", "MOV"); + if (BIT(op, 4)) + format_io(stream, opcodes.r8(pc + bytes++)); + else + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + break; + + case 0x41: case 0x51: + util::stream_format(stream, "%-8s", "MOV"); + if (BIT(op, 4)) + format_io(stream, opcodes.r8(pc + bytes++)); + else + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + stream << ", A"; + break; + + case 0x42: + util::stream_format(stream, "%-8sA, ", "MOV"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x43: + util::stream_format(stream, "%-8sA, ", "MOVX"); + format_imm_signed(stream, s32(s8(opcodes.r8(pc + bytes++)))); + break; + + case 0x44: case 0x54: + util::stream_format(stream, "%-8s", "MOV"); + if (BIT(op, 4)) + format_io(stream, opcodes.r8(pc + bytes++)); + else + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + stream << ", "; + format_imm8(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x45: case 0x55: + util::stream_format(stream, "%-8sA, ", "MOVX"); + if (BIT(op, 4)) + format_io(stream, opcodes.r8(pc + bytes++)); + else + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + break; + + case 0x46: + util::stream_format(stream, "%-8sA, SP", "MOVW"); + break; + + case 0x47: + util::stream_format(stream, "%-8sSP, A", "MOVW"); + break; + + case 0x48: case 0x58: + util::stream_format(stream, "%-8sA, ", "MOVW"); + if (BIT(op, 4)) + format_io(stream, opcodes.r8(pc + bytes++)); + else + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + break; + + case 0x49: case 0x59: + util::stream_format(stream, "%-8s", "MOVW"); + format_dir(stream, segm, opcodes.r8(pc + bytes++)); + stream << ", A"; + break; + + case 0x4a: + util::stream_format(stream, "%-8sA, ", "MOVW"); + format_imm16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + break; + + case 0x4b: + util::stream_format(stream, "%-8sA, ", "MOVL"); + format_imm32(stream, opcodes.r32(pc + bytes)); + bytes += 4; + break; + + case 0x4c: case 0x4d: + util::stream_format(stream, "%-8sA", "PUSHW"); + if (BIT(op, 0)) + stream << 'H'; + break; + + case 0x4e: + util::stream_format(stream, "%-8sPS", "PUSHW"); + break; + + case 0x4f: + util::stream_format(stream, "%-8s", "PUSHW"); + format_rlist(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x52: case 0x5a: + util::stream_format(stream, "%-8sA, ", BIT(op, 3) ? "MOVW" : "MOV"); + format_addr16(stream, segm, opcodes.r16(pc + bytes)); + bytes += 2; + break; + + case 0x53: case 0x5b: + util::stream_format(stream, "%-8s", BIT(op, 3) ? "MOVW" : "MOV"); + format_addr16(stream, segm, opcodes.r16(pc + bytes)); + stream << ", A"; + bytes += 2; + break; + + case 0x56: + util::stream_format(stream, "%-8s", "MOVW"); + format_io(stream, opcodes.r8(pc + bytes++)); + stream << ", "; + format_imm16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + break; + + case 0x57: + util::stream_format(stream, "%-8sA, ", "MOVX"); + format_addr16(stream, segm, opcodes.r16(pc + bytes)); + bytes += 2; + break; + + case 0x5c: case 0x5d: + util::stream_format(stream, "%-8sA", "POPW"); + if (BIT(op, 0)) + stream << 'H'; + break; + + case 0x5e: + util::stream_format(stream, "%-8sPS", "POPW"); + break; + + case 0x5f: + util::stream_format(stream, "%-8s", "POPW"); + format_rlist(stream, opcodes.r8(pc + bytes++)); + break; + + case 0x60: + util::stream_format(stream, "%-8s", "BRA"); + format_rel(stream, pc + bytes + 1, opcodes.r8(pc + bytes)); + ++bytes; + break; + + case 0x61: + util::stream_format(stream, "%-8s@A", "JMP"); + break; + + case 0x62: + util::stream_format(stream, "%-8s", "JMP"); + format_dst16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + break; + + case 0x63: + util::stream_format(stream, "%-8s", "JMPP"); + format_addr24(stream, opcodes.r16(pc + bytes) | u32(opcodes.r8(pc + bytes + 2)) << 16); + bytes += 3; + break; + + case 0x64: + util::stream_format(stream, "%-8s", "CALL"); + format_dst16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + return bytes | STEP_OVER | SUPPORTED; + + case 0x65: + util::stream_format(stream, "%-8s", "CALLP"); + format_addr24(stream, opcodes.r16(pc + bytes) | u32(opcodes.r8(pc + bytes + 2)) << 16); + bytes += 3; + return bytes | STEP_OVER | SUPPORTED; + + case 0x66: case 0x67: + stream << "RET"; + if (!BIT(op, 0)) + stream << 'P'; + return bytes | STEP_OUT | SUPPORTED; + + case 0x68: + util::stream_format(stream, "%-8s", "INT"); + format_imm8(stream, opcodes.r8(pc + bytes++)); + return bytes | STEP_OVER | SUPPORTED; + + case 0x69: + util::stream_format(stream, "%-8s", "INT"); + format_dst16(stream, opcodes.r16(pc + bytes)); + bytes += 2; + return bytes | STEP_OVER | SUPPORTED; + + case 0x6a: + util::stream_format(stream, "%-8s", "INTP"); + format_addr24(stream, opcodes.r16(pc + bytes) | u32(opcodes.r8(pc + bytes + 2)) << 16); + bytes += 3; + return bytes | STEP_OVER | SUPPORTED; + + case 0x6b: + stream << "RETI"; + return bytes | STEP_OUT | SUPPORTED; + + case 0x6c: + return dasm_bitop(stream, pc, bytes, segm, opcodes); + + case 0x6d: + return dasm_movm(stream, pc, bytes, segm, opcodes); + + case 0x6e: + return dasm_cstrop(stream, pc, bytes, segm, opcodes); + + case 0x6f: + return dasm_op6f(stream, pc, bytes, segm, opcodes); + + case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: case 0x78: + return dasm_eainst(stream, pc, bytes, op, segm, opcodes); + + case 0x79: + { + u8 op2 = opcodes.r8(pc + bytes++); + util::stream_format(stream, "%-8sRW%d, ", "MOVEA", BIT(op2, 5, 3)); + bytes += dasm_ea16(stream, pc + bytes, op2, 0, opcodes); + break; + } + + case 0x7a: case 0x7e: + { + u8 op2 = opcodes.r8(pc + bytes++); + util::stream_format(stream, "%-8sR%d, ", BIT(op, 2) ? "XCH" : "MOV", BIT(op2, 5, 3)); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + break; + } + + case 0x7b: case 0x7f: + { + u8 op2 = opcodes.r8(pc + bytes++); + util::stream_format(stream, "%-8sRW%d, ", BIT(op, 2) ? "XCHW" : "MOVW", BIT(op2, 5, 3)); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + break; + } + + case 0x7c: + { + u8 op2 = opcodes.r8(pc + bytes++); + util::stream_format(stream, "%-8s", "MOV"); + bytes += dasm_ea8(stream, pc + bytes, op2, segm, opcodes); + util::stream_format(stream, ", R%d", BIT(op2, 5, 3)); + break; + } + + case 0x7d: + { + u8 op2 = opcodes.r8(pc + bytes++); + util::stream_format(stream, "%-8s", "MOVW"); + bytes += dasm_ea16(stream, pc + bytes, op2, segm, opcodes); + util::stream_format(stream, ", RW%d", BIT(op2, 5, 3)); + break; + } + + default: + util::stream_format(stream, "%-8s0x%02X", ".DATA.B", segm != 0 ? segm : op); + return 1 | SUPPORTED; + } + + return bytes | SUPPORTED; +} diff --git a/src/devices/cpu/f2mc16/f2mc16d.h b/src/devices/cpu/f2mc16/f2mc16d.h new file mode 100644 index 00000000000..10aa6595235 --- /dev/null +++ b/src/devices/cpu/f2mc16/f2mc16d.h @@ -0,0 +1,62 @@ +// license:BSD-3-Clause +// copyright-holders:AJR + +#ifndef MAME_CPU_F2MC16_F2MC16D_H +#define MAME_CPU_F2MC16_F2MC16D_H + +#pragma once + +class f2mc16_disassembler : public util::disasm_interface +{ +public: + f2mc16_disassembler(); + +protected: + // disasm_interface overrides + virtual offs_t opcode_alignment() const override; + virtual u32 interface_flags() const override; + virtual u32 page_address_bits() const override; + virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms) override; + +private: + // mnemonic tables + static const std::string_view s_segment_prefixes[4]; + static const std::string_view s_segment_registers[6]; + static const std::string_view s_bit_ops[8]; + static const std::string_view s_movs_ops[4]; + static const std::string_view s_sceq_ops[4]; + static const std::string_view s_shift_ops[3][4]; + static const std::string_view s_movp_ops[4]; + static const std::string_view s_bcc_ops[16]; + + // formatting helpers + void format_imm4(std::ostream &stream, u8 x); + void format_imm8(std::ostream &stream, u8 x); + void format_imm16(std::ostream &stream, u16 x); + void format_imm32(std::ostream &stream, u32 x); + void format_imm_signed(std::ostream &stream, s32 x); + void format_dir(std::ostream &stream, u8 segm, u8 addr); + void format_io(std::ostream &stream, u8 addr); + void format_addr16(std::ostream &stream, u8 segm, u16 addr); + void format_dst16(std::ostream &stream, u16 addr); + void format_addr24(std::ostream &stream, u32 addr); + void format_rel(std::ostream &stream, offs_t pc, s8 disp); + void format_rwdisp8(std::ostream &stream, u8 r, u8 segm, s8 disp); + void format_rwdisp16(std::ostream &stream, u8 r, u8 segm, u16 disp); + void format_rldisp8(std::ostream &stream, u8 r, s8 disp); + void format_spdisp8(std::ostream &stream, s8 disp); + void format_pcdisp16(std::ostream &stream, s16 disp); + void format_rlist(std::ostream &stream, u8 rlst); + + // disassembly helpers + u32 dasm_ea8(std::ostream &stream, offs_t pc, u8 op2, u8 segm, const data_buffer &opcodes); + u32 dasm_ea16(std::ostream &stream, offs_t pc, u8 op2, u8 segm, const data_buffer &opcodes); + u32 dasm_ea32(std::ostream &stream, offs_t pc, u8 op2, u8 segm, const data_buffer &opcodes); + offs_t dasm_bitop(std::ostream &stream, offs_t pc, u32 bytes, u8 segm, const data_buffer &opcodes); + offs_t dasm_movm(std::ostream &stream, offs_t pc, u32 bytes, u8 segm, const data_buffer &opcodes); + offs_t dasm_cstrop(std::ostream &stream, offs_t pc, u32 bytes, u8 segm, const data_buffer &opcodes); + offs_t dasm_op6f(std::ostream &stream, offs_t pc, u32 bytes, u8 segm, const data_buffer &opcodes); + offs_t dasm_eainst(std::ostream &stream, offs_t pc, u32 bytes, u8 op1, u8 segm, const data_buffer &opcodes); +}; + +#endif // MAME_CPU_F2MC16_F2MC16D_H diff --git a/src/devices/cpu/f2mc16/f2mc16dasm.cpp b/src/devices/cpu/f2mc16/f2mc16dasm.cpp deleted file mode 100644 index 9fdac5b2419..00000000000 --- a/src/devices/cpu/f2mc16/f2mc16dasm.cpp +++ /dev/null @@ -1,2168 +0,0 @@ -// license:BSD-3-Clause -// copyright-holders:R. Belmont -/*************************************************************************** - - Fujitsu Micro F2MC-16 series disassembler - -***************************************************************************/ - -#include "emu.h" -#include "util/disasmintf.h" -#include "f2mc16dasm.h" - -#include "util/strformat.h" - -using osd::u32; -using util::BIT; -using offs_t = u32; - -u32 f2mc16_disassembler::opcode_alignment() const -{ - return 1; -} - -void f2mc16_disassembler::branch_helper(std::ostream &stream, const char *insName, u16 PC, s8 offset) -{ - util::stream_format(stream, "%s $%04X", insName, PC+offset); -} - -offs_t f2mc16_disassembler::ea_form1_helper(std::ostream &stream, const char *opName, u16 pc, u8 operand, u16 imm16, bool bAIsDest) -{ - offs_t bytes = 2; - - switch (operand & 0xf) - { - case 0x0: case 0x1: case 0x2: case 0x3: case 0x4: case 0x5: case 0x6: case 0x7: - if (bAIsDest) - { - util::stream_format(stream, "%s A, @RW%d + #$%02x", opName, (operand & 0x7), imm16&0xff); - } - else - { - util::stream_format(stream, "%s @RW%d + #$%02x, A", opName, (operand & 0x7), imm16&0xff); - } - bytes = 3; - break; - - case 0x8: case 0x9: case 0xa: case 0xb: - if (bAIsDest) - { - util::stream_format(stream, "%s A, @RW%d + #$%04x", opName, (operand & 0x3), imm16); - } - else - { - util::stream_format(stream, "%s @RW%d + #$%04x, A", opName, (operand & 0x3), imm16); - } - bytes = 4; - break; - - case 0xc: case 0xd: - if (bAIsDest) - { - util::stream_format(stream, "%s A, @RW%d + RW7", opName, (operand & 0x1)); - } - else - { - util::stream_format(stream, "%s @RW%d + RW7, A", opName, (operand & 0x1)); - } - bytes = 2; - break; - - case 0xe: - if (bAIsDest) - { - util::stream_format(stream, "%s A, @PC + #$04x ($%04X)", opName, imm16, (s16)imm16 + (pc & 0xffff)); - } - else - { - util::stream_format(stream, "%s @PC + #$04x ($%04X), A", opName, imm16, (s16)imm16 + (pc & 0xffff)); - } - bytes = 4; - break; - - case 0xf: - if (bAIsDest) - { - util::stream_format(stream, "%s A, $%04x", opName, imm16); - } - else - { - util::stream_format(stream, "%s $%04x, A", opName, imm16); - } - bytes = 4; - break; - } - - return bytes; -} - -offs_t f2mc16_disassembler::ea_form1_helper_noA(std::ostream &stream, const char *opName, u16 pc, u8 operand, u16 imm16) -{ - offs_t bytes = 2; - - switch (operand & 0xf) - { - case 0x0: case 0x1: case 0x2: case 0x3: case 0x4: case 0x5: case 0x6: case 0x7: - util::stream_format(stream, "%s @RW%d + #$%02x", opName, (operand & 0x7), imm16&0xff); - bytes = 3; - break; - - case 0x8: case 0x9: case 0xa: case 0xb: - util::stream_format(stream, "%s@RW%d + #$%04x", opName, (operand & 0x3), imm16); - bytes = 4; - break; - - case 0xc: case 0xd: - util::stream_format(stream, "%s@RW%d + RW7", opName, (operand & 0x1)); - bytes = 2; - break; - - case 0xe: - util::stream_format(stream, "%s@PC + #$04x ($%04X)", opName, imm16, (s16)imm16 + (pc & 0xffff)); - bytes = 4; - break; - - case 0xf: - util::stream_format(stream, "%s$%04x", opName, imm16); - bytes = 4; - break; - } - - return bytes; -} - -offs_t f2mc16_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms) -{ - u8 opcode = opcodes.r8(pc); - u8 operand = opcodes.r8(pc+1); - offs_t bytes = 1; - - switch (opcode) - { - case 0x00: - stream << "NOP"; - break; - - case 0x01: - stream << "INT9"; - break; - - case 0x03: - util::stream_format(stream, "NEG A"); - break; - - case 0x04: - stream << "PCB "; - bytes = 1 + (disassemble(stream, pc + 1, opcodes, params) & LENGTHMASK); - break; - - case 0x05: - stream << "DTB "; - bytes = 1 + (disassemble(stream, pc + 1, opcodes, params) & LENGTHMASK); - break; - - case 0x06: - stream << "ADB "; - bytes = 1 + (disassemble(stream, pc + 1, opcodes, params) & LENGTHMASK); - break; - - case 0x07: - stream << "SPB "; - bytes = 1 + (disassemble(stream, pc + 1, opcodes, params) & LENGTHMASK); - break; - - case 0x08: - util::stream_format(stream, "LINK #$%02x", operand); - bytes = 2; - break; - - case 0x09: - stream << "UNLINK"; - break; - - case 0x0a: - util::stream_format(stream, "MOV RP, #$%02x", operand); - bytes = 2; - break; - - case 0x0b: - stream << "NEGW A"; - break; - - case 0x0c: - stream << "LSLW A"; - break; - - case 0x0e: - stream << "ASRW A"; - break; - - case 0x0f: - stream << "LSRW A"; - break; - - case 0x10: - stream << "CMR "; - bytes = 1 + (disassemble(stream, pc + 1, opcodes, params) & LENGTHMASK); - break; - - case 0x11: - stream << "NCC "; - bytes = 1 + (disassemble(stream, pc + 1, opcodes, params) & LENGTHMASK); - break; - - case 0x12: - stream << "SUBDC A"; - break; - - case 0x14: - stream << "EXT"; - break; - - case 0x15: - stream << "ZEXT"; - break; - - case 0x16: - stream << "SWAP"; - break; - - case 0x17: - util::stream_format(stream, "ADDSP #$%02x", operand); - bytes = 2; - break; - - case 0x18: - util::stream_format(stream, "ADDL A, #$%08x", opcodes.r16(pc+1) | (opcodes.r16(pc+3)<<16)); - bytes = 5; - break; - - case 0x19: - util::stream_format(stream, "SUBL A, #$%08x", opcodes.r16(pc+1) | (opcodes.r16(pc+3)<<16)); - bytes = 5; - break; - - case 0x1a: - util::stream_format(stream, "MOV ILM, #$%02x", operand); - bytes = 2; - break; - - case 0x1c: - stream << "EXTW"; - break; - - case 0x1d: - stream << "ZEXTW"; - break; - - case 0x1e: - stream << "SWAPW"; - break; - - case 0x20: - util::stream_format(stream, "ADD A, $%02x", operand); - bytes = 2; - break; - - case 0x21: - util::stream_format(stream, "SUB A, $%02x", operand); - bytes = 2; - break; - - case 0x22: - stream << "ADDC A"; - break; - - case 0x23: - stream << "CMP A"; - break; - - case 0x24: - util::stream_format(stream, "AND CCR, #$%02x", operand); - bytes = 2; - break; - - case 0x25: - util::stream_format(stream, "OR CCR, #$%02x", operand); - bytes = 2; - break; - - case 0x26: - stream << "DIVU A"; - break; - - case 0x27: - stream << "MULU A"; - break; - - case 0x28: - stream << "ADDW A"; - break; - - case 0x29: - stream << "SUBW A"; - break; - - case 0x2a: - util::stream_format(stream, "CBNE A, #$%02X, $%04X", operand, (s8)opcodes.r8(pc+2) + (pc & 0xffff) + 3); - bytes = 3; - break; - - case 0x2b: - stream << "CMPW A"; - break; - - case 0x2c: - stream << "ANDW A"; - break; - - case 0x2d: - stream << "ORW A"; - break; - - case 0x2e: - stream << "XORW A"; - break; - - case 0x2f: - stream << "MULUW A"; - break; - - case 0x30: - util::stream_format(stream, "ADD A, #$%02x", operand); - bytes = 2; - break; - - case 0x31: - util::stream_format(stream, "SUB A, #$%02x", operand); - bytes = 2; - break; - - case 0x32: - stream << "SUBC A"; - break; - - case 0x33: - util::stream_format(stream, "CMP A, #$%02x", operand); - bytes = 2; - break; - - case 0x34: - util::stream_format(stream, "AND A, #$%02x", operand); - bytes = 2; - break; - - case 0x35: - util::stream_format(stream, "OR A, #$%02x", operand); - bytes = 2; - break; - - case 0x36: - util::stream_format(stream, "XOR A, #$%02x", operand); - bytes = 2; - break; - - case 0x37: - stream << "NOT A"; - break; - - case 0x38: - util::stream_format(stream, "ADDW A, #$%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x39: - util::stream_format(stream, "SUBW A, #$%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x3a: - util::stream_format(stream, "CWBNE A, #$%04X, $%04X", opcodes.r16(pc+1), (s8)opcodes.r8(pc+3) + (pc & 0xffff) + 4); - bytes = 4; - break; - - case 0x3b: - util::stream_format(stream, "CMPW A, #$%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x3c: - util::stream_format(stream, "ANDW A, #$%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x3d: - util::stream_format(stream, "ORW A, #$%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x3e: - util::stream_format(stream, "XORW A, #$%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x3f: - stream << "NOTW A"; - break; - - case 0x40: - util::stream_format(stream, "MOV A, dir(%02x)", operand); - bytes = 2; - break; - - case 0x41: - util::stream_format(stream, "MOV dir(%02x), A", operand); - bytes = 2; - break; - - case 0x42: - util::stream_format(stream, "MOV A, #$%02x", operand); - bytes = 2; - break; - - case 0x43: - util::stream_format(stream, "MOVX A, #$%02x", operand); - bytes = 2; - break; - - case 0x44: - util::stream_format(stream, "MOV dir(%02x), #$%02x", operand, opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x46: - util::stream_format(stream, "MOVW A, SP"); - break; - - case 0x47: - util::stream_format(stream, "MOVW SP, A"); - break; - - case 0x48: - util::stream_format(stream, "MOVW A, dir(%02x)", operand); - bytes = 2; - break; - - case 0x49: - util::stream_format(stream, "MOVW dir(%02x), A", operand); - bytes = 2; - break; - - case 0x4a: - util::stream_format(stream, "MOVW A, #$%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x4b: - util::stream_format(stream, "MOVL A, #$%08x", opcodes.r32(pc+1)); - bytes = 5; - break; - - case 0x4c: - stream << "PUSHW A"; - break; - - case 0x4d: - stream << "PUSHW AH"; - break; - - case 0x4e: - stream << "PUSHW PS"; - break; - - case 0x4f: - util::stream_format(stream, "PUSHW "); - { - bool bComma = false; - for (int i = 0; i < 8; i++) - { - if (operand & (1<<i)) - { - if (bComma) - { - util::stream_format(stream, ", RW%d", i); - } - else - { - util::stream_format(stream, "RW%d", i); - bComma = true; - } - } - } - } - bytes = 2; - break; - - case 0x50: - util::stream_format(stream, "MOV A, $%02x", opcodes.r8(pc+1)); - bytes = 2; - break; - - case 0x51: - util::stream_format(stream, "MOV $%02x, A", opcodes.r8(pc+1)); - bytes = 2; - break; - - case 0x52: - util::stream_format(stream, "MOV A, $%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x53: - util::stream_format(stream, "MOV $%04x, A", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x54: - util::stream_format(stream, "MOV $%02x, #$%02x", opcodes.r8(pc+1), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x55: - util::stream_format(stream, "MOVX A, $%02x", opcodes.r8(pc+1)); - bytes = 2; - break; - - case 0x56: - util::stream_format(stream, "MOVW $%02x, #$%04x", opcodes.r8(pc+1), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x57: - util::stream_format(stream, "MOVX A, $%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x58: - util::stream_format(stream, "MOVW A, $%02x", opcodes.r8(pc+1)); - bytes = 2; - break; - - case 0x59: - util::stream_format(stream, "MOVW $%02x, A", opcodes.r8(pc+1)); - bytes = 2; - break; - - case 0x5a: - util::stream_format(stream, "MOVW A, $%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x5b: - util::stream_format(stream, "MOVW $%04x, A", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x5c: - stream << "POPW A"; - break; - - case 0x5d: - stream << "POPW AH"; - break; - - case 0x5e: - stream << "POPW PS"; - break; - - case 0x5f: - util::stream_format(stream, "POPW "); - { - bool bComma = false; - - for (int i = 7; i >= 0; i--) - { - if (operand & (1<<i)) - { - if (bComma) - { - util::stream_format(stream, ", RW%d", i); - } - else - { - util::stream_format(stream, "RW%d", i); - bComma = true; - } - } - } - } - bytes = 2; - break; - - case 0x60: branch_helper(stream, "BRA ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - - case 0x61: - stream << "JMP @A"; - break; - - case 0x62: - util::stream_format(stream, "JMP $%04x", opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0x63: - util::stream_format(stream, "JMPP $%06x", opcodes.r8(pc+3)<<16|opcodes.r8(pc+2)<<8|opcodes.r8(pc+1)); - bytes = 4; - break; - - case 0x64: - util::stream_format(stream, "CALL $%04x", opcodes.r16(pc+1)); - bytes = 3 | STEP_OVER; - break; - - case 0x65: - util::stream_format(stream, "CALLP $%06x", opcodes.r8(pc+3)<<16|opcodes.r8(pc+2)<<8|opcodes.r8(pc+1)); - bytes = 4 | STEP_OVER; - break; - - case 0x66: - util::stream_format(stream, "RETP"); - bytes |= STEP_OUT; - break; - - case 0x67: - stream << "RET"; - bytes |= STEP_OUT; - break; - - case 0x68: - util::stream_format(stream, "INT #$%02x", opcodes.r8(pc+1)); - bytes = 2 | STEP_OVER; - break; - - case 0x69: - util::stream_format(stream, "INT $%04x", opcodes.r16(pc+1)); - bytes = 3 | STEP_OVER; - break; - - case 0x6a: - util::stream_format(stream, "INTP $%06x", opcodes.r8(pc+3)<<16|opcodes.r8(pc+2)<<8|opcodes.r8(pc+1)); - bytes = 4 | STEP_OVER; - break; - - case 0x6b: - stream << "RETI"; - bytes |= STEP_OUT; - break; - - case 0x6c: // bit operations - switch (operand) - { - case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: - util::stream_format(stream, "MOVB A, $%02x:%d", opcodes.r8(pc+2), operand & 7); - bytes = 3; - break; - - case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: - util::stream_format(stream, "MOVB $%02x:%d, A", opcodes.r8(pc+2), operand & 7); - bytes = 3; - break; - - case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47: - util::stream_format(stream, "CLRB $%02x:%d", opcodes.r8(pc+2), operand & 7); - bytes = 3; - break; - - case 0x58: case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f: - util::stream_format(stream, "CLRB $%04x:%d", opcodes.r16(pc+2), operand & 7); - bytes = 4; - break; - - case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: - util::stream_format(stream, "SETB $%02x:%d", opcodes.r8(pc+2), operand & 7); - bytes = 3; - break; - - case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c: case 0x7d: case 0x7e: case 0x7f: - util::stream_format(stream, "SETB $%04x:%d", opcodes.r16(pc+2), operand & 7); - bytes = 4; - break; - - case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: - util::stream_format(stream, "BBC $%02x:%d, $%x", opcodes.r8(pc+2), operand & 7, pc+4+(s8)opcodes.r8(pc+3)); - bytes = 4; - break; - - case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f: - util::stream_format(stream, "BBC dir(%02x):%d, $%x", opcodes.r8(pc+2), operand & 7, pc+4+(s8)opcodes.r8(pc+3)); - bytes = 4; - break; - - case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f: - util::stream_format(stream, "BBC $%04x:%d, $%x", opcodes.r16(pc+2), operand & 7, pc+5+(s8)opcodes.r8(pc+4)); - bytes = 5; - break; - - case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: - util::stream_format(stream, "BBS $%02x:%d, $%x", opcodes.r8(pc+2), operand & 7, pc+4+(s8)opcodes.r8(pc+3)); - bytes = 4; - break; - - case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf: - util::stream_format(stream, "BBS dir(%02x):%d, $%x", opcodes.r8(pc+2), operand & 7, pc+4+(s8)opcodes.r8(pc+3)); - bytes = 4; - break; - - case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf: - util::stream_format(stream, "BBS $%04x:%d, $%x", opcodes.r16(pc+2), operand & 7, pc+5+(s8)opcodes.r8(pc+4)); - bytes = 5; - break; - - case 0xc0: case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: - util::stream_format(stream, "WBTS $%02x:%d", opcodes.r8(pc+2), operand & 7); - bytes = 3; - break; - - case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: - util::stream_format(stream, "WBTC $%02x:%d", opcodes.r8(pc+2), operand & 7); - bytes = 3; - break; - - default: - stream << "UNK 6C bit op"; - break; - } - break; - - case 0x6e: // string instructions - switch (operand) - { - case 0x09: - util::stream_format(stream, "MOVSI ADB, DTB"); - bytes = 2; - break; - - default: - stream << "UNK string op"; - break; - } - break; - - case 0x6f: // 2-byte instructions - switch (operand) - { - case 0x00: stream << "MOV A, DTB"; bytes = 2; break; - case 0x01: stream << "MOV A, ADB"; bytes = 2; break; - case 0x02: stream << "MOV A, SSB"; bytes = 2; break; - case 0x03: stream << "MOV A, USB"; bytes = 2; break; - case 0x04: stream << "MOV A, DPR"; bytes = 2; break; - - case 0x05: - util::stream_format(stream, "MOV A, @A"); - bytes = 2; - break; - - case 0x06: stream << "MOV A, PCB"; bytes = 2; break; - case 0x07: stream << "ROLC A"; bytes = 2; break; - - case 0x0c: - util::stream_format(stream, "LSLW A, R0"); - bytes = 2; - break; - - case 0x0d: - util::stream_format(stream, "MOVW A, @A"); - bytes = 2; - break; - - case 0x0e: - util::stream_format(stream, "ASRW A, R0"); - bytes = 2; - break; - - case 0x0f: - util::stream_format(stream, "LSRW A, R0"); - bytes = 2; - break; - - case 0x10: - util::stream_format(stream, "MOV DTB, A"); - bytes = 2; - break; - - case 0x11: - util::stream_format(stream, "MOV ADB, A"); - bytes = 2; - break; - - case 0x12: - util::stream_format(stream, "MOV SSB, A"); - bytes = 2; - break; - - case 0x13: - util::stream_format(stream, "MOV USB, A"); - bytes = 2; - break; - - case 0x14: - util::stream_format(stream, "MOV DPR, A"); - bytes = 2; - break; - - case 0x15: - util::stream_format(stream, "MOV @AL, AH"); - bytes = 2; - break; - - case 0x1c: - util::stream_format(stream, "LSLL A, R0"); - bytes = 2; - break; - - case 0x1d: - util::stream_format(stream, "MOVW @AL, AH"); - bytes = 2; - break; - - case 0x1e: - util::stream_format(stream, "ASRL A, R0"); - bytes = 2; - break; - - case 0x1f: - util::stream_format(stream, "LSRL A, R0"); - bytes = 2; - break; - - case 0x2c: - util::stream_format(stream, "LSL A, R0"); - bytes = 2; - break; - - case 0x2d: - util::stream_format(stream, "NRML A, R0"); - bytes = 2; - break; - - case 0x2e: - util::stream_format(stream, "ASR A, R0"); - bytes = 2; - break; - - case 0x2f: - util::stream_format(stream, "LSR A, R0"); - bytes = 2; - break; - - case 0x30: case 0x32: case 0x34: case 0x36: - util::stream_format(stream, "MOV @RL%d + #$%02x, A", ((operand>>1) & 0x3), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x38: case 0x3a: case 0x3c: case 0x3e: - util::stream_format(stream, "MOVW @RL%d + #$%02x, A", ((operand>>1) & 0x3), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x40: case 0x42: case 0x44: case 0x46: - util::stream_format(stream, "MOV A, @RL%d + #$%02x", ((operand>>1) & 0x3), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x48: case 0x4a: case 0x4c: case 0x4e: - util::stream_format(stream, "MOVW A, @RL%d + #$%02x", ((operand>>1) & 0x3), opcodes.r8(pc+2)); - bytes = 3; - break; - - default: - stream << "UNK 2-byte 6F"; - break; - } - break; - - case 0x70: // ea-type instructions - switch ((operand >> 4) & 0xf) - { - case 0x0: - switch (operand) - { - case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: - util::stream_format(stream, "ADDL A, RL%d", (operand & 0x6)>>1); - bytes = 2; - break; - - case 8: case 9: case 0xa: case 0xb: - util::stream_format(stream, "ADDL A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0xc: case 0xd: case 0xe: case 0xf: - util::stream_format(stream, "ADDL A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - } - break; - - case 0x1: bytes = ea_form1_helper(stream, "ADDL ", pc, operand, opcodes.r16(pc+2), true); break; - - case 0x2: - switch (operand & 0xf) - { - case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: - util::stream_format(stream, "SUBL A, RL%d", (operand & 0x6)>>1); - bytes = 2; - break; - - case 8: case 9: case 0xa: case 0xb: - util::stream_format(stream, "SUBL A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0xc: case 0xd: case 0xe: case 0xf: - util::stream_format(stream, "SUBL A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - } - break; - - case 0x3: bytes = ea_form1_helper(stream, "SUBL ", pc, operand, opcodes.r16(pc+2), true); break; - - case 0x6: - switch (operand & 0xf) - { - case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: - util::stream_format(stream, "CMPL A, RL%d", (operand & 0x6)>>1); - bytes = 2; - break; - - case 8: case 9: case 0xa: case 0xb: - util::stream_format(stream, "CMPL A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0xc: case 0xd: case 0xe: case 0xf: - util::stream_format(stream, "CMPL A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - } - break; - - case 0x7: bytes = ea_form1_helper(stream, "CMPL ", pc, operand, opcodes.r16(pc+2), true); break; - - case 0x8: - switch (operand & 0xf) - { - case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: - util::stream_format(stream, "ANDL A, RL%d", (operand & 0x6)>>1); - bytes = 2; - break; - - case 8: case 9: case 0xa: case 0xb: - util::stream_format(stream, "ANDL A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0xc: case 0xd: case 0xe: case 0xf: - util::stream_format(stream, "ANDL A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - } - break; - - case 0x9: bytes = ea_form1_helper(stream, "ANDL ", pc, operand, opcodes.r16(pc+2), true); break; - - case 0xa: - switch (operand & 0xf) - { - case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: - util::stream_format(stream, "ORL A, RL%d", (operand & 0x6)>>1); - bytes = 2; - break; - - case 8: case 9: case 0xa: case 0xb: - util::stream_format(stream, "ORL A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0xc: case 0xd: case 0xe: case 0xf: - util::stream_format(stream, "ORL A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - } - break; - - case 0xb: bytes = ea_form1_helper(stream, "ORL ", pc, operand, opcodes.r16(pc+2), true); break; - - case 0xc: - switch (operand & 0xf) - { - case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: - util::stream_format(stream, "XORL A, RL%d", (operand & 0x6)>>1); - bytes = 2; - break; - - case 8: case 9: case 0xa: case 0xb: - util::stream_format(stream, "XORL A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0xc: case 0xd: case 0xe: case 0xf: - util::stream_format(stream, "XORL A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - } - break; - - case 0xd: bytes = ea_form1_helper(stream, "XORL ", pc, operand, opcodes.r16(pc+2), true); break; - - default: - stream << "UNK ea-type 70"; - break; - } - break; - - case 0x71: // ea-type instructions - switch (operand) - { - case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: - util::stream_format(stream, "JMPP @RL%d", (operand & 0x6)>>1); - bytes = 2; - break; - - case 0x08: case 0x09: case 0x0a: case 0x0b: - util::stream_format(stream, "JMPP @@RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x0c: case 0x0d: case 0x0e: case 0x0f: - util::stream_format(stream, "JMPP @@RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: - case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f: - bytes = ea_form1_helper_noA(stream, "JMPP @", pc, operand, opcodes.r16(pc+2)); - break; - - case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: - util::stream_format(stream, "CALLP @RL%d", (operand & 0x6)>>1); - bytes = 2 | STEP_OVER; - break; - - case 0x28: case 0x29: case 0x2a: case 0x2b: - util::stream_format(stream, "CALLP @@RW%d", (operand & 0x3)); - bytes = 2 | STEP_OVER; - break; - - case 0x2c: case 0x2d: case 0x2e: case 0x2f: - util::stream_format(stream, "CALLP @@RW%d+", (operand & 0x3)); - bytes = 2 | STEP_OVER; - break; - - case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: - case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f: - bytes = ea_form1_helper_noA(stream, "CALLP @", pc, operand, opcodes.r16(pc+2)) | STEP_OVER; - break; - - case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47: - util::stream_format(stream, "INCL RL%d", ((operand>>1) & 0x3)); - bytes = 2; - break; - - case 0x48: case 0x49: case 0x4a: case 0x4b: - util::stream_format(stream, "INCL @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x4c: case 0x4d: case 0x4e: case 0x4f: - util::stream_format(stream, "INCL @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57: - util::stream_format(stream, "INCL @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x58: case 0x59: case 0x5a: case 0x5b: - util::stream_format(stream, "INCL @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x5c: case 0x5d: - util::stream_format(stream, "INCL @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x5e: - util::stream_format(stream, "INCL @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x5f: - util::stream_format(stream, "INCL $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: - util::stream_format(stream, "DECL RL%d", ((operand>>1) & 0x3)); - bytes = 2; - break; - - case 0x68: case 0x69: case 0x6a: case 0x6b: - util::stream_format(stream, "DECL @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x6c: case 0x6d: case 0x6e: case 0x6f: - util::stream_format(stream, "DECL @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: - util::stream_format(stream, "DECL @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x78: case 0x79: case 0x7a: case 0x7b: - util::stream_format(stream, "DECL @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x7c: case 0x7d: - util::stream_format(stream, "DECL @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x7e: - util::stream_format(stream, "DECL @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x7f: - util::stream_format(stream, "DECL $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: - util::stream_format(stream, "MOVL A, RL%d", (operand & 0x6)>>1); - bytes = 2; - break; - - case 0x88: case 0x89: case 0x8a: case 0x8b: - util::stream_format(stream, "MOVL A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x8c: case 0x8d: case 0x8e: case 0x8f: - util::stream_format(stream, "MOVL A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97: - util::stream_format(stream, "MOVL A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x98: case 0x99: case 0x9a: case 0x9b: - util::stream_format(stream, "MOVL A, @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x9c: case 0x9d: - util::stream_format(stream, "MOVL A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x9e: - util::stream_format(stream, "MOVL A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x9f: - util::stream_format(stream, "MOVL A, $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: - util::stream_format(stream, "MOVL RL%d, A", (operand & 0x6)>>1); - bytes = 2; - break; - - case 0xa8: case 0xa9: case 0xaa: case 0xab: - util::stream_format(stream, "MOVL @RW%d, A", (operand & 0x3)); - bytes = 2; - break; - - case 0xac: case 0xad: case 0xae: case 0xaf: - util::stream_format(stream, "MOVL @RW%d+, A", (operand & 0x3)); - bytes = 2; - break; - - case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: - util::stream_format(stream, "MOVL @RW%d + #$%02x, A", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xb8: case 0xb9: case 0xba: case 0xbb: - util::stream_format(stream, "MOVL @RW%d + #$%04x, A", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xbc: case 0xbd: - util::stream_format(stream, "MOVL @RW%d + RW7, A", (operand & 0x1)); - bytes = 2; - break; - - case 0xbe: - util::stream_format(stream, "MOVL @PC + #$04x ($%04X), A", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0xbf: - util::stream_format(stream, "MOVL $%04x, A", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xc0: case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: - util::stream_format(stream, "MOV R%d, #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xc8: case 0xc9: case 0xca: case 0xcb: - util::stream_format(stream, "MOV @RW%d, #$%02x", (operand & 0x3), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xcc: case 0xcd: case 0xce: case 0xcf: - util::stream_format(stream, "MOV @RW%d+, #$%02x", (operand & 0x3), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xd0: case 0xd1: case 0xd2: case 0xd3: case 0xd4: case 0xd5: case 0xd6: case 0xd7: - util::stream_format(stream, "MOV @RW%d + #$%02x, #$%02x", (operand & 0x7), opcodes.r8(pc+2), opcodes.r8(pc+3)); - bytes = 4; - break; - - case 0xd8: case 0xd9: case 0xda: case 0xdb: - util::stream_format(stream, "MOV @RW%d + #$%04x, #$%02x", (operand & 0x3), opcodes.r16(pc+2), opcodes.r8(pc+4)); - bytes = 5; - break; - - case 0xdc: case 0xdd: - util::stream_format(stream, "MOV @RW%d+RW7, #$%02x", (operand & 0x1), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xde: - util::stream_format(stream, "MOV @PC + #$04x ($%04X), #$%02x", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff), opcodes.r8(pc+4)); - bytes = 5; - break; - - case 0xdf: - util::stream_format(stream, "MOV $%04x, #$%02x", opcodes.r16(pc+2), opcodes.r8(pc+4)); - bytes = 5; - break; - - case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: - util::stream_format(stream, "MOVEA A, RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0xe8: case 0xe9: case 0xea: case 0xeb: - util::stream_format(stream, "MOVEA A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0xec: case 0xed: case 0xee: case 0xef: - util::stream_format(stream, "MOVEA A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7: - util::stream_format(stream, "MOVEA A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xf8: case 0xf9: case 0xfa: case 0xfb: - util::stream_format(stream, "MOVEA A, @RW%d + #$%04x", (operand & 0x3), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xfc: case 0xfd: - util::stream_format(stream, "MOVEA A, @RW%d+RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0xfe: - util::stream_format(stream, "MOVEA A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0xff: - util::stream_format(stream, "MOVEA A, $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - default: - stream << "UNK ea-type 71"; - break; - } - break; - - case 0x72: // ea-type instructions - switch (operand) - { - case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: - util::stream_format(stream, "ROLC R%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x08: case 0x09: case 0x0a: case 0x0b: - util::stream_format(stream, "ROLC @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x0c: case 0x0d: case 0x0e: case 0x0f: - util::stream_format(stream, "ROLC @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: - util::stream_format(stream, "ROLC @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x18: case 0x19: case 0x1a: case 0x1b: - util::stream_format(stream, "ROLC @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x1c: case 0x1d: - util::stream_format(stream, "ROLC @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x1e: - util::stream_format(stream, "ROLC @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x1f: - util::stream_format(stream, "ROLC $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: - util::stream_format(stream, "RORC R%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x28: case 0x29: case 0x2a: case 0x2b: - util::stream_format(stream, "RORC @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x2c: case 0x2d: case 0x2e: case 0x2f: - util::stream_format(stream, "RORC @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: - util::stream_format(stream, "RORC @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x38: case 0x39: case 0x3a: case 0x3b: - util::stream_format(stream, "RORC @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x3c: case 0x3d: - util::stream_format(stream, "RORC @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x3e: - util::stream_format(stream, "RORC @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x3f: - util::stream_format(stream, "RORC $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47: - util::stream_format(stream, "INC R%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x48: case 0x49: case 0x4a: case 0x4b: - util::stream_format(stream, "INC @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x4c: case 0x4d: case 0x4e: case 0x4f: - util::stream_format(stream, "INC @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57: - util::stream_format(stream, "INC @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x58: case 0x59: case 0x5a: case 0x5b: - util::stream_format(stream, "INC @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x5c: case 0x5d: - util::stream_format(stream, "INC @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x5e: - util::stream_format(stream, "INC @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x5f: - util::stream_format(stream, "INC $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: - util::stream_format(stream, "DEC R%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x68: case 0x69: case 0x6a: case 0x6b: - util::stream_format(stream, "DEC @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x6c: case 0x6d: case 0x6e: case 0x6f: - util::stream_format(stream, "DEC @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: - util::stream_format(stream, "DEC @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x78: case 0x79: case 0x7a: case 0x7b: - util::stream_format(stream, "DEC @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x7c: case 0x7d: - util::stream_format(stream, "DEC @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x7e: - util::stream_format(stream, "DEC @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x7f: - util::stream_format(stream, "DEC $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: - util::stream_format(stream, "MOV A, R%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x88: case 0x89: case 0x8a: case 0x8b: - util::stream_format(stream, "MOV A, @RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x8c: case 0x8d: case 0x8e: case 0x8f: - util::stream_format(stream, "MOV A, @RW%d+", (operand & 0x7)); - bytes = 2; - break; - - case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97: - util::stream_format(stream, "MOV A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x98: case 0x99: case 0x9a: case 0x9b: - util::stream_format(stream, "MOV A, @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x9c: case 0x9d: - util::stream_format(stream, "MOV A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x9e: - util::stream_format(stream, "MOV A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x9f: - util::stream_format(stream, "MOV A, $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: - util::stream_format(stream, "MOV R%d, A", (operand & 0x7)); - bytes = 2; - break; - - case 0xa8: case 0xa9: case 0xaa: case 0xab: - util::stream_format(stream, "MOV @RW%d, A", (operand & 0x7)); - bytes = 2; - break; - - case 0xac: case 0xad: case 0xae: case 0xaf: - util::stream_format(stream, "MOV @RW%d+, A", (operand & 0x7)); - bytes = 2; - break; - - case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: - util::stream_format(stream, "MOV @RW%d + #$%02x, A", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xb8: case 0xb9: case 0xba: case 0xbb: - util::stream_format(stream, "MOV @RW%d + #$%04x, A", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xbc: case 0xbd: - util::stream_format(stream, "MOV @RW%d + RW7, A", (operand & 0x1)); - bytes = 2; - break; - - case 0xbe: - util::stream_format(stream, "MOV @PC + #$04x ($%04X), A", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0xbf: - util::stream_format(stream, "MOV A, $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xc0: case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: - util::stream_format(stream, "MOVX A, R%d", (operand & 0x7)); - bytes = 2; - break; - - case 0xc8: case 0xc9: case 0xca: case 0xcb: - util::stream_format(stream, "MOVX A, @RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0xcc: case 0xcd: case 0xce: case 0xcf: - util::stream_format(stream, "MOVX A, @RW%d+", (operand & 0x7)); - bytes = 2; - break; - - case 0xd0: case 0xd1: case 0xd2: case 0xd3: case 0xd4: case 0xd5: case 0xd6: case 0xd7: - util::stream_format(stream, "MOVX A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xd8: case 0xd9: case 0xda: case 0xdb: - util::stream_format(stream, "MOVX A, @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xdc: case 0xdd: - util::stream_format(stream, "MOVX A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0xde: - util::stream_format(stream, "MOVX A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0xdf: - util::stream_format(stream, "MOVX A, $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: - util::stream_format(stream, "XCH A, R%d", (operand & 0x7)); - bytes = 2; - break; - - case 0xe8: case 0xe9: case 0xea: case 0xeb: - util::stream_format(stream, "XCH A, @RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0xec: case 0xed: case 0xee: case 0xef: - util::stream_format(stream, "XCH A, @RW%d+", (operand & 0x7)); - bytes = 2; - break; - - case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7: - util::stream_format(stream, "XCH A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xf8: case 0xf9: case 0xfa: case 0xfb: - util::stream_format(stream, "XCH A, @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xfc: case 0xfd: - util::stream_format(stream, "XCH A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0xfe: - util::stream_format(stream, "XCH A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0xff: - util::stream_format(stream, "XCH A, $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - default: - stream << "UNK ea-type 72"; - break; - } - break; - - case 0x73: // ea-type instructions - switch (operand) - { - case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47: - util::stream_format(stream, "INCW RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x48: case 0x49: case 0x4a: case 0x4b: - util::stream_format(stream, "INCW @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x4c: case 0x4d: case 0x4e: case 0x4f: - util::stream_format(stream, "INCW @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57: - util::stream_format(stream, "INCW @RW%d + #$%02x, A", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x58: case 0x59: case 0x5a: case 0x5b: - util::stream_format(stream, "INCW @RW%d + #$%04x, A", (operand & 0x3), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x5c: case 0x5d: - util::stream_format(stream, "INCW A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x5e: - util::stream_format(stream, "INCW A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x5f: - util::stream_format(stream, "INCW $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: - util::stream_format(stream, "DECW @RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x68: case 0x69: case 0x6a: case 0x6b: - util::stream_format(stream, "DECW @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x6c: case 0x6d: case 0x6e: case 0x6f: - util::stream_format(stream, "DECW @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: - util::stream_format(stream, "DECW @RW%d + #$%02x, A", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x78: case 0x79: case 0x7a: case 0x7b: - util::stream_format(stream, "DECW @RW%d + #$%04x, A", (operand & 0x3), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x7c: case 0x7d: - util::stream_format(stream, "DECW A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x7e: - util::stream_format(stream, "DECW A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x7f: - util::stream_format(stream, "DECW $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x88: case 0x89: case 0x8a: case 0x8b: - util::stream_format(stream, "MOVW A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x8c: case 0x8d: case 0x8e: case 0x8f: - util::stream_format(stream, "MOVW A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97: - util::stream_format(stream, "MOVW @RW%d + #$%02x, A", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f: - util::stream_format(stream, "MOVW @RW%d + #$%04x, A", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xa8: case 0xa9: case 0xaa: case 0xab: - util::stream_format(stream, "MOVW @RW%d, A", (operand & 0x3)); - bytes = 2; - break; - - case 0xac: case 0xad: case 0xae: case 0xaf: - util::stream_format(stream, "MOVW @RW%d+, A", (operand & 0x3)); - bytes = 2; - break; - - case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: - case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf: - bytes = ea_form1_helper(stream, "MOVW ", pc, operand, opcodes.r16(pc+2), false); - break; - - case 0xc8: case 0xc9: case 0xca: case 0xcb: - util::stream_format(stream, "MOVW @RW%d, #$%04x", (operand & 0x3), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xcc: case 0xcd: case 0xce: case 0xcf: - util::stream_format(stream, "MOVW @RW%d+, #$%04x", (operand & 0x3), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xd0: case 0xd1: case 0xd2: case 0xd3: case 0xd4: case 0xd5: case 0xd6: case 0xd7: - util::stream_format(stream, "MOVW @RW%d + #$%02x, $%04x", (operand & 0x7), opcodes.r8(pc+2), opcodes.r16(pc+3)); - bytes = 5; - break; - - case 0xd8: case 0xd9: case 0xda: case 0xdb: - util::stream_format(stream, "MOVW @RW%d + #$%04x, $%04x", (operand & 0x7), opcodes.r16(pc+2), opcodes.r16(pc+4)); - bytes = 6; - break; - - case 0xdc: case 0xdd: - util::stream_format(stream, "MOVW @RW%d + RW7, $%04x", (operand & 0x1), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xde: - util::stream_format(stream, "MOVW @PC + #$04x, $%04x", opcodes.r16(pc+2), opcodes.r16(pc+4)); - bytes = 6; - break; - - case 0xdf: - util::stream_format(stream, "MOVW $%04x, #$%04x", opcodes.r16(pc+2), opcodes.r16(pc+4)); - bytes = 6; - break; - - default: - stream << "UNK ea-type 73"; - break; - } - break; - - case 0x74: // ea-type instructions - switch (operand) - { - case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: - util::stream_format(stream, "CMP A, R%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x57: - util::stream_format(stream, "CMP A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x78: case 0x79: case 0x7a: case 0x7b: - util::stream_format(stream, "CMP A, @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x7c: case 0x7d: - util::stream_format(stream, "CMP A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x7e: - util::stream_format(stream, "CMP A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x7f: - util::stream_format(stream, "CMP A, $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: - util::stream_format(stream, "OR A, R%d", (operand & 7)); - bytes = 2; - break; - - case 0xa8: case 0xa9: case 0xaa: case 0xab: - util::stream_format(stream, "OR A, @R%d", (operand & 7)); - bytes = 2; - break; - - case 0xac: case 0xad: case 0xae: case 0xaf: - util::stream_format(stream, "OR A, @R%d+", (operand & 7)); - bytes = 2; - break; - - case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: - util::stream_format(stream, "DBNZ R%d, $%04x", (operand & 0x7), (s8)opcodes.r8(pc+2) + (pc & 0xffff) + 3); - bytes = 3; - break; - - default: - stream << "UNK ea-type 74"; - break; - } - break; - - case 0x75: // ea-type instructions - switch (operand) - { - case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: - util::stream_format(stream, "ADD R%d, A", (operand & 7)); - bytes = 2; - break; - - case 0x08: case 0x09: case 0x0a: case 0x0b: - util::stream_format(stream, "ADD @RW%d, A", (operand & 3)); - bytes = 2; - break; - - case 0x0c: case 0x0d: case 0x0e: case 0x0f: - util::stream_format(stream, "ADD @RW%d+, A", (operand & 3)); - bytes = 2; - break; - - case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: - util::stream_format(stream, "SUB R%d, A", (operand & 7)); - bytes = 2; - break; - - default: - stream << "UNK ea-type 75"; - break; - } - break; - - case 0x76: // ea-type instructions - switch (operand) - { - case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07: - util::stream_format(stream, "ADDW A, RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x08: case 0x09: case 0x0a: case 0x0b: - util::stream_format(stream, "ADDW A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x0c: case 0x0d: case 0x0e: case 0x0f: - util::stream_format(stream, "ADDW A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: - util::stream_format(stream, "ADDW A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x18: case 0x19: case 0x1a: case 0x1b: - util::stream_format(stream, "ADDW A, @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x1c: case 0x1d: - util::stream_format(stream, "ADDW A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x1e: - util::stream_format(stream, "ADDW A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x1f: - util::stream_format(stream, "ADDW $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: - util::stream_format(stream, "SUBW A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x38: case 0x39: case 0x3a: case 0x3b: - util::stream_format(stream, "SUBW A, @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x3c: case 0x3d: - util::stream_format(stream, "SUBW A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x3e: - util::stream_format(stream, "SUBW A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x3f: - util::stream_format(stream, "SUBW $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: - util::stream_format(stream, "CMPW A, RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x68: case 0x69: case 0x6a: case 0x6b: - util::stream_format(stream, "CMPW A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x6c: case 0x6d: case 0x6e: case 0x6f: - util::stream_format(stream, "CMPW A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x57: - util::stream_format(stream, "CMPW A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0x78: case 0x79: case 0x7a: case 0x7b: - util::stream_format(stream, "CMPW A, @RW%d + #$%04x", (operand & 0x7), opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0x7c: case 0x7d: - util::stream_format(stream, "CMPW A, @RW%d + RW7", (operand & 0x1)); - bytes = 2; - break; - - case 0x7e: - util::stream_format(stream, "CMPW A, @PC + #$04x ($%04X)", opcodes.r16(pc+2), (s16)opcodes.r16(pc+2) + (pc & 0xffff)); - bytes = 4; - break; - - case 0x7f: - util::stream_format(stream, "CMPW $%04x", opcodes.r16(pc+2)); - bytes = 4; - break; - - case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: - util::stream_format(stream, "ORW A, RW%d", (operand & 0x1)); - bytes = 2; - break; - - case 0xa8: case 0xa9: case 0xaa: case 0xab: - util::stream_format(stream, "ORW A, @RW%d", (operand & 0x1)); - bytes = 2; - break; - - case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: - util::stream_format(stream, "ORW A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - default: - stream << "UNK ea-type 76"; - break; - } - break; - - case 0x77: // ea-type instructions - switch (operand) - { - default: - stream << "UNK ea-type 77"; - break; - } - break; - - case 0x78: // ea-type instructions - switch (operand) - { - case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: - util::stream_format(stream, "MULUW A, RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0x28: case 0x29: case 0x2a: case 0x2b: - util::stream_format(stream, "MULUW A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0x2c: case 0x2d: case 0x2e: case 0x2f: - util::stream_format(stream, "MULUW A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37: - util::stream_format(stream, "MULUW A, @RW%d + #$%02x", (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - break; - - case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: - util::stream_format(stream, "DIVUW A, RW%d", (operand & 0x7)); - bytes = 2; - break; - - case 0xa8: case 0xa9: case 0xaa: case 0xab: - util::stream_format(stream, "DIVUW A, @RW%d", (operand & 0x3)); - bytes = 2; - break; - - case 0xac: case 0xad: case 0xae: case 0xaf: - util::stream_format(stream, "DIVUW A, @RW%d+", (operand & 0x3)); - bytes = 2; - break; - - default: - stream << "UNK ea-type 78"; - break; - } - break; - - case 0x7a: // ea RWi-type instructions - if (operand & 0x10) - { - util::stream_format(stream, "MOV RW%d, @RW%d + #$%02x", (operand>>5) & 0x7, (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - } - else - { - util::stream_format(stream, "MOV R%d, R%d", (operand>>5) & 0x7, (operand & 0x7)); - bytes = 2; - } - break; - - case 0x7b: // ea RWi-type instructions - if (operand & 0x10) - { - util::stream_format(stream, "MOVW RW%d, @RW%d + #$%02x", (operand>>5) & 0x7, (operand & 0x7), opcodes.r8(pc+2)); - bytes = 3; - } - else - { - util::stream_format(stream, "MOVW RW%d, RW%d", (operand>>5) & 0x7, (operand & 0x7)); - bytes = 2; - } - break; - - case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: - util::stream_format(stream, "MOV A, R%d", (opcode & 0x7)); - break; - - case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f: - util::stream_format(stream, "MOVW A, RW%d", (opcode & 0x7)); - break; - - case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97: - util::stream_format(stream, "MOV R%d, A", (opcode & 0x7)); - break; - - case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f: - util::stream_format(stream, "MOVW RW%d, A", (opcode & 0x7)); - break; - - case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7: - util::stream_format(stream, "MOV R%d, #$%02x", (opcode & 0x7), operand); - bytes = 2; - break; - - case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf: - util::stream_format(stream, "MOVW RW%d, #$%04x", (opcode & 0x7), opcodes.r16(pc+1)); - bytes = 3; - break; - - case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: - util::stream_format(stream, "MOVX A, R%d", (opcode & 0x7)); - break; - - case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf: - util::stream_format(stream, "MOVW A, @RW%d + #$%02x", (opcode & 0x7), operand); - bytes = 2; - break; - - case 0xc0: case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: - util::stream_format(stream, "MOVX A, @RW%d + #$%02x", (opcode & 0x7), operand); - bytes = 2; - break; - - case 0xc8: case 0xc9: case 0xca: case 0xcb: case 0xcc: case 0xcd: case 0xce: case 0xcf: - util::stream_format(stream, "MOVW @RW%d + #$%02x, A", (opcode & 0x7), operand); - bytes = 2; - break; - - case 0xd0: case 0xd1: case 0xd2: case 0xd3: case 0xd4: case 0xd5: case 0xd6: case 0xd7: - case 0xd8: case 0xd9: case 0xda: case 0xdb: case 0xdc: case 0xdd: case 0xde: case 0xdf: - util::stream_format(stream, "MOVN A, #$%01x", (opcode & 0xf)); - break; - - case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: - case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef: - util::stream_format(stream, "CALL #$%01x", (opcode & 0xf)); - bytes |= STEP_OVER; - break; - - case 0xf0: branch_helper(stream, "BEQ ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf1: branch_helper(stream, "BNE ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf2: branch_helper(stream, "BC ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf3: branch_helper(stream, "BNC ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf4: branch_helper(stream, "BN ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf5: branch_helper(stream, "BP ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf6: branch_helper(stream, "BV ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf7: branch_helper(stream, "BNV ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf8: branch_helper(stream, "BT ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xf9: branch_helper(stream, "BNT ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xfa: branch_helper(stream, "BLT ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xfb: branch_helper(stream, "BGE ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xfc: branch_helper(stream, "BLE ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xfd: branch_helper(stream, "BGT ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xfe: branch_helper(stream, "BLS ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - case 0xff: branch_helper(stream, "BHI ", (pc & 0xffff)+2, (s8)operand); bytes = 2; break; - - default: - stream << "???"; - break; - - } - - return bytes | SUPPORTED; -} diff --git a/src/devices/cpu/f2mc16/f2mc16dasm.h b/src/devices/cpu/f2mc16/f2mc16dasm.h deleted file mode 100644 index e6d0e92109d..00000000000 --- a/src/devices/cpu/f2mc16/f2mc16dasm.h +++ /dev/null @@ -1,28 +0,0 @@ -// license:BSD-3-Clause -// copyright-holders:R. Belmont - -#ifndef MAME_CPU_F2MC16_F2MC16DASM_H -#define MAME_CPU_F2MC16_F2MC16DASM_H - -#pragma once - -class f2mc16_disassembler : public util::disasm_interface -{ -public: - // construction/destruction - f2mc16_disassembler() = default; - virtual ~f2mc16_disassembler() = default; - -protected: - // disassembler overrides - virtual u32 opcode_alignment() const override; - virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms) override; - -private: - // internal helpers - void branch_helper(std::ostream &stream, const char *insName, u16 PC, s8 offset); - offs_t ea_form1_helper(std::ostream &stream, const char *opName, u16 pc, u8 operand, u16 imm16, bool bAIsDest); - offs_t ea_form1_helper_noA(std::ostream &stream, const char *opName, u16 pc, u8 operand, u16 imm16); -}; - -#endif // MAME_CPU_F2MC16_F2MC16DASM_H diff --git a/src/tools/unidasm.cpp b/src/tools/unidasm.cpp index b9fe1ce0539..14e7dbf2c6d 100644 --- a/src/tools/unidasm.cpp +++ b/src/tools/unidasm.cpp @@ -50,7 +50,7 @@ using util::BIT; #include "cpu/e132xs/32xsdasm.h" #include "cpu/es5510/es5510d.h" #include "cpu/esrip/esripdsm.h" -#include "cpu/f2mc16/f2mc16dasm.h" +#include "cpu/f2mc16/f2mc16d.h" #include "cpu/f8/f8dasm.h" #include "cpu/fr/frdasm.h" #include "cpu/g65816/g65816ds.h" |