From 96e7fc45cf4ec06dc4fb56ecba097b8212b23d4f Mon Sep 17 00:00:00 2001 From: David Haywood Date: Wed, 27 Dec 2023 17:58:24 +0000 Subject: [PATCH 01/62] Epoch Cassette Vision software list holder --- hash/cassvisn_cart.xml | 185 ++++++++++++++++++++++++++++++++++++ src/mame/epoch/cassvisn.cpp | 51 ++++++++++ src/mame/mame.lst | 3 + 3 files changed, 239 insertions(+) create mode 100644 hash/cassvisn_cart.xml create mode 100644 src/mame/epoch/cassvisn.cpp diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml new file mode 100644 index 0000000000000..964033d49ab7b --- /dev/null +++ b/hash/cassvisn_cart.xml @@ -0,0 +1,185 @@ + + + + + + + + + D777C002 + 1981 + Epoch + + + + + + + + + + + + D777C004 + 1981 + Epoch + + + + + + + + + + + + D777C005 + 1981 + Epoch + + + + + + + + + + + + D777C007 + 1981 + Epoch + + + + + + + + + + + + D777C008 + 1981 + Epoch + + + + + + + + + + + + D777C009 + 1981 + Epoch + + + + + + + + + + + + D777C010 + 1981 + Epoch + + + + + + + + + + + + D777C013 + 1981 + Epoch + + + + + + + + + + + + D777C015 + 1981 + Epoch + + + + + + + + + + + + D774C + 1981 + Epoch + + + + + + + + + + + + D778C + 1981 + Epoch + + + + + + + + + + + diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp new file mode 100644 index 0000000000000..a53a6149d9f99 --- /dev/null +++ b/src/mame/epoch/cassvisn.cpp @@ -0,0 +1,51 @@ +// license:BSD-3-Clause +// copyright-holders: + +#include "emu.h" +#include "bus/generic/slot.h" +#include "bus/generic/carts.h" +#include "softlist_dev.h" + +namespace { + +class cassvisn_state : public driver_device +{ +public: + cassvisn_state(const machine_config &mconfig, device_type type, const char *tag) : + driver_device(mconfig, type, tag), + m_cart(*this, "cartslot") + { } + + void cassvisn(machine_config &config); +protected: + DECLARE_DEVICE_IMAGE_LOAD_MEMBER(cart_load); + required_device m_cart; +}; + +static INPUT_PORTS_START( cassvisn ) +INPUT_PORTS_END + +DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) +{ + uint32_t size = m_cart->common_get_size("rom"); + m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_LITTLE); + m_cart->common_load_rom(m_cart->get_rom_base(), size, "rom"); + return std::make_pair(std::error_condition(), std::string()); +} + +void cassvisn_state::cassvisn(machine_config &config) +{ + GENERIC_CARTSLOT(config, m_cart, generic_plain_slot, "cassvisn_cart"); + m_cart->set_width(GENERIC_ROM16_WIDTH); + m_cart->set_device_load(FUNC(cassvisn_state::cart_load)); + m_cart->set_must_be_loaded(true); + + SOFTWARE_LIST(config, "cart_list").set_original("cassvisn_cart"); +} + +ROM_START( cassvisn ) +ROM_END + +} // anonymous namespace + +CONS( 1981, cassvisn, 0, 0, cassvisn, cassvisn, cassvisn_state, empty_init, "Epoch", "Cassette Vision", MACHINE_IS_SKELETON ) diff --git a/src/mame/mame.lst b/src/mame/mame.lst index 92ef9c7a8b359..2a13f3094ef10 100644 --- a/src/mame/mame.lst +++ b/src/mame/mame.lst @@ -17576,6 +17576,9 @@ touryuu // (c) 200? Yuki Enterprise @source:eolith/vegaeo.cpp crazywar // (c) 2002 Eolith +@source:epoch/cassvisn.cpp +cassvisn + @source:epoch/gamepock.cpp gamepock // Epoch Game Pocket Computer From 9e235d96a0727ff96832e8b63591a21083a8e82f Mon Sep 17 00:00:00 2001 From: David Haywood Date: Wed, 27 Dec 2023 18:47:26 +0000 Subject: [PATCH 02/62] add likely names --- hash/cassvisn_cart.xml | 55 +++++++++++++++++++++--------------------- 1 file changed, 27 insertions(+), 28 deletions(-) diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index 964033d49ab7b..66010c444c937 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -15,21 +15,18 @@ The following games exist for this platform 7 New Baseball 8 Monster Mansion 9 Astro Command -10 Grand Champion +10 Grand Champion* 11 Monster Block 12 Elevator Panic -TODO: Identify which game is which, the PCB scans provided in some cases seem mismatched with the - other details. - The D774C PCB is marked "TV Vader & Yosaku" (do they share an MCU?) - The Galaxian PCB is marked D777C-006 but none of these dumps are? - etc. +* = not dumped + --> - - D777C002 + + New Baseball 1981 Epoch @@ -42,8 +39,8 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D777C004 + + Big Sports 12 1981 Epoch @@ -56,8 +53,8 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D777C005 + + Yosaku 1981 Epoch @@ -70,8 +67,9 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D777C007 + + + Galaxian 1981 Epoch @@ -84,8 +82,8 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D777C008 + + PakPak Monster 1981 Epoch @@ -98,8 +96,8 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D777C009 + + Monster Mansion 1981 Epoch @@ -112,8 +110,8 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D777C010 + + Astro Command 1981 Epoch @@ -126,8 +124,8 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D777C013 + + Monster Block 1981 Epoch @@ -140,8 +138,8 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D777C015 + + Elevator Panic 1981 Epoch @@ -154,8 +152,9 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D774C + + + Battle Vader 1981 Epoch @@ -168,8 +167,8 @@ TODO: Identify which game is which, the PCB scans provided in some cases seem mi - - D778C + + Baseball 1981 Epoch From 9c6a69591952beda6ceb968cd8f528db3df898e6 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Wed, 27 Dec 2023 19:28:56 +0000 Subject: [PATCH 03/62] reorder list based on release order --- hash/cassvisn_cart.xml | 92 +++++++++++++++++++++--------------------- 1 file changed, 46 insertions(+), 46 deletions(-) diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index 66010c444c937..64332a5ff7f1b 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -25,59 +25,74 @@ The following games exist for this platform - - New Baseball + + Yosaku 1981 Epoch - + - + - - Big Sports 12 + + Baseball 1981 Epoch - + - + + + + + + + + Galaxian + 1981 + Epoch + + + + + + - - Yosaku + + Big Sports 12 1981 Epoch - + - + - - - Galaxian + + + Battle Vader 1981 Epoch - + - + @@ -96,6 +111,20 @@ The following games exist for this platform + + New Baseball + 1981 + Epoch + + + + + + + + + + Monster Mansion 1981 @@ -151,34 +180,5 @@ The following games exist for this platform - - - - Battle Vader - 1981 - Epoch - - - - - - - - - - - - Baseball - 1981 - Epoch - - - - - - - - - From 84ee2b83468316ae1b200b3d999c88608518f55b Mon Sep 17 00:00:00 2001 From: David Haywood Date: Wed, 27 Dec 2023 22:06:10 +0000 Subject: [PATCH 04/62] add note where CPU information can be found --- src/mame/epoch/cassvisn.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index a53a6149d9f99..594adc417500a 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -1,6 +1,15 @@ // license:BSD-3-Clause // copyright-holders: +/* + +for architecture details see +https://www.oguchi-rd.com/LSI%20products.php +the linked 'design note' contains a large amount of useful information +https://www.oguchi-rd.com/777/777%20Design%20Note.pdf + +*/ + #include "emu.h" #include "bus/generic/slot.h" #include "bus/generic/carts.h" From 0be4b63a3d9a5f95aace8a58c64f4b648a947266 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Fri, 29 Dec 2023 18:48:11 +0000 Subject: [PATCH 05/62] preliminary disassembler --- hash/cassvisn_cart.xml | 22 +- scripts/src/cpu.lua | 18 + src/devices/cpu/upd777/upd777.cpp | 104 +++ src/devices/cpu/upd777/upd777.h | 53 ++ src/devices/cpu/upd777/upd777dasm.cpp | 1154 +++++++++++++++++++++++++ src/devices/cpu/upd777/upd777dasm.h | 47 + src/mame/epoch/cassvisn.cpp | 23 +- 7 files changed, 1407 insertions(+), 14 deletions(-) create mode 100644 src/devices/cpu/upd777/upd777.cpp create mode 100644 src/devices/cpu/upd777/upd777.h create mode 100644 src/devices/cpu/upd777/upd777dasm.cpp create mode 100644 src/devices/cpu/upd777/upd777dasm.h diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index 64332a5ff7f1b..d7ebcec017a29 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -31,7 +31,7 @@ The following games exist for this platform Epoch - + @@ -45,7 +45,7 @@ The following games exist for this platform Epoch - + @@ -60,7 +60,7 @@ The following games exist for this platform Epoch - + @@ -74,7 +74,7 @@ The following games exist for this platform Epoch - + @@ -89,7 +89,7 @@ The following games exist for this platform Epoch - + @@ -103,7 +103,7 @@ The following games exist for this platform Epoch - + @@ -117,7 +117,7 @@ The following games exist for this platform Epoch - + @@ -131,7 +131,7 @@ The following games exist for this platform Epoch - + @@ -145,7 +145,7 @@ The following games exist for this platform Epoch - + @@ -159,7 +159,7 @@ The following games exist for this platform Epoch - + @@ -173,7 +173,7 @@ The following games exist for this platform Epoch - + diff --git a/scripts/src/cpu.lua b/scripts/src/cpu.lua index 1afc05b20eefb..64f7e093a277a 100644 --- a/scripts/src/cpu.lua +++ b/scripts/src/cpu.lua @@ -3949,3 +3949,21 @@ if opt_tool(CPUS, "HT1130") then table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/ht1130/ht1130d.cpp") table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/ht1130/ht1130d.h") end + +-------------------------------------------------- +-- UPD777 +--@src/devices/cpu/upd777/upd777.h,CPUS["UPD777"] = true +-------------------------------------------------- + +if CPUS["UPD777"] then + files { + MAME_DIR .. "src/devices/cpu/upd777/upd777.cpp", + MAME_DIR .. "src/devices/cpu/upd777/upd777.h", + } +end + +if opt_tool(CPUS, "UPD777") then + table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/upd777/upd777dasm.cpp") + table.insert(disasm_files , MAME_DIR .. "src/devices/cpu/upd777/upd777dasm.h") +end + diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp new file mode 100644 index 0000000000000..3390b8789ad84 --- /dev/null +++ b/src/devices/cpu/upd777/upd777.cpp @@ -0,0 +1,104 @@ +// license:BSD-3-Clause +// copyright-holders:David Haywood + +#include "emu.h" +#include "upd777.h" +#include "upd777dasm.h" + +#define LOG_UNHANDLED_OPS (1U << 1) + +#define VERBOSE (LOG_UNHANDLED_OPS) +#include "logmacro.h" + +// device type definitions +DEFINE_DEVICE_TYPE(UPD777, upd777_device, "upd777", "uPD777") + + + +upd777_device::upd777_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data) + : cpu_device(mconfig, type, tag, owner, clock) + , m_space_config("program", ENDIANNESS_LITTLE, 16, 11, -1, address_map_constructor(FUNC(upd777_device::internal_map), this)) + , m_data_config("data", ENDIANNESS_LITTLE, 8, 8, 0, data) +{ +} + +upd777_device::upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : upd777_device(mconfig, UPD777, tag, owner, clock, address_map_constructor(FUNC(upd777_device::internal_data_map), this)) +{ +} + +std::unique_ptr upd777_device::create_disassembler() +{ + return std::make_unique(); +} + +device_memory_interface::space_config_vector upd777_device::memory_space_config() const +{ + return space_config_vector{ + std::make_pair(AS_PROGRAM, &m_space_config), + std::make_pair(AS_DATA, &m_data_config) + }; +} + +void upd777_device::internal_map(address_map &map) +{ + map(0x000, 0x7ff).rom(); +} + +void upd777_device::internal_data_map(address_map &map) +{ +} + +void upd777_device::device_start() +{ + space(AS_PROGRAM).specific(m_space); + space(AS_DATA).specific(m_data); + + set_icountptr(m_icount); + + state_add(UPD777_PC, "PC", m_pc); + state_add(STATE_GENPC, "GENPC", m_pc).noshow(); + state_add(STATE_GENPCBASE, "CURPC", m_pc).noshow(); + + upd777_disassembler::populate_addr_table(m_table); + + save_item(NAME(m_pc)); + save_item(NAME(m_icount)); +} + +void upd777_device::device_reset() +{ + m_pc = 0; +} + +u16 upd777_device::fetch() +{ + return m_space.read_word(m_pc++); +} + +void upd777_device::do_op() +{ + const u16 inst = fetch(); + + switch (inst) + { + default: + { + LOGMASKED(LOG_UNHANDLED_OPS, "", inst); + return; + } + } +} + +void upd777_device::execute_run() +{ + while (m_icount > 0) + { + debugger_instruction_hook(m_pc); + do_op(); + } +} + +void upd777_device::execute_set_input(int inputnum, int state) +{ +} diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h new file mode 100644 index 0000000000000..ee564c1d8fdbe --- /dev/null +++ b/src/devices/cpu/upd777/upd777.h @@ -0,0 +1,53 @@ +// license:BSD-3-Clause +// copyright-holders:David Haywood + +#ifndef MAME_CPU_UPD777_UPD777_H +#define MAME_CPU_UPD777_UPD777_H + +#pragma once + + +class upd777_device : public cpu_device +{ +public: + upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); + + enum { + UPD777_PC = 0 + }; + +protected: + upd777_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data); + + virtual void device_start() override; + virtual void device_reset() override; + + virtual void execute_run() override; + virtual void execute_set_input(int inputnum, int state) override; + + virtual std::unique_ptr create_disassembler() override; + + virtual space_config_vector memory_space_config() const override; + + void internal_map(address_map &map); + void internal_data_map(address_map &map); + +private: + address_space_config m_space_config; + address_space_config m_data_config; + + memory_access<11, 1, -1, ENDIANNESS_LITTLE>::specific m_space; + memory_access<8, 0, 0, ENDIANNESS_LITTLE>::specific m_data; + + u16 fetch(); + void do_op(); + + u16 m_table[0xfe0/2]; + + u32 m_pc; + s32 m_icount; +}; + +DECLARE_DEVICE_TYPE(UPD777, upd777_device) + +#endif // MAME_CPU_UPD777_UPD777_H diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp new file mode 100644 index 0000000000000..b9f457c13d250 --- /dev/null +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -0,0 +1,1154 @@ +// license:BSD-3-Clause +// copyright-holders:David Haywood + +#include "emu.h" +#include "upd777dasm.h" + +upd777_disassembler::upd777_disassembler() + : util::disasm_interface() +{ + populate_addr_table(m_table); +} + +u32 upd777_disassembler::opcode_alignment() const +{ + return 1; +} + +u16 upd777_disassembler::get_table(u16 addr) +{ + if (addr < 0xfe0) + { + return m_table[addr]; + } + else + { + return 0xffff; + } +} + +offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const upd777_disassembler::data_buffer &opcodes, const upd777_disassembler::data_buffer ¶ms) +{ + u16 inst = opcodes.r16(pc); + + if (inst < 0x800) + { + switch (inst) + { + case 0b000000000000: + { // No Operation + util::stream_format(stream, "%04x: NOP", get_table(pc)); + break; + } + + // case 0b000000000001: case 0b000000000010: case 0b000000000011: + + case 0b000000000100: + { // Skip if (Gun Port Latch) = 1 + util::stream_format(stream, "%04x: GPL", get_table(pc)); + break; + } + + //case 0b000000000101: case 0b000000000110: case 0b000000000111: + + case 0b000000001000: + { // Move H[5:1] to Line Buffer Register[5:1] + util::stream_format(stream, "%04x: H->NRM", get_table(pc)); + break; + } + + //case 0b000000001001: case 0b000000001010: case 0b000000001011: case 0b000000001100: case 0b000000001101: case 0b000000001110: case 0b000000001111: case 0b000000010000: case 0b000000010001: case 0b000000010010: case 0b000000010011: case 0b000000010100: case 0b000000010101: case 0b000000010110: case 0b000000010111: + + case 0b000000011000: + { // H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] + util::stream_format(stream, "%04x: H<->X", get_table(pc)); + break; + } + + // case 0b000000011001: case 0b000000011010: case 0b000000011011: case 0b000000011100: case 0b000000011101: case 0b000000011110: case 0b000000011111: + + case 0b000000100000: + { // Subroutine End, Pop down address stack + util::stream_format(stream, "%04x: SRE", get_table(pc)); + break; + } + + // case 0b000000100001: case 0b000000100010: case 0b000000100011: case 0b000000100100: case 0b000000100101: case 0b000000100110: case 0b000000100111: + + case 0b000000101000: case 0b000000101001: + { // Shift STB[4:1], N->STB[1] + util::stream_format(stream, "%04x: %d->STB", get_table(pc), inst & 1); + break; + } + + // case 0b000000101010: case 0b000000101011: case 0b000000101100: case 0b000000101101: case 0b000000101110: case 0b000000101111: + + case 0b000000110000: + { // Skip if (PD1 input) = 1 + util::stream_format(stream, "%04x: PD1 J", get_table(pc)); + break; + } + + // case 0b000000110001: case 0b000000110010: case 0b000000110011: + + case 0b000000110100: + { // Skip if (PD2 input) = 1 + util::stream_format(stream, "%04x: PD2 J", get_table(pc)); + break; + } + + //case 0b000000110101: case 0b000000110110: case 0b000000110111: + + case 0b000000111000: + { // Skip if (PD3 input) = 1 + util::stream_format(stream, "%04x: PD3 J", get_table(pc)); + break; + } + + //case 0b000000111001: case 0b000000111010: case 0b000000111011: + + case 0b000000111100: + { // Skip if (PD4 input) = 1 + util::stream_format(stream, "%04x: PD4 J", get_table(pc)); + break; + } + + //case 0b000000111101: case 0b000000111110: case 0b000000111111: case 0b000001000000: case 0b000001000001: case 0b000001000010: case 0b000001000011: case 0b000001000100: case 0b000001000101: case 0b000001000110: case 0b000001000111: case 0b000001001000: + + case 0b000001001001: + { // Skip if (4H Horizontal Blank) = 1 + util::stream_format(stream, "%04x: 4H BLK", get_table(pc)); + break; + } + + case 0b000001001010: + { // Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] + + util::stream_format(stream, "%04x: VBLK", get_table(pc)); + break; + } + + //case 0b000001001011: + + case 0b000001001100: + { // Skip if (GP&SW/ input) = 1 + util::stream_format(stream, "%04x: GPSW/", get_table(pc)); + break; + } + + // case 0b000001001101: case 0b000001001110: case 0b000001001111: case 0b000001010000: case 0b000001010001: case 0b000001010010: case 0b000001010011: + + case 0b000001010100: + { // Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] + util::stream_format(stream, "%04x: A->MA", get_table(pc)); + break; + } + + // case 0b000001010101: case 0b000001010110: case 0b000001010111: + + case 0b000001011000: + { // Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) + util::stream_format(stream, "%04x: MA->A", get_table(pc)); + break; + } + + // case 0b000001011001: case 0b000001011010: case 0b000001011011: + + case 0b000001011100: + { // Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] + util::stream_format(stream, "%04x: MA<->A", get_table(pc)); + break; + } + + // case 0b000001011101: case 0b000001011110: case 0b000001011111: + + case 0b000001100000: + { // Subroutine End, Pop down address stack, Skip + util::stream_format(stream, "%04x: SRE+1", get_table(pc)); + break; + } + + // case 0b000001100001: case 0b000001100010: case 0b000001100011: case 0b000001100100: case 0b000001100101: case 0b000001100110: case 0b000001100111: case 0b000001101000: case 0b000001101001: case 0b000001101010: case 0b000001101011: case 0b000001101100: case 0b000001101101: case 0b000001101110: case 0b000001101111: + + case 0b000001110000: + { // Skip if (PD1 input) = 0 + util::stream_format(stream, "%04x: PD1 /J", get_table(pc), inst); + break; + } + + // case 0b000001110001: case 0b000001110010: case 0b000001110011: + + case 0b000001110100: + { // Skip if (PD2 input) = 0 + util::stream_format(stream, "%04x: PD2 /J", get_table(pc), inst); + break; + } + + // case 0b000001110101: case 0b000001110110: case 0b000001110111: + + case 0b000001111000: + { // Skip if (PD3 input) = 0 + util::stream_format(stream, "%04x: PD3 /J", get_table(pc), inst); + break; + } + + // case 0b000001111001: case 0b000001111010: case 0b000001111011: + + case 0b000001111100: + { // Skip if (PD4 input) = 0 + util::stream_format(stream, "%04x: PD4 /J", get_table(pc), inst); + break; + } + + // case 0b000001111101: case 0b000001111110: case 0b000001111111: + + case 0b000010000000: case 0b000010000001: case 0b000010000010: case 0b000010000011: case 0b000010000100: case 0b000010000101: case 0b000010000110: case 0b000010000111: case 0b000010001000: case 0b000010001001: case 0b000010001010: case 0b000010001011: case 0b000010001100: case 0b000010001101: case 0b000010001110: case 0b000010001111: case 0b000010010000: case 0b000010010001: case 0b000010010010: case 0b000010010011: case 0b000010010100: case 0b000010010101: case 0b000010010110: case 0b000010010111: case 0b000010011000: case 0b000010011001: case 0b000010011010: case 0b000010011011: case 0b000010011100: case 0b000010011101: case 0b000010011110: case 0b000010011111: case 0b000010100000: case 0b000010100001: case 0b000010100010: case 0b000010100011: case 0b000010100100: case 0b000010100101: case 0b000010100110: case 0b000010100111: case 0b000010101000: case 0b000010101001: case 0b000010101010: case 0b000010101011: case 0b000010101100: case 0b000010101101: case 0b000010101110: case 0b000010101111: case 0b000010110000: case 0b000010110001: case 0b000010110010: case 0b000010110011: case 0b000010110100: case 0b000010110101: case 0b000010110110: case 0b000010110111: case 0b000010111000: case 0b000010111001: case 0b000010111010: case 0b000010111011: case 0b000010111100: case 0b000010111101: case 0b000010111110: case 0b000010111111: case 0b000011000000: case 0b000011000001: case 0b000011000010: case 0b000011000011: case 0b000011000100: case 0b000011000101: case 0b000011000110: case 0b000011000111: case 0b000011001000: case 0b000011001001: case 0b000011001010: case 0b000011001011: case 0b000011001100: case 0b000011001101: case 0b000011001110: case 0b000011001111: case 0b000011010000: case 0b000011010001: case 0b000011010010: case 0b000011010011: case 0b000011010100: case 0b000011010101: case 0b000011010110: case 0b000011010111: case 0b000011011000: case 0b000011011001: case 0b000011011010: case 0b000011011011: case 0b000011011100: case 0b000011011101: case 0b000011011110: case 0b000011011111: case 0b000011100000: case 0b000011100001: case 0b000011100010: case 0b000011100011: case 0b000011100100: case 0b000011100101: case 0b000011100110: case 0b000011100111: case 0b000011101000: case 0b000011101001: case 0b000011101010: case 0b000011101011: case 0b000011101100: case 0b000011101101: case 0b000011101110: case 0b000011101111: case 0b000011110000: case 0b000011110001: case 0b000011110010: case 0b000011110011: case 0b000011110100: case 0b000011110101: case 0b000011110110: case 0b000011110111: case 0b000011111000: case 0b000011111001: case 0b000011111010: case 0b000011111011: case 0b000011111100: case 0b000011111101: case 0b000011111110: case 0b000011111111: + { // Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow + util::stream_format(stream, "%04x: M-K(%02x)", get_table(pc), inst & 0x7f); + break; + } + + + case 0b000100000000: case 0b000100000001: case 0b000100000010: case 0b000100000011: case 0b000100000100: case 0b000100000101: case 0b000100000110: case 0b000100000111: case 0b000100001000: case 0b000100001001: case 0b000100001010: case 0b000100001011: case 0b000100001100: case 0b000100001101: case 0b000100001110: case 0b000100001111: case 0b000100010000: case 0b000100010001: case 0b000100010010: case 0b000100010011: case 0b000100010100: case 0b000100010101: case 0b000100010110: case 0b000100010111: case 0b000100011000: case 0b000100011001: case 0b000100011010: case 0b000100011011: case 0b000100011100: case 0b000100011101: case 0b000100011110: case 0b000100011111: case 0b000100100000: case 0b000100100001: case 0b000100100010: case 0b000100100011: case 0b000100100100: case 0b000100100101: case 0b000100100110: case 0b000100100111: case 0b000100101000: case 0b000100101001: case 0b000100101010: case 0b000100101011: case 0b000100101100: case 0b000100101101: case 0b000100101110: case 0b000100101111: case 0b000100110000: case 0b000100110001: case 0b000100110010: case 0b000100110011: case 0b000100110100: case 0b000100110101: case 0b000100110110: case 0b000100110111: case 0b000100111000: case 0b000100111001: case 0b000100111010: case 0b000100111011: case 0b000100111100: case 0b000100111101: case 0b000100111110: case 0b000100111111: case 0b000101000000: case 0b000101000001: case 0b000101000010: case 0b000101000011: case 0b000101000100: case 0b000101000101: case 0b000101000110: case 0b000101000111: case 0b000101001000: case 0b000101001001: case 0b000101001010: case 0b000101001011: case 0b000101001100: case 0b000101001101: case 0b000101001110: case 0b000101001111: case 0b000101010000: case 0b000101010001: case 0b000101010010: case 0b000101010011: case 0b000101010100: case 0b000101010101: case 0b000101010110: case 0b000101010111: case 0b000101011000: case 0b000101011001: case 0b000101011010: case 0b000101011011: case 0b000101011100: case 0b000101011101: case 0b000101011110: case 0b000101011111: case 0b000101100000: case 0b000101100001: case 0b000101100010: case 0b000101100011: case 0b000101100100: case 0b000101100101: case 0b000101100110: case 0b000101100111: case 0b000101101000: case 0b000101101001: case 0b000101101010: case 0b000101101011: case 0b000101101100: case 0b000101101101: case 0b000101101110: case 0b000101101111: case 0b000101110000: case 0b000101110001: case 0b000101110010: case 0b000101110011: case 0b000101110100: case 0b000101110101: case 0b000101110110: case 0b000101110111: case 0b000101111000: case 0b000101111001: case 0b000101111010: case 0b000101111011: case 0b000101111100: case 0b000101111101: case 0b000101111110: case 0b000101111111: + { // M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] + + util::stream_format(stream, "%04x: M+K(%02x)->M, N(%01x)->L", get_table(pc), inst & 0x1f, (inst >> 5) & 0x3); + break; + } + + case 0b000110000000: case 0b000110000001: case 0b000110000010: case 0b000110000011: case 0b000110000100: case 0b000110000101: case 0b000110000110: case 0b000110000111: case 0b000110001000: case 0b000110001001: case 0b000110001010: case 0b000110001011: case 0b000110001100: case 0b000110001101: case 0b000110001110: case 0b000110001111: case 0b000110010000: case 0b000110010001: case 0b000110010010: case 0b000110010011: case 0b000110010100: case 0b000110010101: case 0b000110010110: case 0b000110010111: case 0b000110011000: case 0b000110011001: case 0b000110011010: case 0b000110011011: case 0b000110011100: case 0b000110011101: case 0b000110011110: case 0b000110011111: case 0b000110100000: case 0b000110100001: case 0b000110100010: case 0b000110100011: case 0b000110100100: case 0b000110100101: case 0b000110100110: case 0b000110100111: case 0b000110101000: case 0b000110101001: case 0b000110101010: case 0b000110101011: case 0b000110101100: case 0b000110101101: case 0b000110101110: case 0b000110101111: case 0b000110110000: case 0b000110110001: case 0b000110110010: case 0b000110110011: case 0b000110110100: case 0b000110110101: case 0b000110110110: case 0b000110110111: case 0b000110111000: case 0b000110111001: case 0b000110111010: case 0b000110111011: case 0b000110111100: case 0b000110111101: case 0b000110111110: case 0b000110111111: case 0b000111000000: case 0b000111000001: case 0b000111000010: case 0b000111000011: case 0b000111000100: case 0b000111000101: case 0b000111000110: case 0b000111000111: case 0b000111001000: case 0b000111001001: case 0b000111001010: case 0b000111001011: case 0b000111001100: case 0b000111001101: case 0b000111001110: case 0b000111001111: case 0b000111010000: case 0b000111010001: case 0b000111010010: case 0b000111010011: case 0b000111010100: case 0b000111010101: case 0b000111010110: case 0b000111010111: case 0b000111011000: case 0b000111011001: case 0b000111011010: case 0b000111011011: case 0b000111011100: case 0b000111011101: case 0b000111011110: case 0b000111011111: case 0b000111100000: case 0b000111100001: case 0b000111100010: case 0b000111100011: case 0b000111100100: case 0b000111100101: case 0b000111100110: case 0b000111100111: case 0b000111101000: case 0b000111101001: case 0b000111101010: case 0b000111101011: case 0b000111101100: case 0b000111101101: case 0b000111101110: case 0b000111101111: case 0b000111110000: case 0b000111110001: case 0b000111110010: case 0b000111110011: case 0b000111110100: case 0b000111110101: case 0b000111110110: case 0b000111110111: case 0b000111111000: case 0b000111111001: case 0b000111111010: case 0b000111111011: case 0b000111111100: case 0b000111111101: case 0b000111111110: case 0b000111111111: + { // M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: M-K(%02x)->M, N(%01x)->L", get_table(pc), inst & 0x1f, (inst >> 5) & 0x3); + break; + } + + + ///////////////////////////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////////////////////////// + + // 200 + case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: + { // Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] + util::stream_format(stream, "%04x: A1·A1, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 204 + //case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: + + // 208 + case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: + { // Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) + util::stream_format(stream, "%04x: A1=A1, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 20c + case 0b001000001100: case 0b001000001101: case 0b001000001110:case 0b001000001111: + { // Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] + util::stream_format(stream, "%04x: A1-A1, %d->L BOJ", get_table(pc), inst & 0x3); + break; + } + + // 210 + case 0b001000010000: case 0b001000010001: case 0b001000010010: case 0b001000010011: + { // Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] + util::stream_format(stream, "%04x: A1·A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 214 + // case 0b001000010100: case 0b001000010101: case 0b001000010110: case 0b001000010111: + + // 218 + case 0b001000011000: case 0b001000011001: case 0b001000011010: case 0b001000011011: + { // Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) + util::stream_format(stream, "%04x: A1=A2, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 21c + case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: + { // Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] + util::stream_format(stream, "%04x: A1-A2, %d->L BOJ", get_table(pc), inst & 0x3); + break; + } + + // 220 + case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: + { // Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: A1·A1, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 224 + // case 0b001000100100: case 0b001000100101: case 0b001000100110: case 0b001000100111: + + // 228 + case 0b001000101000: case 0b001000101001: case 0b001000101010:case 0b001000101011: + { // Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) + util::stream_format(stream, "%04x: A1=A1, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 22c + case 0b001000101100: case 0b001000101101: case 0b001000101110: case 0b001000101111: + { // Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + util::stream_format(stream, "%04x: A1-A1, %d->L BOJ/", get_table(pc), inst & 0x3); + break; + } + + // 230 + case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: + { // Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: A1·A2, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 234 + //case 0b001000110100: case 0b001000110101: case 0b001000110110: case 0b001000110111: + + // 238 + case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: + { // Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) + util::stream_format(stream, "%04x: A1=A2, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 23c + case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: + { // Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + util::stream_format(stream, "%04x: A1-A2, %d->L BOJ/", get_table(pc), inst & 0x3); + break; + } + + // 240 + case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: + { // Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] + util::stream_format(stream, "%04x: A2·A1, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 244 + //case 0b001001000100: case 0b001001000101: case 0b001001000110: case 0b001001000111: + + // 248 + case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: + { // Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: A2=A1, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 24c + case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: + { // Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] + util::stream_format(stream, "%04x: A2-A1, %d->L BOJ", get_table(pc), inst & 0x3); + break; + } + + // 250 + case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: + { // Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] + util::stream_format(stream, "%04x: A2·A2, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 254 + //case 0b001001010100: case 0b001001010101: case 0b001001010110: case 0b001001010111: + + // 258 + case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: + { // Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: A2=A2, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 25c + case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: + { // Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] + util::stream_format(stream, "%04x: A2-A2, N%(d)->L BOJ", get_table(pc), inst & 0x3); + break; + } + + // 260 + case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: + { // Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: A2·A1, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 264 + //case 0b001001100100: case 0b001001100101: case 0b001001100110: case 0b001001100111: + + // 268 + case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: + { // Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: A2=A1, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 26c + case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: + { // Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + util::stream_format(stream, "%04x: A2-A1, %d->L BOJ/", get_table(pc), inst & 0x3); + break; + } + + // 270 + case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: + { // Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: A2·A2, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 274 + //case 0b001001110100: case 0b001001110101: case 0b001001110110: case 0b001001110111: + + // 278 + case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: + { // Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: A2=A2, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 27c + case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: + { // Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + util::stream_format(stream, "%04x: A2-A2, %d->L BOJ/", get_table(pc), inst & 0x3); + break; + } + + // 280 + case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: + { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] + util::stream_format(stream, "%04x: M·A1, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 284 + //case 0b001010000100: case 0b001010000101: case 0b001010000110: case 0b001010000111: + + // 288 + case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: + { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: M=A1, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 28c + case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: + { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] + util::stream_format(stream, "%04x: M-A1, %d->L BOJ", get_table(pc), inst & 0x3); + break; + } + + // 290 + case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: + { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] + util::stream_format(stream, "%04x: M·A2, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 294 + //case 0b001010010100: case 0b001010010101: case 0b001010010110: case 0b001010010111: + + // 298 + case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: + { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: M=A2, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 29c + case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: + { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] + util::stream_format(stream, "%04x: M-A2, %d->L BOJ", get_table(pc), inst & 0x3); + break; + } + + // 2a0 + case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: + { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: M·A1, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 2a4 + //case 0b001010100100: case 0b001010100101: case 0b001010100110: case 0b001010100111: + + // 2a8 + case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: + { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: M=A1, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 2ac + case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: + { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] + util::stream_format(stream, "%04x: M-A1, %d->L BOJ/", get_table(pc), inst & 0x3); + break; + } + + // 2b0 + case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: + { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: M·A2, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 2b4 + //case 0b001010110100: case 0b001010110101: case 0b001010110110: case 0b001010110111: + + // 2b8 + case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: + { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: M=A2, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 2bc + case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: + { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] + util::stream_format(stream, "%04x: M-A2, %d->L BOJ/", get_table(pc), inst & 0x3); + break; + } + + // 2c0 + case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: + { // Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] + util::stream_format(stream, "%04x: H·A1, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 2c4 + //case 0b001011000100: case 0b001011000101: case 0b001011000110: case 0b001011000111: + + // 2c8 + case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: + { // Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: H=A1, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 2cc + case 0b001011001100: case 0b001011001101: case 0b001011001110: case 0b001011001111: + { // Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] + util::stream_format(stream, "%04x: H-A1, N%(d)->L BOJ", get_table(pc), inst & 0x3); + break; + } + + // 2d0 + case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: + { // Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] + util::stream_format(stream, "%04x: H·A2, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 2d4 + //case 0b001011010100: case 0b001011010101: case 0b001011010110: case 0b001011010111: + + // 2d8 + case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: + { // Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: H=A2, %d->L EQJ", get_table(pc), inst & 0x3); + break; + } + + // 2dc + case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: + { // Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] + util::stream_format(stream, "%04x: H-A2, %d->L BOJ", get_table(pc), inst & 0x3); + break; + } + + // 2e0 + case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: + { // Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: H·A1, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 2e4 + //case 0b001011100100: case 0b001011100101: case 0b001011100110: case 0b001011100111: + + // 2e8 + case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: + { // Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) + util::stream_format(stream, "%04x: H=A1, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 2ec + case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: + { // Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] + util::stream_format(stream, "%04x: H-A1, %d->L BOJ/", get_table(pc), inst & 0x3); + break; + } + + // 2f0 + case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: + { // Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: H·A2, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 2f4 + //case 0b001011110100: case 0b001011110101: case 0b001011110110: case 0b001011110111: + + // 2f8 + case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: + { // Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] + util::stream_format(stream, "%04x: H=A2, %d->L EQJ/", get_table(pc), inst & 0x3); + break; + } + + // 2fc + case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: + { // Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] + util::stream_format(stream, "%04x: H-A2, %d->L BOJ/", get_table(pc), inst & 0x3); + break; + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////////////////////////// + + // 300 + case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: + { // N->L[2:1] + util::stream_format(stream, "%04x: %d->L", get_table(pc), inst & 0x3); + break; + } + + // 304 + //case 0b001100000100: case 0b001100000101: case 0b001100000110: case 0b001100000111: + + // 308 + case 0b001100001000: + { // Move A1[7:1] to FLS[7:1], 0->L[2:1] + util::stream_format(stream, "%04x: A1->FLS, 0->L", get_table(pc)); + break; + } + + // 309 + case 0b001100001001: + { // Move A1[7:1] to FRS[7:1], 1->L[2:1] + util::stream_format(stream, "%04x: A1->FRS, 1->L", get_table(pc)); + break; + } + + // 30a + case 0b001100001010: case 0b001100001011: + { // Move A1[7:1] to MODE[7:1], 1N->L[2:1] + util::stream_format(stream, "%04x: A1->MODE, 1%d->L", get_table(pc), inst & 0x1); + break; + } + + // 30c + //case 0b001100001100: case 0b001100001101: case 0b001100001110: case 0b001100001111: + + // 310 + case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: + { // Move A2[7:1] to A1[7:1], N->L[2:1 + util::stream_format(stream, "%04x: A2->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 314 + //case 0b001100010100: case 0b001100010101: case 0b001100010110: case 0b001100010111: + + // 318 + case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: + { // Right shift A1[7:1], 0A1[7], N->L[2:1] + util::stream_format(stream, "%04x: A1->RS, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 31c + case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: + { // Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: A1-A2->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 320 + case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: + { // AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A1·A1->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 324 + case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: + { // Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A1+A1->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 328 + case 0b001100101000: case 0b001100101001: case 0b001100101010: case 0b001100101011: + { // OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A1vA1->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 32c + case 0b001100101100: case 0b001100101101: case 0b001100101110: case 0b001100101111: + { // Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: A1-A1->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 330 + case 0b001100110000: case 0b001100110001: case 0b001100110010: case 0b001100110011: + { // AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A1·A2->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 334 + case 0b001100110100: case 0b001100110101: case 0b001100110110: case 0b001100110111: + { // Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A1+A2->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 338 + case 0b001100111000: case 0b001100111001: case 0b001100111010: case 0b001100111011: + { // OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A1vA2->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 33c + case 0b001100111100: case 0b001100111101: case 0b001100111110: case 0b001100111111: + { // Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: A1-A2->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 340 + case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: + { // Move A1[7:1] to A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A1->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 344 + // case 0b001101000100: case 0b001101000101: case 0b001101000110: case 0b001101000111: + + // 348 + case 0b001101001000: + { // Move A2[7:1] to FLS[7:1], 0->L[2:1] + util::stream_format(stream, "%04x: A2->FLS, 0->L", get_table(pc)); + break; + } + + // 349 + case 0b001101001001: + { // Move A2[7:1] to FRS[7:1], 1->L[2:1] + util::stream_format(stream, "%04x: A2->FRS, 1->L", get_table(pc)); + break; + } + + // 34a + case 0b001101001010: case 0b001101001011: + { // Move A2[7:1] to MODE[7:1], 1N->L[2:1] + util::stream_format(stream, "%04x: A2->MODE, 1%d->L", get_table(pc), inst & 0x1); + break; + } + + // 34c + case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: + { // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: A2-A1->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 350 + // case 0b001101010000: case 0b001101010001: case 0b001101010010: case 0b001101010011: case 0b001101010100: case 0b001101010101: case 0b001101010110: case 0b001101010111: + + // 358 + case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: + { // Right shift A2[7:1], 0A2[7], N->L[2:1] + util::stream_format(stream, "%04x: A2->RS, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 35c + // case 0b001101011100: case 0b001101011101: case 0b001101011110: case 0b001101011111: + + // 360 + case 0b001101100000: case 0b001101100001: case 0b001101100010: case 0b001101100011: + { // AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A2·A1->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 364 + case 0b001101100100: case 0b001101100101: case 0b001101100110: case 0b001101100111: + { // Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A2+A1->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 368 + case 0b001101101000: case 0b001101101001: case 0b001101101010: case 0b001101101011: + { // OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A2vA1->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 36c + case 0b001101101100: case 0b001101101101: case 0b001101101110: case 0b001101101111: + { // Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: A2-A1->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 370 + case 0b001101110000: case 0b001101110001: case 0b001101110010: case 0b001101110011: + { // AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A2·A2->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 374 + case 0b001101110100: case 0b001101110101: case 0b001101110110: case 0b001101110111: + { // Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A2+A2->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 378 + case 0b001101111000: case 0b001101111001: case 0b001101111010: case 0b001101111011: + { // OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: A2vA2->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 37c + case 0b001101111100: case 0b001101111101: case 0b001101111110: case 0b001101111111: + { // Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: A2-A2->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 380 + case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: + { // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + util::stream_format(stream, "%04x: A1->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 384 + case 0b001110000100: case 0b001110000101: case 0b001110000110: case 0b001110000111: + { // Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] + util::stream_format(stream, "%04x: M<->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 388 + case 0b001110001000: + { // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] + util::stream_format(stream, "%04x: M->FLS, 0->L", get_table(pc)); + break; + } + + // 389 + case 0b001110001001: + { // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] + util::stream_format(stream, "%04x: M->FRS, 1->L", get_table(pc)); + break; + } + + // 38a + case 0b001110001010: case 0b001110001011: + { // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] + util::stream_format(stream, "%04x: M->MODE, 1%d->L", get_table(pc), inst & 0x1); + break; + } + + // 38c + case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: + { // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] + util::stream_format(stream, "%04x: M->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 390 + case 0b001110010000: case 0b001110010001: case 0b001110010010: case 0b001110010011: + { // Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + util::stream_format(stream, "%04x: A2->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 394 + case 0b001110010100: case 0b001110010101: case 0b001110010110: case 0b001110010111: + { // Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: M<->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 398 + case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: + { // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] + util::stream_format(stream, "%04x: M->RS, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 39c + case 0b001110011100: case 0b001110011101: case 0b001110011110: case 0b001110011111: + { // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] + util::stream_format(stream, "%04x: M<->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3a0 + case 0b001110100000: case 0b001110100001: case 0b001110100010: case 0b001110100011: + { // AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + util::stream_format(stream, "%04x: M·A1->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3a4 + case 0b001110100100: case 0b001110100101: case 0b001110100110: case 0b001110100111: + { // Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + util::stream_format(stream, "%04x: M+A1->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3a8 + case 0b001110101000: case 0b001110101001: case 0b001110101010: case 0b001110101011: + { // OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + util::stream_format(stream, "%04x: MvA1->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3ac + case 0b001110101100: case 0b001110101101: case 0b001110101110: case 0b001110101111: + { // Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + util::stream_format(stream, "%04x: M-A1->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3b0 + case 0b001110110000: case 0b001110110001: case 0b001110110010: case 0b001110110011: + { // AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + util::stream_format(stream, "%04x: M·A2->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3b4 + case 0b001110110100: case 0b001110110101: case 0b001110110110: case 0b001110110111: + { // Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + + util::stream_format(stream, "%04x: M+A2->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3b8 + case 0b001110111000: case 0b001110111001: case 0b001110111010: case 0b001110111011: + { // OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + + util::stream_format(stream, "%04x: MvA2->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3bc + case 0b001110111100: case 0b001110111101: case 0b001110111110: case 0b001110111111: + { // Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + + util::stream_format(stream, "%04x: M-A2->M, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3c0 + case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: + { // Move A1[5:1] to H[5:1], N->L[2:1] + util::stream_format(stream, "%04x: A1->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + //case 0b001111000100: case 0b001111000101: case 0b001111000110: case 0b001111000111: //case 0b001111001000: case 0b001111001001: case 0b001111001010: case 0b001111001011: + + // 3cc + case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: + { // Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] + util::stream_format(stream, "%04x: H->A1, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3d0 + case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: + { // Move A2[5:1] to H[5:1], N->L[2:1] + util::stream_format(stream, "%04x: A2->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + //case 0b001111010100: case 0b001111010101: case 0b001111010110: case 0b001111010111: case 0b001111011000: case 0b001111011001: case 0b001111011010: case 0b001111011011: + + // 3dc + case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: + { // Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] + util::stream_format(stream, "%04x: H->A2, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3e0 + case 0b001111100000: case 0b001111100001: case 0b001111100010: case 0b001111100011: + { // AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + util::stream_format(stream, "%04x: H·A1->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + case 0b001111100100: case 0b001111100101: case 0b001111100110: case 0b001111100111: + { // Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + util::stream_format(stream, "%04x: H+A1->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + case 0b001111101000: case 0b001111101001: case 0b001111101010: case 0b001111101011: + { // OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + util::stream_format(stream, "%04x: HvA1->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + case 0b001111101100: case 0b001111101101: case 0b001111101110: case 0b001111101111: + { // Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: H-A1->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3f0 + case 0b001111110000: case 0b001111110001: case 0b001111110010: case 0b001111110011: + { // AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + util::stream_format(stream, "%04x: H·A2->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3f4 + case 0b001111110100: case 0b001111110101: case 0b001111110110: case 0b001111110111: + { // Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + util::stream_format(stream, "%04x: H+A2->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3f8 + case 0b001111111000: case 0b001111111001: case 0b001111111010: case 0b001111111011: + { // OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + util::stream_format(stream, "%04x: HvA2->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + // 3fc + case 0b001111111100: case 0b001111111101: case 0b001111111110: case 0b001111111111: + { // Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: H-A2->H, %d->L", get_table(pc), inst & 0x3); + break; + } + + ////////////////////////////////////////////////////////////////////////////////////////////// + + // 400 + case 0b010000000000: case 0b010000000001: + { // N->A[11] + util::stream_format(stream, "%04x: %d->A11", get_table(pc), inst & 0x1); + break; + } + + // 402 + case 0b010000000010: case 0b010000000011: + { // Jump to (000,M[H[5:1],L[2:1]][5:1],1N),0 L  [2:1], NA[11] + util::stream_format(stream, "%04x: JPM, 0->L, %d->A11", get_table(pc), inst & 0x1); + break; + } + + // case 0b010000000100: case 0b010000000101: case 0b010000000110: case 0b010000000111: case 0b010000001000: case 0b010000001001: case 0b010000001010: case 0b010000001011: case 0b010000001100: case 0b010000001101: case 0b010000001110: case 0b010000001111: case 0b010000010000: case 0b010000010001: case 0b010000010010: case 0b010000010011: case 0b010000010100: case 0b010000010101: case 0b010000010110: case 0b010000010111: case 0b010000011000: case 0b010000011001: case 0b010000011010: case 0b010000011011: case 0b010000011100: case 0b010000011101: case 0b010000011110: case 0b010000011111: case 0b010000100000: case 0b010000100001: case 0b010000100010: case 0b010000100011: case 0b010000100100: case 0b010000100101: case 0b010000100110: case 0b010000100111: case 0b010000101000: case 0b010000101001: case 0b010000101010: case 0b010000101011: case 0b010000101100: case 0b010000101101: case 0b010000101110: case 0b010000101111: case 0b010000110000: case 0b010000110001: case 0b010000110010: case 0b010000110011: case 0b010000110100: case 0b010000110101: case 0b010000110110: case 0b010000110111: case 0b010000111000: case 0b010000111001: case 0b010000111010: case 0b010000111011: case 0b010000111100: case 0b010000111101: case 0b010000111110: case 0b010000111111: + + // 440 + case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: + { // Set D to DISP, G to GPE, K to KIE, S to SME, NA[11] + util::stream_format(stream, "%04x: D(%d)->D, G(%d)->G, K(%d)->K, S(%d)->S, %d->A11", get_table(pc), (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); + break; + } + + // 442 + //case 0b010001000010: case 0b010001000011: case 0b010001000110: case 0b010001000111: case 0b010001001010: case 0b010001001011: case 0b010001001110: case 0b010001001111: case 0b010001010010: case 0b010001010011: case 0b010001010110: case 0b010001010111: case 0b010001011010: case 0b010001011011: case 0b010001011110: case 0b010001011111: case 0b010001100010: case 0b010001100011: case 0b010001100110: case 0b010001100111: case 0b010001101010: case 0b010001101011: case 0b010001101110: case 0b010001101111: case 0b010001110010: case 0b010001110011: case 0b010001110110: case 0b010001110111: case 0b010001111010: case 0b010001111011: case 0b010001111110: case 0b010001111111: + + // 480 + case 0b010010000000: case 0b010010000001: case 0b010010000010: case 0b010010000011: case 0b010010000100: case 0b010010000101: case 0b010010000110: case 0b010010000111: case 0b010010001000: case 0b010010001001: case 0b010010001010: case 0b010010001011: case 0b010010001100: case 0b010010001101: case 0b010010001110: case 0b010010001111: case 0b010010010000: case 0b010010010001: case 0b010010010010: case 0b010010010011: case 0b010010010100: case 0b010010010101: case 0b010010010110: case 0b010010010111: case 0b010010011000: case 0b010010011001: case 0b010010011010: case 0b010010011011: case 0b010010011100: case 0b010010011101: case 0b010010011110: case 0b010010011111: case 0b010010100000: case 0b010010100001: case 0b010010100010: case 0b010010100011: case 0b010010100100: case 0b010010100101: case 0b010010100110: case 0b010010100111: case 0b010010101000: case 0b010010101001: case 0b010010101010: case 0b010010101011: case 0b010010101100: case 0b010010101101: case 0b010010101110: case 0b010010101111: case 0b010010110000: case 0b010010110001: case 0b010010110010: case 0b010010110011: case 0b010010110100: case 0b010010110101: case 0b010010110110: case 0b010010110111: case 0b010010111000: case 0b010010111001: case 0b010010111010: case 0b010010111011: case 0b010010111100: case 0b010010111101: case 0b010010111110: case 0b010010111111: + { // H[5:1]-K[5:1]->H[5:1], Skip if borrow + util::stream_format(stream, "%04x: H-K(%02x)->H BOJ", get_table(pc), inst & 0x1f); + break; + } + + // 4c0 + case 0b010011000000: case 0b010011000001: case 0b010011000010: case 0b010011000011: case 0b010011000100: case 0b010011000101: case 0b010011000110: case 0b010011000111: case 0b010011001000: case 0b010011001001: case 0b010011001010: case 0b010011001011: case 0b010011001100: case 0b010011001101: case 0b010011001110: case 0b010011001111: case 0b010011010000: case 0b010011010001: case 0b010011010010: case 0b010011010011: case 0b010011010100: case 0b010011010101: case 0b010011010110: case 0b010011010111: case 0b010011011000: case 0b010011011001: case 0b010011011010: case 0b010011011011: case 0b010011011100: case 0b010011011101: case 0b010011011110: case 0b010011011111: case 0b010011100000: case 0b010011100001: case 0b010011100010: case 0b010011100011: case 0b010011100100: case 0b010011100101: case 0b010011100110: case 0b010011100111: case 0b010011101000: case 0b010011101001: case 0b010011101010: case 0b010011101011: case 0b010011101100: case 0b010011101101: case 0b010011101110: case 0b010011101111: case 0b010011110000: case 0b010011110001: case 0b010011110010: case 0b010011110011: case 0b010011110100: case 0b010011110101: case 0b010011110110: case 0b010011110111: case 0b010011111000: case 0b010011111001: case 0b010011111010: case 0b010011111011: case 0b010011111100: case 0b010011111101: case 0b010011111110: case 0b010011111111: + { // H[5:1]+K[5:1]H[5:1], Skip if carry + util::stream_format(stream, "%04x: H+K(%02x)->H CAJ", get_table(pc), inst & 0x1f); + break; + } + + // 500 + case 0b010100000000: case 0b010100000001: case 0b010100000010: case 0b010100000011: case 0b010100000100: case 0b010100000101: case 0b010100000110: case 0b010100000111: case 0b010100001000: case 0b010100001001: case 0b010100001010: case 0b010100001011: case 0b010100001100: case 0b010100001101: case 0b010100001110: case 0b010100001111: case 0b010100010000: case 0b010100010001: case 0b010100010010: case 0b010100010011: case 0b010100010100: case 0b010100010101: case 0b010100010110: case 0b010100010111: case 0b010100011000: case 0b010100011001: case 0b010100011010: case 0b010100011011: case 0b010100011100: case 0b010100011101: case 0b010100011110: case 0b010100011111: case 0b010100100000: case 0b010100100001: case 0b010100100010: case 0b010100100011: case 0b010100100100: case 0b010100100101: case 0b010100100110: case 0b010100100111: case 0b010100101000: case 0b010100101001: case 0b010100101010: case 0b010100101011: case 0b010100101100: case 0b010100101101: case 0b010100101110: case 0b010100101111: case 0b010100110000: case 0b010100110001: case 0b010100110010: case 0b010100110011: case 0b010100110100: case 0b010100110101: case 0b010100110110: case 0b010100110111: case 0b010100111000: case 0b010100111001: case 0b010100111010: case 0b010100111011: case 0b010100111100: case 0b010100111101: case 0b010100111110: case 0b010100111111: case 0b010101000000: case 0b010101000001: case 0b010101000010: case 0b010101000011: case 0b010101000100: case 0b010101000101: case 0b010101000110: case 0b010101000111: case 0b010101001000: case 0b010101001001: case 0b010101001010: case 0b010101001011: case 0b010101001100: case 0b010101001101: case 0b010101001110: case 0b010101001111: case 0b010101010000: case 0b010101010001: case 0b010101010010: case 0b010101010011: case 0b010101010100: case 0b010101010101: case 0b010101010110: case 0b010101010111: case 0b010101011000: case 0b010101011001: case 0b010101011010: case 0b010101011011: case 0b010101011100: case 0b010101011101: case 0b010101011110: case 0b010101011111: case 0b010101100000: case 0b010101100001: case 0b010101100010: case 0b010101100011: case 0b010101100100: case 0b010101100101: case 0b010101100110: case 0b010101100111: case 0b010101101000: case 0b010101101001: case 0b010101101010: case 0b010101101011: case 0b010101101100: case 0b010101101101: case 0b010101101110: case 0b010101101111: case 0b010101110000: case 0b010101110001: case 0b010101110010: case 0b010101110011: case 0b010101110100: case 0b010101110101: case 0b010101110110: case 0b010101110111: case 0b010101111000: case 0b010101111001: case 0b010101111010: case 0b010101111011: case 0b010101111100: case 0b010101111101: case 0b010101111110: case 0b010101111111: + { // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] + // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] + // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] + util::stream_format(stream, "%04x: K(%02x)->M", get_table(pc), inst & 0x7f); + break; + } + + // 580 + case 0b010110000000: case 0b010110000001: case 0b010110000010: case 0b010110000011: case 0b010110000100: case 0b010110000101: case 0b010110000110: case 0b010110000111: case 0b010110001000: case 0b010110001001: case 0b010110001010: case 0b010110001011: case 0b010110001100: case 0b010110001101: case 0b010110001110: case 0b010110001111: case 0b010110010000: case 0b010110010001: case 0b010110010010: case 0b010110010011: case 0b010110010100: case 0b010110010101: case 0b010110010110: case 0b010110010111: case 0b010110011000: case 0b010110011001: case 0b010110011010: case 0b010110011011: case 0b010110011100: case 0b010110011101: case 0b010110011110: case 0b010110011111: case 0b010110100000: case 0b010110100001: case 0b010110100010: case 0b010110100011: case 0b010110100100: case 0b010110100101: case 0b010110100110: case 0b010110100111: case 0b010110101000: case 0b010110101001: case 0b010110101010: case 0b010110101011: case 0b010110101100: case 0b010110101101: case 0b010110101110: case 0b010110101111: case 0b010110110000: case 0b010110110001: case 0b010110110010: case 0b010110110011: case 0b010110110100: case 0b010110110101: case 0b010110110110: case 0b010110110111: case 0b010110111000: case 0b010110111001: case 0b010110111010: case 0b010110111011: case 0b010110111100: case 0b010110111101: case 0b010110111110: case 0b010110111111: case 0b010111000000: case 0b010111000001: case 0b010111000010: case 0b010111000011: case 0b010111000100: case 0b010111000101: case 0b010111000110: case 0b010111000111: case 0b010111001000: case 0b010111001001: case 0b010111001010: case 0b010111001011: case 0b010111001100: case 0b010111001101: case 0b010111001110: case 0b010111001111: case 0b010111010000: case 0b010111010001: case 0b010111010010: case 0b010111010011: case 0b010111010100: case 0b010111010101: case 0b010111010110: case 0b010111010111: case 0b010111011000: case 0b010111011001: case 0b010111011010: case 0b010111011011: case 0b010111011100: case 0b010111011101: case 0b010111011110: case 0b010111011111: case 0b010111100000: case 0b010111100001: case 0b010111100010: case 0b010111100011: case 0b010111100100: case 0b010111100101: case 0b010111100110: case 0b010111100111: case 0b010111101000: case 0b010111101001: case 0b010111101010: case 0b010111101011: case 0b010111101100: case 0b010111101101: case 0b010111101110: case 0b010111101111: case 0b010111110000: case 0b010111110001: case 0b010111110010: case 0b010111110011: case 0b010111110100: case 0b010111110101: case 0b010111110110: case 0b010111110111: case 0b010111111000: case 0b010111111001: case 0b010111111010: case 0b010111111011: case 0b010111111100: case 0b010111111101: case 0b010111111110: case 0b010111111111: + { // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] + util::stream_format(stream, "%04x: K(%02x)->L,H", get_table(pc), inst & 0x7f); + break; + } + + // 600 + case 0b011000000000: case 0b011000000001: case 0b011000000010: case 0b011000000011: case 0b011000000100: case 0b011000000101: case 0b011000000110: case 0b011000000111: case 0b011000001000: case 0b011000001001: case 0b011000001010: case 0b011000001011: case 0b011000001100: case 0b011000001101: case 0b011000001110: case 0b011000001111: case 0b011000010000: case 0b011000010001: case 0b011000010010: case 0b011000010011: case 0b011000010100: case 0b011000010101: case 0b011000010110: case 0b011000010111: case 0b011000011000: case 0b011000011001: case 0b011000011010: case 0b011000011011: case 0b011000011100: case 0b011000011101: case 0b011000011110: case 0b011000011111: case 0b011000100000: case 0b011000100001: case 0b011000100010: case 0b011000100011: case 0b011000100100: case 0b011000100101: case 0b011000100110: case 0b011000100111: case 0b011000101000: case 0b011000101001: case 0b011000101010: case 0b011000101011: case 0b011000101100: case 0b011000101101: case 0b011000101110: case 0b011000101111: case 0b011000110000: case 0b011000110001: case 0b011000110010: case 0b011000110011: case 0b011000110100: case 0b011000110101: case 0b011000110110: case 0b011000110111: case 0b011000111000: case 0b011000111001: case 0b011000111010: case 0b011000111011: case 0b011000111100: case 0b011000111101: case 0b011000111110: case 0b011000111111: case 0b011001000000: case 0b011001000001: case 0b011001000010: case 0b011001000011: case 0b011001000100: case 0b011001000101: case 0b011001000110: case 0b011001000111: case 0b011001001000: case 0b011001001001: case 0b011001001010: case 0b011001001011: case 0b011001001100: case 0b011001001101: case 0b011001001110: case 0b011001001111: case 0b011001010000: case 0b011001010001: case 0b011001010010: case 0b011001010011: case 0b011001010100: case 0b011001010101: case 0b011001010110: case 0b011001010111: case 0b011001011000: case 0b011001011001: case 0b011001011010: case 0b011001011011: case 0b011001011100: case 0b011001011101: case 0b011001011110: case 0b011001011111: case 0b011001100000: case 0b011001100001: case 0b011001100010: case 0b011001100011: case 0b011001100100: case 0b011001100101: case 0b011001100110: case 0b011001100111: case 0b011001101000: case 0b011001101001: case 0b011001101010: case 0b011001101011: case 0b011001101100: case 0b011001101101: case 0b011001101110: case 0b011001101111: case 0b011001110000: case 0b011001110001: case 0b011001110010: case 0b011001110011: case 0b011001110100: case 0b011001110101: case 0b011001110110: case 0b011001110111: case 0b011001111000: case 0b011001111001: case 0b011001111010: case 0b011001111011: case 0b011001111100: case 0b011001111101: case 0b011001111110: case 0b011001111111: + { // Store K[7:1] to A1[7:1] + util::stream_format(stream, "%04x: K(%02x)->A1", get_table(pc), inst & 0x7f); + break; + } + + // 680 + case 0b011010000000: case 0b011010000001: case 0b011010000010: case 0b011010000011: case 0b011010000100: case 0b011010000101: case 0b011010000110: case 0b011010000111: case 0b011010001000: case 0b011010001001: case 0b011010001010: case 0b011010001011: case 0b011010001100: case 0b011010001101: case 0b011010001110: case 0b011010001111: case 0b011010010000: case 0b011010010001: case 0b011010010010: case 0b011010010011: case 0b011010010100: case 0b011010010101: case 0b011010010110: case 0b011010010111: case 0b011010011000: case 0b011010011001: case 0b011010011010: case 0b011010011011: case 0b011010011100: case 0b011010011101: case 0b011010011110: case 0b011010011111: case 0b011010100000: case 0b011010100001: case 0b011010100010: case 0b011010100011: case 0b011010100100: case 0b011010100101: case 0b011010100110: case 0b011010100111: case 0b011010101000: case 0b011010101001: case 0b011010101010: case 0b011010101011: case 0b011010101100: case 0b011010101101: case 0b011010101110: case 0b011010101111: case 0b011010110000: case 0b011010110001: case 0b011010110010: case 0b011010110011: case 0b011010110100: case 0b011010110101: case 0b011010110110: case 0b011010110111: case 0b011010111000: case 0b011010111001: case 0b011010111010: case 0b011010111011: case 0b011010111100: case 0b011010111101: case 0b011010111110: case 0b011010111111: case 0b011011000000: case 0b011011000001: case 0b011011000010: case 0b011011000011: case 0b011011000100: case 0b011011000101: case 0b011011000110: case 0b011011000111: case 0b011011001000: case 0b011011001001: case 0b011011001010: case 0b011011001011: case 0b011011001100: case 0b011011001101: case 0b011011001110: case 0b011011001111: case 0b011011010000: case 0b011011010001: case 0b011011010010: case 0b011011010011: case 0b011011010100: case 0b011011010101: case 0b011011010110: case 0b011011010111: case 0b011011011000: case 0b011011011001: case 0b011011011010: case 0b011011011011: case 0b011011011100: case 0b011011011101: case 0b011011011110: case 0b011011011111: case 0b011011100000: case 0b011011100001: case 0b011011100010: case 0b011011100011: case 0b011011100100: case 0b011011100101: case 0b011011100110: case 0b011011100111: case 0b011011101000: case 0b011011101001: case 0b011011101010: case 0b011011101011: case 0b011011101100: case 0b011011101101: case 0b011011101110: case 0b011011101111: case 0b011011110000: case 0b011011110001: case 0b011011110010: case 0b011011110011: case 0b011011110100: case 0b011011110101: case 0b011011110110: case 0b011011110111: case 0b011011111000: case 0b011011111001: case 0b011011111010: case 0b011011111011: case 0b011011111100: case 0b011011111101: case 0b011011111110: case 0b011011111111: + { // Store K[7:1] to A2[7:1] + util::stream_format(stream, "%04x: K(%02x)->A2", get_table(pc), inst & 0x7f); + break; + } + + // 700 + case 0b011100000000: case 0b011100000001: case 0b011100000010: case 0b011100000011: case 0b011100000100: case 0b011100000101: case 0b011100000110: case 0b011100000111: case 0b011100001000: case 0b011100001001: case 0b011100001010: case 0b011100001011: case 0b011100001100: case 0b011100001101: case 0b011100001110: case 0b011100001111: case 0b011100010000: case 0b011100010001: case 0b011100010010: case 0b011100010011: case 0b011100010100: case 0b011100010101: case 0b011100010110: case 0b011100010111: case 0b011100011000: case 0b011100011001: case 0b011100011010: case 0b011100011011: case 0b011100011100: case 0b011100011101: case 0b011100011110: case 0b011100011111: case 0b011100100000: case 0b011100100001: case 0b011100100010: case 0b011100100011: case 0b011100100100: case 0b011100100101: case 0b011100100110: case 0b011100100111: case 0b011100101000: case 0b011100101001: case 0b011100101010: case 0b011100101011: case 0b011100101100: case 0b011100101101: case 0b011100101110: case 0b011100101111: case 0b011100110000: case 0b011100110001: case 0b011100110010: case 0b011100110011: case 0b011100110100: case 0b011100110101: case 0b011100110110: case 0b011100110111: case 0b011100111000: case 0b011100111001: case 0b011100111010: case 0b011100111011: case 0b011100111100: case 0b011100111101: case 0b011100111110: case 0b011100111111: case 0b011101000000: case 0b011101000001: case 0b011101000010: case 0b011101000011: case 0b011101000100: case 0b011101000101: case 0b011101000110: case 0b011101000111: case 0b011101001000: case 0b011101001001: case 0b011101001010: case 0b011101001011: case 0b011101001100: case 0b011101001101: case 0b011101001110: case 0b011101001111: case 0b011101010000: case 0b011101010001: case 0b011101010010: case 0b011101010011: case 0b011101010100: case 0b011101010101: case 0b011101010110: case 0b011101010111: case 0b011101011000: case 0b011101011001: case 0b011101011010: case 0b011101011011: case 0b011101011100: case 0b011101011101: case 0b011101011110: case 0b011101011111: case 0b011101100000: case 0b011101100001: case 0b011101100010: case 0b011101100011: case 0b011101100100: case 0b011101100101: case 0b011101100110: case 0b011101100111: case 0b011101101000: case 0b011101101001: case 0b011101101010: case 0b011101101011: case 0b011101101100: case 0b011101101101: case 0b011101101110: case 0b011101101111: case 0b011101110000: case 0b011101110001: case 0b011101110010: case 0b011101110011: case 0b011101110100: case 0b011101110101: case 0b011101110110: case 0b011101110111: case 0b011101111000: case 0b011101111001: case 0b011101111010: case 0b011101111011: case 0b011101111100: case 0b011101111101: case 0b011101111110: case 0b011101111111: + { // Store K[7:1] to A3[7:1] + util::stream_format(stream, "%04x: K(%02x)->A3", get_table(pc), inst & 0x7f); + break; + } + + // 780 + case 0b011110000000: case 0b011110000001: case 0b011110000010: case 0b011110000011: case 0b011110000100: case 0b011110000101: case 0b011110000110: case 0b011110000111: case 0b011110001000: case 0b011110001001: case 0b011110001010: case 0b011110001011: case 0b011110001100: case 0b011110001101: case 0b011110001110: case 0b011110001111: case 0b011110010000: case 0b011110010001: case 0b011110010010: case 0b011110010011: case 0b011110010100: case 0b011110010101: case 0b011110010110: case 0b011110010111: case 0b011110011000: case 0b011110011001: case 0b011110011010: case 0b011110011011: case 0b011110011100: case 0b011110011101: case 0b011110011110: case 0b011110011111: case 0b011110100000: case 0b011110100001: case 0b011110100010: case 0b011110100011: case 0b011110100100: case 0b011110100101: case 0b011110100110: case 0b011110100111: case 0b011110101000: case 0b011110101001: case 0b011110101010: case 0b011110101011: case 0b011110101100: case 0b011110101101: case 0b011110101110: case 0b011110101111: case 0b011110110000: case 0b011110110001: case 0b011110110010: case 0b011110110011: case 0b011110110100: case 0b011110110101: case 0b011110110110: case 0b011110110111: case 0b011110111000: case 0b011110111001: case 0b011110111010: case 0b011110111011: case 0b011110111100: case 0b011110111101: case 0b011110111110: case 0b011110111111: case 0b011111000000: case 0b011111000001: case 0b011111000010: case 0b011111000011: case 0b011111000100: case 0b011111000101: case 0b011111000110: case 0b011111000111: case 0b011111001000: case 0b011111001001: case 0b011111001010: case 0b011111001011: case 0b011111001100: case 0b011111001101: case 0b011111001110: case 0b011111001111: case 0b011111010000: case 0b011111010001: case 0b011111010010: case 0b011111010011: case 0b011111010100: case 0b011111010101: case 0b011111010110: case 0b011111010111: case 0b011111011000: case 0b011111011001: case 0b011111011010: case 0b011111011011: case 0b011111011100: case 0b011111011101: case 0b011111011110: case 0b011111011111: case 0b011111100000: case 0b011111100001: case 0b011111100010: case 0b011111100011: case 0b011111100100: case 0b011111100101: case 0b011111100110: case 0b011111100111: case 0b011111101000: case 0b011111101001: case 0b011111101010: case 0b011111101011: case 0b011111101100: case 0b011111101101: case 0b011111101110: case 0b011111101111: case 0b011111110000: case 0b011111110001: case 0b011111110010: case 0b011111110011: case 0b011111110100: case 0b011111110101: case 0b011111110110: case 0b011111110111: case 0b011111111000: case 0b011111111001: case 0b011111111010: case 0b011111111011: case 0b011111111100: case 0b011111111101: case 0b011111111110: case 0b011111111111: + { // Store K[7:1] to A4[7:1] + util::stream_format(stream, "%04x: K(%02x)->A4", get_table(pc), inst & 0x7f); + break; + } + + default: + { + util::stream_format(stream, "%04x: %04x ", get_table(pc), inst); + break; + } + } + } + else if (inst < 0xc00) // 800 - bff + { // Move K[10:1] to A[10:1], Jump to A[11:1] + util::stream_format(stream, "%04x: JP %03x", get_table(pc), inst & 0x3ff); + } + else if (inst < 0x1000) // c00 - fff + { // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack + util::stream_format(stream, "%04x: JS %03x", get_table(pc), inst & 0x3ff); + } + + return 1; +} diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h new file mode 100644 index 0000000000000..f42d44839c72b --- /dev/null +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -0,0 +1,47 @@ +// license:BSD-3-Clause +// copyright-holders:David Haywood + +#ifndef MAME_CPU_UPD777_UPD777DASM_H +#define MAME_CPU_UPD777_UPD777DASM_H + +#pragma once + + +class upd777_disassembler : public util::disasm_interface +{ +public: + // construction/destruction + upd777_disassembler(); + + // the ROMs are for some reason already in execution order, not address order, so build up a table of addresses + static void populate_addr_table(u16 *table) + { + int count = 0; + for (int upper = 0; upper < 0x800; upper += 0x80) + { + int out = 0; + for (int i = 0; i < 127; i++) // 127 not 128, because last address is just 0 again and doesn't exist + { + int top1 = (out & 0x40) >> 6; + int top2 = (out & 0x20) >> 5; + int nor = (top1 ^ top2) ^ 1; + int full = upper | out; + table[count++] = full; + out = (out << 1) | nor; + out &= 0x7f; + } + } + + } + +protected: + // disassembler overrides + virtual u32 opcode_alignment() const override; + virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms) override; + +private: + u16 get_table(u16 addr); + u16 m_table[0xfe0/2]; +}; + +#endif // MAME_CPU_UPD777_UPD777DASM_H diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index 594adc417500a..c360dfdce1c53 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -11,10 +11,14 @@ the linked 'design note' contains a large amount of useful information */ #include "emu.h" + #include "bus/generic/slot.h" #include "bus/generic/carts.h" +#include "cpu/upd777/upd777.h" + #include "softlist_dev.h" + namespace { class cassvisn_state : public driver_device @@ -22,12 +26,17 @@ class cassvisn_state : public driver_device public: cassvisn_state(const machine_config &mconfig, device_type type, const char *tag) : driver_device(mconfig, type, tag), + m_maincpu(*this, "maincpu"), m_cart(*this, "cartslot") { } void cassvisn(machine_config &config); + + void init_cass(); protected: DECLARE_DEVICE_IMAGE_LOAD_MEMBER(cart_load); +private: + required_device m_maincpu; required_device m_cart; }; @@ -36,14 +45,17 @@ INPUT_PORTS_END DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) { - uint32_t size = m_cart->common_get_size("rom"); + uint32_t size = m_cart->common_get_size("prg"); m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_LITTLE); - m_cart->common_load_rom(m_cart->get_rom_base(), size, "rom"); + m_cart->common_load_rom(m_cart->get_rom_base(), size, "prg"); + memcpy(memregion("maincpu")->base(), m_cart->get_rom_base(), size); return std::make_pair(std::error_condition(), std::string()); } void cassvisn_state::cassvisn(machine_config &config) { + UPD777(config, m_maincpu, 1000000); // frequency? UPD774 / UPD778 in some carts? + GENERIC_CARTSLOT(config, m_cart, generic_plain_slot, "cassvisn_cart"); m_cart->set_width(GENERIC_ROM16_WIDTH); m_cart->set_device_load(FUNC(cassvisn_state::cart_load)); @@ -53,8 +65,13 @@ void cassvisn_state::cassvisn(machine_config &config) } ROM_START( cassvisn ) + ROM_REGION( 0x1000, "maincpu", ROMREGION_ERASEFF ) ROM_END +void cassvisn_state::init_cass() +{ +} + } // anonymous namespace -CONS( 1981, cassvisn, 0, 0, cassvisn, cassvisn, cassvisn_state, empty_init, "Epoch", "Cassette Vision", MACHINE_IS_SKELETON ) +CONS( 1981, cassvisn, 0, 0, cassvisn, cassvisn, cassvisn_state, init_cass, "Epoch", "Cassette Vision", MACHINE_IS_SKELETON ) From bb1acb35258388f4d26fecfd84b0ea637958d6ff Mon Sep 17 00:00:00 2001 From: David Haywood Date: Fri, 29 Dec 2023 18:49:52 +0000 Subject: [PATCH 06/62] stop MAME from locking up --- src/devices/cpu/upd777/upd777.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 3390b8789ad84..721778615c5da 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -96,6 +96,7 @@ void upd777_device::execute_run() { debugger_instruction_hook(m_pc); do_op(); + m_icount--; } } From d3118fc5b178aa67d2b91e04494908fab605a3ad Mon Sep 17 00:00:00 2001 From: David Haywood Date: Fri, 29 Dec 2023 19:37:05 +0000 Subject: [PATCH 07/62] squash down some larger switch cases --- src/devices/cpu/upd777/upd777dasm.cpp | 108 +++++++++++--------------- 1 file changed, 47 insertions(+), 61 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index b9f457c13d250..c999f7acb24f6 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -31,7 +31,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { u16 inst = opcodes.r16(pc); - if (inst < 0x800) + if (inst < 0x480) { switch (inst) { @@ -1076,64 +1076,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 442 //case 0b010001000010: case 0b010001000011: case 0b010001000110: case 0b010001000111: case 0b010001001010: case 0b010001001011: case 0b010001001110: case 0b010001001111: case 0b010001010010: case 0b010001010011: case 0b010001010110: case 0b010001010111: case 0b010001011010: case 0b010001011011: case 0b010001011110: case 0b010001011111: case 0b010001100010: case 0b010001100011: case 0b010001100110: case 0b010001100111: case 0b010001101010: case 0b010001101011: case 0b010001101110: case 0b010001101111: case 0b010001110010: case 0b010001110011: case 0b010001110110: case 0b010001110111: case 0b010001111010: case 0b010001111011: case 0b010001111110: case 0b010001111111: - // 480 - case 0b010010000000: case 0b010010000001: case 0b010010000010: case 0b010010000011: case 0b010010000100: case 0b010010000101: case 0b010010000110: case 0b010010000111: case 0b010010001000: case 0b010010001001: case 0b010010001010: case 0b010010001011: case 0b010010001100: case 0b010010001101: case 0b010010001110: case 0b010010001111: case 0b010010010000: case 0b010010010001: case 0b010010010010: case 0b010010010011: case 0b010010010100: case 0b010010010101: case 0b010010010110: case 0b010010010111: case 0b010010011000: case 0b010010011001: case 0b010010011010: case 0b010010011011: case 0b010010011100: case 0b010010011101: case 0b010010011110: case 0b010010011111: case 0b010010100000: case 0b010010100001: case 0b010010100010: case 0b010010100011: case 0b010010100100: case 0b010010100101: case 0b010010100110: case 0b010010100111: case 0b010010101000: case 0b010010101001: case 0b010010101010: case 0b010010101011: case 0b010010101100: case 0b010010101101: case 0b010010101110: case 0b010010101111: case 0b010010110000: case 0b010010110001: case 0b010010110010: case 0b010010110011: case 0b010010110100: case 0b010010110101: case 0b010010110110: case 0b010010110111: case 0b010010111000: case 0b010010111001: case 0b010010111010: case 0b010010111011: case 0b010010111100: case 0b010010111101: case 0b010010111110: case 0b010010111111: - { // H[5:1]-K[5:1]->H[5:1], Skip if borrow - util::stream_format(stream, "%04x: H-K(%02x)->H BOJ", get_table(pc), inst & 0x1f); - break; - } - - // 4c0 - case 0b010011000000: case 0b010011000001: case 0b010011000010: case 0b010011000011: case 0b010011000100: case 0b010011000101: case 0b010011000110: case 0b010011000111: case 0b010011001000: case 0b010011001001: case 0b010011001010: case 0b010011001011: case 0b010011001100: case 0b010011001101: case 0b010011001110: case 0b010011001111: case 0b010011010000: case 0b010011010001: case 0b010011010010: case 0b010011010011: case 0b010011010100: case 0b010011010101: case 0b010011010110: case 0b010011010111: case 0b010011011000: case 0b010011011001: case 0b010011011010: case 0b010011011011: case 0b010011011100: case 0b010011011101: case 0b010011011110: case 0b010011011111: case 0b010011100000: case 0b010011100001: case 0b010011100010: case 0b010011100011: case 0b010011100100: case 0b010011100101: case 0b010011100110: case 0b010011100111: case 0b010011101000: case 0b010011101001: case 0b010011101010: case 0b010011101011: case 0b010011101100: case 0b010011101101: case 0b010011101110: case 0b010011101111: case 0b010011110000: case 0b010011110001: case 0b010011110010: case 0b010011110011: case 0b010011110100: case 0b010011110101: case 0b010011110110: case 0b010011110111: case 0b010011111000: case 0b010011111001: case 0b010011111010: case 0b010011111011: case 0b010011111100: case 0b010011111101: case 0b010011111110: case 0b010011111111: - { // H[5:1]+K[5:1]H[5:1], Skip if carry - util::stream_format(stream, "%04x: H+K(%02x)->H CAJ", get_table(pc), inst & 0x1f); - break; - } - - // 500 - case 0b010100000000: case 0b010100000001: case 0b010100000010: case 0b010100000011: case 0b010100000100: case 0b010100000101: case 0b010100000110: case 0b010100000111: case 0b010100001000: case 0b010100001001: case 0b010100001010: case 0b010100001011: case 0b010100001100: case 0b010100001101: case 0b010100001110: case 0b010100001111: case 0b010100010000: case 0b010100010001: case 0b010100010010: case 0b010100010011: case 0b010100010100: case 0b010100010101: case 0b010100010110: case 0b010100010111: case 0b010100011000: case 0b010100011001: case 0b010100011010: case 0b010100011011: case 0b010100011100: case 0b010100011101: case 0b010100011110: case 0b010100011111: case 0b010100100000: case 0b010100100001: case 0b010100100010: case 0b010100100011: case 0b010100100100: case 0b010100100101: case 0b010100100110: case 0b010100100111: case 0b010100101000: case 0b010100101001: case 0b010100101010: case 0b010100101011: case 0b010100101100: case 0b010100101101: case 0b010100101110: case 0b010100101111: case 0b010100110000: case 0b010100110001: case 0b010100110010: case 0b010100110011: case 0b010100110100: case 0b010100110101: case 0b010100110110: case 0b010100110111: case 0b010100111000: case 0b010100111001: case 0b010100111010: case 0b010100111011: case 0b010100111100: case 0b010100111101: case 0b010100111110: case 0b010100111111: case 0b010101000000: case 0b010101000001: case 0b010101000010: case 0b010101000011: case 0b010101000100: case 0b010101000101: case 0b010101000110: case 0b010101000111: case 0b010101001000: case 0b010101001001: case 0b010101001010: case 0b010101001011: case 0b010101001100: case 0b010101001101: case 0b010101001110: case 0b010101001111: case 0b010101010000: case 0b010101010001: case 0b010101010010: case 0b010101010011: case 0b010101010100: case 0b010101010101: case 0b010101010110: case 0b010101010111: case 0b010101011000: case 0b010101011001: case 0b010101011010: case 0b010101011011: case 0b010101011100: case 0b010101011101: case 0b010101011110: case 0b010101011111: case 0b010101100000: case 0b010101100001: case 0b010101100010: case 0b010101100011: case 0b010101100100: case 0b010101100101: case 0b010101100110: case 0b010101100111: case 0b010101101000: case 0b010101101001: case 0b010101101010: case 0b010101101011: case 0b010101101100: case 0b010101101101: case 0b010101101110: case 0b010101101111: case 0b010101110000: case 0b010101110001: case 0b010101110010: case 0b010101110011: case 0b010101110100: case 0b010101110101: case 0b010101110110: case 0b010101110111: case 0b010101111000: case 0b010101111001: case 0b010101111010: case 0b010101111011: case 0b010101111100: case 0b010101111101: case 0b010101111110: case 0b010101111111: - { // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] - // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] - // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] - util::stream_format(stream, "%04x: K(%02x)->M", get_table(pc), inst & 0x7f); - break; - } - - // 580 - case 0b010110000000: case 0b010110000001: case 0b010110000010: case 0b010110000011: case 0b010110000100: case 0b010110000101: case 0b010110000110: case 0b010110000111: case 0b010110001000: case 0b010110001001: case 0b010110001010: case 0b010110001011: case 0b010110001100: case 0b010110001101: case 0b010110001110: case 0b010110001111: case 0b010110010000: case 0b010110010001: case 0b010110010010: case 0b010110010011: case 0b010110010100: case 0b010110010101: case 0b010110010110: case 0b010110010111: case 0b010110011000: case 0b010110011001: case 0b010110011010: case 0b010110011011: case 0b010110011100: case 0b010110011101: case 0b010110011110: case 0b010110011111: case 0b010110100000: case 0b010110100001: case 0b010110100010: case 0b010110100011: case 0b010110100100: case 0b010110100101: case 0b010110100110: case 0b010110100111: case 0b010110101000: case 0b010110101001: case 0b010110101010: case 0b010110101011: case 0b010110101100: case 0b010110101101: case 0b010110101110: case 0b010110101111: case 0b010110110000: case 0b010110110001: case 0b010110110010: case 0b010110110011: case 0b010110110100: case 0b010110110101: case 0b010110110110: case 0b010110110111: case 0b010110111000: case 0b010110111001: case 0b010110111010: case 0b010110111011: case 0b010110111100: case 0b010110111101: case 0b010110111110: case 0b010110111111: case 0b010111000000: case 0b010111000001: case 0b010111000010: case 0b010111000011: case 0b010111000100: case 0b010111000101: case 0b010111000110: case 0b010111000111: case 0b010111001000: case 0b010111001001: case 0b010111001010: case 0b010111001011: case 0b010111001100: case 0b010111001101: case 0b010111001110: case 0b010111001111: case 0b010111010000: case 0b010111010001: case 0b010111010010: case 0b010111010011: case 0b010111010100: case 0b010111010101: case 0b010111010110: case 0b010111010111: case 0b010111011000: case 0b010111011001: case 0b010111011010: case 0b010111011011: case 0b010111011100: case 0b010111011101: case 0b010111011110: case 0b010111011111: case 0b010111100000: case 0b010111100001: case 0b010111100010: case 0b010111100011: case 0b010111100100: case 0b010111100101: case 0b010111100110: case 0b010111100111: case 0b010111101000: case 0b010111101001: case 0b010111101010: case 0b010111101011: case 0b010111101100: case 0b010111101101: case 0b010111101110: case 0b010111101111: case 0b010111110000: case 0b010111110001: case 0b010111110010: case 0b010111110011: case 0b010111110100: case 0b010111110101: case 0b010111110110: case 0b010111110111: case 0b010111111000: case 0b010111111001: case 0b010111111010: case 0b010111111011: case 0b010111111100: case 0b010111111101: case 0b010111111110: case 0b010111111111: - { // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] - util::stream_format(stream, "%04x: K(%02x)->L,H", get_table(pc), inst & 0x7f); - break; - } - - // 600 - case 0b011000000000: case 0b011000000001: case 0b011000000010: case 0b011000000011: case 0b011000000100: case 0b011000000101: case 0b011000000110: case 0b011000000111: case 0b011000001000: case 0b011000001001: case 0b011000001010: case 0b011000001011: case 0b011000001100: case 0b011000001101: case 0b011000001110: case 0b011000001111: case 0b011000010000: case 0b011000010001: case 0b011000010010: case 0b011000010011: case 0b011000010100: case 0b011000010101: case 0b011000010110: case 0b011000010111: case 0b011000011000: case 0b011000011001: case 0b011000011010: case 0b011000011011: case 0b011000011100: case 0b011000011101: case 0b011000011110: case 0b011000011111: case 0b011000100000: case 0b011000100001: case 0b011000100010: case 0b011000100011: case 0b011000100100: case 0b011000100101: case 0b011000100110: case 0b011000100111: case 0b011000101000: case 0b011000101001: case 0b011000101010: case 0b011000101011: case 0b011000101100: case 0b011000101101: case 0b011000101110: case 0b011000101111: case 0b011000110000: case 0b011000110001: case 0b011000110010: case 0b011000110011: case 0b011000110100: case 0b011000110101: case 0b011000110110: case 0b011000110111: case 0b011000111000: case 0b011000111001: case 0b011000111010: case 0b011000111011: case 0b011000111100: case 0b011000111101: case 0b011000111110: case 0b011000111111: case 0b011001000000: case 0b011001000001: case 0b011001000010: case 0b011001000011: case 0b011001000100: case 0b011001000101: case 0b011001000110: case 0b011001000111: case 0b011001001000: case 0b011001001001: case 0b011001001010: case 0b011001001011: case 0b011001001100: case 0b011001001101: case 0b011001001110: case 0b011001001111: case 0b011001010000: case 0b011001010001: case 0b011001010010: case 0b011001010011: case 0b011001010100: case 0b011001010101: case 0b011001010110: case 0b011001010111: case 0b011001011000: case 0b011001011001: case 0b011001011010: case 0b011001011011: case 0b011001011100: case 0b011001011101: case 0b011001011110: case 0b011001011111: case 0b011001100000: case 0b011001100001: case 0b011001100010: case 0b011001100011: case 0b011001100100: case 0b011001100101: case 0b011001100110: case 0b011001100111: case 0b011001101000: case 0b011001101001: case 0b011001101010: case 0b011001101011: case 0b011001101100: case 0b011001101101: case 0b011001101110: case 0b011001101111: case 0b011001110000: case 0b011001110001: case 0b011001110010: case 0b011001110011: case 0b011001110100: case 0b011001110101: case 0b011001110110: case 0b011001110111: case 0b011001111000: case 0b011001111001: case 0b011001111010: case 0b011001111011: case 0b011001111100: case 0b011001111101: case 0b011001111110: case 0b011001111111: - { // Store K[7:1] to A1[7:1] - util::stream_format(stream, "%04x: K(%02x)->A1", get_table(pc), inst & 0x7f); - break; - } - - // 680 - case 0b011010000000: case 0b011010000001: case 0b011010000010: case 0b011010000011: case 0b011010000100: case 0b011010000101: case 0b011010000110: case 0b011010000111: case 0b011010001000: case 0b011010001001: case 0b011010001010: case 0b011010001011: case 0b011010001100: case 0b011010001101: case 0b011010001110: case 0b011010001111: case 0b011010010000: case 0b011010010001: case 0b011010010010: case 0b011010010011: case 0b011010010100: case 0b011010010101: case 0b011010010110: case 0b011010010111: case 0b011010011000: case 0b011010011001: case 0b011010011010: case 0b011010011011: case 0b011010011100: case 0b011010011101: case 0b011010011110: case 0b011010011111: case 0b011010100000: case 0b011010100001: case 0b011010100010: case 0b011010100011: case 0b011010100100: case 0b011010100101: case 0b011010100110: case 0b011010100111: case 0b011010101000: case 0b011010101001: case 0b011010101010: case 0b011010101011: case 0b011010101100: case 0b011010101101: case 0b011010101110: case 0b011010101111: case 0b011010110000: case 0b011010110001: case 0b011010110010: case 0b011010110011: case 0b011010110100: case 0b011010110101: case 0b011010110110: case 0b011010110111: case 0b011010111000: case 0b011010111001: case 0b011010111010: case 0b011010111011: case 0b011010111100: case 0b011010111101: case 0b011010111110: case 0b011010111111: case 0b011011000000: case 0b011011000001: case 0b011011000010: case 0b011011000011: case 0b011011000100: case 0b011011000101: case 0b011011000110: case 0b011011000111: case 0b011011001000: case 0b011011001001: case 0b011011001010: case 0b011011001011: case 0b011011001100: case 0b011011001101: case 0b011011001110: case 0b011011001111: case 0b011011010000: case 0b011011010001: case 0b011011010010: case 0b011011010011: case 0b011011010100: case 0b011011010101: case 0b011011010110: case 0b011011010111: case 0b011011011000: case 0b011011011001: case 0b011011011010: case 0b011011011011: case 0b011011011100: case 0b011011011101: case 0b011011011110: case 0b011011011111: case 0b011011100000: case 0b011011100001: case 0b011011100010: case 0b011011100011: case 0b011011100100: case 0b011011100101: case 0b011011100110: case 0b011011100111: case 0b011011101000: case 0b011011101001: case 0b011011101010: case 0b011011101011: case 0b011011101100: case 0b011011101101: case 0b011011101110: case 0b011011101111: case 0b011011110000: case 0b011011110001: case 0b011011110010: case 0b011011110011: case 0b011011110100: case 0b011011110101: case 0b011011110110: case 0b011011110111: case 0b011011111000: case 0b011011111001: case 0b011011111010: case 0b011011111011: case 0b011011111100: case 0b011011111101: case 0b011011111110: case 0b011011111111: - { // Store K[7:1] to A2[7:1] - util::stream_format(stream, "%04x: K(%02x)->A2", get_table(pc), inst & 0x7f); - break; - } - - // 700 - case 0b011100000000: case 0b011100000001: case 0b011100000010: case 0b011100000011: case 0b011100000100: case 0b011100000101: case 0b011100000110: case 0b011100000111: case 0b011100001000: case 0b011100001001: case 0b011100001010: case 0b011100001011: case 0b011100001100: case 0b011100001101: case 0b011100001110: case 0b011100001111: case 0b011100010000: case 0b011100010001: case 0b011100010010: case 0b011100010011: case 0b011100010100: case 0b011100010101: case 0b011100010110: case 0b011100010111: case 0b011100011000: case 0b011100011001: case 0b011100011010: case 0b011100011011: case 0b011100011100: case 0b011100011101: case 0b011100011110: case 0b011100011111: case 0b011100100000: case 0b011100100001: case 0b011100100010: case 0b011100100011: case 0b011100100100: case 0b011100100101: case 0b011100100110: case 0b011100100111: case 0b011100101000: case 0b011100101001: case 0b011100101010: case 0b011100101011: case 0b011100101100: case 0b011100101101: case 0b011100101110: case 0b011100101111: case 0b011100110000: case 0b011100110001: case 0b011100110010: case 0b011100110011: case 0b011100110100: case 0b011100110101: case 0b011100110110: case 0b011100110111: case 0b011100111000: case 0b011100111001: case 0b011100111010: case 0b011100111011: case 0b011100111100: case 0b011100111101: case 0b011100111110: case 0b011100111111: case 0b011101000000: case 0b011101000001: case 0b011101000010: case 0b011101000011: case 0b011101000100: case 0b011101000101: case 0b011101000110: case 0b011101000111: case 0b011101001000: case 0b011101001001: case 0b011101001010: case 0b011101001011: case 0b011101001100: case 0b011101001101: case 0b011101001110: case 0b011101001111: case 0b011101010000: case 0b011101010001: case 0b011101010010: case 0b011101010011: case 0b011101010100: case 0b011101010101: case 0b011101010110: case 0b011101010111: case 0b011101011000: case 0b011101011001: case 0b011101011010: case 0b011101011011: case 0b011101011100: case 0b011101011101: case 0b011101011110: case 0b011101011111: case 0b011101100000: case 0b011101100001: case 0b011101100010: case 0b011101100011: case 0b011101100100: case 0b011101100101: case 0b011101100110: case 0b011101100111: case 0b011101101000: case 0b011101101001: case 0b011101101010: case 0b011101101011: case 0b011101101100: case 0b011101101101: case 0b011101101110: case 0b011101101111: case 0b011101110000: case 0b011101110001: case 0b011101110010: case 0b011101110011: case 0b011101110100: case 0b011101110101: case 0b011101110110: case 0b011101110111: case 0b011101111000: case 0b011101111001: case 0b011101111010: case 0b011101111011: case 0b011101111100: case 0b011101111101: case 0b011101111110: case 0b011101111111: - { // Store K[7:1] to A3[7:1] - util::stream_format(stream, "%04x: K(%02x)->A3", get_table(pc), inst & 0x7f); - break; - } - - // 780 - case 0b011110000000: case 0b011110000001: case 0b011110000010: case 0b011110000011: case 0b011110000100: case 0b011110000101: case 0b011110000110: case 0b011110000111: case 0b011110001000: case 0b011110001001: case 0b011110001010: case 0b011110001011: case 0b011110001100: case 0b011110001101: case 0b011110001110: case 0b011110001111: case 0b011110010000: case 0b011110010001: case 0b011110010010: case 0b011110010011: case 0b011110010100: case 0b011110010101: case 0b011110010110: case 0b011110010111: case 0b011110011000: case 0b011110011001: case 0b011110011010: case 0b011110011011: case 0b011110011100: case 0b011110011101: case 0b011110011110: case 0b011110011111: case 0b011110100000: case 0b011110100001: case 0b011110100010: case 0b011110100011: case 0b011110100100: case 0b011110100101: case 0b011110100110: case 0b011110100111: case 0b011110101000: case 0b011110101001: case 0b011110101010: case 0b011110101011: case 0b011110101100: case 0b011110101101: case 0b011110101110: case 0b011110101111: case 0b011110110000: case 0b011110110001: case 0b011110110010: case 0b011110110011: case 0b011110110100: case 0b011110110101: case 0b011110110110: case 0b011110110111: case 0b011110111000: case 0b011110111001: case 0b011110111010: case 0b011110111011: case 0b011110111100: case 0b011110111101: case 0b011110111110: case 0b011110111111: case 0b011111000000: case 0b011111000001: case 0b011111000010: case 0b011111000011: case 0b011111000100: case 0b011111000101: case 0b011111000110: case 0b011111000111: case 0b011111001000: case 0b011111001001: case 0b011111001010: case 0b011111001011: case 0b011111001100: case 0b011111001101: case 0b011111001110: case 0b011111001111: case 0b011111010000: case 0b011111010001: case 0b011111010010: case 0b011111010011: case 0b011111010100: case 0b011111010101: case 0b011111010110: case 0b011111010111: case 0b011111011000: case 0b011111011001: case 0b011111011010: case 0b011111011011: case 0b011111011100: case 0b011111011101: case 0b011111011110: case 0b011111011111: case 0b011111100000: case 0b011111100001: case 0b011111100010: case 0b011111100011: case 0b011111100100: case 0b011111100101: case 0b011111100110: case 0b011111100111: case 0b011111101000: case 0b011111101001: case 0b011111101010: case 0b011111101011: case 0b011111101100: case 0b011111101101: case 0b011111101110: case 0b011111101111: case 0b011111110000: case 0b011111110001: case 0b011111110010: case 0b011111110011: case 0b011111110100: case 0b011111110101: case 0b011111110110: case 0b011111110111: case 0b011111111000: case 0b011111111001: case 0b011111111010: case 0b011111111011: case 0b011111111100: case 0b011111111101: case 0b011111111110: case 0b011111111111: - { // Store K[7:1] to A4[7:1] - util::stream_format(stream, "%04x: K(%02x)->A4", get_table(pc), inst & 0x7f); - break; - } - default: { util::stream_format(stream, "%04x: %04x ", get_table(pc), inst); @@ -1141,12 +1083,56 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u } } } + else if (inst >= 0x480 && inst <= 0x4bf) // 480 - 4bf + { + // H[5:1]-K[5:1]->H[5:1], Skip if borrow + util::stream_format(stream, "%04x: H-K(%02x)->H BOJ", get_table(pc), inst & 0x1f); + } + else if (inst >= 0x4c0 && inst <= 0x4ff) // 4c0 - 4ff + { + // H[5:1]+K[5:1]H[5:1], Skip if carry + util::stream_format(stream, "%04x: H+K(%02x)->H CAJ", get_table(pc), inst & 0x1f); + } + else if (inst >= 0x500 && inst <= 0x57f) // 500 - 57f + { + // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] + // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] + // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] + util::stream_format(stream, "%04x: K(%02x)->M", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x580 && inst <= 0x5ff) // 580 - 5ff + { + // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] + util::stream_format(stream, "%04x: K(%02x)->L,H", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x600 && inst <= 0x67f) // 600 - 67f + { + // Store K[7:1] to A1[7:1] + util::stream_format(stream, "%04x: K(%02x)->A1", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x680 && inst <= 0x6ff) // 680 - 6ff + { + // Store K[7:1] to A2[7:1] + util::stream_format(stream, "%04x: K(%02x)->A2", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x700 && inst <= 0x77f) // 680 - 6ff + { + // Store K[7:1] to A3[7:1] + util::stream_format(stream, "%04x: K(%02x)->A3", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x780 && inst <= 0x7ff) // 780 - 7ff + { + // Store K[7:1] to A4[7:1] + util::stream_format(stream, "%04x: K(%02x)->A4", get_table(pc), inst & 0x7f); + } else if (inst < 0xc00) // 800 - bff - { // Move K[10:1] to A[10:1], Jump to A[11:1] + { + // Move K[10:1] to A[10:1], Jump to A[11:1] util::stream_format(stream, "%04x: JP %03x", get_table(pc), inst & 0x3ff); } else if (inst < 0x1000) // c00 - fff - { // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack + { + // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack util::stream_format(stream, "%04x: JS %03x", get_table(pc), inst & 0x3ff); } From 16c668405ca55c231e401ad7bf3bdaac215f9b9a Mon Sep 17 00:00:00 2001 From: David Haywood Date: Fri, 29 Dec 2023 19:57:30 +0000 Subject: [PATCH 08/62] squash down some other larger case statements --- src/devices/cpu/upd777/upd777dasm.cpp | 346 +++++++++++++------------- 1 file changed, 170 insertions(+), 176 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index c999f7acb24f6..3e1c9a19c6e69 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -31,7 +31,74 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { u16 inst = opcodes.r16(pc); - if (inst < 0x480) + if (inst >= 0x080 && inst <= 0x0ff) + { + // Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow + util::stream_format(stream, "%04x: M-0x%02x", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x100 && inst <= 0x17f) + { + // M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] + util::stream_format(stream, "%04x: M+0x%02x->M, 0x%d->L", get_table(pc), inst & 0x1f, (inst >> 5) & 0x3); + } + else if (inst >= 0x180 && inst <= 0x1ff) + { + // M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "%04x: M-0x%02x->M, 0x%d->L", get_table(pc), inst & 0x1f, (inst >> 5) & 0x3); + } + else if (inst >= 0x480 && inst <= 0x4bf) // 480 - 4bf + { + // H[5:1]-K[5:1]->H[5:1], Skip if borrow + util::stream_format(stream, "%04x: H-0x%02x->H BOJ", get_table(pc), inst & 0x1f); + } + else if (inst >= 0x4c0 && inst <= 0x4ff) // 4c0 - 4ff + { + // H[5:1]+K[5:1]H[5:1], Skip if carry + util::stream_format(stream, "%04x: H+0x%02x->H CAJ", get_table(pc), inst & 0x1f); + } + else if (inst >= 0x500 && inst <= 0x57f) // 500 - 57f + { + // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] + // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] + // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] + util::stream_format(stream, "%04x: 0x%02x->M", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x580 && inst <= 0x5ff) // 580 - 5ff + { + // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] + util::stream_format(stream, "%04x: 0x%02x->L,H", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x600 && inst <= 0x67f) // 600 - 67f + { + // Store K[7:1] to A1[7:1] + util::stream_format(stream, "%04x: 0x%02x->A1", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x680 && inst <= 0x6ff) // 680 - 6ff + { + // Store K[7:1] to A2[7:1] + util::stream_format(stream, "%04x: 0x%02x->A2", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x700 && inst <= 0x77f) // 680 - 6ff + { + // Store K[7:1] to A3[7:1] + util::stream_format(stream, "%04x: 0x%02x->A3", get_table(pc), inst & 0x7f); + } + else if (inst >= 0x780 && inst <= 0x7ff) // 780 - 7ff + { + // Store K[7:1] to A4[7:1] + util::stream_format(stream, "%04x: 0x%02x->A4", get_table(pc), inst & 0x7f); + } + else if (inst < 0xc00) // 800 - bff + { + // Move K[10:1] to A[10:1], Jump to A[11:1] + util::stream_format(stream, "%04x: JP 0x%03x", get_table(pc), inst & 0x3ff); + } + else if (inst < 0x1000) // c00 - fff + { + // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack + util::stream_format(stream, "%04x: JS 0x%03x", get_table(pc), inst & 0x3ff); + } + else { switch (inst) { @@ -77,7 +144,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000101000: case 0b000000101001: { // Shift STB[4:1], N->STB[1] - util::stream_format(stream, "%04x: %d->STB", get_table(pc), inst & 1); + util::stream_format(stream, "%04x: 0x%d->STB", get_table(pc), inst & 1); break; } @@ -202,26 +269,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001111101: case 0b000001111110: case 0b000001111111: - case 0b000010000000: case 0b000010000001: case 0b000010000010: case 0b000010000011: case 0b000010000100: case 0b000010000101: case 0b000010000110: case 0b000010000111: case 0b000010001000: case 0b000010001001: case 0b000010001010: case 0b000010001011: case 0b000010001100: case 0b000010001101: case 0b000010001110: case 0b000010001111: case 0b000010010000: case 0b000010010001: case 0b000010010010: case 0b000010010011: case 0b000010010100: case 0b000010010101: case 0b000010010110: case 0b000010010111: case 0b000010011000: case 0b000010011001: case 0b000010011010: case 0b000010011011: case 0b000010011100: case 0b000010011101: case 0b000010011110: case 0b000010011111: case 0b000010100000: case 0b000010100001: case 0b000010100010: case 0b000010100011: case 0b000010100100: case 0b000010100101: case 0b000010100110: case 0b000010100111: case 0b000010101000: case 0b000010101001: case 0b000010101010: case 0b000010101011: case 0b000010101100: case 0b000010101101: case 0b000010101110: case 0b000010101111: case 0b000010110000: case 0b000010110001: case 0b000010110010: case 0b000010110011: case 0b000010110100: case 0b000010110101: case 0b000010110110: case 0b000010110111: case 0b000010111000: case 0b000010111001: case 0b000010111010: case 0b000010111011: case 0b000010111100: case 0b000010111101: case 0b000010111110: case 0b000010111111: case 0b000011000000: case 0b000011000001: case 0b000011000010: case 0b000011000011: case 0b000011000100: case 0b000011000101: case 0b000011000110: case 0b000011000111: case 0b000011001000: case 0b000011001001: case 0b000011001010: case 0b000011001011: case 0b000011001100: case 0b000011001101: case 0b000011001110: case 0b000011001111: case 0b000011010000: case 0b000011010001: case 0b000011010010: case 0b000011010011: case 0b000011010100: case 0b000011010101: case 0b000011010110: case 0b000011010111: case 0b000011011000: case 0b000011011001: case 0b000011011010: case 0b000011011011: case 0b000011011100: case 0b000011011101: case 0b000011011110: case 0b000011011111: case 0b000011100000: case 0b000011100001: case 0b000011100010: case 0b000011100011: case 0b000011100100: case 0b000011100101: case 0b000011100110: case 0b000011100111: case 0b000011101000: case 0b000011101001: case 0b000011101010: case 0b000011101011: case 0b000011101100: case 0b000011101101: case 0b000011101110: case 0b000011101111: case 0b000011110000: case 0b000011110001: case 0b000011110010: case 0b000011110011: case 0b000011110100: case 0b000011110101: case 0b000011110110: case 0b000011110111: case 0b000011111000: case 0b000011111001: case 0b000011111010: case 0b000011111011: case 0b000011111100: case 0b000011111101: case 0b000011111110: case 0b000011111111: - { // Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow - util::stream_format(stream, "%04x: M-K(%02x)", get_table(pc), inst & 0x7f); - break; - } - - - case 0b000100000000: case 0b000100000001: case 0b000100000010: case 0b000100000011: case 0b000100000100: case 0b000100000101: case 0b000100000110: case 0b000100000111: case 0b000100001000: case 0b000100001001: case 0b000100001010: case 0b000100001011: case 0b000100001100: case 0b000100001101: case 0b000100001110: case 0b000100001111: case 0b000100010000: case 0b000100010001: case 0b000100010010: case 0b000100010011: case 0b000100010100: case 0b000100010101: case 0b000100010110: case 0b000100010111: case 0b000100011000: case 0b000100011001: case 0b000100011010: case 0b000100011011: case 0b000100011100: case 0b000100011101: case 0b000100011110: case 0b000100011111: case 0b000100100000: case 0b000100100001: case 0b000100100010: case 0b000100100011: case 0b000100100100: case 0b000100100101: case 0b000100100110: case 0b000100100111: case 0b000100101000: case 0b000100101001: case 0b000100101010: case 0b000100101011: case 0b000100101100: case 0b000100101101: case 0b000100101110: case 0b000100101111: case 0b000100110000: case 0b000100110001: case 0b000100110010: case 0b000100110011: case 0b000100110100: case 0b000100110101: case 0b000100110110: case 0b000100110111: case 0b000100111000: case 0b000100111001: case 0b000100111010: case 0b000100111011: case 0b000100111100: case 0b000100111101: case 0b000100111110: case 0b000100111111: case 0b000101000000: case 0b000101000001: case 0b000101000010: case 0b000101000011: case 0b000101000100: case 0b000101000101: case 0b000101000110: case 0b000101000111: case 0b000101001000: case 0b000101001001: case 0b000101001010: case 0b000101001011: case 0b000101001100: case 0b000101001101: case 0b000101001110: case 0b000101001111: case 0b000101010000: case 0b000101010001: case 0b000101010010: case 0b000101010011: case 0b000101010100: case 0b000101010101: case 0b000101010110: case 0b000101010111: case 0b000101011000: case 0b000101011001: case 0b000101011010: case 0b000101011011: case 0b000101011100: case 0b000101011101: case 0b000101011110: case 0b000101011111: case 0b000101100000: case 0b000101100001: case 0b000101100010: case 0b000101100011: case 0b000101100100: case 0b000101100101: case 0b000101100110: case 0b000101100111: case 0b000101101000: case 0b000101101001: case 0b000101101010: case 0b000101101011: case 0b000101101100: case 0b000101101101: case 0b000101101110: case 0b000101101111: case 0b000101110000: case 0b000101110001: case 0b000101110010: case 0b000101110011: case 0b000101110100: case 0b000101110101: case 0b000101110110: case 0b000101110111: case 0b000101111000: case 0b000101111001: case 0b000101111010: case 0b000101111011: case 0b000101111100: case 0b000101111101: case 0b000101111110: case 0b000101111111: - { // M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] - - util::stream_format(stream, "%04x: M+K(%02x)->M, N(%01x)->L", get_table(pc), inst & 0x1f, (inst >> 5) & 0x3); - break; - } - - case 0b000110000000: case 0b000110000001: case 0b000110000010: case 0b000110000011: case 0b000110000100: case 0b000110000101: case 0b000110000110: case 0b000110000111: case 0b000110001000: case 0b000110001001: case 0b000110001010: case 0b000110001011: case 0b000110001100: case 0b000110001101: case 0b000110001110: case 0b000110001111: case 0b000110010000: case 0b000110010001: case 0b000110010010: case 0b000110010011: case 0b000110010100: case 0b000110010101: case 0b000110010110: case 0b000110010111: case 0b000110011000: case 0b000110011001: case 0b000110011010: case 0b000110011011: case 0b000110011100: case 0b000110011101: case 0b000110011110: case 0b000110011111: case 0b000110100000: case 0b000110100001: case 0b000110100010: case 0b000110100011: case 0b000110100100: case 0b000110100101: case 0b000110100110: case 0b000110100111: case 0b000110101000: case 0b000110101001: case 0b000110101010: case 0b000110101011: case 0b000110101100: case 0b000110101101: case 0b000110101110: case 0b000110101111: case 0b000110110000: case 0b000110110001: case 0b000110110010: case 0b000110110011: case 0b000110110100: case 0b000110110101: case 0b000110110110: case 0b000110110111: case 0b000110111000: case 0b000110111001: case 0b000110111010: case 0b000110111011: case 0b000110111100: case 0b000110111101: case 0b000110111110: case 0b000110111111: case 0b000111000000: case 0b000111000001: case 0b000111000010: case 0b000111000011: case 0b000111000100: case 0b000111000101: case 0b000111000110: case 0b000111000111: case 0b000111001000: case 0b000111001001: case 0b000111001010: case 0b000111001011: case 0b000111001100: case 0b000111001101: case 0b000111001110: case 0b000111001111: case 0b000111010000: case 0b000111010001: case 0b000111010010: case 0b000111010011: case 0b000111010100: case 0b000111010101: case 0b000111010110: case 0b000111010111: case 0b000111011000: case 0b000111011001: case 0b000111011010: case 0b000111011011: case 0b000111011100: case 0b000111011101: case 0b000111011110: case 0b000111011111: case 0b000111100000: case 0b000111100001: case 0b000111100010: case 0b000111100011: case 0b000111100100: case 0b000111100101: case 0b000111100110: case 0b000111100111: case 0b000111101000: case 0b000111101001: case 0b000111101010: case 0b000111101011: case 0b000111101100: case 0b000111101101: case 0b000111101110: case 0b000111101111: case 0b000111110000: case 0b000111110001: case 0b000111110010: case 0b000111110011: case 0b000111110100: case 0b000111110101: case 0b000111110110: case 0b000111110111: case 0b000111111000: case 0b000111111001: case 0b000111111010: case 0b000111111011: case 0b000111111100: case 0b000111111101: case 0b000111111110: case 0b000111111111: - { // M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-K(%02x)->M, N(%01x)->L", get_table(pc), inst & 0x1f, (inst >> 5) & 0x3); - break; - } - ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// @@ -229,7 +276,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 200 case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: { // Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: A1·A1, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1·A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } @@ -239,21 +286,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 208 case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: { // Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "%04x: A1=A1, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1=A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } // 20c case 0b001000001100: case 0b001000001101: case 0b001000001110:case 0b001000001111: { // Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A1, %d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1-A1, 0x%d->L BOJ", get_table(pc), inst & 0x3); break; } // 210 case 0b001000010000: case 0b001000010001: case 0b001000010010: case 0b001000010011: { // Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: A1·A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1·A2, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -263,21 +310,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 218 case 0b001000011000: case 0b001000011001: case 0b001000011010: case 0b001000011011: { // Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "%04x: A1=A2, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1=A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } // 21c case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: { // Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A2, %d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1-A2, 0x%d->L BOJ", get_table(pc), inst & 0x3); break; } // 220 case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: { // Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: A1·A1, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1·A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } @@ -287,21 +334,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 228 case 0b001000101000: case 0b001000101001: case 0b001000101010:case 0b001000101011: { // Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "%04x: A1=A1, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1=A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } // 22c case 0b001000101100: case 0b001000101101: case 0b001000101110: case 0b001000101111: { // Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A1, %d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1-A1, 0x%d->L BOJ/", get_table(pc), inst & 0x3); break; } // 230 case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: { // Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: A1·A2, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1·A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } @@ -311,21 +358,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 238 case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: { // Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "%04x: A1=A2, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1=A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } // 23c case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: { // Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A2, %d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1-A2, 0x%d->L BOJ/", get_table(pc), inst & 0x3); break; } // 240 case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: { // Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: A2·A1, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2·A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } @@ -335,21 +382,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 248 case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: { // Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: A2=A1, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2=A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } // 24c case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: { // Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A1, %d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2-A1, 0x%d->L BOJ", get_table(pc), inst & 0x3); break; } // 250 case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: { // Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: A2·A2, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2·A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } @@ -359,21 +406,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 258 case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: { // Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: A2=A2, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2=A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } // 25c case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: { // Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A2, N%(d)->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2-A2, 0x%d->L BOJ", get_table(pc), inst & 0x3); break; } // 260 case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: { // Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: A2·A1, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2·A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } @@ -383,21 +430,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 268 case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: { // Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: A2=A1, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2=A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } // 26c case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: { // Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A1, %d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2-A1, 0x%d->L BOJ/", get_table(pc), inst & 0x3); break; } // 270 case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: { // Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: A2·A2, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2·A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } @@ -407,21 +454,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 278 case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: { // Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: A2=A2, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2=A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } // 27c case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: { // Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A2, %d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2-A2, 0x%d->L BOJ/", get_table(pc), inst & 0x3); break; } // 280 case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: M·A1, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M·A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } @@ -431,21 +478,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 288 case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: M=A1, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M=A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } // 28c case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-A1, %d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M-A1, 0x%d->L BOJ", get_table(pc), inst & 0x3); break; } // 290 case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: M·A2, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M·A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } @@ -455,21 +502,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 298 case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: M=A2, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M=A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } // 29c case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-A2, %d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M-A2, 0x%d->L BOJ", get_table(pc), inst & 0x3); break; } // 2a0 case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: M·A1, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M·A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } @@ -479,21 +526,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2a8 case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: M=A1, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M=A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } // 2ac case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-A1, %d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M-A1, 0x%d->L BOJ/", get_table(pc), inst & 0x3); break; } // 2b0 case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: M·A2, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M·A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } @@ -503,21 +550,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2b8 case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: M=A2, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M=A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } // 2bc case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-A2, %d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M-A2, 0x%d->L BOJ/", get_table(pc), inst & 0x3); break; } // 2c0 case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: { // Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: H·A1, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H·A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } @@ -527,7 +574,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2c8 case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: { // Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: H=A1, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H=A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } @@ -541,7 +588,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2d0 case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: { // Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: H·A2, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H·A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } @@ -551,21 +598,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2d8 case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: { // Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: H=A2, %d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H=A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); break; } // 2dc case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: { // Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A2, %d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H-A2, 0x%d->L BOJ", get_table(pc), inst & 0x3); break; } // 2e0 case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: { // Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: H·A1, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H·A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } @@ -575,21 +622,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2e8 case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: { // Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: H=A1, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H=A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } // 2ec case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: { // Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A1, %d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H-A1, 0x%d->L BOJ/", get_table(pc), inst & 0x3); break; } // 2f0 case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: { // Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: H·A2, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H·A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } @@ -599,14 +646,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2f8 case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: { // Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: H=A2, %d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H=A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); break; } // 2fc case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: { // Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A2, %d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H-A2, 0x%d->L BOJ/", get_table(pc), inst & 0x3); break; } @@ -616,7 +663,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 300 case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: { // N->L[2:1] - util::stream_format(stream, "%04x: %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -640,7 +687,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 30a case 0b001100001010: case 0b001100001011: { // Move A1[7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "%04x: A1->MODE, 1%d->L", get_table(pc), inst & 0x1); + util::stream_format(stream, "%04x: A1->MODE, 0x%d->L", get_table(pc), (inst & 0x1) + 2); break; } @@ -650,7 +697,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 310 case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: { // Move A2[7:1] to A1[7:1], N->L[2:1 - util::stream_format(stream, "%04x: A2->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -660,77 +707,77 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 318 case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: { // Right shift A1[7:1], 0A1[7], N->L[2:1] - util::stream_format(stream, "%04x: A1->RS, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1->RS, 0x%d->L", get_table(pc), inst & 0x3); break; } // 31c case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: { // Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A2->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1-A2->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 320 case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: { // AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1·A1->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1·A1->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 324 case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: { // Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1+A1->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1+A1->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 328 case 0b001100101000: case 0b001100101001: case 0b001100101010: case 0b001100101011: { // OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1vA1->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1vA1->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 32c case 0b001100101100: case 0b001100101101: case 0b001100101110: case 0b001100101111: { // Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A1->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1-A1->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 330 case 0b001100110000: case 0b001100110001: case 0b001100110010: case 0b001100110011: { // AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1·A2->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1·A2->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 334 case 0b001100110100: case 0b001100110101: case 0b001100110110: case 0b001100110111: { // Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1+A2->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1+A2->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 338 case 0b001100111000: case 0b001100111001: case 0b001100111010: case 0b001100111011: { // OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1vA2->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1vA2->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 33c case 0b001100111100: case 0b001100111101: case 0b001100111110: case 0b001100111111: { // Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A2->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1-A2->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 340 case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: { // Move A1[7:1] to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -754,14 +801,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 34a case 0b001101001010: case 0b001101001011: { // Move A2[7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "%04x: A2->MODE, 1%d->L", get_table(pc), inst & 0x1); + util::stream_format(stream, "%04x: A2->MODE, 0x%d->L", get_table(pc), (inst & 0x1) + 2); break; } // 34c case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: { // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A1->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2-A1->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -771,7 +818,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 358 case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: { // Right shift A2[7:1], 0A2[7], N->L[2:1] - util::stream_format(stream, "%04x: A2->RS, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2->RS, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -781,70 +828,70 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 360 case 0b001101100000: case 0b001101100001: case 0b001101100010: case 0b001101100011: { // AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2·A1->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2·A1->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 364 case 0b001101100100: case 0b001101100101: case 0b001101100110: case 0b001101100111: { // Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2+A1->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2+A1->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 368 case 0b001101101000: case 0b001101101001: case 0b001101101010: case 0b001101101011: { // OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2vA1->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2vA1->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 36c case 0b001101101100: case 0b001101101101: case 0b001101101110: case 0b001101101111: { // Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A1->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2-A1->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 370 case 0b001101110000: case 0b001101110001: case 0b001101110010: case 0b001101110011: { // AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2·A2->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2·A2->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 374 case 0b001101110100: case 0b001101110101: case 0b001101110110: case 0b001101110111: { // Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2+A2->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2+A2->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 378 case 0b001101111000: case 0b001101111001: case 0b001101111010: case 0b001101111011: { // OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2vA2->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2vA2->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 37c case 0b001101111100: case 0b001101111101: case 0b001101111110: case 0b001101111111: { // Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A2->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2-A2->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 380 case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: { // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1->M, 0x%d->L", get_table(pc), inst & 0x3); break; } // 384 case 0b001110000100: case 0b001110000101: case 0b001110000110: case 0b001110000111: { // Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: M<->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M<->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -865,77 +912,77 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 38a case 0b001110001010: case 0b001110001011: { // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "%04x: M->MODE, 1%d->L", get_table(pc), inst & 0x1); + util::stream_format(stream, "%04x: M->MODE, 0x%d->L", get_table(pc), (inst & 0x1) + 2); break; } // 38c case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: { // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: M->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 390 case 0b001110010000: case 0b001110010001: case 0b001110010010: case 0b001110010011: { // Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2->M, 0x%d->L", get_table(pc), inst & 0x3); break; } // 394 case 0b001110010100: case 0b001110010101: case 0b001110010110: case 0b001110010111: { // Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: M<->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M<->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 398 case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: { // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] - util::stream_format(stream, "%04x: M->RS, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M->RS, 0x%d->L", get_table(pc), inst & 0x3); break; } // 39c case 0b001110011100: case 0b001110011101: case 0b001110011110: case 0b001110011111: { // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: M<->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M<->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3a0 case 0b001110100000: case 0b001110100001: case 0b001110100010: case 0b001110100011: { // AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: M·A1->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M·A1->M, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3a4 case 0b001110100100: case 0b001110100101: case 0b001110100110: case 0b001110100111: { // Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - util::stream_format(stream, "%04x: M+A1->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M+A1->M, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3a8 case 0b001110101000: case 0b001110101001: case 0b001110101010: case 0b001110101011: { // OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: MvA1->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: MvA1->M, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3ac case 0b001110101100: case 0b001110101101: case 0b001110101110: case 0b001110101111: { // Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - util::stream_format(stream, "%04x: M-A1->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M-A1->M, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3b0 case 0b001110110000: case 0b001110110001: case 0b001110110010: case 0b001110110011: { // AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: M·A2->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M·A2->M, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -943,7 +990,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001110110100: case 0b001110110101: case 0b001110110110: case 0b001110110111: { // Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - util::stream_format(stream, "%04x: M+A2->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M+A2->M, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -951,7 +998,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001110111000: case 0b001110111001: case 0b001110111010: case 0b001110111011: { // OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: MvA2->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: MvA2->M, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -959,14 +1006,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001110111100: case 0b001110111101: case 0b001110111110: case 0b001110111111: { // Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - util::stream_format(stream, "%04x: M-A2->M, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: M-A2->M, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3c0 case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: { // Move A1[5:1] to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: A1->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A1->H, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -975,14 +1022,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 3cc case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: { // Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] - util::stream_format(stream, "%04x: H->A1, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H->A1, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3d0 case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: { // Move A2[5:1] to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: A2->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: A2->H, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -991,60 +1038,60 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 3dc case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: { // Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] - util::stream_format(stream, "%04x: H->A2, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H->A2, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3e0 case 0b001111100000: case 0b001111100001: case 0b001111100010: case 0b001111100011: { // AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: H·A1->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H·A1->H, 0x%d->L", get_table(pc), inst & 0x3); break; } case 0b001111100100: case 0b001111100101: case 0b001111100110: case 0b001111100111: { // Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: H+A1->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H+A1->H, 0x%d->L", get_table(pc), inst & 0x3); break; } case 0b001111101000: case 0b001111101001: case 0b001111101010: case 0b001111101011: { // OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: HvA1->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: HvA1->H, 0x%d->L", get_table(pc), inst & 0x3); break; } case 0b001111101100: case 0b001111101101: case 0b001111101110: case 0b001111101111: { // Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A1->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H-A1->H, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3f0 case 0b001111110000: case 0b001111110001: case 0b001111110010: case 0b001111110011: { // AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: H·A2->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H·A2->H, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3f4 case 0b001111110100: case 0b001111110101: case 0b001111110110: case 0b001111110111: { // Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: H+A2->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H+A2->H, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3f8 case 0b001111111000: case 0b001111111001: case 0b001111111010: case 0b001111111011: { // OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: HvA2->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: HvA2->H, 0x%d->L", get_table(pc), inst & 0x3); break; } // 3fc case 0b001111111100: case 0b001111111101: case 0b001111111110: case 0b001111111111: { // Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A2->H, %d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "%04x: H-A2->H, 0x%d->L", get_table(pc), inst & 0x3); break; } @@ -1069,7 +1116,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 440 case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: { // Set D to DISP, G to GPE, K to KIE, S to SME, NA[11] - util::stream_format(stream, "%04x: D(%d)->D, G(%d)->G, K(%d)->K, S(%d)->S, %d->A11", get_table(pc), (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); + util::stream_format(stream, "%04x: %d->D, %d->G, %d->K, %d->S, %d->A11", get_table(pc), (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); break; } @@ -1083,58 +1130,5 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u } } } - else if (inst >= 0x480 && inst <= 0x4bf) // 480 - 4bf - { - // H[5:1]-K[5:1]->H[5:1], Skip if borrow - util::stream_format(stream, "%04x: H-K(%02x)->H BOJ", get_table(pc), inst & 0x1f); - } - else if (inst >= 0x4c0 && inst <= 0x4ff) // 4c0 - 4ff - { - // H[5:1]+K[5:1]H[5:1], Skip if carry - util::stream_format(stream, "%04x: H+K(%02x)->H CAJ", get_table(pc), inst & 0x1f); - } - else if (inst >= 0x500 && inst <= 0x57f) // 500 - 57f - { - // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] - // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] - // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] - util::stream_format(stream, "%04x: K(%02x)->M", get_table(pc), inst & 0x7f); - } - else if (inst >= 0x580 && inst <= 0x5ff) // 580 - 5ff - { - // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] - util::stream_format(stream, "%04x: K(%02x)->L,H", get_table(pc), inst & 0x7f); - } - else if (inst >= 0x600 && inst <= 0x67f) // 600 - 67f - { - // Store K[7:1] to A1[7:1] - util::stream_format(stream, "%04x: K(%02x)->A1", get_table(pc), inst & 0x7f); - } - else if (inst >= 0x680 && inst <= 0x6ff) // 680 - 6ff - { - // Store K[7:1] to A2[7:1] - util::stream_format(stream, "%04x: K(%02x)->A2", get_table(pc), inst & 0x7f); - } - else if (inst >= 0x700 && inst <= 0x77f) // 680 - 6ff - { - // Store K[7:1] to A3[7:1] - util::stream_format(stream, "%04x: K(%02x)->A3", get_table(pc), inst & 0x7f); - } - else if (inst >= 0x780 && inst <= 0x7ff) // 780 - 7ff - { - // Store K[7:1] to A4[7:1] - util::stream_format(stream, "%04x: K(%02x)->A4", get_table(pc), inst & 0x7f); - } - else if (inst < 0xc00) // 800 - bff - { - // Move K[10:1] to A[10:1], Jump to A[11:1] - util::stream_format(stream, "%04x: JP %03x", get_table(pc), inst & 0x3ff); - } - else if (inst < 0x1000) // c00 - fff - { - // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack - util::stream_format(stream, "%04x: JS %03x", get_table(pc), inst & 0x3ff); - } - return 1; } From 3025ae6238c68fcaeb1d244acc1dc035c481efdf Mon Sep 17 00:00:00 2001 From: David Haywood Date: Fri, 29 Dec 2023 20:15:49 +0000 Subject: [PATCH 09/62] temporary debug code for creating rearranged ROMs --- src/mame/epoch/cassvisn.cpp | 38 +++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index c360dfdce1c53..1a7ac5b68a007 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -15,6 +15,7 @@ the linked 'design note' contains a large amount of useful information #include "bus/generic/slot.h" #include "bus/generic/carts.h" #include "cpu/upd777/upd777.h" +#include "cpu/upd777/upd777dasm.h" #include "softlist_dev.h" @@ -38,6 +39,8 @@ class cassvisn_state : public driver_device private: required_device m_maincpu; required_device m_cart; + + u16 m_table[0xfe0/2]; }; static INPUT_PORTS_START( cassvisn ) @@ -49,6 +52,41 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_LITTLE); m_cart->common_load_rom(m_cart->get_rom_base(), size, "prg"); memcpy(memregion("maincpu")->base(), m_cart->get_rom_base(), size); + + upd777_disassembler::populate_addr_table(m_table); + + if (size == 0xfe0) + { + u8 *ROM = memregion("maincpu")->base(); + + u8 m_newrom[0x1000]; + std::fill(std::begin(m_newrom), std::end(m_newrom), 0xff); + + for (int realadd = 0; realadd < 0x800; realadd++) + { + int found = -1; + for (int checkaddr = 0; checkaddr < 0xfe0/2; checkaddr++) + { + if (m_table[checkaddr] == realadd) + found = checkaddr; + } + + if (found != -1) + { + m_newrom[(realadd * 2) + 1] = ROM[(found * 2) + 0]; + m_newrom[(realadd * 2) + 0] = ROM[(found * 2) + 1]; + } + } + + FILE *fp; + fp=fopen("rearranged_rom.bin", "w+b"); + if (fp) + { + fwrite(m_newrom, 0x1000, 1, fp); + fclose(fp); + } + } + return std::make_pair(std::error_condition(), std::string()); } From 6666697735373f66b876970ea15d038e7c189673 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Fri, 29 Dec 2023 20:37:26 +0000 Subject: [PATCH 10/62] replace dumps with MAME-cooked ones --- hash/cassvisn_cart.xml | 50 +++++++++++++++++++++--------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index d7ebcec017a29..00b9672bb0c4f 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -30,9 +30,9 @@ The following games exist for this platform 1981 Epoch - - - + + + @@ -44,8 +44,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -59,9 +59,9 @@ The following games exist for this platform 1981 Epoch - - - + + + @@ -73,9 +73,9 @@ The following games exist for this platform 1981 Epoch - - - + + + @@ -88,8 +88,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -102,8 +102,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -116,8 +116,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -130,8 +130,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -144,8 +144,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -158,8 +158,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -172,8 +172,8 @@ The following games exist for this platform 1981 Epoch - - + + From e0f88d27e8cc7cdd9972522342a79bc8fc379d9e Mon Sep 17 00:00:00 2001 From: David Haywood Date: Fri, 29 Dec 2023 21:09:50 +0000 Subject: [PATCH 11/62] this is not giving me the correct addresses in the dasm and I still don't know why --- src/devices/cpu/upd777/upd777.cpp | 2 - src/devices/cpu/upd777/upd777.h | 2 - src/devices/cpu/upd777/upd777dasm.cpp | 318 +++++++++++++------------- src/devices/cpu/upd777/upd777dasm.h | 28 +-- src/mame/epoch/cassvisn.cpp | 37 --- 5 files changed, 165 insertions(+), 222 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 721778615c5da..0f625cdce63b6 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -60,8 +60,6 @@ void upd777_device::device_start() state_add(STATE_GENPC, "GENPC", m_pc).noshow(); state_add(STATE_GENPCBASE, "CURPC", m_pc).noshow(); - upd777_disassembler::populate_addr_table(m_table); - save_item(NAME(m_pc)); save_item(NAME(m_icount)); } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index ee564c1d8fdbe..cfbe849b75694 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -42,8 +42,6 @@ class upd777_device : public cpu_device u16 fetch(); void do_op(); - u16 m_table[0xfe0/2]; - u32 m_pc; s32 m_icount; }; diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 3e1c9a19c6e69..f9708e1430bd4 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -7,7 +7,21 @@ upd777_disassembler::upd777_disassembler() : util::disasm_interface() { - populate_addr_table(m_table); + // init lfsr pc lut + for (u32 i = 0, pc = 0; i < 0x80; i++) + { + m_l2r[i] = pc; + m_r2l[pc] = i; + + printf("pc %02x\n", pc); + + int top1 = (pc & 0x40) >> 6; + int top2 = (pc & 0x20) >> 5; + int nor = (top1 ^ top2) ^ 1; + pc = (pc << 1) | nor; + pc &= 0x7f; + + } } u32 upd777_disassembler::opcode_alignment() const @@ -15,18 +29,6 @@ u32 upd777_disassembler::opcode_alignment() const return 1; } -u16 upd777_disassembler::get_table(u16 addr) -{ - if (addr < 0xfe0) - { - return m_table[addr]; - } - else - { - return 0xffff; - } -} - offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const upd777_disassembler::data_buffer &opcodes, const upd777_disassembler::data_buffer ¶ms) { u16 inst = opcodes.r16(pc); @@ -34,69 +36,69 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u if (inst >= 0x080 && inst <= 0x0ff) { // Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow - util::stream_format(stream, "%04x: M-0x%02x", get_table(pc), inst & 0x7f); + util::stream_format(stream, "M-0x%02x", inst & 0x7f); } else if (inst >= 0x100 && inst <= 0x17f) { // M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] - util::stream_format(stream, "%04x: M+0x%02x->M, 0x%d->L", get_table(pc), inst & 0x1f, (inst >> 5) & 0x3); + util::stream_format(stream, "M+0x%02x->M, 0x%d->L", inst & 0x1f, (inst >> 5) & 0x3); } else if (inst >= 0x180 && inst <= 0x1ff) { // M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-0x%02x->M, 0x%d->L", get_table(pc), inst & 0x1f, (inst >> 5) & 0x3); + util::stream_format(stream, "M-0x%02x->M, 0x%d->L", inst & 0x1f, (inst >> 5) & 0x3); } else if (inst >= 0x480 && inst <= 0x4bf) // 480 - 4bf { // H[5:1]-K[5:1]->H[5:1], Skip if borrow - util::stream_format(stream, "%04x: H-0x%02x->H BOJ", get_table(pc), inst & 0x1f); + util::stream_format(stream, "H-0x%02x->H BOJ", inst & 0x1f); } else if (inst >= 0x4c0 && inst <= 0x4ff) // 4c0 - 4ff { // H[5:1]+K[5:1]H[5:1], Skip if carry - util::stream_format(stream, "%04x: H+0x%02x->H CAJ", get_table(pc), inst & 0x1f); + util::stream_format(stream, "H+0x%02x->H CAJ", inst & 0x1f); } else if (inst >= 0x500 && inst <= 0x57f) // 500 - 57f { // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] - util::stream_format(stream, "%04x: 0x%02x->M", get_table(pc), inst & 0x7f); + util::stream_format(stream, "0x%02x->M", inst & 0x7f); } else if (inst >= 0x580 && inst <= 0x5ff) // 580 - 5ff { // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] - util::stream_format(stream, "%04x: 0x%02x->L,H", get_table(pc), inst & 0x7f); + util::stream_format(stream, "0x%02x->L,H", inst & 0x7f); } else if (inst >= 0x600 && inst <= 0x67f) // 600 - 67f { // Store K[7:1] to A1[7:1] - util::stream_format(stream, "%04x: 0x%02x->A1", get_table(pc), inst & 0x7f); + util::stream_format(stream, "0x%02x->A1", inst & 0x7f); } else if (inst >= 0x680 && inst <= 0x6ff) // 680 - 6ff { // Store K[7:1] to A2[7:1] - util::stream_format(stream, "%04x: 0x%02x->A2", get_table(pc), inst & 0x7f); + util::stream_format(stream, "0x%02x->A2", inst & 0x7f); } else if (inst >= 0x700 && inst <= 0x77f) // 680 - 6ff { // Store K[7:1] to A3[7:1] - util::stream_format(stream, "%04x: 0x%02x->A3", get_table(pc), inst & 0x7f); + util::stream_format(stream, "0x%02x->A3", inst & 0x7f); } else if (inst >= 0x780 && inst <= 0x7ff) // 780 - 7ff { // Store K[7:1] to A4[7:1] - util::stream_format(stream, "%04x: 0x%02x->A4", get_table(pc), inst & 0x7f); + util::stream_format(stream, "0x%02x->A4", inst & 0x7f); } else if (inst < 0xc00) // 800 - bff { // Move K[10:1] to A[10:1], Jump to A[11:1] - util::stream_format(stream, "%04x: JP 0x%03x", get_table(pc), inst & 0x3ff); + util::stream_format(stream, "JP 0x%03x", inst & 0x3ff); } else if (inst < 0x1000) // c00 - fff { // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack - util::stream_format(stream, "%04x: JS 0x%03x", get_table(pc), inst & 0x3ff); + util::stream_format(stream, "JS 0x%03x", inst & 0x3ff); } else { @@ -104,7 +106,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { case 0b000000000000: { // No Operation - util::stream_format(stream, "%04x: NOP", get_table(pc)); + util::stream_format(stream, "NOP"); break; } @@ -112,7 +114,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000000100: { // Skip if (Gun Port Latch) = 1 - util::stream_format(stream, "%04x: GPL", get_table(pc)); + util::stream_format(stream, "GPL"); break; } @@ -120,7 +122,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000001000: { // Move H[5:1] to Line Buffer Register[5:1] - util::stream_format(stream, "%04x: H->NRM", get_table(pc)); + util::stream_format(stream, "H->NRM"); break; } @@ -128,7 +130,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000011000: { // H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] - util::stream_format(stream, "%04x: H<->X", get_table(pc)); + util::stream_format(stream, "H<->X"); break; } @@ -136,7 +138,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000100000: { // Subroutine End, Pop down address stack - util::stream_format(stream, "%04x: SRE", get_table(pc)); + util::stream_format(stream, "SRE"); break; } @@ -144,7 +146,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000101000: case 0b000000101001: { // Shift STB[4:1], N->STB[1] - util::stream_format(stream, "%04x: 0x%d->STB", get_table(pc), inst & 1); + util::stream_format(stream, "0x%d->STB", inst & 1); break; } @@ -152,7 +154,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000110000: { // Skip if (PD1 input) = 1 - util::stream_format(stream, "%04x: PD1 J", get_table(pc)); + util::stream_format(stream, "PD1 J"); break; } @@ -160,7 +162,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000110100: { // Skip if (PD2 input) = 1 - util::stream_format(stream, "%04x: PD2 J", get_table(pc)); + util::stream_format(stream, "PD2 J"); break; } @@ -168,7 +170,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000111000: { // Skip if (PD3 input) = 1 - util::stream_format(stream, "%04x: PD3 J", get_table(pc)); + util::stream_format(stream, "PD3 J"); break; } @@ -176,7 +178,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000111100: { // Skip if (PD4 input) = 1 - util::stream_format(stream, "%04x: PD4 J", get_table(pc)); + util::stream_format(stream, "PD4 J"); break; } @@ -184,14 +186,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001001001: { // Skip if (4H Horizontal Blank) = 1 - util::stream_format(stream, "%04x: 4H BLK", get_table(pc)); + util::stream_format(stream, "4H BLK"); break; } case 0b000001001010: { // Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] - util::stream_format(stream, "%04x: VBLK", get_table(pc)); + util::stream_format(stream, "VBLK"); break; } @@ -199,7 +201,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001001100: { // Skip if (GP&SW/ input) = 1 - util::stream_format(stream, "%04x: GPSW/", get_table(pc)); + util::stream_format(stream, "GPSW/"); break; } @@ -207,7 +209,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001010100: { // Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] - util::stream_format(stream, "%04x: A->MA", get_table(pc)); + util::stream_format(stream, "A->MA"); break; } @@ -215,7 +217,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001011000: { // Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) - util::stream_format(stream, "%04x: MA->A", get_table(pc)); + util::stream_format(stream, "MA->A"); break; } @@ -223,7 +225,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001011100: { // Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] - util::stream_format(stream, "%04x: MA<->A", get_table(pc)); + util::stream_format(stream, "MA<->A"); break; } @@ -231,7 +233,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001100000: { // Subroutine End, Pop down address stack, Skip - util::stream_format(stream, "%04x: SRE+1", get_table(pc)); + util::stream_format(stream, "SRE+1"); break; } @@ -239,7 +241,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001110000: { // Skip if (PD1 input) = 0 - util::stream_format(stream, "%04x: PD1 /J", get_table(pc), inst); + util::stream_format(stream, "PD1 /J", inst); break; } @@ -247,7 +249,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001110100: { // Skip if (PD2 input) = 0 - util::stream_format(stream, "%04x: PD2 /J", get_table(pc), inst); + util::stream_format(stream, "PD2 /J", inst); break; } @@ -255,7 +257,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001111000: { // Skip if (PD3 input) = 0 - util::stream_format(stream, "%04x: PD3 /J", get_table(pc), inst); + util::stream_format(stream, "PD3 /J", inst); break; } @@ -263,7 +265,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001111100: { // Skip if (PD4 input) = 0 - util::stream_format(stream, "%04x: PD4 /J", get_table(pc), inst); + util::stream_format(stream, "PD4 /J", inst); break; } @@ -276,7 +278,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 200 case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: { // Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: A1·A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1·A1, 0x%d->L EQJ", inst & 0x3); break; } @@ -286,21 +288,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 208 case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: { // Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "%04x: A1=A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1=A1, 0x%d->L EQJ", inst & 0x3); break; } // 20c case 0b001000001100: case 0b001000001101: case 0b001000001110:case 0b001000001111: { // Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A1, 0x%d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1-A1, 0x%d->L BOJ", inst & 0x3); break; } // 210 case 0b001000010000: case 0b001000010001: case 0b001000010010: case 0b001000010011: { // Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: A1·A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1·A2, 0x%d->L", inst & 0x3); break; } @@ -310,21 +312,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 218 case 0b001000011000: case 0b001000011001: case 0b001000011010: case 0b001000011011: { // Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "%04x: A1=A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1=A2, 0x%d->L EQJ", inst & 0x3); break; } // 21c case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: { // Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A2, 0x%d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1-A2, 0x%d->L BOJ", inst & 0x3); break; } // 220 case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: { // Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: A1·A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1·A1, 0x%d->L EQJ/", inst & 0x3); break; } @@ -334,21 +336,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 228 case 0b001000101000: case 0b001000101001: case 0b001000101010:case 0b001000101011: { // Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "%04x: A1=A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1=A1, 0x%d->L EQJ/", inst & 0x3); break; } // 22c case 0b001000101100: case 0b001000101101: case 0b001000101110: case 0b001000101111: { // Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A1, 0x%d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1-A1, 0x%d->L BOJ/", inst & 0x3); break; } // 230 case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: { // Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: A1·A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1·A2, 0x%d->L EQJ/", inst & 0x3); break; } @@ -358,21 +360,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 238 case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: { // Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "%04x: A1=A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1=A2, 0x%d->L EQJ/", inst & 0x3); break; } // 23c case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: { // Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A2, 0x%d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1-A2, 0x%d->L BOJ/", inst & 0x3); break; } // 240 case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: { // Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: A2·A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2·A1, 0x%d->L EQJ", inst & 0x3); break; } @@ -382,21 +384,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 248 case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: { // Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: A2=A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2=A1, 0x%d->L EQJ", inst & 0x3); break; } // 24c case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: { // Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A1, 0x%d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2-A1, 0x%d->L BOJ", inst & 0x3); break; } // 250 case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: { // Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: A2·A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2·A2, 0x%d->L EQJ", inst & 0x3); break; } @@ -406,21 +408,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 258 case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: { // Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: A2=A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2=A2, 0x%d->L EQJ", inst & 0x3); break; } // 25c case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: { // Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A2, 0x%d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2-A2, 0x%d->L BOJ", inst & 0x3); break; } // 260 case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: { // Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: A2·A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2·A1, 0x%d->L EQJ/", inst & 0x3); break; } @@ -430,21 +432,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 268 case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: { // Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: A2=A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2=A1, 0x%d->L EQJ/", inst & 0x3); break; } // 26c case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: { // Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A1, 0x%d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2-A1, 0x%d->L BOJ/", inst & 0x3); break; } // 270 case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: { // Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: A2·A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2·A2, 0x%d->L EQJ/", inst & 0x3); break; } @@ -454,21 +456,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 278 case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: { // Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: A2=A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2=A2, 0x%d->L EQJ/", inst & 0x3); break; } // 27c case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: { // Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A2, 0x%d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2-A2, 0x%d->L BOJ/", inst & 0x3); break; } // 280 case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: M·A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "M·A1, 0x%d->L EQJ", inst & 0x3); break; } @@ -478,21 +480,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 288 case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: M=A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "M=A1, 0x%d->L EQJ", inst & 0x3); break; } // 28c case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-A1, 0x%d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "M-A1, 0x%d->L BOJ", inst & 0x3); break; } // 290 case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: M·A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "M·A2, 0x%d->L EQJ", inst & 0x3); break; } @@ -502,21 +504,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 298 case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: M=A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "M=A2, 0x%d->L EQJ", inst & 0x3); break; } // 29c case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-A2, 0x%d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "M-A2, 0x%d->L BOJ", inst & 0x3); break; } // 2a0 case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: M·A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "M·A1, 0x%d->L EQJ/", inst & 0x3); break; } @@ -526,21 +528,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2a8 case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: M=A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "M=A1, 0x%d->L EQJ/", inst & 0x3); break; } // 2ac case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-A1, 0x%d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "M-A1, 0x%d->L BOJ/", inst & 0x3); break; } // 2b0 case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: M·A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "M·A2, 0x%d->L EQJ/", inst & 0x3); break; } @@ -550,21 +552,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2b8 case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: M=A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "M=A2, 0x%d->L EQJ/", inst & 0x3); break; } // 2bc case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: M-A2, 0x%d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "M-A2, 0x%d->L BOJ/", inst & 0x3); break; } // 2c0 case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: { // Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: H·A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "H·A1, 0x%d->L EQJ", inst & 0x3); break; } @@ -574,21 +576,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2c8 case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: { // Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: H=A1, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "H=A1, 0x%d->L EQJ", inst & 0x3); break; } // 2cc case 0b001011001100: case 0b001011001101: case 0b001011001110: case 0b001011001111: { // Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A1, N%(d)->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "H-A1, N%(d)->L BOJ", inst & 0x3); break; } // 2d0 case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: { // Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] - util::stream_format(stream, "%04x: H·A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "H·A2, 0x%d->L EQJ", inst & 0x3); break; } @@ -598,21 +600,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2d8 case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: { // Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: H=A2, 0x%d->L EQJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "H=A2, 0x%d->L EQJ", inst & 0x3); break; } // 2dc case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: { // Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A2, 0x%d->L BOJ", get_table(pc), inst & 0x3); + util::stream_format(stream, "H-A2, 0x%d->L BOJ", inst & 0x3); break; } // 2e0 case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: { // Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: H·A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "H·A1, 0x%d->L EQJ/", inst & 0x3); break; } @@ -622,21 +624,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2e8 case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: { // Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "%04x: H=A1, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "H=A1, 0x%d->L EQJ/", inst & 0x3); break; } // 2ec case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: { // Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A1, 0x%d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "H-A1, 0x%d->L BOJ/", inst & 0x3); break; } // 2f0 case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: { // Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: H·A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "H·A2, 0x%d->L EQJ/", inst & 0x3); break; } @@ -646,14 +648,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2f8 case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: { // Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "%04x: H=A2, 0x%d->L EQJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "H=A2, 0x%d->L EQJ/", inst & 0x3); break; } // 2fc case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: { // Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A2, 0x%d->L BOJ/", get_table(pc), inst & 0x3); + util::stream_format(stream, "H-A2, 0x%d->L BOJ/", inst & 0x3); break; } @@ -663,7 +665,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 300 case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: { // N->L[2:1] - util::stream_format(stream, "%04x: 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "0x%d->L", inst & 0x3); break; } @@ -673,21 +675,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 308 case 0b001100001000: { // Move A1[7:1] to FLS[7:1], 0->L[2:1] - util::stream_format(stream, "%04x: A1->FLS, 0->L", get_table(pc)); + util::stream_format(stream, "A1->FLS, 0->L"); break; } // 309 case 0b001100001001: { // Move A1[7:1] to FRS[7:1], 1->L[2:1] - util::stream_format(stream, "%04x: A1->FRS, 1->L", get_table(pc)); + util::stream_format(stream, "A1->FRS, 1->L"); break; } // 30a case 0b001100001010: case 0b001100001011: { // Move A1[7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "%04x: A1->MODE, 0x%d->L", get_table(pc), (inst & 0x1) + 2); + util::stream_format(stream, "A1->MODE, 0x%d->L", (inst & 0x1) + 2); break; } @@ -697,7 +699,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 310 case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: { // Move A2[7:1] to A1[7:1], N->L[2:1 - util::stream_format(stream, "%04x: A2->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2->A1, 0x%d->L", inst & 0x3); break; } @@ -707,77 +709,77 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 318 case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: { // Right shift A1[7:1], 0A1[7], N->L[2:1] - util::stream_format(stream, "%04x: A1->RS, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1->RS, 0x%d->L", inst & 0x3); break; } // 31c case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: { // Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A2->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1-A2->A2, 0x%d->L", inst & 0x3); break; } // 320 case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: { // AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1·A1->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1·A1->A1, 0x%d->L", inst & 0x3); break; } // 324 case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: { // Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1+A1->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1+A1->A1, 0x%d->L", inst & 0x3); break; } // 328 case 0b001100101000: case 0b001100101001: case 0b001100101010: case 0b001100101011: { // OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1vA1->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1vA1->A1, 0x%d->L", inst & 0x3); break; } // 32c case 0b001100101100: case 0b001100101101: case 0b001100101110: case 0b001100101111: { // Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A1->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1-A1->A1, 0x%d->L", inst & 0x3); break; } // 330 case 0b001100110000: case 0b001100110001: case 0b001100110010: case 0b001100110011: { // AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1·A2->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1·A2->A1, 0x%d->L", inst & 0x3); break; } // 334 case 0b001100110100: case 0b001100110101: case 0b001100110110: case 0b001100110111: { // Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1+A2->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1+A2->A1, 0x%d->L", inst & 0x3); break; } // 338 case 0b001100111000: case 0b001100111001: case 0b001100111010: case 0b001100111011: { // OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1vA2->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1vA2->A1, 0x%d->L", inst & 0x3); break; } // 33c case 0b001100111100: case 0b001100111101: case 0b001100111110: case 0b001100111111: { // Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A1-A2->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1-A2->A1, 0x%d->L", inst & 0x3); break; } // 340 case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: { // Move A1[7:1] to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1->A2, 0x%d->L", inst & 0x3); break; } @@ -787,28 +789,28 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 348 case 0b001101001000: { // Move A2[7:1] to FLS[7:1], 0->L[2:1] - util::stream_format(stream, "%04x: A2->FLS, 0->L", get_table(pc)); + util::stream_format(stream, "A2->FLS, 0->L"); break; } // 349 case 0b001101001001: { // Move A2[7:1] to FRS[7:1], 1->L[2:1] - util::stream_format(stream, "%04x: A2->FRS, 1->L", get_table(pc)); + util::stream_format(stream, "A2->FRS, 1->L"); break; } // 34a case 0b001101001010: case 0b001101001011: { // Move A2[7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "%04x: A2->MODE, 0x%d->L", get_table(pc), (inst & 0x1) + 2); + util::stream_format(stream, "A2->MODE, 0x%d->L", (inst & 0x1) + 2); break; } // 34c case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: { // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A1->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2-A1->A1, 0x%d->L", inst & 0x3); break; } @@ -818,7 +820,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 358 case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: { // Right shift A2[7:1], 0A2[7], N->L[2:1] - util::stream_format(stream, "%04x: A2->RS, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2->RS, 0x%d->L", inst & 0x3); break; } @@ -828,161 +830,161 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 360 case 0b001101100000: case 0b001101100001: case 0b001101100010: case 0b001101100011: { // AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2·A1->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2·A1->A2, 0x%d->L", inst & 0x3); break; } // 364 case 0b001101100100: case 0b001101100101: case 0b001101100110: case 0b001101100111: { // Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2+A1->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2+A1->A2, 0x%d->L", inst & 0x3); break; } // 368 case 0b001101101000: case 0b001101101001: case 0b001101101010: case 0b001101101011: { // OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2vA1->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2vA1->A2, 0x%d->L", inst & 0x3); break; } // 36c case 0b001101101100: case 0b001101101101: case 0b001101101110: case 0b001101101111: { // Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A1->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2-A1->A2, 0x%d->L", inst & 0x3); break; } // 370 case 0b001101110000: case 0b001101110001: case 0b001101110010: case 0b001101110011: { // AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2·A2->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2·A2->A2, 0x%d->L", inst & 0x3); break; } // 374 case 0b001101110100: case 0b001101110101: case 0b001101110110: case 0b001101110111: { // Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2+A2->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2+A2->A2, 0x%d->L", inst & 0x3); break; } // 378 case 0b001101111000: case 0b001101111001: case 0b001101111010: case 0b001101111011: { // OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2vA2->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2vA2->A2, 0x%d->L", inst & 0x3); break; } // 37c case 0b001101111100: case 0b001101111101: case 0b001101111110: case 0b001101111111: { // Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: A2-A2->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2-A2->A2, 0x%d->L", inst & 0x3); break; } // 380 case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: { // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: A1->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1->M, 0x%d->L", inst & 0x3); break; } // 384 case 0b001110000100: case 0b001110000101: case 0b001110000110: case 0b001110000111: { // Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: M<->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M<->A1, 0x%d->L", inst & 0x3); break; } // 388 case 0b001110001000: { // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] - util::stream_format(stream, "%04x: M->FLS, 0->L", get_table(pc)); + util::stream_format(stream, "M->FLS, 0->L"); break; } // 389 case 0b001110001001: { // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] - util::stream_format(stream, "%04x: M->FRS, 1->L", get_table(pc)); + util::stream_format(stream, "M->FRS, 1->L"); break; } // 38a case 0b001110001010: case 0b001110001011: { // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "%04x: M->MODE, 0x%d->L", get_table(pc), (inst & 0x1) + 2); + util::stream_format(stream, "M->MODE, 0x%d->L", (inst & 0x1) + 2); break; } // 38c case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: { // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] - util::stream_format(stream, "%04x: M->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M->A1, 0x%d->L", inst & 0x3); break; } // 390 case 0b001110010000: case 0b001110010001: case 0b001110010010: case 0b001110010011: { // Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: A2->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2->M, 0x%d->L", inst & 0x3); break; } // 394 case 0b001110010100: case 0b001110010101: case 0b001110010110: case 0b001110010111: { // Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: M<->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M<->A2, 0x%d->L", inst & 0x3); break; } // 398 case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: { // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] - util::stream_format(stream, "%04x: M->RS, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M->RS, 0x%d->L", inst & 0x3); break; } // 39c case 0b001110011100: case 0b001110011101: case 0b001110011110: case 0b001110011111: { // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] - util::stream_format(stream, "%04x: M<->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M<->A2, 0x%d->L", inst & 0x3); break; } // 3a0 case 0b001110100000: case 0b001110100001: case 0b001110100010: case 0b001110100011: { // AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: M·A1->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M·A1->M, 0x%d->L", inst & 0x3); break; } // 3a4 case 0b001110100100: case 0b001110100101: case 0b001110100110: case 0b001110100111: { // Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - util::stream_format(stream, "%04x: M+A1->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M+A1->M, 0x%d->L", inst & 0x3); break; } // 3a8 case 0b001110101000: case 0b001110101001: case 0b001110101010: case 0b001110101011: { // OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: MvA1->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "MvA1->M, 0x%d->L", inst & 0x3); break; } // 3ac case 0b001110101100: case 0b001110101101: case 0b001110101110: case 0b001110101111: { // Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - util::stream_format(stream, "%04x: M-A1->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M-A1->M, 0x%d->L", inst & 0x3); break; } // 3b0 case 0b001110110000: case 0b001110110001: case 0b001110110010: case 0b001110110011: { // AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: M·A2->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M·A2->M, 0x%d->L", inst & 0x3); break; } @@ -990,7 +992,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001110110100: case 0b001110110101: case 0b001110110110: case 0b001110110111: { // Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - util::stream_format(stream, "%04x: M+A2->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M+A2->M, 0x%d->L", inst & 0x3); break; } @@ -998,7 +1000,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001110111000: case 0b001110111001: case 0b001110111010: case 0b001110111011: { // OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "%04x: MvA2->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "MvA2->M, 0x%d->L", inst & 0x3); break; } @@ -1006,14 +1008,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001110111100: case 0b001110111101: case 0b001110111110: case 0b001110111111: { // Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - util::stream_format(stream, "%04x: M-A2->M, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "M-A2->M, 0x%d->L", inst & 0x3); break; } // 3c0 case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: { // Move A1[5:1] to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: A1->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A1->H, 0x%d->L", inst & 0x3); break; } @@ -1022,14 +1024,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 3cc case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: { // Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] - util::stream_format(stream, "%04x: H->A1, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "H->A1, 0x%d->L", inst & 0x3); break; } // 3d0 case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: { // Move A2[5:1] to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: A2->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "A2->H, 0x%d->L", inst & 0x3); break; } @@ -1038,60 +1040,60 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 3dc case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: { // Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] - util::stream_format(stream, "%04x: H->A2, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "H->A2, 0x%d->L", inst & 0x3); break; } // 3e0 case 0b001111100000: case 0b001111100001: case 0b001111100010: case 0b001111100011: { // AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: H·A1->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "H·A1->H, 0x%d->L", inst & 0x3); break; } case 0b001111100100: case 0b001111100101: case 0b001111100110: case 0b001111100111: { // Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: H+A1->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "H+A1->H, 0x%d->L", inst & 0x3); break; } case 0b001111101000: case 0b001111101001: case 0b001111101010: case 0b001111101011: { // OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: HvA1->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "HvA1->H, 0x%d->L", inst & 0x3); break; } case 0b001111101100: case 0b001111101101: case 0b001111101110: case 0b001111101111: { // Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A1->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "H-A1->H, 0x%d->L", inst & 0x3); break; } // 3f0 case 0b001111110000: case 0b001111110001: case 0b001111110010: case 0b001111110011: { // AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: H·A2->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "H·A2->H, 0x%d->L", inst & 0x3); break; } // 3f4 case 0b001111110100: case 0b001111110101: case 0b001111110110: case 0b001111110111: { // Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: H+A2->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "H+A2->H, 0x%d->L", inst & 0x3); break; } // 3f8 case 0b001111111000: case 0b001111111001: case 0b001111111010: case 0b001111111011: { // OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "%04x: HvA2->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "HvA2->H, 0x%d->L", inst & 0x3); break; } // 3fc case 0b001111111100: case 0b001111111101: case 0b001111111110: case 0b001111111111: { // Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "%04x: H-A2->H, 0x%d->L", get_table(pc), inst & 0x3); + util::stream_format(stream, "H-A2->H, 0x%d->L", inst & 0x3); break; } @@ -1100,14 +1102,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 400 case 0b010000000000: case 0b010000000001: { // N->A[11] - util::stream_format(stream, "%04x: %d->A11", get_table(pc), inst & 0x1); + util::stream_format(stream, "%d->A11", inst & 0x1); break; } // 402 case 0b010000000010: case 0b010000000011: { // Jump to (000,M[H[5:1],L[2:1]][5:1],1N),0 L  [2:1], NA[11] - util::stream_format(stream, "%04x: JPM, 0->L, %d->A11", get_table(pc), inst & 0x1); + util::stream_format(stream, "JPM, 0->L, %d->A11", inst & 0x1); break; } @@ -1116,7 +1118,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 440 case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: { // Set D to DISP, G to GPE, K to KIE, S to SME, NA[11] - util::stream_format(stream, "%04x: %d->D, %d->G, %d->K, %d->S, %d->A11", get_table(pc), (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); + util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); break; } @@ -1125,7 +1127,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u default: { - util::stream_format(stream, "%04x: %04x ", get_table(pc), inst); + util::stream_format(stream, "%04x ", inst); break; } } diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index f42d44839c72b..32ee26ff2dda4 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -13,35 +13,17 @@ class upd777_disassembler : public util::disasm_interface // construction/destruction upd777_disassembler(); - // the ROMs are for some reason already in execution order, not address order, so build up a table of addresses - static void populate_addr_table(u16 *table) - { - int count = 0; - for (int upper = 0; upper < 0x800; upper += 0x80) - { - int out = 0; - for (int i = 0; i < 127; i++) // 127 not 128, because last address is just 0 again and doesn't exist - { - int top1 = (out & 0x40) >> 6; - int top2 = (out & 0x20) >> 5; - int nor = (top1 ^ top2) ^ 1; - int full = upper | out; - table[count++] = full; - out = (out << 1) | nor; - out &= 0x7f; - } - } - - } - protected: // disassembler overrides virtual u32 opcode_alignment() const override; + virtual u32 interface_flags() const override { return NONLINEAR_PC; } + virtual offs_t pc_linear_to_real(offs_t pc) const override { return (pc & ~0x7f) | m_l2r[pc & 0x7f]; } + virtual offs_t pc_real_to_linear(offs_t pc) const override { return (pc & ~0x7f) | m_r2l[pc & 0x7f]; } virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms) override; private: - u16 get_table(u16 addr); - u16 m_table[0xfe0/2]; + u8 m_l2r[0x80]; + u8 m_r2l[0x80]; }; #endif // MAME_CPU_UPD777_UPD777DASM_H diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index 1a7ac5b68a007..fba1c90b5a9ad 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -39,8 +39,6 @@ class cassvisn_state : public driver_device private: required_device m_maincpu; required_device m_cart; - - u16 m_table[0xfe0/2]; }; static INPUT_PORTS_START( cassvisn ) @@ -52,41 +50,6 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_LITTLE); m_cart->common_load_rom(m_cart->get_rom_base(), size, "prg"); memcpy(memregion("maincpu")->base(), m_cart->get_rom_base(), size); - - upd777_disassembler::populate_addr_table(m_table); - - if (size == 0xfe0) - { - u8 *ROM = memregion("maincpu")->base(); - - u8 m_newrom[0x1000]; - std::fill(std::begin(m_newrom), std::end(m_newrom), 0xff); - - for (int realadd = 0; realadd < 0x800; realadd++) - { - int found = -1; - for (int checkaddr = 0; checkaddr < 0xfe0/2; checkaddr++) - { - if (m_table[checkaddr] == realadd) - found = checkaddr; - } - - if (found != -1) - { - m_newrom[(realadd * 2) + 1] = ROM[(found * 2) + 0]; - m_newrom[(realadd * 2) + 0] = ROM[(found * 2) + 1]; - } - } - - FILE *fp; - fp=fopen("rearranged_rom.bin", "w+b"); - if (fp) - { - fwrite(m_newrom, 0x1000, 1, fp); - fclose(fp); - } - } - return std::make_pair(std::error_condition(), std::string()); } From f6aaef64efdcf234d3cf2fdd1e8e066fceec6808 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 31 Dec 2023 14:33:39 +0000 Subject: [PATCH 12/62] fix debugger dasm --- src/devices/cpu/upd777/upd777dasm.cpp | 13 +++---------- src/devices/cpu/upd777/upd777dasm.h | 5 +++-- 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index f9708e1430bd4..03229b4f9265c 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -8,25 +8,18 @@ upd777_disassembler::upd777_disassembler() : util::disasm_interface() { // init lfsr pc lut - for (u32 i = 0, pc = 0; i < 0x80; i++) + for (u32 i = 0, pc = 0; i < 0x7f; i++) { m_l2r[i] = pc; m_r2l[pc] = i; - - printf("pc %02x\n", pc); - int top1 = (pc & 0x40) >> 6; int top2 = (pc & 0x20) >> 5; int nor = (top1 ^ top2) ^ 1; pc = (pc << 1) | nor; pc &= 0x7f; - } -} - -u32 upd777_disassembler::opcode_alignment() const -{ - return 1; + m_l2r[0x7f] = 0x7f; + m_r2l[0x7f] = 0x7f; } offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const upd777_disassembler::data_buffer &opcodes, const upd777_disassembler::data_buffer ¶ms) diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 32ee26ff2dda4..6089c3894fe98 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -15,8 +15,9 @@ class upd777_disassembler : public util::disasm_interface protected: // disassembler overrides - virtual u32 opcode_alignment() const override; - virtual u32 interface_flags() const override { return NONLINEAR_PC; } + virtual u32 opcode_alignment() const override { return 1; } + virtual u32 interface_flags() const override { return NONLINEAR_PC | PAGED; } + virtual u32 page_address_bits() const override { return 7; } virtual offs_t pc_linear_to_real(offs_t pc) const override { return (pc & ~0x7f) | m_l2r[pc & 0x7f]; } virtual offs_t pc_real_to_linear(offs_t pc) const override { return (pc & ~0x7f) | m_r2l[pc & 0x7f]; } virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms) override; From 09a60ba81b348ba3d03db9858ec82ae9a37e315e Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 31 Dec 2023 14:45:07 +0000 Subject: [PATCH 13/62] add to unidasm, fix recently introduced error --- src/devices/cpu/upd777/upd777.cpp | 2 +- src/devices/cpu/upd777/upd777dasm.cpp | 4 ++-- src/tools/unidasm.cpp | 2 ++ 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 0f625cdce63b6..ad942ef7b1a22 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -11,7 +11,7 @@ #include "logmacro.h" // device type definitions -DEFINE_DEVICE_TYPE(UPD777, upd777_device, "upd777", "uPD777") +DEFINE_DEVICE_TYPE(UPD777, upd777_device, "upd777", "NEC uPD777") diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 03229b4f9265c..e73301fffde0b 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -83,12 +83,12 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // Store K[7:1] to A4[7:1] util::stream_format(stream, "0x%02x->A4", inst & 0x7f); } - else if (inst < 0xc00) // 800 - bff + else if (inst >= 0x800 && inst < 0xc00) // 800 - bff { // Move K[10:1] to A[10:1], Jump to A[11:1] util::stream_format(stream, "JP 0x%03x", inst & 0x3ff); } - else if (inst < 0x1000) // c00 - fff + else if (inst >= 0xc00 && inst < 0x1000) // c00 - fff { // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack util::stream_format(stream, "JS 0x%03x", inst & 0x3ff); diff --git a/src/tools/unidasm.cpp b/src/tools/unidasm.cpp index d84393be307d5..ae266d42e8946 100644 --- a/src/tools/unidasm.cpp +++ b/src/tools/unidasm.cpp @@ -191,6 +191,7 @@ using util::BIT; #include "cpu/unsp/unspdasm.h" #include "cpu/upd177x/upd177xd.h" #include "cpu/upd7725/dasm7725.h" +#include "cpu/upd777/upd777dasm.h" #include "cpu/upd7810/upd7810_dasm.h" #include "cpu/upd78k/upd78k0d.h" #include "cpu/upd78k/upd78k1d.h" @@ -657,6 +658,7 @@ static const dasm_table_entry dasm_table[] = { "unsp12", be, -1, []() -> util::disasm_interface * { return new unsp_12_disassembler; } }, { "unsp20", be, -1, []() -> util::disasm_interface * { return new unsp_20_disassembler; } }, { "upd177x", be, -1, []() -> util::disasm_interface * { return new upd177x_disassembler; } }, + { "upd777", le, -1, []() -> util::disasm_interface * { return new upd777_disassembler; } }, { "upd7725", be, -2, []() -> util::disasm_interface * { return new necdsp_disassembler; } }, { "upd7801", le, 0, []() -> util::disasm_interface * { return new upd7801_disassembler; } }, { "upd78c05", le, 0, []() -> util::disasm_interface * { return new upd78c05_disassembler; } }, From 01dde5fbfeb8e4e93ef6e8cef2cb6bf47020183c Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 31 Dec 2023 14:49:24 +0000 Subject: [PATCH 14/62] maybe paged is worse --- src/devices/cpu/upd777/upd777dasm.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 6089c3894fe98..622e5b6ba42dd 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -16,8 +16,8 @@ class upd777_disassembler : public util::disasm_interface protected: // disassembler overrides virtual u32 opcode_alignment() const override { return 1; } - virtual u32 interface_flags() const override { return NONLINEAR_PC | PAGED; } - virtual u32 page_address_bits() const override { return 7; } + //virtual u32 interface_flags() const override { return NONLINEAR_PC | PAGED; } + //virtual u32 page_address_bits() const override { return 7; } virtual offs_t pc_linear_to_real(offs_t pc) const override { return (pc & ~0x7f) | m_l2r[pc & 0x7f]; } virtual offs_t pc_real_to_linear(offs_t pc) const override { return (pc & ~0x7f) | m_r2l[pc & 0x7f]; } virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms) override; From 675b72a30612a5c9f2ea5084fc9bb2f0eb804d5a Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 31 Dec 2023 14:51:21 +0000 Subject: [PATCH 15/62] actually no. --- src/devices/cpu/upd777/upd777dasm.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 622e5b6ba42dd..6089c3894fe98 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -16,8 +16,8 @@ class upd777_disassembler : public util::disasm_interface protected: // disassembler overrides virtual u32 opcode_alignment() const override { return 1; } - //virtual u32 interface_flags() const override { return NONLINEAR_PC | PAGED; } - //virtual u32 page_address_bits() const override { return 7; } + virtual u32 interface_flags() const override { return NONLINEAR_PC | PAGED; } + virtual u32 page_address_bits() const override { return 7; } virtual offs_t pc_linear_to_real(offs_t pc) const override { return (pc & ~0x7f) | m_l2r[pc & 0x7f]; } virtual offs_t pc_real_to_linear(offs_t pc) const override { return (pc & ~0x7f) | m_r2l[pc & 0x7f]; } virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer ¶ms) override; From f55c666d755ce7b12c0985b696431c679509d13c Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 31 Dec 2023 15:00:11 +0000 Subject: [PATCH 16/62] show the mame 'page' format in Jump disassembly (not the official format, which seems to flow from 0x7f to 0x80, not 0:7f to 1:00 but probably the best we can do? --- src/devices/cpu/upd777/upd777dasm.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index e73301fffde0b..cff1c4383aace 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -86,12 +86,12 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u else if (inst >= 0x800 && inst < 0xc00) // 800 - bff { // Move K[10:1] to A[10:1], Jump to A[11:1] - util::stream_format(stream, "JP 0x%03x", inst & 0x3ff); + util::stream_format(stream, "JP A11 | 0x%03x (%01x:%02x)", inst & 0x3ff, (inst & 0x380)>>7, inst & 0x07f); } else if (inst >= 0xc00 && inst < 0x1000) // c00 - fff { // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack - util::stream_format(stream, "JS 0x%03x", inst & 0x3ff); + util::stream_format(stream, "JS 0x%03x (%01x:%02x)", inst & 0x3ff, (inst & 0x380)>>7, inst & 0x07f); } else { From 607e24e2fa4999d25e3b5476d17cecea36ea76bc Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 31 Dec 2023 15:37:49 +0000 Subject: [PATCH 17/62] add a basic gfx decode --- src/mame/epoch/cassvisn.cpp | 51 ++++++++++++++++++++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-) diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index fba1c90b5a9ad..bbc336e38ffcb 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -17,6 +17,8 @@ the linked 'design note' contains a large amount of useful information #include "cpu/upd777/upd777.h" #include "cpu/upd777/upd777dasm.h" +#include "emupal.h" +#include "screen.h" #include "softlist_dev.h" @@ -28,7 +30,9 @@ class cassvisn_state : public driver_device cassvisn_state(const machine_config &mconfig, device_type type, const char *tag) : driver_device(mconfig, type, tag), m_maincpu(*this, "maincpu"), - m_cart(*this, "cartslot") + m_cart(*this, "cartslot"), + m_gfxdecode(*this, "gfxdecode"), + m_palette(*this, "palette") { } void cassvisn(machine_config &config); @@ -37,10 +41,40 @@ class cassvisn_state : public driver_device protected: DECLARE_DEVICE_IMAGE_LOAD_MEMBER(cart_load); private: + uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); + required_device m_maincpu; required_device m_cart; + required_device m_gfxdecode; + required_device m_palette; +}; + +uint32_t cassvisn_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) +{ + return 0; +} + + +// documentation says patterns 0x00 - 0x6e are 7x7 +// and patterns 0x70 - 0x7e are 8x7 +// but they all seem to be stored at 11x7, just with some columns blank? +static const gfx_layout test_layout = +{ + 11,7, + 0x80, + 8, + { 0 }, + { 0,1,2,3,4,5,6,7,8,9,10 }, + { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, + 7*11 }; + +static GFXDECODE_START( gfx_cassvisn ) + GFXDECODE_ENTRY( "patterns", 0, test_layout, 0, 1 ) +GFXDECODE_END + + static INPUT_PORTS_START( cassvisn ) INPUT_PORTS_END @@ -50,6 +84,9 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_LITTLE); m_cart->common_load_rom(m_cart->get_rom_base(), size, "prg"); memcpy(memregion("maincpu")->base(), m_cart->get_rom_base(), size); + + size = m_cart->common_get_size("pat"); + m_cart->common_load_rom(memregion("patterns")->base(), size, "pat"); return std::make_pair(std::error_condition(), std::string()); } @@ -62,11 +99,23 @@ void cassvisn_state::cassvisn(machine_config &config) m_cart->set_device_load(FUNC(cassvisn_state::cart_load)); m_cart->set_must_be_loaded(true); + screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER)); + screen.set_refresh_hz(60); + screen.set_vblank_time(ATTOSECONDS_IN_USEC(0)); + screen.set_size(256, 256); + screen.set_visarea(0, 256-1, 16, 256-16-1); + screen.set_screen_update(FUNC(cassvisn_state::screen_update)); + screen.set_palette(m_palette); + + GFXDECODE(config, m_gfxdecode, m_palette, gfx_cassvisn); + PALETTE(config, m_palette).set_entries(0x1000); + SOFTWARE_LIST(config, "cart_list").set_original("cassvisn_cart"); } ROM_START( cassvisn ) ROM_REGION( 0x1000, "maincpu", ROMREGION_ERASEFF ) + ROM_REGION( 0x4d0, "patterns", ROMREGION_ERASEFF ) ROM_END void cassvisn_state::init_cass() From 54389b49b2b13b21c592b6e7ebb21e43db816356 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 31 Dec 2023 16:32:20 +0000 Subject: [PATCH 18/62] feedback --- hash/cassvisn_cart.xml | 44 +++++++++++++++---------------- src/devices/cpu/upd777/upd777.cpp | 1 - 2 files changed, 22 insertions(+), 23 deletions(-) diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index 00b9672bb0c4f..3f9ff9eb63d39 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -31,10 +31,10 @@ The following games exist for this platform Epoch - + - + @@ -45,10 +45,10 @@ The following games exist for this platform Epoch - + - + @@ -60,10 +60,10 @@ The following games exist for this platform Epoch - + - + @@ -74,10 +74,10 @@ The following games exist for this platform Epoch - + - + @@ -89,10 +89,10 @@ The following games exist for this platform Epoch - + - + @@ -103,10 +103,10 @@ The following games exist for this platform Epoch - + - + @@ -117,10 +117,10 @@ The following games exist for this platform Epoch - + - + @@ -131,10 +131,10 @@ The following games exist for this platform Epoch - + - + @@ -145,10 +145,10 @@ The following games exist for this platform Epoch - + - + @@ -159,10 +159,10 @@ The following games exist for this platform Epoch - + - + @@ -173,10 +173,10 @@ The following games exist for this platform Epoch - + - + diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index ad942ef7b1a22..0dc794189f956 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -61,7 +61,6 @@ void upd777_device::device_start() state_add(STATE_GENPCBASE, "CURPC", m_pc).noshow(); save_item(NAME(m_pc)); - save_item(NAME(m_icount)); } void upd777_device::device_reset() From 1da7ed6fc7c164b116c9d3e34c40f4c52da446b2 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Mon, 1 Jan 2024 23:43:37 +0000 Subject: [PATCH 19/62] I'm fairly sure if you change A11 with the xx->A11 opcodes then you instantly change the execution address to be the upper/lower half of the ROM, so the jump instruction that uses A11 is always going to be within the current half. --- src/devices/cpu/upd777/upd777dasm.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index cff1c4383aace..fb10f29b06bfc 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -86,7 +86,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u else if (inst >= 0x800 && inst < 0xc00) // 800 - bff { // Move K[10:1] to A[10:1], Jump to A[11:1] - util::stream_format(stream, "JP A11 | 0x%03x (%01x:%02x)", inst & 0x3ff, (inst & 0x380)>>7, inst & 0x07f); + u16 fulladdress = (pc & 0x400) | (inst & 0x3ff); + util::stream_format(stream, "JP 0x%03x (%01x:%02x)", fulladdress, (fulladdress & 0x780)>>7, inst & 0x07f); } else if (inst >= 0xc00 && inst < 0x1000) // c00 - fff { From b6c2076161fe692ce70d1d89b013ed434a1e07c3 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 00:10:59 +0000 Subject: [PATCH 20/62] code reduction --- src/devices/cpu/upd777/upd777dasm.cpp | 392 ++++++++++---------------- 1 file changed, 143 insertions(+), 249 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index fb10f29b06bfc..9ace27164b017 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -271,385 +271,279 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 200 case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: + case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: { // Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "A1·A1, 0x%d->L EQJ", inst & 0x3); + // Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "A1·A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 204 - //case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: - // 208 + // 204, 224 + // case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: + // case 0b001000100100: case 0b001000100101: case 0b001000100110: case 0b001000100111: + + // 208, 228 case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: + case 0b001000101000: case 0b001000101001: case 0b001000101010: case 0b001000101011: { // Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "A1=A1, 0x%d->L EQJ", inst & 0x3); + // Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) + u8 non = inst & 0x20; + util::stream_format(stream, "A1=A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 20c - case 0b001000001100: case 0b001000001101: case 0b001000001110:case 0b001000001111: + // 20c, 22c + case 0b001000001100: case 0b001000001101: case 0b001000001110: case 0b001000001111: + case 0b001000101100: case 0b001000101101: case 0b001000101110: case 0b001000101111: { // Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "A1-A1, 0x%d->L BOJ", inst & 0x3); + // Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "A1-A1, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); break; } - // 210 + // 210, 230 case 0b001000010000: case 0b001000010001: case 0b001000010010: case 0b001000010011: + case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: + { // Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "A1·A2, 0x%d->L", inst & 0x3); + // Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "A1·A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 214 + // 214, 234 // case 0b001000010100: case 0b001000010101: case 0b001000010110: case 0b001000010111: + // case 0b001000110100: case 0b001000110101: case 0b001000110110: case 0b001000110111: - // 218 + // 218, 238 case 0b001000011000: case 0b001000011001: case 0b001000011010: case 0b001000011011: + case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: { // Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "A1=A2, 0x%d->L EQJ", inst & 0x3); + // Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) + u8 non = inst & 0x20; + util::stream_format(stream, "A1=A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 21c + // 21c, 23c case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: - { // Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "A1-A2, 0x%d->L BOJ", inst & 0x3); - break; - } - - // 220 - case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: - { // Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "A1·A1, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 224 - // case 0b001000100100: case 0b001000100101: case 0b001000100110: case 0b001000100111: - - // 228 - case 0b001000101000: case 0b001000101001: case 0b001000101010:case 0b001000101011: - { // Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "A1=A1, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 22c - case 0b001000101100: case 0b001000101101: case 0b001000101110: case 0b001000101111: - { // Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "A1-A1, 0x%d->L BOJ/", inst & 0x3); - break; - } - - // 230 - case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: - { // Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "A1·A2, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 234 - //case 0b001000110100: case 0b001000110101: case 0b001000110110: case 0b001000110111: - - // 238 - case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: - { // Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - util::stream_format(stream, "A1=A2, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 23c case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: - { // Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "A1-A2, 0x%d->L BOJ/", inst & 0x3); + { // Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "A1-A2, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); break; } - // 240 + // 240, 260 case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: + case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: { // Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "A2·A1, 0x%d->L EQJ", inst & 0x3); + // Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "A2·A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 244 + + // 244, 264 //case 0b001001000100: case 0b001001000101: case 0b001001000110: case 0b001001000111: + //case 0b001001100100: case 0b001001100101: case 0b001001100110: case 0b001001100111: - // 248 + // 248, 268 case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: + case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: { // Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "A2=A1, 0x%d->L EQJ", inst & 0x3); + // Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) + u8 non = inst & 0x20; + util::stream_format(stream, "A2=A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 24c + // 24c, 26c case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: + case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: { // Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "A2-A1, 0x%d->L BOJ", inst & 0x3); + // Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "A2-A1, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); break; } - // 250 + // 250, 270 case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: + case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: { // Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "A2·A2, 0x%d->L EQJ", inst & 0x3); + // Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "A2·A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 254 + // 254, 274 //case 0b001001010100: case 0b001001010101: case 0b001001010110: case 0b001001010111: + //case 0b001001110100: case 0b001001110101: case 0b001001110110: case 0b001001110111: - // 258 + // 258, 278 case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: + case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: { // Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "A2=A2, 0x%d->L EQJ", inst & 0x3); + // Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) + u8 non = inst & 0x20; + util::stream_format(stream, "A2=A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 25c + // 25c, 27c case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: - { // Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "A2-A2, 0x%d->L BOJ", inst & 0x3); - break; - } - - // 260 - case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: - { // Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "A2·A1, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 264 - //case 0b001001100100: case 0b001001100101: case 0b001001100110: case 0b001001100111: - - // 268 - case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: - { // Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "A2=A1, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 26c - case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: - { // Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "A2-A1, 0x%d->L BOJ/", inst & 0x3); - break; - } - - // 270 - case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: - { // Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "A2·A2, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 274 - //case 0b001001110100: case 0b001001110101: case 0b001001110110: case 0b001001110111: - - // 278 - case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: - { // Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "A2=A2, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 27c case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: - { // Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "A2-A2, 0x%d->L BOJ/", inst & 0x3); + { // Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "A2-A2, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); break; } - // 280 + // 280, 2a0 case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: + case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "M·A1, 0x%d->L EQJ", inst & 0x3); + // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "M·A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 284 + // 284, 2a4 //case 0b001010000100: case 0b001010000101: case 0b001010000110: case 0b001010000111: + //case 0b001010100100: case 0b001010100101: case 0b001010100110: case 0b001010100111: - // 288 + // 288, 2a8 case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: + case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "M=A1, 0x%d->L EQJ", inst & 0x3); + // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) + u8 non = inst & 0x20; + util::stream_format(stream, "M=A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 28c + // 28c, 2ac case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: + case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "M-A1, 0x%d->L BOJ", inst & 0x3); + // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "M-A1, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); break; } - // 290 + // 290, 2b0 case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: + case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] - util::stream_format(stream, "M·A2, 0x%d->L EQJ", inst & 0x3); + // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "M·A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 294 + // 294, 2b4 //case 0b001010010100: case 0b001010010101: case 0b001010010110: case 0b001010010111: + //case 0b001010110100: case 0b001010110101: case 0b001010110110: case 0b001010110111: - // 298 + // 298, 2b8 case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: + case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "M=A2, 0x%d->L EQJ", inst & 0x3); - break; - } - - // 29c - case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "M-A2, 0x%d->L BOJ", inst & 0x3); - break; - } - - // 2a0 - case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: - { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "M·A1, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 2a4 - //case 0b001010100100: case 0b001010100101: case 0b001010100110: case 0b001010100111: - - // 2a8 - case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "M=A1, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 2ac - case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "M-A1, 0x%d->L BOJ/", inst & 0x3); - break; - } - - // 2b0 - case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: - { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "M·A2, 0x%d->L EQJ/", inst & 0x3); + // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) + u8 non = inst & 0x20; + util::stream_format(stream, "M=A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 2b4 - //case 0b001010110100: case 0b001010110101: case 0b001010110110: case 0b001010110111: - // 2b8 - case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "M=A2, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 2bc + // 29c, 2bc + case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "M-A2, 0x%d->L BOJ/", inst & 0x3); + { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] + // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "M-A2, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); break; } - // 2c0 + // 2c0, 2e0 case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: + case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: { // Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] - util::stream_format(stream, "H·A1, 0x%d->L EQJ", inst & 0x3); + // Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "H·A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 2c4 + // 2c4, 2e4 //case 0b001011000100: case 0b001011000101: case 0b001011000110: case 0b001011000111: + //case 0b001011100100: case 0b001011100101: case 0b001011100110: case 0b001011100111: - // 2c8 + // 2c8, 2e8 case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: + case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: { // Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "H=A1, 0x%d->L EQJ", inst & 0x3); + // Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) + u8 non = inst & 0x20; + util::stream_format(stream, "H=A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 2cc + // 2cc, 2ec case 0b001011001100: case 0b001011001101: case 0b001011001110: case 0b001011001111: + case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: { // Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "H-A1, N%(d)->L BOJ", inst & 0x3); + // Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "H-A1, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); break; } - // 2d0 + // 2d0, 2f0 case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: + case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: { // Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] - util::stream_format(stream, "H·A2, 0x%d->L EQJ", inst & 0x3); + // Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "H·A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 2d4 + + // 2d4, 2f4 //case 0b001011010100: case 0b001011010101: case 0b001011010110: case 0b001011010111: + //case 0b001011110100: case 0b001011110101: case 0b001011110110: case 0b001011110111: - // 2d8 + // 2d8, 2f8 case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: + case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: { // Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) - util::stream_format(stream, "H=A2, 0x%d->L EQJ", inst & 0x3); - break; - } - - // 2dc - case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: - { // Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] - util::stream_format(stream, "H-A2, 0x%d->L BOJ", inst & 0x3); - break; - } - - // 2e0 - case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: - { // Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "H·A1, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 2e4 - //case 0b001011100100: case 0b001011100101: case 0b001011100110: case 0b001011100111: - - // 2e8 - case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: - { // Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) - util::stream_format(stream, "H=A1, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 2ec - case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: - { // Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "H-A1, 0x%d->L BOJ/", inst & 0x3); - break; - } - - // 2f0 - case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: - { // Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "H·A2, 0x%d->L EQJ/", inst & 0x3); + // Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] (typo?) + u8 non = inst & 0x20; + util::stream_format(stream, "H=A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); break; } - // 2f4 - //case 0b001011110100: case 0b001011110101: case 0b001011110110: case 0b001011110111: - // 2f8 - case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: - { // Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] - util::stream_format(stream, "H=A2, 0x%d->L EQJ/", inst & 0x3); - break; - } - - // 2fc + // 2dc, 2fc + case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: - { // Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] - util::stream_format(stream, "H-A2, 0x%d->L BOJ/", inst & 0x3); + { // Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] + // Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] + u8 non = inst & 0x20; + util::stream_format(stream, "H-A2, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); break; } From fc3ac4df6ef2e21602672bb85e403990b257095a Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 00:35:46 +0000 Subject: [PATCH 21/62] code reduction --- src/devices/cpu/upd777/upd777dasm.cpp | 330 +++++++++++--------------- src/devices/cpu/upd777/upd777dasm.h | 2 + 2 files changed, 134 insertions(+), 198 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 9ace27164b017..4fa4618a56735 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -269,284 +269,218 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// - // 200 + // 200, 220, 208, 228, 20c, 22c case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: - { // Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] - // Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] - u8 non = inst & 0x20; - util::stream_format(stream, "A1·A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - - // 204, 224 - // case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: - // case 0b001000100100: case 0b001000100101: case 0b001000100110: case 0b001000100111: - - // 208, 228 case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: case 0b001000101000: case 0b001000101001: case 0b001000101010: case 0b001000101011: - { // Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - // Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - u8 non = inst & 0x20; - util::stream_format(stream, "A1=A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 20c, 22c case 0b001000001100: case 0b001000001101: case 0b001000001110: case 0b001000001111: case 0b001000101100: case 0b001000101101: case 0b001000101110: case 0b001000101111: - { // Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + { + // optype · + // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // optype = + // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) + // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) + // optype - + // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; - util::stream_format(stream, "A1-A1, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); + u8 optype = (inst & 0x0c) >> 2; + util::stream_format(stream, "A1%sA1, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); break; } - // 210, 230 + // 210, 230, 218, 238, 21c, 23c case 0b001000010000: case 0b001000010001: case 0b001000010010: case 0b001000010011: case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: - - { // Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] - // Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - u8 non = inst & 0x20; - util::stream_format(stream, "A1·A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 214, 234 - // case 0b001000010100: case 0b001000010101: case 0b001000010110: case 0b001000010111: - // case 0b001000110100: case 0b001000110101: case 0b001000110110: case 0b001000110111: - - // 218, 238 case 0b001000011000: case 0b001000011001: case 0b001000011010: case 0b001000011011: case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: - { // Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - // Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - u8 non = inst & 0x20; - util::stream_format(stream, "A1=A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 21c, 23c case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: - { // Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + { + // optype · + // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // optype = + // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) + // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) + // optype - + // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; - util::stream_format(stream, "A1-A2, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); + u8 optype = (inst & 0x0c) >> 2; + util::stream_format(stream, "A1%sA2, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); break; } - // 240, 260 + // 240, 260, 248, 268, 24c, 26c case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: - { // Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] - // Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] - u8 non = inst & 0x20; - util::stream_format(stream, "A2·A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - - // 244, 264 - //case 0b001001000100: case 0b001001000101: case 0b001001000110: case 0b001001000111: - //case 0b001001100100: case 0b001001100101: case 0b001001100110: case 0b001001100111: - - // 248, 268 case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: - { // Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - // Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - u8 non = inst & 0x20; - util::stream_format(stream, "A2=A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 24c, 26c case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: - { // Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + { + // optype · + // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // optype = + // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) + // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; - util::stream_format(stream, "A2-A1, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); + u8 optype = (inst & 0x0c) >> 2; + util::stream_format(stream, "A2%sA1, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); break; } - // 250, 270 + // 250, 270, 258, 278, 25c, 27c case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: - { // Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] - // Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] - u8 non = inst & 0x20; - util::stream_format(stream, "A2·A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 254, 274 - //case 0b001001010100: case 0b001001010101: case 0b001001010110: case 0b001001010111: - //case 0b001001110100: case 0b001001110101: case 0b001001110110: case 0b001001110111: - - // 258, 278 case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: - { // Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - // Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - u8 non = inst & 0x20; - util::stream_format(stream, "A2=A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 25c, 27c case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: - { // Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + { + // optype · + // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // optype = + // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) + // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; - util::stream_format(stream, "A2-A2, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); + u8 optype = (inst & 0x0c) >> 2; + util::stream_format(stream, "A2%sA2, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); break; } - // 280, 2a0 + // 280, 2a0, 288, 2a8, 28c, 2ac case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: - { // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] - // Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] - u8 non = inst & 0x20; - util::stream_format(stream, "M·A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 284, 2a4 - //case 0b001010000100: case 0b001010000101: case 0b001010000110: case 0b001010000111: - //case 0b001010100100: case 0b001010100101: case 0b001010100110: case 0b001010100111: - - // 288, 2a8 case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - u8 non = inst & 0x20; - util::stream_format(stream, "M=A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 28c, 2ac case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] - // Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] + { + // optype · + // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] + // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] + // optype = + // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) + // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; - util::stream_format(stream, "M-A1, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); + u8 optype = (inst & 0x0c) >> 2; + util::stream_format(stream, "M%sA1, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); break; } - // 290, 2b0 + // 290, 2b0, 298, 2b8, 29c, 2bc case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: - { // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] - // Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] - u8 non = inst & 0x20; - util::stream_format(stream, "M·A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 294, 2b4 - //case 0b001010010100: case 0b001010010101: case 0b001010010110: case 0b001010010111: - //case 0b001010110100: case 0b001010110101: case 0b001010110110: case 0b001010110111: - - // 298, 2b8 case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - u8 non = inst & 0x20; - util::stream_format(stream, "M=A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - - // 29c, 2bc case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: - { // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] - // Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] + { + // optype · + // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] + // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] + // optype = + // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) + // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; - util::stream_format(stream, "M-A2, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); + u8 optype = (inst & 0x0c) >> 2; + util::stream_format(stream, "M%sA2, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); break; } - // 2c0, 2e0 + // 2c0, 2e0, 2c8, 2e8, 2cc, 2ec case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: - { // Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] - // Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] - u8 non = inst & 0x20; - util::stream_format(stream, "H·A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 2c4, 2e4 - //case 0b001011000100: case 0b001011000101: case 0b001011000110: case 0b001011000111: - //case 0b001011100100: case 0b001011100101: case 0b001011100110: case 0b001011100111: - - // 2c8, 2e8 case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: - { // Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) - // Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) - u8 non = inst & 0x20; - util::stream_format(stream, "H=A1, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - // 2cc, 2ec case 0b001011001100: case 0b001011001101: case 0b001011001110: case 0b001011001111: case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: - { // Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] - // Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] + { + // optype · + // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] + // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] + // optype = + // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) + // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] + // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; - util::stream_format(stream, "H-A1, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); + u8 optype = (inst & 0x0c) >> 2; + util::stream_format(stream, "H%sA1, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); break; } - // 2d0, 2f0 + // 2d0, 2f0, 2d8, 2f8, 2dc, 2fc case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: - { // Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] - // Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] - u8 non = inst & 0x20; - util::stream_format(stream, "H·A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - - // 2d4, 2f4 - //case 0b001011010100: case 0b001011010101: case 0b001011010110: case 0b001011010111: - //case 0b001011110100: case 0b001011110101: case 0b001011110110: case 0b001011110111: - - // 2d8, 2f8 case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: - { // Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) - // Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] (typo?) - u8 non = inst & 0x20; - util::stream_format(stream, "H=A2, 0x%d->L EQJ%s", inst & 0x3, non ? "/" : ""); - break; - } - - - // 2dc, 2fc case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: - { // Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] - // Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] + { + // optype · + // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] + // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] + // optype = + // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) + // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] + // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; - util::stream_format(stream, "H-A2, 0x%d->L BOJ%s", inst & 0x3, non ? "/" : ""); + u8 optype = (inst & 0x0c) >> 2; + util::stream_format(stream, "H%sA2, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); break; } + + // these would be 'invalid' optype + // 204, 224 + // case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: + // case 0b001000100100: case 0b001000100101: case 0b001000100110: case 0b001000100111: + // 214, 234 + // case 0b001000010100: case 0b001000010101: case 0b001000010110: case 0b001000010111: + // case 0b001000110100: case 0b001000110101: case 0b001000110110: case 0b001000110111: + // 244, 264 + // case 0b001001000100: case 0b001001000101: case 0b001001000110: case 0b001001000111: + // case 0b001001100100: case 0b001001100101: case 0b001001100110: case 0b001001100111: + // 254, 274 + // case 0b001001010100: case 0b001001010101: case 0b001001010110: case 0b001001010111: + // case 0b001001110100: case 0b001001110101: case 0b001001110110: case 0b001001110111: + // 284, 2a4 + // case 0b001010000100: case 0b001010000101: case 0b001010000110: case 0b001010000111: + // case 0b001010100100: case 0b001010100101: case 0b001010100110: case 0b001010100111: + // 294, 2b4 + // case 0b001010010100: case 0b001010010101: case 0b001010010110: case 0b001010010111: + // case 0b001010110100: case 0b001010110101: case 0b001010110110: case 0b001010110111: + // 2c4, 2e4 + // case 0b001011000100: case 0b001011000101: case 0b001011000110: case 0b001011000111: + // case 0b001011100100: case 0b001011100101: case 0b001011100110: case 0b001011100111: + // 2d4, 2f4 + // case 0b001011010100: case 0b001011010101: case 0b001011010110: case 0b001011010111: + // case 0b001011110100: case 0b001011110101: case 0b001011110110: case 0b001011110111: + + ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 6089c3894fe98..0fbf9ce31959b 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -25,6 +25,8 @@ class upd777_disassembler : public util::disasm_interface private: u8 m_l2r[0x80]; u8 m_r2l[0x80]; + + std::string m_200_optypes[4] = {"·", "invalid", "=", "-"}; }; #endif // MAME_CPU_UPD777_UPD777DASM_H From 23ca8bd891f41052f4cdecc2c7b2e63867275dec Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 00:44:46 +0000 Subject: [PATCH 22/62] code reduction --- src/devices/cpu/upd777/upd777dasm.cpp | 102 ++++++++++---------------- src/devices/cpu/upd777/upd777dasm.h | 1 + 2 files changed, 38 insertions(+), 65 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 4fa4618a56735..3ab0ab058ce69 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -269,13 +269,19 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// - // 200, 220, 208, 228, 20c, 22c + // 200, 220, 208, 228, 20c, 22c, 210, 230, 218, 238, 21c, 23c case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: case 0b001000101000: case 0b001000101001: case 0b001000101010: case 0b001000101011: case 0b001000001100: case 0b001000001101: case 0b001000001110: case 0b001000001111: case 0b001000101100: case 0b001000101101: case 0b001000101110: case 0b001000101111: + case 0b001000010000: case 0b001000010001: case 0b001000010010: case 0b001000010011: + case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: + case 0b001000011000: case 0b001000011001: case 0b001000011010: case 0b001000011011: + case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: + case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: + case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: { // optype · // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] @@ -286,20 +292,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // optype - // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - u8 non = inst & 0x20; - u8 optype = (inst & 0x0c) >> 2; - util::stream_format(stream, "A1%sA1, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); - break; - } - - // 210, 230, 218, 238, 21c, 23c - case 0b001000010000: case 0b001000010001: case 0b001000010010: case 0b001000010011: - case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: - case 0b001000011000: case 0b001000011001: case 0b001000011010: case 0b001000011011: - case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: - case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: - case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: - { // optype · // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] @@ -311,17 +303,24 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; u8 optype = (inst & 0x0c) >> 2; - util::stream_format(stream, "A1%sA2, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); + u8 reg2 = (inst & 0x10) >> 4; + util::stream_format(stream, "A1%s%s, 0x%d->L %s%s", m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); break; } - // 240, 260, 248, 268, 24c, 26c + // 240, 260, 248, 268, 24c, 26c, 250, 270, 258, 278, 25c, 27c case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: + case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: + case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: + case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: + case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: + case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: + case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: { // optype · // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] @@ -332,20 +331,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // optype - // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - u8 non = inst & 0x20; - u8 optype = (inst & 0x0c) >> 2; - util::stream_format(stream, "A2%sA1, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); - break; - } - - // 250, 270, 258, 278, 25c, 27c - case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: - case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: - case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: - case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: - case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: - case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: - { // optype · // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] @@ -357,17 +342,25 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; u8 optype = (inst & 0x0c) >> 2; - util::stream_format(stream, "A2%sA2, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); + u8 reg2 = (inst & 0x10) >> 4; + util::stream_format(stream, "A2%s%s, 0x%d->L %s%s", m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); break; } - // 280, 2a0, 288, 2a8, 28c, 2ac + + // 280, 2a0, 288, 2a8, 28c, 2ac, 290, 2b0, 298, 2b8, 29c, 2bc case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: + case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: + case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: + case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: + case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: + case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: + case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: { // optype · // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] @@ -378,20 +371,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // optype - // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] - u8 non = inst & 0x20; - u8 optype = (inst & 0x0c) >> 2; - util::stream_format(stream, "M%sA1, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); - break; - } - - // 290, 2b0, 298, 2b8, 29c, 2bc - case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: - case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: - case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: - case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: - case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: - case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: - { // optype · // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] @@ -403,17 +382,24 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; u8 optype = (inst & 0x0c) >> 2; - util::stream_format(stream, "M%sA2, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); + u8 reg2 = (inst & 0x10) >> 4; + util::stream_format(stream, "M%s%s, 0x%d->L %s%s", m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); break; } - // 2c0, 2e0, 2c8, 2e8, 2cc, 2ec + // 2c0, 2e0, 2c8, 2e8, 2cc, 2ec, 2d0, 2f0, 2d8, 2f8, 2dc, 2fc case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: case 0b001011001100: case 0b001011001101: case 0b001011001110: case 0b001011001111: case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: + case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: + case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: + case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: + case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: + case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: + case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: { // optype · // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] @@ -424,20 +410,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // optype - // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] - u8 non = inst & 0x20; - u8 optype = (inst & 0x0c) >> 2; - util::stream_format(stream, "H%sA1, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); - break; - } - - // 2d0, 2f0, 2d8, 2f8, 2dc, 2fc - case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: - case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: - case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: - case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: - case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: - case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: - { // optype · // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] @@ -449,11 +421,11 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; u8 optype = (inst & 0x0c) >> 2; - util::stream_format(stream, "H%sA2, 0x%d->L EQJ%s", m_200_optypes[optype], inst & 0x3, non ? "/" : ""); + u8 reg2 = (inst & 0x10) >> 4; + util::stream_format(stream, "H%s%s, 0x%d->L %s%s", m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); break; } - // these would be 'invalid' optype // 204, 224 // case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 0fbf9ce31959b..2d3f171aa3c1a 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -27,6 +27,7 @@ class upd777_disassembler : public util::disasm_interface u8 m_r2l[0x80]; std::string m_200_optypes[4] = {"·", "invalid", "=", "-"}; + std::string m_200_reg2[2] = {"A1", "A2" }; }; #endif // MAME_CPU_UPD777_UPD777DASM_H From f9b444882cade2c759fb84979b9b7731a88953d0 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 00:50:45 +0000 Subject: [PATCH 23/62] further code reduction --- src/devices/cpu/upd777/upd777dasm.cpp | 115 +++++++++----------------- src/devices/cpu/upd777/upd777dasm.h | 1 + 2 files changed, 41 insertions(+), 75 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 3ab0ab058ce69..59d840e85e14e 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -269,7 +269,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// - // 200, 220, 208, 228, 20c, 22c, 210, 230, 218, 238, 21c, 23c + // 200, 220, 208, 228, 20c, 22c, 210, 230, 218, 238, 21c, 23c, 240, 260, 248, 268, 24c, 26c, 250, 270, 258, 278, 25c, 27c, 280, 2a0, 288, 2a8, 28c, 2ac, 290, 2b0, 298, 2b8, 29c, 2bc, 2c0, 2e0, 2c8, 2e8, 2cc, 2ec, 2d0, 2f0, 2d8, 2f8, 2dc, 2fc case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: @@ -282,6 +282,42 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: + case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: + case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: + case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: + case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: + case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: + case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: + case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: + case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: + case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: + case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: + case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: + case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: + case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: + case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: + case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: + case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: + case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: + case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: + case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: + case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: + case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: + case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: + case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: + case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: + case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: + case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: + case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: + case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: + case 0b001011001100: case 0b001011001101: case 0b001011001110: case 0b001011001111: + case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: + case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: + case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: + case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: + case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: + case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: + case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: { // optype · // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] @@ -301,27 +337,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // optype - // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - u8 non = inst & 0x20; - u8 optype = (inst & 0x0c) >> 2; - u8 reg2 = (inst & 0x10) >> 4; - util::stream_format(stream, "A1%s%s, 0x%d->L %s%s", m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); - break; - } - - // 240, 260, 248, 268, 24c, 26c, 250, 270, 258, 278, 25c, 27c - case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: - case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: - case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: - case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: - case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: - case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: - case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: - case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: - case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: - case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: - case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: - case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: - { // optype · // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] @@ -340,28 +355,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // optype - // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - u8 non = inst & 0x20; - u8 optype = (inst & 0x0c) >> 2; - u8 reg2 = (inst & 0x10) >> 4; - util::stream_format(stream, "A2%s%s, 0x%d->L %s%s", m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); - break; - } - - - // 280, 2a0, 288, 2a8, 28c, 2ac, 290, 2b0, 298, 2b8, 29c, 2bc - case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: - case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: - case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: - case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: - case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: - case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: - case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: - case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: - case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: - case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: - case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: - case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: - { // optype · // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] @@ -380,27 +373,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // optype - // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] - u8 non = inst & 0x20; - u8 optype = (inst & 0x0c) >> 2; - u8 reg2 = (inst & 0x10) >> 4; - util::stream_format(stream, "M%s%s, 0x%d->L %s%s", m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); - break; - } - - // 2c0, 2e0, 2c8, 2e8, 2cc, 2ec, 2d0, 2f0, 2d8, 2f8, 2dc, 2fc - case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: - case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: - case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: - case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: - case 0b001011001100: case 0b001011001101: case 0b001011001110: case 0b001011001111: - case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: - case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: - case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: - case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: - case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: - case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: - case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: - { // optype · // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] @@ -421,38 +393,31 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; u8 optype = (inst & 0x0c) >> 2; + u8 reg1 = (inst & 0xc0) >> 6; u8 reg2 = (inst & 0x10) >> 4; - util::stream_format(stream, "H%s%s, 0x%d->L %s%s", m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); + util::stream_format(stream, "%s%s%s, 0x%d->L %s%s", m_200_reg1[reg1], m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); break; } // these would be 'invalid' optype - // 204, 224 + // 204, 224, 214, 234, 244, 264, 254, 274, 284, 2a4, 294, 2b4, 2c4, 2e4, 2d4, 2f4 // case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: // case 0b001000100100: case 0b001000100101: case 0b001000100110: case 0b001000100111: - // 214, 234 // case 0b001000010100: case 0b001000010101: case 0b001000010110: case 0b001000010111: // case 0b001000110100: case 0b001000110101: case 0b001000110110: case 0b001000110111: - // 244, 264 // case 0b001001000100: case 0b001001000101: case 0b001001000110: case 0b001001000111: // case 0b001001100100: case 0b001001100101: case 0b001001100110: case 0b001001100111: - // 254, 274 // case 0b001001010100: case 0b001001010101: case 0b001001010110: case 0b001001010111: // case 0b001001110100: case 0b001001110101: case 0b001001110110: case 0b001001110111: - // 284, 2a4 // case 0b001010000100: case 0b001010000101: case 0b001010000110: case 0b001010000111: // case 0b001010100100: case 0b001010100101: case 0b001010100110: case 0b001010100111: - // 294, 2b4 // case 0b001010010100: case 0b001010010101: case 0b001010010110: case 0b001010010111: // case 0b001010110100: case 0b001010110101: case 0b001010110110: case 0b001010110111: - // 2c4, 2e4 // case 0b001011000100: case 0b001011000101: case 0b001011000110: case 0b001011000111: // case 0b001011100100: case 0b001011100101: case 0b001011100110: case 0b001011100111: - // 2d4, 2f4 // case 0b001011010100: case 0b001011010101: case 0b001011010110: case 0b001011010111: // case 0b001011110100: case 0b001011110101: case 0b001011110110: case 0b001011110111: - ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 2d3f171aa3c1a..04b635507c37d 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -28,6 +28,7 @@ class upd777_disassembler : public util::disasm_interface std::string m_200_optypes[4] = {"·", "invalid", "=", "-"}; std::string m_200_reg2[2] = {"A1", "A2" }; + std::string m_200_reg1[4] = {"A1", "A2", "M", "H" }; }; #endif // MAME_CPU_UPD777_UPD777DASM_H From bfb508c987ec868719799c9faad5b40aeea10268 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 10:48:39 +0000 Subject: [PATCH 24/62] remove final page from PRG ROMs as it doesn't exist physically --- hash/cassvisn_cart.xml | 53 ++++++++++++++++++++++++------------------ 1 file changed, 31 insertions(+), 22 deletions(-) diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index 3f9ff9eb63d39..b437a2de59d36 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -23,6 +23,15 @@ The following games exist for this platform --> + + @@ -30,8 +39,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -44,8 +53,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -59,8 +68,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -73,8 +82,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -88,8 +97,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -102,8 +111,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -116,8 +125,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -130,8 +139,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -144,8 +153,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -158,8 +167,8 @@ The following games exist for this platform 1981 Epoch - - + + @@ -172,8 +181,8 @@ The following games exist for this platform 1981 Epoch - - + + From 46663e8fbc38cc1bce808dd0decf1cb4201cda5a Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 11:56:56 +0000 Subject: [PATCH 25/62] code reduction --- src/devices/cpu/upd777/upd777dasm.cpp | 84 +++++++++------------------ 1 file changed, 28 insertions(+), 56 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 59d840e85e14e..ce5ce5eef0e91 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -146,37 +146,41 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000000101010: case 0b000000101011: case 0b000000101100: case 0b000000101101: case 0b000000101110: case 0b000000101111: + // 030, 034, 038, 03c, 070, 074, 078, 07c case 0b000000110000: - { // Skip if (PD1 input) = 1 - util::stream_format(stream, "PD1 J"); - break; - } - - // case 0b000000110001: case 0b000000110010: case 0b000000110011: - case 0b000000110100: - { // Skip if (PD2 input) = 1 - util::stream_format(stream, "PD2 J"); - break; - } - - //case 0b000000110101: case 0b000000110110: case 0b000000110111: - case 0b000000111000: - { // Skip if (PD3 input) = 1 - util::stream_format(stream, "PD3 J"); - break; - } - - //case 0b000000111001: case 0b000000111010: case 0b000000111011: - case 0b000000111100: - { // Skip if (PD4 input) = 1 - util::stream_format(stream, "PD4 J"); + case 0b000001110000: + case 0b000001110100: + case 0b000001111000: + case 0b000001111100: + { // 30 Skip if (PD1 input) = 1 + // 34 Skip if (PD2 input) = 1 + // 38 Skip if (PD3 input) = 1 + // 3c Skip if (PD4 input) = 1 + // 70 Skip if (PD1 input) = 0 + // 74 Skip if (PD2 input) = 0 + // 78 Skip if (PD3 input) = 0 + // 7c Skip if (PD4 input) = 0 + int which = (inst & 0x00c) >> 2; + int inv = inst & 0x40; + util::stream_format(stream, "PD%d %sJ", which + 1, inv ? "/" : ""); break; } - //case 0b000000111101: case 0b000000111110: case 0b000000111111: case 0b000001000000: case 0b000001000001: case 0b000001000010: case 0b000001000011: case 0b000001000100: case 0b000001000101: case 0b000001000110: case 0b000001000111: case 0b000001001000: + // unused instructions after the PDx J and PDx /J opcodes + // case 0b000000110001: case 0b000000110010: case 0b000000110011: + // case 0b000000110101: case 0b000000110110: case 0b000000110111: + // case 0b000000111001: case 0b000000111010: case 0b000000111011: + // case 0b000000111101: case 0b000000111110: case 0b000000111111: + // + // case 0b000001110001: case 0b000001110010: case 0b000001110011: + // case 0b000001110101: case 0b000001110110: case 0b000001110111: + // case 0b000001111001: case 0b000001111010: case 0b000001111011: + // case 0b000001111101: case 0b000001111110: case 0b000001111111: + + // case 0b000001000000: case 0b000001000001: case 0b000001000010: case 0b000001000011: case 0b000001000100: case 0b000001000101: case 0b000001000110: case 0b000001000111: case 0b000001001000: case 0b000001001001: { // Skip if (4H Horizontal Blank) = 1 @@ -233,38 +237,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001100001: case 0b000001100010: case 0b000001100011: case 0b000001100100: case 0b000001100101: case 0b000001100110: case 0b000001100111: case 0b000001101000: case 0b000001101001: case 0b000001101010: case 0b000001101011: case 0b000001101100: case 0b000001101101: case 0b000001101110: case 0b000001101111: - case 0b000001110000: - { // Skip if (PD1 input) = 0 - util::stream_format(stream, "PD1 /J", inst); - break; - } - - // case 0b000001110001: case 0b000001110010: case 0b000001110011: - - case 0b000001110100: - { // Skip if (PD2 input) = 0 - util::stream_format(stream, "PD2 /J", inst); - break; - } - - // case 0b000001110101: case 0b000001110110: case 0b000001110111: - - case 0b000001111000: - { // Skip if (PD3 input) = 0 - util::stream_format(stream, "PD3 /J", inst); - break; - } - - // case 0b000001111001: case 0b000001111010: case 0b000001111011: - - case 0b000001111100: - { // Skip if (PD4 input) = 0 - util::stream_format(stream, "PD4 /J", inst); - break; - } - - // case 0b000001111101: case 0b000001111110: case 0b000001111111: - ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// From 4711521d43778c0821e7823535a186beb63b241d Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 12:18:32 +0000 Subject: [PATCH 26/62] code reduction --- src/devices/cpu/upd777/upd777dasm.cpp | 135 +++++++------------------- src/devices/cpu/upd777/upd777dasm.h | 4 + 2 files changed, 40 insertions(+), 99 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index ce5ce5eef0e91..05379204413c6 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -182,12 +182,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001000000: case 0b000001000001: case 0b000001000010: case 0b000001000011: case 0b000001000100: case 0b000001000101: case 0b000001000110: case 0b000001000111: case 0b000001001000: + // 049 case 0b000001001001: { // Skip if (4H Horizontal Blank) = 1 util::stream_format(stream, "4H BLK"); break; } + // 04a case 0b000001001010: { // Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] @@ -197,6 +199,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u //case 0b000001001011: + // 04c case 0b000001001100: { // Skip if (GP&SW/ input) = 1 util::stream_format(stream, "GPSW/"); @@ -451,59 +454,47 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // 320 - case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: - { // AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "A1·A1->A1, 0x%d->L", inst & 0x3); - break; - } + ///////////////////////////////////////////////////// + ///////////////////////////////////////////////////// - // 324 - case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: - { // Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "A1+A1->A1, 0x%d->L", inst & 0x3); - break; - } - // 328 + // 320, 324, 328, 32c, 330, 334, 338, 33c, 360, 364, 368, 36c, 370, 374, 378, 37c + case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: + case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: case 0b001100101000: case 0b001100101001: case 0b001100101010: case 0b001100101011: - { // OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "A1vA1->A1, 0x%d->L", inst & 0x3); - break; - } - - // 32c case 0b001100101100: case 0b001100101101: case 0b001100101110: case 0b001100101111: - { // Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "A1-A1->A1, 0x%d->L", inst & 0x3); - break; - } - - // 330 case 0b001100110000: case 0b001100110001: case 0b001100110010: case 0b001100110011: - { // AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "A1·A2->A1, 0x%d->L", inst & 0x3); - break; - } - - // 334 case 0b001100110100: case 0b001100110101: case 0b001100110110: case 0b001100110111: - { // Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "A1+A2->A1, 0x%d->L", inst & 0x3); - break; - } - - // 338 case 0b001100111000: case 0b001100111001: case 0b001100111010: case 0b001100111011: - { // OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - util::stream_format(stream, "A1vA2->A1, 0x%d->L", inst & 0x3); - break; - } - - // 33c case 0b001100111100: case 0b001100111101: case 0b001100111110: case 0b001100111111: - { // Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "A1-A2->A1, 0x%d->L", inst & 0x3); + case 0b001101100000: case 0b001101100001: case 0b001101100010: case 0b001101100011: + case 0b001101100100: case 0b001101100101: case 0b001101100110: case 0b001101100111: + case 0b001101101000: case 0b001101101001: case 0b001101101010: case 0b001101101011: + case 0b001101101100: case 0b001101101101: case 0b001101101110: case 0b001101101111: + case 0b001101110000: case 0b001101110001: case 0b001101110010: case 0b001101110011: + case 0b001101110100: case 0b001101110101: case 0b001101110110: case 0b001101110111: + case 0b001101111000: case 0b001101111001: case 0b001101111010: case 0b001101111011: + case 0b001101111100: case 0b001101111101: case 0b001101111110: case 0b001101111111: + { // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 32c Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 330 AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 334 Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 338 OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 33c Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 360 AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 364 Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 368 OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 36c Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + // 370 AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + int type = (inst & 0x0c)>>2; + int reg2 = (inst & 0x10)>>4; + int reg1 = (inst & 0x40)>>6; + util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", m_320_reg[reg1], m_320_optypes[type], m_320_reg[reg2], m_320_reg[reg1], inst & 0x3, (type == 3) ? "BOJ" : ""); break; } @@ -558,61 +549,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 35c // case 0b001101011100: case 0b001101011101: case 0b001101011110: case 0b001101011111: - // 360 - case 0b001101100000: case 0b001101100001: case 0b001101100010: case 0b001101100011: - { // AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "A2·A1->A2, 0x%d->L", inst & 0x3); - break; - } - - // 364 - case 0b001101100100: case 0b001101100101: case 0b001101100110: case 0b001101100111: - { // Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "A2+A1->A2, 0x%d->L", inst & 0x3); - break; - } - - // 368 - case 0b001101101000: case 0b001101101001: case 0b001101101010: case 0b001101101011: - { // OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "A2vA1->A2, 0x%d->L", inst & 0x3); - break; - } - - // 36c - case 0b001101101100: case 0b001101101101: case 0b001101101110: case 0b001101101111: - { // Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "A2-A1->A2, 0x%d->L", inst & 0x3); - break; - } - // 370 - case 0b001101110000: case 0b001101110001: case 0b001101110010: case 0b001101110011: - { // AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "A2·A2->A2, 0x%d->L", inst & 0x3); - break; - } - - // 374 - case 0b001101110100: case 0b001101110101: case 0b001101110110: case 0b001101110111: - { // Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "A2+A2->A2, 0x%d->L", inst & 0x3); - break; - } - - // 378 - case 0b001101111000: case 0b001101111001: case 0b001101111010: case 0b001101111011: - { // OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - util::stream_format(stream, "A2vA2->A2, 0x%d->L", inst & 0x3); - break; - } - - // 37c - case 0b001101111100: case 0b001101111101: case 0b001101111110: case 0b001101111111: - { // Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "A2-A2->A2, 0x%d->L", inst & 0x3); - break; - } // 380 case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 04b635507c37d..5aaa7e1bcd9ed 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -29,6 +29,10 @@ class upd777_disassembler : public util::disasm_interface std::string m_200_optypes[4] = {"·", "invalid", "=", "-"}; std::string m_200_reg2[2] = {"A1", "A2" }; std::string m_200_reg1[4] = {"A1", "A2", "M", "H" }; + + std::string m_320_optypes[4] = {"·", "+", "v", "-"}; + std::string m_320_reg[2] = {"A1", "A2" }; + }; #endif // MAME_CPU_UPD777_UPD777DASM_H From 9a55eec5a53ccdb3ead7c62b71dda7b8b04218de Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 12:44:13 +0000 Subject: [PATCH 27/62] code reduction --- src/devices/cpu/upd777/upd777dasm.cpp | 255 +++++++++++--------------- 1 file changed, 112 insertions(+), 143 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 05379204413c6..f24da1dbf27c8 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -396,6 +396,25 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// + // unused + // 304 + // case 0b001100000100: case 0b001100000101: case 0b001100000110: case 0b001100000111: + // 344 + // case 0b001101000100: case 0b001101000101: case 0b001101000110: case 0b001101000111: + // 30c + //case 0b001100001100: case 0b001100001101: case 0b001100001110: case 0b001100001111: + // 314 + //case 0b001100010100: case 0b001100010101: case 0b001100010110: case 0b001100010111: + // 350 + // case 0b001101010000: case 0b001101010001: case 0b001101010010: case 0b001101010011: + // case 0b001101010100: case 0b001101010101: case 0b001101010110: case 0b001101010111: + // 35c + // case 0b001101011100: case 0b001101011101: case 0b001101011110: case 0b001101011111: + // case 0b001111000100: case 0b001111000101: case 0b001111000110: case 0b001111000111: + // case 0b001111001000: case 0b001111001001: case 0b001111001010: case 0b001111001011: + // case 0b001111010100: case 0b001111010101: case 0b001111010110: case 0b001111010111: + // case 0b001111011000: case 0b001111011001: case 0b001111011010: case 0b001111011011: + // 300 case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: { // N->L[2:1] @@ -403,15 +422,30 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // 304 - //case 0b001100000100: case 0b001100000101: case 0b001100000110: case 0b001100000111: - + ////////////////////////////////////////// + ////////////////////////////////////////// + // 308 case 0b001100001000: { // Move A1[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A1->FLS, 0->L"); break; } + // 348 + case 0b001101001000: + { // Move A2[7:1] to FLS[7:1], 0->L[2:1] + util::stream_format(stream, "A2->FLS, 0->L"); + break; + } + // 388 + case 0b001110001000: + { // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] + util::stream_format(stream, "M->FLS, 0->L"); + break; + } + + ////////////////////////////////////////// + ////////////////////////////////////////// // 309 case 0b001100001001: @@ -419,6 +453,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "A1->FRS, 1->L"); break; } + // 349 + case 0b001101001001: + { // Move A2[7:1] to FRS[7:1], 1->L[2:1] + util::stream_format(stream, "A2->FRS, 1->L"); + break; + } + // 389 + case 0b001110001001: + { // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] + util::stream_format(stream, "M->FRS, 1->L"); + break; + } + + ////////////////////////////////////////// + ////////////////////////////////////////// // 30a case 0b001100001010: case 0b001100001011: @@ -426,19 +475,37 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "A1->MODE, 0x%d->L", (inst & 0x1) + 2); break; } + // 34a + case 0b001101001010: case 0b001101001011: + { // Move A2[7:1] to MODE[7:1], 1N->L[2:1] + util::stream_format(stream, "A2->MODE, 0x%d->L", (inst & 0x1) + 2); + break; + } + // 38a + case 0b001110001010: case 0b001110001011: + { // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] + util::stream_format(stream, "M->MODE, 0x%d->L", (inst & 0x1) + 2); + break; + } - // 30c - //case 0b001100001100: case 0b001100001101: case 0b001100001110: case 0b001100001111: - + ////////////////////////////////////////// + ////////////////////////////////////////// + // 310 case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: - { // Move A2[7:1] to A1[7:1], N->L[2:1 + { // Move A2[7:1] to A1[7:1], N->L[2:1] util::stream_format(stream, "A2->A1, 0x%d->L", inst & 0x3); break; } + // 340 + case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: + { // Move A1[7:1] to A2[7:1], N->L[2:1] + util::stream_format(stream, "A1->A2, 0x%d->L", inst & 0x3); + break; + } - // 314 - //case 0b001100010100: case 0b001100010101: case 0b001100010110: case 0b001100010111: + ////////////////////////////////////////// + ////////////////////////////////////////// // 318 case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: @@ -446,6 +513,18 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "A1->RS, 0x%d->L", inst & 0x3); break; } + // 358 + case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: + { // Right shift A2[7:1], 0A2[7], N->L[2:1] + util::stream_format(stream, "A2->RS, 0x%d->L", inst & 0x3); + break; + } + // 398 + case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: + { // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] + util::stream_format(stream, "M->RS, 0x%d->L", inst & 0x3); + break; + } // 31c case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: @@ -453,11 +532,16 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "A1-A2->A2, 0x%d->L", inst & 0x3); break; } + // 34c + case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: + { // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + util::stream_format(stream, "A2-A1->A1, 0x%d->L", inst & 0x3); + break; + } ///////////////////////////////////////////////////// ///////////////////////////////////////////////////// - // 320, 324, 328, 32c, 330, 334, 338, 33c, 360, 364, 368, 36c, 370, 374, 378, 37c case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: @@ -498,59 +582,9 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // 340 - case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: - { // Move A1[7:1] to A2[7:1], N->L[2:1] - util::stream_format(stream, "A1->A2, 0x%d->L", inst & 0x3); - break; - } - - // 344 - // case 0b001101000100: case 0b001101000101: case 0b001101000110: case 0b001101000111: - - // 348 - case 0b001101001000: - { // Move A2[7:1] to FLS[7:1], 0->L[2:1] - util::stream_format(stream, "A2->FLS, 0->L"); - break; - } - - // 349 - case 0b001101001001: - { // Move A2[7:1] to FRS[7:1], 1->L[2:1] - util::stream_format(stream, "A2->FRS, 1->L"); - break; - } - - // 34a - case 0b001101001010: case 0b001101001011: - { // Move A2[7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "A2->MODE, 0x%d->L", (inst & 0x1) + 2); - break; - } - - // 34c - case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: - { // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "A2-A1->A1, 0x%d->L", inst & 0x3); - break; - } - - // 350 - // case 0b001101010000: case 0b001101010001: case 0b001101010010: case 0b001101010011: case 0b001101010100: case 0b001101010101: case 0b001101010110: case 0b001101010111: - - // 358 - case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: - { // Right shift A2[7:1], 0A2[7], N->L[2:1] - util::stream_format(stream, "A2->RS, 0x%d->L", inst & 0x3); - break; - } - - // 35c - // case 0b001101011100: case 0b001101011101: case 0b001101011110: case 0b001101011111: - - - + ////////////////////////////////////////// + ////////////////////////////////////////// + // 380 case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: { // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] @@ -565,27 +599,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // 388 - case 0b001110001000: - { // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] - util::stream_format(stream, "M->FLS, 0->L"); - break; - } - - // 389 - case 0b001110001001: - { // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] - util::stream_format(stream, "M->FRS, 1->L"); - break; - } - - // 38a - case 0b001110001010: case 0b001110001011: - { // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "M->MODE, 0x%d->L", (inst & 0x1) + 2); - break; - } - // 38c case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: { // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] @@ -607,13 +620,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // 398 - case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: - { // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] - util::stream_format(stream, "M->RS, 0x%d->L", inst & 0x3); - break; - } - // 39c case 0b001110011100: case 0b001110011101: case 0b001110011110: case 0b001110011111: { // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] @@ -621,62 +627,29 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // 3a0 + ////////////////////////////////////////// + ////////////////////////////////////////// + + // 3a0, 3a4, 3a8, 3ac, 3b0, 3b4, 3b8, 3bc case 0b001110100000: case 0b001110100001: case 0b001110100010: case 0b001110100011: - { // AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "M·A1->M, 0x%d->L", inst & 0x3); - break; - } - - // 3a4 case 0b001110100100: case 0b001110100101: case 0b001110100110: case 0b001110100111: - { // Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - util::stream_format(stream, "M+A1->M, 0x%d->L", inst & 0x3); - break; - } - - // 3a8 case 0b001110101000: case 0b001110101001: case 0b001110101010: case 0b001110101011: - { // OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "MvA1->M, 0x%d->L", inst & 0x3); - break; - } - - // 3ac case 0b001110101100: case 0b001110101101: case 0b001110101110: case 0b001110101111: - { // Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - util::stream_format(stream, "M-A1->M, 0x%d->L", inst & 0x3); - break; - } - - // 3b0 case 0b001110110000: case 0b001110110001: case 0b001110110010: case 0b001110110011: - { // AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "M·A2->M, 0x%d->L", inst & 0x3); - break; - } - - // 3b4 case 0b001110110100: case 0b001110110101: case 0b001110110110: case 0b001110110111: - { // Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - - util::stream_format(stream, "M+A2->M, 0x%d->L", inst & 0x3); - break; - } - - // 3b8 case 0b001110111000: case 0b001110111001: case 0b001110111010: case 0b001110111011: - { // OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - - util::stream_format(stream, "MvA2->M, 0x%d->L", inst & 0x3); - break; - } - - // 3bc case 0b001110111100: case 0b001110111101: case 0b001110111110: case 0b001110111111: - { // Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - - util::stream_format(stream, "M-A2->M, 0x%d->L", inst & 0x3); + { // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3ac Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + // 3b0 AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + int optype = (inst & 0x0c)>>2; + int reg2 = (inst & 0x10)>>4; + util::stream_format(stream, "M%s%s->M, 0x%d->L", m_320_optypes[optype], m_320_reg[reg2], inst & 0x3); break; } @@ -687,8 +660,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - //case 0b001111000100: case 0b001111000101: case 0b001111000110: case 0b001111000111: //case 0b001111001000: case 0b001111001001: case 0b001111001010: case 0b001111001011: - // 3cc case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: { // Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] @@ -703,8 +674,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - //case 0b001111010100: case 0b001111010101: case 0b001111010110: case 0b001111010111: case 0b001111011000: case 0b001111011001: case 0b001111011010: case 0b001111011011: - // 3dc case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: { // Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] From ca4a9bd51b012a3d77e4ebd4b8b3463a4174bfe8 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 13:28:38 +0000 Subject: [PATCH 28/62] code reduction and cleanup --- src/devices/cpu/upd777/upd777dasm.cpp | 473 ++++++++++++-------------- 1 file changed, 219 insertions(+), 254 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index f24da1dbf27c8..f50b5a2a01995 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -40,7 +40,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { // M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] util::stream_format(stream, "M-0x%02x->M, 0x%d->L", inst & 0x1f, (inst >> 5) & 0x3); - } + } else if (inst >= 0x480 && inst <= 0x4bf) // 480 - 4bf { // H[5:1]-K[5:1]->H[5:1], Skip if borrow @@ -63,25 +63,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] util::stream_format(stream, "0x%02x->L,H", inst & 0x7f); } - else if (inst >= 0x600 && inst <= 0x67f) // 600 - 67f - { - // Store K[7:1] to A1[7:1] - util::stream_format(stream, "0x%02x->A1", inst & 0x7f); - } - else if (inst >= 0x680 && inst <= 0x6ff) // 680 - 6ff - { - // Store K[7:1] to A2[7:1] - util::stream_format(stream, "0x%02x->A2", inst & 0x7f); - } - else if (inst >= 0x700 && inst <= 0x77f) // 680 - 6ff - { - // Store K[7:1] to A3[7:1] - util::stream_format(stream, "0x%02x->A3", inst & 0x7f); - } - else if (inst >= 0x780 && inst <= 0x7ff) // 780 - 7ff + else if (inst >= 0x600 && inst <= 0x7ff) // 600 - 7ff { - // Store K[7:1] to A4[7:1] - util::stream_format(stream, "0x%02x->A4", inst & 0x7f); + // 600-67f Store K[7:1] to A1[7:1] + // 680-6ff Store K[7:1] to A2[7:1] + // 700-77f Store K[7:1] to A3[7:1] + // 780-7ff Store K[7:1] to A4[7:1] + int reg = (inst & 0x180) >> 7; + util::stream_format(stream, "0x%02x->A%d", inst & 0x7f, reg+1); } else if (inst >= 0x800 && inst < 0xc00) // 800 - bff { @@ -99,7 +88,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u switch (inst) { case 0b000000000000: - { // No Operation + { // No Operation util::stream_format(stream, "NOP"); break; } @@ -107,7 +96,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000000000001: case 0b000000000010: case 0b000000000011: case 0b000000000100: - { // Skip if (Gun Port Latch) = 1 + { // Skip if (Gun Port Latch) = 1 util::stream_format(stream, "GPL"); break; } @@ -115,15 +104,15 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u //case 0b000000000101: case 0b000000000110: case 0b000000000111: case 0b000000001000: - { // Move H[5:1] to Line Buffer Register[5:1] + { // Move H[5:1] to Line Buffer Register[5:1] util::stream_format(stream, "H->NRM"); break; } //case 0b000000001001: case 0b000000001010: case 0b000000001011: case 0b000000001100: case 0b000000001101: case 0b000000001110: case 0b000000001111: case 0b000000010000: case 0b000000010001: case 0b000000010010: case 0b000000010011: case 0b000000010100: case 0b000000010101: case 0b000000010110: case 0b000000010111: - + case 0b000000011000: - { // H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] + { // H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] util::stream_format(stream, "H<->X"); break; } @@ -131,7 +120,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000000011001: case 0b000000011010: case 0b000000011011: case 0b000000011100: case 0b000000011101: case 0b000000011110: case 0b000000011111: case 0b000000100000: - { // Subroutine End, Pop down address stack + { // Subroutine End, Pop down address stack util::stream_format(stream, "SRE"); break; } @@ -139,7 +128,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000000100001: case 0b000000100010: case 0b000000100011: case 0b000000100100: case 0b000000100101: case 0b000000100110: case 0b000000100111: case 0b000000101000: case 0b000000101001: - { // Shift STB[4:1], N->STB[1] + { // Shift STB[4:1], N->STB[1] util::stream_format(stream, "0x%d->STB", inst & 1); break; } @@ -155,14 +144,15 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001110100: case 0b000001111000: case 0b000001111100: - { // 30 Skip if (PD1 input) = 1 - // 34 Skip if (PD2 input) = 1 - // 38 Skip if (PD3 input) = 1 - // 3c Skip if (PD4 input) = 1 - // 70 Skip if (PD1 input) = 0 - // 74 Skip if (PD2 input) = 0 - // 78 Skip if (PD3 input) = 0 - // 7c Skip if (PD4 input) = 0 + { + // 30 Skip if (PD1 input) = 1 + // 34 Skip if (PD2 input) = 1 + // 38 Skip if (PD3 input) = 1 + // 3c Skip if (PD4 input) = 1 + // 70 Skip if (PD1 input) = 0 + // 74 Skip if (PD2 input) = 0 + // 78 Skip if (PD3 input) = 0 + // 7c Skip if (PD4 input) = 0 int which = (inst & 0x00c) >> 2; int inv = inst & 0x40; util::stream_format(stream, "PD%d %sJ", which + 1, inv ? "/" : ""); @@ -174,7 +164,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000000110101: case 0b000000110110: case 0b000000110111: // case 0b000000111001: case 0b000000111010: case 0b000000111011: // case 0b000000111101: case 0b000000111110: case 0b000000111111: - // + // // case 0b000001110001: case 0b000001110010: case 0b000001110011: // case 0b000001110101: case 0b000001110110: case 0b000001110111: // case 0b000001111001: case 0b000001111010: case 0b000001111011: @@ -184,24 +174,24 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 049 case 0b000001001001: - { // Skip if (4H Horizontal Blank) = 1 + { // Skip if (4H Horizontal Blank) = 1 util::stream_format(stream, "4H BLK"); break; } // 04a case 0b000001001010: - { // Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] + { // Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] util::stream_format(stream, "VBLK"); break; } - //case 0b000001001011: + // case 0b000001001011: // 04c case 0b000001001100: - { // Skip if (GP&SW/ input) = 1 + { // Skip if (GP&SW/ input) = 1 util::stream_format(stream, "GPSW/"); break; } @@ -209,7 +199,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001001101: case 0b000001001110: case 0b000001001111: case 0b000001010000: case 0b000001010001: case 0b000001010010: case 0b000001010011: case 0b000001010100: - { // Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] + { // Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] util::stream_format(stream, "A->MA"); break; } @@ -217,7 +207,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001010101: case 0b000001010110: case 0b000001010111: case 0b000001011000: - { // Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) + { // Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) util::stream_format(stream, "MA->A"); break; } @@ -225,7 +215,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001011001: case 0b000001011010: case 0b000001011011: case 0b000001011100: - { // Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] + { // Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] util::stream_format(stream, "MA<->A"); break; } @@ -233,7 +223,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001011101: case 0b000001011110: case 0b000001011111: case 0b000001100000: - { // Subroutine End, Pop down address stack, Skip + { // Subroutine End, Pop down address stack, Skip util::stream_format(stream, "SRE+1"); break; } @@ -294,78 +284,78 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: { - // optype · - // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] - // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] - // optype = - // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - // optype - - // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // optype · - // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] - // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // optype = - // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - // optype - - // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // optype · - // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] - // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] - // optype = - // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // optype · - // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] - // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // optype = - // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // optype · - // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] - // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] - // optype = - // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // optype · - // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] - // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] - // optype = - // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // optype · - // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] - // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] - // optype = - // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) - // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] - // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] - // optype · - // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] - // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] - // optype = - // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) - // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] - // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] + // optype · + // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // optype = + // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) + // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) + // optype - + // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // optype · + // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // optype = + // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) + // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) + // optype - + // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // optype · + // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // optype = + // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) + // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // optype · + // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // optype = + // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) + // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // optype · + // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] + // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] + // optype = + // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) + // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // optype · + // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] + // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] + // optype = + // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) + // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // optype · + // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] + // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] + // optype = + // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) + // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] + // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] + // optype · + // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] + // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] + // optype = + // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) + // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] (typo?) + // optype - + // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] + // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] u8 non = inst & 0x20; u8 optype = (inst & 0x0c) >> 2; u8 reg1 = (inst & 0xc0) >> 6; @@ -417,51 +407,51 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 300 case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: - { // N->L[2:1] + { // N->L[2:1] util::stream_format(stream, "0x%d->L", inst & 0x3); break; } ////////////////////////////////////////// ////////////////////////////////////////// - + // 308 case 0b001100001000: - { // Move A1[7:1] to FLS[7:1], 0->L[2:1] + { // Move A1[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A1->FLS, 0->L"); break; } // 348 case 0b001101001000: - { // Move A2[7:1] to FLS[7:1], 0->L[2:1] + { // Move A2[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A2->FLS, 0->L"); break; } // 388 case 0b001110001000: - { // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] + { // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "M->FLS, 0->L"); break; } ////////////////////////////////////////// - ////////////////////////////////////////// + ////////////////////////////////////////// // 309 case 0b001100001001: - { // Move A1[7:1] to FRS[7:1], 1->L[2:1] + { // Move A1[7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "A1->FRS, 1->L"); break; } // 349 case 0b001101001001: - { // Move A2[7:1] to FRS[7:1], 1->L[2:1] + { // Move A2[7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "A2->FRS, 1->L"); break; } // 389 case 0b001110001001: - { // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] + { // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "M->FRS, 1->L"); break; } @@ -471,35 +461,35 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 30a case 0b001100001010: case 0b001100001011: - { // Move A1[7:1] to MODE[7:1], 1N->L[2:1] + { // Move A1[7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "A1->MODE, 0x%d->L", (inst & 0x1) + 2); break; } // 34a case 0b001101001010: case 0b001101001011: - { // Move A2[7:1] to MODE[7:1], 1N->L[2:1] + { // Move A2[7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "A2->MODE, 0x%d->L", (inst & 0x1) + 2); break; } // 38a case 0b001110001010: case 0b001110001011: - { // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] + { // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "M->MODE, 0x%d->L", (inst & 0x1) + 2); break; } ////////////////////////////////////////// ////////////////////////////////////////// - + // 310 case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: - { // Move A2[7:1] to A1[7:1], N->L[2:1] + { // Move A2[7:1] to A1[7:1], N->L[2:1] util::stream_format(stream, "A2->A1, 0x%d->L", inst & 0x3); break; } // 340 case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: - { // Move A1[7:1] to A2[7:1], N->L[2:1] + { // Move A1[7:1] to A2[7:1], N->L[2:1] util::stream_format(stream, "A1->A2, 0x%d->L", inst & 0x3); break; } @@ -509,32 +499,32 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 318 case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: - { // Right shift A1[7:1], 0A1[7], N->L[2:1] + { // Right shift A1[7:1], 0A1[7], N->L[2:1] util::stream_format(stream, "A1->RS, 0x%d->L", inst & 0x3); break; } // 358 case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: - { // Right shift A2[7:1], 0A2[7], N->L[2:1] + { // Right shift A2[7:1], 0A2[7], N->L[2:1] util::stream_format(stream, "A2->RS, 0x%d->L", inst & 0x3); break; } // 398 case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: - { // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] + { // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] util::stream_format(stream, "M->RS, 0x%d->L", inst & 0x3); break; } // 31c case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: - { // Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + { // Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] util::stream_format(stream, "A1-A2->A2, 0x%d->L", inst & 0x3); break; } // 34c case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: - { // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + { // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] util::stream_format(stream, "A2-A1->A1, 0x%d->L", inst & 0x3); break; } @@ -559,77 +549,76 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001101110100: case 0b001101110101: case 0b001101110110: case 0b001101110111: case 0b001101111000: case 0b001101111001: case 0b001101111010: case 0b001101111011: case 0b001101111100: case 0b001101111101: case 0b001101111110: case 0b001101111111: - { // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 32c Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - // 330 AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 334 Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 338 OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 33c Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - // 360 AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 364 Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 368 OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 36c Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - // 370 AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - int type = (inst & 0x0c)>>2; - int reg2 = (inst & 0x10)>>4; - int reg1 = (inst & 0x40)>>6; - util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", m_320_reg[reg1], m_320_optypes[type], m_320_reg[reg2], m_320_reg[reg1], inst & 0x3, (type == 3) ? "BOJ" : ""); + { + // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 32c Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 330 AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 334 Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 338 OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 33c Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 360 AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 364 Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 368 OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 36c Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + // 370 AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + int optype = (inst & 0x0c) >> 2; + int reg2 = (inst & 0x10) >> 4; + int reg1 = (inst & 0x40) >> 6; + util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", m_320_reg[reg1], m_320_optypes[optype], m_320_reg[reg2], m_320_reg[reg1], inst & 0x3, (optype == 3) ? "BOJ" : ""); break; } ////////////////////////////////////////// ////////////////////////////////////////// - + // 380 case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: - { // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + { // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] util::stream_format(stream, "A1->M, 0x%d->L", inst & 0x3); break; } - - // 384 - case 0b001110000100: case 0b001110000101: case 0b001110000110: case 0b001110000111: - { // Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] - util::stream_format(stream, "M<->A1, 0x%d->L", inst & 0x3); - break; - } - - // 38c - case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: - { // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] - util::stream_format(stream, "M->A1, 0x%d->L", inst & 0x3); - break; - } - // 390 case 0b001110010000: case 0b001110010001: case 0b001110010010: case 0b001110010011: - { // Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + { // Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] util::stream_format(stream, "A2->M, 0x%d->L", inst & 0x3); break; } + // 384 + case 0b001110000100: case 0b001110000101: case 0b001110000110: case 0b001110000111: + { // Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] + util::stream_format(stream, "M<->A1, 0x%d->L", inst & 0x3); + break; + } // 394 case 0b001110010100: case 0b001110010101: case 0b001110010110: case 0b001110010111: - { // Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] + { // Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] util::stream_format(stream, "M<->A2, 0x%d->L", inst & 0x3); break; } + + // 38c + case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: + { // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] + util::stream_format(stream, "M->A1, 0x%d->L", inst & 0x3); + break; + } // 39c case 0b001110011100: case 0b001110011101: case 0b001110011110: case 0b001110011111: - { // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] - util::stream_format(stream, "M<->A2, 0x%d->L", inst & 0x3); + { // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] + util::stream_format(stream, "M->A2, 0x%d->L", inst & 0x3); break; } ////////////////////////////////////////// ////////////////////////////////////////// - + // 3a0, 3a4, 3a8, 3ac, 3b0, 3b4, 3b8, 3bc case 0b001110100000: case 0b001110100001: case 0b001110100010: case 0b001110100011: case 0b001110100100: case 0b001110100101: case 0b001110100110: case 0b001110100111: @@ -639,98 +628,74 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001110110100: case 0b001110110101: case 0b001110110110: case 0b001110110111: case 0b001110111000: case 0b001110111001: case 0b001110111010: case 0b001110111011: case 0b001110111100: case 0b001110111101: case 0b001110111110: case 0b001110111111: - { // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3ac Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - // 3b0 AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - int optype = (inst & 0x0c)>>2; - int reg2 = (inst & 0x10)>>4; + { + // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3ac Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + // 3b0 AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + int optype = (inst & 0x0c) >> 2; + int reg2 = (inst & 0x10) >> 4; util::stream_format(stream, "M%s%s->M, 0x%d->L", m_320_optypes[optype], m_320_reg[reg2], inst & 0x3); break; } - // 3c0 - case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: - { // Move A1[5:1] to H[5:1], N->L[2:1] - util::stream_format(stream, "A1->H, 0x%d->L", inst & 0x3); - break; - } - - // 3cc - case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: - { // Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] - util::stream_format(stream, "H->A1, 0x%d->L", inst & 0x3); - break; - } - - // 3d0 - case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: - { // Move A2[5:1] to H[5:1], N->L[2:1] - util::stream_format(stream, "A2->H, 0x%d->L", inst & 0x3); - break; - } - - // 3dc - case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: - { // Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] - util::stream_format(stream, "H->A2, 0x%d->L", inst & 0x3); - break; - } + ////////////////////////////////////////// + ////////////////////////////////////////// - // 3e0 + // 3e0, 3e4, 3e8, 3ec, 3f0, 3f4, 3f8, 3fc case 0b001111100000: case 0b001111100001: case 0b001111100010: case 0b001111100011: - { // AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "H·A1->H, 0x%d->L", inst & 0x3); - break; - } - case 0b001111100100: case 0b001111100101: case 0b001111100110: case 0b001111100111: - { // Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "H+A1->H, 0x%d->L", inst & 0x3); - break; - } - case 0b001111101000: case 0b001111101001: case 0b001111101010: case 0b001111101011: - { // OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "HvA1->H, 0x%d->L", inst & 0x3); - break; - } - case 0b001111101100: case 0b001111101101: case 0b001111101110: case 0b001111101111: - { // Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "H-A1->H, 0x%d->L", inst & 0x3); + case 0b001111110000: case 0b001111110001: case 0b001111110010: case 0b001111110011: + case 0b001111110100: case 0b001111110101: case 0b001111110110: case 0b001111110111: + case 0b001111111000: case 0b001111111001: case 0b001111111010: case 0b001111111011: + case 0b001111111100: case 0b001111111101: case 0b001111111110: case 0b001111111111: + { + // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3e8 OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3ec Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + // 3f0 AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3f4 Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + int optype = (inst & 0x0c) >> 2; + int reg = (inst & 0x10) >> 4; + util::stream_format(stream, "H%s%s->H, 0x%d->L", m_320_optypes[optype], m_320_reg[reg], inst & 0x3); break; } - // 3f0 - case 0b001111110000: case 0b001111110001: case 0b001111110010: case 0b001111110011: - { // AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "H·A2->H, 0x%d->L", inst & 0x3); + ////////////////////////////////////////// + ////////////////////////////////////////// + + // 3c0 + case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: + { // Move A1[5:1] to H[5:1], N->L[2:1] + util::stream_format(stream, "A1->H, 0x%d->L", inst & 0x3); break; } - - // 3f4 - case 0b001111110100: case 0b001111110101: case 0b001111110110: case 0b001111110111: - { // Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "H+A2->H, 0x%d->L", inst & 0x3); + // 3d0 + case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: + { // Move A2[5:1] to H[5:1], N->L[2:1] + util::stream_format(stream, "A2->H, 0x%d->L", inst & 0x3); break; } - // 3f8 - case 0b001111111000: case 0b001111111001: case 0b001111111010: case 0b001111111011: - { // OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - util::stream_format(stream, "HvA2->H, 0x%d->L", inst & 0x3); + // 3cc + case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: + { // Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] + util::stream_format(stream, "H->A1, 0x%d->L", inst & 0x3); break; } - - // 3fc - case 0b001111111100: case 0b001111111101: case 0b001111111110: case 0b001111111111: - { // Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "H-A2->H, 0x%d->L", inst & 0x3); + // 3dc + case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: + { // Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] + util::stream_format(stream, "H->A2, 0x%d->L", inst & 0x3); break; } @@ -738,14 +703,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 400 case 0b010000000000: case 0b010000000001: - { // N->A[11] + { // N->A[11] util::stream_format(stream, "%d->A11", inst & 0x1); break; } // 402 case 0b010000000010: case 0b010000000011: - { // Jump to (000,M[H[5:1],L[2:1]][5:1],1N),0 L  [2:1], NA[11] + { // Jump to (000,M[H[5:1],L[2:1]][5:1],1N),0 L  [2:1], NA[11] util::stream_format(stream, "JPM, 0->L, %d->A11", inst & 0x1); break; } @@ -754,13 +719,13 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 440 case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: - { // Set D to DISP, G to GPE, K to KIE, S to SME, NA[11] + { // Set D to DISP, G to GPE, K to KIE, S to SME, NA[11] util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); break; } // 442 - //case 0b010001000010: case 0b010001000011: case 0b010001000110: case 0b010001000111: case 0b010001001010: case 0b010001001011: case 0b010001001110: case 0b010001001111: case 0b010001010010: case 0b010001010011: case 0b010001010110: case 0b010001010111: case 0b010001011010: case 0b010001011011: case 0b010001011110: case 0b010001011111: case 0b010001100010: case 0b010001100011: case 0b010001100110: case 0b010001100111: case 0b010001101010: case 0b010001101011: case 0b010001101110: case 0b010001101111: case 0b010001110010: case 0b010001110011: case 0b010001110110: case 0b010001110111: case 0b010001111010: case 0b010001111011: case 0b010001111110: case 0b010001111111: + // case 0b010001000010: case 0b010001000011: case 0b010001000110: case 0b010001000111: case 0b010001001010: case 0b010001001011: case 0b010001001110: case 0b010001001111: case 0b010001010010: case 0b010001010011: case 0b010001010110: case 0b010001010111: case 0b010001011010: case 0b010001011011: case 0b010001011110: case 0b010001011111: case 0b010001100010: case 0b010001100011: case 0b010001100110: case 0b010001100111: case 0b010001101010: case 0b010001101011: case 0b010001101110: case 0b010001101111: case 0b010001110010: case 0b010001110011: case 0b010001110110: case 0b010001110111: case 0b010001111010: case 0b010001111011: case 0b010001111110: case 0b010001111111: default: { From 0f7212454b9b0ccddb33f4b9e9f0204deffacce3 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 14:15:57 +0000 Subject: [PATCH 29/62] code reduction and cleanup --- src/devices/cpu/upd777/upd777dasm.cpp | 146 ++++++++++++++++---------- 1 file changed, 90 insertions(+), 56 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index f50b5a2a01995..ee8b6b265ff0d 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -88,7 +88,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u switch (inst) { case 0b000000000000: - { // No Operation + { + // No Operation util::stream_format(stream, "NOP"); break; } @@ -96,7 +97,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000000000001: case 0b000000000010: case 0b000000000011: case 0b000000000100: - { // Skip if (Gun Port Latch) = 1 + { + // Skip if (Gun Port Latch) = 1 util::stream_format(stream, "GPL"); break; } @@ -104,7 +106,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u //case 0b000000000101: case 0b000000000110: case 0b000000000111: case 0b000000001000: - { // Move H[5:1] to Line Buffer Register[5:1] + { + // Move H[5:1] to Line Buffer Register[5:1] util::stream_format(stream, "H->NRM"); break; } @@ -112,7 +115,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u //case 0b000000001001: case 0b000000001010: case 0b000000001011: case 0b000000001100: case 0b000000001101: case 0b000000001110: case 0b000000001111: case 0b000000010000: case 0b000000010001: case 0b000000010010: case 0b000000010011: case 0b000000010100: case 0b000000010101: case 0b000000010110: case 0b000000010111: case 0b000000011000: - { // H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] + { + // H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] util::stream_format(stream, "H<->X"); break; } @@ -120,7 +124,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000000011001: case 0b000000011010: case 0b000000011011: case 0b000000011100: case 0b000000011101: case 0b000000011110: case 0b000000011111: case 0b000000100000: - { // Subroutine End, Pop down address stack + { + // Subroutine End, Pop down address stack util::stream_format(stream, "SRE"); break; } @@ -128,7 +133,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000000100001: case 0b000000100010: case 0b000000100011: case 0b000000100100: case 0b000000100101: case 0b000000100110: case 0b000000100111: case 0b000000101000: case 0b000000101001: - { // Shift STB[4:1], N->STB[1] + { + // Shift STB[4:1], N->STB[1] util::stream_format(stream, "0x%d->STB", inst & 1); break; } @@ -174,15 +180,16 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 049 case 0b000001001001: - { // Skip if (4H Horizontal Blank) = 1 + { + // Skip if (4H Horizontal Blank) = 1 util::stream_format(stream, "4H BLK"); break; } // 04a case 0b000001001010: - { // Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] - + { + // Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] util::stream_format(stream, "VBLK"); break; } @@ -191,7 +198,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 04c case 0b000001001100: - { // Skip if (GP&SW/ input) = 1 + { + // Skip if (GP&SW/ input) = 1 util::stream_format(stream, "GPSW/"); break; } @@ -199,7 +207,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001001101: case 0b000001001110: case 0b000001001111: case 0b000001010000: case 0b000001010001: case 0b000001010010: case 0b000001010011: case 0b000001010100: - { // Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] + { + // Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] util::stream_format(stream, "A->MA"); break; } @@ -207,7 +216,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001010101: case 0b000001010110: case 0b000001010111: case 0b000001011000: - { // Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) + { + // Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) util::stream_format(stream, "MA->A"); break; } @@ -215,7 +225,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001011001: case 0b000001011010: case 0b000001011011: case 0b000001011100: - { // Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] + { + // Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] util::stream_format(stream, "MA<->A"); break; } @@ -223,7 +234,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001011101: case 0b000001011110: case 0b000001011111: case 0b000001100000: - { // Subroutine End, Pop down address stack, Skip + { + // Subroutine End, Pop down address stack, Skip util::stream_format(stream, "SRE+1"); break; } @@ -407,7 +419,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 300 case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: - { // N->L[2:1] + { + // N->L[2:1] util::stream_format(stream, "0x%d->L", inst & 0x3); break; } @@ -417,19 +430,22 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 308 case 0b001100001000: - { // Move A1[7:1] to FLS[7:1], 0->L[2:1] + { + // Move A1[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A1->FLS, 0->L"); break; } // 348 case 0b001101001000: - { // Move A2[7:1] to FLS[7:1], 0->L[2:1] + { + // Move A2[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A2->FLS, 0->L"); break; } // 388 case 0b001110001000: - { // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] + { + // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "M->FLS, 0->L"); break; } @@ -439,19 +455,22 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 309 case 0b001100001001: - { // Move A1[7:1] to FRS[7:1], 1->L[2:1] + { + // Move A1[7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "A1->FRS, 1->L"); break; } // 349 case 0b001101001001: - { // Move A2[7:1] to FRS[7:1], 1->L[2:1] + { + // Move A2[7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "A2->FRS, 1->L"); break; } // 389 case 0b001110001001: - { // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] + { + // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "M->FRS, 1->L"); break; } @@ -461,19 +480,22 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 30a case 0b001100001010: case 0b001100001011: - { // Move A1[7:1] to MODE[7:1], 1N->L[2:1] + { + // Move A1[7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "A1->MODE, 0x%d->L", (inst & 0x1) + 2); break; } // 34a case 0b001101001010: case 0b001101001011: - { // Move A2[7:1] to MODE[7:1], 1N->L[2:1] + { + // Move A2[7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "A2->MODE, 0x%d->L", (inst & 0x1) + 2); break; } // 38a case 0b001110001010: case 0b001110001011: - { // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] + { + // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "M->MODE, 0x%d->L", (inst & 0x1) + 2); break; } @@ -483,13 +505,15 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 310 case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: - { // Move A2[7:1] to A1[7:1], N->L[2:1] + { + // Move A2[7:1] to A1[7:1], N->L[2:1] util::stream_format(stream, "A2->A1, 0x%d->L", inst & 0x3); break; } // 340 case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: - { // Move A1[7:1] to A2[7:1], N->L[2:1] + { + // Move A1[7:1] to A2[7:1], N->L[2:1] util::stream_format(stream, "A1->A2, 0x%d->L", inst & 0x3); break; } @@ -499,32 +523,37 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 318 case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: - { // Right shift A1[7:1], 0A1[7], N->L[2:1] + { + // Right shift A1[7:1], 0A1[7], N->L[2:1] util::stream_format(stream, "A1->RS, 0x%d->L", inst & 0x3); break; } // 358 case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: - { // Right shift A2[7:1], 0A2[7], N->L[2:1] + { + // Right shift A2[7:1], 0A2[7], N->L[2:1] util::stream_format(stream, "A2->RS, 0x%d->L", inst & 0x3); break; } // 398 case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: - { // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] + { + // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] util::stream_format(stream, "M->RS, 0x%d->L", inst & 0x3); break; } // 31c case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: - { // Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + { + // Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] util::stream_format(stream, "A1-A2->A2, 0x%d->L", inst & 0x3); break; } // 34c case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: - { // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + { + // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] util::stream_format(stream, "A2-A1->A1, 0x%d->L", inst & 0x3); break; } @@ -578,26 +607,30 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 380 case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: - { // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + { + // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] util::stream_format(stream, "A1->M, 0x%d->L", inst & 0x3); break; } // 390 case 0b001110010000: case 0b001110010001: case 0b001110010010: case 0b001110010011: - { // Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + { + // Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] util::stream_format(stream, "A2->M, 0x%d->L", inst & 0x3); break; } // 384 case 0b001110000100: case 0b001110000101: case 0b001110000110: case 0b001110000111: - { // Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] + { + // Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] util::stream_format(stream, "M<->A1, 0x%d->L", inst & 0x3); break; } // 394 case 0b001110010100: case 0b001110010101: case 0b001110010110: case 0b001110010111: - { // Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] + { + // Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] util::stream_format(stream, "M<->A2, 0x%d->L", inst & 0x3); break; } @@ -605,13 +638,15 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 38c case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: - { // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] + { + // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] util::stream_format(stream, "M->A1, 0x%d->L", inst & 0x3); break; } // 39c case 0b001110011100: case 0b001110011101: case 0b001110011110: case 0b001110011111: - { // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] + { + // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] util::stream_format(stream, "M->A2, 0x%d->L", inst & 0x3); break; } @@ -673,29 +708,25 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////// ////////////////////////////////////////// - // 3c0 + // 3c0, 3d0 case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: - { // Move A1[5:1] to H[5:1], N->L[2:1] - util::stream_format(stream, "A1->H, 0x%d->L", inst & 0x3); - break; - } - // 3d0 case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: - { // Move A2[5:1] to H[5:1], N->L[2:1] - util::stream_format(stream, "A2->H, 0x%d->L", inst & 0x3); + { + // 3c0 Move A1[5:1] to H[5:1], N->L[2:1] + // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] + int reg = (inst & 0x10) >> 4; + util::stream_format(stream, "A%d->H, 0x%d->L", reg + 1, inst & 0x3); break; } - // 3cc + // 3cc, 3dc case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: - { // Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] - util::stream_format(stream, "H->A1, 0x%d->L", inst & 0x3); - break; - } - // 3dc case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: - { // Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] - util::stream_format(stream, "H->A2, 0x%d->L", inst & 0x3); + { + // 3cc Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] + // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] + int reg = (inst & 0x10) >> 4; + util::stream_format(stream, "H->A%d, 0x%d->L", reg + 1, inst & 0x3); break; } @@ -703,14 +734,16 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 400 case 0b010000000000: case 0b010000000001: - { // N->A[11] + { + // N->A[11] util::stream_format(stream, "%d->A11", inst & 0x1); break; } // 402 case 0b010000000010: case 0b010000000011: - { // Jump to (000,M[H[5:1],L[2:1]][5:1],1N),0 L  [2:1], NA[11] + { + // Jump to (000,M[H[5:1],L[2:1]][5:1],1N),0 L  [2:1], N->A[11] util::stream_format(stream, "JPM, 0->L, %d->A11", inst & 0x1); break; } @@ -719,7 +752,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 440 case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: - { // Set D to DISP, G to GPE, K to KIE, S to SME, NA[11] + { + // Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); break; } From 762e33f96eb4449ec49f529039b99450b6a891f8 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 14:30:51 +0000 Subject: [PATCH 30/62] final(?) reformatting before using as a base for an execution core --- src/devices/cpu/upd777/upd777dasm.cpp | 138 +++++++++----------------- 1 file changed, 48 insertions(+), 90 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index ee8b6b265ff0d..d804737ee7ec6 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -89,7 +89,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { case 0b000000000000: { - // No Operation + // 000 No Operation util::stream_format(stream, "NOP"); break; } @@ -98,7 +98,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000000100: { - // Skip if (Gun Port Latch) = 1 + // 004 Skip if (Gun Port Latch) = 1 util::stream_format(stream, "GPL"); break; } @@ -107,7 +107,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000001000: { - // Move H[5:1] to Line Buffer Register[5:1] + // 008 Move H[5:1] to Line Buffer Register[5:1] util::stream_format(stream, "H->NRM"); break; } @@ -116,7 +116,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000011000: { - // H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] + // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] util::stream_format(stream, "H<->X"); break; } @@ -125,7 +125,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000100000: { - // Subroutine End, Pop down address stack + // 020 Subroutine End, Pop down address stack util::stream_format(stream, "SRE"); break; } @@ -134,14 +134,13 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000000101000: case 0b000000101001: { - // Shift STB[4:1], N->STB[1] + // 028 Shift STB[4:1], N->STB[1] util::stream_format(stream, "0x%d->STB", inst & 1); break; } // case 0b000000101010: case 0b000000101011: case 0b000000101100: case 0b000000101101: case 0b000000101110: case 0b000000101111: - // 030, 034, 038, 03c, 070, 074, 078, 07c case 0b000000110000: case 0b000000110100: case 0b000000111000: @@ -178,28 +177,25 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b000001000000: case 0b000001000001: case 0b000001000010: case 0b000001000011: case 0b000001000100: case 0b000001000101: case 0b000001000110: case 0b000001000111: case 0b000001001000: - // 049 case 0b000001001001: { - // Skip if (4H Horizontal Blank) = 1 + // 049 Skip if (4H Horizontal Blank) = 1 util::stream_format(stream, "4H BLK"); break; } - // 04a case 0b000001001010: { - // Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] + // 04a Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] util::stream_format(stream, "VBLK"); break; } // case 0b000001001011: - // 04c case 0b000001001100: { - // Skip if (GP&SW/ input) = 1 + // 04c Skip if (GP&SW/ input) = 1 util::stream_format(stream, "GPSW/"); break; } @@ -208,7 +204,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001010100: { - // Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] + // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] util::stream_format(stream, "A->MA"); break; } @@ -217,7 +213,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001011000: { - // Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) + // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) util::stream_format(stream, "MA->A"); break; } @@ -226,7 +222,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001011100: { - // Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] + // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] util::stream_format(stream, "MA<->A"); break; } @@ -235,7 +231,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b000001100000: { - // Subroutine End, Pop down address stack, Skip + // 060 Subroutine End, Pop down address stack, Skip util::stream_format(stream, "SRE+1"); break; } @@ -246,7 +242,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// - // 200, 220, 208, 228, 20c, 22c, 210, 230, 218, 238, 21c, 23c, 240, 260, 248, 268, 24c, 26c, 250, 270, 258, 278, 25c, 27c, 280, 2a0, 288, 2a8, 28c, 2ac, 290, 2b0, 298, 2b8, 29c, 2bc, 2c0, 2e0, 2c8, 2e8, 2cc, 2ec, 2d0, 2f0, 2d8, 2f8, 2dc, 2fc case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: @@ -417,10 +412,9 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // case 0b001111010100: case 0b001111010101: case 0b001111010110: case 0b001111010111: // case 0b001111011000: case 0b001111011001: case 0b001111011010: case 0b001111011011: - // 300 case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: { - // N->L[2:1] + // 300 N->L[2:1] util::stream_format(stream, "0x%d->L", inst & 0x3); break; } @@ -428,24 +422,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////// ////////////////////////////////////////// - // 308 case 0b001100001000: { - // Move A1[7:1] to FLS[7:1], 0->L[2:1] + // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A1->FLS, 0->L"); break; } - // 348 case 0b001101001000: { - // Move A2[7:1] to FLS[7:1], 0->L[2:1] + // 348 Move A2[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A2->FLS, 0->L"); break; } - // 388 case 0b001110001000: { - // Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] + // 388 Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "M->FLS, 0->L"); break; } @@ -453,24 +444,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////// ////////////////////////////////////////// - // 309 case 0b001100001001: { - // Move A1[7:1] to FRS[7:1], 1->L[2:1] + // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "A1->FRS, 1->L"); break; } - // 349 case 0b001101001001: { - // Move A2[7:1] to FRS[7:1], 1->L[2:1] + // 349 Move A2[7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "A2->FRS, 1->L"); break; } - // 389 case 0b001110001001: { - // Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] + // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "M->FRS, 1->L"); break; } @@ -478,24 +466,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////// ////////////////////////////////////////// - // 30a case 0b001100001010: case 0b001100001011: { - // Move A1[7:1] to MODE[7:1], 1N->L[2:1] + // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "A1->MODE, 0x%d->L", (inst & 0x1) + 2); break; } - // 34a case 0b001101001010: case 0b001101001011: { - // Move A2[7:1] to MODE[7:1], 1N->L[2:1] + // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "A2->MODE, 0x%d->L", (inst & 0x1) + 2); break; } - // 38a case 0b001110001010: case 0b001110001011: { - // Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] + // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] util::stream_format(stream, "M->MODE, 0x%d->L", (inst & 0x1) + 2); break; } @@ -503,17 +488,15 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////// ////////////////////////////////////////// - // 310 case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: { - // Move A2[7:1] to A1[7:1], N->L[2:1] + // 310 Move A2[7:1] to A1[7:1], N->L[2:1] util::stream_format(stream, "A2->A1, 0x%d->L", inst & 0x3); break; } - // 340 case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: { - // Move A1[7:1] to A2[7:1], N->L[2:1] + // 340 Move A1[7:1] to A2[7:1], N->L[2:1] util::stream_format(stream, "A1->A2, 0x%d->L", inst & 0x3); break; } @@ -524,36 +507,35 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 318 case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: { - // Right shift A1[7:1], 0A1[7], N->L[2:1] + // Right shift A1[7:1], 0->A1[7], N->L[2:1] util::stream_format(stream, "A1->RS, 0x%d->L", inst & 0x3); break; } - // 358 case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: { - // Right shift A2[7:1], 0A2[7], N->L[2:1] + // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] util::stream_format(stream, "A2->RS, 0x%d->L", inst & 0x3); break; } - // 398 case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: { - // Right shift M[H[5:1],L[2:1]][7:1], 0M[H[5:1],L[2:1]][7], N->L[2:1] + // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] util::stream_format(stream, "M->RS, 0x%d->L", inst & 0x3); break; } - // 31c + ////////////////////////////////////////// + ////////////////////////////////////////// + case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: { - // Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] util::stream_format(stream, "A1-A2->A2, 0x%d->L", inst & 0x3); break; } - // 34c case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: { - // Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] util::stream_format(stream, "A2-A1->A1, 0x%d->L", inst & 0x3); break; } @@ -561,7 +543,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ///////////////////////////////////////////////////// ///////////////////////////////////////////////////// - // 320, 324, 328, 32c, 330, 334, 338, 33c, 360, 364, 368, 36c, 370, 374, 378, 37c case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: case 0b001100101000: case 0b001100101001: case 0b001100101010: case 0b001100101011: @@ -605,56 +586,39 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////// ////////////////////////////////////////// - // 380 case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: - { - // Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "A1->M, 0x%d->L", inst & 0x3); - break; - } - // 390 case 0b001110010000: case 0b001110010001: case 0b001110010010: case 0b001110010011: { - // Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - util::stream_format(stream, "A2->M, 0x%d->L", inst & 0x3); + // 380 Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + int reg = (inst & 0x10) >> 4; + util::stream_format(stream, "A%d->M, 0x%d->L", reg + 1, inst & 0x3); break; } - // 384 case 0b001110000100: case 0b001110000101: case 0b001110000110: case 0b001110000111: - { - // Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] - util::stream_format(stream, "M<->A1, 0x%d->L", inst & 0x3); - break; - } - // 394 case 0b001110010100: case 0b001110010101: case 0b001110010110: case 0b001110010111: { - // Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] - util::stream_format(stream, "M<->A2, 0x%d->L", inst & 0x3); + // 384 Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] + // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] + int reg = (inst & 0x10) >> 4; + util::stream_format(stream, "M<->A%d, 0x%d->L", reg + 1, inst & 0x3); break; } - - // 38c case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: - { - // Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] - util::stream_format(stream, "M->A1, 0x%d->L", inst & 0x3); - break; - } - // 39c case 0b001110011100: case 0b001110011101: case 0b001110011110: case 0b001110011111: { - // Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] - util::stream_format(stream, "M->A2, 0x%d->L", inst & 0x3); + // 38c Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] + // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] + int reg = (inst & 0x10) >> 4; + util::stream_format(stream, "M->A%d, 0x%d->L", reg + 1, inst & 0x3); break; } ////////////////////////////////////////// ////////////////////////////////////////// - // 3a0, 3a4, 3a8, 3ac, 3b0, 3b4, 3b8, 3bc case 0b001110100000: case 0b001110100001: case 0b001110100010: case 0b001110100011: case 0b001110100100: case 0b001110100101: case 0b001110100110: case 0b001110100111: case 0b001110101000: case 0b001110101001: case 0b001110101010: case 0b001110101011: @@ -681,7 +645,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////// ////////////////////////////////////////// - // 3e0, 3e4, 3e8, 3ec, 3f0, 3f4, 3f8, 3fc case 0b001111100000: case 0b001111100001: case 0b001111100010: case 0b001111100011: case 0b001111100100: case 0b001111100101: case 0b001111100110: case 0b001111100111: case 0b001111101000: case 0b001111101001: case 0b001111101010: case 0b001111101011: @@ -708,7 +671,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////// ////////////////////////////////////////// - // 3c0, 3d0 case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: { @@ -719,7 +681,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // 3cc, 3dc case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: { @@ -732,28 +693,25 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ////////////////////////////////////////////////////////////////////////////////////////////// - // 400 case 0b010000000000: case 0b010000000001: { - // N->A[11] + // 400 N->A[11] util::stream_format(stream, "%d->A11", inst & 0x1); break; } - // 402 case 0b010000000010: case 0b010000000011: { - // Jump to (000,M[H[5:1],L[2:1]][5:1],1N),0 L  [2:1], N->A[11] + // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] util::stream_format(stream, "JPM, 0->L, %d->A11", inst & 0x1); break; } // case 0b010000000100: case 0b010000000101: case 0b010000000110: case 0b010000000111: case 0b010000001000: case 0b010000001001: case 0b010000001010: case 0b010000001011: case 0b010000001100: case 0b010000001101: case 0b010000001110: case 0b010000001111: case 0b010000010000: case 0b010000010001: case 0b010000010010: case 0b010000010011: case 0b010000010100: case 0b010000010101: case 0b010000010110: case 0b010000010111: case 0b010000011000: case 0b010000011001: case 0b010000011010: case 0b010000011011: case 0b010000011100: case 0b010000011101: case 0b010000011110: case 0b010000011111: case 0b010000100000: case 0b010000100001: case 0b010000100010: case 0b010000100011: case 0b010000100100: case 0b010000100101: case 0b010000100110: case 0b010000100111: case 0b010000101000: case 0b010000101001: case 0b010000101010: case 0b010000101011: case 0b010000101100: case 0b010000101101: case 0b010000101110: case 0b010000101111: case 0b010000110000: case 0b010000110001: case 0b010000110010: case 0b010000110011: case 0b010000110100: case 0b010000110101: case 0b010000110110: case 0b010000110111: case 0b010000111000: case 0b010000111001: case 0b010000111010: case 0b010000111011: case 0b010000111100: case 0b010000111101: case 0b010000111110: case 0b010000111111: - // 440 case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: { - // Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] + // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); break; } From bd72cbae5e286a245e057c435f917bc7a7939d9e Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 15:41:13 +0000 Subject: [PATCH 31/62] extract some params in a way that will be useful for converting over to execution core --- src/devices/cpu/upd777/upd777dasm.cpp | 353 +++++++++++++------------- 1 file changed, 172 insertions(+), 181 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index d804737ee7ec6..12952c6f772e0 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -12,9 +12,9 @@ upd777_disassembler::upd777_disassembler() { m_l2r[i] = pc; m_r2l[pc] = i; - int top1 = (pc & 0x40) >> 6; - int top2 = (pc & 0x20) >> 5; - int nor = (top1 ^ top2) ^ 1; + const int top1 = (pc & 0x40) >> 6; + const int top2 = (pc & 0x20) >> 5; + const int nor = (top1 ^ top2) ^ 1; pc = (pc << 1) | nor; pc &= 0x7f; } @@ -29,17 +29,22 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u if (inst >= 0x080 && inst <= 0x0ff) { // Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow - util::stream_format(stream, "M-0x%02x", inst & 0x7f); + const int k = inst & 0x7f; + util::stream_format(stream, "M-0x%02x", k); } else if (inst >= 0x100 && inst <= 0x17f) { // M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] - util::stream_format(stream, "M+0x%02x->M, 0x%d->L", inst & 0x1f, (inst >> 5) & 0x3); + const int k = inst & 0x1f; + const int n = (inst >> 5) & 0x3; + util::stream_format(stream, "M+0x%02x->M, 0x%d->L", k, n); } else if (inst >= 0x180 && inst <= 0x1ff) { // M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "M-0x%02x->M, 0x%d->L", inst & 0x1f, (inst >> 5) & 0x3); + const int k = inst & 0x1f; + const int n = (inst >> 5) & 0x3; + util::stream_format(stream, "M-0x%02x->M, 0x%d->L", k, n); } else if (inst >= 0x480 && inst <= 0x4bf) // 480 - 4bf { @@ -49,19 +54,22 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u else if (inst >= 0x4c0 && inst <= 0x4ff) // 4c0 - 4ff { // H[5:1]+K[5:1]H[5:1], Skip if carry - util::stream_format(stream, "H+0x%02x->H CAJ", inst & 0x1f); + const int k = inst & 0x1f; + util::stream_format(stream, "H+0x%02x->H CAJ", k); } else if (inst >= 0x500 && inst <= 0x57f) // 500 - 57f { // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] - util::stream_format(stream, "0x%02x->M", inst & 0x7f); + const int k = inst & 0x7f; + util::stream_format(stream, "0x%02x->M", k); } else if (inst >= 0x580 && inst <= 0x5ff) // 580 - 5ff { // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] - util::stream_format(stream, "0x%02x->L,H", inst & 0x7f); + const int k = inst & 0x7f; + util::stream_format(stream, "0x%02x->L,H", k); } else if (inst >= 0x600 && inst <= 0x7ff) // 600 - 7ff { @@ -69,8 +77,9 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 680-6ff Store K[7:1] to A2[7:1] // 700-77f Store K[7:1] to A3[7:1] // 780-7ff Store K[7:1] to A4[7:1] - int reg = (inst & 0x180) >> 7; - util::stream_format(stream, "0x%02x->A%d", inst & 0x7f, reg+1); + const int reg = (inst & 0x180) >> 7; + const int k = inst & 0x7f; + util::stream_format(stream, "0x%02x->A%d", k, reg+1); } else if (inst >= 0x800 && inst < 0xc00) // 800 - bff { @@ -81,7 +90,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u else if (inst >= 0xc00 && inst < 0x1000) // c00 - fff { // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack - util::stream_format(stream, "JS 0x%03x (%01x:%02x)", inst & 0x3ff, (inst & 0x380)>>7, inst & 0x07f); + const int k = inst & 0x3ff; + util::stream_format(stream, "JS 0x%03x (%01x:%02x)", k & 0x3ff, (k & 0x380)>>7, k & 0x07f); } else { @@ -93,54 +103,37 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "NOP"); break; } - - // case 0b000000000001: case 0b000000000010: case 0b000000000011: - case 0b000000000100: { // 004 Skip if (Gun Port Latch) = 1 util::stream_format(stream, "GPL"); break; } - - //case 0b000000000101: case 0b000000000110: case 0b000000000111: - case 0b000000001000: { // 008 Move H[5:1] to Line Buffer Register[5:1] util::stream_format(stream, "H->NRM"); break; } - - //case 0b000000001001: case 0b000000001010: case 0b000000001011: case 0b000000001100: case 0b000000001101: case 0b000000001110: case 0b000000001111: case 0b000000010000: case 0b000000010001: case 0b000000010010: case 0b000000010011: case 0b000000010100: case 0b000000010101: case 0b000000010110: case 0b000000010111: - case 0b000000011000: { // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] util::stream_format(stream, "H<->X"); break; } - - // case 0b000000011001: case 0b000000011010: case 0b000000011011: case 0b000000011100: case 0b000000011101: case 0b000000011110: case 0b000000011111: - case 0b000000100000: { // 020 Subroutine End, Pop down address stack util::stream_format(stream, "SRE"); break; } - - // case 0b000000100001: case 0b000000100010: case 0b000000100011: case 0b000000100100: case 0b000000100101: case 0b000000100110: case 0b000000100111: - case 0b000000101000: case 0b000000101001: { // 028 Shift STB[4:1], N->STB[1] - util::stream_format(stream, "0x%d->STB", inst & 1); + const int n = inst & 1; + util::stream_format(stream, "0x%d->STB", n); break; } - - // case 0b000000101010: case 0b000000101011: case 0b000000101100: case 0b000000101101: case 0b000000101110: case 0b000000101111: - case 0b000000110000: case 0b000000110100: case 0b000000111000: @@ -158,77 +151,47 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 74 Skip if (PD2 input) = 0 // 78 Skip if (PD3 input) = 0 // 7c Skip if (PD4 input) = 0 - int which = (inst & 0x00c) >> 2; - int inv = inst & 0x40; + const int which = (inst & 0x00c) >> 2; + const int inv = inst & 0x40; util::stream_format(stream, "PD%d %sJ", which + 1, inv ? "/" : ""); break; } - - // unused instructions after the PDx J and PDx /J opcodes - // case 0b000000110001: case 0b000000110010: case 0b000000110011: - // case 0b000000110101: case 0b000000110110: case 0b000000110111: - // case 0b000000111001: case 0b000000111010: case 0b000000111011: - // case 0b000000111101: case 0b000000111110: case 0b000000111111: - // - // case 0b000001110001: case 0b000001110010: case 0b000001110011: - // case 0b000001110101: case 0b000001110110: case 0b000001110111: - // case 0b000001111001: case 0b000001111010: case 0b000001111011: - // case 0b000001111101: case 0b000001111110: case 0b000001111111: - - // case 0b000001000000: case 0b000001000001: case 0b000001000010: case 0b000001000011: case 0b000001000100: case 0b000001000101: case 0b000001000110: case 0b000001000111: case 0b000001001000: - case 0b000001001001: { // 049 Skip if (4H Horizontal Blank) = 1 util::stream_format(stream, "4H BLK"); break; } - case 0b000001001010: { // 04a Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] util::stream_format(stream, "VBLK"); break; } - - // case 0b000001001011: - case 0b000001001100: { // 04c Skip if (GP&SW/ input) = 1 util::stream_format(stream, "GPSW/"); break; } - - // case 0b000001001101: case 0b000001001110: case 0b000001001111: case 0b000001010000: case 0b000001010001: case 0b000001010010: case 0b000001010011: - case 0b000001010100: { // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] util::stream_format(stream, "A->MA"); break; } - - // case 0b000001010101: case 0b000001010110: case 0b000001010111: - case 0b000001011000: { // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) util::stream_format(stream, "MA->A"); break; } - - // case 0b000001011001: case 0b000001011010: case 0b000001011011: - case 0b000001011100: { // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] util::stream_format(stream, "MA<->A"); break; } - - // case 0b000001011101: case 0b000001011110: case 0b000001011111: - case 0b000001100000: { // 060 Subroutine End, Pop down address stack, Skip @@ -236,9 +199,31 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } + // unused < 0x80 cases + // case 0b000000000001: case 0b000000000010: case 0b000000000011: + // case 0b000000000101: case 0b000000000110: case 0b000000000111: + // case 0b000000001001: case 0b000000001010: case 0b000000001011: case 0b000000001100: case 0b000000001101: case 0b000000001110: case 0b000000001111: case 0b000000010000: case 0b000000010001: case 0b000000010010: case 0b000000010011: case 0b000000010100: case 0b000000010101: case 0b000000010110: case 0b000000010111: + // case 0b000000011001: case 0b000000011010: case 0b000000011011: case 0b000000011100: case 0b000000011101: case 0b000000011110: case 0b000000011111: + // case 0b000000100001: case 0b000000100010: case 0b000000100011: case 0b000000100100: case 0b000000100101: case 0b000000100110: case 0b000000100111: + // case 0b000000101010: case 0b000000101011: case 0b000000101100: case 0b000000101101: case 0b000000101110: case 0b000000101111: + // unused instructions after the PDx J and PDx /J opcodes + // case 0b000000110001: case 0b000000110010: case 0b000000110011: + // case 0b000000110101: case 0b000000110110: case 0b000000110111: + // case 0b000000111001: case 0b000000111010: case 0b000000111011: + // case 0b000000111101: case 0b000000111110: case 0b000000111111: + // + // case 0b000001110001: case 0b000001110010: case 0b000001110011: + // case 0b000001110101: case 0b000001110110: case 0b000001110111: + // case 0b000001111001: case 0b000001111010: case 0b000001111011: + // case 0b000001111101: case 0b000001111110: case 0b000001111111: + // case 0b000001000000: case 0b000001000001: case 0b000001000010: case 0b000001000011: case 0b000001000100: case 0b000001000101: case 0b000001000110: case 0b000001000111: case 0b000001001000: + // case 0b000001001011: + // case 0b000001001101: case 0b000001001110: case 0b000001001111: case 0b000001010000: case 0b000001010001: case 0b000001010010: case 0b000001010011: + // case 0b000001010101: case 0b000001010110: case 0b000001010111: + // case 0b000001011001: case 0b000001011010: case 0b000001011011: + // case 0b000001011101: case 0b000001011110: case 0b000001011111: // case 0b000001100001: case 0b000001100010: case 0b000001100011: case 0b000001100100: case 0b000001100101: case 0b000001100110: case 0b000001100111: case 0b000001101000: case 0b000001101001: case 0b000001101010: case 0b000001101011: case 0b000001101100: case 0b000001101101: case 0b000001101110: case 0b000001101111: - ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// @@ -294,84 +279,66 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // optype · // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] - // optype = - // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - // optype - - // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // optype · // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // optype = - // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo on description?, should be =?) - // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo on description?, should be =?) - // optype - - // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // optype · - // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] - // optype = - // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // optype · // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // optype = - // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // optype · // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] - // optype = - // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] (typo?) - // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // optype · // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] - // optype = - // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] (typo?) - // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // optype · // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] - // optype = - // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] (typo?) - // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] (typo?) - // optype - - // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] - // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] - // optype · // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] - // optype = - // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] (typo?) - // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] (typo?) + + // optype = (these are expressed as x=y in the opcopde syntax, but x-y in the description, in reality it seems to act as 'CMP' so x-y = 0) + // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] + // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] + // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] + // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] + // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] + // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] + // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] + // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] + // optype - + // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] + // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] - u8 non = inst & 0x20; - u8 optype = (inst & 0x0c) >> 2; - u8 reg1 = (inst & 0xc0) >> 6; - u8 reg2 = (inst & 0x10) >> 4; - util::stream_format(stream, "%s%s%s, 0x%d->L %s%s", m_200_reg1[reg1], m_200_optypes[optype], m_200_reg2[reg2], inst & 0x3, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); + const int non = inst & 0x20; + const int optype = (inst & 0x0c) >> 2; + const int reg1 = (inst & 0xc0) >> 6; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "%s%s%s, 0x%d->L %s%s", m_200_reg1[reg1], m_200_optypes[optype], m_200_reg2[reg2], n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); break; } - // these would be 'invalid' optype + // unused 2xx - these would be 'invalid' optype // 204, 224, 214, 234, 244, 264, 254, 274, 284, 2a4, 294, 2b4, 2c4, 2e4, 2d4, 2f4 // case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: // case 0b001000100100: case 0b001000100101: case 0b001000100110: case 0b001000100111: @@ -393,29 +360,11 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u ///////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////// - // unused - // 304 - // case 0b001100000100: case 0b001100000101: case 0b001100000110: case 0b001100000111: - // 344 - // case 0b001101000100: case 0b001101000101: case 0b001101000110: case 0b001101000111: - // 30c - //case 0b001100001100: case 0b001100001101: case 0b001100001110: case 0b001100001111: - // 314 - //case 0b001100010100: case 0b001100010101: case 0b001100010110: case 0b001100010111: - // 350 - // case 0b001101010000: case 0b001101010001: case 0b001101010010: case 0b001101010011: - // case 0b001101010100: case 0b001101010101: case 0b001101010110: case 0b001101010111: - // 35c - // case 0b001101011100: case 0b001101011101: case 0b001101011110: case 0b001101011111: - // case 0b001111000100: case 0b001111000101: case 0b001111000110: case 0b001111000111: - // case 0b001111001000: case 0b001111001001: case 0b001111001010: case 0b001111001011: - // case 0b001111010100: case 0b001111010101: case 0b001111010110: case 0b001111010111: - // case 0b001111011000: case 0b001111011001: case 0b001111011010: case 0b001111011011: - case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: { // 300 N->L[2:1] - util::stream_format(stream, "0x%d->L", inst & 0x3); + const int n = inst & 0x3; + util::stream_format(stream, "0x%d->L", n); break; } @@ -469,19 +418,22 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001100001010: case 0b001100001011: { // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "A1->MODE, 0x%d->L", (inst & 0x1) + 2); + const int n = (inst & 0x1) + 2; + util::stream_format(stream, "A1->MODE, 0x%d->L", n); break; } case 0b001101001010: case 0b001101001011: { // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "A2->MODE, 0x%d->L", (inst & 0x1) + 2); + const int n = (inst & 0x1) + 2; + util::stream_format(stream, "A2->MODE, 0x%d->L", n); break; } case 0b001110001010: case 0b001110001011: { // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] - util::stream_format(stream, "M->MODE, 0x%d->L", (inst & 0x1) + 2); + const int n = (inst & 0x1) + 2; + util::stream_format(stream, "M->MODE, 0x%d->L", n); break; } @@ -491,13 +443,15 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: { // 310 Move A2[7:1] to A1[7:1], N->L[2:1] - util::stream_format(stream, "A2->A1, 0x%d->L", inst & 0x3); + const int n = inst & 0x3; + util::stream_format(stream, "A2->A1, 0x%d->L", n); break; } case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: { // 340 Move A1[7:1] to A2[7:1], N->L[2:1] - util::stream_format(stream, "A1->A2, 0x%d->L", inst & 0x3); + const int n = inst & 0x3; + util::stream_format(stream, "A1->A2, 0x%d->L", n); break; } @@ -508,19 +462,22 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: { // Right shift A1[7:1], 0->A1[7], N->L[2:1] - util::stream_format(stream, "A1->RS, 0x%d->L", inst & 0x3); + const int n = inst & 0x3; + util::stream_format(stream, "A1->RS, 0x%d->L", n); break; } case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: { // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] - util::stream_format(stream, "A2->RS, 0x%d->L", inst & 0x3); + const int n = inst & 0x3; + util::stream_format(stream, "A2->RS, 0x%d->L", n); break; } case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: { // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] - util::stream_format(stream, "M->RS, 0x%d->L", inst & 0x3); + const int n = inst & 0x3; + util::stream_format(stream, "M->RS, 0x%d->L", n); break; } @@ -530,13 +487,15 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: { // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "A1-A2->A2, 0x%d->L", inst & 0x3); + const int n = inst & 0x3; + util::stream_format(stream, "A1-A2->A2, 0x%d->L", n); break; } case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: { // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - util::stream_format(stream, "A2-A1->A1, 0x%d->L", inst & 0x3); + const int n = inst & 0x3; + util::stream_format(stream, "A2-A1->A1, 0x%d->L", n); break; } @@ -576,10 +535,11 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - int optype = (inst & 0x0c) >> 2; - int reg2 = (inst & 0x10) >> 4; - int reg1 = (inst & 0x40) >> 6; - util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", m_320_reg[reg1], m_320_optypes[optype], m_320_reg[reg2], m_320_reg[reg1], inst & 0x3, (optype == 3) ? "BOJ" : ""); + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int reg1 = (inst & 0x40) >> 6; + const int n = inst & 0x3; + util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", m_320_reg[reg1], m_320_optypes[optype], m_320_reg[reg2], m_320_reg[reg1], n, (optype == 3) ? "BOJ" : ""); break; } @@ -591,8 +551,9 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { // 380 Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - int reg = (inst & 0x10) >> 4; - util::stream_format(stream, "A%d->M, 0x%d->L", reg + 1, inst & 0x3); + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "A%d->M, 0x%d->L", reg + 1, n); break; } @@ -601,8 +562,9 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { // 384 Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] - int reg = (inst & 0x10) >> 4; - util::stream_format(stream, "M<->A%d, 0x%d->L", reg + 1, inst & 0x3); + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "M<->A%d, 0x%d->L", reg + 1, n); break; } @@ -611,8 +573,9 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { // 38c Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] - int reg = (inst & 0x10) >> 4; - util::stream_format(stream, "M->A%d, 0x%d->L", reg + 1, inst & 0x3); + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "M->A%d, 0x%d->L", reg + 1, n); break; } @@ -636,9 +599,10 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - int optype = (inst & 0x0c) >> 2; - int reg2 = (inst & 0x10) >> 4; - util::stream_format(stream, "M%s%s->M, 0x%d->L", m_320_optypes[optype], m_320_reg[reg2], inst & 0x3); + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "M%s%s->M, 0x%d->L", m_320_optypes[optype], m_320_reg[reg2], n); break; } @@ -662,9 +626,10 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 3f4 Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - int optype = (inst & 0x0c) >> 2; - int reg = (inst & 0x10) >> 4; - util::stream_format(stream, "H%s%s->H, 0x%d->L", m_320_optypes[optype], m_320_reg[reg], inst & 0x3); + const int optype = (inst & 0x0c) >> 2; + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "H%s%s->H, 0x%d->L", m_320_optypes[optype], m_320_reg[reg], n); break; } @@ -676,46 +641,72 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { // 3c0 Move A1[5:1] to H[5:1], N->L[2:1] // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] - int reg = (inst & 0x10) >> 4; - util::stream_format(stream, "A%d->H, 0x%d->L", reg + 1, inst & 0x3); + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "A%d->H, 0x%d->L", reg + 1, n); break; } - case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: { // 3cc Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] - int reg = (inst & 0x10) >> 4; - util::stream_format(stream, "H->A%d, 0x%d->L", reg + 1, inst & 0x3); + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "H->A%d, 0x%d->L", reg + 1, n); break; } + // unused 3xx + // 304 + // case 0b001100000100: case 0b001100000101: case 0b001100000110: case 0b001100000111: + // 344 + // case 0b001101000100: case 0b001101000101: case 0b001101000110: case 0b001101000111: + // 30c + //case 0b001100001100: case 0b001100001101: case 0b001100001110: case 0b001100001111: + // 314 + //case 0b001100010100: case 0b001100010101: case 0b001100010110: case 0b001100010111: + // 350 + // case 0b001101010000: case 0b001101010001: case 0b001101010010: case 0b001101010011: + // case 0b001101010100: case 0b001101010101: case 0b001101010110: case 0b001101010111: + // 35c + // case 0b001101011100: case 0b001101011101: case 0b001101011110: case 0b001101011111: + // case 0b001111000100: case 0b001111000101: case 0b001111000110: case 0b001111000111: + // case 0b001111001000: case 0b001111001001: case 0b001111001010: case 0b001111001011: + // case 0b001111010100: case 0b001111010101: case 0b001111010110: case 0b001111010111: + // case 0b001111011000: case 0b001111011001: case 0b001111011010: case 0b001111011011: + ////////////////////////////////////////////////////////////////////////////////////////////// case 0b010000000000: case 0b010000000001: { // 400 N->A[11] - util::stream_format(stream, "%d->A11", inst & 0x1); + const int n = inst & 0x1; + util::stream_format(stream, "%d->A11", n); break; } - case 0b010000000010: case 0b010000000011: { // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] - util::stream_format(stream, "JPM, 0->L, %d->A11", inst & 0x1); + const int n = inst & 0x1; + util::stream_format(stream, "JPM, 0->L, %d->A11", n); break; } - - // case 0b010000000100: case 0b010000000101: case 0b010000000110: case 0b010000000111: case 0b010000001000: case 0b010000001001: case 0b010000001010: case 0b010000001011: case 0b010000001100: case 0b010000001101: case 0b010000001110: case 0b010000001111: case 0b010000010000: case 0b010000010001: case 0b010000010010: case 0b010000010011: case 0b010000010100: case 0b010000010101: case 0b010000010110: case 0b010000010111: case 0b010000011000: case 0b010000011001: case 0b010000011010: case 0b010000011011: case 0b010000011100: case 0b010000011101: case 0b010000011110: case 0b010000011111: case 0b010000100000: case 0b010000100001: case 0b010000100010: case 0b010000100011: case 0b010000100100: case 0b010000100101: case 0b010000100110: case 0b010000100111: case 0b010000101000: case 0b010000101001: case 0b010000101010: case 0b010000101011: case 0b010000101100: case 0b010000101101: case 0b010000101110: case 0b010000101111: case 0b010000110000: case 0b010000110001: case 0b010000110010: case 0b010000110011: case 0b010000110100: case 0b010000110101: case 0b010000110110: case 0b010000110111: case 0b010000111000: case 0b010000111001: case 0b010000111010: case 0b010000111011: case 0b010000111100: case 0b010000111101: case 0b010000111110: case 0b010000111111: - case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: { // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] - util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", (inst >> 5) & 0x1, (inst >> 4) & 0x1, (inst >> 3) & 0x1, (inst >> 2) & 0x1, inst & 0x1); + const int d = (inst >> 5) & 0x1; + const int g = (inst >> 4) & 0x1; + const int k = (inst >> 3) & 0x1; + const int s = (inst >> 2) & 0x1; + const int n = inst & 0x1; + util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", d, g, k, s, n); break; } + // unused 4xx + // 404 + // case 0b010000000100: case 0b010000000101: case 0b010000000110: case 0b010000000111: case 0b010000001000: case 0b010000001001: case 0b010000001010: case 0b010000001011: case 0b010000001100: case 0b010000001101: case 0b010000001110: case 0b010000001111: case 0b010000010000: case 0b010000010001: case 0b010000010010: case 0b010000010011: case 0b010000010100: case 0b010000010101: case 0b010000010110: case 0b010000010111: case 0b010000011000: case 0b010000011001: case 0b010000011010: case 0b010000011011: case 0b010000011100: case 0b010000011101: case 0b010000011110: case 0b010000011111: case 0b010000100000: case 0b010000100001: case 0b010000100010: case 0b010000100011: case 0b010000100100: case 0b010000100101: case 0b010000100110: case 0b010000100111: case 0b010000101000: case 0b010000101001: case 0b010000101010: case 0b010000101011: case 0b010000101100: case 0b010000101101: case 0b010000101110: case 0b010000101111: case 0b010000110000: case 0b010000110001: case 0b010000110010: case 0b010000110011: case 0b010000110100: case 0b010000110101: case 0b010000110110: case 0b010000110111: case 0b010000111000: case 0b010000111001: case 0b010000111010: case 0b010000111011: case 0b010000111100: case 0b010000111101: case 0b010000111110: case 0b010000111111: // 442 // case 0b010001000010: case 0b010001000011: case 0b010001000110: case 0b010001000111: case 0b010001001010: case 0b010001001011: case 0b010001001110: case 0b010001001111: case 0b010001010010: case 0b010001010011: case 0b010001010110: case 0b010001010111: case 0b010001011010: case 0b010001011011: case 0b010001011110: case 0b010001011111: case 0b010001100010: case 0b010001100011: case 0b010001100110: case 0b010001100111: case 0b010001101010: case 0b010001101011: case 0b010001101110: case 0b010001101111: case 0b010001110010: case 0b010001110011: case 0b010001110110: case 0b010001110111: case 0b010001111010: case 0b010001111011: case 0b010001111110: case 0b010001111111: From 68683084cd2951bfa98d5bd0acc367a999578c98 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 17:52:36 +0000 Subject: [PATCH 32/62] small comment fix --- src/devices/cpu/upd777/upd777dasm.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 12952c6f772e0..fb3bc483a8fd5 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -53,7 +53,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u } else if (inst >= 0x4c0 && inst <= 0x4ff) // 4c0 - 4ff { - // H[5:1]+K[5:1]H[5:1], Skip if carry + // H[5:1]+K[5:1]->H[5:1], Skip if carry const int k = inst & 0x1f; util::stream_format(stream, "H+0x%02x->H CAJ", k); } @@ -164,7 +164,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u } case 0b000001001010: { - // 04a Skip if (Vertical Blank) = 1, 0M[[18:00],[3]][1] + // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] util::stream_format(stream, "VBLK"); break; } @@ -281,7 +281,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] @@ -301,7 +301,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] - // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] @@ -317,7 +317,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] From b8a36a5ea25c44fe0f7dc0d831b9948db47d5786 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Tue, 2 Jan 2024 18:03:14 +0000 Subject: [PATCH 33/62] add dates in the softlist --- hash/cassvisn_cart.xml | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index b437a2de59d36..74228678a061d 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -36,7 +36,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Yosaku - 1981 + 1981 Epoch @@ -50,7 +50,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Baseball - 1981 + 1981 Epoch @@ -65,7 +65,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Galaxian - 1981 + 1981 Epoch @@ -79,7 +79,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Big Sports 12 - 1981 + 1982 Epoch @@ -94,7 +94,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Battle Vader - 1981 + 1982 Epoch @@ -108,7 +108,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 PakPak Monster - 1981 + 1982 Epoch @@ -122,7 +122,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 New Baseball - 1981 + 1982 Epoch @@ -136,7 +136,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Monster Mansion - 1981 + 1982 Epoch @@ -150,7 +150,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Astro Command - 1981 + 1982 Epoch @@ -164,7 +164,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Monster Block - 1981 + 1984 Epoch @@ -178,7 +178,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Elevator Panic - 1981 + 1984 Epoch From 87844d46b524729e2b19c820c8b828f453c82ece Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 16:01:50 +0000 Subject: [PATCH 34/62] remove commented out case lines (which are too long) but I'm happy with the case structure otherwise. --- src/devices/cpu/upd777/upd777dasm.cpp | 122 ++------------------------ 1 file changed, 9 insertions(+), 113 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index fb3bc483a8fd5..44b367061d453 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -199,34 +199,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // unused < 0x80 cases - // case 0b000000000001: case 0b000000000010: case 0b000000000011: - // case 0b000000000101: case 0b000000000110: case 0b000000000111: - // case 0b000000001001: case 0b000000001010: case 0b000000001011: case 0b000000001100: case 0b000000001101: case 0b000000001110: case 0b000000001111: case 0b000000010000: case 0b000000010001: case 0b000000010010: case 0b000000010011: case 0b000000010100: case 0b000000010101: case 0b000000010110: case 0b000000010111: - // case 0b000000011001: case 0b000000011010: case 0b000000011011: case 0b000000011100: case 0b000000011101: case 0b000000011110: case 0b000000011111: - // case 0b000000100001: case 0b000000100010: case 0b000000100011: case 0b000000100100: case 0b000000100101: case 0b000000100110: case 0b000000100111: - // case 0b000000101010: case 0b000000101011: case 0b000000101100: case 0b000000101101: case 0b000000101110: case 0b000000101111: - // unused instructions after the PDx J and PDx /J opcodes - // case 0b000000110001: case 0b000000110010: case 0b000000110011: - // case 0b000000110101: case 0b000000110110: case 0b000000110111: - // case 0b000000111001: case 0b000000111010: case 0b000000111011: - // case 0b000000111101: case 0b000000111110: case 0b000000111111: - // - // case 0b000001110001: case 0b000001110010: case 0b000001110011: - // case 0b000001110101: case 0b000001110110: case 0b000001110111: - // case 0b000001111001: case 0b000001111010: case 0b000001111011: - // case 0b000001111101: case 0b000001111110: case 0b000001111111: - // case 0b000001000000: case 0b000001000001: case 0b000001000010: case 0b000001000011: case 0b000001000100: case 0b000001000101: case 0b000001000110: case 0b000001000111: case 0b000001001000: - // case 0b000001001011: - // case 0b000001001101: case 0b000001001110: case 0b000001001111: case 0b000001010000: case 0b000001010001: case 0b000001010010: case 0b000001010011: - // case 0b000001010101: case 0b000001010110: case 0b000001010111: - // case 0b000001011001: case 0b000001011010: case 0b000001011011: - // case 0b000001011101: case 0b000001011110: case 0b000001011111: - // case 0b000001100001: case 0b000001100010: case 0b000001100011: case 0b000001100100: case 0b000001100101: case 0b000001100110: case 0b000001100111: case 0b000001101000: case 0b000001101001: case 0b000001101010: case 0b000001101011: case 0b000001101100: case 0b000001101101: case 0b000001101110: case 0b000001101111: - - ///////////////////////////////////////////////////////////////////////////////////////////////////// - ///////////////////////////////////////////////////////////////////////////////////////////////////// - case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: @@ -338,28 +310,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // unused 2xx - these would be 'invalid' optype - // 204, 224, 214, 234, 244, 264, 254, 274, 284, 2a4, 294, 2b4, 2c4, 2e4, 2d4, 2f4 - // case 0b001000000100: case 0b001000000101: case 0b001000000110: case 0b001000000111: - // case 0b001000100100: case 0b001000100101: case 0b001000100110: case 0b001000100111: - // case 0b001000010100: case 0b001000010101: case 0b001000010110: case 0b001000010111: - // case 0b001000110100: case 0b001000110101: case 0b001000110110: case 0b001000110111: - // case 0b001001000100: case 0b001001000101: case 0b001001000110: case 0b001001000111: - // case 0b001001100100: case 0b001001100101: case 0b001001100110: case 0b001001100111: - // case 0b001001010100: case 0b001001010101: case 0b001001010110: case 0b001001010111: - // case 0b001001110100: case 0b001001110101: case 0b001001110110: case 0b001001110111: - // case 0b001010000100: case 0b001010000101: case 0b001010000110: case 0b001010000111: - // case 0b001010100100: case 0b001010100101: case 0b001010100110: case 0b001010100111: - // case 0b001010010100: case 0b001010010101: case 0b001010010110: case 0b001010010111: - // case 0b001010110100: case 0b001010110101: case 0b001010110110: case 0b001010110111: - // case 0b001011000100: case 0b001011000101: case 0b001011000110: case 0b001011000111: - // case 0b001011100100: case 0b001011100101: case 0b001011100110: case 0b001011100111: - // case 0b001011010100: case 0b001011010101: case 0b001011010110: case 0b001011010111: - // case 0b001011110100: case 0b001011110101: case 0b001011110110: case 0b001011110111: - - ///////////////////////////////////////////////////////////////////////////////////////////////////// - ///////////////////////////////////////////////////////////////////////////////////////////////////// - case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: { // 300 N->L[2:1] @@ -368,9 +318,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001100001000: { // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] @@ -390,9 +337,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001100001001: { // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] @@ -412,9 +356,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001100001010: case 0b001100001011: { // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] @@ -437,9 +378,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: { // 310 Move A2[7:1] to A1[7:1], N->L[2:1] @@ -455,13 +393,9 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - - // 318 case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: { - // Right shift A1[7:1], 0->A1[7], N->L[2:1] + // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] const int n = inst & 0x3; util::stream_format(stream, "A1->RS, 0x%d->L", n); break; @@ -481,9 +415,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: { // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] @@ -499,9 +430,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ///////////////////////////////////////////////////// - ///////////////////////////////////////////////////// - case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: case 0b001100101000: case 0b001100101001: case 0b001100101010: case 0b001100101011: @@ -543,9 +471,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: case 0b001110010000: case 0b001110010001: case 0b001110010010: case 0b001110010011: { @@ -579,9 +504,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001110100000: case 0b001110100001: case 0b001110100010: case 0b001110100011: case 0b001110100100: case 0b001110100101: case 0b001110100110: case 0b001110100111: case 0b001110101000: case 0b001110101001: case 0b001110101010: case 0b001110101011: @@ -606,9 +528,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001111100000: case 0b001111100001: case 0b001111100010: case 0b001111100011: case 0b001111100100: case 0b001111100101: case 0b001111100110: case 0b001111100111: case 0b001111101000: case 0b001111101001: case 0b001111101010: case 0b001111101011: @@ -633,9 +552,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - ////////////////////////////////////////// - ////////////////////////////////////////// - case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: { @@ -657,27 +573,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // unused 3xx - // 304 - // case 0b001100000100: case 0b001100000101: case 0b001100000110: case 0b001100000111: - // 344 - // case 0b001101000100: case 0b001101000101: case 0b001101000110: case 0b001101000111: - // 30c - //case 0b001100001100: case 0b001100001101: case 0b001100001110: case 0b001100001111: - // 314 - //case 0b001100010100: case 0b001100010101: case 0b001100010110: case 0b001100010111: - // 350 - // case 0b001101010000: case 0b001101010001: case 0b001101010010: case 0b001101010011: - // case 0b001101010100: case 0b001101010101: case 0b001101010110: case 0b001101010111: - // 35c - // case 0b001101011100: case 0b001101011101: case 0b001101011110: case 0b001101011111: - // case 0b001111000100: case 0b001111000101: case 0b001111000110: case 0b001111000111: - // case 0b001111001000: case 0b001111001001: case 0b001111001010: case 0b001111001011: - // case 0b001111010100: case 0b001111010101: case 0b001111010110: case 0b001111010111: - // case 0b001111011000: case 0b001111011001: case 0b001111011010: case 0b001111011011: - - ////////////////////////////////////////////////////////////////////////////////////////////// - case 0b010000000000: case 0b010000000001: { // 400 N->A[11] @@ -692,7 +587,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "JPM, 0->L, %d->A11", n); break; } - case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: + case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: + case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: + case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: + case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: + case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: + case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: + case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: + case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: { // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] const int d = (inst >> 5) & 0x1; @@ -704,12 +606,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - // unused 4xx - // 404 - // case 0b010000000100: case 0b010000000101: case 0b010000000110: case 0b010000000111: case 0b010000001000: case 0b010000001001: case 0b010000001010: case 0b010000001011: case 0b010000001100: case 0b010000001101: case 0b010000001110: case 0b010000001111: case 0b010000010000: case 0b010000010001: case 0b010000010010: case 0b010000010011: case 0b010000010100: case 0b010000010101: case 0b010000010110: case 0b010000010111: case 0b010000011000: case 0b010000011001: case 0b010000011010: case 0b010000011011: case 0b010000011100: case 0b010000011101: case 0b010000011110: case 0b010000011111: case 0b010000100000: case 0b010000100001: case 0b010000100010: case 0b010000100011: case 0b010000100100: case 0b010000100101: case 0b010000100110: case 0b010000100111: case 0b010000101000: case 0b010000101001: case 0b010000101010: case 0b010000101011: case 0b010000101100: case 0b010000101101: case 0b010000101110: case 0b010000101111: case 0b010000110000: case 0b010000110001: case 0b010000110010: case 0b010000110011: case 0b010000110100: case 0b010000110101: case 0b010000110110: case 0b010000110111: case 0b010000111000: case 0b010000111001: case 0b010000111010: case 0b010000111011: case 0b010000111100: case 0b010000111101: case 0b010000111110: case 0b010000111111: - // 442 - // case 0b010001000010: case 0b010001000011: case 0b010001000110: case 0b010001000111: case 0b010001001010: case 0b010001001011: case 0b010001001110: case 0b010001001111: case 0b010001010010: case 0b010001010011: case 0b010001010110: case 0b010001010111: case 0b010001011010: case 0b010001011011: case 0b010001011110: case 0b010001011111: case 0b010001100010: case 0b010001100011: case 0b010001100110: case 0b010001100111: case 0b010001101010: case 0b010001101011: case 0b010001101110: case 0b010001101111: case 0b010001110010: case 0b010001110011: case 0b010001110110: case 0b010001110111: case 0b010001111010: case 0b010001111011: case 0b010001111110: case 0b010001111111: - default: { util::stream_format(stream, "%04x ", inst); From bce957721b551926f809893c85d141b22362d768 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 17:58:18 +0000 Subject: [PATCH 35/62] address legitimate feedback --- hash/cassvisn_cart.xml | 22 +- src/devices/cpu/upd777/upd777.cpp | 18 +- src/devices/cpu/upd777/upd777.h | 1 + src/devices/cpu/upd777/upd777dasm.cpp | 358 ++++++++++++++------------ src/devices/cpu/upd777/upd777dasm.h | 10 +- src/mame/epoch/cassvisn.cpp | 28 +- 6 files changed, 251 insertions(+), 186 deletions(-) diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index 74228678a061d..0b28b66b5ba62 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -40,7 +40,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -54,7 +54,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -69,7 +69,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -83,7 +83,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -98,7 +98,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -112,7 +112,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -126,7 +126,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -140,7 +140,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -154,7 +154,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -168,7 +168,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + @@ -182,7 +182,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 Epoch - + diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 0dc794189f956..9c66eedf707c7 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -49,6 +49,20 @@ void upd777_device::internal_data_map(address_map &map) { } +void upd777_device::increment_pc() +{ + u16 lowpc = m_pc & 0x07f; + u16 highpc = m_pc & 0x780; + + const int top1 = (lowpc & 0x40) >> 6; + const int top2 = (lowpc & 0x20) >> 5; + const int nor = (top1 ^ top2) ^ 1; + lowpc = (lowpc << 1) | nor; + lowpc &= 0x7f; + + m_pc = highpc | lowpc; +} + void upd777_device::device_start() { space(AS_PROGRAM).specific(m_space); @@ -70,7 +84,9 @@ void upd777_device::device_reset() u16 upd777_device::fetch() { - return m_space.read_word(m_pc++); + u16 opcode = m_space.read_word(m_pc); + increment_pc(); + return opcode; } void upd777_device::do_op() diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index cfbe849b75694..213c1f1ddbdf0 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -39,6 +39,7 @@ class upd777_device : public cpu_device memory_access<11, 1, -1, ENDIANNESS_LITTLE>::specific m_space; memory_access<8, 0, 0, ENDIANNESS_LITTLE>::specific m_data; + void increment_pc(); u16 fetch(); void do_op(); diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 44b367061d453..1b719a1ed6a1c 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -22,56 +22,94 @@ upd777_disassembler::upd777_disassembler() m_r2l[0x7f] = 0x7f; } + +std::string upd777_disassembler::get_300optype_name(int optype) +{ + switch (optype) + { + case 0x00: return "·"; // 'AND' + case 0x01: return "+"; + case 0x02: return "v"; // 'OR' + case 0x03: return "-"; + } + return ""; +} + +std::string upd777_disassembler::get_200optype_name(int optype) +{ + switch (optype) + { + case 0x00: return "·"; // 'AND' + case 0x01: return ""; + case 0x02: return "="; + case 0x03: return "-"; + } + return ""; +} + +std::string upd777_disassembler::get_reg_name(int reg) +{ + switch (reg) + { + case 0x00: return "A1"; // general reg A1 + case 0x01: return "A2"; // general reg A2 + case 0x02: return "M"; // content of memory + case 0x03: return "H"; // high address + } + return ""; +} + offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const upd777_disassembler::data_buffer &opcodes, const upd777_disassembler::data_buffer ¶ms) { u16 inst = opcodes.r16(pc); - if (inst >= 0x080 && inst <= 0x0ff) + if (inst >= 0b0000'0000'0000 && inst <= 0b0000'1111'1111) { - // Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow + // 000 - 0ff Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow const int k = inst & 0x7f; util::stream_format(stream, "M-0x%02x", k); } - else if (inst >= 0x100 && inst <= 0x17f) + else if (inst >= 0b0001'0000'0000 && inst <= 0b0001'0111'1111) { - // M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] + // 100-17f M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] const int k = inst & 0x1f; const int n = (inst >> 5) & 0x3; util::stream_format(stream, "M+0x%02x->M, 0x%d->L", k, n); } - else if (inst >= 0x180 && inst <= 0x1ff) + else if (inst >= 0b0001'1000'0000 && inst <= 0b0001'1111'1111) { - // M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] + // 180-1ff M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] const int k = inst & 0x1f; const int n = (inst >> 5) & 0x3; util::stream_format(stream, "M-0x%02x->M, 0x%d->L", k, n); } - else if (inst >= 0x480 && inst <= 0x4bf) // 480 - 4bf + else if (inst >= 0b0100'1000'0000 && inst <= 0b0100'1011'1111) { - // H[5:1]-K[5:1]->H[5:1], Skip if borrow + // 480-4bf H[5:1]-K[5:1]->H[5:1], Skip if borrow util::stream_format(stream, "H-0x%02x->H BOJ", inst & 0x1f); } - else if (inst >= 0x4c0 && inst <= 0x4ff) // 4c0 - 4ff + else if (inst >= 0b0100'1100'0000 && inst <= 0b0100'1111'1111) { - // H[5:1]+K[5:1]->H[5:1], Skip if carry + // 4c0 - 4ff H[5:1]+K[5:1]->H[5:1], Skip if carry const int k = inst & 0x1f; util::stream_format(stream, "H+0x%02x->H CAJ", k); } - else if (inst >= 0x500 && inst <= 0x57f) // 500 - 57f + else if (inst >= 0b0101'0000'0000 && inst <= 0b0101'0111'1111) { + // 500 - 57f // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] const int k = inst & 0x7f; util::stream_format(stream, "0x%02x->M", k); } - else if (inst >= 0x580 && inst <= 0x5ff) // 580 - 5ff + else if (inst >= 0b0101'1000'0000 && inst <= 0b0101'1111'1111) { - // Store K[7:6] to L[2:1] and K[5:1] to H[5:1] + // 580 - 5ff Store K[7:6] to L[2:1] and K[5:1] to H[5:1] const int k = inst & 0x7f; util::stream_format(stream, "0x%02x->L,H", k); } - else if (inst >= 0x600 && inst <= 0x7ff) // 600 - 7ff + else if (inst >= 0b0110'0000'0000 && inst <= 0b0111'1111'1111) { // 600-67f Store K[7:1] to A1[7:1] // 680-6ff Store K[7:1] to A2[7:1] @@ -81,15 +119,15 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int k = inst & 0x7f; util::stream_format(stream, "0x%02x->A%d", k, reg+1); } - else if (inst >= 0x800 && inst < 0xc00) // 800 - bff + else if (inst >= 0b1000'0000'0000 && inst <= 0b1011'1111'1111) { - // Move K[10:1] to A[10:1], Jump to A[11:1] + // 800 - bff Move K[10:1] to A[10:1], Jump to A[11:1] u16 fulladdress = (pc & 0x400) | (inst & 0x3ff); util::stream_format(stream, "JP 0x%03x (%01x:%02x)", fulladdress, (fulladdress & 0x780)>>7, inst & 0x07f); } - else if (inst >= 0xc00 && inst < 0x1000) // c00 - fff + else if (inst >= 0b1100'0000'0000 && inst <= 0b1111'1111'1111) { - // Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack + // c00 - fff Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack const int k = inst & 0x3ff; util::stream_format(stream, "JS 0x%03x (%01x:%02x)", k & 0x3ff, (k & 0x380)>>7, k & 0x07f); } @@ -97,51 +135,51 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { switch (inst) { - case 0b000000000000: + case 0b0000'0000'0000: { // 000 No Operation util::stream_format(stream, "NOP"); break; } - case 0b000000000100: + case 0b0000'0000'0100: { // 004 Skip if (Gun Port Latch) = 1 util::stream_format(stream, "GPL"); break; } - case 0b000000001000: + case 0b0000'0000'1000: { // 008 Move H[5:1] to Line Buffer Register[5:1] util::stream_format(stream, "H->NRM"); break; } - case 0b000000011000: + case 0b0000'0001'1000: { // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] util::stream_format(stream, "H<->X"); break; } - case 0b000000100000: + case 0b0000'0010'0000: { // 020 Subroutine End, Pop down address stack util::stream_format(stream, "SRE"); break; } - case 0b000000101000: case 0b000000101001: + case 0b0000'0010'1000: case 0b0000'0010'1001: { // 028 Shift STB[4:1], N->STB[1] const int n = inst & 1; util::stream_format(stream, "0x%d->STB", n); break; } - case 0b000000110000: - case 0b000000110100: - case 0b000000111000: - case 0b000000111100: - case 0b000001110000: - case 0b000001110100: - case 0b000001111000: - case 0b000001111100: + case 0b0000'0011'0000: + case 0b0000'0011'0100: + case 0b0000'0011'1000: + case 0b0000'0011'1100: + case 0b0000'0111'0000: + case 0b0000'0111'0100: + case 0b0000'0111'1000: + case 0b0000'0111'1100: { // 30 Skip if (PD1 input) = 1 // 34 Skip if (PD2 input) = 1 @@ -156,97 +194,97 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "PD%d %sJ", which + 1, inv ? "/" : ""); break; } - case 0b000001001001: + case 0b0000'0100'1001: { // 049 Skip if (4H Horizontal Blank) = 1 util::stream_format(stream, "4H BLK"); break; } - case 0b000001001010: + case 0b0000'0100'1010: { // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] util::stream_format(stream, "VBLK"); break; } - case 0b000001001100: + case 0b0000'0100'1100: { // 04c Skip if (GP&SW/ input) = 1 util::stream_format(stream, "GPSW/"); break; } - case 0b000001010100: + case 0b0000'0101'0100: { // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] util::stream_format(stream, "A->MA"); break; } - case 0b000001011000: + case 0b0000'0101'1000: { // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) util::stream_format(stream, "MA->A"); break; } - case 0b000001011100: + case 0b0000'0101'1100: { // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] util::stream_format(stream, "MA<->A"); break; } - case 0b000001100000: + case 0b0000'0110'0000: { // 060 Subroutine End, Pop down address stack, Skip util::stream_format(stream, "SRE+1"); break; } - case 0b001000000000: case 0b001000000001: case 0b001000000010: case 0b001000000011: - case 0b001000100000: case 0b001000100001: case 0b001000100010: case 0b001000100011: - case 0b001000001000: case 0b001000001001: case 0b001000001010: case 0b001000001011: - case 0b001000101000: case 0b001000101001: case 0b001000101010: case 0b001000101011: - case 0b001000001100: case 0b001000001101: case 0b001000001110: case 0b001000001111: - case 0b001000101100: case 0b001000101101: case 0b001000101110: case 0b001000101111: - case 0b001000010000: case 0b001000010001: case 0b001000010010: case 0b001000010011: - case 0b001000110000: case 0b001000110001: case 0b001000110010: case 0b001000110011: - case 0b001000011000: case 0b001000011001: case 0b001000011010: case 0b001000011011: - case 0b001000111000: case 0b001000111001: case 0b001000111010: case 0b001000111011: - case 0b001000011100: case 0b001000011101: case 0b001000011110: case 0b001000011111: - case 0b001000111100: case 0b001000111101: case 0b001000111110: case 0b001000111111: - case 0b001001000000: case 0b001001000001: case 0b001001000010: case 0b001001000011: - case 0b001001100000: case 0b001001100001: case 0b001001100010: case 0b001001100011: - case 0b001001001000: case 0b001001001001: case 0b001001001010: case 0b001001001011: - case 0b001001101000: case 0b001001101001: case 0b001001101010: case 0b001001101011: - case 0b001001001100: case 0b001001001101: case 0b001001001110: case 0b001001001111: - case 0b001001101100: case 0b001001101101: case 0b001001101110: case 0b001001101111: - case 0b001001010000: case 0b001001010001: case 0b001001010010: case 0b001001010011: - case 0b001001110000: case 0b001001110001: case 0b001001110010: case 0b001001110011: - case 0b001001011000: case 0b001001011001: case 0b001001011010: case 0b001001011011: - case 0b001001111000: case 0b001001111001: case 0b001001111010: case 0b001001111011: - case 0b001001011100: case 0b001001011101: case 0b001001011110: case 0b001001011111: - case 0b001001111100: case 0b001001111101: case 0b001001111110: case 0b001001111111: - case 0b001010000000: case 0b001010000001: case 0b001010000010: case 0b001010000011: - case 0b001010100000: case 0b001010100001: case 0b001010100010: case 0b001010100011: - case 0b001010001000: case 0b001010001001: case 0b001010001010: case 0b001010001011: - case 0b001010101000: case 0b001010101001: case 0b001010101010: case 0b001010101011: - case 0b001010001100: case 0b001010001101: case 0b001010001110: case 0b001010001111: - case 0b001010101100: case 0b001010101101: case 0b001010101110: case 0b001010101111: - case 0b001010010000: case 0b001010010001: case 0b001010010010: case 0b001010010011: - case 0b001010110000: case 0b001010110001: case 0b001010110010: case 0b001010110011: - case 0b001010011000: case 0b001010011001: case 0b001010011010: case 0b001010011011: - case 0b001010111000: case 0b001010111001: case 0b001010111010: case 0b001010111011: - case 0b001010011100: case 0b001010011101: case 0b001010011110: case 0b001010011111: - case 0b001010111100: case 0b001010111101: case 0b001010111110: case 0b001010111111: - case 0b001011000000: case 0b001011000001: case 0b001011000010: case 0b001011000011: - case 0b001011100000: case 0b001011100001: case 0b001011100010: case 0b001011100011: - case 0b001011001000: case 0b001011001001: case 0b001011001010: case 0b001011001011: - case 0b001011101000: case 0b001011101001: case 0b001011101010: case 0b001011101011: - case 0b001011001100: case 0b001011001101: case 0b001011001110: case 0b001011001111: - case 0b001011101100: case 0b001011101101: case 0b001011101110: case 0b001011101111: - case 0b001011010000: case 0b001011010001: case 0b001011010010: case 0b001011010011: - case 0b001011110000: case 0b001011110001: case 0b001011110010: case 0b001011110011: - case 0b001011011000: case 0b001011011001: case 0b001011011010: case 0b001011011011: - case 0b001011111000: case 0b001011111001: case 0b001011111010: case 0b001011111011: - case 0b001011011100: case 0b001011011101: case 0b001011011110: case 0b001011011111: - case 0b001011111100: case 0b001011111101: case 0b001011111110: case 0b001011111111: + case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: + case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: + case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: + case 0b0010'0010'1000: case 0b0010'0010'1001: case 0b0010'0010'1010: case 0b0010'0010'1011: + case 0b0010'0000'1100: case 0b0010'0000'1101: case 0b0010'0000'1110: case 0b0010'0000'1111: + case 0b0010'0010'1100: case 0b0010'0010'1101: case 0b0010'0010'1110: case 0b0010'0010'1111: + case 0b0010'0001'0000: case 0b0010'0001'0001: case 0b0010'0001'0010: case 0b0010'0001'0011: + case 0b0010'0011'0000: case 0b0010'0011'0001: case 0b0010'0011'0010: case 0b0010'0011'0011: + case 0b0010'0001'1000: case 0b0010'0001'1001: case 0b0010'0001'1010: case 0b0010'0001'1011: + case 0b0010'0011'1000: case 0b0010'0011'1001: case 0b0010'0011'1010: case 0b0010'0011'1011: + case 0b0010'0001'1100: case 0b0010'0001'1101: case 0b0010'0001'1110: case 0b0010'0001'1111: + case 0b0010'0011'1100: case 0b0010'0011'1101: case 0b0010'0011'1110: case 0b0010'0011'1111: + case 0b0010'0100'0000: case 0b0010'0100'0001: case 0b0010'0100'0010: case 0b0010'0100'0011: + case 0b0010'0110'0000: case 0b0010'0110'0001: case 0b0010'0110'0010: case 0b0010'0110'0011: + case 0b0010'0100'1000: case 0b0010'0100'1001: case 0b0010'0100'1010: case 0b0010'0100'1011: + case 0b0010'0110'1000: case 0b0010'0110'1001: case 0b0010'0110'1010: case 0b0010'0110'1011: + case 0b0010'0100'1100: case 0b0010'0100'1101: case 0b0010'0100'1110: case 0b0010'0100'1111: + case 0b0010'0110'1100: case 0b0010'0110'1101: case 0b0010'0110'1110: case 0b0010'0110'1111: + case 0b0010'0101'0000: case 0b0010'0101'0001: case 0b0010'0101'0010: case 0b0010'0101'0011: + case 0b0010'0111'0000: case 0b0010'0111'0001: case 0b0010'0111'0010: case 0b0010'0111'0011: + case 0b0010'0101'1000: case 0b0010'0101'1001: case 0b0010'0101'1010: case 0b0010'0101'1011: + case 0b0010'0111'1000: case 0b0010'0111'1001: case 0b0010'0111'1010: case 0b0010'0111'1011: + case 0b0010'0101'1100: case 0b0010'0101'1101: case 0b0010'0101'1110: case 0b0010'0101'1111: + case 0b0010'0111'1100: case 0b0010'0111'1101: case 0b0010'0111'1110: case 0b0010'0111'1111: + case 0b0010'1000'0000: case 0b0010'1000'0001: case 0b0010'1000'0010: case 0b0010'1000'0011: + case 0b0010'1010'0000: case 0b0010'1010'0001: case 0b0010'1010'0010: case 0b0010'1010'0011: + case 0b0010'1000'1000: case 0b0010'1000'1001: case 0b0010'1000'1010: case 0b0010'1000'1011: + case 0b0010'1010'1000: case 0b0010'1010'1001: case 0b0010'1010'1010: case 0b0010'1010'1011: + case 0b0010'1000'1100: case 0b0010'1000'1101: case 0b0010'1000'1110: case 0b0010'1000'1111: + case 0b0010'1010'1100: case 0b0010'1010'1101: case 0b0010'1010'1110: case 0b0010'1010'1111: + case 0b0010'1001'0000: case 0b0010'1001'0001: case 0b0010'1001'0010: case 0b0010'1001'0011: + case 0b0010'1011'0000: case 0b0010'1011'0001: case 0b0010'1011'0010: case 0b0010'1011'0011: + case 0b0010'1001'1000: case 0b0010'1001'1001: case 0b0010'1001'1010: case 0b0010'1001'1011: + case 0b0010'1011'1000: case 0b0010'1011'1001: case 0b0010'1011'1010: case 0b0010'1011'1011: + case 0b0010'1001'1100: case 0b0010'1001'1101: case 0b0010'1001'1110: case 0b0010'1001'1111: + case 0b0010'1011'1100: case 0b0010'1011'1101: case 0b0010'1011'1110: case 0b0010'1011'1111: + case 0b0010'1100'0000: case 0b0010'1100'0001: case 0b0010'1100'0010: case 0b0010'1100'0011: + case 0b0010'1110'0000: case 0b0010'1110'0001: case 0b0010'1110'0010: case 0b0010'1110'0011: + case 0b0010'1100'1000: case 0b0010'1100'1001: case 0b0010'1100'1010: case 0b0010'1100'1011: + case 0b0010'1110'1000: case 0b0010'1110'1001: case 0b0010'1110'1010: case 0b0010'1110'1011: + case 0b0010'1100'1100: case 0b0010'1100'1101: case 0b0010'1100'1110: case 0b0010'1100'1111: + case 0b0010'1110'1100: case 0b0010'1110'1101: case 0b0010'1110'1110: case 0b0010'1110'1111: + case 0b0010'1101'0000: case 0b0010'1101'0001: case 0b0010'1101'0010: case 0b0010'1101'0011: + case 0b0010'1111'0000: case 0b0010'1111'0001: case 0b0010'1111'0010: case 0b0010'1111'0011: + case 0b0010'1101'1000: case 0b0010'1101'1001: case 0b0010'1101'1010: case 0b0010'1101'1011: + case 0b0010'1111'1000: case 0b0010'1111'1001: case 0b0010'1111'1010: case 0b0010'1111'1011: + case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: + case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: { // optype · // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] @@ -306,11 +344,11 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int reg1 = (inst & 0xc0) >> 6; const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - util::stream_format(stream, "%s%s%s, 0x%d->L %s%s", m_200_reg1[reg1], m_200_optypes[optype], m_200_reg2[reg2], n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); + util::stream_format(stream, "%s%s%s, 0x%d->L %s%s", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); break; } - case 0b001100000000: case 0b001100000001: case 0b001100000010: case 0b001100000011: + case 0b0011'0000'0000: case 0b0011'0000'0001: case 0b0011'0000'0010: case 0b0011'0000'0011: { // 300 N->L[2:1] const int n = inst & 0x3; @@ -318,59 +356,59 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b001100001000: + case 0b0011'0000'1000: { // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A1->FLS, 0->L"); break; } - case 0b001101001000: + case 0b0011'0100'1000: { // 348 Move A2[7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "A2->FLS, 0->L"); break; } - case 0b001110001000: + case 0b0011'1000'1000: { // 388 Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] util::stream_format(stream, "M->FLS, 0->L"); break; } - case 0b001100001001: + case 0b0011'0000'1001: { // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "A1->FRS, 1->L"); break; } - case 0b001101001001: + case 0b0011'0100'1001: { // 349 Move A2[7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "A2->FRS, 1->L"); break; } - case 0b001110001001: + case 0b0011'1000'1001: { // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "M->FRS, 1->L"); break; } - case 0b001100001010: case 0b001100001011: + case 0b0011'0000'1010: case 0b0011'0000'1011: { // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; util::stream_format(stream, "A1->MODE, 0x%d->L", n); break; } - case 0b001101001010: case 0b001101001011: + case 0b0011'01001010: case 0b0011'0100'1011: { // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; util::stream_format(stream, "A2->MODE, 0x%d->L", n); break; } - case 0b001110001010: case 0b001110001011: + case 0b0011'1000'1010: case 0b00111000'1011: { // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; @@ -378,14 +416,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b001100010000: case 0b001100010001: case 0b001100010010: case 0b001100010011: + case 0b0011'0001'0000: case 0b0011'0001'0001: case 0b0011'0001'0010: case 0b0011'0001'0011: { // 310 Move A2[7:1] to A1[7:1], N->L[2:1] const int n = inst & 0x3; util::stream_format(stream, "A2->A1, 0x%d->L", n); break; } - case 0b001101000000: case 0b001101000001: case 0b001101000010: case 0b001101000011: + case 0b0011'0100'0000: case 0b0011'0100'0001: case 0b0011'0100'0010: case 0b0011'0100'0011: { // 340 Move A1[7:1] to A2[7:1], N->L[2:1] const int n = inst & 0x3; @@ -393,21 +431,21 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b001100011000: case 0b001100011001: case 0b001100011010: case 0b001100011011: + case 0b0011'0001'1000: case 0b0011'0001'1001: case 0b0011'0001'1010: case 0b0011'0001'1011: { // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] const int n = inst & 0x3; util::stream_format(stream, "A1->RS, 0x%d->L", n); break; } - case 0b001101011000: case 0b001101011001: case 0b001101011010: case 0b001101011011: + case 0b0011'0101'1000: case 0b0011'0101'1001: case 0b0011'0101'1010: case 0b0011'0101'1011: { // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] const int n = inst & 0x3; util::stream_format(stream, "A2->RS, 0x%d->L", n); break; } - case 0b001110011000: case 0b001110011001: case 0b001110011010: case 0b001110011011: + case 0b0011'1001'1000: case 0b0011'1001'1001: case 0b0011'1001'1010: case 0b0011'1001'1011: { // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] const int n = inst & 0x3; @@ -415,14 +453,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b001100011100: case 0b001100011101: case 0b001100011110: case 0b001100011111: + case 0b0011'0001'1100: case 0b0011'0001'1101: case 0b0011'0001'1110: case 0b0011'0001'1111: { // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] const int n = inst & 0x3; util::stream_format(stream, "A1-A2->A2, 0x%d->L", n); break; } - case 0b001101001100: case 0b001101001101: case 0b001101001110: case 0b001101001111: + case 0b0011'0100'1100: case 0b0011'0100'1101: case 0b0011'0100'1110: case 0b0011'0100'1111: { // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] const int n = inst & 0x3; @@ -430,22 +468,22 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b001100100000: case 0b001100100001: case 0b001100100010: case 0b001100100011: - case 0b001100100100: case 0b001100100101: case 0b001100100110: case 0b001100100111: - case 0b001100101000: case 0b001100101001: case 0b001100101010: case 0b001100101011: - case 0b001100101100: case 0b001100101101: case 0b001100101110: case 0b001100101111: - case 0b001100110000: case 0b001100110001: case 0b001100110010: case 0b001100110011: - case 0b001100110100: case 0b001100110101: case 0b001100110110: case 0b001100110111: - case 0b001100111000: case 0b001100111001: case 0b001100111010: case 0b001100111011: - case 0b001100111100: case 0b001100111101: case 0b001100111110: case 0b001100111111: - case 0b001101100000: case 0b001101100001: case 0b001101100010: case 0b001101100011: - case 0b001101100100: case 0b001101100101: case 0b001101100110: case 0b001101100111: - case 0b001101101000: case 0b001101101001: case 0b001101101010: case 0b001101101011: - case 0b001101101100: case 0b001101101101: case 0b001101101110: case 0b001101101111: - case 0b001101110000: case 0b001101110001: case 0b001101110010: case 0b001101110011: - case 0b001101110100: case 0b001101110101: case 0b001101110110: case 0b001101110111: - case 0b001101111000: case 0b001101111001: case 0b001101111010: case 0b001101111011: - case 0b001101111100: case 0b001101111101: case 0b001101111110: case 0b001101111111: + case 0b0011'0010'0000: case 0b0011'0010'0001: case 0b0011'0010'0010: case 0b0011'0010'0011: + case 0b0011'0010'0100: case 0b0011'0010'0101: case 0b0011'0010'0110: case 0b0011'0010'0111: + case 0b0011'0010'1000: case 0b0011'0010'1001: case 0b0011'0010'1010: case 0b0011'0010'1011: + case 0b0011'0010'1100: case 0b0011'0010'1101: case 0b0011'0010'1110: case 0b0011'0010'1111: + case 0b0011'0011'0000: case 0b0011'0011'0001: case 0b0011'0011'0010: case 0b0011'0011'0011: + case 0b0011'0011'0100: case 0b0011'0011'0101: case 0b0011'0011'0110: case 0b0011'0011'0111: + case 0b0011'0011'1000: case 0b0011'0011'1001: case 0b0011'0011'1010: case 0b0011'0011'1011: + case 0b0011'0011'1100: case 0b0011'0011'1101: case 0b0011'0011'1110: case 0b0011'0011'1111: + case 0b0011'0110'0000: case 0b0011'0110'0001: case 0b0011'0110'0010: case 0b0011'0110'0011: + case 0b0011'0110'0100: case 0b0011'0110'0101: case 0b0011'0110'0110: case 0b0011'0110'0111: + case 0b0011'0110'1000: case 0b0011'0110'1001: case 0b0011'0110'1010: case 0b0011'0110'1011: + case 0b0011'0110'1100: case 0b0011'0110'1101: case 0b0011'0110'1110: case 0b0011'0110'1111: + case 0b0011'0111'0000: case 0b0011'0111'0001: case 0b0011'0111'0010: case 0b0011'0111'0011: + case 0b0011'0111'0100: case 0b0011'0111'0101: case 0b0011'0111'0110: case 0b0011'0111'0111: + case 0b0011'0111'1000: case 0b0011'0111'1001: case 0b0011'0111'1010: case 0b0011'0111'1011: + case 0b0011'0111'1100: case 0b0011'0111'1101: case 0b0011'0111'1110: case 0b0011'0111'1111: { // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] @@ -467,12 +505,12 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int reg2 = (inst & 0x10) >> 4; const int reg1 = (inst & 0x40) >> 6; const int n = inst & 0x3; - util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", m_320_reg[reg1], m_320_optypes[optype], m_320_reg[reg2], m_320_reg[reg1], n, (optype == 3) ? "BOJ" : ""); + util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", get_reg_name(reg1), get_300optype_name(optype), get_reg_name(reg2), get_reg_name(reg1), n, (optype == 3) ? "BOJ" : ""); break; } - case 0b001110000000: case 0b001110000001: case 0b001110000010: case 0b001110000011: - case 0b001110010000: case 0b001110010001: case 0b001110010010: case 0b001110010011: + case 0b0011'1000'0000: case 0b0011'1000'0001: case 0b0011'1000'0010: case 0b0011'1000'0011: + case 0b0011'1001'0000: case 0b0011'1001'0001: case 0b0011'1001'0010: case 0b0011'1001'0011: { // 380 Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] @@ -482,8 +520,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b001110000100: case 0b001110000101: case 0b001110000110: case 0b001110000111: - case 0b001110010100: case 0b001110010101: case 0b001110010110: case 0b001110010111: + case 0b0011'1000'0100: case 0b0011'1000'0101: case 0b0011'1000'0110: case 0b0011'1000'0111: + case 0b0011'1001'0100: case 0b0011'1001'0101: case 0b0011'1001'0110: case 0b0011'1001'0111: { // 384 Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] @@ -493,8 +531,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b001110001100: case 0b001110001101: case 0b001110001110: case 0b001110001111: - case 0b001110011100: case 0b001110011101: case 0b001110011110: case 0b001110011111: + case 0b0011'1000'1100: case 0b0011'1000'1101: case 0b0011'1000'1110: case 0b0011'1000'1111: + case 0b0011'1001'1100: case 0b0011'1001'1101: case 0b0011'1001'1110: case 0b0011'1001'1111: { // 38c Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] @@ -504,14 +542,14 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b001110100000: case 0b001110100001: case 0b001110100010: case 0b001110100011: - case 0b001110100100: case 0b001110100101: case 0b001110100110: case 0b001110100111: - case 0b001110101000: case 0b001110101001: case 0b001110101010: case 0b001110101011: - case 0b001110101100: case 0b001110101101: case 0b001110101110: case 0b001110101111: - case 0b001110110000: case 0b001110110001: case 0b001110110010: case 0b001110110011: - case 0b001110110100: case 0b001110110101: case 0b001110110110: case 0b001110110111: - case 0b001110111000: case 0b001110111001: case 0b001110111010: case 0b001110111011: - case 0b001110111100: case 0b001110111101: case 0b001110111110: case 0b001110111111: + case 0b0011'1010'0000: case 0b0011'1010'0001: case 0b0011'1010'0010: case 0b0011'1010'0011: + case 0b0011'1010'0100: case 0b0011'1010'0101: case 0b0011'1010'0110: case 0b0011'1010'0111: + case 0b0011'1010'1000: case 0b0011'1010'1001: case 0b0011'1010'1010: case 0b0011'1010'1011: + case 0b0011'1010'1100: case 0b0011'1010'1101: case 0b0011'1010'1110: case 0b0011'1010'1111: + case 0b0011'1011'0000: case 0b0011'1011'0001: case 0b0011'1011'0010: case 0b0011'1011'0011: + case 0b0011'1011'0100: case 0b0011'1011'0101: case 0b0011'1011'0110: case 0b0011'1011'0111: + case 0b0011'1011'1000: case 0b0011'1011'1001: case 0b0011'1011'1010: case 0b0011'1011'1011: + case 0b0011'1011'1100: case 0b0011'1011'1101: case 0b0011'1011'1110: case 0b0011'1011'1111: { // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry @@ -524,18 +562,18 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int optype = (inst & 0x0c) >> 2; const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - util::stream_format(stream, "M%s%s->M, 0x%d->L", m_320_optypes[optype], m_320_reg[reg2], n); + util::stream_format(stream, "M%s%s->M, 0x%d->L", get_300optype_name(optype), get_reg_name(reg2), n); break; } - case 0b001111100000: case 0b001111100001: case 0b001111100010: case 0b001111100011: - case 0b001111100100: case 0b001111100101: case 0b001111100110: case 0b001111100111: - case 0b001111101000: case 0b001111101001: case 0b001111101010: case 0b001111101011: - case 0b001111101100: case 0b001111101101: case 0b001111101110: case 0b001111101111: - case 0b001111110000: case 0b001111110001: case 0b001111110010: case 0b001111110011: - case 0b001111110100: case 0b001111110101: case 0b001111110110: case 0b001111110111: - case 0b001111111000: case 0b001111111001: case 0b001111111010: case 0b001111111011: - case 0b001111111100: case 0b001111111101: case 0b001111111110: case 0b001111111111: + case 0b0011'1110'0000: case 0b0011'1110'0001: case 0b0011'1110'0010: case 0b0011'1110'0011: + case 0b0011'1110'0100: case 0b0011'1110'0101: case 0b0011'1110'0110: case 0b0011'1110'0111: + case 0b0011'1110'1000: case 0b0011'1110'1001: case 0b0011'1110'1010: case 0b0011'1110'1011: + case 0b0011'1110'1100: case 0b0011'1110'1101: case 0b0011'1110'1110: case 0b0011'1110'1111: + case 0b0011'1111'0000: case 0b0011'1111'0001: case 0b0011'1111'0010: case 0b0011'1111'0011: + case 0b0011'1111'0100: case 0b0011'1111'0101: case 0b0011'1111'0110: case 0b0011'1111'0111: + case 0b0011'1111'1000: case 0b0011'1111'1001: case 0b0011'1111'1010: case 0b0011'1111'1011: + case 0b0011'1111'1100: case 0b0011'1111'1101: case 0b0011'1111'1110: case 0b0011'1111'1111: { // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] @@ -548,12 +586,12 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int optype = (inst & 0x0c) >> 2; const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - util::stream_format(stream, "H%s%s->H, 0x%d->L", m_320_optypes[optype], m_320_reg[reg], n); + util::stream_format(stream, "H%s%s->H, 0x%d->L", get_300optype_name(optype), get_reg_name(reg), n); break; } - case 0b001111000000: case 0b001111000001: case 0b001111000010: case 0b001111000011: - case 0b001111010000: case 0b001111010001: case 0b001111010010: case 0b001111010011: + case 0b0011'1100'0000: case 0b0011'1100'0001: case 0b0011'1100'0010: case 0b0011'1100'0011: + case 0b0011'1101'0000: case 0b0011'1101'0001: case 0b0011'1101'0010: case 0b0011'1101'0011: { // 3c0 Move A1[5:1] to H[5:1], N->L[2:1] // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] @@ -562,8 +600,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "A%d->H, 0x%d->L", reg + 1, n); break; } - case 0b001111001100: case 0b001111001101: case 0b001111001110: case 0b001111001111: - case 0b001111011100: case 0b001111011101: case 0b001111011110: case 0b001111011111: + case 0b0011'1100'1100: case 0b0011'1100'1101: case 0b0011'1100'1110: case 0b0011'1100'1111: + case 0b0011'1101'1100: case 0b0011'1101'1101: case 0b0011'1101'1110: case 0b0011'1101'1111: { // 3cc Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] @@ -573,28 +611,28 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b010000000000: case 0b010000000001: + case 0b0100'0000'0000: case 0b0100'0000'0001: { // 400 N->A[11] const int n = inst & 0x1; util::stream_format(stream, "%d->A11", n); break; } - case 0b010000000010: case 0b010000000011: + case 0b0100'0000'0010: case 0b0100'0000'0011: { // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] const int n = inst & 0x1; util::stream_format(stream, "JPM, 0->L, %d->A11", n); break; } - case 0b010001000000: case 0b010001000001: case 0b010001000100: case 0b010001000101: - case 0b010001001000: case 0b010001001001: case 0b010001001100: case 0b010001001101: - case 0b010001010000: case 0b010001010001: case 0b010001010100: case 0b010001010101: - case 0b010001011000: case 0b010001011001: case 0b010001011100: case 0b010001011101: - case 0b010001100000: case 0b010001100001: case 0b010001100100: case 0b010001100101: - case 0b010001101000: case 0b010001101001: case 0b010001101100: case 0b010001101101: - case 0b010001110000: case 0b010001110001: case 0b010001110100: case 0b010001110101: - case 0b010001111000: case 0b010001111001: case 0b010001111100: case 0b010001111101: + case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: + case 0b0100'0100'1000: case 0b0100'0100'1001: case 0b0100'0100'1100: case 0b0100'0100'1101: + case 0b0100'0101'0000: case 0b0100'0101'0001: case 0b0100'0101'0100: case 0b0100'0101'0101: + case 0b0100'0101'1000: case 0b0100'0101'1001: case 0b0100'0101'1100: case 0b0100'0101'1101: + case 0b0100'0110'0000: case 0b0100'0110'0001: case 0b0100'0110'0100: case 0b0100'0110'0101: + case 0b0100'0110'1000: case 0b0100'0110'1001: case 0b0100'0110'1100: case 0b0100'0110'1101: + case 0b0100'0111'0000: case 0b0100'0111'0001: case 0b0100'0111'0100: case 0b0100'0111'0101: + case 0b0100'0111'1000: case 0b0100'0111'1001: case 0b0100'0111'1100: case 0b0100'0111'1101: { // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] const int d = (inst >> 5) & 0x1; diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 5aaa7e1bcd9ed..517304ef47de0 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -26,13 +26,9 @@ class upd777_disassembler : public util::disasm_interface u8 m_l2r[0x80]; u8 m_r2l[0x80]; - std::string m_200_optypes[4] = {"·", "invalid", "=", "-"}; - std::string m_200_reg2[2] = {"A1", "A2" }; - std::string m_200_reg1[4] = {"A1", "A2", "M", "H" }; - - std::string m_320_optypes[4] = {"·", "+", "v", "-"}; - std::string m_320_reg[2] = {"A1", "A2" }; - + std::string get_300optype_name(int optype); + std::string get_200optype_name(int optype); + std::string get_reg_name(int reg); }; #endif // MAME_CPU_UPD777_UPD777DASM_H diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index bbc336e38ffcb..7ca91c5f8ddf6 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -37,7 +37,6 @@ class cassvisn_state : public driver_device void cassvisn(machine_config &config); - void init_cass(); protected: DECLARE_DEVICE_IMAGE_LOAD_MEMBER(cart_load); private: @@ -80,12 +79,31 @@ INPUT_PORTS_END DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) { + if (!image.loaded_through_softlist()) + return std::make_pair(image_error::UNSUPPORTED, "Cartridges must be loaded from the software list"); + uint32_t size = m_cart->common_get_size("prg"); + + if (size != 0xf00) + return std::make_pair(image_error::UNSUPPORTED, "prg region size must be 0xf00 in size"); + m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_LITTLE); m_cart->common_load_rom(m_cart->get_rom_base(), size, "prg"); - memcpy(memregion("maincpu")->base(), m_cart->get_rom_base(), size); + uint8_t* prgbase = memregion("maincpu")->base(); + memcpy(prgbase, m_cart->get_rom_base(), size); + + for (int i = 0; i < size; i += 2) + { + uint8_t temp = prgbase[i + 0]; + prgbase[i + 0] = prgbase[i + 1]; + prgbase[i + 1] = temp; + } size = m_cart->common_get_size("pat"); + + if (size != 0x4d0) + return std::make_pair(image_error::UNSUPPORTED, "pat region size must be 0x4d0 in size"); + m_cart->common_load_rom(memregion("patterns")->base(), size, "pat"); return std::make_pair(std::error_condition(), std::string()); } @@ -118,10 +136,6 @@ ROM_START( cassvisn ) ROM_REGION( 0x4d0, "patterns", ROMREGION_ERASEFF ) ROM_END -void cassvisn_state::init_cass() -{ -} - } // anonymous namespace -CONS( 1981, cassvisn, 0, 0, cassvisn, cassvisn, cassvisn_state, init_cass, "Epoch", "Cassette Vision", MACHINE_IS_SKELETON ) +CONS( 1981, cassvisn, 0, 0, cassvisn, cassvisn, cassvisn_state, empty_init, "Epoch", "Cassette Vision", MACHINE_IS_SKELETON ) From 5376a8eb72d9cb824f2e887907bc547cf7a8bd21 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 18:03:40 +0000 Subject: [PATCH 36/62] use a more dasm friendly character --- src/devices/cpu/upd777/upd777dasm.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 1b719a1ed6a1c..ef48d434e5c16 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -27,7 +27,7 @@ std::string upd777_disassembler::get_300optype_name(int optype) { switch (optype) { - case 0x00: return "·"; // 'AND' + case 0x00: return "."; // 'AND' expressed as '·' in documentation, but disassembler isn't keen on that case 0x01: return "+"; case 0x02: return "v"; // 'OR' case 0x03: return "-"; @@ -39,7 +39,7 @@ std::string upd777_disassembler::get_200optype_name(int optype) { switch (optype) { - case 0x00: return "·"; // 'AND' + case 0x00: return "."; // 'AND' expressed as '·' in documentation, but disassembler isn't keen on that case 0x01: return ""; case 0x02: return "="; case 0x03: return "-"; From d85384f0119d70c48f99a7d49d1e1ba00521dd3c Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 18:07:48 +0000 Subject: [PATCH 37/62] small fix based on docs --- src/devices/cpu/upd777/upd777dasm.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index ef48d434e5c16..8a1475cde4f98 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -63,9 +63,9 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u { u16 inst = opcodes.r16(pc); - if (inst >= 0b0000'0000'0000 && inst <= 0b0000'1111'1111) + if (inst >= 0b0000'1000'0000 && inst <= 0b0000'1111'1111) { - // 000 - 0ff Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow + // 080 - 0ff Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow const int k = inst & 0x7f; util::stream_format(stream, "M-0x%02x", k); } From 7cc9ed5b993873bcd822c8145af7125bf9ddcd68 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 19:34:33 +0000 Subject: [PATCH 38/62] copy the disassembler logic into the execution core, add logged execution stubs. --- src/devices/cpu/upd777/upd777.cpp | 629 +++++++++++++++++++++++++- src/devices/cpu/upd777/upd777.h | 5 + src/devices/cpu/upd777/upd777dasm.cpp | 3 +- 3 files changed, 632 insertions(+), 5 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 9c66eedf707c7..3f70f9f2c9263 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -79,27 +79,648 @@ void upd777_device::device_start() void upd777_device::device_reset() { + m_ppc = 0; m_pc = 0; } u16 upd777_device::fetch() { u16 opcode = m_space.read_word(m_pc); + m_ppc = m_pc; increment_pc(); return opcode; } +// temporary, for the opcode logging +std::string upd777_device::get_300optype_name(int optype) +{ + switch (optype) + { + case 0x00: return "."; // 'AND' expressed as '·' in documentation, but disassembler isn't keen on that + case 0x01: return "+"; + case 0x02: return "v"; // 'OR' + case 0x03: return "-"; + } + return ""; +} + +std::string upd777_device::get_200optype_name(int optype) +{ + switch (optype) + { + case 0x00: return "."; // 'AND' expressed as '·' in documentation, but disassembler isn't keen on that + case 0x01: return ""; + case 0x02: return "="; + case 0x03: return "-"; + } + return ""; +} + +std::string upd777_device::get_reg_name(int reg) +{ + switch (reg) + { + case 0x00: return "A1"; // general reg A1 + case 0x01: return "A2"; // general reg A2 + case 0x02: return "M"; // content of memory + case 0x03: return "H"; // high address + } + return ""; +} + + void upd777_device::do_op() { const u16 inst = fetch(); - switch (inst) + if (inst >= 0b0000'1000'0000 && inst <= 0b0000'1111'1111) + { + // 080 - 0ff Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow + const int k = inst & 0x7f; + LOGMASKED(LOG_UNHANDLED_OPS, "M-0x%02x\n", k); + } + else if (inst >= 0b0001'0000'0000 && inst <= 0b0001'0111'1111) { - default: + // 100-17f M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] + const int k = inst & 0x1f; + const int n = (inst >> 5) & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "M+0x%02x->M, 0x%d->L\n", k, n); + } + else if (inst >= 0b0001'1000'0000 && inst <= 0b0001'1111'1111) + { + // 180-1ff M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] + const int k = inst & 0x1f; + const int n = (inst >> 5) & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "M-0x%02x->M, 0x%d->L\n", k, n); + } + else if (inst >= 0b0100'1000'0000 && inst <= 0b0100'1011'1111) + { + // 480-4bf H[5:1]-K[5:1]->H[5:1], Skip if borrow + LOGMASKED(LOG_UNHANDLED_OPS, "H-0x%02x->H BOJ\n", inst & 0x1f); + } + else if (inst >= 0b0100'1100'0000 && inst <= 0b0100'1111'1111) + { + // 4c0 - 4ff H[5:1]+K[5:1]->H[5:1], Skip if carry + const int k = inst & 0x1f; + LOGMASKED(LOG_UNHANDLED_OPS, "H+0x%02x->H CAJ\n", k); + } + else if (inst >= 0b0101'0000'0000 && inst <= 0b0101'0111'1111) + { + // 500 - 57f + // When (KIE=0)&(SME=0), Store K[7:1] to M[H[5:1],L[2:1]][7:1] + // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] + // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] + const int k = inst & 0x7f; + LOGMASKED(LOG_UNHANDLED_OPS, "0x%02x->M\n", k); + } + else if (inst >= 0b0101'1000'0000 && inst <= 0b0101'1111'1111) { - LOGMASKED(LOG_UNHANDLED_OPS, "", inst); - return; + // 580 - 5ff Store K[7:6] to L[2:1] and K[5:1] to H[5:1] + const int k = inst & 0x7f; + LOGMASKED(LOG_UNHANDLED_OPS, "0x%02x->L,H\n", k); } + else if (inst >= 0b0110'0000'0000 && inst <= 0b0111'1111'1111) + { + // 600-67f Store K[7:1] to A1[7:1] + // 680-6ff Store K[7:1] to A2[7:1] + // 700-77f Store K[7:1] to A3[7:1] + // 780-7ff Store K[7:1] to A4[7:1] + const int reg = (inst & 0x180) >> 7; + const int k = inst & 0x7f; + LOGMASKED(LOG_UNHANDLED_OPS, "0x%02x->A%d\n", k, reg+1); + } + else if (inst >= 0b1000'0000'0000 && inst <= 0b1011'1111'1111) + { + // 800 - bff Move K[10:1] to A[10:1], Jump to A[11:1] + u16 fulladdress = (m_ppc & 0x400) | (inst & 0x3ff); + LOGMASKED(LOG_UNHANDLED_OPS, "JP 0x%03x (%01x:%02x)\n", fulladdress, (fulladdress & 0x780)>>7, inst & 0x07f); + } + else if (inst >= 0b1100'0000'0000 && inst <= 0b1111'1111'1111) + { + // c00 - fff Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack + const int k = inst & 0x3ff; + LOGMASKED(LOG_UNHANDLED_OPS, "JS 0x%03x (%01x:%02x)\n", k & 0x3ff, (k & 0x380)>>7, k & 0x07f); + } + else + { + switch (inst) + { + case 0b0000'0000'0000: + { + // 000 No Operation + LOGMASKED(LOG_UNHANDLED_OPS, "NOP\n"); + break; + } + case 0b0000'0000'0100: + { + // 004 Skip if (Gun Port Latch) = 1 + LOGMASKED(LOG_UNHANDLED_OPS, "GPL\n"); + break; + } + case 0b0000'0000'1000: + { + // 008 Move H[5:1] to Line Buffer Register[5:1] + LOGMASKED(LOG_UNHANDLED_OPS, "H->NRM\n"); + break; + } + case 0b0000'0001'1000: + { + // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] + LOGMASKED(LOG_UNHANDLED_OPS, "H<->X\n"); + break; + } + case 0b0000'0010'0000: + { + // 020 Subroutine End, Pop down address stack + LOGMASKED(LOG_UNHANDLED_OPS, "SRE\n"); + break; + } + case 0b0000'0010'1000: case 0b0000'0010'1001: + { + // 028 Shift STB[4:1], N->STB[1] + // STB is an input strobe / shifter + const int n = inst & 1; + LOGMASKED(LOG_UNHANDLED_OPS, "0x%d->STB\n", n); + break; + } + case 0b0000'0011'0000: + case 0b0000'0011'0100: + case 0b0000'0011'1000: + case 0b0000'0011'1100: + case 0b0000'0111'0000: + case 0b0000'0111'0100: + case 0b0000'0111'1000: + case 0b0000'0111'1100: + { + // 30 Skip if (PD1 input) = 1 + // 34 Skip if (PD2 input) = 1 + // 38 Skip if (PD3 input) = 1 + // 3c Skip if (PD4 input) = 1 + // 70 Skip if (PD1 input) = 0 + // 74 Skip if (PD2 input) = 0 + // 78 Skip if (PD3 input) = 0 + // 7c Skip if (PD4 input) = 0 + const int which = (inst & 0x00c) >> 2; + const int inv = inst & 0x40; + LOGMASKED(LOG_UNHANDLED_OPS, "PD%d %sJ\n", which + 1, inv ? "/" : ""); + break; + } + case 0b0000'0100'1001: + { + // 049 Skip if (4H Horizontal Blank) = 1 + LOGMASKED(LOG_UNHANDLED_OPS, "4H BLK\n"); + break; + } + case 0b0000'0100'1010: + { + // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] + LOGMASKED(LOG_UNHANDLED_OPS, "VBLK\n"); + break; + } + case 0b0000'0100'1100: + { + // 04c Skip if (GP&SW/ input) = 1 + LOGMASKED(LOG_UNHANDLED_OPS, "GPSW/\n"); + break; + } + case 0b0000'0101'0100: + { + // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] + LOGMASKED(LOG_UNHANDLED_OPS, "A->MA\n"); + break; + } + case 0b0000'0101'1000: + { + // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) + LOGMASKED(LOG_UNHANDLED_OPS, "MA->A\n"); + break; + } + case 0b0000'0101'1100: + { + // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] + LOGMASKED(LOG_UNHANDLED_OPS, "MA<->A\n"); + break; + } + case 0b0000'0110'0000: + { + // 060 Subroutine End, Pop down address stack, Skip + LOGMASKED(LOG_UNHANDLED_OPS, "SRE+1\n"); + break; + } + + case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: + case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: + case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: + case 0b0010'0010'1000: case 0b0010'0010'1001: case 0b0010'0010'1010: case 0b0010'0010'1011: + case 0b0010'0000'1100: case 0b0010'0000'1101: case 0b0010'0000'1110: case 0b0010'0000'1111: + case 0b0010'0010'1100: case 0b0010'0010'1101: case 0b0010'0010'1110: case 0b0010'0010'1111: + case 0b0010'0001'0000: case 0b0010'0001'0001: case 0b0010'0001'0010: case 0b0010'0001'0011: + case 0b0010'0011'0000: case 0b0010'0011'0001: case 0b0010'0011'0010: case 0b0010'0011'0011: + case 0b0010'0001'1000: case 0b0010'0001'1001: case 0b0010'0001'1010: case 0b0010'0001'1011: + case 0b0010'0011'1000: case 0b0010'0011'1001: case 0b0010'0011'1010: case 0b0010'0011'1011: + case 0b0010'0001'1100: case 0b0010'0001'1101: case 0b0010'0001'1110: case 0b0010'0001'1111: + case 0b0010'0011'1100: case 0b0010'0011'1101: case 0b0010'0011'1110: case 0b0010'0011'1111: + case 0b0010'0100'0000: case 0b0010'0100'0001: case 0b0010'0100'0010: case 0b0010'0100'0011: + case 0b0010'0110'0000: case 0b0010'0110'0001: case 0b0010'0110'0010: case 0b0010'0110'0011: + case 0b0010'0100'1000: case 0b0010'0100'1001: case 0b0010'0100'1010: case 0b0010'0100'1011: + case 0b0010'0110'1000: case 0b0010'0110'1001: case 0b0010'0110'1010: case 0b0010'0110'1011: + case 0b0010'0100'1100: case 0b0010'0100'1101: case 0b0010'0100'1110: case 0b0010'0100'1111: + case 0b0010'0110'1100: case 0b0010'0110'1101: case 0b0010'0110'1110: case 0b0010'0110'1111: + case 0b0010'0101'0000: case 0b0010'0101'0001: case 0b0010'0101'0010: case 0b0010'0101'0011: + case 0b0010'0111'0000: case 0b0010'0111'0001: case 0b0010'0111'0010: case 0b0010'0111'0011: + case 0b0010'0101'1000: case 0b0010'0101'1001: case 0b0010'0101'1010: case 0b0010'0101'1011: + case 0b0010'0111'1000: case 0b0010'0111'1001: case 0b0010'0111'1010: case 0b0010'0111'1011: + case 0b0010'0101'1100: case 0b0010'0101'1101: case 0b0010'0101'1110: case 0b0010'0101'1111: + case 0b0010'0111'1100: case 0b0010'0111'1101: case 0b0010'0111'1110: case 0b0010'0111'1111: + case 0b0010'1000'0000: case 0b0010'1000'0001: case 0b0010'1000'0010: case 0b0010'1000'0011: + case 0b0010'1010'0000: case 0b0010'1010'0001: case 0b0010'1010'0010: case 0b0010'1010'0011: + case 0b0010'1000'1000: case 0b0010'1000'1001: case 0b0010'1000'1010: case 0b0010'1000'1011: + case 0b0010'1010'1000: case 0b0010'1010'1001: case 0b0010'1010'1010: case 0b0010'1010'1011: + case 0b0010'1000'1100: case 0b0010'1000'1101: case 0b0010'1000'1110: case 0b0010'1000'1111: + case 0b0010'1010'1100: case 0b0010'1010'1101: case 0b0010'1010'1110: case 0b0010'1010'1111: + case 0b0010'1001'0000: case 0b0010'1001'0001: case 0b0010'1001'0010: case 0b0010'1001'0011: + case 0b0010'1011'0000: case 0b0010'1011'0001: case 0b0010'1011'0010: case 0b0010'1011'0011: + case 0b0010'1001'1000: case 0b0010'1001'1001: case 0b0010'1001'1010: case 0b0010'1001'1011: + case 0b0010'1011'1000: case 0b0010'1011'1001: case 0b0010'1011'1010: case 0b0010'1011'1011: + case 0b0010'1001'1100: case 0b0010'1001'1101: case 0b0010'1001'1110: case 0b0010'1001'1111: + case 0b0010'1011'1100: case 0b0010'1011'1101: case 0b0010'1011'1110: case 0b0010'1011'1111: + case 0b0010'1100'0000: case 0b0010'1100'0001: case 0b0010'1100'0010: case 0b0010'1100'0011: + case 0b0010'1110'0000: case 0b0010'1110'0001: case 0b0010'1110'0010: case 0b0010'1110'0011: + case 0b0010'1100'1000: case 0b0010'1100'1001: case 0b0010'1100'1010: case 0b0010'1100'1011: + case 0b0010'1110'1000: case 0b0010'1110'1001: case 0b0010'1110'1010: case 0b0010'1110'1011: + case 0b0010'1100'1100: case 0b0010'1100'1101: case 0b0010'1100'1110: case 0b0010'1100'1111: + case 0b0010'1110'1100: case 0b0010'1110'1101: case 0b0010'1110'1110: case 0b0010'1110'1111: + case 0b0010'1101'0000: case 0b0010'1101'0001: case 0b0010'1101'0010: case 0b0010'1101'0011: + case 0b0010'1111'0000: case 0b0010'1111'0001: case 0b0010'1111'0010: case 0b0010'1111'0011: + case 0b0010'1101'1000: case 0b0010'1101'1001: case 0b0010'1101'1010: case 0b0010'1101'1011: + case 0b0010'1111'1000: case 0b0010'1111'1001: case 0b0010'1111'1010: case 0b0010'1111'1011: + case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: + case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: + { + // optype · (AND) + // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] + // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] + // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] + // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] + // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] + // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] + + // optype = (these are expressed as x=y in the opcopde syntax, but x-y in the description, in reality it seems to act as 'CMP' so x-y = 0) + // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] + // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] + // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] + // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] + // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] + // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] + // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] + // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] + + // optype - + // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] + // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] + // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] + // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] + const int non = inst & 0x20; + const int optype = (inst & 0x0c) >> 2; + const int reg1 = (inst & 0xc0) >> 6; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "%s%s%s, 0x%d->L %s%s\n", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); + break; + } + + case 0b0011'0000'0000: case 0b0011'0000'0001: case 0b0011'0000'0010: case 0b0011'0000'0011: + { + // 300 N->L[2:1] + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "0x%d->L\n", n); + break; + } + + case 0b0011'0000'1000: + { + // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] + LOGMASKED(LOG_UNHANDLED_OPS, "A1->FLS, 0->L\n"); + break; + } + case 0b0011'0100'1000: + { + // 348 Move A2[7:1] to FLS[7:1], 0->L[2:1] + LOGMASKED(LOG_UNHANDLED_OPS, "A2->FLS, 0->L\n"); + break; + } + case 0b0011'1000'1000: + { + // 388 Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] + LOGMASKED(LOG_UNHANDLED_OPS, "M->FLS, 0->L\n"); + break; + } + + case 0b0011'0000'1001: + { + // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] + LOGMASKED(LOG_UNHANDLED_OPS, "A1->FRS, 1->L\n"); + break; + } + case 0b0011'0100'1001: + { + // 349 Move A2[7:1] to FRS[7:1], 1->L[2:1] + LOGMASKED(LOG_UNHANDLED_OPS, "A2->FRS, 1->L\n"); + break; + } + case 0b0011'1000'1001: + { + // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] + LOGMASKED(LOG_UNHANDLED_OPS, "M->FRS, 1->L\n"); + break; + } + + case 0b0011'0000'1010: case 0b0011'0000'1011: + { + // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + LOGMASKED(LOG_UNHANDLED_OPS, "A1->MODE, 0x%d->L\n", n); + break; + } + case 0b0011'01001010: case 0b0011'0100'1011: + { + // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + LOGMASKED(LOG_UNHANDLED_OPS, "A2->MODE, 0x%d->L\n", n); + break; + } + case 0b0011'1000'1010: case 0b00111000'1011: + { + // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + LOGMASKED(LOG_UNHANDLED_OPS, "M->MODE, 0x%d->L\n", n); + break; + } + + case 0b0011'0001'0000: case 0b0011'0001'0001: case 0b0011'0001'0010: case 0b0011'0001'0011: + { + // 310 Move A2[7:1] to A1[7:1], N->L[2:1] + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "A2->A1, 0x%d->L\n", n); + break; + } + case 0b0011'0100'0000: case 0b0011'0100'0001: case 0b0011'0100'0010: case 0b0011'0100'0011: + { + // 340 Move A1[7:1] to A2[7:1], N->L[2:1] + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "A1->A2, 0x%d->L\n", n); + break; + } + + case 0b0011'0001'1000: case 0b0011'0001'1001: case 0b0011'0001'1010: case 0b0011'0001'1011: + { + // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "A1->RS, 0x%d->L\n", n); + break; + } + case 0b0011'0101'1000: case 0b0011'0101'1001: case 0b0011'0101'1010: case 0b0011'0101'1011: + { + // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "A2->RS, 0x%d->L\n", n); + break; + } + case 0b0011'1001'1000: case 0b0011'1001'1001: case 0b0011'1001'1010: case 0b0011'1001'1011: + { + // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "M->RS, 0x%d->L\n", n); + break; + } + + case 0b0011'0001'1100: case 0b0011'0001'1101: case 0b0011'0001'1110: case 0b0011'0001'1111: + { + // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "A1-A2->A2, 0x%d->L\n", n); + break; + } + case 0b0011'0100'1100: case 0b0011'0100'1101: case 0b0011'0100'1110: case 0b0011'0100'1111: + { + // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "A2-A1->A1, 0x%d->L\n", n); + break; + } + + case 0b0011'0010'0000: case 0b0011'0010'0001: case 0b0011'0010'0010: case 0b0011'0010'0011: + case 0b0011'0010'0100: case 0b0011'0010'0101: case 0b0011'0010'0110: case 0b0011'0010'0111: + case 0b0011'0010'1000: case 0b0011'0010'1001: case 0b0011'0010'1010: case 0b0011'0010'1011: + case 0b0011'0010'1100: case 0b0011'0010'1101: case 0b0011'0010'1110: case 0b0011'0010'1111: + case 0b0011'0011'0000: case 0b0011'0011'0001: case 0b0011'0011'0010: case 0b0011'0011'0011: + case 0b0011'0011'0100: case 0b0011'0011'0101: case 0b0011'0011'0110: case 0b0011'0011'0111: + case 0b0011'0011'1000: case 0b0011'0011'1001: case 0b0011'0011'1010: case 0b0011'0011'1011: + case 0b0011'0011'1100: case 0b0011'0011'1101: case 0b0011'0011'1110: case 0b0011'0011'1111: + case 0b0011'0110'0000: case 0b0011'0110'0001: case 0b0011'0110'0010: case 0b0011'0110'0011: + case 0b0011'0110'0100: case 0b0011'0110'0101: case 0b0011'0110'0110: case 0b0011'0110'0111: + case 0b0011'0110'1000: case 0b0011'0110'1001: case 0b0011'0110'1010: case 0b0011'0110'1011: + case 0b0011'0110'1100: case 0b0011'0110'1101: case 0b0011'0110'1110: case 0b0011'0110'1111: + case 0b0011'0111'0000: case 0b0011'0111'0001: case 0b0011'0111'0010: case 0b0011'0111'0011: + case 0b0011'0111'0100: case 0b0011'0111'0101: case 0b0011'0111'0110: case 0b0011'0111'0111: + case 0b0011'0111'1000: case 0b0011'0111'1001: case 0b0011'0111'1010: case 0b0011'0111'1011: + case 0b0011'0111'1100: case 0b0011'0111'1101: case 0b0011'0111'1110: case 0b0011'0111'1111: + { + // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 32c Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 330 AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 334 Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 338 OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 33c Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 360 AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 364 Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 368 OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 36c Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + // 370 AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int reg1 = (inst & 0x40) >> 6; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "%s%s%s->%s, 0x%d->L %s\n", get_reg_name(reg1), get_300optype_name(optype), get_reg_name(reg2), get_reg_name(reg1), n, (optype == 3) ? "BOJ" : ""); + break; + } + + case 0b0011'1000'0000: case 0b0011'1000'0001: case 0b0011'1000'0010: case 0b0011'1000'0011: + case 0b0011'1001'0000: case 0b0011'1001'0001: case 0b0011'1001'0010: case 0b0011'1001'0011: + { + // 380 Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "A%d->M, 0x%d->L\n", reg + 1, n); + break; + } + + case 0b0011'1000'0100: case 0b0011'1000'0101: case 0b0011'1000'0110: case 0b0011'1000'0111: + case 0b0011'1001'0100: case 0b0011'1001'0101: case 0b0011'1001'0110: case 0b0011'1001'0111: + { + // 384 Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] + // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "M<->A%d, 0x%d->L\n", reg + 1, n); + break; + } + + case 0b0011'1000'1100: case 0b0011'1000'1101: case 0b0011'1000'1110: case 0b0011'1000'1111: + case 0b0011'1001'1100: case 0b0011'1001'1101: case 0b0011'1001'1110: case 0b0011'1001'1111: + { + // 38c Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] + // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "M->A%d, 0x%d->L\n", reg + 1, n); + break; + } + + case 0b0011'1010'0000: case 0b0011'1010'0001: case 0b0011'1010'0010: case 0b0011'1010'0011: + case 0b0011'1010'0100: case 0b0011'1010'0101: case 0b0011'1010'0110: case 0b0011'1010'0111: + case 0b0011'1010'1000: case 0b0011'1010'1001: case 0b0011'1010'1010: case 0b0011'1010'1011: + case 0b0011'1010'1100: case 0b0011'1010'1101: case 0b0011'1010'1110: case 0b0011'1010'1111: + case 0b0011'1011'0000: case 0b0011'1011'0001: case 0b0011'1011'0010: case 0b0011'1011'0011: + case 0b0011'1011'0100: case 0b0011'1011'0101: case 0b0011'1011'0110: case 0b0011'1011'0111: + case 0b0011'1011'1000: case 0b0011'1011'1001: case 0b0011'1011'1010: case 0b0011'1011'1011: + case 0b0011'1011'1100: case 0b0011'1011'1101: case 0b0011'1011'1110: case 0b0011'1011'1111: + { + // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3ac Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + // 3b0 AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "M%s%s->M, 0x%d->L\n", get_300optype_name(optype), get_reg_name(reg2), n); + break; + } + + case 0b0011'1110'0000: case 0b0011'1110'0001: case 0b0011'1110'0010: case 0b0011'1110'0011: + case 0b0011'1110'0100: case 0b0011'1110'0101: case 0b0011'1110'0110: case 0b0011'1110'0111: + case 0b0011'1110'1000: case 0b0011'1110'1001: case 0b0011'1110'1010: case 0b0011'1110'1011: + case 0b0011'1110'1100: case 0b0011'1110'1101: case 0b0011'1110'1110: case 0b0011'1110'1111: + case 0b0011'1111'0000: case 0b0011'1111'0001: case 0b0011'1111'0010: case 0b0011'1111'0011: + case 0b0011'1111'0100: case 0b0011'1111'0101: case 0b0011'1111'0110: case 0b0011'1111'0111: + case 0b0011'1111'1000: case 0b0011'1111'1001: case 0b0011'1111'1010: case 0b0011'1111'1011: + case 0b0011'1111'1100: case 0b0011'1111'1101: case 0b0011'1111'1110: case 0b0011'1111'1111: + { + // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3e8 OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3ec Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + // 3f0 AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3f4 Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + const int optype = (inst & 0x0c) >> 2; + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "H%s%s->H, 0x%d->L\n", get_300optype_name(optype), get_reg_name(reg), n); + break; + } + + case 0b0011'1100'0000: case 0b0011'1100'0001: case 0b0011'1100'0010: case 0b0011'1100'0011: + case 0b0011'1101'0000: case 0b0011'1101'0001: case 0b0011'1101'0010: case 0b0011'1101'0011: + { + // 3c0 Move A1[5:1] to H[5:1], N->L[2:1] + // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "A%d->H, 0x%d->L\n", reg + 1, n); + break; + } + case 0b0011'1100'1100: case 0b0011'1100'1101: case 0b0011'1100'1110: case 0b0011'1100'1111: + case 0b0011'1101'1100: case 0b0011'1101'1101: case 0b0011'1101'1110: case 0b0011'1101'1111: + { + // 3cc Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] + // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + LOGMASKED(LOG_UNHANDLED_OPS, "H->A%d, 0x%d->L\n", reg + 1, n); + break; + } + + case 0b0100'0000'0000: case 0b0100'0000'0001: + { + // 400 N->A[11] + const int n = inst & 0x1; + LOGMASKED(LOG_UNHANDLED_OPS, "%d->A11\n", n); + break; + } + case 0b0100'0000'0010: case 0b0100'0000'0011: + { + // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] + const int n = inst & 0x1; + LOGMASKED(LOG_UNHANDLED_OPS, "JPM, 0->L, %d->A11\n", n); + break; + } + case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: + case 0b0100'0100'1000: case 0b0100'0100'1001: case 0b0100'0100'1100: case 0b0100'0100'1101: + case 0b0100'0101'0000: case 0b0100'0101'0001: case 0b0100'0101'0100: case 0b0100'0101'0101: + case 0b0100'0101'1000: case 0b0100'0101'1001: case 0b0100'0101'1100: case 0b0100'0101'1101: + case 0b0100'0110'0000: case 0b0100'0110'0001: case 0b0100'0110'0100: case 0b0100'0110'0101: + case 0b0100'0110'1000: case 0b0100'0110'1001: case 0b0100'0110'1100: case 0b0100'0110'1101: + case 0b0100'0111'0000: case 0b0100'0111'0001: case 0b0100'0111'0100: case 0b0100'0111'0101: + case 0b0100'0111'1000: case 0b0100'0111'1001: case 0b0100'0111'1100: case 0b0100'0111'1101: + { + // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] + const int d = (inst >> 5) & 0x1; + const int g = (inst >> 4) & 0x1; + const int k = (inst >> 3) & 0x1; + const int s = (inst >> 2) & 0x1; + const int n = inst & 0x1; + LOGMASKED(LOG_UNHANDLED_OPS, "%d->D, %d->G, %d->K, %d->S, %d->A11\n", d, g, k, s, n); + break; + } + + default: + { + LOGMASKED(LOG_UNHANDLED_OPS, "%04x \n", inst); + break; + } + } } } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 213c1f1ddbdf0..f0e33276192e1 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -39,10 +39,15 @@ class upd777_device : public cpu_device memory_access<11, 1, -1, ENDIANNESS_LITTLE>::specific m_space; memory_access<8, 0, 0, ENDIANNESS_LITTLE>::specific m_data; + std::string get_300optype_name(int optype); + std::string get_200optype_name(int optype); + std::string get_reg_name(int reg); + void increment_pc(); u16 fetch(); void do_op(); + u32 m_ppc; u32 m_pc; s32 m_icount; }; diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 8a1475cde4f98..cb26f7def8801 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -168,6 +168,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b0000'0010'1000: case 0b0000'0010'1001: { // 028 Shift STB[4:1], N->STB[1] + // STB is an input strobe / shifter const int n = inst & 1; util::stream_format(stream, "0x%d->STB", n); break; @@ -286,7 +287,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: { - // optype · + // optype · (AND) // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] From 37239bc3595fab4b7a43c81e5ba566207d0ad155 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 20:22:07 +0000 Subject: [PATCH 39/62] begin adding ops --- src/devices/cpu/upd777/upd777.cpp | 79 +++++++++++++++++++++++++++++-- src/devices/cpu/upd777/upd777.h | 19 +++++++- 2 files changed, 93 insertions(+), 5 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 3f70f9f2c9263..410eea477f134 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -74,13 +74,34 @@ void upd777_device::device_start() state_add(STATE_GENPC, "GENPC", m_pc).noshow(); state_add(STATE_GENPCBASE, "CURPC", m_pc).noshow(); + state_add(UPD777_A1, "A1", m_a[0]); + state_add(UPD777_A2, "A2", m_a[1]); + state_add(UPD777_A3, "A3", m_a[2]); + state_add(UPD777_A4, "A4", m_a[3]); + + state_add(UPD777_L, "L", m_l); + state_add(UPD777_H, "H", m_h); + + //state_add(UPD777_SKIP, "SKIP", m_skip); + + save_item(NAME(m_ppc)); save_item(NAME(m_pc)); + save_item(NAME(m_skip)); + save_item(NAME(m_a)); + save_item(NAME(m_l)); + save_item(NAME(m_h)); } void upd777_device::device_reset() { m_ppc = 0; m_pc = 0; + + m_a[0] = m_a[1] = m_a[2] = m_a[3] = 0; + m_l = 0; + m_h = 0; + + m_skip = 1; // the first opcode is always 'NOP' so maybe skip is 1 on startup? } u16 upd777_device::fetch() @@ -91,6 +112,26 @@ u16 upd777_device::fetch() return opcode; } +void upd777_device::set_a11(int a11) +{ + m_pc = (m_pc & 0x3ff) | (a11 & 1) << 10; +} + +void upd777_device::set_new_pc(int newpc) +{ + m_pc = newpc; +} + +void upd777_device::set_l(int l) +{ + m_l = l & 0x3; +} + +void upd777_device::set_h(int h) +{ + m_h = h & 0x1f; +} + // temporary, for the opcode logging std::string upd777_device::get_300optype_name(int optype) { @@ -145,6 +186,7 @@ void upd777_device::do_op() const int k = inst & 0x1f; const int n = (inst >> 5) & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "M+0x%02x->M, 0x%d->L\n", k, n); + set_l(n); } else if (inst >= 0b0001'1000'0000 && inst <= 0b0001'1111'1111) { @@ -152,6 +194,7 @@ void upd777_device::do_op() const int k = inst & 0x1f; const int n = (inst >> 5) & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "M-0x%02x->M, 0x%d->L\n", k, n); + set_l(n); } else if (inst >= 0b0100'1000'0000 && inst <= 0b0100'1011'1111) { @@ -177,7 +220,8 @@ void upd777_device::do_op() { // 580 - 5ff Store K[7:6] to L[2:1] and K[5:1] to H[5:1] const int k = inst & 0x7f; - LOGMASKED(LOG_UNHANDLED_OPS, "0x%02x->L,H\n", k); + set_l(k >> 5); + set_h(k & 0x1f); } else if (inst >= 0b0110'0000'0000 && inst <= 0b0111'1111'1111) { @@ -193,7 +237,7 @@ void upd777_device::do_op() { // 800 - bff Move K[10:1] to A[10:1], Jump to A[11:1] u16 fulladdress = (m_ppc & 0x400) | (inst & 0x3ff); - LOGMASKED(LOG_UNHANDLED_OPS, "JP 0x%03x (%01x:%02x)\n", fulladdress, (fulladdress & 0x780)>>7, inst & 0x07f); + set_new_pc(fulladdress); } else if (inst >= 0b1100'0000'0000 && inst <= 0b1111'1111'1111) { @@ -416,6 +460,7 @@ void upd777_device::do_op() const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "%s%s%s, 0x%d->L %s%s\n", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); + set_l(n); break; } @@ -423,7 +468,7 @@ void upd777_device::do_op() { // 300 N->L[2:1] const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "0x%d->L\n", n); + set_l(n); break; } @@ -470,6 +515,7 @@ void upd777_device::do_op() // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; LOGMASKED(LOG_UNHANDLED_OPS, "A1->MODE, 0x%d->L\n", n); + set_l(n + 2); break; } case 0b0011'01001010: case 0b0011'0100'1011: @@ -477,6 +523,7 @@ void upd777_device::do_op() // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; LOGMASKED(LOG_UNHANDLED_OPS, "A2->MODE, 0x%d->L\n", n); + set_l(n + 2); break; } case 0b0011'1000'1010: case 0b00111000'1011: @@ -484,6 +531,7 @@ void upd777_device::do_op() // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; LOGMASKED(LOG_UNHANDLED_OPS, "M->MODE, 0x%d->L\n", n); + set_l(n + 2); break; } @@ -492,6 +540,7 @@ void upd777_device::do_op() // 310 Move A2[7:1] to A1[7:1], N->L[2:1] const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "A2->A1, 0x%d->L\n", n); + set_l(n); break; } case 0b0011'0100'0000: case 0b0011'0100'0001: case 0b0011'0100'0010: case 0b0011'0100'0011: @@ -499,6 +548,7 @@ void upd777_device::do_op() // 340 Move A1[7:1] to A2[7:1], N->L[2:1] const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "A1->A2, 0x%d->L\n", n); + set_l(n); break; } @@ -507,6 +557,7 @@ void upd777_device::do_op() // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "A1->RS, 0x%d->L\n", n); + set_l(n); break; } case 0b0011'0101'1000: case 0b0011'0101'1001: case 0b0011'0101'1010: case 0b0011'0101'1011: @@ -514,6 +565,7 @@ void upd777_device::do_op() // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "A2->RS, 0x%d->L\n", n); + set_l(n); break; } case 0b0011'1001'1000: case 0b0011'1001'1001: case 0b0011'1001'1010: case 0b0011'1001'1011: @@ -521,6 +573,7 @@ void upd777_device::do_op() // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "M->RS, 0x%d->L\n", n); + set_l(n); break; } @@ -529,6 +582,7 @@ void upd777_device::do_op() // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "A1-A2->A2, 0x%d->L\n", n); + set_l(n); break; } case 0b0011'0100'1100: case 0b0011'0100'1101: case 0b0011'0100'1110: case 0b0011'0100'1111: @@ -536,6 +590,7 @@ void upd777_device::do_op() // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "A2-A1->A1, 0x%d->L\n", n); + set_l(n); break; } @@ -577,6 +632,7 @@ void upd777_device::do_op() const int reg1 = (inst & 0x40) >> 6; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "%s%s%s->%s, 0x%d->L %s\n", get_reg_name(reg1), get_300optype_name(optype), get_reg_name(reg2), get_reg_name(reg1), n, (optype == 3) ? "BOJ" : ""); + set_l(n); break; } @@ -588,6 +644,7 @@ void upd777_device::do_op() const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "A%d->M, 0x%d->L\n", reg + 1, n); + set_l(n); break; } @@ -599,6 +656,7 @@ void upd777_device::do_op() const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "M<->A%d, 0x%d->L\n", reg + 1, n); + set_l(n); break; } @@ -610,6 +668,7 @@ void upd777_device::do_op() const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "M->A%d, 0x%d->L\n", reg + 1, n); + set_l(n); break; } @@ -634,6 +693,7 @@ void upd777_device::do_op() const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "M%s%s->M, 0x%d->L\n", get_300optype_name(optype), get_reg_name(reg2), n); + set_l(n); break; } @@ -658,6 +718,7 @@ void upd777_device::do_op() const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "H%s%s->H, 0x%d->L\n", get_300optype_name(optype), get_reg_name(reg), n); + set_l(n); break; } @@ -669,6 +730,7 @@ void upd777_device::do_op() const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "A%d->H, 0x%d->L\n", reg + 1, n); + set_l(n); break; } case 0b0011'1100'1100: case 0b0011'1100'1101: case 0b0011'1100'1110: case 0b0011'1100'1111: @@ -679,6 +741,7 @@ void upd777_device::do_op() const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; LOGMASKED(LOG_UNHANDLED_OPS, "H->A%d, 0x%d->L\n", reg + 1, n); + set_l(n); break; } @@ -686,7 +749,7 @@ void upd777_device::do_op() { // 400 N->A[11] const int n = inst & 0x1; - LOGMASKED(LOG_UNHANDLED_OPS, "%d->A11\n", n); + set_a11(n); break; } case 0b0100'0000'0010: case 0b0100'0000'0011: @@ -694,6 +757,7 @@ void upd777_device::do_op() // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] const int n = inst & 0x1; LOGMASKED(LOG_UNHANDLED_OPS, "JPM, 0->L, %d->A11\n", n); + set_a11(n); break; } case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: @@ -712,6 +776,7 @@ void upd777_device::do_op() const int s = (inst >> 2) & 0x1; const int n = inst & 0x1; LOGMASKED(LOG_UNHANDLED_OPS, "%d->D, %d->G, %d->K, %d->S, %d->A11\n", d, g, k, s, n); + set_a11(n); break; } @@ -728,6 +793,12 @@ void upd777_device::execute_run() { while (m_icount > 0) { + if (m_skip) + { + fetch(); + m_skip = 0; + } + debugger_instruction_hook(m_pc); do_op(); m_icount--; diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index f0e33276192e1..7f921d7d528db 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -13,7 +13,14 @@ class upd777_device : public cpu_device upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); enum { - UPD777_PC = 0 + UPD777_PC = 0, + UPD777_A1, + UPD777_A2, + UPD777_A3, + UPD777_A4, + UPD777_SKIP, + UPD777_H, + UPD777_L, }; protected: @@ -47,9 +54,19 @@ class upd777_device : public cpu_device u16 fetch(); void do_op(); + void set_l(int l); + void set_h(int h); + void set_a11(int a11); + void set_new_pc(int newpc); + u32 m_ppc; u32 m_pc; s32 m_icount; + u8 m_skip; + u8 m_a[4]; // A1 to A4 + u8 m_h; + u8 m_l; + }; DECLARE_DEVICE_TYPE(UPD777, upd777_device) From d5f0ccb9573bb952e749a7b99680538552768263 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 20:56:32 +0000 Subject: [PATCH 40/62] correct data memory size, add notes --- src/devices/cpu/upd777/upd777.cpp | 50 +++++++++++++++++++++++++++++-- src/devices/cpu/upd777/upd777.h | 15 ++++++++++ 2 files changed, 63 insertions(+), 2 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 410eea477f134..4e3f8d0379258 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -18,7 +18,8 @@ DEFINE_DEVICE_TYPE(UPD777, upd777_device, "upd777", "NEC uPD777") upd777_device::upd777_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data) : cpu_device(mconfig, type, tag, owner, clock) , m_space_config("program", ENDIANNESS_LITTLE, 16, 11, -1, address_map_constructor(FUNC(upd777_device::internal_map), this)) - , m_data_config("data", ENDIANNESS_LITTLE, 8, 8, 0, data) + , m_data_config("data", ENDIANNESS_LITTLE, 8, 7, 0, data) + , m_datamem(*this, "datamem") { } @@ -47,6 +48,16 @@ void upd777_device::internal_map(address_map &map) void upd777_device::internal_data_map(address_map &map) { + // 0x20 groups of 4 7-bit values + // groups 0x00-0x18 are used for sprite/pattern entries with the format + + // 6543210 + // 00 yyyyyyp (y = ypos, p = PRIO) + // 01 xxxxxxx (x = xpos) + // 02 ttttttt (t = pattern) + // 03 YYYRGBS (Y = , RGB = color, S=ySUB) + + map(0x00, 0x7f).ram().share("datamem"); } void upd777_device::increment_pc() @@ -122,16 +133,48 @@ void upd777_device::set_new_pc(int newpc) m_pc = newpc; } +// L reg (lower memory pointer is 2 bit void upd777_device::set_l(int l) { m_l = l & 0x3; } +// H reg (upper memory pointer) is 5-bit void upd777_device::set_h(int h) { m_h = h & 0x1f; } +// H reg is used as upper bits of memory address +u8 upd777_device::get_h_shifted() +{ + return (m_h & 0x1f) << 2; +} + +// 'A' regs are 7-bit +void upd777_device::set_a1(u8 data) { m_a[0] = data & 0x7f; } +void upd777_device::set_a2(u8 data) { m_a[1] = data & 0x7f; } +void upd777_device::set_a3(u8 data) { m_a[2] = data & 0x7f; } +void upd777_device::set_a4(u8 data) { m_a[3] = data & 0x7f; } + +// 'A' regs are 7-bit +u8 upd777_device::get_a1() { return m_a[0] & 0x7f; } +u8 upd777_device::get_a2() { return m_a[1] & 0x7f; } +u8 upd777_device::get_a3() { return m_a[2] & 0x7f; } +u8 upd777_device::get_a4() { return m_a[3] & 0x7f; } + +u8 upd777_device::read_data_mem(u8 addr) +{ + // data memory is 7-bit + return m_data.read_byte(addr) & 0x7f; +} + +void upd777_device::write_data_mem(u8 addr, u8 data) +{ + // data memory is 7-bit + m_data.write_byte(addr, data & 0x7f); +} + // temporary, for the opcode logging std::string upd777_device::get_300optype_name(int optype) { @@ -330,7 +373,10 @@ void upd777_device::do_op() case 0b0000'0101'0100: { // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] - LOGMASKED(LOG_UNHANDLED_OPS, "A->MA\n"); + write_data_mem(get_h_shifted() | 0, get_a1()); + write_data_mem(get_h_shifted() | 1, get_a2()); + write_data_mem(get_h_shifted() | 2, get_a3()); + write_data_mem(get_h_shifted() | 3, get_a4()); break; } case 0b0000'0101'1000: diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 7f921d7d528db..72589c3d5f95b 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -46,6 +46,8 @@ class upd777_device : public cpu_device memory_access<11, 1, -1, ENDIANNESS_LITTLE>::specific m_space; memory_access<8, 0, 0, ENDIANNESS_LITTLE>::specific m_data; + required_shared_ptr m_datamem; + std::string get_300optype_name(int optype); std::string get_200optype_name(int optype); std::string get_reg_name(int reg); @@ -54,10 +56,23 @@ class upd777_device : public cpu_device u16 fetch(); void do_op(); + + u8 read_data_mem(u8 addr); + void write_data_mem(u8 addr, u8 data); + void set_l(int l); + u8 get_h_shifted(); void set_h(int h); void set_a11(int a11); void set_new_pc(int newpc); + void set_a1(u8 data); + void set_a2(u8 data); + void set_a3(u8 data); + void set_a4(u8 data); + u8 get_a1(); + u8 get_a2(); + u8 get_a3(); + u8 get_a4(); u32 m_ppc; u32 m_pc; From d79ef62000265d2ee04be6fae283ab6c05f52b49 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 21:21:37 +0000 Subject: [PATCH 41/62] add the (very) limited stack --- src/devices/cpu/upd777/upd777.cpp | 53 ++++++++++++++++++++++++++++--- src/devices/cpu/upd777/upd777.h | 8 +++++ 2 files changed, 56 insertions(+), 5 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 4e3f8d0379258..cb26e8187c175 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -93,7 +93,12 @@ void upd777_device::device_start() state_add(UPD777_L, "L", m_l); state_add(UPD777_H, "H", m_h); - //state_add(UPD777_SKIP, "SKIP", m_skip); + state_add(UPD777_ADDR_STACK0, "ADDR_STACK0", m_stack[0]); + state_add(UPD777_ADDR_STACK1, "ADDR_STACK1", m_stack[1]); + state_add(UPD777_ADDR_STACK2, "ADDR_STACK2", m_stack[2]); + state_add(UPD777_ADDR_STACK_POS, "ADDR_STACK_POS", m_stackpos); + + //state_add(UPD777_SKIP, "SKIP", m_skip); // will always be showing 0 as debugger doesn't hook on skipped opcodes save_item(NAME(m_ppc)); save_item(NAME(m_pc)); @@ -101,6 +106,9 @@ void upd777_device::device_start() save_item(NAME(m_a)); save_item(NAME(m_l)); save_item(NAME(m_h)); + + save_item(NAME(m_stack)); + save_item(NAME(m_stackpos)); } void upd777_device::device_reset() @@ -113,6 +121,9 @@ void upd777_device::device_reset() m_h = 0; m_skip = 1; // the first opcode is always 'NOP' so maybe skip is 1 on startup? + + m_stack[0] = m_stack[1] = m_stack[2] = 0; + m_stackpos = 0; } u16 upd777_device::fetch() @@ -123,6 +134,34 @@ u16 upd777_device::fetch() return opcode; } +void upd777_device::push_to_stack(u16 addr) +{ + if (m_stackpos < 3) + { + m_stack[m_stackpos] = addr; + m_stackpos++; + } + else + { + logerror("attempting to push to full address stack\n"); + } +} + +u16 upd777_device::pull_from_stack() +{ + if (m_stackpos > 0) + { + m_stackpos--; + return m_stack[m_stackpos]; + } + else + { + logerror("attempting to pull from empty address stack\n"); + return 0; + } +} + + void upd777_device::set_a11(int a11) { m_pc = (m_pc & 0x3ff) | (a11 & 1) << 10; @@ -286,7 +325,8 @@ void upd777_device::do_op() { // c00 - fff Move K[10:1] to A[10:1], 0 to A11, Jump to A[11:1], Push next A[11:1] up to ROM address stack const int k = inst & 0x3ff; - LOGMASKED(LOG_UNHANDLED_OPS, "JS 0x%03x (%01x:%02x)\n", k & 0x3ff, (k & 0x380)>>7, k & 0x07f); + push_to_stack(m_pc); + set_new_pc(k); } else { @@ -295,7 +335,7 @@ void upd777_device::do_op() case 0b0000'0000'0000: { // 000 No Operation - LOGMASKED(LOG_UNHANDLED_OPS, "NOP\n"); + // nothing break; } case 0b0000'0000'0100: @@ -319,7 +359,8 @@ void upd777_device::do_op() case 0b0000'0010'0000: { // 020 Subroutine End, Pop down address stack - LOGMASKED(LOG_UNHANDLED_OPS, "SRE\n"); + u16 addr = pull_from_stack(); + set_new_pc(addr); break; } case 0b0000'0010'1000: case 0b0000'0010'1001: @@ -394,7 +435,9 @@ void upd777_device::do_op() case 0b0000'0110'0000: { // 060 Subroutine End, Pop down address stack, Skip - LOGMASKED(LOG_UNHANDLED_OPS, "SRE+1\n"); + u16 addr = pull_from_stack(); + set_new_pc(addr); + m_skip = 1; break; } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 72589c3d5f95b..b4526e8c5f2b9 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -21,6 +21,10 @@ class upd777_device : public cpu_device UPD777_SKIP, UPD777_H, UPD777_L, + UPD777_ADDR_STACK0, + UPD777_ADDR_STACK1, + UPD777_ADDR_STACK2, + UPD777_ADDR_STACK_POS, }; protected: @@ -59,6 +63,8 @@ class upd777_device : public cpu_device u8 read_data_mem(u8 addr); void write_data_mem(u8 addr, u8 data); + void push_to_stack(u16 addr); + u16 pull_from_stack(); void set_l(int l); u8 get_h_shifted(); @@ -81,6 +87,8 @@ class upd777_device : public cpu_device u8 m_a[4]; // A1 to A4 u8 m_h; u8 m_l; + u16 m_stack[3]; // 3 11-bit registers + u8 m_stackpos; }; From 35a9f34cceaca79617762d51e03cc6c9d9cb1006 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 21:53:57 +0000 Subject: [PATCH 42/62] add some very specific registers --- src/devices/cpu/upd777/upd777.cpp | 67 +++++++++++++++++++++++++------ src/devices/cpu/upd777/upd777.h | 12 ++++++ 2 files changed, 67 insertions(+), 12 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index cb26e8187c175..11961db04845c 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -107,6 +107,9 @@ void upd777_device::device_start() save_item(NAME(m_l)); save_item(NAME(m_h)); + save_item(NAME(m_frs)); + save_item(NAME(m_fls)); + save_item(NAME(m_stack)); save_item(NAME(m_stackpos)); } @@ -120,6 +123,9 @@ void upd777_device::device_reset() m_l = 0; m_h = 0; + m_frs = 0; + m_fls = 0; + m_skip = 1; // the first opcode is always 'NOP' so maybe skip is 1 on startup? m_stack[0] = m_stack[1] = m_stack[2] = 0; @@ -178,6 +184,11 @@ void upd777_device::set_l(int l) m_l = l & 0x3; } +u8 upd777_device::get_l() +{ + return m_l & 0x3; +} + // H reg (upper memory pointer) is 5-bit void upd777_device::set_h(int h) { @@ -190,6 +201,13 @@ u8 upd777_device::get_h_shifted() return (m_h & 0x1f) << 2; } +// M is the content of memory address pointed to by H and L +u8 upd777_device::get_m_data() +{ + u8 addr = get_h_shifted() | get_l(); + return read_data_mem(addr); +} + // 'A' regs are 7-bit void upd777_device::set_a1(u8 data) { m_a[0] = data & 0x7f; } void upd777_device::set_a2(u8 data) { m_a[1] = data & 0x7f; } @@ -202,6 +220,16 @@ u8 upd777_device::get_a2() { return m_a[1] & 0x7f; } u8 upd777_device::get_a3() { return m_a[2] & 0x7f; } u8 upd777_device::get_a4() { return m_a[3] & 0x7f; } +// FRS/FLS are the 2 7-bit sound registers +void upd777_device::set_frs(u8 frs) { m_frs = frs & 0x7f; } +void upd777_device::set_fls(u8 fls) { m_fls = fls & 0x7f; } + +// MODE is a 7-bit register with the following format +// 6543210 +// rbhpRGB (r = reverberate sound effect, b = brightness, h = hue, p = black/prio, RGB = color) +void upd777_device::set_mode(u8 mode) { m_mode = mode & 0x7f; } + + u8 upd777_device::read_data_mem(u8 addr) { // data memory is 7-bit @@ -564,38 +592,50 @@ void upd777_device::do_op() case 0b0011'0000'1000: { // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] - LOGMASKED(LOG_UNHANDLED_OPS, "A1->FLS, 0->L\n"); + u8 a1 = get_a1(); + set_fls(a1); + set_l(0); break; } case 0b0011'0100'1000: { // 348 Move A2[7:1] to FLS[7:1], 0->L[2:1] - LOGMASKED(LOG_UNHANDLED_OPS, "A2->FLS, 0->L\n"); + u8 a2 = get_a2(); + set_fls(a2); + set_l(0); break; } case 0b0011'1000'1000: { // 388 Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] - LOGMASKED(LOG_UNHANDLED_OPS, "M->FLS, 0->L\n"); + u8 m = get_m_data(); + set_fls(m); + set_l(0); break; } case 0b0011'0000'1001: { // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] - LOGMASKED(LOG_UNHANDLED_OPS, "A1->FRS, 1->L\n"); + u8 a1 = get_a1(); + set_frs(a1); + set_l(1); break; } case 0b0011'0100'1001: { // 349 Move A2[7:1] to FRS[7:1], 1->L[2:1] - LOGMASKED(LOG_UNHANDLED_OPS, "A2->FRS, 1->L\n"); + u8 a2 = get_a2(); + set_frs(a2); + set_l(1); break; } case 0b0011'1000'1001: { // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] - LOGMASKED(LOG_UNHANDLED_OPS, "M->FRS, 1->L\n"); + u8 m = get_m_data(); + set_frs(m); + set_l(1); break; } @@ -603,24 +643,27 @@ void upd777_device::do_op() { // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; - LOGMASKED(LOG_UNHANDLED_OPS, "A1->MODE, 0x%d->L\n", n); - set_l(n + 2); + u8 a1 = get_a1(); + set_mode(a1); + set_l(n); break; } case 0b0011'01001010: case 0b0011'0100'1011: { // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; - LOGMASKED(LOG_UNHANDLED_OPS, "A2->MODE, 0x%d->L\n", n); - set_l(n + 2); + u8 a2 = get_a2(); + set_mode(a2); + set_l(n); break; } case 0b0011'1000'1010: case 0b00111000'1011: { // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] const int n = (inst & 0x1) + 2; - LOGMASKED(LOG_UNHANDLED_OPS, "M->MODE, 0x%d->L\n", n); - set_l(n + 2); + u8 m = get_m_data(); + set_mode(m); + set_l(n); break; } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index b4526e8c5f2b9..60781f399f65d 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -66,6 +66,7 @@ class upd777_device : public cpu_device void push_to_stack(u16 addr); u16 pull_from_stack(); + u8 get_l(); void set_l(int l); u8 get_h_shifted(); void set_h(int h); @@ -75,6 +76,13 @@ class upd777_device : public cpu_device void set_a2(u8 data); void set_a3(u8 data); void set_a4(u8 data); + + void set_frs(u8 frs); + void set_fls(u8 fls); + void set_mode(u8 mode); + + u8 get_m_data(); + u8 get_a1(); u8 get_a2(); u8 get_a3(); @@ -90,6 +98,10 @@ class upd777_device : public cpu_device u16 m_stack[3]; // 3 11-bit registers u8 m_stackpos; + u8 m_frs; + u8 m_fls; + + u8 m_mode; }; DECLARE_DEVICE_TYPE(UPD777, upd777_device) From c84642dc07cad30c73f87881e0f988b948ad970d Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 22:30:26 +0000 Subject: [PATCH 43/62] some basic ops to push us forward --- src/devices/cpu/upd777/upd777.cpp | 38 +++++++++++++++++++++++---- src/devices/cpu/upd777/upd777.h | 2 ++ src/devices/cpu/upd777/upd777dasm.cpp | 3 ++- 3 files changed, 37 insertions(+), 6 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 11961db04845c..57a31bcfcd60b 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -201,11 +201,22 @@ u8 upd777_device::get_h_shifted() return (m_h & 0x1f) << 2; } +u8 upd777_device::get_h() +{ + return m_h & 0x1f; +} + // M is the content of memory address pointed to by H and L u8 upd777_device::get_m_data() { u8 addr = get_h_shifted() | get_l(); - return read_data_mem(addr); + return read_data_mem(addr & 0x7f) & 0x7f; +} + +void upd777_device::set_m_data(u8 data) +{ + u8 addr = get_h_shifted() | get_l(); + return write_data_mem(addr & 0x7f, data & 0x7f); } // 'A' regs are 7-bit @@ -295,7 +306,11 @@ void upd777_device::do_op() // 100-17f M[H[5:1],L[2:1]][7:1]+K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if carry, N->L[2:1] const int k = inst & 0x1f; const int n = (inst >> 5) & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "M+0x%02x->M, 0x%d->L\n", k, n); + u8 m = get_m_data(); + m = m + k; + if (m & 0x80) + m_skip = 1; + set_m_data(m & 0x7f); set_l(n); } else if (inst >= 0b0001'1000'0000 && inst <= 0b0001'1111'1111) @@ -303,19 +318,32 @@ void upd777_device::do_op() // 180-1ff M[H[5:1],L[2:1]][7:1]-K[7:1]->M[H[5:1],L[2:1]][7:1], Skip if borrow, N->L[2:1] const int k = inst & 0x1f; const int n = (inst >> 5) & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "M-0x%02x->M, 0x%d->L\n", k, n); + u8 m = get_m_data(); + m = m - k; + if (m & 0x80) + m_skip = 1; + set_m_data(m & 0x7f); set_l(n); } else if (inst >= 0b0100'1000'0000 && inst <= 0b0100'1011'1111) { // 480-4bf H[5:1]-K[5:1]->H[5:1], Skip if borrow - LOGMASKED(LOG_UNHANDLED_OPS, "H-0x%02x->H BOJ\n", inst & 0x1f); + const int k = inst & 0x1f; + u8 h = get_h(); + h = h - k; + if (h & 0x20) + m_skip = 1; + set_h(h & 0x1f); } else if (inst >= 0b0100'1100'0000 && inst <= 0b0100'1111'1111) { // 4c0 - 4ff H[5:1]+K[5:1]->H[5:1], Skip if carry const int k = inst & 0x1f; - LOGMASKED(LOG_UNHANDLED_OPS, "H+0x%02x->H CAJ\n", k); + u8 h = get_h(); + h = h + k; + if (h & 0x20) + m_skip = 1; + set_h(h & 0x1f); } else if (inst >= 0b0101'0000'0000 && inst <= 0b0101'0111'1111) { diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 60781f399f65d..4c9fe2782ef1d 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -69,6 +69,7 @@ class upd777_device : public cpu_device u8 get_l(); void set_l(int l); u8 get_h_shifted(); + u8 get_h(); void set_h(int h); void set_a11(int a11); void set_new_pc(int newpc); @@ -82,6 +83,7 @@ class upd777_device : public cpu_device void set_mode(u8 mode); u8 get_m_data(); + void set_m_data(u8 data); u8 get_a1(); u8 get_a2(); diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index cb26f7def8801..65b5612d0f172 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -86,7 +86,8 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u else if (inst >= 0b0100'1000'0000 && inst <= 0b0100'1011'1111) { // 480-4bf H[5:1]-K[5:1]->H[5:1], Skip if borrow - util::stream_format(stream, "H-0x%02x->H BOJ", inst & 0x1f); + const int k = inst & 0x1f; + util::stream_format(stream, "H-0x%02x->H BOJ", k); } else if (inst >= 0b0100'1100'0000 && inst <= 0b0100'1111'1111) { From 2773dde7a931662eebf1cf90bab4b640dd92f228 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 22:47:40 +0000 Subject: [PATCH 44/62] rename this as a cpu_device as I'll probably need a devices/machine device that includes it but has the video parts --- src/devices/cpu/upd777/upd777.cpp | 117 ++++++++++++++++++------------ src/devices/cpu/upd777/upd777.h | 8 +- src/mame/epoch/cassvisn.cpp | 2 +- 3 files changed, 76 insertions(+), 51 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 57a31bcfcd60b..a74edaa3d21c2 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -11,29 +11,29 @@ #include "logmacro.h" // device type definitions -DEFINE_DEVICE_TYPE(UPD777, upd777_device, "upd777", "NEC uPD777") +DEFINE_DEVICE_TYPE(UPD777_CPU, upd777_cpu_device, "upd777cpu", "NEC uPD777 (CPU)") -upd777_device::upd777_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data) +upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data) : cpu_device(mconfig, type, tag, owner, clock) - , m_space_config("program", ENDIANNESS_LITTLE, 16, 11, -1, address_map_constructor(FUNC(upd777_device::internal_map), this)) + , m_space_config("program", ENDIANNESS_LITTLE, 16, 11, -1, address_map_constructor(FUNC(upd777_cpu_device::internal_map), this)) , m_data_config("data", ENDIANNESS_LITTLE, 8, 7, 0, data) , m_datamem(*this, "datamem") { } -upd777_device::upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) - : upd777_device(mconfig, UPD777, tag, owner, clock, address_map_constructor(FUNC(upd777_device::internal_data_map), this)) +upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : upd777_cpu_device(mconfig, UPD777_CPU, tag, owner, clock, address_map_constructor(FUNC(upd777_cpu_device::internal_data_map), this)) { } -std::unique_ptr upd777_device::create_disassembler() +std::unique_ptr upd777_cpu_device::create_disassembler() { return std::make_unique(); } -device_memory_interface::space_config_vector upd777_device::memory_space_config() const +device_memory_interface::space_config_vector upd777_cpu_device::memory_space_config() const { return space_config_vector{ std::make_pair(AS_PROGRAM, &m_space_config), @@ -41,12 +41,12 @@ device_memory_interface::space_config_vector upd777_device::memory_space_config( }; } -void upd777_device::internal_map(address_map &map) +void upd777_cpu_device::internal_map(address_map &map) { map(0x000, 0x7ff).rom(); } -void upd777_device::internal_data_map(address_map &map) +void upd777_cpu_device::internal_data_map(address_map &map) { // 0x20 groups of 4 7-bit values // groups 0x00-0x18 are used for sprite/pattern entries with the format @@ -60,7 +60,7 @@ void upd777_device::internal_data_map(address_map &map) map(0x00, 0x7f).ram().share("datamem"); } -void upd777_device::increment_pc() +void upd777_cpu_device::increment_pc() { u16 lowpc = m_pc & 0x07f; u16 highpc = m_pc & 0x780; @@ -74,7 +74,7 @@ void upd777_device::increment_pc() m_pc = highpc | lowpc; } -void upd777_device::device_start() +void upd777_cpu_device::device_start() { space(AS_PROGRAM).specific(m_space); space(AS_DATA).specific(m_data); @@ -114,7 +114,7 @@ void upd777_device::device_start() save_item(NAME(m_stackpos)); } -void upd777_device::device_reset() +void upd777_cpu_device::device_reset() { m_ppc = 0; m_pc = 0; @@ -132,7 +132,7 @@ void upd777_device::device_reset() m_stackpos = 0; } -u16 upd777_device::fetch() +u16 upd777_cpu_device::fetch() { u16 opcode = m_space.read_word(m_pc); m_ppc = m_pc; @@ -140,7 +140,7 @@ u16 upd777_device::fetch() return opcode; } -void upd777_device::push_to_stack(u16 addr) +void upd777_cpu_device::push_to_stack(u16 addr) { if (m_stackpos < 3) { @@ -153,7 +153,7 @@ void upd777_device::push_to_stack(u16 addr) } } -u16 upd777_device::pull_from_stack() +u16 upd777_cpu_device::pull_from_stack() { if (m_stackpos > 0) { @@ -168,93 +168,93 @@ u16 upd777_device::pull_from_stack() } -void upd777_device::set_a11(int a11) +void upd777_cpu_device::set_a11(int a11) { m_pc = (m_pc & 0x3ff) | (a11 & 1) << 10; } -void upd777_device::set_new_pc(int newpc) +void upd777_cpu_device::set_new_pc(int newpc) { m_pc = newpc; } // L reg (lower memory pointer is 2 bit -void upd777_device::set_l(int l) +void upd777_cpu_device::set_l(int l) { m_l = l & 0x3; } -u8 upd777_device::get_l() +u8 upd777_cpu_device::get_l() { return m_l & 0x3; } // H reg (upper memory pointer) is 5-bit -void upd777_device::set_h(int h) +void upd777_cpu_device::set_h(int h) { m_h = h & 0x1f; } // H reg is used as upper bits of memory address -u8 upd777_device::get_h_shifted() +u8 upd777_cpu_device::get_h_shifted() { return (m_h & 0x1f) << 2; } -u8 upd777_device::get_h() +u8 upd777_cpu_device::get_h() { return m_h & 0x1f; } // M is the content of memory address pointed to by H and L -u8 upd777_device::get_m_data() +u8 upd777_cpu_device::get_m_data() { u8 addr = get_h_shifted() | get_l(); return read_data_mem(addr & 0x7f) & 0x7f; } -void upd777_device::set_m_data(u8 data) +void upd777_cpu_device::set_m_data(u8 data) { u8 addr = get_h_shifted() | get_l(); return write_data_mem(addr & 0x7f, data & 0x7f); } // 'A' regs are 7-bit -void upd777_device::set_a1(u8 data) { m_a[0] = data & 0x7f; } -void upd777_device::set_a2(u8 data) { m_a[1] = data & 0x7f; } -void upd777_device::set_a3(u8 data) { m_a[2] = data & 0x7f; } -void upd777_device::set_a4(u8 data) { m_a[3] = data & 0x7f; } +void upd777_cpu_device::set_a1(u8 data) { m_a[0] = data & 0x7f; } +void upd777_cpu_device::set_a2(u8 data) { m_a[1] = data & 0x7f; } +void upd777_cpu_device::set_a3(u8 data) { m_a[2] = data & 0x7f; } +void upd777_cpu_device::set_a4(u8 data) { m_a[3] = data & 0x7f; } // 'A' regs are 7-bit -u8 upd777_device::get_a1() { return m_a[0] & 0x7f; } -u8 upd777_device::get_a2() { return m_a[1] & 0x7f; } -u8 upd777_device::get_a3() { return m_a[2] & 0x7f; } -u8 upd777_device::get_a4() { return m_a[3] & 0x7f; } +u8 upd777_cpu_device::get_a1() { return m_a[0] & 0x7f; } +u8 upd777_cpu_device::get_a2() { return m_a[1] & 0x7f; } +u8 upd777_cpu_device::get_a3() { return m_a[2] & 0x7f; } +u8 upd777_cpu_device::get_a4() { return m_a[3] & 0x7f; } // FRS/FLS are the 2 7-bit sound registers -void upd777_device::set_frs(u8 frs) { m_frs = frs & 0x7f; } -void upd777_device::set_fls(u8 fls) { m_fls = fls & 0x7f; } +void upd777_cpu_device::set_frs(u8 frs) { m_frs = frs & 0x7f; } +void upd777_cpu_device::set_fls(u8 fls) { m_fls = fls & 0x7f; } // MODE is a 7-bit register with the following format // 6543210 // rbhpRGB (r = reverberate sound effect, b = brightness, h = hue, p = black/prio, RGB = color) -void upd777_device::set_mode(u8 mode) { m_mode = mode & 0x7f; } +void upd777_cpu_device::set_mode(u8 mode) { m_mode = mode & 0x7f; } -u8 upd777_device::read_data_mem(u8 addr) +u8 upd777_cpu_device::read_data_mem(u8 addr) { // data memory is 7-bit return m_data.read_byte(addr) & 0x7f; } -void upd777_device::write_data_mem(u8 addr, u8 data) +void upd777_cpu_device::write_data_mem(u8 addr, u8 data) { // data memory is 7-bit m_data.write_byte(addr, data & 0x7f); } // temporary, for the opcode logging -std::string upd777_device::get_300optype_name(int optype) +std::string upd777_cpu_device::get_300optype_name(int optype) { switch (optype) { @@ -266,7 +266,7 @@ std::string upd777_device::get_300optype_name(int optype) return ""; } -std::string upd777_device::get_200optype_name(int optype) +std::string upd777_cpu_device::get_200optype_name(int optype) { switch (optype) { @@ -278,7 +278,7 @@ std::string upd777_device::get_200optype_name(int optype) return ""; } -std::string upd777_device::get_reg_name(int reg) +std::string upd777_cpu_device::get_reg_name(int reg) { switch (reg) { @@ -291,7 +291,7 @@ std::string upd777_device::get_reg_name(int reg) } -void upd777_device::do_op() +void upd777_cpu_device::do_op() { const u16 inst = fetch(); @@ -369,7 +369,13 @@ void upd777_device::do_op() // 780-7ff Store K[7:1] to A4[7:1] const int reg = (inst & 0x180) >> 7; const int k = inst & 0x7f; - LOGMASKED(LOG_UNHANDLED_OPS, "0x%02x->A%d\n", k, reg+1); + switch (reg) + { + case 0: set_a1(k); break; + case 1: set_a2(k); break; + case 2: set_a3(k); break; + case 3: set_a4(k); break; + } } else if (inst >= 0b1000'0000'0000 && inst <= 0b1011'1111'1111) { @@ -453,6 +459,7 @@ void upd777_device::do_op() { // 049 Skip if (4H Horizontal Blank) = 1 LOGMASKED(LOG_UNHANDLED_OPS, "4H BLK\n"); + m_skip = 1; break; } case 0b0000'0100'1010: @@ -479,13 +486,31 @@ void upd777_device::do_op() case 0b0000'0101'1000: { // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) - LOGMASKED(LOG_UNHANDLED_OPS, "MA->A\n"); + u8 m1 = read_data_mem(get_h_shifted() | 0); + u8 m2 = read_data_mem(get_h_shifted() | 1); + u8 m3 = read_data_mem(get_h_shifted() | 2); + u8 m4 = read_data_mem(get_h_shifted() | 3); + set_a1(m1); + set_a2(m2); + set_a3(m3); + set_a4(m4); break; } case 0b0000'0101'1100: { // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] - LOGMASKED(LOG_UNHANDLED_OPS, "MA<->A\n"); + u8 m1 = read_data_mem(get_h_shifted() | 0); + u8 m2 = read_data_mem(get_h_shifted() | 1); + u8 m3 = read_data_mem(get_h_shifted() | 2); + u8 m4 = read_data_mem(get_h_shifted() | 3); + write_data_mem(get_h_shifted() | 0, get_a1()); + write_data_mem(get_h_shifted() | 1, get_a2()); + write_data_mem(get_h_shifted() | 2, get_a3()); + write_data_mem(get_h_shifted() | 3, get_a4()); + set_a1(m1); + set_a2(m2); + set_a3(m3); + set_a4(m4); break; } case 0b0000'0110'0000: @@ -949,7 +974,7 @@ void upd777_device::do_op() } } -void upd777_device::execute_run() +void upd777_cpu_device::execute_run() { while (m_icount > 0) { @@ -965,6 +990,6 @@ void upd777_device::execute_run() } } -void upd777_device::execute_set_input(int inputnum, int state) +void upd777_cpu_device::execute_set_input(int inputnum, int state) { } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 4c9fe2782ef1d..d1f6b6daa1cd4 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -7,10 +7,10 @@ #pragma once -class upd777_device : public cpu_device +class upd777_cpu_device : public cpu_device { public: - upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); + upd777_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); enum { UPD777_PC = 0, @@ -28,7 +28,7 @@ class upd777_device : public cpu_device }; protected: - upd777_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data); + upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data); virtual void device_start() override; virtual void device_reset() override; @@ -106,6 +106,6 @@ class upd777_device : public cpu_device u8 m_mode; }; -DECLARE_DEVICE_TYPE(UPD777, upd777_device) +DECLARE_DEVICE_TYPE(UPD777_CPU, upd777_cpu_device) #endif // MAME_CPU_UPD777_UPD777_H diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index 7ca91c5f8ddf6..f0d9c3a5b2feb 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -110,7 +110,7 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) void cassvisn_state::cassvisn(machine_config &config) { - UPD777(config, m_maincpu, 1000000); // frequency? UPD774 / UPD778 in some carts? + UPD777_CPU(config, m_maincpu, 1000000); // frequency? UPD774 / UPD778 in some carts? GENERIC_CARTSLOT(config, m_cart, generic_plain_slot, "cassvisn_cart"); m_cart->set_width(GENERIC_ROM16_WIDTH); From 9cb30ade2c016b15beacd3324b42f3e1de12c3b0 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sun, 7 Jan 2024 23:04:29 +0000 Subject: [PATCH 45/62] add some specific (but not really understood) enable flags --- src/devices/cpu/upd777/upd777.cpp | 38 +++++++++++++++++++++++++++++-- src/devices/cpu/upd777/upd777.h | 14 ++++++++++++ 2 files changed, 50 insertions(+), 2 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index a74edaa3d21c2..1d1895706beae 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -112,6 +112,11 @@ void upd777_cpu_device::device_start() save_item(NAME(m_stack)); save_item(NAME(m_stackpos)); + + save_item(NAME(m_disp)); + save_item(NAME(m_gpe)); + save_item(NAME(m_kie)); + save_item(NAME(m_sme)); } void upd777_cpu_device::device_reset() @@ -130,6 +135,11 @@ void upd777_cpu_device::device_reset() m_stack[0] = m_stack[1] = m_stack[2] = 0; m_stackpos = 0; + + m_disp = 0; + m_gpe = 0; + m_kie = 0; + m_sme = 0; } u16 upd777_cpu_device::fetch() @@ -240,6 +250,15 @@ void upd777_cpu_device::set_fls(u8 fls) { m_fls = fls & 0x7f; } // rbhpRGB (r = reverberate sound effect, b = brightness, h = hue, p = black/prio, RGB = color) void upd777_cpu_device::set_mode(u8 mode) { m_mode = mode & 0x7f; } +// single bit enable registers, although they have an important effect on the K->M opcode +void upd777_cpu_device::set_disp(u8 data) { m_disp = data & 1; } +void upd777_cpu_device::set_gpe(u8 data) { m_gpe = data & 1; } +void upd777_cpu_device::set_kie(u8 data) { m_kie = data & 1; } +void upd777_cpu_device::set_sme(u8 data) { m_sme = data & 1; } + +u8 upd777_cpu_device::get_kie() { return m_kie & 1; } +u8 upd777_cpu_device::get_sme() { return m_sme & 1; } + u8 upd777_cpu_device::read_data_mem(u8 addr) { @@ -352,7 +371,19 @@ void upd777_cpu_device::do_op() // When (KIE=1), Store KIN[7:1] to M[H[5:1],L[2:1]][7:1] // When (SME=1), Store HCL[7:1] to M[H[5:1],L[2:1]][7:1] const int k = inst & 0x7f; - LOGMASKED(LOG_UNHANDLED_OPS, "0x%02x->M\n", k); + + if (get_kie()) // documentation does not state if KIE or SME has priority + { + LOGMASKED(LOG_UNHANDLED_OPS, "KIE->M\n", k); + } + else if (get_sme()) + { + LOGMASKED(LOG_UNHANDLED_OPS, "SME->M\n", k); + } + else + { + set_m_data(k & 0x7f); + } } else if (inst >= 0b0101'1000'0000 && inst <= 0b0101'1111'1111) { @@ -960,7 +991,10 @@ void upd777_cpu_device::do_op() const int k = (inst >> 3) & 0x1; const int s = (inst >> 2) & 0x1; const int n = inst & 0x1; - LOGMASKED(LOG_UNHANDLED_OPS, "%d->D, %d->G, %d->K, %d->S, %d->A11\n", d, g, k, s, n); + set_disp(d); + set_gpe(g); + set_kie(k); + set_sme(s); set_a11(n); break; } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index d1f6b6daa1cd4..9f38a785a3248 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -85,6 +85,14 @@ class upd777_cpu_device : public cpu_device u8 get_m_data(); void set_m_data(u8 data); + void set_disp(u8 data); + void set_gpe(u8 data); + void set_kie(u8 data); + void set_sme(u8 data); + + u8 get_kie(); + u8 get_sme(); + u8 get_a1(); u8 get_a2(); u8 get_a3(); @@ -104,6 +112,12 @@ class upd777_cpu_device : public cpu_device u8 m_fls; u8 m_mode; + + // single bit enable registers? + u8 m_disp; + u8 m_gpe; + u8 m_kie; + u8 m_sme; }; DECLARE_DEVICE_TYPE(UPD777_CPU, upd777_cpu_device) From 3c0b1f87a8a0251e2225b112e6e494cdc86a8c17 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Mon, 8 Jan 2024 00:10:05 +0000 Subject: [PATCH 46/62] create a 'machine' device file so that video/sound related bits don't have to go directly in the main CPU core --- scripts/src/machine.lua | 12 ++++++ src/devices/cpu/upd777/upd777.cpp | 13 +++--- src/devices/cpu/upd777/upd777.h | 4 +- src/devices/machine/upd777_dev.cpp | 63 ++++++++++++++++++++++++++++++ src/devices/machine/upd777_dev.h | 30 ++++++++++++++ src/mame/epoch/cassvisn.cpp | 57 +++------------------------ 6 files changed, 116 insertions(+), 63 deletions(-) create mode 100644 src/devices/machine/upd777_dev.cpp create mode 100644 src/devices/machine/upd777_dev.h diff --git a/scripts/src/machine.lua b/scripts/src/machine.lua index 049cae04d364c..85fa45351fb56 100644 --- a/scripts/src/machine.lua +++ b/scripts/src/machine.lua @@ -5305,3 +5305,15 @@ if (MACHINES["TC9223"]~=null) then MAME_DIR .. "src/devices/machine/tc9223.h", } end + +--------------------------------------------------- +-- +--@src/devices/machine/upd777.h,MACHINES["UPD777"] = true +--------------------------------------------------- + +if (MACHINES["UPD777"]~=null) then + files { + MAME_DIR .. "src/devices/machine/upd777_dev.cpp", + MAME_DIR .. "src/devices/machine/upd777_dev.h", + } +end diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 1d1895706beae..ffe97235f90b6 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -10,10 +10,6 @@ #define VERBOSE (LOG_UNHANDLED_OPS) #include "logmacro.h" -// device type definitions -DEFINE_DEVICE_TYPE(UPD777_CPU, upd777_cpu_device, "upd777cpu", "NEC uPD777 (CPU)") - - upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data) : cpu_device(mconfig, type, tag, owner, clock) @@ -23,8 +19,8 @@ upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, device_type { } -upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) - : upd777_cpu_device(mconfig, UPD777_CPU, tag, owner, clock, address_map_constructor(FUNC(upd777_cpu_device::internal_data_map), this)) +upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock) + : upd777_cpu_device(mconfig, type, tag, owner, clock, address_map_constructor(FUNC(upd777_cpu_device::internal_data_map), this)) { } @@ -43,7 +39,7 @@ device_memory_interface::space_config_vector upd777_cpu_device::memory_space_con void upd777_cpu_device::internal_map(address_map &map) { - map(0x000, 0x7ff).rom(); + map(0x000, 0x7ff).rom().region("prg", 0); } void upd777_cpu_device::internal_data_map(address_map &map) @@ -440,7 +436,8 @@ void upd777_cpu_device::do_op() case 0b0000'0000'1000: { // 008 Move H[5:1] to Line Buffer Register[5:1] - LOGMASKED(LOG_UNHANDLED_OPS, "H->NRM\n"); + u8 h = get_h(); + LOGMASKED(LOG_UNHANDLED_OPS, "H(%02x)->NRM\n", h); break; } case 0b0000'0001'1000: diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 9f38a785a3248..b6bbcfe0db70f 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -10,7 +10,6 @@ class upd777_cpu_device : public cpu_device { public: - upd777_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); enum { UPD777_PC = 0, @@ -28,6 +27,7 @@ class upd777_cpu_device : public cpu_device }; protected: + upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock); upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data); virtual void device_start() override; @@ -120,6 +120,4 @@ class upd777_cpu_device : public cpu_device u8 m_sme; }; -DECLARE_DEVICE_TYPE(UPD777_CPU, upd777_cpu_device) - #endif // MAME_CPU_UPD777_UPD777_H diff --git a/src/devices/machine/upd777_dev.cpp b/src/devices/machine/upd777_dev.cpp new file mode 100644 index 0000000000000..277700a864e48 --- /dev/null +++ b/src/devices/machine/upd777_dev.cpp @@ -0,0 +1,63 @@ +// license:BSD-3-Clause +// copyright-holders:David Haywood + +#include "emu.h" +#include "upd777_dev.h" + +DEFINE_DEVICE_TYPE(UPD777, upd777_device, "upd777", "uPD777") + +upd777_device::upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : + upd777_cpu_device(mconfig, UPD777, tag, owner, clock), + m_gfxdecode(*this, "gfxdecode"), + m_palette(*this, "palette") +{ +} + +uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) +{ + return 0; +} + +// documentation says patterns 0x00 - 0x6e are 7x7 +// and patterns 0x70 - 0x7e are 8x7 +// but they all seem to be stored at 11x7, just with some columns blank? +static const gfx_layout test_layout = +{ + 11,7, + 0x80, + 8, + { 0 }, + { 0,1,2,3,4,5,6,7,8,9,10 }, + { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, + 7*11 +}; + + +static GFXDECODE_START( gfx_ud777 ) + GFXDECODE_ENTRY( "patterns", 0, test_layout, 0, 1 ) +GFXDECODE_END + +void upd777_device::device_add_mconfig(machine_config &config) +{ + // or pass the screen from the driver? + screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER)); + screen.set_refresh_hz(60); + screen.set_vblank_time(ATTOSECONDS_IN_USEC(0)); + screen.set_size(256, 256); + screen.set_visarea(0, 256-1, 16, 256-16-1); + screen.set_screen_update(FUNC(upd777_device::screen_update)); + screen.set_palette(m_palette); + + GFXDECODE(config, m_gfxdecode, m_palette, gfx_ud777); + PALETTE(config, m_palette).set_entries(0x1000); +} + +ROM_START( upd777 ) + ROM_REGION16_LE( 0x1000, "prg", ROMREGION_ERASEFF ) + ROM_REGION( 0x4d0, "patterns", ROMREGION_ERASEFF ) +ROM_END + +const tiny_rom_entry *upd777_device::device_rom_region() const +{ + return ROM_NAME(upd777); +} diff --git a/src/devices/machine/upd777_dev.h b/src/devices/machine/upd777_dev.h new file mode 100644 index 0000000000000..00d433a6280d1 --- /dev/null +++ b/src/devices/machine/upd777_dev.h @@ -0,0 +1,30 @@ +// license:BSD-3-Clause +// copyright-holders:David Haywood +#ifndef MAME_MACHINE_UPD777 +#define MAME_MACHINE_UPD777 + +#pragma once + +#include "emupal.h" +#include "screen.h" + +#include "cpu/upd777/upd777.h" + +class upd777_device : public upd777_cpu_device { +public: + upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); + +protected: + virtual void device_add_mconfig(machine_config &config) override; + virtual const tiny_rom_entry *device_rom_region() const override; + +private: + uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); + + required_device m_gfxdecode; + required_device m_palette; +}; + +DECLARE_DEVICE_TYPE(UPD777, upd777_device) + +#endif // MAME_MACHINE_UPD777 diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index f0d9c3a5b2feb..45bdcb1a3fc0e 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -14,11 +14,8 @@ the linked 'design note' contains a large amount of useful information #include "bus/generic/slot.h" #include "bus/generic/carts.h" -#include "cpu/upd777/upd777.h" -#include "cpu/upd777/upd777dasm.h" +#include "machine/upd777_dev.h" -#include "emupal.h" -#include "screen.h" #include "softlist_dev.h" @@ -30,9 +27,7 @@ class cassvisn_state : public driver_device cassvisn_state(const machine_config &mconfig, device_type type, const char *tag) : driver_device(mconfig, type, tag), m_maincpu(*this, "maincpu"), - m_cart(*this, "cartslot"), - m_gfxdecode(*this, "gfxdecode"), - m_palette(*this, "palette") + m_cart(*this, "cartslot") { } void cassvisn(machine_config &config); @@ -40,40 +35,11 @@ class cassvisn_state : public driver_device protected: DECLARE_DEVICE_IMAGE_LOAD_MEMBER(cart_load); private: - uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); required_device m_maincpu; required_device m_cart; - required_device m_gfxdecode; - required_device m_palette; }; -uint32_t cassvisn_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) -{ - return 0; -} - - -// documentation says patterns 0x00 - 0x6e are 7x7 -// and patterns 0x70 - 0x7e are 8x7 -// but they all seem to be stored at 11x7, just with some columns blank? -static const gfx_layout test_layout = -{ - 11,7, - 0x80, - 8, - { 0 }, - { 0,1,2,3,4,5,6,7,8,9,10 }, - { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, - 7*11 -}; - - -static GFXDECODE_START( gfx_cassvisn ) - GFXDECODE_ENTRY( "patterns", 0, test_layout, 0, 1 ) -GFXDECODE_END - - static INPUT_PORTS_START( cassvisn ) INPUT_PORTS_END @@ -89,7 +55,7 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_LITTLE); m_cart->common_load_rom(m_cart->get_rom_base(), size, "prg"); - uint8_t* prgbase = memregion("maincpu")->base(); + uint8_t* prgbase = memregion("maincpu:prg")->base(); memcpy(prgbase, m_cart->get_rom_base(), size); for (int i = 0; i < size; i += 2) @@ -104,36 +70,23 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) if (size != 0x4d0) return std::make_pair(image_error::UNSUPPORTED, "pat region size must be 0x4d0 in size"); - m_cart->common_load_rom(memregion("patterns")->base(), size, "pat"); + m_cart->common_load_rom(memregion("maincpu:patterns")->base(), size, "pat"); return std::make_pair(std::error_condition(), std::string()); } void cassvisn_state::cassvisn(machine_config &config) { - UPD777_CPU(config, m_maincpu, 1000000); // frequency? UPD774 / UPD778 in some carts? + UPD777(config, m_maincpu, 1000000); // frequency? UPD774 / UPD778 in some carts? GENERIC_CARTSLOT(config, m_cart, generic_plain_slot, "cassvisn_cart"); m_cart->set_width(GENERIC_ROM16_WIDTH); m_cart->set_device_load(FUNC(cassvisn_state::cart_load)); m_cart->set_must_be_loaded(true); - screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER)); - screen.set_refresh_hz(60); - screen.set_vblank_time(ATTOSECONDS_IN_USEC(0)); - screen.set_size(256, 256); - screen.set_visarea(0, 256-1, 16, 256-16-1); - screen.set_screen_update(FUNC(cassvisn_state::screen_update)); - screen.set_palette(m_palette); - - GFXDECODE(config, m_gfxdecode, m_palette, gfx_cassvisn); - PALETTE(config, m_palette).set_entries(0x1000); - SOFTWARE_LIST(config, "cart_list").set_original("cassvisn_cart"); } ROM_START( cassvisn ) - ROM_REGION( 0x1000, "maincpu", ROMREGION_ERASEFF ) - ROM_REGION( 0x4d0, "patterns", ROMREGION_ERASEFF ) ROM_END } // anonymous namespace From 7ebcab42187220a7733ada6b3d7e25635fb68459 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Mon, 8 Jan 2024 01:29:38 +0000 Subject: [PATCH 47/62] added some (very) crude rendering (mostly placeholder just to get an idea of what is going on) --- src/devices/cpu/upd777/upd777.cpp | 135 ++++++++++++++++++++++++++--- src/devices/cpu/upd777/upd777.h | 3 +- src/devices/machine/upd777_dev.cpp | 46 +++++++++- src/devices/machine/upd777_dev.h | 2 + 4 files changed, 169 insertions(+), 17 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index ffe97235f90b6..529e9f43127c2 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -13,9 +13,9 @@ upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data) : cpu_device(mconfig, type, tag, owner, clock) + , m_datamem(*this, "datamem") , m_space_config("program", ENDIANNESS_LITTLE, 16, 11, -1, address_map_constructor(FUNC(upd777_cpu_device::internal_map), this)) , m_data_config("data", ENDIANNESS_LITTLE, 8, 7, 0, data) - , m_datamem(*this, "datamem") { } @@ -657,7 +657,82 @@ void upd777_cpu_device::do_op() const int reg1 = (inst & 0xc0) >> 6; const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "%s%s%s, 0x%d->L %s%s\n", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); + //LOGMASKED(LOG_UNHANDLED_OPS, "2xx %s%s%s, 0x%d->L %s%s\n", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); + u8 srcreg2 = 0; + switch (reg2) + { + case 0: srcreg2 = get_a1(); break; + case 1: srcreg2 = get_a2(); break; + } + + u8 srcreg1 = 0; + switch (reg1) + { + case 0: srcreg1 = get_a1(); break; + case 1: srcreg1 = get_a2(); break; + case 2: srcreg1 = get_m_data(); break; + case 3: + { + srcreg1 = get_h(); + srcreg2 &= 0x1f; + break; + } + } + + switch (optype) + { + case 0: // AND + { + if (!non) + { + if (srcreg1 & srcreg2) + m_skip = 1; + } + else + { + if (!(srcreg1 & srcreg2)) + m_skip = 1; + } + break; + } + case 1: // invalid + { + // can't happen, no switch case leads here + break; + } + case 2: // = + { + if (!non) + { + if (srcreg1 == srcreg2) + m_skip = 1; + } + else + { + if (!(srcreg1 == srcreg2)) + m_skip = 1; + } + break; + } + case 3: // - + { + u8 result = srcreg1 - srcreg2; + + if (!non) + { + if (result & 0x80) + m_skip = 1; + } + else + { + if (!(result & 0x80)) + m_skip = 1; + } + + break; + } + } + set_l(n); break; } @@ -752,7 +827,8 @@ void upd777_cpu_device::do_op() { // 310 Move A2[7:1] to A1[7:1], N->L[2:1] const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "A2->A1, 0x%d->L\n", n); + u8 a2 = get_a2(); + set_a1(a2); set_l(n); break; } @@ -760,7 +836,8 @@ void upd777_cpu_device::do_op() { // 340 Move A1[7:1] to A2[7:1], N->L[2:1] const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "A1->A2, 0x%d->L\n", n); + u8 a1 = get_a1(); + set_a2(a1); set_l(n); break; } @@ -769,7 +846,9 @@ void upd777_cpu_device::do_op() { // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "A1->RS, 0x%d->L\n", n); + u8 a1 = get_a1(); + a1 = a1 >> 1; + set_a1(a1); set_l(n); break; } @@ -777,7 +856,9 @@ void upd777_cpu_device::do_op() { // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "A2->RS, 0x%d->L\n", n); + u8 a2 = get_a2(); + a2 = a2 >> 1; + set_a2(a2); set_l(n); break; } @@ -785,7 +866,9 @@ void upd777_cpu_device::do_op() { // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "M->RS, 0x%d->L\n", n); + u8 m = get_m_data(); + m = m >> 1; + set_m_data(m); set_l(n); break; } @@ -856,7 +939,12 @@ void upd777_cpu_device::do_op() // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "A%d->M, 0x%d->L\n", reg + 1, n); + u8 src = 0; + if (reg == 0) + src = get_a1(); + else + src = get_a2(); + set_m_data(src); set_l(n); break; } @@ -868,7 +956,17 @@ void upd777_cpu_device::do_op() // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "M<->A%d, 0x%d->L\n", reg + 1, n); + u8 src = 0; + if (reg == 0) + src = get_a1(); + else + src = get_a2(); + u8 m = get_m_data(); + set_m_data(src); + if (reg == 0) + set_a1(m); + else + set_a2(m); set_l(n); break; } @@ -880,7 +978,11 @@ void upd777_cpu_device::do_op() // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "M->A%d, 0x%d->L\n", reg + 1, n); + u8 m = get_m_data(); + if (reg == 0) + set_a1(m); + else + set_a2(m); set_l(n); break; } @@ -942,7 +1044,12 @@ void upd777_cpu_device::do_op() // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "A%d->H, 0x%d->L\n", reg + 1, n); + u8 src = 0; + if (reg == 0) + src = get_a1() & 0x1f; + else + src = get_a2() & 0x1f; + set_h(src); set_l(n); break; } @@ -953,7 +1060,11 @@ void upd777_cpu_device::do_op() // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "H->A%d, 0x%d->L\n", reg + 1, n); + u8 h = get_h() & 0x1f; + if (reg == 0) + set_a1(h); + else + set_a2(h); set_l(n); break; } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index b6bbcfe0db70f..cd6e614848817 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -43,6 +43,8 @@ class upd777_cpu_device : public cpu_device void internal_map(address_map &map); void internal_data_map(address_map &map); + required_shared_ptr m_datamem; + private: address_space_config m_space_config; address_space_config m_data_config; @@ -50,7 +52,6 @@ class upd777_cpu_device : public cpu_device memory_access<11, 1, -1, ENDIANNESS_LITTLE>::specific m_space; memory_access<8, 0, 0, ENDIANNESS_LITTLE>::specific m_data; - required_shared_ptr m_datamem; std::string get_300optype_name(int optype); std::string get_200optype_name(int optype); diff --git a/src/devices/machine/upd777_dev.cpp b/src/devices/machine/upd777_dev.cpp index 277700a864e48..a18ff062c75b0 100644 --- a/src/devices/machine/upd777_dev.cpp +++ b/src/devices/machine/upd777_dev.cpp @@ -15,6 +15,27 @@ upd777_device::upd777_device(const machine_config &mconfig, const char *tag, dev uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { + bitmap.fill(0, cliprect); + gfx_element *gfx = m_gfxdecode->gfx(0); + + for (int i = 0; i <= 0x18; i++) + { + u8 s0 = m_datamem[(i * 4) + 0]; + u8 s1 = m_datamem[(i * 4) + 1]; + u8 s2 = m_datamem[(i * 4) + 2]; + u8 s3 = m_datamem[(i * 4) + 3]; + + int ypos = (s0 & 0x7e) >> 1; + //int prio = (s0 & 0x01); + int xpos = (s1 & 0x7f); + int patn = (s2 & 0x7f); + //int ylow = (s3 & 0x70); + int pal = (s3 & 0x0e) >> 1; + //int ysub = (s3 & 0x01); + + gfx->zoom_transpen(bitmap, cliprect, patn, pal, 0, 0, xpos * 3, ypos * 4, 0x40000, 0x40000, 0); + } + return 0; } @@ -25,7 +46,7 @@ static const gfx_layout test_layout = { 11,7, 0x80, - 8, + 1, { 0 }, { 0,1,2,3,4,5,6,7,8,9,10 }, { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, @@ -34,9 +55,26 @@ static const gfx_layout test_layout = static GFXDECODE_START( gfx_ud777 ) - GFXDECODE_ENTRY( "patterns", 0, test_layout, 0, 1 ) + GFXDECODE_ENTRY( "patterns", 0, test_layout, 0, 8 ) GFXDECODE_END + +void upd777_device::palette_init(palette_device &palette) const +{ + // just a fake palette for now + for (int i = 0; i < palette.entries(); i++) + { + if (i & 1) + { + palette.set_pen_color(i, rgb_t(((i >> 1) & 1) ? 0xff : 0x7f, ((i >> 2) & 1) ? 0xff : 0x7f, ((i >> 3) & 1) ? 0xff : 0x7f)); + } + else + { + palette.set_pen_color(i, rgb_t(0, 0, 0)); + } + } +} + void upd777_device::device_add_mconfig(machine_config &config) { // or pass the screen from the driver? @@ -44,12 +82,12 @@ void upd777_device::device_add_mconfig(machine_config &config) screen.set_refresh_hz(60); screen.set_vblank_time(ATTOSECONDS_IN_USEC(0)); screen.set_size(256, 256); - screen.set_visarea(0, 256-1, 16, 256-16-1); + screen.set_visarea(0, 256-1, 0, 256-0-1); screen.set_screen_update(FUNC(upd777_device::screen_update)); screen.set_palette(m_palette); GFXDECODE(config, m_gfxdecode, m_palette, gfx_ud777); - PALETTE(config, m_palette).set_entries(0x1000); + PALETTE(config, m_palette, FUNC(upd777_device::palette_init), 32 * 3).set_entries(0x10); } ROM_START( upd777 ) diff --git a/src/devices/machine/upd777_dev.h b/src/devices/machine/upd777_dev.h index 00d433a6280d1..f6d7bf432c7e6 100644 --- a/src/devices/machine/upd777_dev.h +++ b/src/devices/machine/upd777_dev.h @@ -21,6 +21,8 @@ class upd777_device : public upd777_cpu_device { private: uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); + void palette_init(palette_device &palette) const; + required_device m_gfxdecode; required_device m_palette; }; From ace3da8580d192544a08c50c40fef2558dd60b74 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Mon, 8 Jan 2024 02:13:34 +0000 Subject: [PATCH 48/62] decode tiles at a more correct size --- src/devices/machine/upd777_dev.cpp | 41 +++++++++++++++++++++++++----- 1 file changed, 34 insertions(+), 7 deletions(-) diff --git a/src/devices/machine/upd777_dev.cpp b/src/devices/machine/upd777_dev.cpp index a18ff062c75b0..88a793e19adc9 100644 --- a/src/devices/machine/upd777_dev.cpp +++ b/src/devices/machine/upd777_dev.cpp @@ -17,6 +17,7 @@ uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitma { bitmap.fill(0, cliprect); gfx_element *gfx = m_gfxdecode->gfx(0); + gfx_element *gfx2 = m_gfxdecode->gfx(0); for (int i = 0; i <= 0x18; i++) { @@ -33,7 +34,10 @@ uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitma int pal = (s3 & 0x0e) >> 1; //int ysub = (s3 & 0x01); - gfx->zoom_transpen(bitmap, cliprect, patn, pal, 0, 0, xpos * 3, ypos * 4, 0x40000, 0x40000, 0); + if (patn<0x70) + gfx->zoom_transpen(bitmap, cliprect, patn, pal, 0, 0, xpos * 4, ypos * 4, 0x40000, 0x40000, 0); + else + gfx2->zoom_transpen(bitmap, cliprect, patn-0x70, pal, 0, 0, xpos * 4, ypos * 4, 0x40000, 0x40000, 0); } return 0; @@ -42,20 +46,43 @@ uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitma // documentation says patterns 0x00 - 0x6e are 7x7 // and patterns 0x70 - 0x7e are 8x7 // but they all seem to be stored at 11x7, just with some columns blank? +// this is probably because of how they were read out, over 11 data lines + +// 0x00-0x2f are 'Normal (7x7) +// 0x30-0x67 are 'Bent' (7x7) +// 0x68-0x6f are 'Y Repeat' (7x7) +// 0x70-0x77 are 'XY Repeat' (8x7) +// 0x78-0x7f are 'X Repeat' (8x8) +// +// NOTE, sprite patterns *7 and *f are unused so documentation expresses these ranges as to 66, 6e etc. rather than 67 6f +// +// it isn't clear how the 'Bent' effect etc. is enabled, as clearly not all patterns in this range should use it? + static const gfx_layout test_layout = { - 11,7, - 0x80, + 7,7, + 0x70, 1, { 0 }, - { 0,1,2,3,4,5,6,7,8,9,10 }, + { 4,5,6,7,8,9,10 }, { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, 7*11 }; +static const gfx_layout test2_layout = +{ + 8,7, + 0x10, + 1, + { 0 }, + { 3,4,5,6,7,8,9,10 }, + { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, + 7*11 +}; static GFXDECODE_START( gfx_ud777 ) - GFXDECODE_ENTRY( "patterns", 0, test_layout, 0, 8 ) + GFXDECODE_ENTRY( "patterns", 0x000, test_layout, 0, 8 ) + GFXDECODE_ENTRY( "patterns", 0x436, test2_layout, 0, 8 ) GFXDECODE_END @@ -81,8 +108,8 @@ void upd777_device::device_add_mconfig(machine_config &config) screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER)); screen.set_refresh_hz(60); screen.set_vblank_time(ATTOSECONDS_IN_USEC(0)); - screen.set_size(256, 256); - screen.set_visarea(0, 256-1, 0, 256-0-1); + screen.set_size(512, 256); + screen.set_visarea(0, 512-1, 0, 256-0-1); screen.set_screen_update(FUNC(upd777_device::screen_update)); screen.set_palette(m_palette); From 13e4b0469a005c2333208ae9ee6980fbbc21aff4 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Mon, 8 Jan 2024 02:23:16 +0000 Subject: [PATCH 49/62] improve btlvader --- src/devices/cpu/upd777/upd777.cpp | 50 ++++++++++++++++++++++++++++-- src/devices/machine/upd777_dev.cpp | 2 +- 2 files changed, 49 insertions(+), 3 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 529e9f43127c2..34109aa4d6598 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -314,7 +314,10 @@ void upd777_cpu_device::do_op() { // 080 - 0ff Skip if (M[H[5:1],L[2:1]][7:1]-K[7:1]) makes borrow const int k = inst & 0x7f; - LOGMASKED(LOG_UNHANDLED_OPS, "M-0x%02x\n", k); + u8 m = get_m_data(); + m = m - k; + if (m & 0x80) + m_skip = 1; } else if (inst >= 0b0001'0000'0000 && inst <= 0b0001'0111'1111) { @@ -927,7 +930,50 @@ void upd777_cpu_device::do_op() const int reg2 = (inst & 0x10) >> 4; const int reg1 = (inst & 0x40) >> 6; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "%s%s%s->%s, 0x%d->L %s\n", get_reg_name(reg1), get_300optype_name(optype), get_reg_name(reg2), get_reg_name(reg1), n, (optype == 3) ? "BOJ" : ""); + + u8 src1 = 0; + if (reg1 == 0) + src1 = get_a1(); + else + src1 = get_a2(); + + u8 src2 = 0; + if (reg2 == 0) + src2 = get_a1(); + else + src2 = get_a2(); + + switch (optype) + { + case 0: // AND + { + src1 = src1 & src2; + break; + } + case 1: // ADD + { + src1 = src1 + src2; + break; + } + case 2: // OR + { + src1 = src1 | src2; + break; + } + case 3: // MINUS + { + src1 = src1 - src2; + if (src1 & 0x80) + m_skip = 1; + break; + } + } + + if (reg1 == 0) + set_a1(src1); + else + set_a2(src1); + set_l(n); break; } diff --git a/src/devices/machine/upd777_dev.cpp b/src/devices/machine/upd777_dev.cpp index 88a793e19adc9..0b3f615ec9e49 100644 --- a/src/devices/machine/upd777_dev.cpp +++ b/src/devices/machine/upd777_dev.cpp @@ -52,7 +52,7 @@ uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitma // 0x30-0x67 are 'Bent' (7x7) // 0x68-0x6f are 'Y Repeat' (7x7) // 0x70-0x77 are 'XY Repeat' (8x7) -// 0x78-0x7f are 'X Repeat' (8x8) +// 0x78-0x7f are 'X Repeat' (8x7) // // NOTE, sprite patterns *7 and *f are unused so documentation expresses these ranges as to 66, 6e etc. rather than 67 6f // From 4e67db2801df98a33679eb707489722006b1cc11 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Mon, 8 Jan 2024 02:55:56 +0000 Subject: [PATCH 50/62] fill in some more ops --- src/devices/cpu/upd777/upd777.cpp | 105 ++++++++++++++++++++++++++++-- src/devices/cpu/upd777/upd777.h | 4 ++ 2 files changed, 104 insertions(+), 5 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 34109aa4d6598..0a730f699128e 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -101,6 +101,8 @@ void upd777_cpu_device::device_start() save_item(NAME(m_skip)); save_item(NAME(m_a)); save_item(NAME(m_l)); + save_item(NAME(m_ldash)); + save_item(NAME(m_x4)); save_item(NAME(m_h)); save_item(NAME(m_frs)); @@ -122,6 +124,8 @@ void upd777_cpu_device::device_reset() m_a[0] = m_a[1] = m_a[2] = m_a[3] = 0; m_l = 0; + m_ldash = 0; + m_x4 = 0; m_h = 0; m_frs = 0; @@ -447,6 +451,18 @@ void upd777_cpu_device::do_op() { // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] LOGMASKED(LOG_UNHANDLED_OPS, "H<->X\n"); + // this opcode is not well explained! but X4 etc. are referenced on Data RAM & Register Files which makes + // it even more confusing + u8 temp; + + temp = m_x4; + m_x4 = get_h(); + m_h = temp; + + temp = m_ldash; + m_ldash = get_l(); + set_l(temp); + break; } case 0b0000'0010'0000: @@ -880,7 +896,12 @@ void upd777_cpu_device::do_op() { // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "A1-A2->A2, 0x%d->L\n", n); + u8 a1 = get_a1(); + u8 a2 = get_a2(); + a2 = a1 - a2; + if (a2 & 0x80) + m_skip = 1; + set_a2(a2); set_l(n); break; } @@ -888,7 +909,12 @@ void upd777_cpu_device::do_op() { // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "A2-A1->A1, 0x%d->L\n", n); + u8 a1 = get_a1(); + u8 a2 = get_a2(); + a1 = a2 - a1; + if (a1 & 0x80) + m_skip = 1; + set_a1(a1); set_l(n); break; } @@ -1053,7 +1079,43 @@ void upd777_cpu_device::do_op() const int optype = (inst & 0x0c) >> 2; const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "M%s%s->M, 0x%d->L\n", get_300optype_name(optype), get_reg_name(reg2), n); + + u8 src2 = 0; + if (reg2 == 0) + src2 = get_a1(); + else + src2 = get_a2(); + + u8 m = get_m_data(); + + switch (optype) + { + case 0: // AND + { + m = m & src2; + break; + } + case 1: // ADD + { + m = m + src2; + if (m & 0x80) + m_skip = 1; + break; + } + case 2: // OR + { + m = m | src2; + break; + } + case 3: // MINUS + { + m = m - src2; + if (m & 0x80) + m_skip = 1; + break; + } + } + set_m_data(m); set_l(n); break; } @@ -1076,9 +1138,42 @@ void upd777_cpu_device::do_op() // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] const int optype = (inst & 0x0c) >> 2; - const int reg = (inst & 0x10) >> 4; + const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - LOGMASKED(LOG_UNHANDLED_OPS, "H%s%s->H, 0x%d->L\n", get_300optype_name(optype), get_reg_name(reg), n); + u8 src2 = 0; + if (reg2 == 0) + src2 = get_a1() & 0x1f; + else + src2 = get_a2() & 0x1f; + + u8 h = get_h(); + + switch (optype) + { + case 0: // AND + { + h = h & src2; + break; + } + case 1: // ADD + { + h = h + src2; + break; + } + case 2: // OR + { + h = h | src2; + break; + } + case 3: // MINUS + { + h = h - src2; + if (h & 0x20) + m_skip = 1; + break; + } + } + set_h(h & 0x1f); set_l(n); break; } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index cd6e614848817..4d346cbea803e 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -114,6 +114,10 @@ class upd777_cpu_device : public cpu_device u8 m_mode; + // what are these, used by H<->X opcode + u8 m_ldash; + u8 m_x4; + // single bit enable registers? u8 m_disp; u8 m_gpe; From 6ecf4def3142248e61a55d38ba308be03a51dacf Mon Sep 17 00:00:00 2001 From: David Haywood Date: Mon, 8 Jan 2024 12:11:09 +0000 Subject: [PATCH 51/62] some feedback --- hash/cassvisn_cart.xml | 22 +++++++-------- scripts/src/cpu.lua | 2 ++ scripts/src/machine.lua | 12 -------- src/devices/cpu/upd777/upd777.cpp | 9 ++++-- src/devices/cpu/upd777/upd777.h | 6 ++-- .../{machine => cpu/upd777}/upd777_dev.cpp | 28 +++++++++++++------ .../{machine => cpu/upd777}/upd777_dev.h | 11 +++++--- src/mame/epoch/cassvisn.cpp | 4 +-- 8 files changed, 52 insertions(+), 42 deletions(-) rename src/devices/{machine => cpu/upd777}/upd777_dev.cpp (85%) rename src/devices/{machine => cpu/upd777}/upd777_dev.h (76%) diff --git a/hash/cassvisn_cart.xml b/hash/cassvisn_cart.xml index 0b28b66b5ba62..c021b01d30823 100644 --- a/hash/cassvisn_cart.xml +++ b/hash/cassvisn_cart.xml @@ -39,7 +39,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1981 Epoch - + @@ -53,7 +53,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1981 Epoch - + @@ -68,7 +68,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1981 Epoch - + @@ -82,7 +82,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1982 Epoch - + @@ -97,7 +97,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1982 Epoch - + @@ -111,7 +111,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1982 Epoch - + @@ -125,7 +125,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1982 Epoch - + @@ -139,7 +139,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1982 Epoch - + @@ -153,7 +153,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1982 Epoch - + @@ -167,7 +167,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1984 Epoch - + @@ -181,7 +181,7 @@ the ROM files below store 12 bit in a 16-bit word with 4 bits unused, so 128 * 1 1984 Epoch - + diff --git a/scripts/src/cpu.lua b/scripts/src/cpu.lua index 64f7e093a277a..cee50a48f5fb8 100644 --- a/scripts/src/cpu.lua +++ b/scripts/src/cpu.lua @@ -3959,6 +3959,8 @@ if CPUS["UPD777"] then files { MAME_DIR .. "src/devices/cpu/upd777/upd777.cpp", MAME_DIR .. "src/devices/cpu/upd777/upd777.h", + MAME_DIR .. "src/devices/cpu/upd777/upd777_dev.cpp", + MAME_DIR .. "src/devices/cpu/upd777/upd777_dev.h", } end diff --git a/scripts/src/machine.lua b/scripts/src/machine.lua index 85fa45351fb56..049cae04d364c 100644 --- a/scripts/src/machine.lua +++ b/scripts/src/machine.lua @@ -5305,15 +5305,3 @@ if (MACHINES["TC9223"]~=null) then MAME_DIR .. "src/devices/machine/tc9223.h", } end - ---------------------------------------------------- --- ---@src/devices/machine/upd777.h,MACHINES["UPD777"] = true ---------------------------------------------------- - -if (MACHINES["UPD777"]~=null) then - files { - MAME_DIR .. "src/devices/machine/upd777_dev.cpp", - MAME_DIR .. "src/devices/machine/upd777_dev.h", - } -end diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 0a730f699128e..fead30d320eca 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -14,8 +14,8 @@ upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data) : cpu_device(mconfig, type, tag, owner, clock) , m_datamem(*this, "datamem") - , m_space_config("program", ENDIANNESS_LITTLE, 16, 11, -1, address_map_constructor(FUNC(upd777_cpu_device::internal_map), this)) - , m_data_config("data", ENDIANNESS_LITTLE, 8, 7, 0, data) + , m_space_config("program", ENDIANNESS_BIG, 16, 11, -1, address_map_constructor(FUNC(upd777_cpu_device::internal_map), this)) + , m_data_config("data", ENDIANNESS_BIG, 8, 7, 0, data) { } @@ -513,6 +513,11 @@ void upd777_cpu_device::do_op() { // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] LOGMASKED(LOG_UNHANDLED_OPS, "VBLK\n"); + if (get_vbl_state()) + m_skip = 1; + + // need to do the 0->M[[18:00],[3]][1] bit + break; } case 0b0000'0100'1100: diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 4d346cbea803e..abe0ed2e7ba5a 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -40,6 +40,8 @@ class upd777_cpu_device : public cpu_device virtual space_config_vector memory_space_config() const override; + virtual bool get_vbl_state() = 0; + void internal_map(address_map &map); void internal_data_map(address_map &map); @@ -49,8 +51,8 @@ class upd777_cpu_device : public cpu_device address_space_config m_space_config; address_space_config m_data_config; - memory_access<11, 1, -1, ENDIANNESS_LITTLE>::specific m_space; - memory_access<8, 0, 0, ENDIANNESS_LITTLE>::specific m_data; + memory_access<11, 1, -1, ENDIANNESS_BIG>::specific m_space; + memory_access<8, 0, 0, ENDIANNESS_BIG>::specific m_data; std::string get_300optype_name(int optype); diff --git a/src/devices/machine/upd777_dev.cpp b/src/devices/cpu/upd777/upd777_dev.cpp similarity index 85% rename from src/devices/machine/upd777_dev.cpp rename to src/devices/cpu/upd777/upd777_dev.cpp index 0b3f615ec9e49..a914ee88001c4 100644 --- a/src/devices/machine/upd777_dev.cpp +++ b/src/devices/cpu/upd777/upd777_dev.cpp @@ -9,10 +9,20 @@ DEFINE_DEVICE_TYPE(UPD777, upd777_device, "upd777", "uPD777") upd777_device::upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : upd777_cpu_device(mconfig, UPD777, tag, owner, clock), m_gfxdecode(*this, "gfxdecode"), - m_palette(*this, "palette") + m_palette(*this, "palette"), + m_screen(*this, "screen") { } +bool upd777_device::get_vbl_state() +{ + int vpos = m_screen->vpos(); + if (vpos > 240) + return true; + + return false; +} + uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { bitmap.fill(0, cliprect); @@ -105,20 +115,20 @@ void upd777_device::palette_init(palette_device &palette) const void upd777_device::device_add_mconfig(machine_config &config) { // or pass the screen from the driver? - screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER)); - screen.set_refresh_hz(60); - screen.set_vblank_time(ATTOSECONDS_IN_USEC(0)); - screen.set_size(512, 256); - screen.set_visarea(0, 512-1, 0, 256-0-1); - screen.set_screen_update(FUNC(upd777_device::screen_update)); - screen.set_palette(m_palette); + SCREEN(config, m_screen, SCREEN_TYPE_RASTER); + m_screen->set_refresh_hz(60); + m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2000)); + m_screen->set_size(512, 256); + m_screen->set_visarea(0, 512-1, 0, 256-0-1); + m_screen->set_screen_update(FUNC(upd777_device::screen_update)); + m_screen->set_palette(m_palette); GFXDECODE(config, m_gfxdecode, m_palette, gfx_ud777); PALETTE(config, m_palette, FUNC(upd777_device::palette_init), 32 * 3).set_entries(0x10); } ROM_START( upd777 ) - ROM_REGION16_LE( 0x1000, "prg", ROMREGION_ERASEFF ) + ROM_REGION16_BE( 0x1000, "prg", ROMREGION_ERASEFF ) ROM_REGION( 0x4d0, "patterns", ROMREGION_ERASEFF ) ROM_END diff --git a/src/devices/machine/upd777_dev.h b/src/devices/cpu/upd777/upd777_dev.h similarity index 76% rename from src/devices/machine/upd777_dev.h rename to src/devices/cpu/upd777/upd777_dev.h index f6d7bf432c7e6..a18584f12c40d 100644 --- a/src/devices/machine/upd777_dev.h +++ b/src/devices/cpu/upd777/upd777_dev.h @@ -1,14 +1,14 @@ // license:BSD-3-Clause // copyright-holders:David Haywood -#ifndef MAME_MACHINE_UPD777 -#define MAME_MACHINE_UPD777 +#ifndef MAME_CPU_UPD777_UPD777_DEV_H +#define MAME_CPU_UPD777_UPD777_DEV_H #pragma once #include "emupal.h" #include "screen.h" -#include "cpu/upd777/upd777.h" +#include "upd777.h" class upd777_device : public upd777_cpu_device { public: @@ -18,6 +18,8 @@ class upd777_device : public upd777_cpu_device { virtual void device_add_mconfig(machine_config &config) override; virtual const tiny_rom_entry *device_rom_region() const override; + virtual bool get_vbl_state() override; + private: uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); @@ -25,8 +27,9 @@ class upd777_device : public upd777_cpu_device { required_device m_gfxdecode; required_device m_palette; + required_device m_screen; }; DECLARE_DEVICE_TYPE(UPD777, upd777_device) -#endif // MAME_MACHINE_UPD777 +#endif // MAME_CPU_UPD777_UPD777_DEV_H diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index 45bdcb1a3fc0e..a06336986f34f 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -14,7 +14,7 @@ the linked 'design note' contains a large amount of useful information #include "bus/generic/slot.h" #include "bus/generic/carts.h" -#include "machine/upd777_dev.h" +#include "cpu/upd777/upd777_dev.h" #include "softlist_dev.h" @@ -53,7 +53,7 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) if (size != 0xf00) return std::make_pair(image_error::UNSUPPORTED, "prg region size must be 0xf00 in size"); - m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_LITTLE); + m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_BIG); m_cart->common_load_rom(m_cart->get_rom_base(), size, "prg"); uint8_t* prgbase = memregion("maincpu:prg")->base(); memcpy(prgbase, m_cart->get_rom_base(), size); From 70e793a42841b388b08808b34308f37faedc931a Mon Sep 17 00:00:00 2001 From: David Haywood Date: Mon, 8 Jan 2024 13:01:25 +0000 Subject: [PATCH 52/62] add a TODO note after some more experimentation --- src/devices/cpu/upd777/upd777_dev.cpp | 6 ++++-- src/devices/cpu/upd777/upd777_dev.h | 5 +++++ src/mame/epoch/cassvisn.cpp | 13 ++++++------- 3 files changed, 15 insertions(+), 9 deletions(-) diff --git a/src/devices/cpu/upd777/upd777_dev.cpp b/src/devices/cpu/upd777/upd777_dev.cpp index a914ee88001c4..9b11ec5e35d49 100644 --- a/src/devices/cpu/upd777/upd777_dev.cpp +++ b/src/devices/cpu/upd777/upd777_dev.cpp @@ -10,7 +10,9 @@ upd777_device::upd777_device(const machine_config &mconfig, const char *tag, dev upd777_cpu_device(mconfig, UPD777, tag, owner, clock), m_gfxdecode(*this, "gfxdecode"), m_palette(*this, "palette"), - m_screen(*this, "screen") + m_screen(*this, "screen"), + m_prgregion(*this, "prg"), + m_patregion(*this, "patterns") { } @@ -27,7 +29,7 @@ uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitma { bitmap.fill(0, cliprect); gfx_element *gfx = m_gfxdecode->gfx(0); - gfx_element *gfx2 = m_gfxdecode->gfx(0); + gfx_element *gfx2 = m_gfxdecode->gfx(1); for (int i = 0; i <= 0x18; i++) { diff --git a/src/devices/cpu/upd777/upd777_dev.h b/src/devices/cpu/upd777/upd777_dev.h index a18584f12c40d..f749c8e223af4 100644 --- a/src/devices/cpu/upd777/upd777_dev.h +++ b/src/devices/cpu/upd777/upd777_dev.h @@ -14,6 +14,9 @@ class upd777_device : public upd777_cpu_device { public: upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); + u16* get_prgregion() { return &m_prgregion[0]; } + u8* get_patregion() { return &m_patregion[0]; } + protected: virtual void device_add_mconfig(machine_config &config) override; virtual const tiny_rom_entry *device_rom_region() const override; @@ -28,6 +31,8 @@ class upd777_device : public upd777_cpu_device { required_device m_gfxdecode; required_device m_palette; required_device m_screen; + required_region_ptr m_prgregion; + required_region_ptr m_patregion; }; DECLARE_DEVICE_TYPE(UPD777, upd777_device) diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index a06336986f34f..393eec78dfe48 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -36,7 +36,7 @@ class cassvisn_state : public driver_device DECLARE_DEVICE_IMAGE_LOAD_MEMBER(cart_load); private: - required_device m_maincpu; + required_device m_maincpu; required_device m_cart; }; @@ -55,14 +55,13 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) m_cart->rom_alloc(size, GENERIC_ROM16_WIDTH, ENDIANNESS_BIG); m_cart->common_load_rom(m_cart->get_rom_base(), size, "prg"); - uint8_t* prgbase = memregion("maincpu:prg")->base(); + uint16_t* prgbase = m_maincpu->get_prgregion(); memcpy(prgbase, m_cart->get_rom_base(), size); - for (int i = 0; i < size; i += 2) + // TODO: why is this needed? doesn't matter if we set endianness to big or little + for (int i = 0; i < size / 2; i++) { - uint8_t temp = prgbase[i + 0]; - prgbase[i + 0] = prgbase[i + 1]; - prgbase[i + 1] = temp; + prgbase[i] = ((prgbase[i] & 0xff00) >> 8) | ((prgbase[i] & 0x00ff) << 8); } size = m_cart->common_get_size("pat"); @@ -70,7 +69,7 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) if (size != 0x4d0) return std::make_pair(image_error::UNSUPPORTED, "pat region size must be 0x4d0 in size"); - m_cart->common_load_rom(memregion("maincpu:patterns")->base(), size, "pat"); + m_cart->common_load_rom(m_maincpu->get_patregion(), size, "pat"); return std::make_pair(std::error_condition(), std::string()); } From e0e0fc3679db81ebe9ee6db178a7c843dfcd573f Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 12:55:21 +0000 Subject: [PATCH 53/62] fix an op --- src/devices/cpu/upd777/upd777.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index fead30d320eca..0635d9b8e0d76 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -709,12 +709,12 @@ void upd777_cpu_device::do_op() { if (!non) { - if (srcreg1 & srcreg2) + if ((srcreg1 & srcreg2) == 0) // skip if (x·y) makes zero, N->L[2:1] m_skip = 1; } else { - if (!(srcreg1 & srcreg2)) + if ((srcreg1 & srcreg2) != 0) // skip if (x·y) makes non zero, N->L[2:1] m_skip = 1; } break; @@ -728,12 +728,12 @@ void upd777_cpu_device::do_op() { if (!non) { - if (srcreg1 == srcreg2) + if (srcreg1 == srcreg2) // skip if (x-y) makes zero, N->L[2:1] m_skip = 1; } else { - if (!(srcreg1 == srcreg2)) + if (srcreg1 != srcreg2) // skip if (x-y) makes non zero, N->L[2:1] m_skip = 1; } break; @@ -744,12 +744,12 @@ void upd777_cpu_device::do_op() if (!non) { - if (result & 0x80) + if (result & 0x80) // skip if (x-y) makes borrow, N->L[2:1] m_skip = 1; } else { - if (!(result & 0x80)) + if ((result & 0x80) == 0) // skip if (x-y) makes non borrow, N->L[2:1] m_skip = 1; } From f5bbf155040b530304c656c4254ea33d951162b2 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 13:26:09 +0000 Subject: [PATCH 54/62] don't need these loggers now --- src/devices/cpu/upd777/upd777.cpp | 45 ++++--------------------------- src/devices/cpu/upd777/upd777.h | 5 ---- 2 files changed, 5 insertions(+), 45 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 0635d9b8e0d76..484deedca732d 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -67,6 +67,10 @@ void upd777_cpu_device::increment_pc() lowpc = (lowpc << 1) | nor; lowpc &= 0x7f; + // is returning to the start of the page the correct behavior? + if (lowpc == 0x00) + logerror("overflowing PC, returning to start of current page\n"); + m_pc = highpc | lowpc; } @@ -188,7 +192,7 @@ void upd777_cpu_device::set_new_pc(int newpc) m_pc = newpc; } -// L reg (lower memory pointer is 2 bit +// L reg (lower memory pointer) is 2 bit void upd777_cpu_device::set_l(int l) { m_l = l & 0x3; @@ -272,44 +276,6 @@ void upd777_cpu_device::write_data_mem(u8 addr, u8 data) m_data.write_byte(addr, data & 0x7f); } -// temporary, for the opcode logging -std::string upd777_cpu_device::get_300optype_name(int optype) -{ - switch (optype) - { - case 0x00: return "."; // 'AND' expressed as '·' in documentation, but disassembler isn't keen on that - case 0x01: return "+"; - case 0x02: return "v"; // 'OR' - case 0x03: return "-"; - } - return ""; -} - -std::string upd777_cpu_device::get_200optype_name(int optype) -{ - switch (optype) - { - case 0x00: return "."; // 'AND' expressed as '·' in documentation, but disassembler isn't keen on that - case 0x01: return ""; - case 0x02: return "="; - case 0x03: return "-"; - } - return ""; -} - -std::string upd777_cpu_device::get_reg_name(int reg) -{ - switch (reg) - { - case 0x00: return "A1"; // general reg A1 - case 0x01: return "A2"; // general reg A2 - case 0x02: return "M"; // content of memory - case 0x03: return "H"; // high address - } - return ""; -} - - void upd777_cpu_device::do_op() { const u16 inst = fetch(); @@ -681,7 +647,6 @@ void upd777_cpu_device::do_op() const int reg1 = (inst & 0xc0) >> 6; const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - //LOGMASKED(LOG_UNHANDLED_OPS, "2xx %s%s%s, 0x%d->L %s%s\n", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); u8 srcreg2 = 0; switch (reg2) { diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index abe0ed2e7ba5a..184f709743b8e 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -54,11 +54,6 @@ class upd777_cpu_device : public cpu_device memory_access<11, 1, -1, ENDIANNESS_BIG>::specific m_space; memory_access<8, 0, 0, ENDIANNESS_BIG>::specific m_data; - - std::string get_300optype_name(int optype); - std::string get_200optype_name(int optype); - std::string get_reg_name(int reg); - void increment_pc(); u16 fetch(); void do_op(); From 30359a39be9b4289268584036a4ed23b6f9d88a7 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 13:49:55 +0000 Subject: [PATCH 55/62] refactor --- src/devices/cpu/upd777/upd777.cpp | 100 +++++++++++------------------- src/devices/cpu/upd777/upd777.h | 3 + 2 files changed, 38 insertions(+), 65 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 484deedca732d..dedbd4030959e 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -245,6 +245,22 @@ u8 upd777_cpu_device::get_a2() { return m_a[1] & 0x7f; } u8 upd777_cpu_device::get_a3() { return m_a[2] & 0x7f; } u8 upd777_cpu_device::get_a4() { return m_a[3] & 0x7f; } +u8 upd777_cpu_device::get_a1_or_a2(int reg) +{ + if (reg == 0) + return get_a1(); + else + return get_a2(); +} + +void upd777_cpu_device::set_a1_or_a2(int reg, u8 value) +{ + if (reg == 0) + set_a1(value); + else + set_a2(value); +} + // FRS/FLS are the 2 7-bit sound registers void upd777_cpu_device::set_frs(u8 frs) { m_frs = frs & 0x7f; } void upd777_cpu_device::set_fls(u8 fls) { m_fls = fls & 0x7f; } @@ -344,10 +360,12 @@ void upd777_cpu_device::do_op() if (get_kie()) // documentation does not state if KIE or SME has priority { LOGMASKED(LOG_UNHANDLED_OPS, "KIE->M\n", k); + set_m_data(0); } else if (get_sme()) { LOGMASKED(LOG_UNHANDLED_OPS, "SME->M\n", k); + set_m_data(0); } else { @@ -417,6 +435,7 @@ void upd777_cpu_device::do_op() { // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] LOGMASKED(LOG_UNHANDLED_OPS, "H<->X\n"); +#if 1 // this opcode is not well explained! but X4 etc. are referenced on Data RAM & Register Files which makes // it even more confusing u8 temp; @@ -428,7 +447,7 @@ void upd777_cpu_device::do_op() temp = m_ldash; m_ldash = get_l(); set_l(temp); - +#endif break; } case 0b0000'0010'0000: @@ -647,13 +666,7 @@ void upd777_cpu_device::do_op() const int reg1 = (inst & 0xc0) >> 6; const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - u8 srcreg2 = 0; - switch (reg2) - { - case 0: srcreg2 = get_a1(); break; - case 1: srcreg2 = get_a2(); break; - } - + u8 srcreg2 = get_a1_or_a2(reg2); u8 srcreg1 = 0; switch (reg1) { @@ -927,17 +940,8 @@ void upd777_cpu_device::do_op() const int reg1 = (inst & 0x40) >> 6; const int n = inst & 0x3; - u8 src1 = 0; - if (reg1 == 0) - src1 = get_a1(); - else - src1 = get_a2(); - - u8 src2 = 0; - if (reg2 == 0) - src2 = get_a1(); - else - src2 = get_a2(); + u8 src1 = get_a1_or_a2(reg1); + u8 src2 = get_a1_or_a2(reg2); switch (optype) { @@ -949,6 +953,9 @@ void upd777_cpu_device::do_op() case 1: // ADD { src1 = src1 + src2; + // not in this case? + //if (src1 & 0x80) + // m_skip = 1; break; } case 2: // OR @@ -964,12 +971,7 @@ void upd777_cpu_device::do_op() break; } } - - if (reg1 == 0) - set_a1(src1); - else - set_a2(src1); - + set_a1_or_a2(reg1, src1); set_l(n); break; } @@ -981,11 +983,7 @@ void upd777_cpu_device::do_op() // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - u8 src = 0; - if (reg == 0) - src = get_a1(); - else - src = get_a2(); + u8 src = get_a1_or_a2(reg); set_m_data(src); set_l(n); break; @@ -998,17 +996,10 @@ void upd777_cpu_device::do_op() // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - u8 src = 0; - if (reg == 0) - src = get_a1(); - else - src = get_a2(); + u8 src = get_a1_or_a2(reg); u8 m = get_m_data(); set_m_data(src); - if (reg == 0) - set_a1(m); - else - set_a2(m); + set_a1_or_a2(reg,m); set_l(n); break; } @@ -1021,10 +1012,7 @@ void upd777_cpu_device::do_op() const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; u8 m = get_m_data(); - if (reg == 0) - set_a1(m); - else - set_a2(m); + set_a1_or_a2(reg,m); set_l(n); break; } @@ -1049,13 +1037,7 @@ void upd777_cpu_device::do_op() const int optype = (inst & 0x0c) >> 2; const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - - u8 src2 = 0; - if (reg2 == 0) - src2 = get_a1(); - else - src2 = get_a2(); - + u8 src2 = get_a1_or_a2(reg2); u8 m = get_m_data(); switch (optype) @@ -1110,12 +1092,7 @@ void upd777_cpu_device::do_op() const int optype = (inst & 0x0c) >> 2; const int reg2 = (inst & 0x10) >> 4; const int n = inst & 0x3; - u8 src2 = 0; - if (reg2 == 0) - src2 = get_a1() & 0x1f; - else - src2 = get_a2() & 0x1f; - + u8 src2 = get_a1_or_a2(reg2) & 0x1f; u8 h = get_h(); switch (optype) @@ -1155,11 +1132,7 @@ void upd777_cpu_device::do_op() // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; - u8 src = 0; - if (reg == 0) - src = get_a1() & 0x1f; - else - src = get_a2() & 0x1f; + u8 src = get_a1_or_a2(reg); set_h(src); set_l(n); break; @@ -1172,10 +1145,7 @@ void upd777_cpu_device::do_op() const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; u8 h = get_h() & 0x1f; - if (reg == 0) - set_a1(h); - else - set_a2(h); + set_a1_or_a2(reg,h); set_l(n); break; } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 184f709743b8e..f74e6071c932a 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -96,6 +96,9 @@ class upd777_cpu_device : public cpu_device u8 get_a3(); u8 get_a4(); + u8 get_a1_or_a2(int reg); + void set_a1_or_a2(int reg, u8 value); + u32 m_ppc; u32 m_pc; s32 m_icount; From 99020df37956d8262675068c02f3e15319ecc567 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 14:45:52 +0000 Subject: [PATCH 56/62] combine files since apparently there is no rule against this anymore --- scripts/src/cpu.lua | 2 - src/devices/cpu/upd777/upd777.cpp | 141 +++++++++++++++++++++++++- src/devices/cpu/upd777/upd777.h | 28 ++++- src/devices/cpu/upd777/upd777_dev.cpp | 140 ------------------------- src/devices/cpu/upd777/upd777_dev.h | 40 -------- src/mame/epoch/cassvisn.cpp | 5 +- 6 files changed, 168 insertions(+), 188 deletions(-) delete mode 100644 src/devices/cpu/upd777/upd777_dev.cpp delete mode 100644 src/devices/cpu/upd777/upd777_dev.h diff --git a/scripts/src/cpu.lua b/scripts/src/cpu.lua index cee50a48f5fb8..64f7e093a277a 100644 --- a/scripts/src/cpu.lua +++ b/scripts/src/cpu.lua @@ -3959,8 +3959,6 @@ if CPUS["UPD777"] then files { MAME_DIR .. "src/devices/cpu/upd777/upd777.cpp", MAME_DIR .. "src/devices/cpu/upd777/upd777.h", - MAME_DIR .. "src/devices/cpu/upd777/upd777_dev.cpp", - MAME_DIR .. "src/devices/cpu/upd777/upd777_dev.h", } end diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index dedbd4030959e..d2d8213bee485 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -10,17 +10,23 @@ #define VERBOSE (LOG_UNHANDLED_OPS) #include "logmacro.h" +DEFINE_DEVICE_TYPE(UPD777, upd777_cpu_device, "upd777", "uPD777") upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data) : cpu_device(mconfig, type, tag, owner, clock) , m_datamem(*this, "datamem") , m_space_config("program", ENDIANNESS_BIG, 16, 11, -1, address_map_constructor(FUNC(upd777_cpu_device::internal_map), this)) , m_data_config("data", ENDIANNESS_BIG, 8, 7, 0, data) + , m_gfxdecode(*this, "gfxdecode") + , m_palette(*this, "palette") + , m_screen(*this, "screen") + , m_prgregion(*this, "prg") + , m_patregion(*this, "patterns") { } -upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock) - : upd777_cpu_device(mconfig, type, tag, owner, clock, address_map_constructor(FUNC(upd777_cpu_device::internal_data_map), this)) +upd777_cpu_device::upd777_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : upd777_cpu_device(mconfig, UPD777, tag, owner, clock, address_map_constructor(FUNC(upd777_cpu_device::internal_data_map), this)) { } @@ -1216,3 +1222,134 @@ void upd777_cpu_device::execute_run() void upd777_cpu_device::execute_set_input(int inputnum, int state) { } + + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +bool upd777_cpu_device::get_vbl_state() +{ + int vpos = m_screen->vpos(); + if (vpos > 240) + return true; + + return false; +} + +uint32_t upd777_cpu_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) +{ + bitmap.fill(0, cliprect); + gfx_element *gfx = m_gfxdecode->gfx(0); + gfx_element *gfx2 = m_gfxdecode->gfx(1); + + for (int i = 0; i <= 0x18; i++) + { + u8 s0 = m_datamem[(i * 4) + 0]; + u8 s1 = m_datamem[(i * 4) + 1]; + u8 s2 = m_datamem[(i * 4) + 2]; + u8 s3 = m_datamem[(i * 4) + 3]; + + int ypos = (s0 & 0x7e) >> 1; + //int prio = (s0 & 0x01); + int xpos = (s1 & 0x7f); + int patn = (s2 & 0x7f); + //int ylow = (s3 & 0x70); + int pal = (s3 & 0x0e) >> 1; + //int ysub = (s3 & 0x01); + + if (patn<0x70) + gfx->zoom_transpen(bitmap, cliprect, patn, pal, 0, 0, xpos * 4, ypos * 4, 0x40000, 0x40000, 0); + else + gfx2->zoom_transpen(bitmap, cliprect, patn-0x70, pal, 0, 0, xpos * 4, ypos * 4, 0x40000, 0x40000, 0); + } + + return 0; +} + +// documentation says patterns 0x00 - 0x6e are 7x7 +// and patterns 0x70 - 0x7e are 8x7 +// but they all seem to be stored at 11x7, just with some columns blank? +// this is probably because of how they were read out, over 11 data lines + +// 0x00-0x2f are 'Normal (7x7) +// 0x30-0x67 are 'Bent' (7x7) +// 0x68-0x6f are 'Y Repeat' (7x7) +// 0x70-0x77 are 'XY Repeat' (8x7) +// 0x78-0x7f are 'X Repeat' (8x7) +// +// NOTE, sprite patterns *7 and *f are unused so documentation expresses these ranges as to 66, 6e etc. rather than 67 6f +// +// it isn't clear how the 'Bent' effect etc. is enabled, as clearly not all patterns in this range should use it? + +static const gfx_layout test_layout = +{ + 7,7, + 0x70, + 1, + { 0 }, + { 4,5,6,7,8,9,10 }, + { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, + 7*11 +}; + +static const gfx_layout test2_layout = +{ + 8,7, + 0x10, + 1, + { 0 }, + { 3,4,5,6,7,8,9,10 }, + { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, + 7*11 +}; + +static GFXDECODE_START( gfx_ud777 ) + GFXDECODE_ENTRY( "patterns", 0x000, test_layout, 0, 8 ) + GFXDECODE_ENTRY( "patterns", 0x436, test2_layout, 0, 8 ) +GFXDECODE_END + + +void upd777_cpu_device::palette_init(palette_device &palette) const +{ + // just a fake palette for now + for (int i = 0; i < palette.entries(); i++) + { + if (i & 1) + { + palette.set_pen_color(i, rgb_t(((i >> 1) & 1) ? 0xff : 0x7f, ((i >> 2) & 1) ? 0xff : 0x7f, ((i >> 3) & 1) ? 0xff : 0x7f)); + } + else + { + palette.set_pen_color(i, rgb_t(0, 0, 0)); + } + } +} + +void upd777_cpu_device::device_add_mconfig(machine_config &config) +{ + // or pass the screen from the driver? + SCREEN(config, m_screen, SCREEN_TYPE_RASTER); + m_screen->set_refresh_hz(60); + m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2000)); + m_screen->set_size(512, 256); + m_screen->set_visarea(0, 512-1, 0, 256-0-1); + m_screen->set_screen_update(FUNC(upd777_cpu_device::screen_update)); + m_screen->set_palette(m_palette); + + GFXDECODE(config, m_gfxdecode, m_palette, gfx_ud777); + PALETTE(config, m_palette, FUNC(upd777_cpu_device::palette_init), 32 * 3).set_entries(0x10); +} + +ROM_START( upd777 ) + ROM_REGION16_BE( 0x1000, "prg", ROMREGION_ERASEFF ) + ROM_REGION( 0x4d0, "patterns", ROMREGION_ERASEFF ) +ROM_END + +const tiny_rom_entry *upd777_cpu_device::device_rom_region() const +{ + return ROM_NAME(upd777); +} + diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index f74e6071c932a..d765679a7af6a 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -6,10 +6,13 @@ #pragma once +#include "emupal.h" +#include "screen.h" class upd777_cpu_device : public cpu_device { public: + upd777_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); enum { UPD777_PC = 0, @@ -26,8 +29,10 @@ class upd777_cpu_device : public cpu_device UPD777_ADDR_STACK_POS, }; + u16* get_prgregion() { return &m_prgregion[0]; } + u8* get_patregion() { return &m_patregion[0]; } + protected: - upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock); upd777_cpu_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, address_map_constructor data); virtual void device_start() override; @@ -36,11 +41,15 @@ class upd777_cpu_device : public cpu_device virtual void execute_run() override; virtual void execute_set_input(int inputnum, int state) override; + virtual void device_add_mconfig(machine_config &config) override; + virtual const tiny_rom_entry *device_rom_region() const override; + virtual std::unique_ptr create_disassembler() override; virtual space_config_vector memory_space_config() const override; - virtual bool get_vbl_state() = 0; + bool get_vbl_state(); + void internal_map(address_map &map); void internal_data_map(address_map &map); @@ -123,6 +132,21 @@ class upd777_cpu_device : public cpu_device u8 m_gpe; u8 m_kie; u8 m_sme; + + ///////////////////////////////////// VIDEO RELATED + + uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); + + void palette_init(palette_device &palette) const; + + required_device m_gfxdecode; + required_device m_palette; + required_device m_screen; + required_region_ptr m_prgregion; + required_region_ptr m_patregion; + }; +DECLARE_DEVICE_TYPE(UPD777, upd777_cpu_device) + #endif // MAME_CPU_UPD777_UPD777_H diff --git a/src/devices/cpu/upd777/upd777_dev.cpp b/src/devices/cpu/upd777/upd777_dev.cpp deleted file mode 100644 index 9b11ec5e35d49..0000000000000 --- a/src/devices/cpu/upd777/upd777_dev.cpp +++ /dev/null @@ -1,140 +0,0 @@ -// license:BSD-3-Clause -// copyright-holders:David Haywood - -#include "emu.h" -#include "upd777_dev.h" - -DEFINE_DEVICE_TYPE(UPD777, upd777_device, "upd777", "uPD777") - -upd777_device::upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : - upd777_cpu_device(mconfig, UPD777, tag, owner, clock), - m_gfxdecode(*this, "gfxdecode"), - m_palette(*this, "palette"), - m_screen(*this, "screen"), - m_prgregion(*this, "prg"), - m_patregion(*this, "patterns") -{ -} - -bool upd777_device::get_vbl_state() -{ - int vpos = m_screen->vpos(); - if (vpos > 240) - return true; - - return false; -} - -uint32_t upd777_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) -{ - bitmap.fill(0, cliprect); - gfx_element *gfx = m_gfxdecode->gfx(0); - gfx_element *gfx2 = m_gfxdecode->gfx(1); - - for (int i = 0; i <= 0x18; i++) - { - u8 s0 = m_datamem[(i * 4) + 0]; - u8 s1 = m_datamem[(i * 4) + 1]; - u8 s2 = m_datamem[(i * 4) + 2]; - u8 s3 = m_datamem[(i * 4) + 3]; - - int ypos = (s0 & 0x7e) >> 1; - //int prio = (s0 & 0x01); - int xpos = (s1 & 0x7f); - int patn = (s2 & 0x7f); - //int ylow = (s3 & 0x70); - int pal = (s3 & 0x0e) >> 1; - //int ysub = (s3 & 0x01); - - if (patn<0x70) - gfx->zoom_transpen(bitmap, cliprect, patn, pal, 0, 0, xpos * 4, ypos * 4, 0x40000, 0x40000, 0); - else - gfx2->zoom_transpen(bitmap, cliprect, patn-0x70, pal, 0, 0, xpos * 4, ypos * 4, 0x40000, 0x40000, 0); - } - - return 0; -} - -// documentation says patterns 0x00 - 0x6e are 7x7 -// and patterns 0x70 - 0x7e are 8x7 -// but they all seem to be stored at 11x7, just with some columns blank? -// this is probably because of how they were read out, over 11 data lines - -// 0x00-0x2f are 'Normal (7x7) -// 0x30-0x67 are 'Bent' (7x7) -// 0x68-0x6f are 'Y Repeat' (7x7) -// 0x70-0x77 are 'XY Repeat' (8x7) -// 0x78-0x7f are 'X Repeat' (8x7) -// -// NOTE, sprite patterns *7 and *f are unused so documentation expresses these ranges as to 66, 6e etc. rather than 67 6f -// -// it isn't clear how the 'Bent' effect etc. is enabled, as clearly not all patterns in this range should use it? - -static const gfx_layout test_layout = -{ - 7,7, - 0x70, - 1, - { 0 }, - { 4,5,6,7,8,9,10 }, - { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, - 7*11 -}; - -static const gfx_layout test2_layout = -{ - 8,7, - 0x10, - 1, - { 0 }, - { 3,4,5,6,7,8,9,10 }, - { 0*11,1*11,2*11,3*11,4*11,5*11,6*11 }, - 7*11 -}; - -static GFXDECODE_START( gfx_ud777 ) - GFXDECODE_ENTRY( "patterns", 0x000, test_layout, 0, 8 ) - GFXDECODE_ENTRY( "patterns", 0x436, test2_layout, 0, 8 ) -GFXDECODE_END - - -void upd777_device::palette_init(palette_device &palette) const -{ - // just a fake palette for now - for (int i = 0; i < palette.entries(); i++) - { - if (i & 1) - { - palette.set_pen_color(i, rgb_t(((i >> 1) & 1) ? 0xff : 0x7f, ((i >> 2) & 1) ? 0xff : 0x7f, ((i >> 3) & 1) ? 0xff : 0x7f)); - } - else - { - palette.set_pen_color(i, rgb_t(0, 0, 0)); - } - } -} - -void upd777_device::device_add_mconfig(machine_config &config) -{ - // or pass the screen from the driver? - SCREEN(config, m_screen, SCREEN_TYPE_RASTER); - m_screen->set_refresh_hz(60); - m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2000)); - m_screen->set_size(512, 256); - m_screen->set_visarea(0, 512-1, 0, 256-0-1); - m_screen->set_screen_update(FUNC(upd777_device::screen_update)); - m_screen->set_palette(m_palette); - - GFXDECODE(config, m_gfxdecode, m_palette, gfx_ud777); - PALETTE(config, m_palette, FUNC(upd777_device::palette_init), 32 * 3).set_entries(0x10); -} - -ROM_START( upd777 ) - ROM_REGION16_BE( 0x1000, "prg", ROMREGION_ERASEFF ) - ROM_REGION( 0x4d0, "patterns", ROMREGION_ERASEFF ) -ROM_END - -const tiny_rom_entry *upd777_device::device_rom_region() const -{ - return ROM_NAME(upd777); -} diff --git a/src/devices/cpu/upd777/upd777_dev.h b/src/devices/cpu/upd777/upd777_dev.h deleted file mode 100644 index f749c8e223af4..0000000000000 --- a/src/devices/cpu/upd777/upd777_dev.h +++ /dev/null @@ -1,40 +0,0 @@ -// license:BSD-3-Clause -// copyright-holders:David Haywood -#ifndef MAME_CPU_UPD777_UPD777_DEV_H -#define MAME_CPU_UPD777_UPD777_DEV_H - -#pragma once - -#include "emupal.h" -#include "screen.h" - -#include "upd777.h" - -class upd777_device : public upd777_cpu_device { -public: - upd777_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); - - u16* get_prgregion() { return &m_prgregion[0]; } - u8* get_patregion() { return &m_patregion[0]; } - -protected: - virtual void device_add_mconfig(machine_config &config) override; - virtual const tiny_rom_entry *device_rom_region() const override; - - virtual bool get_vbl_state() override; - -private: - uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); - - void palette_init(palette_device &palette) const; - - required_device m_gfxdecode; - required_device m_palette; - required_device m_screen; - required_region_ptr m_prgregion; - required_region_ptr m_patregion; -}; - -DECLARE_DEVICE_TYPE(UPD777, upd777_device) - -#endif // MAME_CPU_UPD777_UPD777_DEV_H diff --git a/src/mame/epoch/cassvisn.cpp b/src/mame/epoch/cassvisn.cpp index 393eec78dfe48..00c49c0f17707 100644 --- a/src/mame/epoch/cassvisn.cpp +++ b/src/mame/epoch/cassvisn.cpp @@ -14,7 +14,7 @@ the linked 'design note' contains a large amount of useful information #include "bus/generic/slot.h" #include "bus/generic/carts.h" -#include "cpu/upd777/upd777_dev.h" +#include "cpu/upd777/upd777.h" #include "softlist_dev.h" @@ -36,7 +36,7 @@ class cassvisn_state : public driver_device DECLARE_DEVICE_IMAGE_LOAD_MEMBER(cart_load); private: - required_device m_maincpu; + required_device m_maincpu; required_device m_cart; }; @@ -70,6 +70,7 @@ DEVICE_IMAGE_LOAD_MEMBER(cassvisn_state::cart_load) return std::make_pair(image_error::UNSUPPORTED, "pat region size must be 0x4d0 in size"); m_cart->common_load_rom(m_maincpu->get_patregion(), size, "pat"); + return std::make_pair(std::error_condition(), std::string()); } From 778dc696a44c8bc3c36675da29290a45d155d72b Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 15:13:10 +0000 Subject: [PATCH 57/62] video thoughts --- src/devices/cpu/upd777/upd777.cpp | 52 ++++++++++++++++++++++++++++--- src/devices/cpu/upd777/upd777.h | 7 +++++ 2 files changed, 54 insertions(+), 5 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index d2d8213bee485..22df203921c00 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -5,6 +5,7 @@ #include "upd777.h" #include "upd777dasm.h" + #define LOG_UNHANDLED_OPS (1U << 1) #define VERBOSE (LOG_UNHANDLED_OPS) @@ -434,7 +435,15 @@ void upd777_cpu_device::do_op() { // 008 Move H[5:1] to Line Buffer Register[5:1] u8 h = get_h(); - LOGMASKED(LOG_UNHANDLED_OPS, "H(%02x)->NRM\n", h); + //LOGMASKED(LOG_UNHANDLED_OPS, "H(%02x)->NRM\n", h); + + // this seems to push a value from RAM into the line buffer for the current 4(?) scanlines + u8 m1 = read_data_mem(get_h_shifted() | 0); + u8 m2 = read_data_mem(get_h_shifted() | 1); + u8 m3 = read_data_mem(get_h_shifted() | 2); + u8 m4 = read_data_mem(get_h_shifted() | 3); + push_to_line_buffer(h, m1,m2,m3,m4); + break; } case 0b0000'0001'1000: @@ -443,7 +452,7 @@ void upd777_cpu_device::do_op() LOGMASKED(LOG_UNHANDLED_OPS, "H<->X\n"); #if 1 // this opcode is not well explained! but X4 etc. are referenced on Data RAM & Register Files which makes - // it even more confusing + // it even more confusing (while L' isn't referenced anywhere else at all!) u8 temp; temp = m_x4; @@ -496,14 +505,15 @@ void upd777_cpu_device::do_op() case 0b0000'0100'1001: { // 049 Skip if (4H Horizontal Blank) = 1 - LOGMASKED(LOG_UNHANDLED_OPS, "4H BLK\n"); - m_skip = 1; + //LOGMASKED(LOG_UNHANDLED_OPS, "4H BLK\n"); + if (get_hbl_4_state()) + m_skip = 1; break; } case 0b0000'0100'1010: { // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] - LOGMASKED(LOG_UNHANDLED_OPS, "VBLK\n"); + //LOGMASKED(LOG_UNHANDLED_OPS, "VBLK\n"); if (get_vbl_state()) m_skip = 1; @@ -565,6 +575,7 @@ void upd777_cpu_device::do_op() break; } + // 0b0010'rrnR'oo00 where rr = reg1 (A1, A2, M or H), n = invert condition, R = reg2 (A1 or A2) and oo = optype (only 0,2,3 are valid, no cases here for 1) case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: @@ -1239,8 +1250,25 @@ bool upd777_cpu_device::get_vbl_state() return false; } +bool upd777_cpu_device::get_hbl_4_state() +{ + // I *think* this is Hblank for every 4th line (so a new display list can be written?) + int vpos = m_screen->vpos(); + if ((vpos % 4) == 0) + { + int hpos = m_screen->hpos(); + if (hpos > 200) + return true; + } + + return false; +} + uint32_t upd777_cpu_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { + // this needs to be scanline based, drawing whatever has been pushed to the linebuffer for the current + // group of scanlines! + bitmap.fill(0, cliprect); gfx_element *gfx = m_gfxdecode->gfx(0); gfx_element *gfx2 = m_gfxdecode->gfx(1); @@ -1328,6 +1356,18 @@ void upd777_cpu_device::palette_init(palette_device &palette) const } } +void upd777_cpu_device::push_to_line_buffer(u8 h, u8 m1, u8 m2, u8 m3, u8 m4) +{ + logerror("sprite %02x pushed to line buffer at scanline %d hpos %d: details %02x %02x %02x %02x\n", h, m_screen->vpos(), m_screen->hpos(), m1, m2, m3, m4); +} + +TIMER_DEVICE_CALLBACK_MEMBER(upd777_cpu_device::scanline_timer) +{ + int scanline = param; + + logerror("scanline %d\n", scanline); +} + void upd777_cpu_device::device_add_mconfig(machine_config &config) { // or pass the screen from the driver? @@ -1339,6 +1379,8 @@ void upd777_cpu_device::device_add_mconfig(machine_config &config) m_screen->set_screen_update(FUNC(upd777_cpu_device::screen_update)); m_screen->set_palette(m_palette); + TIMER(config, "scantimer").configure_scanline(FUNC(upd777_cpu_device::scanline_timer), "screen", 0, 1); + GFXDECODE(config, m_gfxdecode, m_palette, gfx_ud777); PALETTE(config, m_palette, FUNC(upd777_cpu_device::palette_init), 32 * 3).set_entries(0x10); } diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index d765679a7af6a..56fa3e8844279 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -9,6 +9,8 @@ #include "emupal.h" #include "screen.h" +#include "machine/timer.h" + class upd777_cpu_device : public cpu_device { public: @@ -49,6 +51,7 @@ class upd777_cpu_device : public cpu_device virtual space_config_vector memory_space_config() const override; bool get_vbl_state(); + bool get_hbl_4_state(); void internal_map(address_map &map); @@ -137,8 +140,12 @@ class upd777_cpu_device : public cpu_device uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); + void push_to_line_buffer(u8 h, u8 m1, u8 m2, u8 m3, u8 m4); + void palette_init(palette_device &palette) const; + TIMER_DEVICE_CALLBACK_MEMBER(scanline_timer); + required_device m_gfxdecode; required_device m_palette; required_device m_screen; From 4112eef78c4fc97ebae214e8941a72efa2fe7250 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 15:28:13 +0000 Subject: [PATCH 58/62] prepare to abandon this --- src/devices/cpu/upd777/upd777.cpp | 365 +++++++++++++------------- src/devices/cpu/upd777/upd777dasm.cpp | 226 ++++++++-------- 2 files changed, 297 insertions(+), 294 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 22df203921c00..8d3d0dbcc3cea 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -415,6 +415,189 @@ void upd777_cpu_device::do_op() push_to_stack(m_pc); set_new_pc(k); } + else if (((inst & 0b1111'0000'0000) == 0b0010'0000'0000) && ((inst & 0b0000'0000'1100) != 0b0000'0000'0100)) + { + // 0b0010'rrnR'oonn where rr = reg1 (A1, A2, M or H), n = invert condition, R = reg2 (A1 or A2) and oo = optype (only 0,2,3 are valid, no cases here for 1) nn = next l value + // the above 'if' statement is a shit way of representing the following bitfields +#if 0 + case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: + case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: + case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: + case 0b0010'0010'1000: case 0b0010'0010'1001: case 0b0010'0010'1010: case 0b0010'0010'1011: + case 0b0010'0000'1100: case 0b0010'0000'1101: case 0b0010'0000'1110: case 0b0010'0000'1111: + case 0b0010'0010'1100: case 0b0010'0010'1101: case 0b0010'0010'1110: case 0b0010'0010'1111: + case 0b0010'0001'0000: case 0b0010'0001'0001: case 0b0010'0001'0010: case 0b0010'0001'0011: + case 0b0010'0011'0000: case 0b0010'0011'0001: case 0b0010'0011'0010: case 0b0010'0011'0011: + case 0b0010'0001'1000: case 0b0010'0001'1001: case 0b0010'0001'1010: case 0b0010'0001'1011: + case 0b0010'0011'1000: case 0b0010'0011'1001: case 0b0010'0011'1010: case 0b0010'0011'1011: + case 0b0010'0001'1100: case 0b0010'0001'1101: case 0b0010'0001'1110: case 0b0010'0001'1111: + case 0b0010'0011'1100: case 0b0010'0011'1101: case 0b0010'0011'1110: case 0b0010'0011'1111: + case 0b0010'0100'0000: case 0b0010'0100'0001: case 0b0010'0100'0010: case 0b0010'0100'0011: + case 0b0010'0110'0000: case 0b0010'0110'0001: case 0b0010'0110'0010: case 0b0010'0110'0011: + case 0b0010'0100'1000: case 0b0010'0100'1001: case 0b0010'0100'1010: case 0b0010'0100'1011: + case 0b0010'0110'1000: case 0b0010'0110'1001: case 0b0010'0110'1010: case 0b0010'0110'1011: + case 0b0010'0100'1100: case 0b0010'0100'1101: case 0b0010'0100'1110: case 0b0010'0100'1111: + case 0b0010'0110'1100: case 0b0010'0110'1101: case 0b0010'0110'1110: case 0b0010'0110'1111: + case 0b0010'0101'0000: case 0b0010'0101'0001: case 0b0010'0101'0010: case 0b0010'0101'0011: + case 0b0010'0111'0000: case 0b0010'0111'0001: case 0b0010'0111'0010: case 0b0010'0111'0011: + case 0b0010'0101'1000: case 0b0010'0101'1001: case 0b0010'0101'1010: case 0b0010'0101'1011: + case 0b0010'0111'1000: case 0b0010'0111'1001: case 0b0010'0111'1010: case 0b0010'0111'1011: + case 0b0010'0101'1100: case 0b0010'0101'1101: case 0b0010'0101'1110: case 0b0010'0101'1111: + case 0b0010'0111'1100: case 0b0010'0111'1101: case 0b0010'0111'1110: case 0b0010'0111'1111: + case 0b0010'1000'0000: case 0b0010'1000'0001: case 0b0010'1000'0010: case 0b0010'1000'0011: + case 0b0010'1010'0000: case 0b0010'1010'0001: case 0b0010'1010'0010: case 0b0010'1010'0011: + case 0b0010'1000'1000: case 0b0010'1000'1001: case 0b0010'1000'1010: case 0b0010'1000'1011: + case 0b0010'1010'1000: case 0b0010'1010'1001: case 0b0010'1010'1010: case 0b0010'1010'1011: + case 0b0010'1000'1100: case 0b0010'1000'1101: case 0b0010'1000'1110: case 0b0010'1000'1111: + case 0b0010'1010'1100: case 0b0010'1010'1101: case 0b0010'1010'1110: case 0b0010'1010'1111: + case 0b0010'1001'0000: case 0b0010'1001'0001: case 0b0010'1001'0010: case 0b0010'1001'0011: + case 0b0010'1011'0000: case 0b0010'1011'0001: case 0b0010'1011'0010: case 0b0010'1011'0011: + case 0b0010'1001'1000: case 0b0010'1001'1001: case 0b0010'1001'1010: case 0b0010'1001'1011: + case 0b0010'1011'1000: case 0b0010'1011'1001: case 0b0010'1011'1010: case 0b0010'1011'1011: + case 0b0010'1001'1100: case 0b0010'1001'1101: case 0b0010'1001'1110: case 0b0010'1001'1111: + case 0b0010'1011'1100: case 0b0010'1011'1101: case 0b0010'1011'1110: case 0b0010'1011'1111: + case 0b0010'1100'0000: case 0b0010'1100'0001: case 0b0010'1100'0010: case 0b0010'1100'0011: + case 0b0010'1110'0000: case 0b0010'1110'0001: case 0b0010'1110'0010: case 0b0010'1110'0011: + case 0b0010'1100'1000: case 0b0010'1100'1001: case 0b0010'1100'1010: case 0b0010'1100'1011: + case 0b0010'1110'1000: case 0b0010'1110'1001: case 0b0010'1110'1010: case 0b0010'1110'1011: + case 0b0010'1100'1100: case 0b0010'1100'1101: case 0b0010'1100'1110: case 0b0010'1100'1111: + case 0b0010'1110'1100: case 0b0010'1110'1101: case 0b0010'1110'1110: case 0b0010'1110'1111: + case 0b0010'1101'0000: case 0b0010'1101'0001: case 0b0010'1101'0010: case 0b0010'1101'0011: + case 0b0010'1111'0000: case 0b0010'1111'0001: case 0b0010'1111'0010: case 0b0010'1111'0011: + case 0b0010'1101'1000: case 0b0010'1101'1001: case 0b0010'1101'1010: case 0b0010'1101'1011: + case 0b0010'1111'1000: case 0b0010'1111'1001: case 0b0010'1111'1010: case 0b0010'1111'1011: + case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: + case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: +#endif + // optype · (AND) + // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] + // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] + // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] + // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] + // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] + // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] + + // optype = (these are expressed as x=y in the opcopde syntax, but x-y in the description, in reality it seems to act as 'CMP' so x-y = 0) + // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] + // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] + // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] + // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] + // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] + // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] + // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] + // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] + + // optype - + // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] + // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] + // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] + // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] + const int non = inst & 0x20; + const int optype = (inst & 0x0c) >> 2; + const int reg1 = (inst & 0xc0) >> 6; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + u8 srcreg2 = get_a1_or_a2(reg2); + u8 srcreg1 = 0; + switch (reg1) + { + case 0: srcreg1 = get_a1(); break; + case 1: srcreg1 = get_a2(); break; + case 2: srcreg1 = get_m_data(); break; + case 3: + { + srcreg1 = get_h(); + srcreg2 &= 0x1f; + break; + } + } + + switch (optype) + { + case 0: // AND + { + if (!non) + { + if ((srcreg1 & srcreg2) == 0) // skip if (x·y) makes zero, N->L[2:1] + m_skip = 1; + } + else + { + if ((srcreg1 & srcreg2) != 0) // skip if (x·y) makes non zero, N->L[2:1] + m_skip = 1; + } + break; + } + case 1: // invalid + { + // can't happen, no switch case leads here + break; + } + case 2: // = + { + if (!non) + { + if (srcreg1 == srcreg2) // skip if (x-y) makes zero, N->L[2:1] + m_skip = 1; + } + else + { + if (srcreg1 != srcreg2) // skip if (x-y) makes non zero, N->L[2:1] + m_skip = 1; + } + break; + } + case 3: // - + { + u8 result = srcreg1 - srcreg2; + + if (!non) + { + if (result & 0x80) // skip if (x-y) makes borrow, N->L[2:1] + m_skip = 1; + } + else + { + if ((result & 0x80) == 0) // skip if (x-y) makes non borrow, N->L[2:1] + m_skip = 1; + } + + break; + } + } + + set_l(n); + } else { switch (inst) @@ -574,188 +757,6 @@ void upd777_cpu_device::do_op() m_skip = 1; break; } - - // 0b0010'rrnR'oo00 where rr = reg1 (A1, A2, M or H), n = invert condition, R = reg2 (A1 or A2) and oo = optype (only 0,2,3 are valid, no cases here for 1) - case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: - case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: - case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: - case 0b0010'0010'1000: case 0b0010'0010'1001: case 0b0010'0010'1010: case 0b0010'0010'1011: - case 0b0010'0000'1100: case 0b0010'0000'1101: case 0b0010'0000'1110: case 0b0010'0000'1111: - case 0b0010'0010'1100: case 0b0010'0010'1101: case 0b0010'0010'1110: case 0b0010'0010'1111: - case 0b0010'0001'0000: case 0b0010'0001'0001: case 0b0010'0001'0010: case 0b0010'0001'0011: - case 0b0010'0011'0000: case 0b0010'0011'0001: case 0b0010'0011'0010: case 0b0010'0011'0011: - case 0b0010'0001'1000: case 0b0010'0001'1001: case 0b0010'0001'1010: case 0b0010'0001'1011: - case 0b0010'0011'1000: case 0b0010'0011'1001: case 0b0010'0011'1010: case 0b0010'0011'1011: - case 0b0010'0001'1100: case 0b0010'0001'1101: case 0b0010'0001'1110: case 0b0010'0001'1111: - case 0b0010'0011'1100: case 0b0010'0011'1101: case 0b0010'0011'1110: case 0b0010'0011'1111: - case 0b0010'0100'0000: case 0b0010'0100'0001: case 0b0010'0100'0010: case 0b0010'0100'0011: - case 0b0010'0110'0000: case 0b0010'0110'0001: case 0b0010'0110'0010: case 0b0010'0110'0011: - case 0b0010'0100'1000: case 0b0010'0100'1001: case 0b0010'0100'1010: case 0b0010'0100'1011: - case 0b0010'0110'1000: case 0b0010'0110'1001: case 0b0010'0110'1010: case 0b0010'0110'1011: - case 0b0010'0100'1100: case 0b0010'0100'1101: case 0b0010'0100'1110: case 0b0010'0100'1111: - case 0b0010'0110'1100: case 0b0010'0110'1101: case 0b0010'0110'1110: case 0b0010'0110'1111: - case 0b0010'0101'0000: case 0b0010'0101'0001: case 0b0010'0101'0010: case 0b0010'0101'0011: - case 0b0010'0111'0000: case 0b0010'0111'0001: case 0b0010'0111'0010: case 0b0010'0111'0011: - case 0b0010'0101'1000: case 0b0010'0101'1001: case 0b0010'0101'1010: case 0b0010'0101'1011: - case 0b0010'0111'1000: case 0b0010'0111'1001: case 0b0010'0111'1010: case 0b0010'0111'1011: - case 0b0010'0101'1100: case 0b0010'0101'1101: case 0b0010'0101'1110: case 0b0010'0101'1111: - case 0b0010'0111'1100: case 0b0010'0111'1101: case 0b0010'0111'1110: case 0b0010'0111'1111: - case 0b0010'1000'0000: case 0b0010'1000'0001: case 0b0010'1000'0010: case 0b0010'1000'0011: - case 0b0010'1010'0000: case 0b0010'1010'0001: case 0b0010'1010'0010: case 0b0010'1010'0011: - case 0b0010'1000'1000: case 0b0010'1000'1001: case 0b0010'1000'1010: case 0b0010'1000'1011: - case 0b0010'1010'1000: case 0b0010'1010'1001: case 0b0010'1010'1010: case 0b0010'1010'1011: - case 0b0010'1000'1100: case 0b0010'1000'1101: case 0b0010'1000'1110: case 0b0010'1000'1111: - case 0b0010'1010'1100: case 0b0010'1010'1101: case 0b0010'1010'1110: case 0b0010'1010'1111: - case 0b0010'1001'0000: case 0b0010'1001'0001: case 0b0010'1001'0010: case 0b0010'1001'0011: - case 0b0010'1011'0000: case 0b0010'1011'0001: case 0b0010'1011'0010: case 0b0010'1011'0011: - case 0b0010'1001'1000: case 0b0010'1001'1001: case 0b0010'1001'1010: case 0b0010'1001'1011: - case 0b0010'1011'1000: case 0b0010'1011'1001: case 0b0010'1011'1010: case 0b0010'1011'1011: - case 0b0010'1001'1100: case 0b0010'1001'1101: case 0b0010'1001'1110: case 0b0010'1001'1111: - case 0b0010'1011'1100: case 0b0010'1011'1101: case 0b0010'1011'1110: case 0b0010'1011'1111: - case 0b0010'1100'0000: case 0b0010'1100'0001: case 0b0010'1100'0010: case 0b0010'1100'0011: - case 0b0010'1110'0000: case 0b0010'1110'0001: case 0b0010'1110'0010: case 0b0010'1110'0011: - case 0b0010'1100'1000: case 0b0010'1100'1001: case 0b0010'1100'1010: case 0b0010'1100'1011: - case 0b0010'1110'1000: case 0b0010'1110'1001: case 0b0010'1110'1010: case 0b0010'1110'1011: - case 0b0010'1100'1100: case 0b0010'1100'1101: case 0b0010'1100'1110: case 0b0010'1100'1111: - case 0b0010'1110'1100: case 0b0010'1110'1101: case 0b0010'1110'1110: case 0b0010'1110'1111: - case 0b0010'1101'0000: case 0b0010'1101'0001: case 0b0010'1101'0010: case 0b0010'1101'0011: - case 0b0010'1111'0000: case 0b0010'1111'0001: case 0b0010'1111'0010: case 0b0010'1111'0011: - case 0b0010'1101'1000: case 0b0010'1101'1001: case 0b0010'1101'1010: case 0b0010'1101'1011: - case 0b0010'1111'1000: case 0b0010'1111'1001: case 0b0010'1111'1010: case 0b0010'1111'1011: - case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: - case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: - { - // optype · (AND) - // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] - // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] - // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] - // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] - // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] - // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] - // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] - // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] - // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] - // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] - // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] - // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] - // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] - // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] - - // optype = (these are expressed as x=y in the opcopde syntax, but x-y in the description, in reality it seems to act as 'CMP' so x-y = 0) - // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] - // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] - // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] - // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] - // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] - // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] - // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] - // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] - // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] - // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] - // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] - // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] - // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] - // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] - // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] - // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] - - // optype - - // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] - // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] - // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] - // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] - const int non = inst & 0x20; - const int optype = (inst & 0x0c) >> 2; - const int reg1 = (inst & 0xc0) >> 6; - const int reg2 = (inst & 0x10) >> 4; - const int n = inst & 0x3; - u8 srcreg2 = get_a1_or_a2(reg2); - u8 srcreg1 = 0; - switch (reg1) - { - case 0: srcreg1 = get_a1(); break; - case 1: srcreg1 = get_a2(); break; - case 2: srcreg1 = get_m_data(); break; - case 3: - { - srcreg1 = get_h(); - srcreg2 &= 0x1f; - break; - } - } - - switch (optype) - { - case 0: // AND - { - if (!non) - { - if ((srcreg1 & srcreg2) == 0) // skip if (x·y) makes zero, N->L[2:1] - m_skip = 1; - } - else - { - if ((srcreg1 & srcreg2) != 0) // skip if (x·y) makes non zero, N->L[2:1] - m_skip = 1; - } - break; - } - case 1: // invalid - { - // can't happen, no switch case leads here - break; - } - case 2: // = - { - if (!non) - { - if (srcreg1 == srcreg2) // skip if (x-y) makes zero, N->L[2:1] - m_skip = 1; - } - else - { - if (srcreg1 != srcreg2) // skip if (x-y) makes non zero, N->L[2:1] - m_skip = 1; - } - break; - } - case 3: // - - { - u8 result = srcreg1 - srcreg2; - - if (!non) - { - if (result & 0x80) // skip if (x-y) makes borrow, N->L[2:1] - m_skip = 1; - } - else - { - if ((result & 0x80) == 0) // skip if (x-y) makes non borrow, N->L[2:1] - m_skip = 1; - } - - break; - } - } - - set_l(n); - break; - } - case 0b0011'0000'0000: case 0b0011'0000'0001: case 0b0011'0000'0010: case 0b0011'0000'0011: { // 300 N->L[2:1] diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 65b5612d0f172..a4e38d0792651 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -132,6 +132,120 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int k = inst & 0x3ff; util::stream_format(stream, "JS 0x%03x (%01x:%02x)", k & 0x3ff, (k & 0x380)>>7, k & 0x07f); } + else if (((inst & 0b1111'0000'0000) == 0b0010'0000'0000) && ((inst & 0b0000'0000'1100) != 0b0000'0000'0100)) + { + // 0b0010'rrnR'oonn where rr = reg1 (A1, A2, M or H), n = invert condition, R = reg2 (A1 or A2) and oo = optype (only 0,2,3 are valid, no cases here for 1) nn = next l value + // the above 'if' statement is a shit way of representing the following bitfields +#if 0 + case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: + case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: + case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: + case 0b0010'0010'1000: case 0b0010'0010'1001: case 0b0010'0010'1010: case 0b0010'0010'1011: + case 0b0010'0000'1100: case 0b0010'0000'1101: case 0b0010'0000'1110: case 0b0010'0000'1111: + case 0b0010'0010'1100: case 0b0010'0010'1101: case 0b0010'0010'1110: case 0b0010'0010'1111: + case 0b0010'0001'0000: case 0b0010'0001'0001: case 0b0010'0001'0010: case 0b0010'0001'0011: + case 0b0010'0011'0000: case 0b0010'0011'0001: case 0b0010'0011'0010: case 0b0010'0011'0011: + case 0b0010'0001'1000: case 0b0010'0001'1001: case 0b0010'0001'1010: case 0b0010'0001'1011: + case 0b0010'0011'1000: case 0b0010'0011'1001: case 0b0010'0011'1010: case 0b0010'0011'1011: + case 0b0010'0001'1100: case 0b0010'0001'1101: case 0b0010'0001'1110: case 0b0010'0001'1111: + case 0b0010'0011'1100: case 0b0010'0011'1101: case 0b0010'0011'1110: case 0b0010'0011'1111: + case 0b0010'0100'0000: case 0b0010'0100'0001: case 0b0010'0100'0010: case 0b0010'0100'0011: + case 0b0010'0110'0000: case 0b0010'0110'0001: case 0b0010'0110'0010: case 0b0010'0110'0011: + case 0b0010'0100'1000: case 0b0010'0100'1001: case 0b0010'0100'1010: case 0b0010'0100'1011: + case 0b0010'0110'1000: case 0b0010'0110'1001: case 0b0010'0110'1010: case 0b0010'0110'1011: + case 0b0010'0100'1100: case 0b0010'0100'1101: case 0b0010'0100'1110: case 0b0010'0100'1111: + case 0b0010'0110'1100: case 0b0010'0110'1101: case 0b0010'0110'1110: case 0b0010'0110'1111: + case 0b0010'0101'0000: case 0b0010'0101'0001: case 0b0010'0101'0010: case 0b0010'0101'0011: + case 0b0010'0111'0000: case 0b0010'0111'0001: case 0b0010'0111'0010: case 0b0010'0111'0011: + case 0b0010'0101'1000: case 0b0010'0101'1001: case 0b0010'0101'1010: case 0b0010'0101'1011: + case 0b0010'0111'1000: case 0b0010'0111'1001: case 0b0010'0111'1010: case 0b0010'0111'1011: + case 0b0010'0101'1100: case 0b0010'0101'1101: case 0b0010'0101'1110: case 0b0010'0101'1111: + case 0b0010'0111'1100: case 0b0010'0111'1101: case 0b0010'0111'1110: case 0b0010'0111'1111: + case 0b0010'1000'0000: case 0b0010'1000'0001: case 0b0010'1000'0010: case 0b0010'1000'0011: + case 0b0010'1010'0000: case 0b0010'1010'0001: case 0b0010'1010'0010: case 0b0010'1010'0011: + case 0b0010'1000'1000: case 0b0010'1000'1001: case 0b0010'1000'1010: case 0b0010'1000'1011: + case 0b0010'1010'1000: case 0b0010'1010'1001: case 0b0010'1010'1010: case 0b0010'1010'1011: + case 0b0010'1000'1100: case 0b0010'1000'1101: case 0b0010'1000'1110: case 0b0010'1000'1111: + case 0b0010'1010'1100: case 0b0010'1010'1101: case 0b0010'1010'1110: case 0b0010'1010'1111: + case 0b0010'1001'0000: case 0b0010'1001'0001: case 0b0010'1001'0010: case 0b0010'1001'0011: + case 0b0010'1011'0000: case 0b0010'1011'0001: case 0b0010'1011'0010: case 0b0010'1011'0011: + case 0b0010'1001'1000: case 0b0010'1001'1001: case 0b0010'1001'1010: case 0b0010'1001'1011: + case 0b0010'1011'1000: case 0b0010'1011'1001: case 0b0010'1011'1010: case 0b0010'1011'1011: + case 0b0010'1001'1100: case 0b0010'1001'1101: case 0b0010'1001'1110: case 0b0010'1001'1111: + case 0b0010'1011'1100: case 0b0010'1011'1101: case 0b0010'1011'1110: case 0b0010'1011'1111: + case 0b0010'1100'0000: case 0b0010'1100'0001: case 0b0010'1100'0010: case 0b0010'1100'0011: + case 0b0010'1110'0000: case 0b0010'1110'0001: case 0b0010'1110'0010: case 0b0010'1110'0011: + case 0b0010'1100'1000: case 0b0010'1100'1001: case 0b0010'1100'1010: case 0b0010'1100'1011: + case 0b0010'1110'1000: case 0b0010'1110'1001: case 0b0010'1110'1010: case 0b0010'1110'1011: + case 0b0010'1100'1100: case 0b0010'1100'1101: case 0b0010'1100'1110: case 0b0010'1100'1111: + case 0b0010'1110'1100: case 0b0010'1110'1101: case 0b0010'1110'1110: case 0b0010'1110'1111: + case 0b0010'1101'0000: case 0b0010'1101'0001: case 0b0010'1101'0010: case 0b0010'1101'0011: + case 0b0010'1111'0000: case 0b0010'1111'0001: case 0b0010'1111'0010: case 0b0010'1111'0011: + case 0b0010'1101'1000: case 0b0010'1101'1001: case 0b0010'1101'1010: case 0b0010'1101'1011: + case 0b0010'1111'1000: case 0b0010'1111'1001: case 0b0010'1111'1010: case 0b0010'1111'1011: + case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: + case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: +#endif + // optype · (AND) + // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] + // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] + // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] + // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] + // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] + // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] + // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] + // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] + // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] + // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] + + // optype = (these are expressed as x=y in the opcopde syntax, but x-y in the description, in reality it seems to act as 'CMP' so x-y = 0) + // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] + // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] + // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] + // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] + // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] + // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] + // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] + // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] + // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] + // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] + // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] + + // optype - + // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] + // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] + // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] + // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] + // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] + // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] + // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] + // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] + const int non = inst & 0x20; + const int optype = (inst & 0x0c) >> 2; + const int reg1 = (inst & 0xc0) >> 6; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "%s%s%s, 0x%d->L %s%s", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); + } else { switch (inst) @@ -238,118 +352,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "SRE+1"); break; } - - case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: - case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: - case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: - case 0b0010'0010'1000: case 0b0010'0010'1001: case 0b0010'0010'1010: case 0b0010'0010'1011: - case 0b0010'0000'1100: case 0b0010'0000'1101: case 0b0010'0000'1110: case 0b0010'0000'1111: - case 0b0010'0010'1100: case 0b0010'0010'1101: case 0b0010'0010'1110: case 0b0010'0010'1111: - case 0b0010'0001'0000: case 0b0010'0001'0001: case 0b0010'0001'0010: case 0b0010'0001'0011: - case 0b0010'0011'0000: case 0b0010'0011'0001: case 0b0010'0011'0010: case 0b0010'0011'0011: - case 0b0010'0001'1000: case 0b0010'0001'1001: case 0b0010'0001'1010: case 0b0010'0001'1011: - case 0b0010'0011'1000: case 0b0010'0011'1001: case 0b0010'0011'1010: case 0b0010'0011'1011: - case 0b0010'0001'1100: case 0b0010'0001'1101: case 0b0010'0001'1110: case 0b0010'0001'1111: - case 0b0010'0011'1100: case 0b0010'0011'1101: case 0b0010'0011'1110: case 0b0010'0011'1111: - case 0b0010'0100'0000: case 0b0010'0100'0001: case 0b0010'0100'0010: case 0b0010'0100'0011: - case 0b0010'0110'0000: case 0b0010'0110'0001: case 0b0010'0110'0010: case 0b0010'0110'0011: - case 0b0010'0100'1000: case 0b0010'0100'1001: case 0b0010'0100'1010: case 0b0010'0100'1011: - case 0b0010'0110'1000: case 0b0010'0110'1001: case 0b0010'0110'1010: case 0b0010'0110'1011: - case 0b0010'0100'1100: case 0b0010'0100'1101: case 0b0010'0100'1110: case 0b0010'0100'1111: - case 0b0010'0110'1100: case 0b0010'0110'1101: case 0b0010'0110'1110: case 0b0010'0110'1111: - case 0b0010'0101'0000: case 0b0010'0101'0001: case 0b0010'0101'0010: case 0b0010'0101'0011: - case 0b0010'0111'0000: case 0b0010'0111'0001: case 0b0010'0111'0010: case 0b0010'0111'0011: - case 0b0010'0101'1000: case 0b0010'0101'1001: case 0b0010'0101'1010: case 0b0010'0101'1011: - case 0b0010'0111'1000: case 0b0010'0111'1001: case 0b0010'0111'1010: case 0b0010'0111'1011: - case 0b0010'0101'1100: case 0b0010'0101'1101: case 0b0010'0101'1110: case 0b0010'0101'1111: - case 0b0010'0111'1100: case 0b0010'0111'1101: case 0b0010'0111'1110: case 0b0010'0111'1111: - case 0b0010'1000'0000: case 0b0010'1000'0001: case 0b0010'1000'0010: case 0b0010'1000'0011: - case 0b0010'1010'0000: case 0b0010'1010'0001: case 0b0010'1010'0010: case 0b0010'1010'0011: - case 0b0010'1000'1000: case 0b0010'1000'1001: case 0b0010'1000'1010: case 0b0010'1000'1011: - case 0b0010'1010'1000: case 0b0010'1010'1001: case 0b0010'1010'1010: case 0b0010'1010'1011: - case 0b0010'1000'1100: case 0b0010'1000'1101: case 0b0010'1000'1110: case 0b0010'1000'1111: - case 0b0010'1010'1100: case 0b0010'1010'1101: case 0b0010'1010'1110: case 0b0010'1010'1111: - case 0b0010'1001'0000: case 0b0010'1001'0001: case 0b0010'1001'0010: case 0b0010'1001'0011: - case 0b0010'1011'0000: case 0b0010'1011'0001: case 0b0010'1011'0010: case 0b0010'1011'0011: - case 0b0010'1001'1000: case 0b0010'1001'1001: case 0b0010'1001'1010: case 0b0010'1001'1011: - case 0b0010'1011'1000: case 0b0010'1011'1001: case 0b0010'1011'1010: case 0b0010'1011'1011: - case 0b0010'1001'1100: case 0b0010'1001'1101: case 0b0010'1001'1110: case 0b0010'1001'1111: - case 0b0010'1011'1100: case 0b0010'1011'1101: case 0b0010'1011'1110: case 0b0010'1011'1111: - case 0b0010'1100'0000: case 0b0010'1100'0001: case 0b0010'1100'0010: case 0b0010'1100'0011: - case 0b0010'1110'0000: case 0b0010'1110'0001: case 0b0010'1110'0010: case 0b0010'1110'0011: - case 0b0010'1100'1000: case 0b0010'1100'1001: case 0b0010'1100'1010: case 0b0010'1100'1011: - case 0b0010'1110'1000: case 0b0010'1110'1001: case 0b0010'1110'1010: case 0b0010'1110'1011: - case 0b0010'1100'1100: case 0b0010'1100'1101: case 0b0010'1100'1110: case 0b0010'1100'1111: - case 0b0010'1110'1100: case 0b0010'1110'1101: case 0b0010'1110'1110: case 0b0010'1110'1111: - case 0b0010'1101'0000: case 0b0010'1101'0001: case 0b0010'1101'0010: case 0b0010'1101'0011: - case 0b0010'1111'0000: case 0b0010'1111'0001: case 0b0010'1111'0010: case 0b0010'1111'0011: - case 0b0010'1101'1000: case 0b0010'1101'1001: case 0b0010'1101'1010: case 0b0010'1101'1011: - case 0b0010'1111'1000: case 0b0010'1111'1001: case 0b0010'1111'1010: case 0b0010'1111'1011: - case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: - case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: - { - // optype · (AND) - // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] - // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] - // 210 Skip if (A1[7:1]·A2[7:1]) makes zero, N->L[2:1] - // 230 Skip if (A1[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // 240 Skip if (A2[7:1]·A1[7:1]) makes zero, N->L[2:1] - // 260 Skip if (A2[7:1]·A1[7:1]) makes non zero, N->L[2:1] - // 250 Skip if (A2[7:1]·A2[7:1]) makes zero, N->L[2:1] - // 270 Skip if (A2[7:1]·A2[7:1]) makes non zero, N->L[2:1] - // 280 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes zero, N->L[2:1] - // 2a0 Skip if (M[H[5:1],L[2:1]][7:1]·A1[7:1]) makes non zero, N->L[2:1] - // 290 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes zero, N->L[2:1] - // 2b0 Skip if (M[H[5:1],L[2:1]][7:1]·A2[7:1]) makes non zero, N->L[2:1] - // 2c0 Skip if (H[5:1]·A1[5:1]) makes zero, N->L[2:1] - // 2e0 Skip if (H[5:1]·A1[5:1]) makes non zero, N->L[2:1] - // 2d0 Skip if (H[5:1]·A2[5:1]) makes zero, N->L[2:1] - // 2f0 Skip if (H[5:1]·A2[5:1]) makes non zero, N->L[2:1] - - // optype = (these are expressed as x=y in the opcopde syntax, but x-y in the description, in reality it seems to act as 'CMP' so x-y = 0) - // 208 Skip if (A1[7:1]-A1[7:1]) makes zero, N->L[2:1] - // 228 Skip if (A1[7:1]-A1[7:1]) makes non zero, N->L[2:1] - // 218 Skip if (A1[7:1]-A2[7:1]) makes zero, N->L[2:1] - // 238 Skip if (A1[7:1]-A2[7:1]) makes non zero, N->L[2:1] - // 248 Skip if (A2[7:1]-A1[7:1]) makes zero, N->L[2:1] - // 268 Skip if (A2[7:1]-A1[7:1]) makes non zero, N->L[2:1] - // 258 Skip if (A2[7:1]-A2[7:1]) makes zero, N->L[2:1] - // 278 Skip if (A2[7:1]-A2[7:1]) makes non zero, N->L[2:1] - // 288 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes zero, N->L[2:1] - // 2a8 Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non zero, N->L[2:1] - // 298 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes zero, N->L[2:1] - // 2b8 Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non zero, N->L[2:1] - // 2c8 Skip if (H[5:1]-A1[5:1]) makes zero, N->L[2:1] - // 2e8 Skip if (H[5:1]-A1[5:1]) makes non zero, N->L[2:1] - // 2d8 Skip if (H[5:1]-A2[5:1]) makes zero, N->L[2:1] - // 2f8 Skip if (H[5:1]-A2[5:1]) makes non zero, N->L[2:1] - - // optype - - // 20c Skip if (A1[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 22c Skip if (A1[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // 21c Skip if (A1[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 23c Skip if (A1[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // 24c Skip if (A2[7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 26c Skip if (A2[7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // 25c Skip if (A2[7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 27c Skip if (A2[7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // 28c Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes borrow, N->L[2:1] - // 2ac Skip if (M[H[5:1],L[2:1]][7:1]-A1[7:1]) makes non borrow, N->L[2:1] - // 29c Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes borrow, N->L[2:1] - // 2bc Skip if (M[H[5:1],L[2:1]][7:1]-A2[7:1]) makes non borrow, N->L[2:1] - // 2cc Skip if (H[5:1]-A1[5:1]) makes borrow, N->L[2:1] - // 2ec Skip if (H[5:1]-A1[5:1]) makes non borrow, N->L[2:1] - // 2dc Skip if (H[5:1]-A2[5:1]) makes borrow, N->L[2:1] - // 2fc Skip if (H[5:1]-A2[5:1]) makes non borrow, N->L[2:1] - const int non = inst & 0x20; - const int optype = (inst & 0x0c) >> 2; - const int reg1 = (inst & 0xc0) >> 6; - const int reg2 = (inst & 0x10) >> 4; - const int n = inst & 0x3; - util::stream_format(stream, "%s%s%s, 0x%d->L %s%s", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); - break; - } - case 0b0011'0000'0000: case 0b0011'0000'0001: case 0b0011'0000'0010: case 0b0011'0000'0011: { // 300 N->L[2:1] From fcba29538a7fcd89d17715b0f4a90f1959e6dd8e Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 15:43:07 +0000 Subject: [PATCH 59/62] continue to turn this into the unmaintainable garbage demanded --- src/devices/cpu/upd777/upd777.cpp | 154 +++++++++++++------------- src/devices/cpu/upd777/upd777dasm.cpp | 87 ++++++++------- 2 files changed, 124 insertions(+), 117 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 8d3d0dbcc3cea..6053e82f3b6a3 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -597,6 +597,85 @@ void upd777_cpu_device::do_op() } set_l(n); + } + else if ((inst & 0b1111'1010'0000) == 0b0011'0010'0000) + { + // the above 'if' statement is a shit way of representing the following bitfields + // 0b0011'0r1R'oonn (where r = reg1, R = reg2, o = optype, and n = next l value) +#if 0 + case 0b0011'0010'0000: case 0b0011'0010'0001: case 0b0011'0010'0010: case 0b0011'0010'0011: + case 0b0011'0010'0100: case 0b0011'0010'0101: case 0b0011'0010'0110: case 0b0011'0010'0111: + case 0b0011'0010'1000: case 0b0011'0010'1001: case 0b0011'0010'1010: case 0b0011'0010'1011: + case 0b0011'0010'1100: case 0b0011'0010'1101: case 0b0011'0010'1110: case 0b0011'0010'1111: + case 0b0011'0011'0000: case 0b0011'0011'0001: case 0b0011'0011'0010: case 0b0011'0011'0011: + case 0b0011'0011'0100: case 0b0011'0011'0101: case 0b0011'0011'0110: case 0b0011'0011'0111: + case 0b0011'0011'1000: case 0b0011'0011'1001: case 0b0011'0011'1010: case 0b0011'0011'1011: + case 0b0011'0011'1100: case 0b0011'0011'1101: case 0b0011'0011'1110: case 0b0011'0011'1111: + case 0b0011'0110'0000: case 0b0011'0110'0001: case 0b0011'0110'0010: case 0b0011'0110'0011: + case 0b0011'0110'0100: case 0b0011'0110'0101: case 0b0011'0110'0110: case 0b0011'0110'0111: + case 0b0011'0110'1000: case 0b0011'0110'1001: case 0b0011'0110'1010: case 0b0011'0110'1011: + case 0b0011'0110'1100: case 0b0011'0110'1101: case 0b0011'0110'1110: case 0b0011'0110'1111: + case 0b0011'0111'0000: case 0b0011'0111'0001: case 0b0011'0111'0010: case 0b0011'0111'0011: + case 0b0011'0111'0100: case 0b0011'0111'0101: case 0b0011'0111'0110: case 0b0011'0111'0111: + case 0b0011'0111'1000: case 0b0011'0111'1001: case 0b0011'0111'1010: case 0b0011'0111'1011: + case 0b0011'0111'1100: case 0b0011'0111'1101: case 0b0011'0111'1110: case 0b0011'0111'1111: +#endif + // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 32c Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 330 AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 334 Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 338 OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 33c Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 360 AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 364 Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 368 OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 36c Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + // 370 AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int reg1 = (inst & 0x40) >> 6; + const int n = inst & 0x3; + + u8 src1 = get_a1_or_a2(reg1); + u8 src2 = get_a1_or_a2(reg2); + + switch (optype) + { + case 0: // AND + { + src1 = src1 & src2; + break; + } + case 1: // ADD + { + src1 = src1 + src2; + // not in this case? + //if (src1 & 0x80) + // m_skip = 1; + break; + } + case 2: // OR + { + src1 = src1 | src2; + break; + } + case 3: // MINUS + { + src1 = src1 - src2; + if (src1 & 0x80) + m_skip = 1; + break; + } + } + set_a1_or_a2(reg1, src1); + set_l(n); + + } else { @@ -919,81 +998,6 @@ void upd777_cpu_device::do_op() set_l(n); break; } - - case 0b0011'0010'0000: case 0b0011'0010'0001: case 0b0011'0010'0010: case 0b0011'0010'0011: - case 0b0011'0010'0100: case 0b0011'0010'0101: case 0b0011'0010'0110: case 0b0011'0010'0111: - case 0b0011'0010'1000: case 0b0011'0010'1001: case 0b0011'0010'1010: case 0b0011'0010'1011: - case 0b0011'0010'1100: case 0b0011'0010'1101: case 0b0011'0010'1110: case 0b0011'0010'1111: - case 0b0011'0011'0000: case 0b0011'0011'0001: case 0b0011'0011'0010: case 0b0011'0011'0011: - case 0b0011'0011'0100: case 0b0011'0011'0101: case 0b0011'0011'0110: case 0b0011'0011'0111: - case 0b0011'0011'1000: case 0b0011'0011'1001: case 0b0011'0011'1010: case 0b0011'0011'1011: - case 0b0011'0011'1100: case 0b0011'0011'1101: case 0b0011'0011'1110: case 0b0011'0011'1111: - case 0b0011'0110'0000: case 0b0011'0110'0001: case 0b0011'0110'0010: case 0b0011'0110'0011: - case 0b0011'0110'0100: case 0b0011'0110'0101: case 0b0011'0110'0110: case 0b0011'0110'0111: - case 0b0011'0110'1000: case 0b0011'0110'1001: case 0b0011'0110'1010: case 0b0011'0110'1011: - case 0b0011'0110'1100: case 0b0011'0110'1101: case 0b0011'0110'1110: case 0b0011'0110'1111: - case 0b0011'0111'0000: case 0b0011'0111'0001: case 0b0011'0111'0010: case 0b0011'0111'0011: - case 0b0011'0111'0100: case 0b0011'0111'0101: case 0b0011'0111'0110: case 0b0011'0111'0111: - case 0b0011'0111'1000: case 0b0011'0111'1001: case 0b0011'0111'1010: case 0b0011'0111'1011: - case 0b0011'0111'1100: case 0b0011'0111'1101: case 0b0011'0111'1110: case 0b0011'0111'1111: - { - // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 32c Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - // 330 AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 334 Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 338 OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 33c Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - // 360 AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 364 Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 368 OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 36c Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - // 370 AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - const int optype = (inst & 0x0c) >> 2; - const int reg2 = (inst & 0x10) >> 4; - const int reg1 = (inst & 0x40) >> 6; - const int n = inst & 0x3; - - u8 src1 = get_a1_or_a2(reg1); - u8 src2 = get_a1_or_a2(reg2); - - switch (optype) - { - case 0: // AND - { - src1 = src1 & src2; - break; - } - case 1: // ADD - { - src1 = src1 + src2; - // not in this case? - //if (src1 & 0x80) - // m_skip = 1; - break; - } - case 2: // OR - { - src1 = src1 | src2; - break; - } - case 3: // MINUS - { - src1 = src1 - src2; - if (src1 & 0x80) - m_skip = 1; - break; - } - } - set_a1_or_a2(reg1, src1); - set_l(n); - break; - } - case 0b0011'1000'0000: case 0b0011'1000'0001: case 0b0011'1000'0010: case 0b0011'1000'0011: case 0b0011'1001'0000: case 0b0011'1001'0001: case 0b0011'1001'0010: case 0b0011'1001'0011: { diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index a4e38d0792651..7b371f55135a6 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -246,6 +246,51 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int n = inst & 0x3; util::stream_format(stream, "%s%s%s, 0x%d->L %s%s", get_reg_name(reg1), get_200optype_name(optype), get_reg_name(reg2), n, (optype == 3) ? "BOJ" : "EQJ", non ? "/" : ""); } + else if ((inst & 0b1111'1010'0000) == 0b0011'0010'0000) + { + // the above 'if' statement is a shit way of representing the following bitfields + // 0b0011'0r1R'oonn (where r = reg1, R = reg2, o = optype, and n = next l value) +#if 0 + case 0b0011'0010'0000: case 0b0011'0010'0001: case 0b0011'0010'0010: case 0b0011'0010'0011: + case 0b0011'0010'0100: case 0b0011'0010'0101: case 0b0011'0010'0110: case 0b0011'0010'0111: + case 0b0011'0010'1000: case 0b0011'0010'1001: case 0b0011'0010'1010: case 0b0011'0010'1011: + case 0b0011'0010'1100: case 0b0011'0010'1101: case 0b0011'0010'1110: case 0b0011'0010'1111: + case 0b0011'0011'0000: case 0b0011'0011'0001: case 0b0011'0011'0010: case 0b0011'0011'0011: + case 0b0011'0011'0100: case 0b0011'0011'0101: case 0b0011'0011'0110: case 0b0011'0011'0111: + case 0b0011'0011'1000: case 0b0011'0011'1001: case 0b0011'0011'1010: case 0b0011'0011'1011: + case 0b0011'0011'1100: case 0b0011'0011'1101: case 0b0011'0011'1110: case 0b0011'0011'1111: + case 0b0011'0110'0000: case 0b0011'0110'0001: case 0b0011'0110'0010: case 0b0011'0110'0011: + case 0b0011'0110'0100: case 0b0011'0110'0101: case 0b0011'0110'0110: case 0b0011'0110'0111: + case 0b0011'0110'1000: case 0b0011'0110'1001: case 0b0011'0110'1010: case 0b0011'0110'1011: + case 0b0011'0110'1100: case 0b0011'0110'1101: case 0b0011'0110'1110: case 0b0011'0110'1111: + case 0b0011'0111'0000: case 0b0011'0111'0001: case 0b0011'0111'0010: case 0b0011'0111'0011: + case 0b0011'0111'0100: case 0b0011'0111'0101: case 0b0011'0111'0110: case 0b0011'0111'0111: + case 0b0011'0111'1000: case 0b0011'0111'1001: case 0b0011'0111'1010: case 0b0011'0111'1011: + case 0b0011'0111'1100: case 0b0011'0111'1101: case 0b0011'0111'1110: case 0b0011'0111'1111: +#endif + + // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] + // 32c Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 330 AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 334 Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 338 OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] + // 33c Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + // 360 AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 364 Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 368 OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] + // 36c Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + // 370 AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] + // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int reg1 = (inst & 0x40) >> 6; + const int n = inst & 0x3; + util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", get_reg_name(reg1), get_300optype_name(optype), get_reg_name(reg2), get_reg_name(reg1), n, (optype == 3) ? "BOJ" : ""); + } else { switch (inst) @@ -471,48 +516,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "A2-A1->A1, 0x%d->L", n); break; } - - case 0b0011'0010'0000: case 0b0011'0010'0001: case 0b0011'0010'0010: case 0b0011'0010'0011: - case 0b0011'0010'0100: case 0b0011'0010'0101: case 0b0011'0010'0110: case 0b0011'0010'0111: - case 0b0011'0010'1000: case 0b0011'0010'1001: case 0b0011'0010'1010: case 0b0011'0010'1011: - case 0b0011'0010'1100: case 0b0011'0010'1101: case 0b0011'0010'1110: case 0b0011'0010'1111: - case 0b0011'0011'0000: case 0b0011'0011'0001: case 0b0011'0011'0010: case 0b0011'0011'0011: - case 0b0011'0011'0100: case 0b0011'0011'0101: case 0b0011'0011'0110: case 0b0011'0011'0111: - case 0b0011'0011'1000: case 0b0011'0011'1001: case 0b0011'0011'1010: case 0b0011'0011'1011: - case 0b0011'0011'1100: case 0b0011'0011'1101: case 0b0011'0011'1110: case 0b0011'0011'1111: - case 0b0011'0110'0000: case 0b0011'0110'0001: case 0b0011'0110'0010: case 0b0011'0110'0011: - case 0b0011'0110'0100: case 0b0011'0110'0101: case 0b0011'0110'0110: case 0b0011'0110'0111: - case 0b0011'0110'1000: case 0b0011'0110'1001: case 0b0011'0110'1010: case 0b0011'0110'1011: - case 0b0011'0110'1100: case 0b0011'0110'1101: case 0b0011'0110'1110: case 0b0011'0110'1111: - case 0b0011'0111'0000: case 0b0011'0111'0001: case 0b0011'0111'0010: case 0b0011'0111'0011: - case 0b0011'0111'0100: case 0b0011'0111'0101: case 0b0011'0111'0110: case 0b0011'0111'0111: - case 0b0011'0111'1000: case 0b0011'0111'1001: case 0b0011'0111'1010: case 0b0011'0111'1011: - case 0b0011'0111'1100: case 0b0011'0111'1101: case 0b0011'0111'1110: case 0b0011'0111'1111: - { - // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] - // 32c Subtract A1[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - // 330 AND A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 334 Add A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 338 OR A1[7:1] and A2[7:1], store to A1[7:1], N->L[2:1] - // 33c Subtract A1[7:1] and A2[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - // 360 AND A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 364 Add A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 368 OR A2[7:1] and A1[7:1], store to A2[7:1], N->L[2:1] - // 36c Subtract A2[7:1] and A1[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - // 370 AND A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 374 Add A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 378 OR A2[7:1] and A2[7:1], store to A2[7:1], N->L[2:1] - // 37c Subtract A2[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - const int optype = (inst & 0x0c) >> 2; - const int reg2 = (inst & 0x10) >> 4; - const int reg1 = (inst & 0x40) >> 6; - const int n = inst & 0x3; - util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", get_reg_name(reg1), get_300optype_name(optype), get_reg_name(reg2), get_reg_name(reg1), n, (optype == 3) ? "BOJ" : ""); - break; - } - case 0b0011'1000'0000: case 0b0011'1000'0001: case 0b0011'1000'0010: case 0b0011'1000'0011: case 0b0011'1001'0000: case 0b0011'1001'0001: case 0b0011'1001'0010: case 0b0011'1001'0011: { From e9c89d37332d2d12395056b7219753abffe77665 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 16:03:43 +0000 Subject: [PATCH 60/62] keep making this significantly worse --- src/devices/cpu/upd777/upd777.cpp | 267 +++++++++++++------------- src/devices/cpu/upd777/upd777dasm.cpp | 140 +++++++------- 2 files changed, 208 insertions(+), 199 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 6053e82f3b6a3..7301aa978cd27 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -674,8 +674,143 @@ void upd777_cpu_device::do_op() } set_a1_or_a2(reg1, src1); set_l(n); + } + else if ((inst & 0b1111'1110'0000) == 0b0011'1010'0000) + { +#if 0 + // 0b0011'101r'oonn (where r = reg, o = optype, n = next l value) + case 0b0011'1010'0000: case 0b0011'1010'0001: case 0b0011'1010'0010: case 0b0011'1010'0011: + case 0b0011'1010'0100: case 0b0011'1010'0101: case 0b0011'1010'0110: case 0b0011'1010'0111: + case 0b0011'1010'1000: case 0b0011'1010'1001: case 0b0011'1010'1010: case 0b0011'1010'1011: + case 0b0011'1010'1100: case 0b0011'1010'1101: case 0b0011'1010'1110: case 0b0011'1010'1111: + case 0b0011'1011'0000: case 0b0011'1011'0001: case 0b0011'1011'0010: case 0b0011'1011'0011: + case 0b0011'1011'0100: case 0b0011'1011'0101: case 0b0011'1011'0110: case 0b0011'1011'0111: + case 0b0011'1011'1000: case 0b0011'1011'1001: case 0b0011'1011'1010: case 0b0011'1011'1011: + case 0b0011'1011'1100: case 0b0011'1011'1101: case 0b0011'1011'1110: case 0b0011'1011'1111: +#endif + // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3ac Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + // 3b0 AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + u8 src2 = get_a1_or_a2(reg2); + u8 m = get_m_data(); + switch (optype) + { + case 0: // AND + { + m = m & src2; + break; + } + case 1: // ADD + { + m = m + src2; + if (m & 0x80) + m_skip = 1; + break; + } + case 2: // OR + { + m = m | src2; + break; + } + case 3: // MINUS + { + m = m - src2; + if (m & 0x80) + m_skip = 1; + break; + } + } + set_m_data(m); + set_l(n); + } + else if ((inst & 0b1111'1110'0000) == 0b0011'1110'0000) + { +#if 0 + // 0b0011'111r'oonn (where r = reg, o = optype, n = next l value) + case 0b0011'1110'0000: case 0b0011'1110'0001: case 0b0011'1110'0010: case 0b0011'1110'0011: + case 0b0011'1110'0100: case 0b0011'1110'0101: case 0b0011'1110'0110: case 0b0011'1110'0111: + case 0b0011'1110'1000: case 0b0011'1110'1001: case 0b0011'1110'1010: case 0b0011'1110'1011: + case 0b0011'1110'1100: case 0b0011'1110'1101: case 0b0011'1110'1110: case 0b0011'1110'1111: + case 0b0011'1111'0000: case 0b0011'1111'0001: case 0b0011'1111'0010: case 0b0011'1111'0011: + case 0b0011'1111'0100: case 0b0011'1111'0101: case 0b0011'1111'0110: case 0b0011'1111'0111: + case 0b0011'1111'1000: case 0b0011'1111'1001: case 0b0011'1111'1010: case 0b0011'1111'1011: + case 0b0011'1111'1100: case 0b0011'1111'1101: case 0b0011'1111'1110: case 0b0011'1111'1111: +#endif + // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3e8 OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3ec Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + // 3f0 AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3f4 Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + u8 src2 = get_a1_or_a2(reg2) & 0x1f; + u8 h = get_h(); + switch (optype) + { + case 0: // AND + { + h = h & src2; + break; + } + case 1: // ADD + { + h = h + src2; + break; + } + case 2: // OR + { + h = h | src2; + break; + } + case 3: // MINUS + { + h = h - src2; + if (h & 0x20) + m_skip = 1; + break; + } + } + set_h(h & 0x1f); + set_l(n); + } + else if ((inst & 0b1111'1100'0010) == 0b0100'0100'0000) + { +#if 0 + // 0b0100'01dg'ks0n (where d = DISP, G = GPE, K = KIE, S = SME, n = A11) + case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: + case 0b0100'0100'1000: case 0b0100'0100'1001: case 0b0100'0100'1100: case 0b0100'0100'1101: + case 0b0100'0101'0000: case 0b0100'0101'0001: case 0b0100'0101'0100: case 0b0100'0101'0101: + case 0b0100'0101'1000: case 0b0100'0101'1001: case 0b0100'0101'1100: case 0b0100'0101'1101: + case 0b0100'0110'0000: case 0b0100'0110'0001: case 0b0100'0110'0100: case 0b0100'0110'0101: + case 0b0100'0110'1000: case 0b0100'0110'1001: case 0b0100'0110'1100: case 0b0100'0110'1101: + case 0b0100'0111'0000: case 0b0100'0111'0001: case 0b0100'0111'0100: case 0b0100'0111'0101: + case 0b0100'0111'1000: case 0b0100'0111'1001: case 0b0100'0111'1100: case 0b0100'0111'1101: +#endif + // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] + const int d = (inst >> 5) & 0x1; + const int g = (inst >> 4) & 0x1; + const int k = (inst >> 3) & 0x1; + const int s = (inst >> 2) & 0x1; + const int n = inst & 0x1; + set_disp(d); + set_gpe(g); + set_kie(k); + set_sme(s); + set_a11(n); } else { @@ -1038,115 +1173,6 @@ void upd777_cpu_device::do_op() set_l(n); break; } - - case 0b0011'1010'0000: case 0b0011'1010'0001: case 0b0011'1010'0010: case 0b0011'1010'0011: - case 0b0011'1010'0100: case 0b0011'1010'0101: case 0b0011'1010'0110: case 0b0011'1010'0111: - case 0b0011'1010'1000: case 0b0011'1010'1001: case 0b0011'1010'1010: case 0b0011'1010'1011: - case 0b0011'1010'1100: case 0b0011'1010'1101: case 0b0011'1010'1110: case 0b0011'1010'1111: - case 0b0011'1011'0000: case 0b0011'1011'0001: case 0b0011'1011'0010: case 0b0011'1011'0011: - case 0b0011'1011'0100: case 0b0011'1011'0101: case 0b0011'1011'0110: case 0b0011'1011'0111: - case 0b0011'1011'1000: case 0b0011'1011'1001: case 0b0011'1011'1010: case 0b0011'1011'1011: - case 0b0011'1011'1100: case 0b0011'1011'1101: case 0b0011'1011'1110: case 0b0011'1011'1111: - { - // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3ac Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - // 3b0 AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - const int optype = (inst & 0x0c) >> 2; - const int reg2 = (inst & 0x10) >> 4; - const int n = inst & 0x3; - u8 src2 = get_a1_or_a2(reg2); - u8 m = get_m_data(); - - switch (optype) - { - case 0: // AND - { - m = m & src2; - break; - } - case 1: // ADD - { - m = m + src2; - if (m & 0x80) - m_skip = 1; - break; - } - case 2: // OR - { - m = m | src2; - break; - } - case 3: // MINUS - { - m = m - src2; - if (m & 0x80) - m_skip = 1; - break; - } - } - set_m_data(m); - set_l(n); - break; - } - - case 0b0011'1110'0000: case 0b0011'1110'0001: case 0b0011'1110'0010: case 0b0011'1110'0011: - case 0b0011'1110'0100: case 0b0011'1110'0101: case 0b0011'1110'0110: case 0b0011'1110'0111: - case 0b0011'1110'1000: case 0b0011'1110'1001: case 0b0011'1110'1010: case 0b0011'1110'1011: - case 0b0011'1110'1100: case 0b0011'1110'1101: case 0b0011'1110'1110: case 0b0011'1110'1111: - case 0b0011'1111'0000: case 0b0011'1111'0001: case 0b0011'1111'0010: case 0b0011'1111'0011: - case 0b0011'1111'0100: case 0b0011'1111'0101: case 0b0011'1111'0110: case 0b0011'1111'0111: - case 0b0011'1111'1000: case 0b0011'1111'1001: case 0b0011'1111'1010: case 0b0011'1111'1011: - case 0b0011'1111'1100: case 0b0011'1111'1101: case 0b0011'1111'1110: case 0b0011'1111'1111: - { - // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - // 3e8 OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - // 3ec Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - // 3f0 AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - // 3f4 Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - const int optype = (inst & 0x0c) >> 2; - const int reg2 = (inst & 0x10) >> 4; - const int n = inst & 0x3; - u8 src2 = get_a1_or_a2(reg2) & 0x1f; - u8 h = get_h(); - - switch (optype) - { - case 0: // AND - { - h = h & src2; - break; - } - case 1: // ADD - { - h = h + src2; - break; - } - case 2: // OR - { - h = h | src2; - break; - } - case 3: // MINUS - { - h = h - src2; - if (h & 0x20) - m_skip = 1; - break; - } - } - set_h(h & 0x1f); - set_l(n); - break; - } - case 0b0011'1100'0000: case 0b0011'1100'0001: case 0b0011'1100'0010: case 0b0011'1100'0011: case 0b0011'1101'0000: case 0b0011'1101'0001: case 0b0011'1101'0010: case 0b0011'1101'0011: { @@ -1187,29 +1213,6 @@ void upd777_cpu_device::do_op() set_a11(n); break; } - case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: - case 0b0100'0100'1000: case 0b0100'0100'1001: case 0b0100'0100'1100: case 0b0100'0100'1101: - case 0b0100'0101'0000: case 0b0100'0101'0001: case 0b0100'0101'0100: case 0b0100'0101'0101: - case 0b0100'0101'1000: case 0b0100'0101'1001: case 0b0100'0101'1100: case 0b0100'0101'1101: - case 0b0100'0110'0000: case 0b0100'0110'0001: case 0b0100'0110'0100: case 0b0100'0110'0101: - case 0b0100'0110'1000: case 0b0100'0110'1001: case 0b0100'0110'1100: case 0b0100'0110'1101: - case 0b0100'0111'0000: case 0b0100'0111'0001: case 0b0100'0111'0100: case 0b0100'0111'0101: - case 0b0100'0111'1000: case 0b0100'0111'1001: case 0b0100'0111'1100: case 0b0100'0111'1101: - { - // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] - const int d = (inst >> 5) & 0x1; - const int g = (inst >> 4) & 0x1; - const int k = (inst >> 3) & 0x1; - const int s = (inst >> 2) & 0x1; - const int n = inst & 0x1; - set_disp(d); - set_gpe(g); - set_kie(k); - set_sme(s); - set_a11(n); - break; - } - default: { LOGMASKED(LOG_UNHANDLED_OPS, "%04x \n", inst); diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 7b371f55135a6..f3ae994d8d287 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -291,6 +291,79 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int n = inst & 0x3; util::stream_format(stream, "%s%s%s->%s, 0x%d->L %s", get_reg_name(reg1), get_300optype_name(optype), get_reg_name(reg2), get_reg_name(reg1), n, (optype == 3) ? "BOJ" : ""); } + else if ((inst & 0b1111'1110'0000) == 0b0011'1010'0000) + { + // 0b0011'101r'oonn (where r = reg, o = optype, n = next l value) +#if 0 + case 0b0011'1010'0000: case 0b0011'1010'0001: case 0b0011'1010'0010: case 0b0011'1010'0011: + case 0b0011'1010'0100: case 0b0011'1010'0101: case 0b0011'1010'0110: case 0b0011'1010'0111: + case 0b0011'1010'1000: case 0b0011'1010'1001: case 0b0011'1010'1010: case 0b0011'1010'1011: + case 0b0011'1010'1100: case 0b0011'1010'1101: case 0b0011'1010'1110: case 0b0011'1010'1111: + case 0b0011'1011'0000: case 0b0011'1011'0001: case 0b0011'1011'0010: case 0b0011'1011'0011: + case 0b0011'1011'0100: case 0b0011'1011'0101: case 0b0011'1011'0110: case 0b0011'1011'0111: + case 0b0011'1011'1000: case 0b0011'1011'1001: case 0b0011'1011'1010: case 0b0011'1011'1011: + case 0b0011'1011'1100: case 0b0011'1011'1101: case 0b0011'1011'1110: case 0b0011'1011'1111: +#endif + // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3ac Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + // 3b0 AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry + // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow + const int optype = (inst & 0x0c) >> 2; + const int reg2 = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "M%s%s->M, 0x%d->L", get_300optype_name(optype), get_reg_name(reg2), n); + } + else if ((inst & 0b1111'1110'0000) == 0b0011'1110'0000) + { +#if 0 + // 0b0011'111r'oonn (where r = reg, o = optype, n = next l value) + case 0b0011'1110'0000: case 0b0011'1110'0001: case 0b0011'1110'0010: case 0b0011'1110'0011: + case 0b0011'1110'0100: case 0b0011'1110'0101: case 0b0011'1110'0110: case 0b0011'1110'0111: + case 0b0011'1110'1000: case 0b0011'1110'1001: case 0b0011'1110'1010: case 0b0011'1110'1011: + case 0b0011'1110'1100: case 0b0011'1110'1101: case 0b0011'1110'1110: case 0b0011'1110'1111: + case 0b0011'1111'0000: case 0b0011'1111'0001: case 0b0011'1111'0010: case 0b0011'1111'0011: + case 0b0011'1111'0100: case 0b0011'1111'0101: case 0b0011'1111'0110: case 0b0011'1111'0111: + case 0b0011'1111'1000: case 0b0011'1111'1001: case 0b0011'1111'1010: case 0b0011'1111'1011: + case 0b0011'1111'1100: case 0b0011'1111'1101: case 0b0011'1111'1110: case 0b0011'1111'1111: + // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3e8 OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] + // 3ec Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] + // 3f0 AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3f4 Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] + // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] +#endif + const int optype = (inst & 0x0c) >> 2; + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "H%s%s->H, 0x%d->L", get_300optype_name(optype), get_reg_name(reg), n); + } + else if ((inst & 0b1111'1100'0010) == 0b0100'0100'0000) + { +#if 0 + // 0b0100'01dg'ks0n (where d = DISP, G = GPE, K = KIE, S = SME, n = A11) + case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: + case 0b0100'0100'1000: case 0b0100'0100'1001: case 0b0100'0100'1100: case 0b0100'0100'1101: + case 0b0100'0101'0000: case 0b0100'0101'0001: case 0b0100'0101'0100: case 0b0100'0101'0101: + case 0b0100'0101'1000: case 0b0100'0101'1001: case 0b0100'0101'1100: case 0b0100'0101'1101: + case 0b0100'0110'0000: case 0b0100'0110'0001: case 0b0100'0110'0100: case 0b0100'0110'0101: + case 0b0100'0110'1000: case 0b0100'0110'1001: case 0b0100'0110'1100: case 0b0100'0110'1101: + case 0b0100'0111'0000: case 0b0100'0111'0001: case 0b0100'0111'0100: case 0b0100'0111'0101: + case 0b0100'0111'1000: case 0b0100'0111'1001: case 0b0100'0111'1100: case 0b0100'0111'1101: +#endif + // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] + const int d = (inst >> 5) & 0x1; + const int g = (inst >> 4) & 0x1; + const int k = (inst >> 3) & 0x1; + const int s = (inst >> 2) & 0x1; + const int n = inst & 0x1; + util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", d, g, k, s, n); + } else { switch (inst) @@ -548,55 +621,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "M->A%d, 0x%d->L", reg + 1, n); break; } - - case 0b0011'1010'0000: case 0b0011'1010'0001: case 0b0011'1010'0010: case 0b0011'1010'0011: - case 0b0011'1010'0100: case 0b0011'1010'0101: case 0b0011'1010'0110: case 0b0011'1010'0111: - case 0b0011'1010'1000: case 0b0011'1010'1001: case 0b0011'1010'1010: case 0b0011'1010'1011: - case 0b0011'1010'1100: case 0b0011'1010'1101: case 0b0011'1010'1110: case 0b0011'1010'1111: - case 0b0011'1011'0000: case 0b0011'1011'0001: case 0b0011'1011'0010: case 0b0011'1011'0011: - case 0b0011'1011'0100: case 0b0011'1011'0101: case 0b0011'1011'0110: case 0b0011'1011'0111: - case 0b0011'1011'1000: case 0b0011'1011'1001: case 0b0011'1011'1010: case 0b0011'1011'1011: - case 0b0011'1011'1100: case 0b0011'1011'1101: case 0b0011'1011'1110: case 0b0011'1011'1111: - { - // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3ac Subtract M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - // 3b0 AND M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3b4 Add M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry - // 3b8 OR M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 3bc Subtract M[H[5:1],L[2:1]][7:1] and A2[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if borrow - const int optype = (inst & 0x0c) >> 2; - const int reg2 = (inst & 0x10) >> 4; - const int n = inst & 0x3; - util::stream_format(stream, "M%s%s->M, 0x%d->L", get_300optype_name(optype), get_reg_name(reg2), n); - break; - } - - case 0b0011'1110'0000: case 0b0011'1110'0001: case 0b0011'1110'0010: case 0b0011'1110'0011: - case 0b0011'1110'0100: case 0b0011'1110'0101: case 0b0011'1110'0110: case 0b0011'1110'0111: - case 0b0011'1110'1000: case 0b0011'1110'1001: case 0b0011'1110'1010: case 0b0011'1110'1011: - case 0b0011'1110'1100: case 0b0011'1110'1101: case 0b0011'1110'1110: case 0b0011'1110'1111: - case 0b0011'1111'0000: case 0b0011'1111'0001: case 0b0011'1111'0010: case 0b0011'1111'0011: - case 0b0011'1111'0100: case 0b0011'1111'0101: case 0b0011'1111'0110: case 0b0011'1111'0111: - case 0b0011'1111'1000: case 0b0011'1111'1001: case 0b0011'1111'1010: case 0b0011'1111'1011: - case 0b0011'1111'1100: case 0b0011'1111'1101: case 0b0011'1111'1110: case 0b0011'1111'1111: - { - // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - // 3e8 OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] - // 3ec Subtract H[5:1] and A1[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - // 3f0 AND H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - // 3f4 Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] - // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] - const int optype = (inst & 0x0c) >> 2; - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - util::stream_format(stream, "H%s%s->H, 0x%d->L", get_300optype_name(optype), get_reg_name(reg), n); - break; - } - case 0b0011'1100'0000: case 0b0011'1100'0001: case 0b0011'1100'0010: case 0b0011'1100'0011: case 0b0011'1101'0000: case 0b0011'1101'0001: case 0b0011'1101'0010: case 0b0011'1101'0011: { @@ -632,24 +656,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "JPM, 0->L, %d->A11", n); break; } - case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: - case 0b0100'0100'1000: case 0b0100'0100'1001: case 0b0100'0100'1100: case 0b0100'0100'1101: - case 0b0100'0101'0000: case 0b0100'0101'0001: case 0b0100'0101'0100: case 0b0100'0101'0101: - case 0b0100'0101'1000: case 0b0100'0101'1001: case 0b0100'0101'1100: case 0b0100'0101'1101: - case 0b0100'0110'0000: case 0b0100'0110'0001: case 0b0100'0110'0100: case 0b0100'0110'0101: - case 0b0100'0110'1000: case 0b0100'0110'1001: case 0b0100'0110'1100: case 0b0100'0110'1101: - case 0b0100'0111'0000: case 0b0100'0111'0001: case 0b0100'0111'0100: case 0b0100'0111'0101: - case 0b0100'0111'1000: case 0b0100'0111'1001: case 0b0100'0111'1100: case 0b0100'0111'1101: - { - // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] - const int d = (inst >> 5) & 0x1; - const int g = (inst >> 4) & 0x1; - const int k = (inst >> 3) & 0x1; - const int s = (inst >> 2) & 0x1; - const int n = inst & 0x1; - util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", d, g, k, s, n); - break; - } default: { From 1b53523172d4faf87bc7dec51d7973df8b91f882 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 16:15:11 +0000 Subject: [PATCH 61/62] also remove myself as copyright holder, because I no longer recognize this code as my own, and would now be ashamed to put my name to it. --- src/devices/cpu/upd777/upd777.cpp | 325 ++++++++++++-------------- src/devices/cpu/upd777/upd777.h | 2 +- src/devices/cpu/upd777/upd777dasm.cpp | 203 ++++++++-------- src/devices/cpu/upd777/upd777dasm.h | 2 +- 4 files changed, 246 insertions(+), 286 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index 7301aa978cd27..d363577581418 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -1,5 +1,5 @@ // license:BSD-3-Clause -// copyright-holders:David Haywood +// copyright-holders: #include "emu.h" #include "upd777.h" @@ -812,63 +812,163 @@ void upd777_cpu_device::do_op() set_sme(s); set_a11(n); } - else + else if (inst == 0b0000'0000'0000) { - switch (inst) - { - case 0b0000'0000'0000: - { - // 000 No Operation - // nothing - break; - } - case 0b0000'0000'0100: - { - // 004 Skip if (Gun Port Latch) = 1 - LOGMASKED(LOG_UNHANDLED_OPS, "GPL\n"); - break; - } - case 0b0000'0000'1000: - { - // 008 Move H[5:1] to Line Buffer Register[5:1] - u8 h = get_h(); - //LOGMASKED(LOG_UNHANDLED_OPS, "H(%02x)->NRM\n", h); - - // this seems to push a value from RAM into the line buffer for the current 4(?) scanlines - u8 m1 = read_data_mem(get_h_shifted() | 0); - u8 m2 = read_data_mem(get_h_shifted() | 1); - u8 m3 = read_data_mem(get_h_shifted() | 2); - u8 m4 = read_data_mem(get_h_shifted() | 3); - push_to_line_buffer(h, m1,m2,m3,m4); - - break; - } - case 0b0000'0001'1000: - { - // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] - LOGMASKED(LOG_UNHANDLED_OPS, "H<->X\n"); + // 000 No Operation + // nothing + } + else if (inst == 0b0000'0000'0100) + { + // 004 Skip if (Gun Port Latch) = 1 + LOGMASKED(LOG_UNHANDLED_OPS, "GPL\n"); + } + else if (inst == 0b0000'0000'1000) + { + // 008 Move H[5:1] to Line Buffer Register[5:1] + u8 h = get_h(); + //LOGMASKED(LOG_UNHANDLED_OPS, "H(%02x)->NRM\n", h); + + // this seems to push a value from RAM into the line buffer for the current 4(?) scanlines + u8 m1 = read_data_mem(get_h_shifted() | 0); + u8 m2 = read_data_mem(get_h_shifted() | 1); + u8 m3 = read_data_mem(get_h_shifted() | 2); + u8 m4 = read_data_mem(get_h_shifted() | 3); + push_to_line_buffer(h, m1,m2,m3,m4); + } + else if (inst == 0b0000'0001'1000) + { + // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] + LOGMASKED(LOG_UNHANDLED_OPS, "H<->X\n"); #if 1 - // this opcode is not well explained! but X4 etc. are referenced on Data RAM & Register Files which makes - // it even more confusing (while L' isn't referenced anywhere else at all!) - u8 temp; + // this opcode is not well explained! but X4 etc. are referenced on Data RAM & Register Files which makes + // it even more confusing (while L' isn't referenced anywhere else at all!) + u8 temp; - temp = m_x4; - m_x4 = get_h(); - m_h = temp; + temp = m_x4; + m_x4 = get_h(); + m_h = temp; - temp = m_ldash; - m_ldash = get_l(); - set_l(temp); + temp = m_ldash; + m_ldash = get_l(); + set_l(temp); #endif - break; - } - case 0b0000'0010'0000: + } + else if (inst == 0b0000'0010'0000) + { + // 020 Subroutine End, Pop down address stack + u16 addr = pull_from_stack(); + set_new_pc(addr); + } + else if (inst == 0b0000'0100'1001) + { + // 049 Skip if (4H Horizontal Blank) = 1 + //LOGMASKED(LOG_UNHANDLED_OPS, "4H BLK\n"); + if (get_hbl_4_state()) + m_skip = 1; + } + else if (inst == 0b0000'0100'1010) + { + // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] + //LOGMASKED(LOG_UNHANDLED_OPS, "VBLK\n"); + if (get_vbl_state()) + m_skip = 1; + + // need to do the 0->M[[18:00],[3]][1] bit + } + else if (inst == 0b0000'0100'1100) + { + // 04c Skip if (GP&SW/ input) = 1 + LOGMASKED(LOG_UNHANDLED_OPS, "GPSW/\n"); + } + else if (inst == 0b0000'0101'0100) + { + // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] + write_data_mem(get_h_shifted() | 0, get_a1()); + write_data_mem(get_h_shifted() | 1, get_a2()); + write_data_mem(get_h_shifted() | 2, get_a3()); + write_data_mem(get_h_shifted() | 3, get_a4()); + } + else if (inst == 0b0000'0101'1000) + { + // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) + u8 m1 = read_data_mem(get_h_shifted() | 0); + u8 m2 = read_data_mem(get_h_shifted() | 1); + u8 m3 = read_data_mem(get_h_shifted() | 2); + u8 m4 = read_data_mem(get_h_shifted() | 3); + set_a1(m1); + set_a2(m2); + set_a3(m3); + set_a4(m4); + } + else if (inst == 0b0000'0101'1100) + { + // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] + u8 m1 = read_data_mem(get_h_shifted() | 0); + u8 m2 = read_data_mem(get_h_shifted() | 1); + u8 m3 = read_data_mem(get_h_shifted() | 2); + u8 m4 = read_data_mem(get_h_shifted() | 3); + write_data_mem(get_h_shifted() | 0, get_a1()); + write_data_mem(get_h_shifted() | 1, get_a2()); + write_data_mem(get_h_shifted() | 2, get_a3()); + write_data_mem(get_h_shifted() | 3, get_a4()); + set_a1(m1); + set_a2(m2); + set_a3(m3); + set_a4(m4); + } + else if (inst == 0b0000'0110'0000) + { + // 060 Subroutine End, Pop down address stack, Skip + u16 addr = pull_from_stack(); + set_new_pc(addr); + m_skip = 1; + } + else if (inst == 0b0011'0000'1000) + { + // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] + u8 a1 = get_a1(); + set_fls(a1); + set_l(0); + } + else if (inst == 0b0011'0100'1000) + { + // 348 Move A2[7:1] to FLS[7:1], 0->L[2:1] + u8 a2 = get_a2(); + set_fls(a2); + set_l(0); + } + else if (inst == 0b0011'1000'1000) + { + // 388 Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] + u8 m = get_m_data(); + set_fls(m); + set_l(0); + } + else if (inst == 0b0011'0000'1001) + { + // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] + u8 a1 = get_a1(); + set_frs(a1); + set_l(1); + } + else if (inst == 0b0011'0100'1001) + { + // 349 Move A2[7:1] to FRS[7:1], 1->L[2:1] + u8 a2 = get_a2(); + set_frs(a2); + set_l(1); + } + else if (inst == 0b0011'1000'1001) + { + // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] + u8 m = get_m_data(); + set_frs(m); + set_l(1); + } + else + { + switch (inst) { - // 020 Subroutine End, Pop down address stack - u16 addr = pull_from_stack(); - set_new_pc(addr); - break; - } case 0b0000'0010'1000: case 0b0000'0010'1001: { // 028 Shift STB[4:1], N->STB[1] @@ -899,78 +999,7 @@ void upd777_cpu_device::do_op() LOGMASKED(LOG_UNHANDLED_OPS, "PD%d %sJ\n", which + 1, inv ? "/" : ""); break; } - case 0b0000'0100'1001: - { - // 049 Skip if (4H Horizontal Blank) = 1 - //LOGMASKED(LOG_UNHANDLED_OPS, "4H BLK\n"); - if (get_hbl_4_state()) - m_skip = 1; - break; - } - case 0b0000'0100'1010: - { - // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] - //LOGMASKED(LOG_UNHANDLED_OPS, "VBLK\n"); - if (get_vbl_state()) - m_skip = 1; - // need to do the 0->M[[18:00],[3]][1] bit - - break; - } - case 0b0000'0100'1100: - { - // 04c Skip if (GP&SW/ input) = 1 - LOGMASKED(LOG_UNHANDLED_OPS, "GPSW/\n"); - break; - } - case 0b0000'0101'0100: - { - // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] - write_data_mem(get_h_shifted() | 0, get_a1()); - write_data_mem(get_h_shifted() | 1, get_a2()); - write_data_mem(get_h_shifted() | 2, get_a3()); - write_data_mem(get_h_shifted() | 3, get_a4()); - break; - } - case 0b0000'0101'1000: - { - // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) - u8 m1 = read_data_mem(get_h_shifted() | 0); - u8 m2 = read_data_mem(get_h_shifted() | 1); - u8 m3 = read_data_mem(get_h_shifted() | 2); - u8 m4 = read_data_mem(get_h_shifted() | 3); - set_a1(m1); - set_a2(m2); - set_a3(m3); - set_a4(m4); - break; - } - case 0b0000'0101'1100: - { - // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] - u8 m1 = read_data_mem(get_h_shifted() | 0); - u8 m2 = read_data_mem(get_h_shifted() | 1); - u8 m3 = read_data_mem(get_h_shifted() | 2); - u8 m4 = read_data_mem(get_h_shifted() | 3); - write_data_mem(get_h_shifted() | 0, get_a1()); - write_data_mem(get_h_shifted() | 1, get_a2()); - write_data_mem(get_h_shifted() | 2, get_a3()); - write_data_mem(get_h_shifted() | 3, get_a4()); - set_a1(m1); - set_a2(m2); - set_a3(m3); - set_a4(m4); - break; - } - case 0b0000'0110'0000: - { - // 060 Subroutine End, Pop down address stack, Skip - u16 addr = pull_from_stack(); - set_new_pc(addr); - m_skip = 1; - break; - } case 0b0011'0000'0000: case 0b0011'0000'0001: case 0b0011'0000'0010: case 0b0011'0000'0011: { // 300 N->L[2:1] @@ -979,56 +1008,6 @@ void upd777_cpu_device::do_op() break; } - case 0b0011'0000'1000: - { - // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] - u8 a1 = get_a1(); - set_fls(a1); - set_l(0); - break; - } - case 0b0011'0100'1000: - { - // 348 Move A2[7:1] to FLS[7:1], 0->L[2:1] - u8 a2 = get_a2(); - set_fls(a2); - set_l(0); - break; - } - case 0b0011'1000'1000: - { - // 388 Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] - u8 m = get_m_data(); - set_fls(m); - set_l(0); - break; - } - - case 0b0011'0000'1001: - { - // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] - u8 a1 = get_a1(); - set_frs(a1); - set_l(1); - break; - } - case 0b0011'0100'1001: - { - // 349 Move A2[7:1] to FRS[7:1], 1->L[2:1] - u8 a2 = get_a2(); - set_frs(a2); - set_l(1); - break; - } - case 0b0011'1000'1001: - { - // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] - u8 m = get_m_data(); - set_frs(m); - set_l(1); - break; - } - case 0b0011'0000'1010: case 0b0011'0000'1011: { // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] diff --git a/src/devices/cpu/upd777/upd777.h b/src/devices/cpu/upd777/upd777.h index 56fa3e8844279..81304f96f6df0 100644 --- a/src/devices/cpu/upd777/upd777.h +++ b/src/devices/cpu/upd777/upd777.h @@ -1,5 +1,5 @@ // license:BSD-3-Clause -// copyright-holders:David Haywood +// copyright-holders: #ifndef MAME_CPU_UPD777_UPD777_H #define MAME_CPU_UPD777_UPD777_H diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index f3ae994d8d287..80d7fa37bced4 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -1,5 +1,5 @@ // license:BSD-3-Clause -// copyright-holders:David Haywood +// copyright-holders: #include "emu.h" #include "upd777dasm.h" @@ -364,40 +364,100 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u const int n = inst & 0x1; util::stream_format(stream, "%d->D, %d->G, %d->K, %d->S, %d->A11", d, g, k, s, n); } + else if (inst == 0b0000'0000'0000) + { + // 000 No Operation + util::stream_format(stream, "NOP"); + } + else if (inst == 0b0000'0000'0100) + { + // 004 Skip if (Gun Port Latch) = 1 + util::stream_format(stream, "GPL"); + } + else if (inst == 0b0000'0000'1000) + { + // 008 Move H[5:1] to Line Buffer Register[5:1] + util::stream_format(stream, "H->NRM"); + } + else if (inst == 0b0000'0001'1000) + { + // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] + util::stream_format(stream, "H<->X"); + } + else if (inst == 0b0000'0010'0000) + { + // 020 Subroutine End, Pop down address stack + util::stream_format(stream, "SRE"); + } + else if (inst == 0b0000'0100'1001) + { + // 049 Skip if (4H Horizontal Blank) = 1 + util::stream_format(stream, "4H BLK"); + } + else if (inst == 0b0000'0100'1010) + { + // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] + util::stream_format(stream, "VBLK"); + } + else if (inst == 0b0000'0100'1100) + { + // 04c Skip if (GP&SW/ input) = 1 + util::stream_format(stream, "GPSW/"); + } + else if (inst == 0b0000'0101'0100) + { + // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] + util::stream_format(stream, "A->MA"); + } + else if (inst == 0b0000'0101'1000) + { + // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) + util::stream_format(stream, "MA->A"); + } + else if (inst == 0b0000'0101'1100) + { + // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] + util::stream_format(stream, "MA<->A"); + } + else if (inst == 0b0000'0110'0000) + { + // 060 Subroutine End, Pop down address stack, Skip + util::stream_format(stream, "SRE+1"); + } + else if (inst == 0b0011'0000'1000) + { + // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] + util::stream_format(stream, "A1->FLS, 0->L"); + } + else if (inst == 0b0011'0100'1000) + { + // 348 Move A2[7:1] to FLS[7:1], 0->L[2:1] + util::stream_format(stream, "A2->FLS, 0->L"); + } + else if (inst == 0b0011'1000'1000) + { + // 388 Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] + util::stream_format(stream, "M->FLS, 0->L"); + } + else if (inst == 0b0011'0000'1001) + { + // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] + util::stream_format(stream, "A1->FRS, 1->L"); + } + else if (inst == 0b0011'0100'1001) + { + // 349 Move A2[7:1] to FRS[7:1], 1->L[2:1] + util::stream_format(stream, "A2->FRS, 1->L"); + } + else if (inst == 0b0011'1000'1001) + { + // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] + util::stream_format(stream, "M->FRS, 1->L"); + } else { switch (inst) { - case 0b0000'0000'0000: - { - // 000 No Operation - util::stream_format(stream, "NOP"); - break; - } - case 0b0000'0000'0100: - { - // 004 Skip if (Gun Port Latch) = 1 - util::stream_format(stream, "GPL"); - break; - } - case 0b0000'0000'1000: - { - // 008 Move H[5:1] to Line Buffer Register[5:1] - util::stream_format(stream, "H->NRM"); - break; - } - case 0b0000'0001'1000: - { - // 018 H[5:1]<->X4[5:1], 0->X4[7:6], 0->X3[7:1], 0->X1'[1], 0->A1'[1], L[2:1]<->L'[2:1] - util::stream_format(stream, "H<->X"); - break; - } - case 0b0000'0010'0000: - { - // 020 Subroutine End, Pop down address stack - util::stream_format(stream, "SRE"); - break; - } case 0b0000'0010'1000: case 0b0000'0010'1001: { // 028 Shift STB[4:1], N->STB[1] @@ -428,48 +488,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u util::stream_format(stream, "PD%d %sJ", which + 1, inv ? "/" : ""); break; } - case 0b0000'0100'1001: - { - // 049 Skip if (4H Horizontal Blank) = 1 - util::stream_format(stream, "4H BLK"); - break; - } - case 0b0000'0100'1010: - { - // 04a Skip if (Vertical Blank) = 1, 0->M[[18:00],[3]][1] - util::stream_format(stream, "VBLK"); - break; - } - case 0b0000'0100'1100: - { - // 04c Skip if (GP&SW/ input) = 1 - util::stream_format(stream, "GPSW/"); - break; - } - case 0b0000'0101'0100: - { - // 054 Move (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) to M[H[5:1]][28:1] - util::stream_format(stream, "A->MA"); - break; - } - case 0b0000'0101'1000: - { - // 058 Move M[H[5:1]][28:1] to (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) - util::stream_format(stream, "MA->A"); - break; - } - case 0b0000'0101'1100: - { - // 05c Exchange (A4[7:1],A3[7:1],A2[7:1],A1[7:1]) and M[H[5:1]][28:1] - util::stream_format(stream, "MA<->A"); - break; - } - case 0b0000'0110'0000: - { - // 060 Subroutine End, Pop down address stack, Skip - util::stream_format(stream, "SRE+1"); - break; - } + case 0b0011'0000'0000: case 0b0011'0000'0001: case 0b0011'0000'0010: case 0b0011'0000'0011: { // 300 N->L[2:1] @@ -478,44 +497,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u break; } - case 0b0011'0000'1000: - { - // 308 Move A1[7:1] to FLS[7:1], 0->L[2:1] - util::stream_format(stream, "A1->FLS, 0->L"); - break; - } - case 0b0011'0100'1000: - { - // 348 Move A2[7:1] to FLS[7:1], 0->L[2:1] - util::stream_format(stream, "A2->FLS, 0->L"); - break; - } - case 0b0011'1000'1000: - { - // 388 Move M[H[5:1],L[2:1]][7:1] to FLS[7:1], 0->L[2:1] - util::stream_format(stream, "M->FLS, 0->L"); - break; - } - - case 0b0011'0000'1001: - { - // 309 Move A1[7:1] to FRS[7:1], 1->L[2:1] - util::stream_format(stream, "A1->FRS, 1->L"); - break; - } - case 0b0011'0100'1001: - { - // 349 Move A2[7:1] to FRS[7:1], 1->L[2:1] - util::stream_format(stream, "A2->FRS, 1->L"); - break; - } - case 0b0011'1000'1001: - { - // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] - util::stream_format(stream, "M->FRS, 1->L"); - break; - } - case 0b0011'0000'1010: case 0b0011'0000'1011: { // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] diff --git a/src/devices/cpu/upd777/upd777dasm.h b/src/devices/cpu/upd777/upd777dasm.h index 517304ef47de0..e02b2e4947a0b 100644 --- a/src/devices/cpu/upd777/upd777dasm.h +++ b/src/devices/cpu/upd777/upd777dasm.h @@ -1,5 +1,5 @@ // license:BSD-3-Clause -// copyright-holders:David Haywood +// copyright-holders: #ifndef MAME_CPU_UPD777_UPD777DASM_H #define MAME_CPU_UPD777_UPD777DASM_H From bb51a272ac8249c213def92f35148728b0eac0a1 Mon Sep 17 00:00:00 2001 From: David Haywood Date: Sat, 13 Jan 2024 16:37:24 +0000 Subject: [PATCH 62/62] final conversion into completely unmaintainable form --- src/devices/cpu/upd777/upd777.cpp | 519 ++++++++++---------------- src/devices/cpu/upd777/upd777dasm.cpp | 431 +++++++-------------- 2 files changed, 331 insertions(+), 619 deletions(-) diff --git a/src/devices/cpu/upd777/upd777.cpp b/src/devices/cpu/upd777/upd777.cpp index d363577581418..b6898774eaa59 100644 --- a/src/devices/cpu/upd777/upd777.cpp +++ b/src/devices/cpu/upd777/upd777.cpp @@ -418,57 +418,7 @@ void upd777_cpu_device::do_op() else if (((inst & 0b1111'0000'0000) == 0b0010'0000'0000) && ((inst & 0b0000'0000'1100) != 0b0000'0000'0100)) { // 0b0010'rrnR'oonn where rr = reg1 (A1, A2, M or H), n = invert condition, R = reg2 (A1 or A2) and oo = optype (only 0,2,3 are valid, no cases here for 1) nn = next l value - // the above 'if' statement is a shit way of representing the following bitfields -#if 0 - case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: - case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: - case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: - case 0b0010'0010'1000: case 0b0010'0010'1001: case 0b0010'0010'1010: case 0b0010'0010'1011: - case 0b0010'0000'1100: case 0b0010'0000'1101: case 0b0010'0000'1110: case 0b0010'0000'1111: - case 0b0010'0010'1100: case 0b0010'0010'1101: case 0b0010'0010'1110: case 0b0010'0010'1111: - case 0b0010'0001'0000: case 0b0010'0001'0001: case 0b0010'0001'0010: case 0b0010'0001'0011: - case 0b0010'0011'0000: case 0b0010'0011'0001: case 0b0010'0011'0010: case 0b0010'0011'0011: - case 0b0010'0001'1000: case 0b0010'0001'1001: case 0b0010'0001'1010: case 0b0010'0001'1011: - case 0b0010'0011'1000: case 0b0010'0011'1001: case 0b0010'0011'1010: case 0b0010'0011'1011: - case 0b0010'0001'1100: case 0b0010'0001'1101: case 0b0010'0001'1110: case 0b0010'0001'1111: - case 0b0010'0011'1100: case 0b0010'0011'1101: case 0b0010'0011'1110: case 0b0010'0011'1111: - case 0b0010'0100'0000: case 0b0010'0100'0001: case 0b0010'0100'0010: case 0b0010'0100'0011: - case 0b0010'0110'0000: case 0b0010'0110'0001: case 0b0010'0110'0010: case 0b0010'0110'0011: - case 0b0010'0100'1000: case 0b0010'0100'1001: case 0b0010'0100'1010: case 0b0010'0100'1011: - case 0b0010'0110'1000: case 0b0010'0110'1001: case 0b0010'0110'1010: case 0b0010'0110'1011: - case 0b0010'0100'1100: case 0b0010'0100'1101: case 0b0010'0100'1110: case 0b0010'0100'1111: - case 0b0010'0110'1100: case 0b0010'0110'1101: case 0b0010'0110'1110: case 0b0010'0110'1111: - case 0b0010'0101'0000: case 0b0010'0101'0001: case 0b0010'0101'0010: case 0b0010'0101'0011: - case 0b0010'0111'0000: case 0b0010'0111'0001: case 0b0010'0111'0010: case 0b0010'0111'0011: - case 0b0010'0101'1000: case 0b0010'0101'1001: case 0b0010'0101'1010: case 0b0010'0101'1011: - case 0b0010'0111'1000: case 0b0010'0111'1001: case 0b0010'0111'1010: case 0b0010'0111'1011: - case 0b0010'0101'1100: case 0b0010'0101'1101: case 0b0010'0101'1110: case 0b0010'0101'1111: - case 0b0010'0111'1100: case 0b0010'0111'1101: case 0b0010'0111'1110: case 0b0010'0111'1111: - case 0b0010'1000'0000: case 0b0010'1000'0001: case 0b0010'1000'0010: case 0b0010'1000'0011: - case 0b0010'1010'0000: case 0b0010'1010'0001: case 0b0010'1010'0010: case 0b0010'1010'0011: - case 0b0010'1000'1000: case 0b0010'1000'1001: case 0b0010'1000'1010: case 0b0010'1000'1011: - case 0b0010'1010'1000: case 0b0010'1010'1001: case 0b0010'1010'1010: case 0b0010'1010'1011: - case 0b0010'1000'1100: case 0b0010'1000'1101: case 0b0010'1000'1110: case 0b0010'1000'1111: - case 0b0010'1010'1100: case 0b0010'1010'1101: case 0b0010'1010'1110: case 0b0010'1010'1111: - case 0b0010'1001'0000: case 0b0010'1001'0001: case 0b0010'1001'0010: case 0b0010'1001'0011: - case 0b0010'1011'0000: case 0b0010'1011'0001: case 0b0010'1011'0010: case 0b0010'1011'0011: - case 0b0010'1001'1000: case 0b0010'1001'1001: case 0b0010'1001'1010: case 0b0010'1001'1011: - case 0b0010'1011'1000: case 0b0010'1011'1001: case 0b0010'1011'1010: case 0b0010'1011'1011: - case 0b0010'1001'1100: case 0b0010'1001'1101: case 0b0010'1001'1110: case 0b0010'1001'1111: - case 0b0010'1011'1100: case 0b0010'1011'1101: case 0b0010'1011'1110: case 0b0010'1011'1111: - case 0b0010'1100'0000: case 0b0010'1100'0001: case 0b0010'1100'0010: case 0b0010'1100'0011: - case 0b0010'1110'0000: case 0b0010'1110'0001: case 0b0010'1110'0010: case 0b0010'1110'0011: - case 0b0010'1100'1000: case 0b0010'1100'1001: case 0b0010'1100'1010: case 0b0010'1100'1011: - case 0b0010'1110'1000: case 0b0010'1110'1001: case 0b0010'1110'1010: case 0b0010'1110'1011: - case 0b0010'1100'1100: case 0b0010'1100'1101: case 0b0010'1100'1110: case 0b0010'1100'1111: - case 0b0010'1110'1100: case 0b0010'1110'1101: case 0b0010'1110'1110: case 0b0010'1110'1111: - case 0b0010'1101'0000: case 0b0010'1101'0001: case 0b0010'1101'0010: case 0b0010'1101'0011: - case 0b0010'1111'0000: case 0b0010'1111'0001: case 0b0010'1111'0010: case 0b0010'1111'0011: - case 0b0010'1101'1000: case 0b0010'1101'1001: case 0b0010'1101'1010: case 0b0010'1101'1011: - case 0b0010'1111'1000: case 0b0010'1111'1001: case 0b0010'1111'1010: case 0b0010'1111'1011: - case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: - case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: -#endif + // optype · (AND) // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] @@ -602,24 +552,7 @@ void upd777_cpu_device::do_op() { // the above 'if' statement is a shit way of representing the following bitfields // 0b0011'0r1R'oonn (where r = reg1, R = reg2, o = optype, and n = next l value) -#if 0 - case 0b0011'0010'0000: case 0b0011'0010'0001: case 0b0011'0010'0010: case 0b0011'0010'0011: - case 0b0011'0010'0100: case 0b0011'0010'0101: case 0b0011'0010'0110: case 0b0011'0010'0111: - case 0b0011'0010'1000: case 0b0011'0010'1001: case 0b0011'0010'1010: case 0b0011'0010'1011: - case 0b0011'0010'1100: case 0b0011'0010'1101: case 0b0011'0010'1110: case 0b0011'0010'1111: - case 0b0011'0011'0000: case 0b0011'0011'0001: case 0b0011'0011'0010: case 0b0011'0011'0011: - case 0b0011'0011'0100: case 0b0011'0011'0101: case 0b0011'0011'0110: case 0b0011'0011'0111: - case 0b0011'0011'1000: case 0b0011'0011'1001: case 0b0011'0011'1010: case 0b0011'0011'1011: - case 0b0011'0011'1100: case 0b0011'0011'1101: case 0b0011'0011'1110: case 0b0011'0011'1111: - case 0b0011'0110'0000: case 0b0011'0110'0001: case 0b0011'0110'0010: case 0b0011'0110'0011: - case 0b0011'0110'0100: case 0b0011'0110'0101: case 0b0011'0110'0110: case 0b0011'0110'0111: - case 0b0011'0110'1000: case 0b0011'0110'1001: case 0b0011'0110'1010: case 0b0011'0110'1011: - case 0b0011'0110'1100: case 0b0011'0110'1101: case 0b0011'0110'1110: case 0b0011'0110'1111: - case 0b0011'0111'0000: case 0b0011'0111'0001: case 0b0011'0111'0010: case 0b0011'0111'0011: - case 0b0011'0111'0100: case 0b0011'0111'0101: case 0b0011'0111'0110: case 0b0011'0111'0111: - case 0b0011'0111'1000: case 0b0011'0111'1001: case 0b0011'0111'1010: case 0b0011'0111'1011: - case 0b0011'0111'1100: case 0b0011'0111'1101: case 0b0011'0111'1110: case 0b0011'0111'1111: -#endif + // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] @@ -677,17 +610,7 @@ void upd777_cpu_device::do_op() } else if ((inst & 0b1111'1110'0000) == 0b0011'1010'0000) { -#if 0 // 0b0011'101r'oonn (where r = reg, o = optype, n = next l value) - case 0b0011'1010'0000: case 0b0011'1010'0001: case 0b0011'1010'0010: case 0b0011'1010'0011: - case 0b0011'1010'0100: case 0b0011'1010'0101: case 0b0011'1010'0110: case 0b0011'1010'0111: - case 0b0011'1010'1000: case 0b0011'1010'1001: case 0b0011'1010'1010: case 0b0011'1010'1011: - case 0b0011'1010'1100: case 0b0011'1010'1101: case 0b0011'1010'1110: case 0b0011'1010'1111: - case 0b0011'1011'0000: case 0b0011'1011'0001: case 0b0011'1011'0010: case 0b0011'1011'0011: - case 0b0011'1011'0100: case 0b0011'1011'0101: case 0b0011'1011'0110: case 0b0011'1011'0111: - case 0b0011'1011'1000: case 0b0011'1011'1001: case 0b0011'1011'1010: case 0b0011'1011'1011: - case 0b0011'1011'1100: case 0b0011'1011'1101: case 0b0011'1011'1110: case 0b0011'1011'1111: -#endif // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] @@ -734,17 +657,7 @@ void upd777_cpu_device::do_op() } else if ((inst & 0b1111'1110'0000) == 0b0011'1110'0000) { -#if 0 // 0b0011'111r'oonn (where r = reg, o = optype, n = next l value) - case 0b0011'1110'0000: case 0b0011'1110'0001: case 0b0011'1110'0010: case 0b0011'1110'0011: - case 0b0011'1110'0100: case 0b0011'1110'0101: case 0b0011'1110'0110: case 0b0011'1110'0111: - case 0b0011'1110'1000: case 0b0011'1110'1001: case 0b0011'1110'1010: case 0b0011'1110'1011: - case 0b0011'1110'1100: case 0b0011'1110'1101: case 0b0011'1110'1110: case 0b0011'1110'1111: - case 0b0011'1111'0000: case 0b0011'1111'0001: case 0b0011'1111'0010: case 0b0011'1111'0011: - case 0b0011'1111'0100: case 0b0011'1111'0101: case 0b0011'1111'0110: case 0b0011'1111'0111: - case 0b0011'1111'1000: case 0b0011'1111'1001: case 0b0011'1111'1010: case 0b0011'1111'1011: - case 0b0011'1111'1100: case 0b0011'1111'1101: case 0b0011'1111'1110: case 0b0011'1111'1111: -#endif // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] // 3e8 OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] @@ -789,17 +702,7 @@ void upd777_cpu_device::do_op() } else if ((inst & 0b1111'1100'0010) == 0b0100'0100'0000) { -#if 0 - // 0b0100'01dg'ks0n (where d = DISP, G = GPE, K = KIE, S = SME, n = A11) - case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: - case 0b0100'0100'1000: case 0b0100'0100'1001: case 0b0100'0100'1100: case 0b0100'0100'1101: - case 0b0100'0101'0000: case 0b0100'0101'0001: case 0b0100'0101'0100: case 0b0100'0101'0101: - case 0b0100'0101'1000: case 0b0100'0101'1001: case 0b0100'0101'1100: case 0b0100'0101'1101: - case 0b0100'0110'0000: case 0b0100'0110'0001: case 0b0100'0110'0100: case 0b0100'0110'0101: - case 0b0100'0110'1000: case 0b0100'0110'1001: case 0b0100'0110'1100: case 0b0100'0110'1101: - case 0b0100'0111'0000: case 0b0100'0111'0001: case 0b0100'0111'0100: case 0b0100'0111'0101: - case 0b0100'0111'1000: case 0b0100'0111'1001: case 0b0100'0111'1100: case 0b0100'0111'1101: -#endif + // 0b0100'01dg'ks0n (where d = DISP, G = GPE, K = KIE, S = SME, n = A11) // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] const int d = (inst >> 5) & 0x1; const int g = (inst >> 4) & 0x1; @@ -965,239 +868,193 @@ void upd777_cpu_device::do_op() set_frs(m); set_l(1); } - else + else if ((inst == 0b0000'0010'1000) || (inst == 0b0000'0010'1001)) { - switch (inst) - { - case 0b0000'0010'1000: case 0b0000'0010'1001: - { - // 028 Shift STB[4:1], N->STB[1] - // STB is an input strobe / shifter - const int n = inst & 1; - LOGMASKED(LOG_UNHANDLED_OPS, "0x%d->STB\n", n); - break; - } - case 0b0000'0011'0000: - case 0b0000'0011'0100: - case 0b0000'0011'1000: - case 0b0000'0011'1100: - case 0b0000'0111'0000: - case 0b0000'0111'0100: - case 0b0000'0111'1000: - case 0b0000'0111'1100: - { - // 30 Skip if (PD1 input) = 1 - // 34 Skip if (PD2 input) = 1 - // 38 Skip if (PD3 input) = 1 - // 3c Skip if (PD4 input) = 1 - // 70 Skip if (PD1 input) = 0 - // 74 Skip if (PD2 input) = 0 - // 78 Skip if (PD3 input) = 0 - // 7c Skip if (PD4 input) = 0 - const int which = (inst & 0x00c) >> 2; - const int inv = inst & 0x40; - LOGMASKED(LOG_UNHANDLED_OPS, "PD%d %sJ\n", which + 1, inv ? "/" : ""); - break; - } - - case 0b0011'0000'0000: case 0b0011'0000'0001: case 0b0011'0000'0010: case 0b0011'0000'0011: - { - // 300 N->L[2:1] - const int n = inst & 0x3; - set_l(n); - break; - } - - case 0b0011'0000'1010: case 0b0011'0000'1011: - { - // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] - const int n = (inst & 0x1) + 2; - u8 a1 = get_a1(); - set_mode(a1); - set_l(n); - break; - } - case 0b0011'01001010: case 0b0011'0100'1011: - { - // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] - const int n = (inst & 0x1) + 2; - u8 a2 = get_a2(); - set_mode(a2); - set_l(n); - break; - } - case 0b0011'1000'1010: case 0b00111000'1011: - { - // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] - const int n = (inst & 0x1) + 2; - u8 m = get_m_data(); - set_mode(m); - set_l(n); - break; - } - - case 0b0011'0001'0000: case 0b0011'0001'0001: case 0b0011'0001'0010: case 0b0011'0001'0011: - { - // 310 Move A2[7:1] to A1[7:1], N->L[2:1] - const int n = inst & 0x3; - u8 a2 = get_a2(); - set_a1(a2); - set_l(n); - break; - } - case 0b0011'0100'0000: case 0b0011'0100'0001: case 0b0011'0100'0010: case 0b0011'0100'0011: - { - // 340 Move A1[7:1] to A2[7:1], N->L[2:1] - const int n = inst & 0x3; - u8 a1 = get_a1(); - set_a2(a1); - set_l(n); - break; - } - - case 0b0011'0001'1000: case 0b0011'0001'1001: case 0b0011'0001'1010: case 0b0011'0001'1011: - { - // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] - const int n = inst & 0x3; - u8 a1 = get_a1(); - a1 = a1 >> 1; - set_a1(a1); - set_l(n); - break; - } - case 0b0011'0101'1000: case 0b0011'0101'1001: case 0b0011'0101'1010: case 0b0011'0101'1011: - { - // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] - const int n = inst & 0x3; - u8 a2 = get_a2(); - a2 = a2 >> 1; - set_a2(a2); - set_l(n); - break; - } - case 0b0011'1001'1000: case 0b0011'1001'1001: case 0b0011'1001'1010: case 0b0011'1001'1011: - { - // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] - const int n = inst & 0x3; - u8 m = get_m_data(); - m = m >> 1; - set_m_data(m); - set_l(n); - break; - } - - case 0b0011'0001'1100: case 0b0011'0001'1101: case 0b0011'0001'1110: case 0b0011'0001'1111: - { - // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - const int n = inst & 0x3; - u8 a1 = get_a1(); - u8 a2 = get_a2(); - a2 = a1 - a2; - if (a2 & 0x80) - m_skip = 1; - set_a2(a2); - set_l(n); - break; - } - case 0b0011'0100'1100: case 0b0011'0100'1101: case 0b0011'0100'1110: case 0b0011'0100'1111: - { - // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - const int n = inst & 0x3; - u8 a1 = get_a1(); - u8 a2 = get_a2(); - a1 = a2 - a1; - if (a1 & 0x80) - m_skip = 1; - set_a1(a1); - set_l(n); - break; - } - case 0b0011'1000'0000: case 0b0011'1000'0001: case 0b0011'1000'0010: case 0b0011'1000'0011: - case 0b0011'1001'0000: case 0b0011'1001'0001: case 0b0011'1001'0010: case 0b0011'1001'0011: - { - // 380 Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - u8 src = get_a1_or_a2(reg); - set_m_data(src); - set_l(n); - break; - } - - case 0b0011'1000'0100: case 0b0011'1000'0101: case 0b0011'1000'0110: case 0b0011'1000'0111: - case 0b0011'1001'0100: case 0b0011'1001'0101: case 0b0011'1001'0110: case 0b0011'1001'0111: - { - // 384 Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] - // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - u8 src = get_a1_or_a2(reg); - u8 m = get_m_data(); - set_m_data(src); - set_a1_or_a2(reg,m); - set_l(n); - break; - } - - case 0b0011'1000'1100: case 0b0011'1000'1101: case 0b0011'1000'1110: case 0b0011'1000'1111: - case 0b0011'1001'1100: case 0b0011'1001'1101: case 0b0011'1001'1110: case 0b0011'1001'1111: - { - // 38c Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] - // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - u8 m = get_m_data(); - set_a1_or_a2(reg,m); - set_l(n); - break; - } - case 0b0011'1100'0000: case 0b0011'1100'0001: case 0b0011'1100'0010: case 0b0011'1100'0011: - case 0b0011'1101'0000: case 0b0011'1101'0001: case 0b0011'1101'0010: case 0b0011'1101'0011: - { - // 3c0 Move A1[5:1] to H[5:1], N->L[2:1] - // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - u8 src = get_a1_or_a2(reg); - set_h(src); - set_l(n); - break; - } - case 0b0011'1100'1100: case 0b0011'1100'1101: case 0b0011'1100'1110: case 0b0011'1100'1111: - case 0b0011'1101'1100: case 0b0011'1101'1101: case 0b0011'1101'1110: case 0b0011'1101'1111: - { - // 3cc Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] - // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - u8 h = get_h() & 0x1f; - set_a1_or_a2(reg,h); - set_l(n); - break; - } + // 028 Shift STB[4:1], N->STB[1] + // STB is an input strobe / shifter + const int n = inst & 1; + LOGMASKED(LOG_UNHANDLED_OPS, "0x%d->STB\n", n); + } - case 0b0100'0000'0000: case 0b0100'0000'0001: - { - // 400 N->A[11] - const int n = inst & 0x1; - set_a11(n); - break; - } - case 0b0100'0000'0010: case 0b0100'0000'0011: - { - // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] - const int n = inst & 0x1; - LOGMASKED(LOG_UNHANDLED_OPS, "JPM, 0->L, %d->A11\n", n); - set_a11(n); - break; - } - default: - { - LOGMASKED(LOG_UNHANDLED_OPS, "%04x \n", inst); - break; - } - } + else if ((inst == 0b0011'0000'1010) || (inst == 0b0011'0000'1011)) + { + // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + u8 a1 = get_a1(); + set_mode(a1); + set_l(n); + } + else if ((inst == 0b0011'01001010) || (inst == 0b0011'0100'1011)) + { + // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + u8 a2 = get_a2(); + set_mode(a2); + set_l(n); + } + else if ((inst == 0b0011'1000'1010) || (inst == 0b00111000'1011)) + { + // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + u8 m = get_m_data(); + set_mode(m); + set_l(n); + } + else if ((inst == 0b0100'0000'0000) || (inst == 0b0100'0000'0001)) + { + // 400 N->A[11] + const int n = inst & 0x1; + set_a11(n); + } + else if ((inst == 0b0100'0000'0010) || (inst == 0b0100'0000'0011)) + { + // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] + const int n = inst & 0x1; + LOGMASKED(LOG_UNHANDLED_OPS, "JPM, 0->L, %d->A11\n", n); + set_a11(n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0000'0000) + { + // 300 N->L[2:1] + const int n = inst & 0x3; + set_l(n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0001'0000) + { + // 310 Move A2[7:1] to A1[7:1], N->L[2:1] + const int n = inst & 0x3; + u8 a2 = get_a2(); + set_a1(a2); + set_l(n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0100'0000) + { + // 340 Move A1[7:1] to A2[7:1], N->L[2:1] + const int n = inst & 0x3; + u8 a1 = get_a1(); + set_a2(a1); + set_l(n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0001'1000) + { + // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] + const int n = inst & 0x3; + u8 a1 = get_a1(); + a1 = a1 >> 1; + set_a1(a1); + set_l(n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0101'1000) + { + // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] + const int n = inst & 0x3; + u8 a2 = get_a2(); + a2 = a2 >> 1; + set_a2(a2); + set_l(n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'1001'1000) + { + // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] + const int n = inst & 0x3; + u8 m = get_m_data(); + m = m >> 1; + set_m_data(m); + set_l(n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0001'1100) + { + // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + const int n = inst & 0x3; + u8 a1 = get_a1(); + u8 a2 = get_a2(); + a2 = a1 - a2; + if (a2 & 0x80) + m_skip = 1; + set_a2(a2); + set_l(n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0100'1100) + { + // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + const int n = inst & 0x3; + u8 a1 = get_a1(); + u8 a2 = get_a2(); + a1 = a2 - a1; + if (a1 & 0x80) + m_skip = 1; + set_a1(a1); + set_l(n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1000'0000) + { + // 380 Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + u8 src = get_a1_or_a2(reg); + set_m_data(src); + set_l(n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1000'0100) + { + // 384 Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] + // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + u8 src = get_a1_or_a2(reg); + u8 m = get_m_data(); + set_m_data(src); + set_a1_or_a2(reg,m); + set_l(n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1000'1100) + { + // 38c Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] + // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + u8 m = get_m_data(); + set_a1_or_a2(reg,m); + set_l(n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1100'0000) + { + // 3c0 Move A1[5:1] to H[5:1], N->L[2:1] + // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + u8 src = get_a1_or_a2(reg); + set_h(src); + set_l(n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1100'1100) + { + // 3cc Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] + // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + u8 h = get_h() & 0x1f; + set_a1_or_a2(reg,h); + set_l(n); + } + else if ((inst & 0b1111'1011'0011) == 0b0000'0011'0000) + { + // 30 Skip if (PD1 input) = 1 + // 34 Skip if (PD2 input) = 1 + // 38 Skip if (PD3 input) = 1 + // 3c Skip if (PD4 input) = 1 + // 70 Skip if (PD1 input) = 0 + // 74 Skip if (PD2 input) = 0 + // 78 Skip if (PD3 input) = 0 + // 7c Skip if (PD4 input) = 0 + const int which = (inst & 0x00c) >> 2; + const int inv = inst & 0x40; + LOGMASKED(LOG_UNHANDLED_OPS, "PD%d %sJ\n", which + 1, inv ? "/" : ""); + } + else + { + LOGMASKED(LOG_UNHANDLED_OPS, "%04x \n", inst); } } diff --git a/src/devices/cpu/upd777/upd777dasm.cpp b/src/devices/cpu/upd777/upd777dasm.cpp index 80d7fa37bced4..265fcf54e581c 100644 --- a/src/devices/cpu/upd777/upd777dasm.cpp +++ b/src/devices/cpu/upd777/upd777dasm.cpp @@ -135,57 +135,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u else if (((inst & 0b1111'0000'0000) == 0b0010'0000'0000) && ((inst & 0b0000'0000'1100) != 0b0000'0000'0100)) { // 0b0010'rrnR'oonn where rr = reg1 (A1, A2, M or H), n = invert condition, R = reg2 (A1 or A2) and oo = optype (only 0,2,3 are valid, no cases here for 1) nn = next l value - // the above 'if' statement is a shit way of representing the following bitfields -#if 0 - case 0b0010'0000'0000: case 0b0010'0000'0001: case 0b0010'0000'0010: case 0b0010'0000'0011: - case 0b0010'0010'0000: case 0b0010'0010'0001: case 0b0010'0010'0010: case 0b0010'0010'0011: - case 0b0010'0000'1000: case 0b0010'0000'1001: case 0b0010'0000'1010: case 0b0010'0000'1011: - case 0b0010'0010'1000: case 0b0010'0010'1001: case 0b0010'0010'1010: case 0b0010'0010'1011: - case 0b0010'0000'1100: case 0b0010'0000'1101: case 0b0010'0000'1110: case 0b0010'0000'1111: - case 0b0010'0010'1100: case 0b0010'0010'1101: case 0b0010'0010'1110: case 0b0010'0010'1111: - case 0b0010'0001'0000: case 0b0010'0001'0001: case 0b0010'0001'0010: case 0b0010'0001'0011: - case 0b0010'0011'0000: case 0b0010'0011'0001: case 0b0010'0011'0010: case 0b0010'0011'0011: - case 0b0010'0001'1000: case 0b0010'0001'1001: case 0b0010'0001'1010: case 0b0010'0001'1011: - case 0b0010'0011'1000: case 0b0010'0011'1001: case 0b0010'0011'1010: case 0b0010'0011'1011: - case 0b0010'0001'1100: case 0b0010'0001'1101: case 0b0010'0001'1110: case 0b0010'0001'1111: - case 0b0010'0011'1100: case 0b0010'0011'1101: case 0b0010'0011'1110: case 0b0010'0011'1111: - case 0b0010'0100'0000: case 0b0010'0100'0001: case 0b0010'0100'0010: case 0b0010'0100'0011: - case 0b0010'0110'0000: case 0b0010'0110'0001: case 0b0010'0110'0010: case 0b0010'0110'0011: - case 0b0010'0100'1000: case 0b0010'0100'1001: case 0b0010'0100'1010: case 0b0010'0100'1011: - case 0b0010'0110'1000: case 0b0010'0110'1001: case 0b0010'0110'1010: case 0b0010'0110'1011: - case 0b0010'0100'1100: case 0b0010'0100'1101: case 0b0010'0100'1110: case 0b0010'0100'1111: - case 0b0010'0110'1100: case 0b0010'0110'1101: case 0b0010'0110'1110: case 0b0010'0110'1111: - case 0b0010'0101'0000: case 0b0010'0101'0001: case 0b0010'0101'0010: case 0b0010'0101'0011: - case 0b0010'0111'0000: case 0b0010'0111'0001: case 0b0010'0111'0010: case 0b0010'0111'0011: - case 0b0010'0101'1000: case 0b0010'0101'1001: case 0b0010'0101'1010: case 0b0010'0101'1011: - case 0b0010'0111'1000: case 0b0010'0111'1001: case 0b0010'0111'1010: case 0b0010'0111'1011: - case 0b0010'0101'1100: case 0b0010'0101'1101: case 0b0010'0101'1110: case 0b0010'0101'1111: - case 0b0010'0111'1100: case 0b0010'0111'1101: case 0b0010'0111'1110: case 0b0010'0111'1111: - case 0b0010'1000'0000: case 0b0010'1000'0001: case 0b0010'1000'0010: case 0b0010'1000'0011: - case 0b0010'1010'0000: case 0b0010'1010'0001: case 0b0010'1010'0010: case 0b0010'1010'0011: - case 0b0010'1000'1000: case 0b0010'1000'1001: case 0b0010'1000'1010: case 0b0010'1000'1011: - case 0b0010'1010'1000: case 0b0010'1010'1001: case 0b0010'1010'1010: case 0b0010'1010'1011: - case 0b0010'1000'1100: case 0b0010'1000'1101: case 0b0010'1000'1110: case 0b0010'1000'1111: - case 0b0010'1010'1100: case 0b0010'1010'1101: case 0b0010'1010'1110: case 0b0010'1010'1111: - case 0b0010'1001'0000: case 0b0010'1001'0001: case 0b0010'1001'0010: case 0b0010'1001'0011: - case 0b0010'1011'0000: case 0b0010'1011'0001: case 0b0010'1011'0010: case 0b0010'1011'0011: - case 0b0010'1001'1000: case 0b0010'1001'1001: case 0b0010'1001'1010: case 0b0010'1001'1011: - case 0b0010'1011'1000: case 0b0010'1011'1001: case 0b0010'1011'1010: case 0b0010'1011'1011: - case 0b0010'1001'1100: case 0b0010'1001'1101: case 0b0010'1001'1110: case 0b0010'1001'1111: - case 0b0010'1011'1100: case 0b0010'1011'1101: case 0b0010'1011'1110: case 0b0010'1011'1111: - case 0b0010'1100'0000: case 0b0010'1100'0001: case 0b0010'1100'0010: case 0b0010'1100'0011: - case 0b0010'1110'0000: case 0b0010'1110'0001: case 0b0010'1110'0010: case 0b0010'1110'0011: - case 0b0010'1100'1000: case 0b0010'1100'1001: case 0b0010'1100'1010: case 0b0010'1100'1011: - case 0b0010'1110'1000: case 0b0010'1110'1001: case 0b0010'1110'1010: case 0b0010'1110'1011: - case 0b0010'1100'1100: case 0b0010'1100'1101: case 0b0010'1100'1110: case 0b0010'1100'1111: - case 0b0010'1110'1100: case 0b0010'1110'1101: case 0b0010'1110'1110: case 0b0010'1110'1111: - case 0b0010'1101'0000: case 0b0010'1101'0001: case 0b0010'1101'0010: case 0b0010'1101'0011: - case 0b0010'1111'0000: case 0b0010'1111'0001: case 0b0010'1111'0010: case 0b0010'1111'0011: - case 0b0010'1101'1000: case 0b0010'1101'1001: case 0b0010'1101'1010: case 0b0010'1101'1011: - case 0b0010'1111'1000: case 0b0010'1111'1001: case 0b0010'1111'1010: case 0b0010'1111'1011: - case 0b0010'1101'1100: case 0b0010'1101'1101: case 0b0010'1101'1110: case 0b0010'1101'1111: - case 0b0010'1111'1100: case 0b0010'1111'1101: case 0b0010'1111'1110: case 0b0010'1111'1111: -#endif + // // optype · (AND) // 200 Skip if (A1[7:1]·A1[7:1]) makes zero, N->L[2:1] // 220 Skip if (A1[7:1]·A1[7:1]) makes non zero, N->L[2:1] @@ -248,27 +198,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u } else if ((inst & 0b1111'1010'0000) == 0b0011'0010'0000) { - // the above 'if' statement is a shit way of representing the following bitfields // 0b0011'0r1R'oonn (where r = reg1, R = reg2, o = optype, and n = next l value) -#if 0 - case 0b0011'0010'0000: case 0b0011'0010'0001: case 0b0011'0010'0010: case 0b0011'0010'0011: - case 0b0011'0010'0100: case 0b0011'0010'0101: case 0b0011'0010'0110: case 0b0011'0010'0111: - case 0b0011'0010'1000: case 0b0011'0010'1001: case 0b0011'0010'1010: case 0b0011'0010'1011: - case 0b0011'0010'1100: case 0b0011'0010'1101: case 0b0011'0010'1110: case 0b0011'0010'1111: - case 0b0011'0011'0000: case 0b0011'0011'0001: case 0b0011'0011'0010: case 0b0011'0011'0011: - case 0b0011'0011'0100: case 0b0011'0011'0101: case 0b0011'0011'0110: case 0b0011'0011'0111: - case 0b0011'0011'1000: case 0b0011'0011'1001: case 0b0011'0011'1010: case 0b0011'0011'1011: - case 0b0011'0011'1100: case 0b0011'0011'1101: case 0b0011'0011'1110: case 0b0011'0011'1111: - case 0b0011'0110'0000: case 0b0011'0110'0001: case 0b0011'0110'0010: case 0b0011'0110'0011: - case 0b0011'0110'0100: case 0b0011'0110'0101: case 0b0011'0110'0110: case 0b0011'0110'0111: - case 0b0011'0110'1000: case 0b0011'0110'1001: case 0b0011'0110'1010: case 0b0011'0110'1011: - case 0b0011'0110'1100: case 0b0011'0110'1101: case 0b0011'0110'1110: case 0b0011'0110'1111: - case 0b0011'0111'0000: case 0b0011'0111'0001: case 0b0011'0111'0010: case 0b0011'0111'0011: - case 0b0011'0111'0100: case 0b0011'0111'0101: case 0b0011'0111'0110: case 0b0011'0111'0111: - case 0b0011'0111'1000: case 0b0011'0111'1001: case 0b0011'0111'1010: case 0b0011'0111'1011: - case 0b0011'0111'1100: case 0b0011'0111'1101: case 0b0011'0111'1110: case 0b0011'0111'1111: -#endif - // 320 AND A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] // 324 Add A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] // 328 OR A1[7:1] and A1[7:1], store to A1[7:1], N->L[2:1] @@ -294,16 +224,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u else if ((inst & 0b1111'1110'0000) == 0b0011'1010'0000) { // 0b0011'101r'oonn (where r = reg, o = optype, n = next l value) -#if 0 - case 0b0011'1010'0000: case 0b0011'1010'0001: case 0b0011'1010'0010: case 0b0011'1010'0011: - case 0b0011'1010'0100: case 0b0011'1010'0101: case 0b0011'1010'0110: case 0b0011'1010'0111: - case 0b0011'1010'1000: case 0b0011'1010'1001: case 0b0011'1010'1010: case 0b0011'1010'1011: - case 0b0011'1010'1100: case 0b0011'1010'1101: case 0b0011'1010'1110: case 0b0011'1010'1111: - case 0b0011'1011'0000: case 0b0011'1011'0001: case 0b0011'1011'0010: case 0b0011'1011'0011: - case 0b0011'1011'0100: case 0b0011'1011'0101: case 0b0011'1011'0110: case 0b0011'1011'0111: - case 0b0011'1011'1000: case 0b0011'1011'1001: case 0b0011'1011'1010: case 0b0011'1011'1011: - case 0b0011'1011'1100: case 0b0011'1011'1101: case 0b0011'1011'1110: case 0b0011'1011'1111: -#endif // 3a0 AND M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] // 3a4 Add M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] Skip if carry // 3a8 OR M[H[5:1],L[2:1]][7:1] and A1[7:1], store to M[H[5:1],L[2:1]][7:1], N->L[2:1] @@ -319,16 +239,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u } else if ((inst & 0b1111'1110'0000) == 0b0011'1110'0000) { -#if 0 // 0b0011'111r'oonn (where r = reg, o = optype, n = next l value) - case 0b0011'1110'0000: case 0b0011'1110'0001: case 0b0011'1110'0010: case 0b0011'1110'0011: - case 0b0011'1110'0100: case 0b0011'1110'0101: case 0b0011'1110'0110: case 0b0011'1110'0111: - case 0b0011'1110'1000: case 0b0011'1110'1001: case 0b0011'1110'1010: case 0b0011'1110'1011: - case 0b0011'1110'1100: case 0b0011'1110'1101: case 0b0011'1110'1110: case 0b0011'1110'1111: - case 0b0011'1111'0000: case 0b0011'1111'0001: case 0b0011'1111'0010: case 0b0011'1111'0011: - case 0b0011'1111'0100: case 0b0011'1111'0101: case 0b0011'1111'0110: case 0b0011'1111'0111: - case 0b0011'1111'1000: case 0b0011'1111'1001: case 0b0011'1111'1010: case 0b0011'1111'1011: - case 0b0011'1111'1100: case 0b0011'1111'1101: case 0b0011'1111'1110: case 0b0011'1111'1111: // 3e0 AND H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] // 3e4 Add H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] // 3e8 OR H[5:1] and A1[5:1], store to H[5:1], N->L[2:1] @@ -337,7 +248,6 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 3f4 Add H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] // 3f8 OR H[5:1] and A2[5:1], store to H[5:1], N->L[2:1] // 3fc Subtract H[5:1] and A2[5:1], store to H[5:1], Skip if borrow, N->L[2:1] -#endif const int optype = (inst & 0x0c) >> 2; const int reg = (inst & 0x10) >> 4; const int n = inst & 0x3; @@ -345,17 +255,7 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u } else if ((inst & 0b1111'1100'0010) == 0b0100'0100'0000) { -#if 0 // 0b0100'01dg'ks0n (where d = DISP, G = GPE, K = KIE, S = SME, n = A11) - case 0b0100'0100'0000: case 0b0100'0100'0001: case 0b0100'0100'0100: case 0b0100'0100'0101: - case 0b0100'0100'1000: case 0b0100'0100'1001: case 0b0100'0100'1100: case 0b0100'0100'1101: - case 0b0100'0101'0000: case 0b0100'0101'0001: case 0b0100'0101'0100: case 0b0100'0101'0101: - case 0b0100'0101'1000: case 0b0100'0101'1001: case 0b0100'0101'1100: case 0b0100'0101'1101: - case 0b0100'0110'0000: case 0b0100'0110'0001: case 0b0100'0110'0100: case 0b0100'0110'0101: - case 0b0100'0110'1000: case 0b0100'0110'1001: case 0b0100'0110'1100: case 0b0100'0110'1101: - case 0b0100'0111'0000: case 0b0100'0111'0001: case 0b0100'0111'0100: case 0b0100'0111'0101: - case 0b0100'0111'1000: case 0b0100'0111'1001: case 0b0100'0111'1100: case 0b0100'0111'1101: -#endif // 440 Set D to DISP, G to GPE, K to KIE, S to SME, N->A[11] const int d = (inst >> 5) & 0x1; const int g = (inst >> 4) & 0x1; @@ -454,196 +354,151 @@ offs_t upd777_disassembler::disassemble(std::ostream &stream, offs_t pc, const u // 389 Move M[H[5:1],L[2:1]][7:1] to FRS[7:1], 1->L[2:1] util::stream_format(stream, "M->FRS, 1->L"); } - else + else if ((inst == 0b0000'0010'1000) || (inst == 0b0000'0010'1001)) { - switch (inst) - { - case 0b0000'0010'1000: case 0b0000'0010'1001: - { - // 028 Shift STB[4:1], N->STB[1] - // STB is an input strobe / shifter - const int n = inst & 1; - util::stream_format(stream, "0x%d->STB", n); - break; - } - case 0b0000'0011'0000: - case 0b0000'0011'0100: - case 0b0000'0011'1000: - case 0b0000'0011'1100: - case 0b0000'0111'0000: - case 0b0000'0111'0100: - case 0b0000'0111'1000: - case 0b0000'0111'1100: - { - // 30 Skip if (PD1 input) = 1 - // 34 Skip if (PD2 input) = 1 - // 38 Skip if (PD3 input) = 1 - // 3c Skip if (PD4 input) = 1 - // 70 Skip if (PD1 input) = 0 - // 74 Skip if (PD2 input) = 0 - // 78 Skip if (PD3 input) = 0 - // 7c Skip if (PD4 input) = 0 - const int which = (inst & 0x00c) >> 2; - const int inv = inst & 0x40; - util::stream_format(stream, "PD%d %sJ", which + 1, inv ? "/" : ""); - break; - } - - case 0b0011'0000'0000: case 0b0011'0000'0001: case 0b0011'0000'0010: case 0b0011'0000'0011: - { - // 300 N->L[2:1] - const int n = inst & 0x3; - util::stream_format(stream, "0x%d->L", n); - break; - } - - case 0b0011'0000'1010: case 0b0011'0000'1011: - { - // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] - const int n = (inst & 0x1) + 2; - util::stream_format(stream, "A1->MODE, 0x%d->L", n); - break; - } - case 0b0011'01001010: case 0b0011'0100'1011: - { - // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] - const int n = (inst & 0x1) + 2; - util::stream_format(stream, "A2->MODE, 0x%d->L", n); - break; - } - case 0b0011'1000'1010: case 0b00111000'1011: - { - // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] - const int n = (inst & 0x1) + 2; - util::stream_format(stream, "M->MODE, 0x%d->L", n); - break; - } - - case 0b0011'0001'0000: case 0b0011'0001'0001: case 0b0011'0001'0010: case 0b0011'0001'0011: - { - // 310 Move A2[7:1] to A1[7:1], N->L[2:1] - const int n = inst & 0x3; - util::stream_format(stream, "A2->A1, 0x%d->L", n); - break; - } - case 0b0011'0100'0000: case 0b0011'0100'0001: case 0b0011'0100'0010: case 0b0011'0100'0011: - { - // 340 Move A1[7:1] to A2[7:1], N->L[2:1] - const int n = inst & 0x3; - util::stream_format(stream, "A1->A2, 0x%d->L", n); - break; - } - - case 0b0011'0001'1000: case 0b0011'0001'1001: case 0b0011'0001'1010: case 0b0011'0001'1011: - { - // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] - const int n = inst & 0x3; - util::stream_format(stream, "A1->RS, 0x%d->L", n); - break; - } - case 0b0011'0101'1000: case 0b0011'0101'1001: case 0b0011'0101'1010: case 0b0011'0101'1011: - { - // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] - const int n = inst & 0x3; - util::stream_format(stream, "A2->RS, 0x%d->L", n); - break; - } - case 0b0011'1001'1000: case 0b0011'1001'1001: case 0b0011'1001'1010: case 0b0011'1001'1011: - { - // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] - const int n = inst & 0x3; - util::stream_format(stream, "M->RS, 0x%d->L", n); - break; - } - - case 0b0011'0001'1100: case 0b0011'0001'1101: case 0b0011'0001'1110: case 0b0011'0001'1111: - { - // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] - const int n = inst & 0x3; - util::stream_format(stream, "A1-A2->A2, 0x%d->L", n); - break; - } - case 0b0011'0100'1100: case 0b0011'0100'1101: case 0b0011'0100'1110: case 0b0011'0100'1111: - { - // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] - const int n = inst & 0x3; - util::stream_format(stream, "A2-A1->A1, 0x%d->L", n); - break; - } - case 0b0011'1000'0000: case 0b0011'1000'0001: case 0b0011'1000'0010: case 0b0011'1000'0011: - case 0b0011'1001'0000: case 0b0011'1001'0001: case 0b0011'1001'0010: case 0b0011'1001'0011: - { - // 380 Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - util::stream_format(stream, "A%d->M, 0x%d->L", reg + 1, n); - break; - } - - case 0b0011'1000'0100: case 0b0011'1000'0101: case 0b0011'1000'0110: case 0b0011'1000'0111: - case 0b0011'1001'0100: case 0b0011'1001'0101: case 0b0011'1001'0110: case 0b0011'1001'0111: - { - // 384 Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] - // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - util::stream_format(stream, "M<->A%d, 0x%d->L", reg + 1, n); - break; - } - - case 0b0011'1000'1100: case 0b0011'1000'1101: case 0b0011'1000'1110: case 0b0011'1000'1111: - case 0b0011'1001'1100: case 0b0011'1001'1101: case 0b0011'1001'1110: case 0b0011'1001'1111: - { - // 38c Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] - // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - util::stream_format(stream, "M->A%d, 0x%d->L", reg + 1, n); - break; - } - case 0b0011'1100'0000: case 0b0011'1100'0001: case 0b0011'1100'0010: case 0b0011'1100'0011: - case 0b0011'1101'0000: case 0b0011'1101'0001: case 0b0011'1101'0010: case 0b0011'1101'0011: - { - // 3c0 Move A1[5:1] to H[5:1], N->L[2:1] - // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - util::stream_format(stream, "A%d->H, 0x%d->L", reg + 1, n); - break; - } - case 0b0011'1100'1100: case 0b0011'1100'1101: case 0b0011'1100'1110: case 0b0011'1100'1111: - case 0b0011'1101'1100: case 0b0011'1101'1101: case 0b0011'1101'1110: case 0b0011'1101'1111: - { - // 3cc Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] - // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] - const int reg = (inst & 0x10) >> 4; - const int n = inst & 0x3; - util::stream_format(stream, "H->A%d, 0x%d->L", reg + 1, n); - break; - } + // 028 Shift STB[4:1], N->STB[1] + // STB is an input strobe / shifter + const int n = inst & 1; + util::stream_format(stream, "0x%d->STB", n); + } + else if ((inst == 0b0011'0000'1010) || (inst == 0b0011'0000'1011)) + { + // 30a Move A1[7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + util::stream_format(stream, "A1->MODE, 0x%d->L", n); + } + else if ((inst == 0b0011'01001010) || (inst == 0b0011'0100'1011)) + { + // 34a Move A2[7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + util::stream_format(stream, "A2->MODE, 0x%d->L", n); + } + else if ((inst == 0b0011'1000'1010) || (inst == 0b00111000'1011)) + { + // 38a Move M[H[5:1],L[2:1]][7:1] to MODE[7:1], 1N->L[2:1] + const int n = (inst & 0x1) + 2; + util::stream_format(stream, "M->MODE, 0x%d->L", n); + } - case 0b0100'0000'0000: case 0b0100'0000'0001: - { - // 400 N->A[11] - const int n = inst & 0x1; - util::stream_format(stream, "%d->A11", n); - break; - } - case 0b0100'0000'0010: case 0b0100'0000'0011: - { - // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] - const int n = inst & 0x1; - util::stream_format(stream, "JPM, 0->L, %d->A11", n); - break; - } + else if ((inst == 0b0100'0000'0000) || (inst == 0b0100'0000'0001)) + { + // 400 N->A[11] + const int n = inst & 0x1; + util::stream_format(stream, "%d->A11", n); + } + else if ((inst == 0b0100'0000'0010) || (inst == 0b0100'0000'0011)) + { + // 402 Jump to (000,M[H[5:1],L[2:1]][5:1],1N), 0->L[2:1], N->A[11] + const int n = inst & 0x1; + util::stream_format(stream, "JPM, 0->L, %d->A11", n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0000'0000) + { + // 300 N->L[2:1] + const int n = inst & 0x3; + util::stream_format(stream, "0x%d->L", n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0001'0000) + { + // 310 Move A2[7:1] to A1[7:1], N->L[2:1] + const int n = inst & 0x3; + util::stream_format(stream, "A2->A1, 0x%d->L", n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0100'0000) + { + // 340 Move A1[7:1] to A2[7:1], N->L[2:1] + const int n = inst & 0x3; + util::stream_format(stream, "A1->A2, 0x%d->L", n); + } - default: - { - util::stream_format(stream, "%04x ", inst); - break; - } - } + else if ((inst & 0b1111'1111'1100) == 0b0011'0001'1000) + { + // 318 Right shift A1[7:1], 0->A1[7], N->L[2:1] + const int n = inst & 0x3; + util::stream_format(stream, "A1->RS, 0x%d->L", n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0101'1000) + { + // 358 Right shift A2[7:1], 0->A2[7], N->L[2:1] + const int n = inst & 0x3; + util::stream_format(stream, "A2->RS, 0x%d->L", n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'1001'1000) + { + // 398 Right shift M[H[5:1],L[2:1]][7:1], 0->M[H[5:1],L[2:1]][7], N->L[2:1] + const int n = inst & 0x3; + util::stream_format(stream, "M->RS, 0x%d->L", n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0001'1100) + { + // 31c Subtract A1[7:1] and A2[7:1], store to A2[7:1], Skip if borrow, N->L[2:1] + const int n = inst & 0x3; + util::stream_format(stream, "A1-A2->A2, 0x%d->L", n); + } + else if ((inst & 0b1111'1111'1100) == 0b0011'0100'1100) + { + // 34c Subtract A2[7:1] and A1[7:1], store to A1[7:1], Skip if borrow, N->L[2:1] + const int n = inst & 0x3; + util::stream_format(stream, "A2-A1->A1, 0x%d->L", n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1000'0000) + { + // 380 Move A1[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + // 390 Move A2[7:1] to M[H[5:1],L[2:1]][7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "A%d->M, 0x%d->L", reg + 1, n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1000'0100) + { + // 384 Exchange M[H[5:1],L[2:1]][7:1] and A1[7:1], N->L[2:1] + // 394 Exchange M[H[5:1],L[2:1]][7:1] and A2[7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "M<->A%d, 0x%d->L", reg + 1, n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1000'1100) + { + // 38c Move M[H[5:1],L[2:1]][7:1] to A1[7:1], N->L[2:1] + // 39c Move M[H[5:1],L[2:1]][7:1] to A2[7:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "M->A%d, 0x%d->L", reg + 1, n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1100'0000) + { + // 3c0 Move A1[5:1] to H[5:1], N->L[2:1] + // 3d0 Move A2[5:1] to H[5:1], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "A%d->H, 0x%d->L", reg + 1, n); + } + else if ((inst & 0b1111'1110'1100) == 0b0011'1100'1100) + { + // 3cc Move H[5:1] to A1[5:1], 0->A1[7:6], N->L[2:1] + // 3dc Move H[5:1] to A2[5:1], 0->A2[7:6], N->L[2:1] + const int reg = (inst & 0x10) >> 4; + const int n = inst & 0x3; + util::stream_format(stream, "H->A%d, 0x%d->L", reg + 1, n); + } + else if ((inst & 0b1111'1011'0011) == 0b0000'0011'0000) + { + // 30 Skip if (PD1 input) = 1 + // 34 Skip if (PD2 input) = 1 + // 38 Skip if (PD3 input) = 1 + // 3c Skip if (PD4 input) = 1 + // 70 Skip if (PD1 input) = 0 + // 74 Skip if (PD2 input) = 0 + // 78 Skip if (PD3 input) = 0 + // 7c Skip if (PD4 input) = 0 + const int which = (inst & 0x00c) >> 2; + const int inv = inst & 0x40; + util::stream_format(stream, "PD%d %sJ", which + 1, inv ? "/" : ""); + } + else + { + util::stream_format(stream, "%04x ", inst); } + return 1; }