Files
prometeu-studio/tools/pbx-conformance/main.rs
T
bquarkz 603ed01227 feat(compiler): port runtime catalogs and enforce target ABI (AGD77)
Import both runtime catalogs and provenance, port all intrinsic metadata and exact constants, and validate target signatures and carriers through the common pipeline. Package matching compiler/SDK resources and add active parity plus production runtime conformance checks.

Validation: 420 compiler/PBS tests passed, with 12 existing skips; provider export, runtime execution and installed catalog checks passed. The pre-existing Gfx.clear typed-metadata failure remains active and assigned to AGD78 under the explicitly accepted scope revision recorded in LSN-0080.
2026-10-15 13:07:49 +01:00

411 lines
15 KiB
Rust

use prometeu_bytecode::Value;
use prometeu_bytecode::load_limits::{LoadBudget, LoadLimits};
use prometeu_hal::syscalls::caps;
use prometeu_vm::{
HostContext, HostReturn, NativeInterface, ValidatedProgramImage, VirtualMachine,
};
struct HasCart(usize);
impl NativeInterface for HasCart {
fn syscall(
&mut self,
id: u32,
args: &[Value],
ret: &mut HostReturn,
_: &mut HostContext,
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
assert_eq!(id, 1);
assert!(args.is_empty());
self.0 += 1;
ret.push_bool(false);
Ok(())
}
}
struct NoNative;
impl NativeInterface for NoNative {
fn syscall(
&mut self,
_: u32,
_: &[Value],
_: &mut HostReturn,
_: &mut HostContext,
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
panic!("fixture unexpectedly invoked native code")
}
}
fn main() {
let root = std::path::PathBuf::from(std::env::args().nth(1).expect("fixture directory"));
verify_catalog_fixtures(&root);
for name in [
"minimal",
"jump-end",
"vec2-signature",
"closure-capture",
"trait-call",
"array-dynamic",
"common-pipeline",
"roles",
"join",
"memcard-role",
"intrinsic-dot",
] {
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
let image = ValidatedProgramImage::load(
&bytes,
&mut LoadBudget::new(LoadLimits::default()),
caps::NONE,
)
.unwrap_or_else(|e| panic!("{name}: {e:?}"));
println!("LOAD PASS {name}");
if name != "vec2-signature" {
let mut vm = VirtualMachine::from_image(image, Default::default());
vm.prepare_boot_call().unwrap();
let report = vm
.run_budget(1000, &mut NoNative, &mut HostContext::new(None))
.unwrap();
let reason = format!("{:?}", report.reason);
assert!(
reason == "Halted" || reason == "EndOfRom",
"{name}: {report:?}"
);
if name == "closure-capture" || name == "trait-call" {
assert!(matches!(vm.operand_stack_top(1)[0], Value::Int32(42)));
}
if name == "intrinsic-dot" {
assert!(
matches!(vm.operand_stack_top(1)[0], Value::Float(value) if value.to_bits() == 11f64.to_bits())
);
}
if name == "array-dynamic" {
assert!(matches!(vm.operand_stack_top(1)[0], Value::Int32(0)));
}
println!(
"EXEC PASS {name}: {reason}, {} steps",
report.steps_executed
);
}
}
for name in ["native", "unknown-native", "native-abi", "unused-native"] {
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
if name == "native" {
let image = ValidatedProgramImage::load(
&bytes,
&mut LoadBudget::new(LoadLimits::default()),
caps::SYSTEM,
)
.unwrap();
let mut vm = VirtualMachine::from_image(image, Default::default());
vm.prepare_boot_call().unwrap();
let mut native = HasCart(0);
let report = vm
.run_budget(1000, &mut native, &mut HostContext::new(None))
.unwrap();
assert_eq!(native.0, 1);
assert_eq!(format!("{:?}", report.reason), "Halted");
println!("BIND + EXEC PASS native with SYSTEM");
}
let capabilities = if name == "native" {
caps::NONE
} else {
caps::SYSTEM
};
let error = ValidatedProgramImage::load(
&bytes,
&mut LoadBudget::new(LoadLimits::default()),
capabilities,
)
.unwrap_err();
record_fault(&root, name, error);
}
let baseline = std::fs::read(root.join("minimal.pbx")).unwrap();
for (name, offset, value) in [
("version", 4, 1),
("unsupported-section", 116, 9),
("unknown-builtin", 178, 0),
("invalid-role", 136, 4),
("retired-opcode", 162, 0x54),
] {
let mut bytes = baseline.clone();
bytes[offset] = value;
reject(&root, name, &bytes, LoadLimits::default());
}
for (name, code, max) in [
("raw-syscall", vec![0x70, 0, 1, 0, 0, 0, 1, 0], 0),
("hostcall-index", vec![0x71, 0, 0, 0, 0, 0, 1, 0], 0),
(
"retired-spawn",
vec![0x54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
0,
),
("retired-yield", vec![0x55, 0, 1, 0], 0),
("retired-sleep", vec![0x56, 0, 0, 0, 0, 0, 1, 0], 0),
(
"unreachable-reference",
vec![1, 0, 0x50, 0, 255, 255, 255, 255],
0,
),
(
"nonfinite",
vec![1, 0, 0x15, 0, 0, 0, 0, 0, 0, 0, 0xf0, 0x7f],
0,
),
("jump-immediate", vec![2, 0, 3, 0, 0, 0, 1, 0], 0),
("zero-max", vec![0x17, 0, 0, 0, 0, 0, 1, 0], 0),
("return-height", vec![0x17, 0, 0, 0, 0, 0, 0x51, 0], 1),
("fallthrough", vec![0, 0], 0),
] {
let mut functions = section(&baseline, 1).to_vec();
functions[18..22].copy_from_slice(&(code.len() as u32).to_le_bytes());
functions[26..30].copy_from_slice(&(max as u32).to_le_bytes());
let bytes = replace(&replace(&baseline, 1, &functions), 2, &code);
reject(&root, name, &bytes, LoadLimits::default());
}
// Two mutually recursive Array declarations: a structural cycle, with valid IDs.
reject(
&root,
"array-cycle",
&replace(
&baseline,
6,
&[2, 0, 0, 0, 2, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0],
),
LoadLimits::default(),
);
reject(
&root,
"structural-cycle",
&replace(
&baseline,
6,
&[
2, 0, 0, 0, 4, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,
],
),
LoadLimits::default(),
);
reject(
&root,
"invalid-type-reference",
&replace(&baseline, 6, &[1, 0, 0, 0, 2, 0, 99, 0, 0, 0]),
LoadLimits::default(),
);
reject(
&root,
"invalid-utf8",
&replace(
&baseline,
6,
&[1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 255, 0x13, 0, 0, 0],
),
LoadLimits::default(),
);
reject(
&root,
"removed-input",
&replace(&baseline, 6, &[1, 0, 0, 0, 0, 0, 0, 1, 0, 0]),
LoadLimits::default(),
);
let mut overlap = baseline.clone();
overlap[36..40].copy_from_slice(&0u32.to_le_bytes());
reject(&root, "overlap", &overlap, LoadLimits::default());
reject(
&root,
"truncated",
&baseline[..baseline.len() - 1],
LoadLimits::default(),
);
let mut duplicate = baseline.clone();
duplicate[44..48].copy_from_slice(&0u32.to_le_bytes());
reject(
&root,
"duplicate-section",
&duplicate,
LoadLimits::default(),
);
reject(
&root,
"empty-entry",
&replace(&replace(&baseline, 1, &[0, 0, 0, 0]), 8, &[0, 0, 0, 0]),
LoadLimits::default(),
);
reject(
&root,
"resource-types",
&baseline,
LoadLimits {
types: 0,
..Default::default()
},
);
reject(
&root,
"resource-scratch",
&baseline,
LoadLimits {
temporary_bytes: 0,
..Default::default()
},
);
reject(
&root,
"resource",
&baseline,
LoadLimits {
work: 0,
..Default::default()
},
);
}
fn verify_catalog_fixtures(root: &std::path::Path) {
use prometeu_vm::LogicalFrameEndingReason as End;
let mut random_cycles = None;
for name in ["catalog-random-off", "catalog-random-on", "catalog-constants", "catalog-vec2-zero", "catalog-input", "catalog-string"] {
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
.unwrap_or_else(|error| panic!("{name}: {error:?}"));
println!("LOAD PASS {name}");
let mut vm = VirtualMachine::from_image(image, Default::default());
vm.prepare_boot_call().unwrap();
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
if name == "catalog-input" {
assert!(matches!(report.reason, End::Trap(ref trap) if trap.code == prometeu_bytecode::TRAP_UNAVAILABLE));
println!("EXEC PASS {name}: TRAP_UNAVAILABLE (known query, no hardware)");
continue;
}
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
if name.starts_with("catalog-random-") {
// Independent seed-42 vector and unit-range consumption from the provider handoff/tests.
assert_eq!(vm.operand_stack_top(3), vec![
Value::Int64(0xF9090E529A7DAE00u64 as i64), Value::Int64(-7),
Value::Float(f64::from_bits(0x3FB304AA46C98538)),
], "{name}: aliasing, discarded first next, mixed operations and exact order");
if let Some(cycles) = random_cycles { assert_eq!(report.cycles_used, cycles, "optimization changed charged work"); }
random_cycles = Some(report.cycles_used);
} else if name == "catalog-vec2-zero" {
assert_eq!(vm.operand_stack_top(2), vec![Value::Float(0.0), Value::Float(0.0)]);
} else if name == "catalog-string" {
assert_eq!(vm.operand_stack_top(1), vec![Value::Int64(0xAABBCCDD)]);
} else {
let mut constants: Vec<_> = prometeu_vm::builtin_constant_catalog().collect();
constants.sort_by_key(|constant| constant.key.key());
let mut expected = Vec::new();
for constant in constants { expected.extend(constant.materialize().unwrap()); }
expected.reverse();
let actual = vm.operand_stack_top(expected.len());
assert_eq!(actual.len(), 16);
for (actual, expected) in actual.iter().zip(expected.iter()) {
match (actual, expected) {
(Value::Float(a), Value::Float(b)) => assert_eq!(a.to_bits(), b.to_bits()),
_ => assert_eq!(actual, expected),
}
}
}
println!("EXEC PASS {name}: {} cycles, {} steps", report.cycles_used, report.steps_executed);
}
let removed = std::fs::read(root.join("catalog-removed.pbx")).unwrap();
reject(root, "catalog-removed", &removed, LoadLimits::default());
let null_string = std::fs::read(root.join("catalog-null-string.pbx")).unwrap();
reject(root, "catalog-null-string", &null_string, LoadLimits::default());
}
fn reject(root: &std::path::Path, name: &str, bytes: &[u8], limits: LoadLimits) {
let error =
ValidatedProgramImage::load(bytes, &mut LoadBudget::new(limits), caps::NONE).unwrap_err();
record_fault(root, name, error);
}
fn record_fault(root: &std::path::Path, name: &str, error: prometeu_vm::VmInitError) {
if let prometeu_vm::VmInitError::RegistryLoadFailed(ref failure) = error {
let expected = match name {
"array-cycle" => Some("ArrayCycle"),
"structural-cycle" => Some("StructuralTypeCycle"),
"invalid-type-reference" => Some("TypeId"),
"invalid-utf8" => Some("Utf8"),
"removed-input" => Some("Builtin"),
"retired-spawn" | "retired-yield" | "retired-sleep" => Some("RemovedOpcode"),
"nonfinite" => Some("NonFiniteValue"),
"unreachable-reference" => Some("FunctionId"),
"return-height" => Some("ReturnHeight"),
"fallthrough" => Some("UnterminatedPath"),
"zero-max" => Some("StackOverflow"),
"duplicate-section" => Some("DuplicateSection"),
_ => None,
};
if let Some(reason) = expected {
assert_eq!(format!("{:?}", failure.reason), reason, "{name}");
}
}
let report = prometeu_system::CrashReport::VmInit { error };
assert_eq!(report.pc(), None);
let fault = serde_json::json!({"kind":"vm_init", "pc":null, "summary":"Conformance fixture", "initError":report.init_diagnostic().unwrap()});
let full: serde_json::Value = serde_json::from_slice(
&std::fs::read(std::env::args().nth(2).expect("schema path")).unwrap(),
)
.unwrap();
let schema = jsonschema::validator_for(
&serde_json::json!({"$defs":full["$defs"],"$ref":"#/$defs/fault"}),
)
.unwrap();
if !schema.is_valid(&fault) {
let reason = fault["initError"]["load"]["reason"].as_str().unwrap();
assert!(
["LifecycleRole", "NonFiniteValue"].contains(&reason),
"unexpected schema failure: {fault}"
);
// Validate the ORIGINAL payload with only the observed missing enum value added.
// This is an explicit upstream defect report, not a claim of published-schema conformance.
let mut corrected = full.clone();
corrected["$defs"]["loadFailure"]["properties"]["reason"]["enum"]
.as_array_mut()
.unwrap()
.push(serde_json::json!(reason));
jsonschema::validator_for(
&serde_json::json!({"$defs":corrected["$defs"],"$ref":"#/$defs/fault"}),
)
.unwrap()
.validate(&fault)
.unwrap();
println!(
"UPSTREAM SCHEMA GAP: {reason} missing from published enum; original payload preserved"
);
}
std::fs::write(
root.join(format!("fault-{name}.json")),
serde_json::to_vec_pretty(&fault).unwrap(),
)
.unwrap();
println!("REJECT PASS {name}: {}", fault["initError"]);
}
fn word(bytes: &[u8], at: usize) -> usize {
u32::from_le_bytes(bytes[at..at + 4].try_into().unwrap()) as usize
}
fn section(bytes: &[u8], kind: usize) -> &[u8] {
for i in 0..word(bytes, 8) {
let at = 32 + 12 * i;
if word(bytes, at) == kind {
let offset = word(bytes, at + 4);
return &bytes[offset..offset + word(bytes, at + 8)];
}
}
panic!("missing section {kind}")
}
fn replace(bytes: &[u8], kind: usize, payload: &[u8]) -> Vec<u8> {
let count = word(bytes, 8);
let mut output = bytes[..32 + 12 * count].to_vec();
for i in 0..count {
let at = 32 + 12 * i;
let body = if word(bytes, at) == kind {
payload
} else {
section(bytes, word(bytes, at))
};
let offset = output.len() as u32;
output[at + 4..at + 8].copy_from_slice(&offset.to_le_bytes());
output[at + 8..at + 12].copy_from_slice(&(body.len() as u32).to_le_bytes());
output.extend_from_slice(body);
}
output
}