128 lines
7.6 KiB
Plaintext
128 lines
7.6 KiB
Plaintext
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
#import <XCTest/XCTest.h>
|
|
#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 <stdexcept>
|
|
using namespace VCC::Mac;
|
|
namespace { template<class F> 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<std::uint8_t> 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
|