feat(vm)!: implement typed callables and single-context execution
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Add structural Fn signatures, typed capture environments, indirect calls and Trait dispatch while preserving logical parameter and result groups, ownership and budgets. Remove guest coroutine execution and legacy loading. Activate bounded sealed PBX v1 with mandatory capture metadata, preserve frame continuations and root return results, and migrate producers and shipped cartridges. Publish coordinated specs, handoffs and the completed runtime lesson. Validation: 880 workspace tests passed, 9 existing tests ignored; both cartridges completed six production-host frames.
This commit is contained in:
@@ -1,9 +1,11 @@
|
||||
use prometeu_bytecode::registry::FunctionDecl;
|
||||
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
use prometeu_bytecode::SourceSpan;
|
||||
use prometeu_bytecode::assembler::assemble;
|
||||
use prometeu_bytecode::model::{BytecodeModule, DebugInfo, Export, FunctionMeta, SyscallDecl};
|
||||
use prometeu_bytecode::model::{DebugInfo, Export, SyscallDecl};
|
||||
use prometeu_hal::InputSignals;
|
||||
use prometeu_hal::app_mode::AppMode;
|
||||
use prometeu_hal::color::Color;
|
||||
@@ -487,9 +489,9 @@ fn color_program() -> Vec<u8> {
|
||||
INTRINSIC 0x210E\n"));
|
||||
let jump_to_blue = rom.len() + 2;
|
||||
rom.extend(asm("JMP_IF_FALSE 0"));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nRET\n")));
|
||||
let blue_at = rom.len() as u32;
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nRET\n")));
|
||||
rom[jump_to_blue..jump_to_blue + 4].copy_from_slice(&blue_at.to_le_bytes());
|
||||
module(rom, color_syscalls())
|
||||
}
|
||||
@@ -497,20 +499,20 @@ fn color_program() -> Vec<u8> {
|
||||
fn input_edge_program() -> Vec<u8> {
|
||||
let mut rom = Vec::new();
|
||||
let pressed_jump = emit_right_predicate(&mut rom, 0x210C);
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nRET\n")));
|
||||
let released_at = rom.len() as u32;
|
||||
rom[pressed_jump..pressed_jump + 4].copy_from_slice(&released_at.to_le_bytes());
|
||||
|
||||
let released_jump = emit_right_predicate(&mut rom, 0x210D);
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nRET\n")));
|
||||
let down_at = rom.len() as u32;
|
||||
rom[released_jump..released_jump + 4].copy_from_slice(&down_at.to_le_bytes());
|
||||
|
||||
let down_jump = emit_right_predicate(&mut rom, 0x210E);
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nRET\n")));
|
||||
let idle_at = rom.len() as u32;
|
||||
rom[down_jump..down_jump + 4].copy_from_slice(&idle_at.to_le_bytes());
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nRET\n")));
|
||||
|
||||
module(rom, gfx_syscalls())
|
||||
}
|
||||
@@ -525,20 +527,20 @@ fn emit_right_predicate(rom: &mut Vec<u8>, predicate: u32) -> usize {
|
||||
fn touch_edge_program() -> Vec<u8> {
|
||||
let mut rom = Vec::new();
|
||||
let pressed_jump = emit_touch_predicate(&mut rom, 0x2130);
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nRET\n")));
|
||||
let released_at = rom.len() as u32;
|
||||
rom[pressed_jump..pressed_jump + 4].copy_from_slice(&released_at.to_le_bytes());
|
||||
|
||||
let released_jump = emit_touch_predicate(&mut rom, 0x2131);
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nRET\n")));
|
||||
let down_at = rom.len() as u32;
|
||||
rom[released_jump..released_jump + 4].copy_from_slice(&down_at.to_le_bytes());
|
||||
|
||||
let down_jump = emit_touch_predicate(&mut rom, 0x2132);
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nRET\n")));
|
||||
let idle_at = rom.len() as u32;
|
||||
rom[down_jump..down_jump + 4].copy_from_slice(&idle_at.to_le_bytes());
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nRET\n")));
|
||||
|
||||
module(rom, gfx_syscalls())
|
||||
}
|
||||
@@ -557,7 +559,7 @@ fn emit_touch_predicate(rom: &mut Vec<u8>, predicate: u32) -> usize {
|
||||
fn fault_program() -> Vec<u8> {
|
||||
// `INTRINSIC 0xDEADBEEF` is rejected by the loader as `VerificationFailed`.
|
||||
// `TRAP` is a legal instruction that becomes `CrashReport::VmTrap` at runtime.
|
||||
module(asm("TRAP\nFRAME_SYNC\nRET\n"), vec![])
|
||||
module(asm("TRAP\nRET\n"), vec![])
|
||||
}
|
||||
|
||||
fn delayed_fault_program() -> Vec<u8> {
|
||||
@@ -567,7 +569,7 @@ fn delayed_fault_program() -> Vec<u8> {
|
||||
rom.extend(asm("JMP_IF_FALSE 0\nTRAP\n"));
|
||||
let continue_at = rom.len() as u32;
|
||||
rom[continue_jump..continue_jump + 4].copy_from_slice(&continue_at.to_le_bytes());
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nRET\n")));
|
||||
module(rom, gfx_syscalls())
|
||||
}
|
||||
|
||||
@@ -575,7 +577,7 @@ fn multi_tick_program() -> Vec<u8> {
|
||||
let mut rom = asm("PUSH_I32 30000\nSET_LOCAL 0\n");
|
||||
let loop_at = rom.len() as u32;
|
||||
rom.extend(asm("GET_LOCAL 0\nPUSH_I32 1\nSUB\nSET_LOCAL 0\nGET_LOCAL 0\nPUSH_I32 0\nGT\n"));
|
||||
rom.extend(asm(&format!("JMP_IF_TRUE {loop_at}\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("JMP_IF_TRUE {loop_at}\nRET\n")));
|
||||
module_with_locals(rom, vec![], 1)
|
||||
}
|
||||
|
||||
@@ -613,16 +615,16 @@ fn module(code: Vec<u8>, syscalls: Vec<SyscallDecl>) -> Vec<u8> {
|
||||
}
|
||||
|
||||
fn module_with_locals(code: Vec<u8>, syscalls: Vec<SyscallDecl>, local_slots: u16) -> Vec<u8> {
|
||||
BytecodeModule {
|
||||
version: 0,
|
||||
TestProgram {
|
||||
const_pool: vec![],
|
||||
functions: vec![FunctionMeta {
|
||||
functions: vec![FunctionDecl {
|
||||
code_offset: 0,
|
||||
code_len: code.len() as u32,
|
||||
param_slots: 0,
|
||||
local_slots,
|
||||
return_slots: 0,
|
||||
local_slots: u32::from(local_slots),
|
||||
max_stack_slots: 8,
|
||||
signature: int64_signature(0, 0),
|
||||
captures: vec![],
|
||||
name: None,
|
||||
}],
|
||||
code,
|
||||
debug_info: Some(DebugInfo {
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
//! Independent catalogue and execution oracles for the fixed input ABI.
|
||||
use prometeu_bytecode::{TRAP_INVALID_INTRINSIC, TRAP_UNAVAILABLE, Value, assembler::assemble};
|
||||
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
use prometeu_vm::ValidatedProgramImage;
|
||||
// Independent catalogue and execution oracles for the fixed input ABI.
|
||||
use prometeu_bytecode::{TRAP_UNAVAILABLE, Value, assembler::assemble};
|
||||
use prometeu_drivers::TestPlatform;
|
||||
use prometeu_hal::{InputSignals, RuntimePlatform, vm_fault::VmFault};
|
||||
use prometeu_vm::{
|
||||
@@ -188,7 +190,7 @@ fn vm_queries_charge_one_cycle_each_and_allocate_no_guest_objects() {
|
||||
for id in 0x2100..=0x2135 {
|
||||
source.push_str(&format!("INTRINSIC {id}\n"));
|
||||
}
|
||||
let mut vm = VirtualMachine::new(assemble(&source).unwrap(), vec![]);
|
||||
let mut vm = query_vm(assemble(&(source + "HALT\n")).unwrap());
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let objects = vm.heap().len();
|
||||
let mut platform = TestPlatform::new();
|
||||
@@ -216,16 +218,36 @@ fn every_known_query_faults_when_unavailable_and_rejects_arguments() {
|
||||
(meta.implementation)(&[Value::Int64(0)], &mut ctx),
|
||||
Err(IntrinsicExecutionError::ArityMismatch { expected: 0, got: 1 })
|
||||
);
|
||||
let mut vm = VirtualMachine::new(assemble(&format!("INTRINSIC {id}\n")).unwrap(), vec![]);
|
||||
let mut vm = query_vm(assemble(&format!("INTRINSIC {id}\nHALT")).unwrap());
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let report = vm.run_budget(10, &mut NoSyscalls, &mut ctx).unwrap();
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
||||
if trap.code == TRAP_UNAVAILABLE && trap.pc == 0));
|
||||
assert!(vm.operand_stack_top(1).is_empty());
|
||||
}
|
||||
let mut vm = VirtualMachine::new(assemble("INTRINSIC 0x2136\n").unwrap(), vec![]);
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let report = vm.run_budget(10, &mut NoSyscalls, &mut HostContext::new(None)).unwrap();
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
||||
if trap.code == TRAP_INVALID_INTRINSIC));
|
||||
let bytes = TestProgram::single(
|
||||
assemble("INTRINSIC 0x2136\nHALT").unwrap(),
|
||||
int64_signature(0, 0),
|
||||
0,
|
||||
64,
|
||||
)
|
||||
.serialize();
|
||||
let error = ValidatedProgramImage::load(
|
||||
&bytes,
|
||||
&mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()),
|
||||
0,
|
||||
)
|
||||
.unwrap_err();
|
||||
assert!(matches!(error, prometeu_vm::VmInitError::RegistryLoadFailed(_)));
|
||||
}
|
||||
|
||||
fn query_vm(code: Vec<u8>) -> VirtualMachine {
|
||||
let bytes = TestProgram::single(code, int64_signature(0, 0), 0, 64).serialize();
|
||||
let image = ValidatedProgramImage::load(
|
||||
&bytes,
|
||||
&mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()),
|
||||
0,
|
||||
)
|
||||
.unwrap();
|
||||
VirtualMachine::from_image(image, Default::default())
|
||||
}
|
||||
|
||||
@@ -0,0 +1,248 @@
|
||||
#[allow(dead_code)]
|
||||
#[path = "../../../console/prometeu-vm/tests/support/callables.rs"]
|
||||
mod callables;
|
||||
use callables::{bytes, sig};
|
||||
use prometeu_bytecode::{Value, registry::TypeId};
|
||||
use prometeu_host_headless::{AdvanceFrameOutcome, HeadlessHost};
|
||||
|
||||
fn cartridge(program: &[u8], name: &str) -> std::path::PathBuf {
|
||||
let dir =
|
||||
std::env::temp_dir().join(format!("prometeu-typed-runtime-{}-{name}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(dir.join("program.pbx"), program).unwrap();
|
||||
std::fs::write(dir.join("manifest.json"),r#"{"magic":"PMTU","cartridge_version":1,"app_id":77,"title":"Typed runtime","app_version":"1.0.0","app_mode":"Game","capabilities":[]}"#).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_in_callee_or_closure_resumes_next_pc_with_locals_and_init_once() {
|
||||
for captured in [false, true] {
|
||||
let root = "GET_GLOBAL 0\nPUSH_I32 0\nEQ\nJMP_IF_FALSE 52\nPUSH_I32 1\nSET_GLOBAL 0\nGET_GLOBAL 1\nPUSH_I32 1\nADD\nSET_GLOBAL 1\nGET_GLOBAL 2\nPUSH_I32 1\nADD\nSET_GLOBAL 2\nCALL 1\nGET_GLOBAL 1\nGET_GLOBAL 2\nGET_GLOBAL 3\nRET";
|
||||
let callee = "PUSH_I32 73\nSET_LOCAL 0\nFRAME_SYNC\nGET_LOCAL 0\nSET_GLOBAL 3\nRET";
|
||||
let adapter = "PUSH_I32 73\nMAKE_CLOSURE fn=2,type=9\nCALL_CLOSURE 9\nRET";
|
||||
let closure = "GET_CAPTURE 0\nSET_LOCAL 0\nFRAME_SYNC\nGET_LOCAL 0\nSET_GLOBAL 3\nRET";
|
||||
let mut bodies = vec![
|
||||
(root, sig(&[], &[0, 0, 0]), vec![]),
|
||||
(if captured { adapter } else { callee }, sig(&[], &[]), vec![]),
|
||||
];
|
||||
if captured {
|
||||
bodies.push((closure, sig(&[], &[]), vec![TypeId(0)]));
|
||||
}
|
||||
let program = bytes(&bodies, vec![], &[]).unwrap();
|
||||
let dir = cartridge(&program, if captured { "closure" } else { "callee" });
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
for entry in 1..=3 {
|
||||
let AdvanceFrameOutcome::FrameCompleted { logical_frame_index: sync, .. } =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("sync failed {:?}", host.get_fault())
|
||||
};
|
||||
assert_eq!(sync, (entry * 2 - 1) as u64);
|
||||
let sync_pc = host.get_state().pc;
|
||||
assert!(sync_pc > 0);
|
||||
let first = host.capture_frame().unwrap();
|
||||
let AdvanceFrameOutcome::FrameCompleted { logical_frame_index: completion, .. } =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("root failed {:?}", host.get_fault())
|
||||
};
|
||||
assert_eq!(completion, (entry * 2) as u64);
|
||||
assert_eq!(
|
||||
&*host.get_state().stack_top,
|
||||
&[Value::Int32(73), Value::Int32(entry), Value::Int32(1)]
|
||||
);
|
||||
let second = host.capture_frame().unwrap();
|
||||
assert_ne!(first.frame.frame_id, second.frame.frame_id);
|
||||
}
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regenerated_cartridges_run_six_complete_frames_on_production_host() {
|
||||
use prometeu_hal::{
|
||||
HostContext, HostReturn, NativeInterface,
|
||||
syscalls::{Syscall, caps},
|
||||
};
|
||||
struct Effects {
|
||||
scene_binds: usize,
|
||||
frame_commands: usize,
|
||||
}
|
||||
impl NativeInterface for Effects {
|
||||
fn syscall(
|
||||
&mut self,
|
||||
id: u32,
|
||||
_: &[Value],
|
||||
results: &mut HostReturn,
|
||||
_: &mut HostContext,
|
||||
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
||||
let syscall = Syscall::from_u32(id).unwrap();
|
||||
if syscall == Syscall::ComposerBindScene {
|
||||
self.scene_binds += 1;
|
||||
}
|
||||
if matches!(syscall, Syscall::GfxClear | Syscall::ComposerSetCamera) {
|
||||
self.frame_commands += 1;
|
||||
}
|
||||
for _ in 0..syscall.results_count() {
|
||||
results.push_int(0);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
let root =
|
||||
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..").join("test-cartridges");
|
||||
for name in ["dummy-boy", "stress-console"] {
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(root.join(name).to_string_lossy()).unwrap();
|
||||
let mut hashes = vec![];
|
||||
for expected in 1..=6 {
|
||||
let AdvanceFrameOutcome::FrameCompleted { logical_frame_index, .. } =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("{name}: {:?}", host.get_fault())
|
||||
};
|
||||
assert_eq!(logical_frame_index, expected);
|
||||
let frame = host.capture_frame().unwrap();
|
||||
hashes.push(
|
||||
frame
|
||||
.frame
|
||||
.pixels
|
||||
.iter()
|
||||
.fold(0u64, |sum, &p| sum.wrapping_mul(31).wrapping_add(p as u64)),
|
||||
);
|
||||
assert_eq!(frame.logical_frame_index, expected);
|
||||
}
|
||||
assert!(hashes.windows(2).all(|h| h[0] != h[1]), "{name} visuals did not progress");
|
||||
assert!(host.get_fault().is_none());
|
||||
// Observe the original program's one-time scene binding separately
|
||||
// from the real host's visual smoke; no guest globals are exposed.
|
||||
let program = std::fs::read(root.join(name).join("program.pbx")).unwrap();
|
||||
let image = prometeu_vm::ValidatedProgramImage::load(
|
||||
&program,
|
||||
&mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()),
|
||||
caps::ALL,
|
||||
)
|
||||
.unwrap();
|
||||
let mut vm = prometeu_vm::VirtualMachine::from_image(image, Default::default());
|
||||
let mut effects = Effects { scene_binds: 0, frame_commands: 0 };
|
||||
for _ in 0..6 {
|
||||
vm.prepare_boot_call().unwrap();
|
||||
assert_eq!(
|
||||
vm.run_budget(1_000_000, &mut effects, &mut HostContext::new(None)).unwrap().reason,
|
||||
prometeu_vm::LogicalFrameEndingReason::EndOfRom,
|
||||
);
|
||||
}
|
||||
assert_eq!(effects.frame_commands, 6);
|
||||
assert_eq!(effects.scene_binds, usize::from(name == "stress-console"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn budget_exhaustion_inside_fn_keeps_the_same_open_logical_frame() {
|
||||
let mut body = "NOP\n".repeat(260_000);
|
||||
body.push_str("GET_CAPTURE 0\nRET");
|
||||
let program = bytes(
|
||||
&[
|
||||
("PUSH_I32 37\nMAKE_CLOSURE fn=1,type=4\nCALL_CLOSURE 4\nRET", sig(&[], &[0]), vec![]),
|
||||
(&body, sig(&[], &[0]), vec![TypeId(0)]),
|
||||
],
|
||||
vec![],
|
||||
&[],
|
||||
)
|
||||
.unwrap();
|
||||
let dir = cartridge(&program, "budget");
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
let before = host.get_state();
|
||||
assert!(matches!(
|
||||
host.advance_frame().unwrap(),
|
||||
AdvanceFrameOutcome::FrameCompleted { logical_frame_index: 1, .. }
|
||||
));
|
||||
let after = host.get_state();
|
||||
assert!(after.tick_index >= before.tick_index + 2);
|
||||
assert_eq!(&*after.stack_top, &[Value::Int32(37)]);
|
||||
assert_eq!(host.capture_frame().unwrap().logical_frame_index, 1);
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn active_host_preserves_removed_opcode_load_context_and_null_fn_trap() {
|
||||
let mut program = bytes(&[("HALT", sig(&[], &[]), vec![])], vec![], &[]).unwrap();
|
||||
let mut budget = prometeu_bytecode::load_limits::LoadBudget::new(Default::default());
|
||||
let code = prometeu_bytecode::registry_codec::PbxEnvelope::parse(&program, &mut budget)
|
||||
.unwrap()
|
||||
.section(2)
|
||||
.unwrap()
|
||||
.offset;
|
||||
program[code..code + 2].copy_from_slice(&0x55u16.to_le_bytes());
|
||||
let dir = cartridge(&program, "removed");
|
||||
let mut host = HeadlessHost::new();
|
||||
let Err(prometeu_host_headless::HostError::BootFailed { report: Some(report), .. }) =
|
||||
host.boot(dir.to_string_lossy())
|
||||
else {
|
||||
panic!("invalid opcode must fail boot")
|
||||
};
|
||||
let diagnostic = report.init_diagnostic().unwrap();
|
||||
assert_eq!(diagnostic["load"]["code"], "LOAD_INVALID_CODE");
|
||||
assert_eq!(diagnostic["load"]["reason"], "RemovedOpcode");
|
||||
assert_eq!(diagnostic["load"]["section"], 2);
|
||||
assert_eq!(diagnostic["load"]["function"], 0);
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
let program = bytes(
|
||||
&[(
|
||||
"STRUCT_NEW 15\nSTRUCT_GET type=15,field=0\nCALL_CLOSURE 4\nRET",
|
||||
sig(&[], &[0]),
|
||||
vec![],
|
||||
)],
|
||||
vec![],
|
||||
&[],
|
||||
)
|
||||
.unwrap();
|
||||
let dir = cartridge(&program, "null");
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
let AdvanceFrameOutcome::Faulted(prometeu_system::CrashReport::VmTrap { trap }) =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("null callback must trap")
|
||||
};
|
||||
assert_eq!(
|
||||
(trap.code, trap.opcode, trap.pc),
|
||||
(prometeu_bytecode::TRAP_NULL_REFERENCE, 0x53, 16)
|
||||
);
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_native_argument_fault_inside_callback_reaches_active_host() {
|
||||
let program = callables::bytes_with_syscalls(
|
||||
&[
|
||||
("MAKE_CLOSURE fn=1,type=9\nCALL_CLOSURE 9\nRET", sig(&[], &[]), vec![]),
|
||||
("PUSH_BOOL 1\nSET_GLOBAL 0\nGET_GLOBAL 0\nHOSTCALL 0\nRET", sig(&[], &[]), vec![]),
|
||||
],
|
||||
vec![],
|
||||
&[],
|
||||
&[prometeu_bytecode::model::SyscallDecl {
|
||||
module: "gfx2d".into(),
|
||||
name: "clear".into(),
|
||||
version: 1,
|
||||
arg_slots: 1,
|
||||
ret_slots: 0,
|
||||
}],
|
||||
)
|
||||
.unwrap();
|
||||
let dir = cartridge(&program, "native-fault");
|
||||
std::fs::write(dir.join("manifest.json"), r#"{"magic":"PMTU","cartridge_version":1,"app_id":77,"title":"Typed runtime","app_version":"1.0.0","app_mode":"Game","capabilities":["gfx2d"]}"#).unwrap();
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
let AdvanceFrameOutcome::Faulted(report @ prometeu_system::CrashReport::VmTrap { .. }) =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("clear requires an integer color carrier")
|
||||
};
|
||||
let prometeu_system::CrashReport::VmTrap { trap } = &report else { unreachable!() };
|
||||
assert_eq!((trap.code, trap.opcode, trap.pc), (prometeu_bytecode::TRAP_TYPE, 0x70, 33));
|
||||
assert_eq!(host.get_fault().as_ref(), Some(&report));
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
Reference in New Issue
Block a user