// SPDX-License-Identifier: GPL-3.0-or-later #import #include "../../../src/core/MachineSession.h" #include "../../../src/core/CpuHost.h" #include "../../../src/core/mc6809.h" #include "../../../src/core/hd6309.h" #include "../../../src/core/tcc1014mmu.h" #include using namespace VCC::Mac; namespace { template bool rejectsTrace(F f) { try { f(); } catch (const std::exception&) { return true; } return false; } } @interface DebuggerTraceTests : XCTestCase @end @implementation DebuggerTraceTests - (void)testInstructionCaptureBoundDoesNotPauseOrMutateGuest { for (auto cpu : {Processor::MC6809, Processor::HD6309}) { MachineSession machine; machine.loadDiagnostic(cpu); auto before = machine.snapshot(); machine.debuggerStartTrace(3, {}, {}, false, false); XCTAssertEqual(machine.snapshot().state, RunState::Paused); machine.resume(); machine.advance(); auto trace = machine.debuggerTrace(); XCTAssertEqual(trace.total, 3u); XCTAssertFalse(trace.armed); XCTAssertFalse(trace.capturing); XCTAssertEqual(trace.status, std::string("Sample limit reached")); XCTAssertEqual(machine.snapshot().state, RunState::Running); XCTAssertEqual(machine.snapshot().generation, before.generation); XCTAssertEqual(trace.records[0].before.PC, 0x8000); XCTAssertEqual(trace.records[0].after.PC, 0x8003); XCTAssertEqual(trace.records[0].bytes[0], 0x7c); XCTAssertGreaterThan(trace.records[0].cycles, 0); XCTAssertLessThan(trace.records[0].clock, trace.records[1].clock); machine.advance(); XCTAssertEqual(machine.debuggerTrace().total, 3u); auto csv = machine.debuggerExportTrace(0, 2); XCTAssertTrue(csv.find("INC") != std::string::npos); XCTAssertTrue(csv.find("BRA") != std::string::npos); XCTAssertTrue(rejectsTrace([&] { machine.debuggerExportTrace(2, 2); })); } } - (void)testMultipleTriggersAndStepTracing { for (auto cpu : {Processor::MC6809, Processor::HD6309}) { MachineSession machine; machine.loadDiagnostic(cpu); machine.debuggerStartTrace(100, {0x9999, 0x8003}, {0x8000, 0x8888}, false, false); machine.debuggerStep(); XCTAssertEqual(machine.debuggerTrace().total, 0u); machine.debuggerStep(); auto trace = machine.debuggerTrace(); XCTAssertEqual(trace.total, 1u); XCTAssertEqual(trace.records[0].before.PC, 0x8003); XCTAssertEqual(trace.records[0].after.PC, 0x8000); machine.debuggerStep(); trace = machine.debuggerTrace(); XCTAssertFalse(trace.armed); XCTAssertEqual(trace.total, 1u); XCTAssertEqual(trace.status, std::string("Stop address reached (before instruction)")); XCTAssertEqual(machine.snapshot().cpu.PC, 0x8003, "Trace stop never prevents guest instruction execution"); machine.debuggerStartTrace(10, {0x9000}, {}, false, false); machine.resume(); machine.advance(); XCTAssertTrue(machine.debuggerTrace().armed); XCTAssertFalse(machine.debuggerTrace().capturing); machine.debuggerStopTrace(); XCTAssertFalse(machine.debuggerTrace().armed); } } - (void)testRealScreenAndSchedulerEventsAndImmutablePages { MachineSession machine; machine.loadDiagnostic(); machine.debuggerStartTrace(100000, {}, {}, true, true); machine.resume(); machine.advance(); machine.advance(); machine.debuggerStopTrace(); auto first = machine.debuggerTrace(0, 256); auto total = first.total; bool screen = false, scheduler = false; std::uint64_t lastClock = 0; for (std::size_t offset = 0; offset < total; offset += 256) { for (const auto& row : machine.debuggerTrace(offset).records) { screen |= row.event == VCC::TraceEvent::ScreenHSYNCLow; scheduler |= row.event == VCC::TraceEvent::EmulatorCycle; XCTAssertGreaterThanOrEqual(row.clock, lastClock); lastClock = row.clock; } } XCTAssertTrue(screen); XCTAssertTrue(scheduler); auto exported = machine.debuggerTraceForExport(1, 2); machine.debuggerClearTrace(); XCTAssertEqual(machine.debuggerTrace().total, 0u); const auto historicalCSV = FormatDebugTraceCSV(exported); XCTAssertTrue(historicalCSV.find("\n2,") != std::string::npos); XCTAssertTrue(historicalCSV.find("\n3,") != std::string::npos); XCTAssertEqual(first.total, total); XCTAssertFalse(first.records.empty()); XCTAssertTrue(rejectsTrace([&] { machine.debuggerTrace(0, 257); })); XCTAssertTrue(rejectsTrace([&] { machine.debuggerStartTrace(100001, {}, {}, false, false); })); } - (void)testIRQStagesAndResetRetainStoppedCapture { MachineSession machine; machine.loadDiagnostic(); machine.debuggerStartTrace(100, {}, {}, false, false); machine.debuggerStep(); // Same synchronous hooks used by the retained CPU interrupt engines; no // interrupt inference from CC masks or polling of device registers. auto state = machine.snapshot().cpu; VCC::CpuDebugger().TraceCaptureInterruptRequest(INT_IRQ, 0, state); VCC::CpuDebugger().TraceCaptureInterruptServicing(INT_IRQ, 0, state); VCC::CpuDebugger().TraceCaptureInterruptExecuting(INT_IRQ, 0, state); auto trace = machine.debuggerTrace(); XCTAssertEqual(trace.total, 4u); XCTAssertEqual(trace.records[1].event, VCC::TraceEvent::IRQRequested); XCTAssertEqual(trace.records[2].event, VCC::TraceEvent::IRQServicing); XCTAssertEqual(trace.records[3].event, VCC::TraceEvent::IRQExecuting); machine.softReset(); XCTAssertFalse(machine.debuggerTrace().armed); XCTAssertEqual(machine.debuggerTrace().total, 4u); machine.reset(); XCTAssertEqual(machine.debuggerTrace().total, 4u); } - (void)testRetainedCPUInterruptEnginesEmitActualIRQStages { for (auto cpu : {Processor::MC6809, Processor::HD6309}) { std::vector rom(0x8000, 0x12); const std::uint8_t program[] = {0x10,0xce,0x70,0x00,0x1c,0xef,0x20,0xfe,0x3b}; std::copy(std::begin(program), std::end(program), rom.begin()); rom[0x7ffe]=0x80; rom[0x7fff]=0; rom[0x7ff8]=0x80; rom[0x7ff9]=8; MachineSession machine; machine.load(rom, cpu); machine.debuggerStep(); machine.debuggerStep(); machine.debuggerStartTrace(100, {}, {}, false, false); machine.debuggerStep(); if (cpu == Processor::MC6809) MC6809AssertInterupt(IS_GIME, INT_IRQ); else HD6309AssertInterupt(IS_GIME, INT_IRQ); machine.resume(); machine.advance(); const auto trace = machine.debuggerTrace(); bool requested=false, servicing=false, vector=false; for (const auto& row : trace.records) { requested |= row.event == VCC::TraceEvent::IRQRequested; servicing |= row.event == VCC::TraceEvent::IRQServicing; vector |= row.event == VCC::TraceEvent::IRQExecuting; } XCTAssertTrue(requested); XCTAssertTrue(servicing); XCTAssertTrue(vector); } } - (void)testDisabledBreakpointsShareAtomicAuthoritativeState { MachineSession machine; machine.loadDiagnostic(); machine.debuggerConfigureBreakpoints({}, {0x8000}); machine.resume(); machine.advance(); XCTAssertEqual(machine.snapshot().state, RunState::Running); machine.debuggerConfigureBreakpoints({0x8000}, {}); machine.advance(); XCTAssertEqual(machine.snapshot().state, RunState::Paused); machine.debuggerConfigureBreakpoints({0x8000}, {0x8003}); machine.softReset(); machine.reset(); XCTAssertEqual(machine.debuggerSnapshot().disabledBreakpoints.size(), 1u); XCTAssertTrue(rejectsTrace([&] { machine.debuggerConfigureBreakpoints({0x8000}, {0x8000}); })); XCTAssertEqual(machine.debuggerSnapshot().disabledBreakpoints[0], 0x8003); machine.debuggerSetBreakpoints({}); XCTAssertTrue(machine.debuggerSnapshot().disabledBreakpoints.empty()); } @end