summaryrefslogtreecommitdiffstatshomepage
path: root/src/devices/cpu
diff options
context:
space:
mode:
Diffstat (limited to 'src/devices/cpu')
-rw-r--r--src/devices/cpu/e0c6200/e0c6s46.cpp2
-rw-r--r--src/devices/cpu/f8/f8dasm.cpp181
-rw-r--r--src/devices/cpu/lc58/lc58d.cpp160
-rw-r--r--src/devices/cpu/lc58/lc58d.h30
-rw-r--r--src/devices/cpu/m6502/n2a03.cpp19
-rw-r--r--src/devices/cpu/m6502/n2a03.h29
-rw-r--r--src/devices/cpu/ns32000/ns32000.cpp72
-rw-r--r--src/devices/cpu/ns32000/ns32000.h9
-rw-r--r--src/devices/cpu/tms34010/tms34010.cpp4
-rw-r--r--src/devices/cpu/tms9900/tms9995.cpp6
-rw-r--r--src/devices/cpu/vt50/vt50.cpp2
11 files changed, 362 insertions, 152 deletions
diff --git a/src/devices/cpu/e0c6200/e0c6s46.cpp b/src/devices/cpu/e0c6200/e0c6s46.cpp
index 9f80774a6e5..5094c36a5f7 100644
--- a/src/devices/cpu/e0c6200/e0c6s46.cpp
+++ b/src/devices/cpu/e0c6200/e0c6s46.cpp
@@ -589,7 +589,7 @@ u32 e0c6s46_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, c
if (!m_pixel_update_cb.isnull())
m_pixel_update_cb(bitmap, cliprect, m_lcd_contrast, seg, com, pixel);
else if (cliprect.contains(seg, com))
- bitmap.pix16(com, seg) = pixel;
+ bitmap.pix(com, seg) = pixel;
}
}
}
diff --git a/src/devices/cpu/f8/f8dasm.cpp b/src/devices/cpu/f8/f8dasm.cpp
index 24ec47b5154..e35a7d42f70 100644
--- a/src/devices/cpu/f8/f8dasm.cpp
+++ b/src/devices/cpu/f8/f8dasm.cpp
@@ -17,33 +17,22 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
{
offs_t base_pc = pc;
uint8_t op = opcodes.r8(pc++);
+ offs_t flags = SUPPORTED;
switch( op )
{
/* opcode bitmask */
case 0x00: /* 0000 0000 */
- util::stream_format(stream, "LR A,KU");
- break;
case 0x01: /* 0000 0001 */
- util::stream_format(stream, "LR A,KL");
- break;
case 0x02: /* 0000 0010 */
- util::stream_format(stream, "LR A,QU");
- break;
case 0x03: /* 0000 0011 */
- util::stream_format(stream, "LR A,QL");
+ util::stream_format(stream, "LR A,%s", rname[op + 12]);
break;
case 0x04: /* 0000 0100 */
- util::stream_format(stream, "LR KU,A");
- break;
case 0x05: /* 0000 0101 */
- util::stream_format(stream, "LR KL,A");
- break;
case 0x06: /* 0000 0110 */
- util::stream_format(stream, "LR QU,A");
- break;
case 0x07: /* 0000 0111 */
- util::stream_format(stream, "LR QL,A");
+ util::stream_format(stream, "LR %s,A", rname[(op - 0x04) + 12]);
break;
case 0x08: /* 0000 1000 */
@@ -60,7 +49,8 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
break;
case 0x0c: /* 0000 1100 */
- util::stream_format(stream, "PK") ;
+ util::stream_format(stream, "PK");
+ flags |= STEP_OUT;
break;
case 0x0d: /* 0000 1101 */
util::stream_format(stream, "LR P0,Q");
@@ -109,6 +99,7 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
break;
case 0x1c: /* 0001 1100 */
util::stream_format(stream, "POP");
+ flags |= STEP_OUT;
break;
case 0x1d: /* 0001 1101 */
util::stream_format(stream, "LR W,J");
@@ -120,39 +111,40 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
util::stream_format(stream, "INC");
break;
case 0x20: /* 0010 0000 */
- util::stream_format(stream, "LI $%02X", opcodes.r8(pc++));
+ util::stream_format(stream, "LI H'%02X'", opcodes.r8(pc++));
break;
case 0x21: /* 0010 0001 */
- util::stream_format(stream, "NI $%02X", opcodes.r8(pc++));
+ util::stream_format(stream, "NI H'%02X'", opcodes.r8(pc++));
break;
case 0x22: /* 0010 0010 */
- util::stream_format(stream, "OI $%02X", opcodes.r8(pc++));
+ util::stream_format(stream, "OI H'%02X'", opcodes.r8(pc++));
break;
case 0x23: /* 0010 0011 */
- util::stream_format(stream, "XI $%02X", opcodes.r8(pc++));
+ util::stream_format(stream, "XI H'%02X'", opcodes.r8(pc++));
break;
case 0x24: /* 0010 0100 */
- util::stream_format(stream, "AI $%02X", opcodes.r8(pc++));
+ util::stream_format(stream, "AI H'%02X'", opcodes.r8(pc++));
break;
case 0x25: /* 0010 0101 */
- util::stream_format(stream, "CI $%02X", opcodes.r8(pc++));
+ util::stream_format(stream, "CI H'%02X'", opcodes.r8(pc++));
break;
case 0x26: /* 0010 0110 */
- util::stream_format(stream, "IN $%02X", opcodes.r8(pc++));
+ util::stream_format(stream, "IN H'%02X'", opcodes.r8(pc++));
break;
case 0x27: /* 0010 0111 */
- util::stream_format(stream, "OUT $%02X", opcodes.r8(pc++));
+ util::stream_format(stream, "OUT H'%02X'", opcodes.r8(pc++));
break;
case 0x28: /* 0010 1000 */
- util::stream_format(stream, "PI $%04X", opcodes.r16(pc));
+ util::stream_format(stream, "PI H'%04X'", opcodes.r16(pc));
pc += 2;
+ flags |= STEP_OVER;
break;
case 0x29: /* 0010 1001 */
- util::stream_format(stream, "JMP $%04X", opcodes.r16(pc));
+ util::stream_format(stream, "JMP H'%04X'", opcodes.r16(pc));
pc += 2;
break;
case 0x2a: /* 0010 1010 */
- util::stream_format(stream, "DCI $%04X", opcodes.r16(pc));
+ util::stream_format(stream, "DCI H'%04X'", opcodes.r16(pc));
pc += 2;
break;
case 0x2b: /* 0010 1011 */
@@ -161,11 +153,9 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0x2c: /* 0010 1100 */
util::stream_format(stream, "XDC");
break;
- case 0x2d: /* 0010 1101 */
- case 0x2e: /* 0010 1110 */
- case 0x2f: /* 0010 1111 */
- util::stream_format(stream, "??? $%02X",op);
- break;
+ /* case 0x2d: 0010 1101 */
+ /* case 0x2e: 0010 1110 */
+ /* case 0x2f: 0010 1111 */
case 0x30: /* 0011 0000 */
case 0x31: /* 0011 0001 */
@@ -179,20 +169,18 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0x39: /* 0011 1001 */
case 0x3a: /* 0011 1010 */
case 0x3b: /* 0011 1011 */
- util::stream_format(stream, "DS %s",rname[op & 15]);
+ util::stream_format(stream, "DS %s", rname[op & 15]);
break;
case 0x3c: /* 0011 1100 */
- util::stream_format(stream, "DS (IS)");
+ util::stream_format(stream, "DS S");
break;
case 0x3d: /* 0011 1101 */
- util::stream_format(stream, "DS (IS++)");
+ util::stream_format(stream, "DS I");
break;
case 0x3e: /* 0011 1110 */
- util::stream_format(stream, "DS (IS--)");
- break;
- case 0x3f: /* 0011 1111 */
- util::stream_format(stream, "??? $%02X",op);
+ util::stream_format(stream, "DS D");
break;
+ /* case 0x3f: 0011 1111 */
case 0x40: /* 0100 0000 */
case 0x41: /* 0100 0001 */
@@ -206,20 +194,18 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0x49: /* 0100 1001 */
case 0x4a: /* 0100 1010 */
case 0x4b: /* 0100 1011 */
- util::stream_format(stream, "LR A,%s",rname[op & 15]);
+ util::stream_format(stream, "LR A,%s", rname[op & 15]);
break;
case 0x4c: /* 0100 1100 */
- util::stream_format(stream, "LR A,(IS)");
+ util::stream_format(stream, "LR A,S");
break;
case 0x4d: /* 0100 1101 */
- util::stream_format(stream, "LR A,(IS++)");
+ util::stream_format(stream, "LR A,I");
break;
case 0x4e: /* 0100 1110 */
- util::stream_format(stream, "LR A,(IS--)");
- break;
- case 0x4f: /* 0100 1111 */
- util::stream_format(stream, "??? $%02X",op);
+ util::stream_format(stream, "LR A,D");
break;
+ /* case 0x4f: 0100 1111 */
case 0x50: /* 0101 0000 */
case 0x51: /* 0101 0001 */
@@ -233,20 +219,18 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0x59: /* 0101 1001 */
case 0x5a: /* 0101 1010 */
case 0x5b: /* 0101 1011 */
- util::stream_format(stream, "LR %s,A",rname[op & 15]);
+ util::stream_format(stream, "LR %s,A", rname[op & 15]);
break;
case 0x5c: /* 0101 1100 */
- util::stream_format(stream, "LR (IS),A");
+ util::stream_format(stream, "LR S,A");
break;
case 0x5d: /* 0101 1101 */
- util::stream_format(stream, "LR (IS++),A");
+ util::stream_format(stream, "LR I,A");
break;
case 0x5e: /* 0101 1110 */
- util::stream_format(stream, "LR (IS--),A");
- break;
- case 0x5f: /* 0101 1111 */
- util::stream_format(stream, "??? $%02X",op);
+ util::stream_format(stream, "LR D,A");
break;
+ /* case 0x5f: 0101 1111 */
case 0x60: /* 0110 0000 */
case 0x61: /* 0110 0001 */
@@ -256,7 +240,7 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0x65: /* 0110 0101 */
case 0x66: /* 0110 0110 */
case 0x67: /* 0110 0111 */
- util::stream_format(stream, "LISU $%02X", op & 0x07);
+ util::stream_format(stream, "LISU %d", op & 0x07);
break;
case 0x68: /* 0110 1000 */
case 0x69: /* 0110 1001 */
@@ -266,7 +250,7 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0x6d: /* 0110 1101 */
case 0x6e: /* 0110 1110 */
case 0x6f: /* 0110 1111 */
- util::stream_format(stream, "LISL $%02X", op & 0x07);
+ util::stream_format(stream, "LISL %d", op & 0x07);
break;
case 0x70: /* 0111 0000 */
@@ -285,27 +269,27 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0x7d: /* 0111 1101 */
case 0x7e: /* 0111 1110 */
case 0x7f: /* 0111 1111 */
- util::stream_format(stream, "LIS $%02X", op & 0x0f);
+ util::stream_format(stream, "LIS H'%02X'", op & 0x0f);
break;
case 0x81: /* 1000 0001 */
case 0x85: /* 1000 0101 */
- util::stream_format(stream, "BP $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BP H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x82: /* 1000 0010 */
- util::stream_format(stream, "BC $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BC H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x84: /* 1000 0100 */
- util::stream_format(stream, "BZ $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BZ H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x80: /* 1000 0000 */
case 0x83: /* 1000 0011 */
case 0x86: /* 1000 0110 */
case 0x87: /* 1000 0111 */
- util::stream_format(stream, "BT $%02X,$%04X", op & 0x07, base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BT H'%02X',H'%04X'", op & 0x07, base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x88: /* 1000 1000 */
@@ -337,28 +321,28 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
break;
case 0x8f: /* 1000 1111 */
- util::stream_format(stream, "BR7 $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BR7 H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x90: /* 1001 0000 */
- util::stream_format(stream, "BR $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BR H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x91: /* 1001 0001 */
case 0x95: /* 1001 0101 */
- util::stream_format(stream, "BM $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BM H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x92: /* 1001 0010 */
- util::stream_format(stream, "BNC $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BNC H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x94: /* 1001 0100 */
- util::stream_format(stream, "BNZ $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BNZ H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x98: /* 1001 1000 */
- util::stream_format(stream, "BNO $%04X", base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BNO H'%04X'", base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0x93: /* 1001 0011 */
@@ -371,18 +355,16 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0x9d: /* 1001 1101 */
case 0x9e: /* 1001 1110 */
case 0x9f: /* 1001 1111 */
- util::stream_format(stream, "BF $%02X,$%04X", op & 0x0f, base_pc + (int8_t)opcodes.r8(pc++) + 1);
+ util::stream_format(stream, "BF H'%02X',H'%04X'", op & 0x0f, base_pc + (int8_t)opcodes.r8(pc++) + 1);
break;
case 0xa0: /* 1010 0000 */
case 0xa1: /* 1010 0001 */
- util::stream_format(stream, "INS $%02X", (unsigned) (int8_t) (op & 0x0F));
+ util::stream_format(stream, "INS %d", op & 0x0f);
break;
- case 0xa2: /* 1010 0010 */
- case 0xa3: /* 1010 0011 */
- util::stream_format(stream, "??? $%02X", op);
- break;
+ /* case 0xa2: 1010 0010 */
+ /* case 0xa3: 1010 0011 */
case 0xa4: /* 1010 0100 */
case 0xa5: /* 1010 0101 */
@@ -396,18 +378,16 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0xad: /* 1010 1101 */
case 0xae: /* 1010 1110 */
case 0xaf: /* 1010 1111 */
- util::stream_format(stream, "INS $%02X", (int8_t) op & 0x0f);
+ util::stream_format(stream, "INS H'%02X'", op & 0x0f);
break;
case 0xb0: /* 1011 0000 */
case 0xb1: /* 1011 0001 */
- util::stream_format(stream, "OUTS $%02X", (int8_t) op & 0x0f);
+ util::stream_format(stream, "OUTS %d", op & 0x0f);
break;
- case 0xb2: /* 1011 0010 */
- case 0xb3: /* 1011 0011 */
- util::stream_format(stream, "??? $%02X", op);
- break;
+ /* case 0xb2: 1011 0010 */
+ /* case 0xb3: 1011 0011 */
case 0xb4: /* 1011 0100 */
case 0xb5: /* 1011 0101 */
@@ -421,7 +401,7 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
case 0xbd: /* 1011 1101 */
case 0xbe: /* 1011 1110 */
case 0xbf: /* 1011 1111 */
- util::stream_format(stream, "OUTS $%02X", (unsigned) (int8_t) op & 0x0f);
+ util::stream_format(stream, "OUTS H'%02X'", op & 0x0f);
break;
case 0xc0: /* 1100 0000 */
@@ -439,17 +419,15 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
util::stream_format(stream, "AS %s", rname[op & 15]);
break;
case 0xcc: /* 1100 1100 */
- util::stream_format(stream, "AS (IS)");
+ util::stream_format(stream, "AS S");
break;
case 0xcd: /* 1100 1101 */
- util::stream_format(stream, "AS (IS++)");
+ util::stream_format(stream, "AS I");
break;
case 0xce: /* 1100 1110 */
- util::stream_format(stream, "AS (IS--)");
- break;
- case 0xcf: /* 1100 1111 */
- util::stream_format(stream, "??? $%02X", op);
+ util::stream_format(stream, "AS D");
break;
+ /* case 0xcf: 1100 1111 */
case 0xd0: /* 1101 0000 */
case 0xd1: /* 1101 0001 */
@@ -466,17 +444,15 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
util::stream_format(stream, "ASD %s", rname[op & 15]);
break;
case 0xdc: /* 1101 1100 */
- util::stream_format(stream, "ASD (IS)");
+ util::stream_format(stream, "ASD S");
break;
case 0xdd: /* 1101 1101 */
- util::stream_format(stream, "ASD (IS++)");
+ util::stream_format(stream, "ASD I");
break;
case 0xde: /* 1101 1110 */
- util::stream_format(stream, "ASD (IS--)");
- break;
- case 0xdf: /* 1101 1111 */
- util::stream_format(stream, "??? $%02X", op);
+ util::stream_format(stream, "ASD D");
break;
+ /* case 0xdf: 1101 1111 */
case 0xe0: /* 1110 0000 */
case 0xe1: /* 1110 0001 */
@@ -493,17 +469,15 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
util::stream_format(stream, "XS %s", rname[op & 15]);
break;
case 0xec: /* 1110 1100 */
- util::stream_format(stream, "XS (IS)");
+ util::stream_format(stream, "XS S");
break;
case 0xed: /* 1110 1101 */
- util::stream_format(stream, "XS (IS++)");
+ util::stream_format(stream, "XS I");
break;
case 0xee: /* 1110 1110 */
- util::stream_format(stream, "XS (IS--)");
- break;
- case 0xef: /* 1110 1111 */
- util::stream_format(stream, "??? $%02X", op);
+ util::stream_format(stream, "XS D");
break;
+ /* case 0xef: 1110 1111 */
case 0xf0: /* 1111 0000 */
@@ -521,18 +495,21 @@ offs_t f8_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_
util::stream_format(stream, "NS %s", rname[op & 15]);
break;
case 0xfc: /* 1111 1100 */
- util::stream_format(stream, "NS (IS)");
+ util::stream_format(stream, "NS S");
break;
case 0xfd: /* 1111 1101 */
- util::stream_format(stream, "NS (IS++)");
+ util::stream_format(stream, "NS I");
break;
case 0xfe: /* 1111 1110 */
- util::stream_format(stream, "NS (IS--)");
+ util::stream_format(stream, "NS D");
break;
- case 0xff: /* 1111 1111 */
- util::stream_format(stream, "??? $%02X", op);
+ /* case 0xff: 1111 1111 */
+
+
+ default:
+ util::stream_format(stream, "DC H'%02X' (?)", op);
break;
}
- return pc - base_pc;
+ return (pc - base_pc) | flags;
}
diff --git a/src/devices/cpu/lc58/lc58d.cpp b/src/devices/cpu/lc58/lc58d.cpp
new file mode 100644
index 00000000000..477ee00ffb0
--- /dev/null
+++ b/src/devices/cpu/lc58/lc58d.cpp
@@ -0,0 +1,160 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// LC58 generic disassembler
+
+#include "emu.h"
+#include "lc58d.h"
+
+u32 lc58_disassembler::opcode_alignment() const
+{
+ return 1;
+}
+
+#define P std::ostream &stream, const lc58_disassembler *d, u16 opcode
+const lc58_disassembler::instruction lc58_disassembler::instructions[] {
+ { 0x5a00, 0xffff, [](P) -> u32 { util::stream_format(stream, "cla"); return 1; } },
+ { 0xec01, 0xffff, [](P) -> u32 { util::stream_format(stream, "rcf"); return 1; } },
+ { 0xe801, 0xffff, [](P) -> u32 { util::stream_format(stream, "scf"); return 1; } },
+ { 0x6000, 0xfc00, [](P) -> u32 { util::stream_format(stream, "mrw wr%x, %02x", (opcode >> 7) & 7, opcode & 0x7f); return 1; } },
+ { 0x6400, 0xfc00, [](P) -> u32 { util::stream_format(stream, "mwr %02x, wr%x", opcode & 0x7f, (opcode >> 7) & 7); return 1; } },
+ { 0x6800, 0xff80, [](P) -> u32 { util::stream_format(stream, "sr0 %02x", opcode & 0x7f); return 1; } },
+ { 0x6900, 0xff80, [](P) -> u32 { util::stream_format(stream, "sr1 %02x", opcode & 0x7f); return 1; } },
+ { 0x6a00, 0xff80, [](P) -> u32 { util::stream_format(stream, "sl0 %02x", opcode & 0x7f); return 1; } },
+ { 0x6b00, 0xff80, [](P) -> u32 { util::stream_format(stream, "sl1 %02x", opcode & 0x7f); return 1; } },
+ { 0x6c00, 0xff80, [](P) -> u32 { util::stream_format(stream, "rar %02x", opcode & 0x7f); return 1; } },
+ { 0x6e00, 0xff80, [](P) -> u32 { util::stream_format(stream, "ral %02x", opcode & 0x7f); return 1; } },
+ { 0x7400, 0xff80, [](P) -> u32 { util::stream_format(stream, "maf %02x", opcode & 0x7f); return 1; } },
+ { 0x0f80, 0xff80, [](P) -> u32 { util::stream_format(stream, "mra %02x", opcode & 0x7f); return 1; } },
+
+ { 0x4000, 0xff80, [](P) -> u32 { util::stream_format(stream, "adc %02x", opcode & 0x7f); return 1; } },
+ { 0x4100, 0xff80, [](P) -> u32 { util::stream_format(stream, "adc* %02x", opcode & 0x7f); return 1; } },
+ { 0x4200, 0xff80, [](P) -> u32 { util::stream_format(stream, "sbc %02x", opcode & 0x7f); return 1; } },
+ { 0x4300, 0xff80, [](P) -> u32 { util::stream_format(stream, "sbc* %02x", opcode & 0x7f); return 1; } },
+ { 0x4400, 0xff80, [](P) -> u32 { util::stream_format(stream, "add %02x", opcode & 0x7f); return 1; } },
+ { 0x4500, 0xff80, [](P) -> u32 { util::stream_format(stream, "add* %02x", opcode & 0x7f); return 1; } },
+ { 0x4600, 0xff80, [](P) -> u32 { util::stream_format(stream, "sub %02x", opcode & 0x7f); return 1; } },
+ { 0x4700, 0xff80, [](P) -> u32 { util::stream_format(stream, "sub* %02x", opcode & 0x7f); return 1; } },
+ { 0x4800, 0xff80, [](P) -> u32 { util::stream_format(stream, "adn %02x", opcode & 0x7f); return 1; } },
+ { 0x4900, 0xff80, [](P) -> u32 { util::stream_format(stream, "adn* %02x", opcode & 0x7f); return 1; } },
+ { 0x4a00, 0xff80, [](P) -> u32 { util::stream_format(stream, "and %02x", opcode & 0x7f); return 1; } },
+ { 0x4b00, 0xff80, [](P) -> u32 { util::stream_format(stream, "and* %02x", opcode & 0x7f); return 1; } },
+ { 0x4c00, 0xff80, [](P) -> u32 { util::stream_format(stream, "eor %02x", opcode & 0x7f); return 1; } },
+ { 0x4d00, 0xff80, [](P) -> u32 { util::stream_format(stream, "eor* %02x", opcode & 0x7f); return 1; } },
+ { 0x4e00, 0xff80, [](P) -> u32 { util::stream_format(stream, "or %02x", opcode & 0x7f); return 1; } },
+ { 0x4f00, 0xff80, [](P) -> u32 { util::stream_format(stream, "or* %02x", opcode & 0x7f); return 1; } },
+ { 0x5000, 0xff00, [](P) -> u32 { util::stream_format(stream, "adci #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5100, 0xff00, [](P) -> u32 { util::stream_format(stream, "adci* #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5200, 0xff00, [](P) -> u32 { util::stream_format(stream, "sbci #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5300, 0xff00, [](P) -> u32 { util::stream_format(stream, "sbci* #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5400, 0xff00, [](P) -> u32 { util::stream_format(stream, "addi #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5500, 0xff00, [](P) -> u32 { util::stream_format(stream, "addi* #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5600, 0xff00, [](P) -> u32 { util::stream_format(stream, "subi #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5700, 0xff00, [](P) -> u32 { util::stream_format(stream, "subi* #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5800, 0xff00, [](P) -> u32 { util::stream_format(stream, "adni #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5900, 0xff00, [](P) -> u32 { util::stream_format(stream, "adni* #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5a00, 0xff00, [](P) -> u32 { util::stream_format(stream, "andi #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5b00, 0xff00, [](P) -> u32 { util::stream_format(stream, "andi* #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5c00, 0xff00, [](P) -> u32 { util::stream_format(stream, "eori #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5d00, 0xff00, [](P) -> u32 { util::stream_format(stream, "eori* #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5e00, 0xff00, [](P) -> u32 { util::stream_format(stream, "ori #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+ { 0x5f00, 0xff00, [](P) -> u32 { util::stream_format(stream, "ori* #%x, %02x", (opcode >> 4) & 0xf, 0x70 + (opcode & 0xf)); return 1; } },
+
+ { 0x7700, 0xff80, [](P) -> u32 { util::stream_format(stream, "mdpl %02x", opcode & 0x7f); return 1; } },
+ { 0x7680, 0xff80, [](P) -> u32 { util::stream_format(stream, "mdph %02x", opcode & 0x7f); return 1; } },
+ { 0x6b80, 0xff80, [](P) -> u32 { util::stream_format(stream, "mrdl %02x", opcode & 0x7f); return 1; } },
+ { 0x6980, 0xff80, [](P) -> u32 { util::stream_format(stream, "mrdh %02x", opcode & 0x7f); return 1; } },
+ { 0x6a80, 0xff80, [](P) -> u32 { util::stream_format(stream, "mrsp %02x", opcode & 0x7f); return 1; } },
+ { 0xe800, 0xfc00, [](P) -> u32 { util::stream_format(stream, "sf1 %03x", opcode & 0x3ff); return 1; } },
+ { 0xec00, 0xfc00, [](P) -> u32 { util::stream_format(stream, "rf1 %03x", opcode & 0x3ff); return 1; } },
+ { 0xf000, 0xfc00, [](P) -> u32 { util::stream_format(stream, "sf2 %03x", opcode & 0x3ff); return 1; } },
+ { 0xf400, 0xfc00, [](P) -> u32 { util::stream_format(stream, "rf2 %03x", opcode & 0x3ff); return 1; } },
+ { 0xe880, 0xffff, [](P) -> u32 { util::stream_format(stream, "sdpf"); return 1; } },
+ { 0xec80, 0xffff, [](P) -> u32 { util::stream_format(stream, "rdpf"); return 1; } },
+
+ { 0x7780, 0xff80, [](P) -> u32 { util::stream_format(stream, "sta %02x", opcode & 0x7f); return 1; } },
+ { 0x7800, 0xf800, [](P) -> u32 { util::stream_format(stream, "lds %02x, #%x", opcode & 0x7f, (opcode >> 7) & 0xf); return 1; } },
+ { 0x6880, 0xff80, [](P) -> u32 { util::stream_format(stream, "lda %02x", opcode & 0x7f); return 1; } },
+
+ { 0xff00, 0xffff, [](P) -> u32 { util::stream_format(stream, "halt"); return 1; } },
+ { 0xe000, 0xffc0, [](P) -> u32 { util::stream_format(stream, "ssw %02x", opcode & 0x3f); return 1; } },
+ { 0xfa00, 0xfe00, [](P) -> u32 { util::stream_format(stream, "sie %03x", opcode & 0x1ff); return 1 | STEP_OVER; } },
+ { 0xfe00, 0xfff0, [](P) -> u32 { util::stream_format(stream, "sie* %x", opcode & 0xf); return 1 | STEP_OVER; } },
+ { 0x7580, 0xff80, [](P) -> u32 { util::stream_format(stream, "msb %02x", opcode & 0x7f); return 1; } },
+ { 0x7600, 0xff80, [](P) -> u32 { util::stream_format(stream, "msc %02x", opcode & 0x7f); return 1; } },
+ { 0x0000, 0xffff, [](P) -> u32 { util::stream_format(stream, "nop"); return 1; } },
+ { 0xf018, 0xffff, [](P) -> u32 { util::stream_format(stream, "lon"); return 1; } },
+ { 0xf418, 0xffff, [](P) -> u32 { util::stream_format(stream, "loff"); return 1; } },
+ { 0xf004, 0xffff, [](P) -> u32 { util::stream_format(stream, "sbak"); return 1; } },
+ { 0xf404, 0xffff, [](P) -> u32 { util::stream_format(stream, "rbak"); return 1; } },
+
+ { 0x7480, 0xff80, [](P) -> u32 { util::stream_format(stream, "mcd %02x", opcode & 0x7f); return 1; } },
+ { 0x7500, 0xff80, [](P) -> u32 { util::stream_format(stream, "mcf %02x", opcode & 0x7f); return 1; } },
+ { 0xfc22, 0xffff, [](P) -> u32 { util::stream_format(stream, "ccc"); return 1; } },
+ { 0xfc40, 0xffff, [](P) -> u32 { util::stream_format(stream, "rlp"); return 1; } },
+ { 0xfc80, 0xffff, [](P) -> u32 { util::stream_format(stream, "csp"); return 1; } },
+ { 0xfb00, 0xffff, [](P) -> u32 { util::stream_format(stream, "cst"); return 1; } },
+ { 0xe802, 0xffff, [](P) -> u32 { util::stream_format(stream, "scex"); return 1; } },
+ { 0xec02, 0xffff, [](P) -> u32 { util::stream_format(stream, "rcex"); return 1; } },
+ { 0xf000, 0xfffc, [](P) -> u32 { util::stream_format(stream, "schf %x", opcode & 3); return 1; } },
+ { 0xf400, 0xfffc, [](P) -> u32 { util::stream_format(stream, "rchf %x", opcode & 3); return 1; } },
+
+ { 0x7180, 0xff80, [](P) -> u32 { util::stream_format(stream, "ipp %02x", opcode & 0x7f); return 1; } },
+ { 0x7000, 0xff80, [](P) -> u32 { util::stream_format(stream, "ips %02x", opcode & 0x7f); return 1; } },
+ { 0x7080, 0xff80, [](P) -> u32 { util::stream_format(stream, "ipm %02x", opcode & 0x7f); return 1; } },
+ { 0x7100, 0xff80, [](P) -> u32 { util::stream_format(stream, "ipk %02x", opcode & 0x7f); return 1; } },
+ { 0x0080, 0xff80, [](P) -> u32 { util::stream_format(stream, "opp %02x", opcode & 0x7f); return 1; } },
+ { 0x0f00, 0xff80, [](P) -> u32 { util::stream_format(stream, "opm %02x", opcode & 0x7f); return 1; } },
+ { 0xe804, 0xffff, [](P) -> u32 { util::stream_format(stream, "sct1"); return 1; } },
+ { 0xec04, 0xffff, [](P) -> u32 { util::stream_format(stream, "rct1"); return 1; } },
+ { 0xf200, 0xffff, [](P) -> u32 { util::stream_format(stream, "sct2"); return 1; } },
+ { 0xf600, 0xffff, [](P) -> u32 { util::stream_format(stream, "rct2"); return 1; } },
+ { 0xf010, 0xffff, [](P) -> u32 { util::stream_format(stream, "slgt"); return 1; } },
+ { 0xf410, 0xffff, [](P) -> u32 { util::stream_format(stream, "rlgt"); return 1; } },
+ { 0xf800, 0xffff, [](P) -> u32 { util::stream_format(stream, "ras"); return 1; } },
+ { 0xf800, 0xfe00, [](P) -> u32 { util::stream_format(stream, "sas %03x", opcode & 0x1ff); return 1; } },
+ { 0xe800, 0xff9f, [](P) -> u32 { util::stream_format(stream, "comd %x", (opcode >> 5) & 3); return 1; } },
+ { 0xec00, 0xff9f, [](P) -> u32 { util::stream_format(stream, "cimd %x", (opcode >> 5) & 3); return 1; } },
+ { 0xf000, 0xfe1f, [](P) -> u32 { util::stream_format(stream, "spdf %x", (opcode >> 5) & 3); return 1; } },
+ { 0xf400, 0xfe1f, [](P) -> u32 { util::stream_format(stream, "rpdf %x", (opcode >> 5) & 3); return 1; } },
+ { 0xe808, 0xffff, [](P) -> u32 { util::stream_format(stream, "sfsp"); return 1; } },
+ { 0xec08, 0xffff, [](P) -> u32 { util::stream_format(stream, "rfsp"); return 1; } },
+ { 0x0000, 0xf000, [](P) -> u32 { util::stream_format(stream, "wrt %02x, %02x", (opcode >> 7) & 0x1f, opcode & 0x7f); return 1; } },
+ { 0x1000, 0xf000, [](P) -> u32 { util::stream_format(stream, "wrb %02x, %02x", (opcode >> 7) & 0x1f, opcode & 0x7f); return 1; } },
+ { 0x2000, 0xf000, [](P) -> u32 { util::stream_format(stream, "wrc %02x, %02x", (opcode >> 7) & 0x1f, opcode & 0x7f); return 1; } },
+ { 0x3000, 0xf000, [](P) -> u32 { util::stream_format(stream, "wrp %02x, %02x", (opcode >> 7) & 0x1f, opcode & 0x7f); return 1; } },
+
+ { 0xc000, 0xf800, [](P) -> u32 { util::stream_format(stream, "jmp %03x", opcode & 0x7ff); return 1; } },
+ { 0x8000, 0xf800, [](P) -> u32 { util::stream_format(stream, "bab0 %03x", opcode & 0x7ff); return 1; } },
+ { 0x8800, 0xf800, [](P) -> u32 { util::stream_format(stream, "bab1 %03x", opcode & 0x7ff); return 1; } },
+ { 0x9000, 0xf800, [](P) -> u32 { util::stream_format(stream, "bab2 %03x", opcode & 0x7ff); return 1; } },
+ { 0x9800, 0xf800, [](P) -> u32 { util::stream_format(stream, "bab3 %03x", opcode & 0x7ff); return 1; } },
+ { 0xa000, 0xf800, [](P) -> u32 { util::stream_format(stream, "banz %03x", opcode & 0x7ff); return 1; } },
+ { 0xb000, 0xf800, [](P) -> u32 { util::stream_format(stream, "baz %03x", opcode & 0x7ff); return 1; } },
+ { 0xa800, 0xf800, [](P) -> u32 { util::stream_format(stream, "bcnh %03x", opcode & 0x7ff); return 1; } },
+ { 0xb800, 0xf800, [](P) -> u32 { util::stream_format(stream, "bch %03x", opcode & 0x7ff); return 1; } },
+
+ { 0xc800, 0xf800, [](P) -> u32 { util::stream_format(stream, "call %03x", opcode & 0x7ff); return 1 | STEP_OVER; } },
+ { 0xd000, 0xffff, [](P) -> u32 { util::stream_format(stream, "rts"); return 1 | STEP_OUT; } },
+ { 0xd800, 0xffff, [](P) -> u32 { util::stream_format(stream, "pop"); return 1; } },
+
+ { 0xe400, 0xfc00, [](P) -> u32 { util::stream_format(stream, "stm %03x", opcode & 0x7ff); return 1; } },
+ { 0xfc04, 0xffff, [](P) -> u32 { util::stream_format(stream, "rtm"); return 1 | STEP_OUT; } },
+ { 0xf810, 0xffff, [](P) -> u32 { util::stream_format(stream, "sfpd"); return 1 | STEP_OUT; } },
+ { 0xfc10, 0xffff, [](P) -> u32 { util::stream_format(stream, "rfpd"); return 1 | STEP_OUT; } },
+ { 0xfc00, 0xfe00, [](P) -> u32 { util::stream_format(stream, "plc %03x", opcode & 0x1ff); return 1 | STEP_OVER; } },
+
+ { 0x0000, 0x0000, [](P) -> u32 { util::stream_format(stream, "?%04x", opcode); return 1; } },
+};
+
+#undef P
+
+offs_t lc58_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer &params)
+{
+ u16 opcode = opcodes.r16(pc);
+
+ for(u32 i=0;; i++)
+ if((opcode & instructions[i].mask) == instructions[i].value)
+ return instructions[i].cb(stream, this, opcode) | SUPPORTED;
+ return 0;
+}
diff --git a/src/devices/cpu/lc58/lc58d.h b/src/devices/cpu/lc58/lc58d.h
new file mode 100644
index 00000000000..6a570c10f02
--- /dev/null
+++ b/src/devices/cpu/lc58/lc58d.h
@@ -0,0 +1,30 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Sanyo LC58 generic disassembler
+
+#ifndef MAME_CPU_LC58_LC58D_H
+#define MAME_CPU_LC58_LC58D_H
+
+#pragma once
+
+class lc58_disassembler : public util::disasm_interface
+{
+public:
+ lc58_disassembler() = default;
+ virtual ~lc58_disassembler() = default;
+
+ 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:
+ struct instruction {
+ u16 value;
+ u16 mask;
+ u32 (*cb)(std::ostream &, const lc58_disassembler *, u16);
+ };
+
+ static const instruction instructions[];
+};
+
+#endif // MAME_CPU_LC58_LC58D_H
diff --git a/src/devices/cpu/m6502/n2a03.cpp b/src/devices/cpu/m6502/n2a03.cpp
index f303f1bf1b6..e1731b62e75 100644
--- a/src/devices/cpu/m6502/n2a03.cpp
+++ b/src/devices/cpu/m6502/n2a03.cpp
@@ -12,6 +12,7 @@
#include "n2a03.h"
#include "n2a03d.h"
+DEFINE_DEVICE_TYPE(N2A03_CORE, n2a03_core_device, "n2a03_core", "Ricoh N2A03 core") // needed for some VT systems with XOP instead of standard APU
DEFINE_DEVICE_TYPE(N2A03, n2a03_device, "n2a03", "Ricoh N2A03")
uint8_t n2a03_device::psg1_4014_r()
@@ -51,15 +52,29 @@ void n2a03_device::n2a03_map(address_map &map)
+n2a03_core_device::n2a03_core_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock)
+ : m6502_device(mconfig, type, tag, owner, clock)
+{
+}
+
+n2a03_core_device::n2a03_core_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
+ : n2a03_core_device(mconfig, N2A03_CORE, tag, owner, clock)
+{
+}
+
+
+
n2a03_device::n2a03_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
- : m6502_device(mconfig, N2A03, tag, owner, clock)
+ : n2a03_core_device(mconfig, N2A03, tag, owner, clock)
, device_mixer_interface(mconfig, *this, 1)
, m_apu(*this, "nesapu")
{
program_config.m_internal_map = address_map_constructor(FUNC(n2a03_device::n2a03_map), this);
}
-std::unique_ptr<util::disasm_interface> n2a03_device::create_disassembler()
+
+
+std::unique_ptr<util::disasm_interface> n2a03_core_device::create_disassembler()
{
return std::make_unique<n2a03_disassembler>();
}
diff --git a/src/devices/cpu/m6502/n2a03.h b/src/devices/cpu/m6502/n2a03.h
index 5a57bcbed2b..4232093c7a5 100644
--- a/src/devices/cpu/m6502/n2a03.h
+++ b/src/devices/cpu/m6502/n2a03.h
@@ -15,22 +15,18 @@
#include "m6502.h"
#include "sound/nes_apu.h"
-class n2a03_device : public m6502_device, public device_mixer_interface {
+class n2a03_core_device : public m6502_device {
public:
- n2a03_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
+ n2a03_core_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual std::unique_ptr<util::disasm_interface> create_disassembler() override;
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
- uint8_t psg1_4014_r();
- uint8_t psg1_4015_r();
- void psg1_4015_w(uint8_t data);
- void psg1_4017_w(uint8_t data);
-
- void n2a03_map(address_map &map);
protected:
+ n2a03_core_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
+
#define O(o) void o ## _full(); void o ## _partial()
// n2a03 opcodes - same as 6502 with D disabled
@@ -42,6 +38,21 @@ protected:
#undef O
+private:
+};
+
+class n2a03_device : public n2a03_core_device, public device_mixer_interface {
+public:
+ n2a03_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
+
+ uint8_t psg1_4014_r();
+ uint8_t psg1_4015_r();
+ void psg1_4015_w(uint8_t data);
+ void psg1_4017_w(uint8_t data);
+
+ void n2a03_map(address_map &map);
+protected:
+
required_device<nesapu_device> m_apu;
virtual void device_add_mconfig(machine_config &config) override;
@@ -52,6 +63,7 @@ private:
};
+
/* These are the official XTAL values and clock rates used by Nintendo for
manufacturing throughout the production of the 2A03. PALC_APU_CLOCK is
the clock rate devised by UMC(?) for PAL Famicom clone hardware. */
@@ -69,6 +81,7 @@ enum {
N2A03_SET_OVERFLOW = m6502_device::V_LINE
};
+DECLARE_DEVICE_TYPE(N2A03_CORE, n2a03_core_device)
DECLARE_DEVICE_TYPE(N2A03, n2a03_device)
#endif // MAME_CPU_M6502_N2A03_H
diff --git a/src/devices/cpu/ns32000/ns32000.cpp b/src/devices/cpu/ns32000/ns32000.cpp
index 4b796f8f345..d4801f3c079 100644
--- a/src/devices/cpu/ns32000/ns32000.cpp
+++ b/src/devices/cpu/ns32000/ns32000.cpp
@@ -83,7 +83,7 @@ static const u32 size_mask[] = { 0x000000ffU, 0x0000ffffU, 0x00000000U, 0xffffff
#define SP ((m_psr & PSR_S) ? m_sp1 : m_sp0)
-ns32000_device::ns32000_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, int databits, int addrbits)
+template <int Width>ns32000_device<Width>::ns32000_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, int databits, int addrbits)
: cpu_device(mconfig, type, tag, owner, clock)
, m_program_config("program", ENDIANNESS_LITTLE, databits, addrbits, 0)
, m_interrupt_config("interrupt", ENDIANNESS_LITTLE, databits, addrbits, 0)
@@ -106,7 +106,7 @@ ns32032_device::ns32032_device(const machine_config &mconfig, const char *tag, d
{
}
-void ns32000_device::device_start()
+template <int Width> void ns32000_device<Width>::device_start()
{
set_icountptr(m_icount);
@@ -152,7 +152,7 @@ void ns32000_device::device_start()
// state_add(8 + i, util::string_format("F%d", i).c_str(), m_f[i]);
}
-void ns32000_device::device_reset()
+template <int Width> void ns32000_device<Width>::device_reset()
{
for (std::pair<int, address_space_config const *> s : memory_space_config())
space(has_configured_map(s.first) ? s.first : 0).cache(m_bus[s.first]);
@@ -166,7 +166,7 @@ void ns32000_device::device_reset()
m_wait = false;
}
-void ns32000_device::state_string_export(device_state_entry const &entry, std::string &str) const
+template <int Width> void ns32000_device<Width>::state_string_export(device_state_entry const &entry, std::string &str) const
{
switch (entry.index())
{
@@ -186,7 +186,7 @@ void ns32000_device::state_string_export(device_state_entry const &entry, std::s
}
}
-s32 ns32000_device::displacement(unsigned &bytes)
+template <int Width> s32 ns32000_device<Width>::displacement(unsigned &bytes)
{
s32 disp = space(0).read_byte(m_pc + bytes);
if (BIT(disp, 7))
@@ -214,7 +214,7 @@ s32 ns32000_device::displacement(unsigned &bytes)
return disp;
}
-void ns32000_device::decode(addr_mode *mode, unsigned imm_size, unsigned &bytes)
+template <int Width> void ns32000_device<Width>::decode(addr_mode *mode, unsigned imm_size, unsigned &bytes)
{
bool scaled[] = { false, false };
@@ -325,7 +325,7 @@ void ns32000_device::decode(addr_mode *mode, unsigned imm_size, unsigned &bytes)
}
}
-u32 ns32000_device::ea(addr_mode const mode)
+template <int Width> u32 ns32000_device<Width>::ea(addr_mode const mode)
{
u32 base;
@@ -352,7 +352,7 @@ u32 ns32000_device::ea(addr_mode const mode)
return base + mode.disp;
}
-u64 ns32000_device::gen_read(addr_mode mode, unsigned size)
+template <int Width> u64 ns32000_device<Width>::gen_read(addr_mode mode, unsigned size)
{
u64 data = 0;
@@ -396,7 +396,7 @@ u64 ns32000_device::gen_read(addr_mode mode, unsigned size)
return data;
}
-s64 ns32000_device::gen_read_sx(addr_mode mode, unsigned size)
+template <int Width> s64 ns32000_device<Width>::gen_read_sx(addr_mode mode, unsigned size)
{
u64 data = gen_read(mode, size);
@@ -411,7 +411,7 @@ s64 ns32000_device::gen_read_sx(addr_mode mode, unsigned size)
return data;
}
-void ns32000_device::gen_write(addr_mode mode, unsigned size, u64 data)
+template <int Width> void ns32000_device<Width>::gen_write(addr_mode mode, unsigned size, u64 data)
{
switch (mode.type)
{
@@ -450,7 +450,7 @@ void ns32000_device::gen_write(addr_mode mode, unsigned size, u64 data)
}
}
-bool ns32000_device::condition(unsigned const cc)
+template <int Width> bool ns32000_device<Width>::condition(unsigned const cc)
{
switch (cc & 15)
{
@@ -492,7 +492,7 @@ bool ns32000_device::condition(unsigned const cc)
return false;
}
-void ns32000_device::flags(u32 const src1, u32 const src2, u32 const dest, unsigned const size, bool const subtraction)
+template <int Width> void ns32000_device<Width>::flags(u32 const src1, u32 const src2, u32 const dest, unsigned const size, bool const subtraction)
{
unsigned const sign_bit = (size + 1) * 8 - 1;
@@ -508,7 +508,7 @@ void ns32000_device::flags(u32 const src1, u32 const src2, u32 const dest, unsig
m_psr |= PSR_F;
}
-void ns32000_device::interrupt(unsigned const vector, u32 const return_address, bool const trap)
+template <int Width> void ns32000_device<Width>::interrupt(unsigned const vector, u32 const return_address, bool const trap)
{
// clear trace pending flag
if (vector == TRC)
@@ -543,7 +543,7 @@ void ns32000_device::interrupt(unsigned const vector, u32 const return_address,
// TODO: flush queue
}
-void ns32000_device::execute_run()
+template <int Width> void ns32000_device<Width>::execute_run()
{
while (m_icount > 0)
{
@@ -866,16 +866,16 @@ void ns32000_device::execute_run()
m_psr &= ~(PSR_N | PSR_Z | PSR_L);
if ((size == SIZE_D && s32(src1) > s32(src2))
- || ((size == SIZE_W && s16(src1) > s16(src2))
- || ((size == SIZE_B && s8(src1) > s8(src2)))))
+ || ((size == SIZE_W && s16(src1) > s16(src2))
+ || ((size == SIZE_B && s8(src1) > s8(src2)))))
m_psr |= PSR_N;
if (src1 == src2)
m_psr |= PSR_Z;
if ((size == SIZE_D && u32(src1) > u32(src2))
- || ((size == SIZE_W && u16(src1) > u16(src2))
- || ((size == SIZE_B && u8(src1) > u8(src2)))))
+ || ((size == SIZE_W && u16(src1) > u16(src2))
+ || ((size == SIZE_B && u8(src1) > u8(src2)))))
m_psr |= PSR_L;
}
m_pc += bytes;
@@ -1160,16 +1160,16 @@ void ns32000_device::execute_run()
m_psr &= ~(PSR_N | PSR_Z | PSR_L);
if ((size == SIZE_D && s32(src1) > s32(src2))
- || ((size == SIZE_W && s16(src1) > s16(src2))
- || ((size == SIZE_B && s8(src1) > s8(src2)))))
+ || ((size == SIZE_W && s16(src1) > s16(src2))
+ || ((size == SIZE_B && s8(src1) > s8(src2)))))
m_psr |= PSR_N;
if (src1 == src2)
m_psr |= PSR_Z;
if ((size == SIZE_D && u32(src1) > u32(src2))
- || ((size == SIZE_W && u16(src1) > u16(src2))
- || ((size == SIZE_B && u8(src1) > u8(src2)))))
+ || ((size == SIZE_W && u16(src1) > u16(src2))
+ || ((size == SIZE_B && u8(src1) > u8(src2)))))
m_psr |= PSR_L;
}
m_pc += bytes;
@@ -1420,13 +1420,13 @@ void ns32000_device::execute_run()
m_psr &= ~PSR_Z;
if ((size == SIZE_D && s32(src1) > s32(src2))
- || ((size == SIZE_W && s16(src1) > s16(src2))
- || ((size == SIZE_B && s8(src1) > s8(src2)))))
+ || ((size == SIZE_W && s16(src1) > s16(src2))
+ || ((size == SIZE_B && s8(src1) > s8(src2)))))
m_psr |= PSR_N;
if ((size == SIZE_D && u32(src1) > u32(src2))
- || ((size == SIZE_W && u16(src1) > u16(src2))
- || ((size == SIZE_B && u8(src1) > u8(src2)))))
+ || ((size == SIZE_W && u16(src1) > u16(src2))
+ || ((size == SIZE_B && u8(src1) > u8(src2)))))
m_psr |= PSR_L;
break;
@@ -2249,6 +2249,18 @@ void ns32000_device::execute_run()
break;
case 0x1e: // format 14
// TODO: mmu
+ {
+ u16 const opword = space(0).read_word_unaligned(m_pc + bytes);
+ bytes += 2;
+
+ addr_mode mode[] = { addr_mode((opword >> 11) & 31), addr_mode(0x13) };
+
+ //unsigned const quick = (opword >> 7) & 15;
+ unsigned const size = opword & 3;
+
+ decode(mode, size, bytes);
+ }
+ m_pc += bytes;
break;
case 0x16: // format 15.0
case 0x36: // format 15.1
@@ -2279,7 +2291,7 @@ void ns32000_device::execute_run()
}
}
-void ns32000_device::execute_set_input(int inputnum, int state)
+template <int Width> void ns32000_device<Width>::execute_set_input(int inputnum, int state)
{
if (state)
m_wait = false;
@@ -2298,7 +2310,7 @@ void ns32000_device::execute_set_input(int inputnum, int state)
}
}
-device_memory_interface::space_config_vector ns32000_device::memory_space_config() const
+template <int Width> device_memory_interface::space_config_vector ns32000_device<Width>::memory_space_config() const
{
return space_config_vector{
std::make_pair(AS_PROGRAM, &m_program_config),
@@ -2312,12 +2324,12 @@ device_memory_interface::space_config_vector ns32000_device::memory_space_config
};
}
-bool ns32000_device::memory_translate(int spacenum, int intention, offs_t &address)
+template <int Width> bool ns32000_device<Width>::memory_translate(int spacenum, int intention, offs_t &address)
{
return true;
}
-std::unique_ptr<util::disasm_interface> ns32000_device::create_disassembler()
+template <int Width> std::unique_ptr<util::disasm_interface> ns32000_device<Width>::create_disassembler()
{
return std::make_unique<ns32000_disassembler>();
}
diff --git a/src/devices/cpu/ns32000/ns32000.h b/src/devices/cpu/ns32000/ns32000.h
index af5977fe52e..800b6982a5d 100644
--- a/src/devices/cpu/ns32000/ns32000.h
+++ b/src/devices/cpu/ns32000/ns32000.h
@@ -6,6 +6,7 @@
#pragma once
+template <int Width>
class ns32000_device : public cpu_device
{
public:
@@ -87,7 +88,7 @@ private:
// emulation state
int m_icount;
- memory_access<24, 1, 0, ENDIANNESS_LITTLE>::cache m_bus[16];
+ typename memory_access<24, Width, 0, ENDIANNESS_LITTLE>::cache m_bus[16];
u32 m_pc; // program counter
u32 m_sb; // static base
@@ -107,19 +108,19 @@ private:
bool m_wait;
};
-class ns32008_device : public ns32000_device
+class ns32008_device : public ns32000_device<0>
{
public:
ns32008_device(machine_config const &mconfig, char const *tag, device_t *owner, u32 clock);
};
-class ns32016_device : public ns32000_device
+class ns32016_device : public ns32000_device<1>
{
public:
ns32016_device(machine_config const &mconfig, char const *tag, device_t *owner, u32 clock);
};
-class ns32032_device : public ns32000_device
+class ns32032_device : public ns32000_device<2>
{
public:
ns32032_device(machine_config const &mconfig, char const *tag, device_t *owner, u32 clock);
diff --git a/src/devices/cpu/tms34010/tms34010.cpp b/src/devices/cpu/tms34010/tms34010.cpp
index d5fd882a484..ab820fc1599 100644
--- a/src/devices/cpu/tms34010/tms34010.cpp
+++ b/src/devices/cpu/tms34010/tms34010.cpp
@@ -1178,7 +1178,7 @@ uint32_t tms340x0_device::tms340x0_ind16(screen_device &screen, bitmap_ind16 &bi
params.heblnk = params.hsblnk = cliprect.max_x + 1;
/* blank out the blank regions */
- uint16_t *dest = &bitmap.pix16(cliprect.min_y);
+ uint16_t *dest = &bitmap.pix(cliprect.min_y);
for (x = cliprect.min_x; x < params.heblnk; x++)
dest[x] = blackpen;
for (x = params.hsblnk; x <= cliprect.max_x; x++)
@@ -1209,7 +1209,7 @@ uint32_t tms340x0_device::tms340x0_rgb32(screen_device &screen, bitmap_rgb32 &bi
params.heblnk = params.hsblnk = cliprect.max_x + 1;
/* blank out the blank regions */
- uint32_t *dest = &bitmap.pix32(cliprect.min_y);
+ uint32_t *dest = &bitmap.pix(cliprect.min_y);
for (x = cliprect.min_x; x < params.heblnk; x++)
dest[x] = blackpen;
for (x = params.hsblnk; x <= cliprect.max_x; x++)
diff --git a/src/devices/cpu/tms9900/tms9995.cpp b/src/devices/cpu/tms9900/tms9995.cpp
index 981356ebcd2..89fdcc8d817 100644
--- a/src/devices/cpu/tms9900/tms9995.cpp
+++ b/src/devices/cpu/tms9900/tms9995.cpp
@@ -220,6 +220,8 @@ void tms9995_device::device_start()
m_source_value = 0;
+ m_index = 0;
+
// add the states for the debugger
for (int i=0; i < 20; i++)
{
@@ -242,7 +244,7 @@ void tms9995_device::device_start()
save_item(NAME(PC));
save_item(NAME(ST));
// save_item(NAME(PC_debug)); // only for debugger output
- save_pointer(NAME(m_onchip_memory),256);
+ save_item(NAME(m_onchip_memory));
save_item(NAME(m_idle_state));
save_item(NAME(m_nmi_state));
save_item(NAME(m_hold_state));
@@ -285,7 +287,7 @@ void tms9995_device::device_start()
save_item(NAME(m_cru_address));
save_item(NAME(m_cru_value));
save_item(NAME(m_cru_first_read));
- save_pointer(NAME(m_flag),16);
+ save_item(NAME(m_flag));
save_item(NAME(IR));
save_item(NAME(m_pre_IR));
save_item(NAME(m_command));
diff --git a/src/devices/cpu/vt50/vt50.cpp b/src/devices/cpu/vt50/vt50.cpp
index 961dca5aa2c..7a964c4be5b 100644
--- a/src/devices/cpu/vt50/vt50.cpp
+++ b/src/devices/cpu/vt50/vt50.cpp
@@ -284,7 +284,7 @@ void vt5x_cpu_device::draw_char_line()
if (xc > screen().visible_area().right() - 8)
return;
- u32 *pix = &m_bitmap.pix32(m_current_line, xc);
+ u32 *pix = &m_bitmap.pix(m_current_line, xc);
if (m_video_process && m_cursor_ff && m_cursor_active)
std::fill_n(pix, 9, rgb_t::white());
else if (!m_video_process || m_cursor_ff)