Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,178 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import XCTest
|
||||
|
||||
/// Runs actual ROM-backed CMOC float operations before inspecting both live frames.
|
||||
final class CMOCFloatingPointIntegrationTests: XCTestCase {
|
||||
private struct Fixture {
|
||||
let root: URL
|
||||
let artifact: CMOCBuildArtifact
|
||||
let metadata: CMOCVariableDebug
|
||||
let rom: Data
|
||||
let sources: [String: String]
|
||||
func line(_ marker: String, file: String) throws -> Int {
|
||||
try XCTUnwrap(sources[file]?.components(separatedBy: "\n").firstIndex { $0.contains(marker) }) + 1
|
||||
}
|
||||
func address(_ marker: String, file: String) throws -> UInt16 {
|
||||
try XCTUnwrap(metadata.sourceMap.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("CMOCFloatingPoint-\(UUID().uuidString)")
|
||||
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
|
||||
do {
|
||||
let project = try CMOCProject.create(at: root.appendingPathComponent("Project"))
|
||||
let sources = ["types.h": """
|
||||
struct Measurements { float x; float samples[3]; float *pointer; };
|
||||
""", "main.c": """
|
||||
#include <cmoc.h>
|
||||
#include <coco.h>
|
||||
#include "types.h"
|
||||
float globalValues[6] = { 0.0f, 1.5f, -2.75f, 1.0e-20f, 1.0e20f, 0.1f };
|
||||
float globalResult;
|
||||
unsigned int result;
|
||||
unsigned int inspect(float input, struct Measurements *parent);
|
||||
int main(void)
|
||||
{
|
||||
float callerValue = -6.25f;
|
||||
struct Measurements measurements;
|
||||
initCoCoSupport();
|
||||
measurements.x = 1.25f;
|
||||
measurements.samples[0] = 0.5f;
|
||||
measurements.samples[1] = -0.125f;
|
||||
measurements.samples[2] = 8.0f;
|
||||
measurements.pointer = &measurements.samples[1];
|
||||
result = inspect(callerValue, &measurements); /* MAIN_CALL */
|
||||
for (;;) ++result;
|
||||
return 0;
|
||||
}
|
||||
""", "helper.c": """
|
||||
#include "types.h"
|
||||
extern float globalResult;
|
||||
extern unsigned int result;
|
||||
unsigned int inspect(float input, struct Measurements *parent)
|
||||
{
|
||||
float local = input + 0.5f;
|
||||
float samples[2];
|
||||
samples[0] = 0.25f;
|
||||
samples[1] = -16.5f;
|
||||
globalResult = parent->x * 3.0f;
|
||||
result = 1; /* LEAF_STOP */
|
||||
return result;
|
||||
}
|
||||
"""]
|
||||
for (name, source) in sources { try Data(source.utf8).write(to: project.directory.appendingPathComponent(name)) }
|
||||
let makefile = """
|
||||
CMOC ?= cmoc
|
||||
build: main.bin
|
||||
main.bin: main.o helper.o
|
||||
\t"$(CMOC)" --coco --intermediate --org=2800 -o $@ main.o helper.o
|
||||
main.o: main.c
|
||||
\t"$(CMOC)" --coco --intermediate -O0 -fno-omit-frame-pointer -c -o $@ $<
|
||||
helper.o: helper.c
|
||||
\t"$(CMOC)" --coco --intermediate -O0 -fno-omit-frame-pointer -c -o $@ $<
|
||||
"""
|
||||
try Data(makefile.utf8).write(to: project.makefileURL)
|
||||
let service = CMOCBuildService(toolchain: toolchain, buildRoot: root.appendingPathComponent("Builds"))
|
||||
let artifact = try await service.build(project: project, overlays: [:])
|
||||
let map = try CMOCProjectSourceMap.parse(artifact: artifact)
|
||||
let metadata = try CMOCVariableDebug.parse(artifact: artifact, verifiedMap: map)
|
||||
return Fixture(root: root, artifact: artifact, metadata: metadata, 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 withStoppedProcessors(_ fixture: Fixture,
|
||||
body: (VCCMachineController, VCCDebuggerSnapshot) 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)
|
||||
let breakpoint = try fixture.address("LEAF_STOP", file: "helper.c")
|
||||
var state = await command { controller.debuggerLoadBinary(fixture.artifact.binaryData, breakpoint: breakpoint, completion: $0) }
|
||||
for _ in 0..<1000 where state.state == .running {
|
||||
try await Task.sleep(nanoseconds: 5_000_000)
|
||||
state = await command(controller.snapshot)
|
||||
}
|
||||
XCTAssertNil(state.errorMessage)
|
||||
XCTAssertEqual(state.state, .paused)
|
||||
XCTAssertEqual(state.programCounter, breakpoint)
|
||||
try await body(controller, await capture(controller))
|
||||
_ = await command(controller.shutdown)
|
||||
} catch { _ = await command(controller.shutdown); throw error }
|
||||
}
|
||||
}
|
||||
private func stack(_ fixture: Fixture, _ snapshot: VCCDebuggerSnapshot,
|
||||
memory: Data? = nil, available: Data? = nil) throws -> CMOCCallStack {
|
||||
CMOCCallStack.capture(metadata: fixture.metadata, pc: snapshot.machine.programCounter,
|
||||
u: try XCTUnwrap(snapshot.registers["U"]?.uint16Value), s: try XCTUnwrap(snapshot.registers["S"]?.uint16Value),
|
||||
memory: memory ?? snapshot.logicalMemory, available: available ?? snapshot.logicalMemoryAvailable)
|
||||
}
|
||||
@MainActor func testCompiledFloatingValuesAndCallerFramesOnBothProcessors() async throws {
|
||||
let fixture = try await fixture()
|
||||
defer { try? FileManager.default.removeItem(at: fixture.root) }
|
||||
try await withStoppedProcessors(fixture) { controller, snapshot in
|
||||
let originalMemory = Data(Array(snapshot.logicalMemory))
|
||||
let frames = try stack(fixture, snapshot)
|
||||
XCTAssertEqual(frames.frames.map(\.functionName), ["inspect", "main"], frames.termination)
|
||||
guard frames.frames.count == 2 else { return }
|
||||
func evaluator(_ frame: CMOCCallStack.Frame) -> CMOCWatchEvaluator {
|
||||
CMOCWatchEvaluator(metadata: fixture.metadata,
|
||||
context: .init(pc: frame.pc, u: frame.u, memory: snapshot.logicalMemory,
|
||||
available: snapshot.logicalMemoryAvailable),
|
||||
frameLocalsAvailable: frame.localsInspectable)
|
||||
}
|
||||
let current = evaluator(frames.frames[0]), caller = evaluator(frames.frames[1])
|
||||
for (engine, expression, expected) in [
|
||||
(current, "input", "-6.25"), (current, "local", "-5.75"),
|
||||
(current, "samples[0]", "0.25"), (current, "samples[1]", "-16.5"),
|
||||
(current, "globalResult", "3.75"), (current, "parent->x", "1.25"),
|
||||
(current, "*parent->pointer", "-0.125"), (caller, "callerValue", "-6.25"),
|
||||
(caller, "measurements.x", "1.25"), (caller, "*measurements.pointer", "-0.125")
|
||||
] {
|
||||
let value = engine.evaluate(expression)
|
||||
XCTAssertNil(value.error, "\(expression): \(value.error ?? "")")
|
||||
XCTAssertEqual(value.value, expected, expression)
|
||||
}
|
||||
let globals = current.children(of: .init(root: .variable("globalValues"))).nodes
|
||||
XCTAssertEqual(globals.count, 6)
|
||||
XCTAssertEqual(Array(globals.prefix(3).map(\.value)), ["0", "1.5", "-2.75"])
|
||||
XCTAssertEqual(try XCTUnwrap(Double(globals[3].value)), 1e-20, accuracy: 1e-29)
|
||||
XCTAssertEqual(try XCTUnwrap(Double(globals[4].value)), 1e20, accuracy: 1e11)
|
||||
XCTAssertEqual(globals[5].value, "0.099999999977", "Preserve the compiled 32-bit significand rather than rounding through host Float")
|
||||
let aggregate = caller.watchTreeRoot("measurements")
|
||||
XCTAssertEqual(aggregate.childCount, 3)
|
||||
let member = caller.children(of: aggregate.path).nodes
|
||||
XCTAssertEqual(member[0].value, "1.25")
|
||||
XCTAssertEqual(caller.children(of: member[1].path).nodes.map(\.value), ["0.5", "-0.125", "8"])
|
||||
XCTAssertEqual(caller.children(of: member[2].path).nodes.first?.value, "-0.125")
|
||||
XCTAssertTrue(current.visibleVariables().contains { $0.name == "local" && $0.value == "-5.75" && $0.error == nil })
|
||||
// The compiler chooses a format explicitly; the app must not guess
|
||||
// from a float's name, byte count or the machine's current ROM.
|
||||
let inputType = try XCTUnwrap(fixture.metadata.variables.first { $0.name == "input" }?.type)
|
||||
XCTAssertEqual(inputType.floatingFormat, "coco-basic-40")
|
||||
XCTAssertEqual(inputType.size, 5)
|
||||
let after = await capture(controller)
|
||||
XCTAssertEqual(after.machine.programCounter, snapshot.machine.programCounter)
|
||||
XCTAssertEqual(after.machine.cycles, snapshot.machine.cycles)
|
||||
XCTAssertEqual(after.registers, snapshot.registers)
|
||||
XCTAssertEqual(snapshot.logicalMemory, originalMemory)
|
||||
XCTAssertEqual(after.logicalMemory, originalMemory, "Reading floats must not execute guest math routines or touch memory")
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user