// SPDX-License-Identifier: GPL-3.0-or-later #import #include "../../../src/core/DebugDisassembler.h" #include using namespace VCC::Mac; namespace { DebugInstruction decode(std::initializer_list bytes, bool use6309 = false, std::uint16_t address = 0x8000, bool native = false) { std::vector memory(65536, 0x12); auto cursor = address; for (auto byte : bytes) memory[cursor++] = byte; VCC::CPUState state; state.IsNative6309 = native; return Disassemble(memory, state, use6309, address, 1).front(); } } @interface DisassemblerTests : XCTestCase @end @implementation DisassemblerTests - (void)testBasicInstructionsAndSignedBranchTargets { const auto load = decode({0x86, 0x7f}); XCTAssertEqual(load.mnemonic, "LDA"); XCTAssertEqual(load.operand, "#$7F"); XCTAssertEqual(load.bytes.size(), 2u); XCTAssertTrue(load.valid); XCTAssertEqual(decode({0x8e, 0x12, 0x34}).operand, "#$1234"); XCTAssertEqual(decode({0x7c, 0x40, 0}).operand, "$4000"); XCTAssertEqual(decode({0x96, 0x42}).operand, "<$42"); XCTAssertEqual(decode({0x20, 0xfb}).operand, "$7FFD"); XCTAssertEqual(decode({0x20, 0x7f}).operand, "$8081"); XCTAssertEqual(decode({0x10, 0x26, 0xff, 0xfc}).operand, "$8000"); XCTAssertEqual(decode({0x16, 0x7f, 0xff}).operand, "$0002"); } - (void)testIndexedSignedOffsetsIndirectAndPCRelative { XCTAssertEqual(decode({0xa6, 0x1f}).operand, "-1,X"); XCTAssertEqual(decode({0xa6, 0x88, 0x80}).operand, "-128,X"); XCTAssertEqual(decode({0xa6, 0xa9, 0xff, 0xfe}).operand, "-2,Y"); XCTAssertEqual(decode({0xa6, 0x9f, 0xff, 0xfe}).operand, "[$FFFE]"); XCTAssertEqual(decode({0xa6, 0x9c, 0xfc}).operand, "[-4,PCR]"); XCTAssertEqual(decode({0xa6, 0xf3}).operand, "[,--S]"); XCTAssertFalse(decode({0xa6, 0x87}).valid); XCTAssertEqual(decode({0xa6, 0x87}, true).operand, "E,X"); XCTAssertEqual(decode({0xa6, 0x8f}, true).operand, ",W"); XCTAssertEqual(decode({0xa6, 0xbe}, true).operand, "[W,Y]"); XCTAssertFalse(decode({0xa6, 0xbe}, false).valid); } - (void)testRegisterListsAndTransfers { XCTAssertEqual(decode({0x34, 0xff}).operand, "CC,A,B,DP,X,Y,U,PC"); XCTAssertEqual(decode({0x36, 0x40}).operand, "S"); XCTAssertEqual(decode({0x1f, 0x01}).operand, "D,X"); XCTAssertFalse(decode({0x1f, 0x61}).valid); XCTAssertEqual(decode({0x1f, 0x61}, true).operand, "W,X"); XCTAssertEqual(decode({0x10, 0x30, 0x12}, true).operand, "X,Y"); XCTAssertEqual(decode({0x11, 0x38, 0x12}, true).operand, "X+,Y+"); XCTAssertEqual(decode({0x11, 0x39, 0x34}, true).operand, "U-,S-"); XCTAssertEqual(decode({0x11, 0x3a, 0x12}, true).operand, "X+,Y"); XCTAssertEqual(decode({0x11, 0x3b, 0x12}, true).operand, "X,Y+"); XCTAssertFalse(decode({0x11, 0x38, 0x56}, true).valid); } - (void)test6309ImmediateMemoryBitOperationsAndNativeIdentity { const auto emulation = decode({0xcd, 0x12, 0x34, 0x56, 0x78}, true); const auto native = decode({0xcd, 0x12, 0x34, 0x56, 0x78}, true, 0x8000, true); XCTAssertEqual(emulation.mnemonic, "LDQ"); XCTAssertEqual(emulation.operand, "#$12345678"); XCTAssertEqual(native.operand, emulation.operand); XCTAssertEqual(native.bytes, emulation.bytes); XCTAssertFalse(decode({0xcd, 0x12, 0x34, 0x56, 0x78}).valid); XCTAssertFalse(decode({0x10, 0xec, 0x84}).valid); XCTAssertEqual(decode({0x01, 0x80, 0x42}, true).operand, "#$80,<$42"); const auto indexed = decode({0x61, 0x80, 0x88, 0xff}, true); XCTAssertEqual(indexed.operand, "#$80,-1,X"); XCTAssertEqual(indexed.bytes.size(), 4u); XCTAssertEqual(decode({0x71, 0x80, 0x12, 0x34}, true).operand, "#$80,$1234"); XCTAssertEqual(decode({0x11, 0x30, 0x53, 0x42}, true).operand, "A,2,3,<$42"); XCTAssertFalse(decode({0x11, 0x30, 0xc0, 0x42}, true).valid); } - (void)testInstructionFetchWrapAndInvalidProgress { XCTAssertFalse(decode({0x15}).valid); XCTAssertFalse(decode({0x11, 0x3e}).valid); const auto wrap = decode({0x8e, 0x12, 0x34}, false, 0xffff); XCTAssertEqual(wrap.address, 0xffff); XCTAssertEqual(wrap.operand, "#$1234"); XCTAssertEqual(decode({0x20, 0xfe}, false, 0xffff).operand, "$FFFF"); std::vector memory(65536, 0x12); memory[0xffff] = 0x10; memory[0] = 0; const auto rows = Disassemble(memory, {}, false, 0xffff, 2); XCTAssertFalse(rows[0].valid); XCTAssertEqual(rows[0].mnemonic, "FCB"); XCTAssertEqual(rows[0].operand, "$10,$00"); XCTAssertEqual(rows[1].address, 1); XCTAssertEqual(rows[1].mnemonic, "NOP"); const auto original = memory; for (bool use6309 : {false, true}) for (unsigned opcode = 0; opcode < 256; ++opcode) { memory[0x8000] = opcode; const auto instruction = Disassemble(memory, {}, use6309, 0x8000, 1).front(); XCTAssertGreaterThan(instruction.bytes.size(), 0u); XCTAssertLessThanOrEqual(instruction.bytes.size(), 6u); } memory[0x8000] = original[0x8000]; XCTAssertEqual(memory, original); } - (void)testSnapshotAndInstructionCountValidation { bool shortRejected = false, countRejected = false; try { Disassemble(std::vector(65535), {}, false, 0, 1); } catch (const std::invalid_argument&) { shortRejected = true; } try { Disassemble(std::vector(65536), {}, false, 0, 1025); } catch (const std::invalid_argument&) { countRejected = true; } XCTAssertTrue(shortRejected); XCTAssertTrue(countRejected); XCTAssertTrue(Disassemble(std::vector(65536), {}, false, 0, 0).empty()); } @end