summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
-rw-r--r--scripts/src/cpu.lua4
-rw-r--r--src/devices/cpu/f2mc16/f2mc16.cpp4
-rw-r--r--src/devices/cpu/f2mc16/f2mc16d.cpp1639
-rw-r--r--src/devices/cpu/f2mc16/f2mc16d.h62
-rw-r--r--src/devices/cpu/f2mc16/f2mc16dasm.cpp2168
-rw-r--r--src/devices/cpu/f2mc16/f2mc16dasm.h28
-rw-r--r--src/tools/unidasm.cpp2
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 &params)
+{
+ 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 &params) 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 &params)
-{
- 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 &params) 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"