Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+311
View File
@@ -0,0 +1,311 @@
// SPDX-License-Identifier: GPL-3.0-or-later
#include "CoreChecks.h"
#include "../../src/core/CpuHost.h"
#include "../../src/core/CpuMemory.h"
#include "../../src/core/Event.h"
#include "../../src/core/mc6809.h"
#include "../../src/core/hd6309.h"
#include <algorithm>
#include <array>
#include <initializer_list>
#include <functional>
#include <stdexcept>
#include <string>
// Test-only bus and joystick clock. These must never be linked into the app:
// there is no ROM protection, MMU, GIME, I/O decoding, or peripheral emulation.
namespace {
std::array<unsigned char, 65536> memory;
unsigned char mapType;
struct FlatBus final : VCC::CpuMemoryBus {
std::function<void(unsigned short)> beforeRead;
unsigned char Read(unsigned short address) override {
if (beforeRead) beforeRead(address);
return memory[address];
}
void Write(unsigned char value, unsigned short address) override { memory[address] = value; }
void SelectMap(unsigned char type) override { mapType = type; }
};
void require(bool condition, const char* message) {
if (!condition) throw std::runtime_error(message);
}
struct Hooks final : VCC::CpuDebugHooks {
bool halted = false, stepping = false, enabled = false, tracing = false;
std::vector<VCC::CPUState> before, after;
std::vector<unsigned char> requested, serviced, executing;
bool IsHalted() const override { return halted; }
bool IsStepping() const override { return stepping; }
void Halt() override { halted = true; stepping = false; }
bool IsTracingEnabled() const override { return enabled; }
bool IsTracing() const override { return tracing; }
void TraceStart() override { tracing = true; }
void TraceCaptureBefore(long, const VCC::CPUState& s) override { before.push_back(s); }
void TraceCaptureAfter(long, const VCC::CPUState& s) override { after.push_back(s); }
void TraceCaptureInterruptRequest(unsigned char irq, long, const VCC::CPUState&) override { requested.push_back(irq); }
void TraceCaptureInterruptServicing(unsigned char irq, long, const VCC::CPUState&) override { serviced.push_back(irq); }
void TraceCaptureInterruptExecuting(unsigned char irq, long, const VCC::CPUState&) override { executing.push_back(irq); }
};
struct Cpu {
void (*init)();
void (*reset)();
int (*exec)(int);
VCC::CPUState (*state)();
void (*assertIRQ)(InterruptSource, Interrupt);
void (*clearIRQ)(InterruptSource, Interrupt);
void (*breakpoints)(const std::vector<unsigned short>&);
void (*triggers)(const std::vector<unsigned short>&);
};
const Cpu m6809 {MC6809Init, MC6809Reset, MC6809Exec, MC6809GetState,
MC6809AssertInterupt, MC6809DeAssertInterupt, MC6809SetBreakpoints, MC6809SetTraceTriggers};
const Cpu h6309 {HD6309Init, HD6309Reset, HD6309Exec, HD6309GetState,
HD6309AssertInterupt, HD6309DeAssertInterupt, HD6309SetBreakpoints, HD6309SetTraceTriggers};
struct Fixture {
const Cpu& cpu;
Hooks hooks;
FlatBus bus;
explicit Fixture(const Cpu& c) : cpu(c) {
VCC::SetCpuMemoryBus(&bus);
memory.fill(0);
mapType = 255;
VCC::gEvents.Reset();
VCC::SetCpuDebugHooks(&hooks);
cpu.init();
cpu.breakpoints({}); cpu.triggers({});
MemWrite16(0x4000, 0xfffe);
cpu.reset();
}
~Fixture() {
cpu.breakpoints({}); cpu.triggers({});
VCC::SetCpuDebugHooks(nullptr);
VCC::SetCpuMemoryBus(nullptr);
VCC::gEvents.Reset();
}
void load(std::initializer_list<unsigned char> bytes, unsigned short address = 0x4000) {
std::copy(bytes.begin(), bytes.end(), memory.begin() + address);
}
int instruction() { return 1 - cpu.exec(1); }
};
void execution(const Cpu& cpu) {
Fixture f(cpu);
auto s = cpu.state();
require(s.PC == 0x4000 && s.CC == 0x50 && s.A == 0 && s.B == 0 &&
s.X == 0 && s.Y == 0 && s.U == 0 && s.S == 0 && s.DP == 0 && !s.IsNative6309,
"CPU reset registers/vector/masks");
require(mapType == 0, "CPU reset selects map zero");
// Authored guest fixture: docs/macos/reference/cpu6809.asm, no ROM needed.
f.load({0x1a,0x50,0x10,0xce,0x70,0x00,0x8e,0x41,0x00,0x4f,
0xc6,0x10,0x4c,0xa7,0x80,0x5a,0x26,0xfa,0x20,0xfe});
cpu.breakpoints({0x4012});
f.hooks.enabled = true;
const int cycles = 1000 - cpu.exec(1000);
s = cpu.state();
require(f.hooks.halted && s.PC == 0x4012 && s.A == 16 && s.B == 0 &&
s.X == 0x4110 && s.S == 0x7000, "CPU guest loop final registers/breakpoint");
for (unsigned i = 0; i < 16; ++i)
require(memory[0x4100+i] == i+1, "CPU guest loop indexed stores");
require(f.hooks.before.size() == 69 && f.hooks.after.size() == 69,
"CPU guest loop executes 69 instructions");
require(cycles == 222 && VCC::gEvents.GetClocks() == 222*16,
"CPU guest loop cycle budget and scheduler clocks");
f.hooks.halted = false; cpu.breakpoints({}); cpu.reset();
f.load({0x86,0x7f,0x8b,0x01,0x8b,0x80,0x80,0x01});
require(f.instruction() == 2, "LDA immediate cycles");
f.instruction(); s = cpu.state();
require(s.A == 0x80 && (s.CC & 0x2f) == 0x2a, "ADDA signed overflow/half-carry flags");
f.instruction(); s = cpu.state();
require(s.A == 0 && (s.CC & 0x2f) == 0x07, "ADDA unsigned carry/zero/overflow flags");
f.instruction(); s = cpu.state();
require(s.A == 0xff && (s.CC & 0x0f) == 0x09, "SUBA borrow/negative flags");
cpu.reset();
f.load({0xcc,0x12,0x34,0xfd,0xff,0xff}); // LDD #$1234; STD $FFFF
f.instruction(); f.instruction();
require(memory[0xffff] == 0x12 && memory[0] == 0x34, "CPU big-endian word store wraps bus address");
}
// A changing peripheral flag must be sampled during TST, before instruction
// completion/IRQ entry. An all-at-the-end tick starves polling loops whenever
// the IRQ handler acknowledges the same flag. No proprietary guest code needed.
void testOperandTiming(const Cpu& cpu) {
for (unsigned mode = 0; mode < 4; ++mode) {
// Direct, ,X, extended, and 8-bit indexed offset (extra EA cycle).
const unsigned cycles = mode == 2 || mode == 3 ? 7 : 6;
const unsigned readCycle = cycles - 2;
for (unsigned edge = 1; edge <= cycles; ++edge) {
Fixture f(cpu);
f.load({0x86,0x42,0x1f,0x8b,0x8e,0x42,0x00,0x1a,0x03}); // DP=$42, X=$4200; set V/C
for (unsigned n = 0; n < 4; ++n) f.instruction();
if (mode == 0) f.load({0x0d,0x00}, 0x4009);
if (mode == 1) f.load({0x6d,0x84}, 0x4009);
if (mode == 2) f.load({0x7d,0x42,0x00}, 0x4009);
if (mode == 3) f.load({0x6d,0x88,0x01}, 0x4009);
const unsigned address = mode == 3 ? 0x4201 : 0x4200;
const auto start = VCC::gEvents.GetClocks();
unsigned reads = 0;
f.bus.beforeRead = [&](unsigned short a) {
if (a == address) {
++reads;
require(VCC::gEvents.GetClocks() - start == readCycle * 16,
"TST samples operand after addressing/data cycles, before trailing cycles");
}
};
// Place the edge just before the cycle boundary (scheduler intervals are half-open).
VCC::gEvents.Queue(edge * 16 - 1, [&] { memory[address] = 0x80; }, 1);
require(f.instruction() == cycles, "TST retains total instruction timing");
require(reads == 1 && memory[address] == 0x80, "TST reads exactly once and advances pending events");
require((cpu.state().CC & 0x0f) == (edge <= readCycle ? 0x09 : 0x05),
"TST sees only edges before operand sampling, clears V and preserves C");
}
Fixture f(cpu);
f.load({0x10,0xce,0x70,0x00,0x86,0x42,0x1f,0x8b,0x8e,0x42,0x00,0x1c,0xaf});
for (unsigned n = 0; n < 5; ++n) f.instruction(); // LDS, LDA, TFR, LDX, ANDCC
unsigned short passed = 0;
if (mode == 0) { f.load({0x0d,0x00,0x2a,0xfc,0x12}, 0x400d); passed = 0x4011; }
if (mode == 1) { f.load({0x6d,0x84,0x2a,0xfc,0x12}, 0x400d); passed = 0x4011; }
if (mode == 2) { f.load({0x7d,0x42,0x00,0x2a,0xfb,0x12}, 0x400d); passed = 0x4012; }
if (mode == 3) { f.load({0x6d,0x88,0x01,0x2a,0xfb,0x12}, 0x400d); passed = 0x4012; }
const unsigned address = mode == 3 ? 0x4201 : 0x4200;
f.load({0xb6,0x43,0x00,0x3b}, 0x5000); // IRQ: read peripheral acknowledge; RTI
MemWrite16(0x5000, 0xfff8);
unsigned acknowledgements = 0;
f.bus.beforeRead = [&](unsigned short a) {
if (a == 0x4300) {
++acknowledgements;
memory[address] = 0;
cpu.clearIRQ(IS_PIA0_VSYNC, INT_IRQ);
}
};
VCC::gEvents.Queue(2 * 16, [&] {
memory[address] = 0x80;
cpu.assertIRQ(IS_PIA0_VSYNC, INT_IRQ);
}, 1);
cpu.breakpoints({passed});
cpu.exec(200);
require(f.hooks.halted && cpu.state().PC == passed && acknowledgements == 1 &&
memory[address] == 0 && cpu.state().S == 0x7000,
"TST polling exits after IRQ acknowledges flag and RTI restores sampled condition codes");
}
}
void interrupts(const Cpu& cpu) {
for (auto irq : {INT_IRQ, INT_FIRQ, INT_NMI}) {
Fixture f(cpu);
f.load({0x10,0xce,0x70,0x00,0x1c,0xaf,0x12}); // LDS; ANDCC clears I/F; NOP
f.load({0x3b}, 0x5000); // RTI
const unsigned short vector = irq == INT_IRQ ? 0xfff8 : irq == INT_FIRQ ? 0xfff6 : 0xfffc;
MemWrite16(0x5000, vector);
f.instruction(); f.instruction();
const auto before = cpu.state();
f.hooks.tracing = true;
cpu.breakpoints({0x5000});
const auto source = irq == INT_NMI ? IS_NMI : IS_GIME;
cpu.assertIRQ(source, irq);
if (irq != INT_NMI) {
// Independent sources share a line; clearing one must not clear the other.
cpu.assertIRQ(IS_PIA0_HSYNC, irq);
cpu.clearIRQ(source, irq);
}
cpu.exec(100);
const auto handler = cpu.state();
const unsigned frameBytes = irq == INT_FIRQ ? 3 : 12;
require(f.hooks.halted && handler.PC == 0x5000 && handler.S == 0x7000-frameBytes,
"CPU interrupt vector and stack frame");
require(MemRead16(0x6ffe) == before.PC, "CPU interrupt stacked return address");
require((memory[handler.S] & 0x80) == (irq == INT_FIRQ ? 0 : 0x80),
"CPU interrupt entire-state flag");
require(f.hooks.serviced == std::vector<unsigned char>{static_cast<unsigned char>(irq)} &&
f.hooks.executing == f.hooks.serviced && !f.hooks.requested.empty(),
"CPU interrupt debug callbacks");
cpu.clearIRQ(source, irq);
if (irq != INT_NMI) cpu.clearIRQ(IS_PIA0_HSYNC, irq);
cpu.breakpoints({}); f.hooks.halted = false;
f.instruction();
const auto restored = cpu.state();
require(restored.PC == before.PC && restored.S == before.S &&
restored.A == before.A && restored.B == before.B &&
(restored.CC & 0x7f) == (before.CC & 0x7f), "CPU RTI restores interrupted state");
}
// Reset masks IRQ/FIRQ; reset also clears previously asserted sources.
for (auto irq : {INT_IRQ, INT_FIRQ}) {
Fixture f(cpu);
f.load({0x12,0x12});
cpu.assertIRQ(IS_GIME, irq);
f.instruction();
require(cpu.state().PC == 0x4001, "CPU masks IRQ/FIRQ after reset");
cpu.reset();
f.load({0x1c,0xaf,0x12});
f.instruction(); f.instruction();
require(cpu.state().PC == 0x4003, "CPU reset clears interrupt sources");
}
}
}
void Check6809Execution() { execution(m6809); }
void Check6309Execution() { execution(h6309); }
void Check6809Interrupts() { interrupts(m6809); testOperandTiming(m6809); }
void Check6309Interrupts() { interrupts(h6309); testOperandTiming(h6309); }
void Check6309Native() {
Fixture f(h6309);
// LDMD #1; LDQ #$12345678; STQ $4200; NOP.
f.load({0x11,0x3d,0x01,0xcd,0x12,0x34,0x56,0x78,0x10,0xfd,0x42,0x00,0x12});
f.instruction();
require(h6309.state().IsNative6309, "6309 enters native mode");
f.instruction();
auto s = h6309.state();
require(s.A == 0x12 && s.B == 0x34 && s.E == 0x56 && s.F == 0x78,
"6309 LDQ register byte order");
f.instruction();
require(MemRead16(0x4200) == 0x1234 && MemRead16(0x4202) == 0x5678,
"6309 STQ memory byte order");
require(f.instruction() == 1, "6309 native NOP timing");
h6309.reset(); f.load({0x12});
require(!h6309.state().IsNative6309 && f.instruction() == 2,
"6309 reset restores emulation mode timing");
}
void CheckCpuDebugHooks() {
for (const auto& cpu : {m6809, h6309}) {
Fixture f(cpu);
f.load({0x12,0x12,0x12,0x12});
cpu.triggers({0x4001}); cpu.breakpoints({0x4003});
f.hooks.enabled = true;
cpu.exec(100);
require(f.hooks.halted && f.hooks.before.size() == 2 && f.hooks.after.size() == 2 &&
f.hooks.before.front().PC == 0x4001 && f.hooks.after.back().PC == 0x4003,
"CPU trace trigger starts at requested instruction and stops before breakpoint");
require(cpu.exec(10) == 10 && cpu.state().PC == 0x4003,
"CPU halt consumes no cycles/instructions");
f.hooks.halted = false; f.hooks.stepping = true;
require(f.instruction() == 2 && cpu.state().PC == 0x4004 && f.hooks.halted,
"CPU debugger single-step advances exactly one instruction");
}
}
void CheckEventScheduler() {
VCC::Event event;
event.Tick(1);
require(event.GetClocks() == 16, "Event constructor initializes default clock rate");
event.Reset();
std::vector<int> order;
event.Queue(32, [&] { order.push_back(2); event.Queue(1, [&] { order.push_back(3); }); });
event.Queue(16, [&] { order.push_back(1); });
event.Tick(1);
require(order.empty(), "Events at exact tick boundary remain queued");
event.Tick(2);
require(order == std::vector<int>({1,2,3}) && event.GetClocks() == 48,
"Events run in clock order including reentrant queue");
event.Queue(32, [&] { order.push_back(4); }, 1);
event.ReQueue(16, [&] { order.push_back(5); }, 1);
event.Queue(16, [&] { order.push_back(6); }, 2);
event.Erase(2); event.Rebase(); event.Tick(2);
require(order.back() == 5 && order.size() == 4 && event.GetSize() == 0,
"Event reschedule/erase/rebase preserves remaining delays");
event.SetClocksPerCycle(8); event.SetOverclock(2); event.Rebase(); event.Tick(2);
require(event.GetClocks() == 8, "Event overclock and cycle rate apply at rebase");
event.Reset(); event.Rebase(); event.Tick(1);
require(event.GetClocks() == 16, "Event reset clears requested rate/overclock");
}