Files
VCCPlusOSS/platforms/macos/Tests/DebuggerCoreTests.mm
T

250 lines
17 KiB
Plaintext

// SPDX-License-Identifier: GPL-3.0-or-later
#import <XCTest/XCTest.h>
#include "../../../src/core/MachineSession.h"
#include "../../../src/core/tcc1014mmu.h"
#include "../../../src/core/tcc1014registers.h"
#include "../../../src/core/mc6821.h"
#include "../../../src/core/Event.h"
#include "../../../src/core/mc6809.h"
#include "../../../src/core/hd6309.h"
#include <algorithm>
#include <stdexcept>
using namespace VCC::Mac;
namespace {
template<class F> bool rejects(F action) { try { action(); } catch (const std::exception&) { return true; } return false; }
struct ReadProbe : VCC::Devices::CartridgeDevice {
unsigned reads = 0;
void reset() override {}
void horizontalSync(VCC::Devices::DeviceHost&) override {}
std::uint8_t readMemory(std::uint16_t) const override { return 0xff; }
std::uint8_t readPort(std::uint8_t, VCC::Devices::DeviceHost&) override { ++reads; return 0x5a; }
void writePort(std::uint8_t, std::uint8_t, VCC::Devices::DeviceHost&) override {}
};
}
@interface DebuggerCoreTests : XCTestCase
@end
@implementation DebuggerCoreTests
- (void)testCSourceStepIntoOverOutAndPermanentBreakpointsOnBothCPUs {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine; machine.loadDiagnostic(cpu);
machine.debuggerWriteMemory(0x4000, {0x10,0xce,0x70,0x00, 0xce,0x6f,0xfe, 0xbd,0x40,0x20, 0x7c,0x41,0x00, 0x20,0xf8});
machine.debuggerWriteMemory(0x4020, {0x34,0x40, 0x33,0xe4, 0xbd,0x40,0x30, 0x35,0xc0});
machine.debuggerWriteMemory(0x4030, {0x7c,0x41,0x01, 0x39});
const std::vector<DebugSourceInstruction> source{
{0x4007,1,{0xbd,0x40,0x20}}, {0x400a,1,{0x7c,0x41,0x00}}, {0x400d,2,{0x20,0xf8}},
{0x4020,10,{0x34,0x40}}, {0x4022,10,{0x33,0xe4}}, {0x4024,11,{0xbd,0x40,0x30}},
{0x4027,12,{0x35,0xc0}}, {0x4030,20,{0x7c,0x41,0x01}}, {0x4033,21,{0x39}}};
auto begin = [&](SourceStepMode mode) {
const auto at = machine.snapshot();
machine.debuggerStepSource(mode, source, at.generation, at.debuggerProgramRevision,
at.debuggerMappingFingerprint, at.cpu.PC);
XCTAssertTrue(machine.snapshot().debuggerSourceStepping);
for (unsigned i = 0; i < 10 && machine.snapshot().state == RunState::Running; ++i) machine.advance();
XCTAssertEqual(machine.snapshot().state, RunState::Paused);
XCTAssertFalse(machine.snapshot().debuggerSourceStepping);
XCTAssertEqual(machine.snapshot().generation, at.generation);
};
auto initialize = [&] { machine.debuggerSetPC(0x4000); machine.debuggerStep(); machine.debuggerStep(); };
initialize(); machine.debuggerSetBreakpoints({0x4007});
begin(SourceStepMode::Into); XCTAssertEqual(machine.snapshot().cpu.PC, 0x4020);
begin(SourceStepMode::Out); XCTAssertEqual(machine.snapshot().cpu.PC, 0x400a);
XCTAssertEqual(machine.snapshot().cpu.S, 0x7000);
initialize(); begin(SourceStepMode::Over); XCTAssertEqual(machine.snapshot().cpu.PC, 0x400d);
XCTAssertEqual(machine.debuggerSnapshot().breakpoints, (std::vector<std::uint16_t>{0x4007}));
initialize(); machine.debuggerSetBreakpoints({0x4007,0x4030});
begin(SourceStepMode::Over); XCTAssertEqual(machine.snapshot().cpu.PC, 0x4030);
XCTAssertEqual(machine.debuggerSnapshot().stopReason, std::string("Breakpoint"));
XCTAssertEqual(machine.debuggerSnapshot().breakpoints, (std::vector<std::uint16_t>{0x4007,0x4030}));
initialize(); machine.debuggerSetBreakpoints({0x4007,0x400a});
begin(SourceStepMode::Into); XCTAssertEqual(machine.snapshot().cpu.PC,0x4020);
begin(SourceStepMode::Out); XCTAssertEqual(machine.snapshot().cpu.PC,0x400a);
XCTAssertEqual(machine.debuggerSnapshot().stopReason,std::string("Returned from C function"));
const auto value = machine.debuggerSnapshot(0x4100,1).memory[0];
machine.resume(); machine.advance();
XCTAssertEqual(machine.snapshot().cpu.PC,0x4007); // no immediate re-break at the caller return
XCTAssertEqual(machine.debuggerSnapshot(0x4100,1).memory[0],std::uint8_t(value+1));
XCTAssertEqual(machine.debuggerSnapshot().breakpoints,(std::vector<std::uint16_t>{0x4007,0x400a}));
}
}
- (void)testCSourceStepRejectsStaleStateAndCodeAndHonorsCancellationAndBounds {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine; machine.loadDiagnostic(cpu);
machine.debuggerWriteMemory(0x4000, {0x12,0x20,0xfe}); machine.debuggerSetPC(0x4000);
const std::vector<DebugSourceInstruction> source{{0x4000,1,{0x12}}};
auto at = machine.snapshot();
auto start = [&](unsigned limit = 100) { machine.debuggerStepSource(SourceStepMode::Over, source,
at.generation, at.debuggerProgramRevision, at.debuggerMappingFingerprint, at.cpu.PC, limit, 3); };
XCTAssertTrue(rejects([&] { machine.debuggerStepSource(SourceStepMode::Into, source, at.generation + 1,
at.debuggerProgramRevision, at.debuggerMappingFingerprint, at.cpu.PC); }));
XCTAssertTrue(rejects([&] { machine.debuggerStepSource(SourceStepMode::Into, source, at.generation,
at.debuggerProgramRevision + 1, at.debuggerMappingFingerprint, at.cpu.PC); }));
XCTAssertTrue(rejects([&] { machine.debuggerStepSource(SourceStepMode::Into, source, at.generation,
at.debuggerProgramRevision, at.debuggerMappingFingerprint + 1, at.cpu.PC); }));
XCTAssertTrue(rejects([&] { machine.debuggerStepSource(SourceStepMode::Into, source, at.generation,
at.debuggerProgramRevision, at.debuggerMappingFingerprint, at.cpu.PC + 1); }));
start(); machine.pause(); XCTAssertFalse(machine.snapshot().debuggerSourceStepping);
XCTAssertEqual(machine.snapshot().cpu.PC, at.cpu.PC);
XCTAssertEqual(machine.debuggerSnapshot().stopReason, std::string("C step canceled"));
start(16); machine.advance(); XCTAssertEqual(machine.snapshot().state, RunState::Paused);
XCTAssertEqual(machine.snapshot().cpu.PC, 0x4001);
XCTAssertNotEqual(machine.debuggerSnapshot().stopReason.find("limit"), std::string::npos);
machine.debuggerSetPC(0x4000); MemWrite8(0x13,0x4000); at = machine.snapshot();
XCTAssertTrue(rejects([&] { start(); })); XCTAssertEqual(machine.snapshot().cpu.PC, 0x4000);
machine.debuggerWriteMemory(0x4000, {0x20,0xfe}); at = machine.snapshot();
machine.debuggerStepSource(SourceStepMode::Into, {{0x4000,1,{0x20,0xfe}}}, at.generation,
at.debuggerProgramRevision, at.debuggerMappingFingerprint, at.cpu.PC);
machine.advance(); XCTAssertEqual(machine.snapshot().cpu.PC, 0x4000);
XCTAssertEqual(machine.debuggerSnapshot().stopReason, std::string("C source location reached"));
}
}
- (void)testCSourceStepPreservesInterruptExecutionWithoutEnteringItsSource {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
std::vector<std::uint8_t> rom(32768,0x12);
rom[0x7ff8] = 0x40; rom[0x7ff9] = 0x80; rom[0x7ffe] = 0x80; rom[0x7fff] = 0;
MachineSession machine; machine.load(rom,cpu);
machine.debuggerWriteMemory(0x4000,{0x10,0xce,0x70,0x00, 0x1c,0xef, 0x12,0x12});
// Mask the saved IRQ flag before RTI, so the synthetic asserted source
// is serviced once; no host shortcut skips the actual IRQ/RTI stack.
machine.debuggerWriteMemory(0x4080,{0xa6,0xe4, 0x8a,0x10, 0xa7,0xe4, 0x7c,0x41,0x00, 0x3b});
machine.debuggerWriteMemory(0x4100,{0});
machine.debuggerSetPC(0x4000); machine.debuggerStep(); machine.debuggerStep();
const auto at = machine.snapshot();
if (cpu == Processor::MC6809) MC6809AssertInterupt(IS_GIME,INT_IRQ); else HD6309AssertInterupt(IS_GIME,INT_IRQ);
machine.debuggerStepSource(SourceStepMode::Into, {{0x4006,1,{0x12}},{0x4007,2,{0x12}},
{0x4080,90,{0xa6,0xe4}},{0x4082,91,{0x8a,0x10}},{0x4084,92,{0xa7,0xe4}},
{0x4086,93,{0x7c,0x41,0x00}},{0x4089,94,{0x3b}}}, at.generation,
at.debuggerProgramRevision, at.debuggerMappingFingerprint, at.cpu.PC);
for (unsigned i=0;i<3 && machine.snapshot().state==RunState::Running;++i) machine.advance();
XCTAssertEqual(machine.snapshot().state,RunState::Paused);
XCTAssertEqual(machine.snapshot().cpu.PC,0x4007); XCTAssertEqual(machine.snapshot().cpu.S,0x7000);
XCTAssertEqual(machine.debuggerSnapshot(0x4100,1).memory[0],1);
if (cpu == Processor::MC6809) MC6809DeAssertInterupt(IS_GIME,INT_IRQ); else HD6309DeAssertInterupt(IS_GIME,INT_IRQ);
}
}
- (void)testCSourceStepStopsForSelfModificationMappingChangesAndWaitLoops {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine; machine.loadDiagnostic(cpu);
machine.debuggerWriteMemory(0x4000,{0x86,0x39, 0xb7,0x40,0x05, 0x12}); machine.debuggerSetPC(0x4000);
auto at = machine.snapshot();
machine.debuggerStepSource(SourceStepMode::Into, {{0x4000,1,{0x86,0x39}},{0x4002,1,{0xb7,0x40,0x05}},{0x4005,2,{0x12}}},
at.generation,at.debuggerProgramRevision,at.debuggerMappingFingerprint,at.cpu.PC);
machine.advance(); XCTAssertEqual(machine.snapshot().cpu.PC,0x4005);
XCTAssertNotEqual(machine.debuggerSnapshot().stopReason.find("bytes changed"),std::string::npos);
machine.debuggerWriteMemory(0x4000,{0xb7,0xff,0xdf, 0x12}); machine.debuggerSetPC(0x4000); at=machine.snapshot();
machine.debuggerStepSource(SourceStepMode::Into, {{0x4000,1,{0xb7,0xff,0xdf}},{0x4003,2,{0x12}}},
at.generation,at.debuggerProgramRevision,at.debuggerMappingFingerprint,at.cpu.PC);
machine.advance(); XCTAssertEqual(machine.snapshot().cpu.PC,0x4003);
XCTAssertNotEqual(machine.debuggerSnapshot().stopReason.find("mapping changed"),std::string::npos);
machine.debuggerWriteMemory(0x4000,{0x13}); machine.debuggerSetPC(0x4000); at=machine.snapshot();
machine.debuggerStepSource(SourceStepMode::Into, {{0x4000,1,{0x13}}},
at.generation,at.debuggerProgramRevision,at.debuggerMappingFingerprint,at.cpu.PC,100,1);
for (unsigned i=0;i<3 && machine.snapshot().state==RunState::Running;++i) machine.advance();
XCTAssertEqual(machine.snapshot().state,RunState::Paused);
XCTAssertNotEqual(machine.debuggerSnapshot().stopReason.find("limit"),std::string::npos);
}
}
- (void)testInstructionStepUsesBothProcessorsAndPreservesSession {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine; machine.loadDiagnostic(cpu);
const auto before = machine.debuggerSnapshot(0x4000, 1);
const auto clocks = VCC::gEvents.GetClocks();
machine.debuggerStep();
const auto after = machine.debuggerSnapshot(0x4000, 1);
XCTAssertEqual(after.cpu.PC, 0x8003); XCTAssertEqual(after.memory[0], std::uint8_t(before.memory[0] + 1));
XCTAssertEqual(after.state, RunState::Paused); XCTAssertEqual(after.generation, before.generation);
XCTAssertGreaterThan(after.cycles, before.cycles); XCTAssertGreaterThan(VCC::gEvents.GetClocks(), clocks);
XCTAssertEqual(after.stopReason, std::string("Instruction stepped"));
machine.debuggerStep(); XCTAssertEqual(machine.debuggerSnapshot().cpu.PC, 0x8000);
XCTAssertTrue(machine.takeAudio().empty());
const auto still = machine.snapshot(); machine.advance();
XCTAssertEqual(machine.snapshot().cycles, still.cycles);
machine.resume(); XCTAssertTrue(rejects([&] { machine.debuggerStep(); }));
machine.advance(); XCTAssertGreaterThan(machine.snapshot().frames, 0u);
}
}
- (void)testBreakpointsContinueExactlyOnceAndSurviveResets {
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine; machine.loadDiagnostic(cpu);
machine.debuggerSetBreakpoints({0x8000,0x8000});
machine.resume(); machine.advance();
auto stopped = machine.debuggerSnapshot(0x4000, 1);
XCTAssertEqual(stopped.state, RunState::Paused); XCTAssertEqual(stopped.cpu.PC, 0x8000);
XCTAssertEqual(stopped.cycles, 0u); XCTAssertEqual(stopped.breakpoints.size(), 1u);
XCTAssertEqual(stopped.stopReason, std::string("Breakpoint"));
machine.resume(); machine.advance();
const auto again = machine.debuggerSnapshot(0x4000, 1);
XCTAssertEqual(again.state, RunState::Paused); XCTAssertEqual(again.cpu.PC, 0x8000);
XCTAssertEqual(again.memory[0], std::uint8_t(stopped.memory[0] + 1));
XCTAssertGreaterThan(again.cycles, stopped.cycles);
machine.debuggerStep(); XCTAssertEqual(machine.debuggerSnapshot().cpu.PC, 0x8003);
machine.resume(); machine.advance(); XCTAssertEqual(machine.debuggerSnapshot().cpu.PC, 0x8000);
machine.softReset(); XCTAssertEqual(machine.debuggerSnapshot().breakpoints.size(), 1u);
machine.reset(); XCTAssertEqual(machine.debuggerSnapshot().breakpoints.size(), 1u);
machine.resume(); machine.advance(); XCTAssertEqual(machine.snapshot().state, RunState::Paused);
machine.debuggerSetBreakpoints({}); machine.resume(); machine.advance();
XCTAssertEqual(machine.snapshot().state, RunState::Running); XCTAssertGreaterThan(machine.snapshot().frames, 0u);
}
}
- (void)testSafeMemorySnapshotsNeverReadDevicePortsOrAcknowledgeInterrupts {
MachineSession machine; auto probe = std::make_shared<ReadProbe>();
machine.cartridges().configure({probe,nullptr,nullptr,nullptr,nullptr}, false, 4);
machine.loadDiagnostic();
MemWrite8(5, 0xff01); irq_hs(FALLING);
const auto controlBefore = MemRead8(0xff01);
XCTAssertNotEqual(controlBefore & 128, 0);
const auto full = machine.debuggerSnapshot(0,65536);
XCTAssertEqual(full.memory.size(), 65536u); XCTAssertEqual(full.memoryAvailable.size(), 65536u);
XCTAssertEqual(probe->reads, 0u); XCTAssertEqual(MemRead8(0xff01), controlBefore);
XCTAssertEqual(full.memoryAvailable[0xff00], 0); XCTAssertEqual(full.memoryAvailable[0xff40], 0);
XCTAssertEqual(full.memoryAvailable[0xffe0], 0); XCTAssertEqual(full.memoryAvailable[0xff92], 1);
XCTAssertEqual(full.memoryAvailable[0xfffe], 1); XCTAssertEqual(full.memory[0xfffe], 0x80);
const auto wrapped = machine.debuggerSnapshot(0xfffe, 4);
XCTAssertEqual(wrapped.memory[0], full.memory[0xfffe]); XCTAssertEqual(wrapped.memory[2], full.memory[0]);
XCTAssertTrue(rejects([&] { machine.debuggerSnapshot(0,65537); }));
}
- (void)testMemoryEditsPreflightWholeSpanAndRequirePausedRAM {
MachineSession machine;
XCTAssertTrue(machine.debuggerSnapshot().memory.empty());
XCTAssertTrue(rejects([&] { machine.debuggerStep(); }));
XCTAssertTrue(rejects([&] { machine.debuggerSetPC(0x4000); }));
machine.loadDiagnostic();
const auto generation = machine.snapshot().generation;
machine.debuggerWriteMemory(0x4000,{0x86,0x5a,0x12});
const auto saved = machine.debuggerSnapshot(0x4000,3);
machine.debuggerSetPC(0x4000); machine.debuggerStep();
XCTAssertEqual(machine.debuggerSnapshot().cpu.A, 0x5a); XCTAssertEqual(machine.debuggerSnapshot().cpu.PC,0x4002);
XCTAssertEqual(machine.snapshot().generation,generation);
const auto lastRAM = machine.debuggerSnapshot(0x7fff,1).memory[0];
XCTAssertTrue(rejects([&] { machine.debuggerWriteMemory(0x7fff,{0xa5,0x5a}); }));
XCTAssertEqual(machine.debuggerSnapshot(0x7fff,1).memory[0],lastRAM);
XCTAssertTrue(rejects([&] { machine.debuggerWriteMemory(0xffff,{1,2}); }));
XCTAssertTrue(rejects([&] { machine.debuggerWriteMemory(0xff00,{1}); }));
XCTAssertTrue(rejects([&] { machine.debuggerWriteMemory(0x4000,{}); }));
XCTAssertTrue(rejects([&] { machine.debuggerWriteMemory(0x4000,std::vector<std::uint8_t>(257)); }));
machine.debuggerWriteMemory(0x4000,{0x12}); XCTAssertEqual(saved.memory[0],0x86);
machine.resume();
XCTAssertTrue(rejects([&] { machine.debuggerWriteMemory(0x4000,{0x13}); }));
XCTAssertTrue(rejects([&] { machine.debuggerSetPC(0x4000); }));
}
- (void)testContinueFromBreakpointHonorsPendingInterruptAndHandlerBreakpoint {
for (auto cpu : {Processor::MC6809,Processor::HD6309}) {
MachineSession machine; std::vector<std::uint8_t> rom(0x8000,0x12);
rom[0x7ffe]=0x40; rom[0x7fff]=0; rom[0x7ff8]=0x50; rom[0x7ff9]=0;
machine.load(rom,cpu);
machine.debuggerWriteMemory(0x4000,{0x10,0xce,0x70,0x00,0x1c,0xef,0x12,0x20,0xfd});
machine.debuggerWriteMemory(0x5000,{0x3b});
machine.debuggerSetBreakpoints({0x4006,0x5000});
machine.resume(); machine.advance(); XCTAssertEqual(machine.debuggerSnapshot().cpu.PC,0x4006);
MemWrite8(1,0xff95); MemWrite8(0x62,0xff90); MemWrite8(0x20,0xff92); GimeAssertTimerInterupt();
machine.resume();
if (machine.snapshot().state == RunState::Running) machine.advance();
const auto interrupted = machine.debuggerSnapshot();
XCTAssertEqual(interrupted.state,RunState::Paused); XCTAssertEqual(interrupted.cpu.PC,0x5000);
XCTAssertEqual(interrupted.cpu.S,0x6ff4);
(void)MemRead8(0xff92);
machine.resume(); machine.advance();
XCTAssertEqual(machine.debuggerSnapshot().cpu.PC,0x4006); XCTAssertEqual(machine.debuggerSnapshot().cpu.S,0x7000);
}
}
@end