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

@@ -0,0 +1,306 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
/// End-to-end qualification: actual compiler output and an executing CoCo,
/// rather than handcrafted addresses or a second implementation of the mapper.
final class CMOCSourceDebugTests: XCTestCase {
private struct Fixture {
let root: URL
let artifact: CMOCBuildArtifact
let map: CMOCProjectSourceMap
let rom: Data
let sources: [String: String]
func line(_ marker: String, file: String = "main.c") throws -> Int {
try XCTUnwrap(sources[file]?.components(separatedBy: "\n").firstIndex { $0.contains(marker) }) + 1
}
func address(_ marker: String, file: String = "main.c") throws -> UInt16 {
try XCTUnwrap(map.addresses(forLine: line(marker, file: file), in: file).first, marker)
}
}
private func fixture() async throws -> Fixture {
let resources = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().appendingPathComponent("LocalResources")
let toolchain = resources.appendingPathComponent("ToolchainBundle")
let rom = resources.appendingPathComponent("ROMs/coco3.rom")
try XCTSkipUnless(FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path)
&& FileManager.default.fileExists(atPath: rom.path), "Local licensed CoCo ROM and staged toolchain are required")
let root = FileManager.default.temporaryDirectory.appendingPathComponent("CMOCSourceDebug-\(UUID().uuidString)")
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
do {
let project = try CMOCProject.create(at: root.appendingPathComponent("Project"))
let sources = ["main.c": """
#include <cmoc.h>
#include <coco.h>
#include "shared.h"
unsigned int result;
unsigned int progress;
unsigned int values[3] = {11, 22, 33};
struct Pair pair = {4, 45};
unsigned int *pointer = &values[1];
int signedValue = -1234;
unsigned char *ioPointer = (unsigned char *)0xFF00;
int main(void)
{
unsigned int mainLocal = 7;
initCoCoSupport();
result = transform(mainLocal); /* CALL_TRANSFORM */
progress = result; /* AFTER_TRANSFORM */
result = recurse(3); /* CALL_RECURSE */
progress = result; /* AFTER_RECURSE */
for (;;) ++progress;
return 0;
}
""", "helper.c": """
#include "shared.h"
unsigned int transform(unsigned int value)
{
unsigned int local = value + 5;
{
unsigned int value = 99;
result = value; /* SHADOW_VALUE */
}
result = local; /* OUTER_VALUE */
return local * 2; /* RETURN_TRANSFORM */
}
unsigned int recurse(unsigned int n)
{
unsigned int local = n + 10;
if (n == 0) return local; /* RECURSION_BASE */
return recurse(n - 1) + local; /* RECURSION_CALL */
}
""", "shared.h": """
struct Pair { unsigned int left; unsigned int right; };
extern unsigned int result;
unsigned int transform(unsigned int value);
unsigned int recurse(unsigned int n);
"""]
for (name, source) in sources { try Data(source.utf8).write(to: project.directory.appendingPathComponent(name)) }
let makefile = """
CMOC ?= cmoc
.PHONY: build clean
build: main.bin
main.bin: main.o helper.o
\t"$(CMOC)" --coco --intermediate --org=2800 -o $@ main.o helper.o
%.o: %.c shared.h
\t"$(CMOC)" --coco --intermediate -O0 -fno-omit-frame-pointer -c -o $@ $<
clean:
\trm -f *.o *.bin *.s *.lst *.map *.link
"""
try Data(makefile.utf8).write(to: project.makefileURL)
let artifact = try await CMOCBuildService(toolchain: toolchain, buildRoot: root.appendingPathComponent("Builds"))
.build(project: project, overlays: [:])
let map = try CMOCProjectSourceMap.parse(artifact: artifact)
XCTAssertEqual(Set(map.sourcePaths), Set(["main.c", "helper.c"]))
return Fixture(root: root, artifact: artifact, map: map, rom: try Data(contentsOf: rom), sources: sources)
} catch { try? FileManager.default.removeItem(at: root); throw error }
}
@MainActor private func command(_ operation: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
await withCheckedContinuation { continuation in operation { continuation.resume(returning: $0) } }
}
@MainActor private func capture(_ controller: VCCMachineController) async -> VCCDebuggerSnapshot {
await withCheckedContinuation { continuation in
controller.debuggerSnapshot(address: 0, followPC: true, memoryAddress: 0) { continuation.resume(returning: $0) }
}
}
@MainActor private func waitForStop(_ controller: VCCMachineController) async throws -> VCCDebuggerSnapshot {
var state = await command(controller.snapshot)
for _ in 0..<1000 where state.state == .running {
try await Task.sleep(nanoseconds: 5_000_000)
state = await command(controller.snapshot)
}
XCTAssertEqual(state.state, .paused, state.errorMessage ?? "Execution did not stop")
XCTAssertNil(state.errorMessage)
return await capture(controller)
}
@MainActor private func runTo(_ fixture: Fixture, controller: VCCMachineController, marker: String, file: String = "main.c") async throws -> VCCDebuggerSnapshot {
let address = try fixture.address(marker, file: file)
let result = await command { controller.debuggerLoadBinary(fixture.artifact.binaryData, breakpoint: address, completion: $0) }
XCTAssertNil(result.errorMessage)
let stopped = try await waitForStop(controller)
XCTAssertEqual(stopped.machine.programCounter, address)
return stopped
}
@MainActor private func startSourceStep(_ mode: Int, fixture: Fixture, controller: VCCMachineController,
snapshot: VCCDebuggerSnapshot) async -> VCCMachineSnapshot {
var identities: [CMOCProjectSourceMap.Location: UInt32] = [:]
let ids = fixture.map.instructions.map { instruction -> NSNumber in
let location = CMOCProjectSourceMap.Location(path: instruction.sourcePath, line: instruction.sourceLine)
if identities[location] == nil { identities[location] = UInt32(identities.count + 1) }
return NSNumber(value: identities[location]!)
}
return await command {
controller.debuggerStepSource(mode: mode,
addresses: fixture.map.instructions.map { NSNumber(value: $0.address) }, locations: ids,
bytes: fixture.map.instructions.map { Data($0.bytes) },
generation: snapshot.machine.generation, programRevision: snapshot.machine.debuggerProgramRevision,
mappingFingerprint: snapshot.machine.debuggerMappingFingerprint,
programCounter: snapshot.machine.programCounter, completion: $0)
}
}
@MainActor private func sourceStep(_ mode: Int, fixture: Fixture, controller: VCCMachineController) async throws -> VCCDebuggerSnapshot {
let result = await startSourceStep(mode, fixture: fixture, controller: controller, snapshot: await capture(controller))
XCTAssertNil(result.errorMessage)
return try await waitForStop(controller)
}
@MainActor private func withProcessors(_ fixture: Fixture,
body: (VCCMachineController) async throws -> Void) async throws {
for use6309 in [false, true] {
let controller = VCCMachineController()
do {
_ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) }
let loaded = await command { controller.loadROM(fixture.rom, use6309: use6309, completion: $0) }
XCTAssertNil(loaded.errorMessage)
_ = await command(controller.resume)
try await Task.sleep(nanoseconds: 1_500_000_000)
_ = await command(controller.pause)
try await body(controller)
_ = await command(controller.shutdown)
} catch { _ = await command(controller.shutdown); throw error }
}
}
@MainActor func testRealMultiFileStepIntoOverOutAndRecursiveFramesOnBothCPUs() async throws {
let fixture = try await fixture()
defer { try? FileManager.default.removeItem(at: fixture.root) }
let metadata = try CMOCVariableDebug.parse(artifact: fixture.artifact, verifiedMap: fixture.map)
try await withProcessors(fixture) { controller in
let original = try await runTo(fixture, controller: controller, marker: "CALL_TRANSFORM")
let over = try await sourceStep(1, fixture: fixture, controller: controller)
XCTAssertEqual(fixture.map.location(at: over.machine.programCounter),
.init(path: "main.c", line: try fixture.line("AFTER_TRANSFORM")))
XCTAssertEqual(over.machine.generation, original.machine.generation)
XCTAssertEqual(over.machine.debuggerProgramRevision, original.machine.debuggerProgramRevision)
XCTAssertEqual(over.breakpoints, original.breakpoints, "Temporary step targets must not replace permanent breakpoints")
assertValue("result", "24", in: try evaluator(metadata, over))
_ = try await runTo(fixture, controller: controller, marker: "CALL_TRANSFORM")
let into = try await sourceStep(0, fixture: fixture, controller: controller)
XCTAssertEqual(fixture.map.location(at: into.machine.programCounter)?.path, "helper.c", "Into must enter the other translation unit")
let out = try await sourceStep(2, fixture: fixture, controller: controller)
XCTAssertEqual(fixture.map.location(at: out.machine.programCounter)?.path, "main.c", "Out must return to the caller")
_ = try await runTo(fixture, controller: controller, marker: "CALL_RECURSE")
var recursive = try await sourceStep(0, fixture: fixture, controller: controller)
let callLine = try fixture.line("RECURSION_CALL", file: "helper.c")
for _ in 0..<12 where fixture.map.location(at: recursive.machine.programCounter)?.line != callLine {
recursive = try await sourceStep(0, fixture: fixture, controller: controller)
}
XCTAssertEqual(fixture.map.location(at: recursive.machine.programCounter), .init(path: "helper.c", line: callLine))
let outerU = recursive.registers["U"]?.uint16Value
var nested = try await sourceStep(0, fixture: fixture, controller: controller)
for _ in 0..<12 where fixture.map.location(at: nested.machine.programCounter)?.line != callLine {
nested = try await sourceStep(0, fixture: fixture, controller: controller)
}
XCTAssertEqual(fixture.map.location(at: nested.machine.programCounter), .init(path: "helper.c", line: callLine))
XCTAssertNotEqual(nested.registers["U"]?.uint16Value, outerU, "Recursion must establish a distinct live frame")
let returned = try await sourceStep(2, fixture: fixture, controller: controller)
XCTAssertEqual(returned.registers["U"]?.uint16Value, outerU, "Out must leave exactly one recursive invocation")
XCTAssertEqual(fixture.map.location(at: returned.machine.programCounter)?.path, "helper.c")
_ = try await runTo(fixture, controller: controller, marker: "CALL_TRANSFORM")
let calleePoint = try fixture.address("SHADOW_VALUE", file: "helper.c")
_ = await command { controller.debuggerConfigureBreakpoints([NSNumber(value: calleePoint)], disabled: [0x7001], completion: $0) }
let userStop = try await sourceStep(1, fixture: fixture, controller: controller)
XCTAssertEqual(userStop.machine.programCounter, calleePoint, "Step Over must still honor an explicit breakpoint inside the call")
XCTAssertEqual(userStop.breakpoints, [NSNumber(value: calleePoint)])
XCTAssertEqual(userStop.disabledBreakpoints, [0x7001])
}
}
@MainActor func testSourceStepRejectsEditedMemoryAndStalePausedPCWithoutExecuting() async throws {
let fixture = try await fixture()
defer { try? FileManager.default.removeItem(at: fixture.root) }
try await withProcessors(fixture) { controller in
var previous = try await runTo(fixture, controller: controller, marker: "CALL_TRANSFORM")
_ = await command { controller.debuggerWriteMemory(address: 0x7000, data: Data([0x55]), completion: $0) }
var before = await capture(controller)
var rejected = await startSourceStep(0, fixture: fixture, controller: controller, snapshot: previous)
XCTAssertNotNil(rejected.errorMessage, "An explicit memory edit invalidates the captured build connection")
XCTAssertEqual(rejected.state, .paused)
XCTAssertEqual(rejected.cycles, before.machine.cycles)
XCTAssertEqual(rejected.programCounter, before.machine.programCounter)
previous = try await runTo(fixture, controller: controller, marker: "CALL_TRANSFORM")
_ = await command(controller.debuggerStep)
before = await capture(controller)
rejected = await startSourceStep(1, fixture: fixture, controller: controller, snapshot: previous)
XCTAssertNotNil(rejected.errorMessage, "The worker must check expected PC at the command boundary")
XCTAssertEqual(rejected.state, .paused)
XCTAssertEqual(rejected.cycles, before.machine.cycles)
XCTAssertEqual(rejected.programCounter, before.machine.programCounter)
let after = await capture(controller)
XCTAssertEqual(after.breakpoints, before.breakpoints)
XCTAssertEqual(after.disabledBreakpoints, before.disabledBreakpoints)
}
}
private func evaluator(_ metadata: CMOCVariableDebug, _ snapshot: VCCDebuggerSnapshot) throws -> CMOCWatchEvaluator {
CMOCWatchEvaluator(metadata: metadata, context: .init(pc: snapshot.machine.programCounter,
u: try XCTUnwrap(snapshot.registers["U"]?.uint16Value),
memory: snapshot.logicalMemory, available: snapshot.logicalMemoryAvailable))
}
private func assertValue(_ expression: String, _ expected: String, in evaluator: CMOCWatchEvaluator,
file: StaticString = #filePath, line: UInt = #line) {
let result = evaluator.evaluate(expression)
XCTAssertNil(result.error, "\(expression): \(result.error ?? "")", file: file, line: line)
XCTAssertEqual(result.value, expected, expression, file: file, line: line)
}
@MainActor func testLiveCompilerVariablesShadowingArraysPointersAndReadOnlyWatchesOnBothCPUs() async throws {
let fixture = try await fixture()
defer { try? FileManager.default.removeItem(at: fixture.root) }
let metadata = try CMOCVariableDebug.parse(artifact: fixture.artifact, verifiedMap: fixture.map)
XCTAssertTrue(metadata.functions.contains { $0.name == "transform" && $0.frame })
try await withProcessors(fixture) { controller in
let nested = try await runTo(fixture, controller: controller, marker: "SHADOW_VALUE", file: "helper.c")
let inner = try evaluator(metadata, nested)
assertValue("value", "99", in: inner)
assertValue("local", "12", in: inner)
assertValue("result", "0", in: inner)
assertValue("signedValue", "-1234", in: inner)
assertValue("values[1]", "22", in: inner)
assertValue("*pointer", "22", in: inner)
assertValue("pointer[1]", "33", in: inner)
assertValue("pair.right", "45", in: inner)
assertValue("values[1] + local * 2", "46", in: inner)
XCTAssertEqual(inner.visibleVariables().filter { $0.name == "value" }.count, 1, "Only the innermost shadow is visible")
for expression in ["values[3]", "*ioPointer", "value = 5", "transform(1)", "++local", "1 / 0", "missing"] {
XCTAssertNotNil(inner.evaluate(expression).error, expression)
}
let afterInspection = await capture(controller)
XCTAssertEqual(afterInspection.logicalMemory, nested.logicalMemory, "Watch evaluation cannot write guest memory or read I/O for side effects")
XCTAssertEqual(afterInspection.machine.cycles, nested.machine.cycles)
let outer = try await sourceStep(0, fixture: fixture, controller: controller)
XCTAssertEqual(fixture.map.location(at: outer.machine.programCounter),
.init(path: "helper.c", line: try fixture.line("OUTER_VALUE", file: "helper.c")))
let outerValues = try evaluator(metadata, outer)
assertValue("value", "7", in: outerValues)
assertValue("local", "12", in: outerValues)
assertValue("result", "99", in: outerValues)
let returned = try await sourceStep(2, fixture: fixture, controller: controller)
let caller = try evaluator(metadata, returned)
assertValue("mainLocal", "7", in: caller)
XCTAssertNotNil(caller.evaluate("local").error, "A callee's stack local is unavailable after return")
_ = try await runTo(fixture, controller: controller, marker: "CALL_RECURSE")
var recursive = try await sourceStep(0, fixture: fixture, controller: controller)
let callLine = try fixture.line("RECURSION_CALL", file: "helper.c")
for _ in 0..<12 where fixture.map.location(at: recursive.machine.programCounter)?.line != callLine {
recursive = try await sourceStep(0, fixture: fixture, controller: controller)
}
assertValue("n", "3", in: try evaluator(metadata, recursive))
assertValue("local", "13", in: try evaluator(metadata, recursive))
var child = try await sourceStep(0, fixture: fixture, controller: controller)
for _ in 0..<12 where fixture.map.location(at: child.machine.programCounter)?.line != callLine {
child = try await sourceStep(0, fixture: fixture, controller: controller)
}
assertValue("n", "2", in: try evaluator(metadata, child))
assertValue("local", "12", in: try evaluator(metadata, child))
let parent = try await sourceStep(2, fixture: fixture, controller: controller)
assertValue("n", "3", in: try evaluator(metadata, parent))
assertValue("local", "13", in: try evaluator(metadata, parent))
let code = try XCTUnwrap(fixture.map.instructions.first)
_ = await command { controller.debuggerWriteMemory(address: code.address, data: Data([code.bytes[0] ^ 1]), completion: $0) }
let changed = await capture(controller)
XCTAssertNotNil(try evaluator(metadata, changed).evaluate("result").error,
"Even apparently valid data must not be reported against changed executable bytes")
}
}
}