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,175 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
/// Read-only evidence from an owned, paused run. This deliberately has no caller
/// supplied memory address: the only newly disclosed storage is [S, S + 64).
enum CMOCOwnedCallContext {
static func capture(map: CMOCProjectSourceMap, metadata: CMOCVariableDebug?,
pc: UInt16, s: UInt16, u: UInt16, memory: Data, available: Data,
physicalPages: [Int: Int], sharedPaths: Set<String>) -> [String: Any] {
func unavailable(_ reason: String) -> [String: Any] {
["status": "unavailable", "reason": reason]
}
guard memory.count == 65536, available.count == 65536 else {
return unavailable("A complete immutable memory and availability snapshot is required.")
}
let start = Int(s), limit = start + 64
guard limit <= 0xfe00 else { return unavailable("The actual S window crosses protected memory or wraps.") }
func ram(_ address: Int, _ count: Int) -> Bool {
guard address >= 0, count > 0, address <= 0xfe00 - count else { return false }
return (address / 8192...(address + count - 1) / 8192).allSatisfy {
physicalPages[$0].map { (0..<1024).contains($0) } == true
}
}
func readable(_ address: Int, _ count: Int) -> Bool {
ram(address, count) && available[address..<(address + count)].allSatisfy { $0 != 0 }
}
guard readable(start, 64) else {
return unavailable("Every byte of the actual S window must be available RAM with a physical mapping.")
}
let selected = map.projected(physicalPages: physicalPages, memory: memory, available: available)
guard selected.verifiesRuntime(memory: memory, available: available), readable(Int(pc), 1) else {
return unavailable("The current executable bytes or RAM mapping could not be verified.")
}
// Metadata must identify this same retained build. Use the supplied map's
// current bank projection, never a metadata object's stale projection.
let debug: CMOCVariableDebug?
if let metadata,
metadata.sourceMap.binarySHA256 == map.binarySHA256,
metadata.sourceMap.linkMapSHA256 == map.linkMapSHA256,
metadata.sourceMap.sourceHashes == map.sourceHashes,
metadata.sourceMap.objectHashes == map.objectHashes,
metadata.sourceMap.listingHashes == map.listingHashes {
debug = CMOCVariableDebug(functions: metadata.functions, variables: metadata.variables,
sourceMap: map).projected(physicalPages: physicalPages, memory: memory, available: available)
} else { debug = nil }
let function = debug?.entryFunction(containing: pc)
let instruction = selected.instruction(at: pc)
let mappedSource = instruction.map {
sharedPaths.contains($0.sourcePath) && !$0.bytes.isEmpty && readable(Int(pc), $0.bytes.count) &&
Array(memory[Int(pc)..<(Int(pc) + $0.bytes.count)]) == $0.bytes
} == true
let functionSource = function.map { sharedPaths.contains($0.sourcePath) } == true
let executableSource = selected.executableLocation(at: pc, memory: memory, available: available, sharedPaths: sharedPaths) != nil
guard mappedSource || functionSource || executableSource else {
return unavailable("The current PC has no verified executable identity in shared source.")
}
var spans: [[String: Any]] = [], cursor = start
while cursor < limit {
let end = min(limit, (cursor / 8192 + 1) * 8192)
spans.append(["logical_address": cursor, "physical_address": physicalPages[cursor / 8192]! * 8192 + cursor % 8192,
"count": end - cursor])
cursor = end
}
let words = stride(from: 0, to: 64, by: 2).map { offset -> [String: Any] in
["offset": offset, "address": start + offset,
"value": Int(memory[start + offset]) * 256 + Int(memory[start + offset + 1])]
}
var result: [String: Any] = [
"status": "available",
"stack_window": ["address": start, "count": 64, "bytes": Array(memory[start..<limit]),
"words_be": words, "physical_spans": spans, "interpretation": "uninterpreted"],
"caller": unavailable("No proven normal C call frame is available at this stop."),
"arguments": unavailable("Typed arguments require a verified normal CMOC frame and direct caller.")
]
guard let debug, let function, functionSource else { return result }
// These bytes must belong to verified executable guards, not merely be
// coincidentally present in writable RAM. No stack scanning is involved.
func guarded(_ address: Int, _ bytes: [UInt8], moduleID: String?) -> Bool {
guard readable(address, bytes.count) else { return false }
let guards: [(Int, [UInt8])]
if let layout = selected.bankedLayout {
guard let moduleID, selected.activeModuleIDs?.contains(moduleID) == true,
let module = layout.module(id: moduleID) else { return false }
guards = module.codeGuards.map { (Int($0.address), $0.bytes) }
} else {
guard moduleID == nil else { return false }
guards = selected.flatCodeGuards.map { (Int($0.address), $0.bytes) }
}
return bytes.enumerated().allSatisfy { offset, byte in
let location = address + offset
return memory[location] == byte && guards.contains { begin, data in
location >= begin && location - begin < data.count && data[location - begin] == byte
}
}
}
func normal(_ f: CMOCVariableDebug.Function) -> Bool {
f.frame && f.entry >= 0 && f.body >= f.entry + 4 && f.body < f.end && f.end <= 0xfe00 - 4 &&
guarded(f.entry, [0x34, 0x40, 0x33, 0xe4], moduleID: f.moduleID) &&
guarded(f.end, [0x32, 0xc4, 0x35, 0xc0], moduleID: f.moduleID)
}
guard normal(function) else { return result }
let frameBase: Int, returnAddress: Int, phase: String
if Int(pc) == function.entry {
frameBase = start - 2 // U after the proven, as-yet unexecuted PSHS U.
returnAddress = start; phase = "function_entry"
} else if Int(pc) >= function.body, Int(pc) < function.end, mappedSource,
Int(u) >= start, Int(u) <= limit - 4 {
frameBase = Int(u); returnAddress = frameBase + 2; phase = "mapped_body"
} else { return result }
// Only these two bytes, already inside the raw window, identify a
// potential caller. Never search other stack words for return addresses.
let returnPC = Int(memory[returnAddress]) * 256 + Int(memory[returnAddress + 1])
func target(_ i: CMOCProjectSourceMap.Instruction) -> Int? {
let b = i.bytes, address = Int(i.address)
switch b.count {
case 2 where b[0] == 0x8d: return (address + 2 + Int(Int8(bitPattern: b[1]))) & 0xffff
case 3 where b[0] == 0x17:
return (address + 3 + Int(Int16(bitPattern: UInt16(b[1]) << 8 | UInt16(b[2])))) & 0xffff
case 3 where b[0] == 0xbd: return Int(b[1]) * 256 + Int(b[2])
case 3 where b[0] == 0xad && b[1] == 0x8c:
return (address + 3 + Int(Int8(bitPattern: b[2]))) & 0xffff
case 4 where b[0] == 0xad && b[1] == 0x8d:
return (address + 4 + Int(Int16(bitPattern: UInt16(b[2]) << 8 | UInt16(b[3])))) & 0xffff
default: return nil // Indirect, tail, interrupt and guessed calls are unsupported.
}
}
let calls = selected.instructions.filter {
Int($0.address) + $0.bytes.count == returnPC && target($0) == function.entry
}
guard calls.count == 1, let call = calls.first, sharedPaths.contains(call.sourcePath),
guarded(Int(call.address), call.bytes, moduleID: call.moduleID),
let caller = debug.entryFunction(containing: call.address), normal(caller),
sharedPaths.contains(caller.sourcePath), caller.moduleID == call.moduleID,
caller.name.utf8.count <= 1024, caller.sourcePath.utf8.count <= 4096,
Int(call.address) >= caller.body else { return result }
result["caller"] = ["status": "available", "function": caller.name, "source_path": caller.sourcePath,
"source_line": call.sourceLine, "call_address": Int(call.address), "return_address": returnPC,
"evidence": "unique_verified_direct_call", "callee_phase": phase]
let parameters = debug.variables.filter {
$0.sourcePath == function.sourcePath && sharedPaths.contains($0.sourcePath) &&
$0.moduleID == function.moduleID && ($0.scopeModuleID == nil || $0.scopeModuleID == function.moduleID) &&
!$0.isStatic && $0.address == nil && $0.scope == (function.body..<function.end) && ($0.offset ?? 0) >= 4
}.sorted { ($0.offset ?? 0) < ($1.offset ?? 0) }
var items: [[String: Any]] = [], occupied = Set<Int>(), names = Set<String>()
for (index, parameter) in parameters.prefix(32).enumerated() {
guard let offset = parameter.offset, offset <= 32767,
!parameter.name.isEmpty, parameter.name.utf8.count <= 1024,
parameters.filter({ $0.name == parameter.name }).count == 1,
names.insert(parameter.name).inserted else { continue }
let address = frameBase + offset, type = parameter.type
guard type.kind == "integer", [1, 2, 4].contains(type.size), type.name.utf8.count <= 1024, let signed = type.signed,
address >= start, address <= limit - type.size,
!parameters.enumerated().contains(where: { otherIndex, other in
guard otherIndex != index, let otherOffset = other.offset,
otherOffset <= 32767, other.type.size > 0, other.type.size <= 65536 else { return false }
return offset < otherOffset + other.type.size && otherOffset < offset + type.size
}),
(address..<(address + type.size)).allSatisfy({ !occupied.contains($0) }) else { continue }
var value: Int64 = 0
for byte in memory[address..<(address + type.size)] { value = value * 256 + Int64(byte) }
if signed && memory[address] & 0x80 != 0 { value -= Int64(1) << (type.size * 8) }
occupied.formUnion(address..<(address + type.size))
items.append(["name": parameter.name, "type": type.name, "address": address, "frame_offset": offset,
"byte_count": type.size, "value": value, "evidence": "compiler_location_and_normal_cmoc_abi"])
}
result["arguments"] = ["status": items.isEmpty ? "unavailable" : "available", "items": items,
"reason": "Only compiler-located integer parameters wholly inside the actual S window are interpreted; other values remain unavailable.",
"all_recorded_parameters_available": !parameters.isEmpty && items.count == parameters.count,
"recorded_parameter_count": parameters.count]
return result
}
}