Intrepid/Prometeu/Runtime/pipeline/pr-master There was a failure building this commit
3896 lines
150 KiB
Rust
3896 lines
150 KiB
Rust
use crate::numeric;
|
|
use crate::resource_budget::BudgetVec;
|
|
mod callable;
|
|
mod collections;
|
|
#[cfg(test)]
|
|
mod collections_tests;
|
|
mod control;
|
|
mod dynamic;
|
|
mod gc;
|
|
mod lifecycle;
|
|
mod loader;
|
|
mod native_arrays;
|
|
mod random;
|
|
mod reference;
|
|
mod runtime;
|
|
mod stack;
|
|
mod strings;
|
|
mod typed;
|
|
#[cfg(test)]
|
|
mod typed_tests;
|
|
|
|
use crate::call_frame::CallFrame;
|
|
use crate::heap::Heap;
|
|
use crate::lookup_intrinsic_by_id;
|
|
use crate::resource_budget::{ResourceFailure, RuntimeBudget, RuntimeLimits, RuntimeResource};
|
|
use crate::roots::{RootVisitor, visit_value_for_roots};
|
|
use crate::vm_init_error::VmInitError;
|
|
use crate::{HostContext, NativeInterface};
|
|
use prometeu_bytecode::HeapRef;
|
|
use prometeu_bytecode::ProgramImage;
|
|
use prometeu_bytecode::Value;
|
|
#[cfg(test)]
|
|
use prometeu_bytecode::decode_next;
|
|
use prometeu_bytecode::isa::core::CoreOpCode as OpCode;
|
|
#[cfg(test)]
|
|
use prometeu_bytecode::registry::FunctionDecl;
|
|
use prometeu_bytecode::{
|
|
TRAP_BAD_RET_SLOTS, TRAP_DIV_ZERO, TRAP_EXPLICIT, TRAP_INVALID_FUNC, TRAP_INVALID_HANDLE,
|
|
TRAP_INVALID_INTRINSIC, TRAP_INVALID_SYSCALL, TRAP_NULL_REFERENCE, TRAP_OOB,
|
|
TRAP_RESOURCE_LIMIT, TRAP_STACK_UNDERFLOW, TRAP_TYPE, TRAP_UNAVAILABLE, TrapInfo,
|
|
};
|
|
use prometeu_hal::syscalls::caps::NONE;
|
|
use prometeu_hal::vm_fault::VmFault;
|
|
#[cfg(test)]
|
|
use prometeu_test_support::program::{TestProgram, int64_signature};
|
|
|
|
/// Reason why the Virtual Machine stopped execution during a specific run.
|
|
/// This allows the system to decide if it should continue execution in the next tick
|
|
/// or if the frame is finalized.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum LogicalFrameEndingReason {
|
|
/// Execution reached a `FRAME_SYNC` instruction, marking the end of the logical frame.
|
|
FrameSync,
|
|
/// The outer lifecycle callback returned; gameplay has not resumed.
|
|
LifecycleComplete,
|
|
/// The cycle budget for the current host tick was exhausted before reaching `FRAME_SYNC`.
|
|
BudgetExhausted,
|
|
/// A `HALT` instruction was executed, terminating the program.
|
|
Halted,
|
|
/// The Program Counter (PC) reached the end of the available bytecode.
|
|
EndOfRom,
|
|
/// Execution hit a registered breakpoint.
|
|
Breakpoint,
|
|
/// A runtime trap occurred (e.g., out-of-bounds access).
|
|
Trap(TrapInfo),
|
|
/// A fatal error occurred that cannot be recovered (e.g., stack underflow).
|
|
Panic(String),
|
|
}
|
|
|
|
pub(crate) enum OpError {
|
|
Trap(u32, String),
|
|
}
|
|
|
|
impl From<crate::numeric::NumericError> for OpError {
|
|
fn from(error: crate::numeric::NumericError) -> Self {
|
|
Self::Trap(error.code, format!("Numeric operation failed: {error:?}"))
|
|
}
|
|
}
|
|
|
|
impl From<TrapInfo> for LogicalFrameEndingReason {
|
|
fn from(info: TrapInfo) -> Self {
|
|
LogicalFrameEndingReason::Trap(info)
|
|
}
|
|
}
|
|
|
|
/// A report detailing the results of an execution slice (run_budget).
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct BudgetReport {
|
|
/// Total virtual cycles consumed during this run.
|
|
pub cycles_used: u64,
|
|
/// Number of VM instructions executed.
|
|
pub steps_executed: u32,
|
|
/// The reason why this execution slice ended.
|
|
pub reason: LogicalFrameEndingReason,
|
|
}
|
|
|
|
pub struct VirtualMachine {
|
|
/// Program Counter (PC): The absolute byte offset in ROM for the next instruction.
|
|
pc: usize,
|
|
/// Operand Stack: The primary workspace for all mathematical and logical operations.
|
|
operand_stack: BudgetVec<Value>,
|
|
/// Call Stack: Manages function call context (return addresses, frame limits).
|
|
call_stack: BudgetVec<CallFrame>,
|
|
/// Global Variable Store: Variables that persist for the lifetime of the program.
|
|
globals: BudgetVec<Value>,
|
|
/// The loaded executable (Bytecode + Constant Pool), that is the ROM translated.
|
|
program: ProgramImage,
|
|
validated_image: Option<std::sync::Arc<crate::ValidatedProgramImage>>,
|
|
strings: Option<crate::string_ledger::StringLedger>,
|
|
/// Heap Memory: Dynamic allocation pool.
|
|
heap: Heap,
|
|
/// Total virtual cycles consumed since the VM started.
|
|
cycles: u64,
|
|
/// Stop flag: true if a `HALT` opcode was encountered.
|
|
halted: bool,
|
|
lifecycle: Option<lifecycle::LifecycleCall>,
|
|
lifecycle_failure: Option<LogicalFrameEndingReason>,
|
|
memcard_boot_started: bool,
|
|
memcard_boot_result: Option<i32>,
|
|
memcard_boot_required: bool,
|
|
/// Set of ROM addresses used for software breakpoints in the debugger.
|
|
breakpoints: std::collections::HashSet<usize>,
|
|
/// GC: number of newly allocated live objects threshold to trigger a collection at safepoint.
|
|
/// The GC only runs at safepoints (e.g., FRAME_SYNC). 0 disables automatic GC.
|
|
gc_alloc_threshold: usize,
|
|
/// GC: snapshot of live objects count after the last collection (or VM init).
|
|
last_gc_live_count: usize,
|
|
/// Capability flags granted to the currently running program/cart.
|
|
/// Syscalls are capability-gated using `prometeu_hal::syscalls::SyscallMeta::caps`.
|
|
capabilities: prometeu_hal::syscalls::CapFlags,
|
|
budget: RuntimeBudget,
|
|
#[cfg(feature = "resource-diagnostics")]
|
|
gc_diagnostics: crate::resource_diagnostics::GcDiagnostics,
|
|
#[cfg(feature = "resource-diagnostics")]
|
|
peak_call_depth: usize,
|
|
}
|
|
|
|
impl Default for VirtualMachine {
|
|
fn default() -> Self {
|
|
Self::empty(RuntimeLimits::default())
|
|
}
|
|
}
|
|
|
|
impl VirtualMachine {
|
|
#[cfg(feature = "resource-diagnostics")]
|
|
pub fn resource_observer(&self) -> RuntimeBudget {
|
|
self.budget.clone()
|
|
}
|
|
|
|
#[cfg(feature = "resource-diagnostics")]
|
|
pub fn resource_snapshot(&self) -> crate::resource_diagnostics::ResourceSnapshot {
|
|
let (free_handles, retired_handles) = self.heap.diagnostic_handles();
|
|
crate::resource_diagnostics::ResourceSnapshot {
|
|
budget: self.budget.diagnostic_snapshot(),
|
|
live_objects: self.heap.len(),
|
|
free_handles,
|
|
retired_handles,
|
|
tracked_strings: self.strings.as_ref().map_or(0, |s| s.tracked_allocations()),
|
|
call_depth: self.call_stack.len(),
|
|
peak_call_depth: self.peak_call_depth.max(self.call_stack.len()),
|
|
cycles: self.cycles,
|
|
gc: self.gc_diagnostics.clone(),
|
|
}
|
|
}
|
|
/// Returns the current program counter.
|
|
pub fn pc(&self) -> usize {
|
|
self.pc
|
|
}
|
|
|
|
/// Returns true if there are no active call frames.
|
|
pub fn call_stack_is_empty(&self) -> bool {
|
|
self.call_stack.is_empty()
|
|
}
|
|
|
|
/// Returns up to `n` values from the top of the operand stack (top-first order).
|
|
pub fn operand_stack_top(&self, n: usize) -> prometeu_hal::ValueSnapshot {
|
|
let len = self.operand_stack.len();
|
|
let start = len.saturating_sub(n);
|
|
let values: Vec<_> = self.operand_stack[start..].iter().rev().cloned().collect();
|
|
let mut owners = [None, None];
|
|
for value in &values {
|
|
if let Value::String(content) = value {
|
|
if let Some(image) = &self.validated_image
|
|
&& owners[0].is_none()
|
|
&& image.retains_string(content)
|
|
{
|
|
owners[0] = Some(image.string_retention());
|
|
}
|
|
if let Some(strings) = &self.strings
|
|
&& owners[1].is_none()
|
|
&& strings.retains(content)
|
|
{
|
|
owners[1] = Some(strings.retention());
|
|
}
|
|
}
|
|
}
|
|
prometeu_hal::ValueSnapshot::with_owners(values, owners)
|
|
}
|
|
|
|
/// Returns a reference to the VM's heap.
|
|
pub fn heap(&self) -> &Heap {
|
|
&self.heap
|
|
}
|
|
|
|
/// Returns true if the VM has executed a HALT and is not currently running.
|
|
pub fn is_halted(&self) -> bool {
|
|
self.halted
|
|
}
|
|
|
|
/// Adds a software breakpoint at the given PC.
|
|
pub fn insert_breakpoint(&mut self, pc: usize) {
|
|
let _ = self.breakpoints.insert(pc);
|
|
}
|
|
|
|
/// Removes a software breakpoint at the given PC, if present.
|
|
pub fn remove_breakpoint(&mut self, pc: usize) {
|
|
let _ = self.breakpoints.remove(&pc);
|
|
}
|
|
|
|
/// Returns the list of currently configured breakpoints.
|
|
pub fn breakpoints_list(&self) -> Vec<usize> {
|
|
self.breakpoints.iter().cloned().collect()
|
|
}
|
|
|
|
// Test-only helpers for internal unit tests within this crate.
|
|
#[cfg(test)]
|
|
pub(crate) fn push_operand_for_test(&mut self, v: Value) {
|
|
self.operand_stack.push(v).unwrap();
|
|
}
|
|
/// Creates a new VM instance with the provided bytecode and constants.
|
|
#[cfg(test)]
|
|
pub(crate) fn fault_session(rom: Vec<u8>, constant_pool: Vec<Value>) -> Self {
|
|
Self::fault_session_with_limits(rom, constant_pool, RuntimeLimits::default())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn fault_session_with_limits(
|
|
rom: Vec<u8>,
|
|
constant_pool: Vec<Value>,
|
|
limits: RuntimeLimits,
|
|
) -> Self {
|
|
let mut vm = Self::empty(limits);
|
|
vm.program = ProgramImage {
|
|
rom: rom.into(),
|
|
constant_pool: constant_pool.into(),
|
|
..Default::default()
|
|
};
|
|
vm.halted = false;
|
|
vm
|
|
}
|
|
|
|
fn empty(limits: RuntimeLimits) -> Self {
|
|
let budget = RuntimeBudget::new(limits);
|
|
Self {
|
|
pc: 0,
|
|
operand_stack: BudgetVec::new(&budget, RuntimeResource::AuxiliaryBytes),
|
|
call_stack: BudgetVec::new(&budget, RuntimeResource::AuxiliaryBytes),
|
|
globals: BudgetVec::new(&budget, RuntimeResource::AuxiliaryBytes),
|
|
program: ProgramImage::default(),
|
|
validated_image: None,
|
|
strings: None,
|
|
heap: Heap::with_budget(&budget),
|
|
cycles: 0,
|
|
halted: true,
|
|
lifecycle: None,
|
|
memcard_boot_started: false,
|
|
memcard_boot_result: None,
|
|
memcard_boot_required: false,
|
|
lifecycle_failure: None,
|
|
breakpoints: std::collections::HashSet::new(),
|
|
gc_alloc_threshold: 1024, // conservative default; tests may override
|
|
last_gc_live_count: 0,
|
|
capabilities: NONE,
|
|
budget,
|
|
#[cfg(feature = "resource-diagnostics")]
|
|
gc_diagnostics: Default::default(),
|
|
#[cfg(feature = "resource-diagnostics")]
|
|
peak_call_depth: 0,
|
|
}
|
|
}
|
|
|
|
/// Sessions share validated code, constants, debug and Registry ownership.
|
|
/// Entry setup validates supplied groups before publishing an active frame.
|
|
pub fn from_image(
|
|
image: std::sync::Arc<crate::ValidatedProgramImage>,
|
|
limits: RuntimeLimits,
|
|
) -> Self {
|
|
let mut vm = Self::empty(limits);
|
|
vm.program = image.execution.clone();
|
|
vm.capabilities = image.capabilities();
|
|
vm.validated_image = Some(image);
|
|
vm.halted = true;
|
|
vm
|
|
}
|
|
|
|
/// Executes a single instruction at the current Program Counter (PC).
|
|
///
|
|
/// This follows the classic CPU cycle:
|
|
/// 1. Fetch: Read the opcode from memory.
|
|
/// 2. Decode: Identify what operation to perform.
|
|
/// 3. Execute: Perform the operation, updating stacks, memory, or calling peripherals.
|
|
fn step_inner(
|
|
&mut self,
|
|
native: &mut dyn NativeInterface,
|
|
ctx: &mut HostContext,
|
|
) -> Result<(), LogicalFrameEndingReason> {
|
|
if self.halted || self.pc >= self.program.rom.len() {
|
|
return Ok(());
|
|
}
|
|
|
|
let start_pc = self.pc;
|
|
|
|
// Fetch & Decode
|
|
let instr = prometeu_bytecode::decode_next(self.pc, &self.program.rom)
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
|
|
let opcode = instr.opcode;
|
|
self.pc = instr.next_pc;
|
|
|
|
// Call/return and branch attempts pay once before any runtime refusal.
|
|
let charged_control = matches!(
|
|
opcode,
|
|
OpCode::Call | OpCode::Ret | OpCode::Jmp | OpCode::JmpIfTrue | OpCode::JmpIfFalse
|
|
);
|
|
if charged_control {
|
|
self.cycles += opcode.cycles();
|
|
}
|
|
|
|
let charged_math = if opcode == OpCode::Intrinsic {
|
|
lookup_intrinsic_by_id(instr.imm_u32().unwrap())
|
|
.filter(|m| m.owner == "vec2" || m.owner == "mathf" || m.owner.starts_with("math."))
|
|
} else {
|
|
None
|
|
};
|
|
if let Some(meta) = charged_math {
|
|
self.cycles += meta.cost_cycles;
|
|
}
|
|
// Execute
|
|
match opcode {
|
|
OpCode::Nop => {}
|
|
OpCode::Halt => {
|
|
self.halted = true;
|
|
}
|
|
OpCode::Jmp => {
|
|
let target = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
|
|
as usize;
|
|
self.jump_to(target, opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::JmpIfFalse => {
|
|
let target = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
|
|
as usize;
|
|
let val =
|
|
self.pop_trap(opcode, start_pc as u32, "JMP_IF_FALSE requires one operand")?;
|
|
match val {
|
|
Value::Boolean(false) => {
|
|
self.jump_to(target, opcode, start_pc as u32)?;
|
|
}
|
|
Value::Boolean(true) => {}
|
|
_ => {
|
|
return Err(self.trap(
|
|
TRAP_TYPE,
|
|
opcode as u16,
|
|
format!("Expected boolean for JMP_IF_FALSE, got {:?}", val),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
}
|
|
}
|
|
OpCode::JmpIfTrue => {
|
|
let target = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
|
|
as usize;
|
|
let val =
|
|
self.pop_trap(opcode, start_pc as u32, "JMP_IF_TRUE requires one operand")?;
|
|
match val {
|
|
Value::Boolean(true) => {
|
|
self.jump_to(target, opcode, start_pc as u32)?;
|
|
}
|
|
Value::Boolean(false) => {}
|
|
_ => {
|
|
return Err(self.trap(
|
|
TRAP_TYPE,
|
|
opcode as u16,
|
|
format!("Expected boolean for JMP_IF_TRUE, got {:?}", val),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
}
|
|
}
|
|
OpCode::Trap => {
|
|
// TRAP is guest-visible ISA, distinct from debugger breakpoints.
|
|
self.cycles += OpCode::Trap.cycles();
|
|
return Err(self.trap(
|
|
TRAP_EXPLICIT,
|
|
opcode as u16,
|
|
"Program requested trap".into(),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
OpCode::Spawn | OpCode::Yield | OpCode::Sleep => {
|
|
return Err(self.trap(
|
|
TRAP_TYPE,
|
|
opcode as u16,
|
|
"Retired coroutine opcode".into(),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
OpCode::Hostcall => {
|
|
return Err(self.trap(
|
|
TRAP_INVALID_SYSCALL,
|
|
opcode as u16,
|
|
"Unpatched HOSTCALL".into(),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
OpCode::MakeClosure | OpCode::CallClosure | OpCode::GetCapture | OpCode::CallTrait => {
|
|
let (first, second) = if matches!(opcode, OpCode::MakeClosure | OpCode::CallTrait) {
|
|
instr.imm_u32x2().unwrap()
|
|
} else {
|
|
(instr.imm_u32().unwrap(), 0)
|
|
};
|
|
return self.execute_callable(opcode, first, second, start_pc as u32);
|
|
}
|
|
OpCode::PushConst => {
|
|
let idx = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
|
|
as usize;
|
|
let val = self.program.constant_pool.get(idx).cloned().ok_or_else(|| {
|
|
self.trap(
|
|
TRAP_OOB,
|
|
opcode as u16,
|
|
format!("Invalid constant index {}", idx),
|
|
start_pc as u32,
|
|
)
|
|
})?;
|
|
self.push_trap(val, opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::PushI64 => {
|
|
let val = instr
|
|
.imm_i64()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
self.push_trap(Value::Int64(val), opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::PushI32 => {
|
|
let val = instr
|
|
.imm_i32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
self.push_trap(Value::Int32(val), opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::PushF64 => {
|
|
let val = instr
|
|
.imm_f64()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
self.push_trap(Value::Float(val), opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::PushBool => {
|
|
let val = instr
|
|
.imm_u8()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
self.push_trap(Value::Boolean(val != 0), opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::Pop => {
|
|
self.pop_trap(opcode, start_pc as u32, "POP requires one operand")?;
|
|
}
|
|
OpCode::PopN => {
|
|
let n = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
for _ in 0..n {
|
|
self.pop_trap(opcode, start_pc as u32, "POPN operand stack underflow")?;
|
|
}
|
|
}
|
|
OpCode::Dup => {
|
|
let val =
|
|
self.peek_trap(opcode, start_pc as u32, "DUP requires one operand")?.clone();
|
|
self.push_trap(val, opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::Swap => {
|
|
let a = self.pop_trap(opcode, start_pc as u32, "SWAP requires two operands")?;
|
|
let b = self.pop_trap(opcode, start_pc as u32, "SWAP requires two operands")?;
|
|
self.push_trap(a, opcode, start_pc as u32)?;
|
|
self.push_trap(b, opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::Add => {
|
|
let len = self.operand_stack.len();
|
|
if self.temporary_slots() >= 2
|
|
&& (matches!(self.operand_stack[len - 2], Value::String(_))
|
|
|| matches!(self.operand_stack[len - 1], Value::String(_)))
|
|
{
|
|
self.execute_string_add(opcode, start_pc as u32)?;
|
|
} else {
|
|
self.binary_op(opcode, start_pc as u32, |a, b| {
|
|
numeric::opcode_binary(opcode, &a, &b).map_err(|e| {
|
|
if e.code == TRAP_TYPE {
|
|
OpError::Trap(
|
|
TRAP_TYPE,
|
|
format!(
|
|
"Invalid types for {}",
|
|
format!("{opcode:?}").to_uppercase()
|
|
),
|
|
)
|
|
} else {
|
|
OpError::from(e)
|
|
}
|
|
})
|
|
})?;
|
|
}
|
|
}
|
|
OpCode::Sub | OpCode::Mul | OpCode::Div => {
|
|
self.binary_op(opcode, start_pc as u32, |a, b| {
|
|
numeric::opcode_binary(opcode, &a, &b).map_err(|e| {
|
|
if e.code == TRAP_TYPE {
|
|
OpError::Trap(
|
|
TRAP_TYPE,
|
|
format!(
|
|
"Invalid types for {}",
|
|
format!("{opcode:?}").to_uppercase()
|
|
),
|
|
)
|
|
} else {
|
|
OpError::from(e)
|
|
}
|
|
})
|
|
})?
|
|
}
|
|
OpCode::Mod => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
|
|
(Value::Int32(a), Value::Int32(b)) => {
|
|
if b == 0 {
|
|
return Err(OpError::Trap(TRAP_DIV_ZERO, "Integer modulo by zero".into()));
|
|
}
|
|
Ok(Value::Int32(a.wrapping_rem(b)))
|
|
}
|
|
(Value::Int64(a), Value::Int64(b)) => {
|
|
if b == 0 {
|
|
return Err(OpError::Trap(TRAP_DIV_ZERO, "Integer modulo by zero".into()));
|
|
}
|
|
Ok(Value::Int64(a.wrapping_rem(b)))
|
|
}
|
|
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for MOD".into())),
|
|
})?,
|
|
OpCode::Eq => self.binary_op(opcode, start_pc as u32, |a, b| {
|
|
numeric::equal_values(&a, &b).map(Value::Boolean).map_err(OpError::from)
|
|
})?,
|
|
OpCode::Neq => self.binary_op(opcode, start_pc as u32, |a, b| {
|
|
numeric::equal_values(&a, &b).map(|v| Value::Boolean(!v)).map_err(OpError::from)
|
|
})?,
|
|
OpCode::Lt => self.binary_op(opcode, start_pc as u32, |a, b| {
|
|
numeric::compare_values(&a, &b)
|
|
.map_err(OpError::from)?
|
|
.map(|o| Value::Boolean(o == std::cmp::Ordering::Less))
|
|
.ok_or_else(|| OpError::Trap(TRAP_TYPE, "Invalid types for LT".into()))
|
|
})?,
|
|
OpCode::Gt => self.binary_op(opcode, start_pc as u32, |a, b| {
|
|
numeric::compare_values(&a, &b)
|
|
.map_err(OpError::from)?
|
|
.map(|o| Value::Boolean(o == std::cmp::Ordering::Greater))
|
|
.ok_or_else(|| OpError::Trap(TRAP_TYPE, "Invalid types for GT".into()))
|
|
})?,
|
|
OpCode::Lte => self.binary_op(opcode, start_pc as u32, |a, b| {
|
|
numeric::compare_values(&a, &b)
|
|
.map_err(OpError::from)?
|
|
.map(|o| Value::Boolean(o != std::cmp::Ordering::Greater))
|
|
.ok_or_else(|| OpError::Trap(TRAP_TYPE, "Invalid types for LTE".into()))
|
|
})?,
|
|
OpCode::Gte => self.binary_op(opcode, start_pc as u32, |a, b| {
|
|
numeric::compare_values(&a, &b)
|
|
.map_err(OpError::from)?
|
|
.map(|o| Value::Boolean(o != std::cmp::Ordering::Less))
|
|
.ok_or_else(|| OpError::Trap(TRAP_TYPE, "Invalid types for GTE".into()))
|
|
})?,
|
|
OpCode::And => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
|
|
(Value::Boolean(a), Value::Boolean(b)) => Ok(Value::Boolean(a && b)),
|
|
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for AND".into())),
|
|
})?,
|
|
OpCode::Or => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
|
|
(Value::Boolean(a), Value::Boolean(b)) => Ok(Value::Boolean(a || b)),
|
|
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for OR".into())),
|
|
})?,
|
|
OpCode::Not => {
|
|
let val = self.pop_trap(opcode, start_pc as u32, "NOT requires one operand")?;
|
|
if let Value::Boolean(b) = val {
|
|
self.push_trap(Value::Boolean(!b), opcode, start_pc as u32)?;
|
|
} else {
|
|
return Err(self.trap(
|
|
TRAP_TYPE,
|
|
opcode as u16,
|
|
"Invalid type for NOT".into(),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
}
|
|
OpCode::BitAnd => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
|
|
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a & b)),
|
|
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a & b)),
|
|
(Value::Int32(a), Value::Int64(b)) => Ok(Value::Int64((a as i64) & b)),
|
|
(Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a & (b as i64))),
|
|
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for BitAnd".into())),
|
|
})?,
|
|
OpCode::BitOr => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
|
|
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a | b)),
|
|
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a | b)),
|
|
(Value::Int32(a), Value::Int64(b)) => Ok(Value::Int64((a as i64) | b)),
|
|
(Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a | (b as i64))),
|
|
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for BitOr".into())),
|
|
})?,
|
|
OpCode::BitXor => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
|
|
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a ^ b)),
|
|
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a ^ b)),
|
|
(Value::Int32(a), Value::Int64(b)) => Ok(Value::Int64((a as i64) ^ b)),
|
|
(Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a ^ (b as i64))),
|
|
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for BitXor".into())),
|
|
})?,
|
|
OpCode::Shl => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
|
|
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_shl(b as u32))),
|
|
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_shl(b as u32))),
|
|
(Value::Int32(a), Value::Int64(b)) => {
|
|
Ok(Value::Int64((a as i64).wrapping_shl(b as u32)))
|
|
}
|
|
(Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a.wrapping_shl(b as u32))),
|
|
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for Shl".into())),
|
|
})?,
|
|
OpCode::Shr => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
|
|
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_shr(b as u32))),
|
|
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_shr(b as u32))),
|
|
(Value::Int32(a), Value::Int64(b)) => {
|
|
Ok(Value::Int64((a as i64).wrapping_shr(b as u32)))
|
|
}
|
|
(Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a.wrapping_shr(b as u32))),
|
|
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for Shr".into())),
|
|
})?,
|
|
OpCode::Neg => {
|
|
let val = self.pop_trap(opcode, start_pc as u32, "NEG requires one operand")?;
|
|
match val {
|
|
Value::Int32(a) => {
|
|
self.push_trap(Value::Int32(a.wrapping_neg()), opcode, start_pc as u32)?
|
|
}
|
|
Value::Int64(a) => {
|
|
self.push_trap(Value::Int64(a.wrapping_neg()), opcode, start_pc as u32)?
|
|
}
|
|
Value::Float(a) => {
|
|
let result = numeric::neg(a).map_err(|e| {
|
|
self.trap(e.code, opcode as u16, format!("NEG: {e:?}"), start_pc as u32)
|
|
})?;
|
|
self.push_trap(Value::Float(result), opcode, start_pc as u32)?;
|
|
}
|
|
_ => {
|
|
return Err(self.trap(
|
|
TRAP_TYPE,
|
|
opcode as u16,
|
|
"Invalid type for Neg".into(),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
}
|
|
}
|
|
OpCode::GetGlobal => {
|
|
let idx = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
|
|
as usize;
|
|
if idx >= self.globals.len() {
|
|
self.globals
|
|
.resize(
|
|
idx.checked_add(1).ok_or_else(|| {
|
|
self.resource_trap(
|
|
self.budget.failure(
|
|
RuntimeResource::AuxiliaryBytes,
|
|
crate::resource_budget::ResourceReason::SizeOverflow,
|
|
u64::MAX,
|
|
),
|
|
opcode,
|
|
start_pc as u32,
|
|
)
|
|
})?,
|
|
Value::Int32(0),
|
|
)
|
|
.map_err(|error| self.resource_trap(error, opcode, start_pc as u32))?;
|
|
}
|
|
let val = self.globals[idx].clone();
|
|
self.push_trap(val, opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::SetGlobal => {
|
|
let idx = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
|
|
as usize;
|
|
let val =
|
|
self.pop_trap(opcode, start_pc as u32, "SET_GLOBAL requires one operand")?;
|
|
if idx >= self.globals.len() {
|
|
self.globals
|
|
.resize(
|
|
idx.checked_add(1).ok_or_else(|| {
|
|
self.resource_trap(
|
|
self.budget.failure(
|
|
RuntimeResource::AuxiliaryBytes,
|
|
crate::resource_budget::ResourceReason::SizeOverflow,
|
|
u64::MAX,
|
|
),
|
|
opcode,
|
|
start_pc as u32,
|
|
)
|
|
})?,
|
|
Value::Int32(0),
|
|
)
|
|
.map_err(|error| self.resource_trap(error, opcode, start_pc as u32))?;
|
|
}
|
|
self.globals[idx] = val;
|
|
}
|
|
OpCode::GetLocal => {
|
|
let slot = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
let frame = self.call_stack.last().ok_or_else(|| {
|
|
LogicalFrameEndingReason::Panic("No active call frame".into())
|
|
})?;
|
|
let func = &self.program.functions[frame.func_idx];
|
|
|
|
crate::local_addressing::check_local_slot(
|
|
func,
|
|
slot,
|
|
opcode as u16,
|
|
start_pc as u32,
|
|
)
|
|
.map_err(|trap_info| {
|
|
self.trap(trap_info.code, trap_info.opcode, trap_info.message, trap_info.pc)
|
|
})?;
|
|
|
|
let stack_idx = crate::local_addressing::local_index(frame, slot);
|
|
let val = self.operand_stack.get(stack_idx).cloned().ok_or_else(|| {
|
|
LogicalFrameEndingReason::Panic(
|
|
"Internal error: validated local slot not found in stack".into(),
|
|
)
|
|
})?;
|
|
self.push_trap(val, opcode, start_pc as u32)?;
|
|
}
|
|
OpCode::SetLocal => {
|
|
let slot = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
let val =
|
|
self.pop_trap(opcode, start_pc as u32, "SET_LOCAL requires one operand")?;
|
|
let frame = self.call_stack.last().ok_or_else(|| {
|
|
LogicalFrameEndingReason::Panic("No active call frame".into())
|
|
})?;
|
|
let func = &self.program.functions[frame.func_idx];
|
|
|
|
crate::local_addressing::check_local_slot(
|
|
func,
|
|
slot,
|
|
opcode as u16,
|
|
start_pc as u32,
|
|
)
|
|
.map_err(|trap_info| {
|
|
self.trap(trap_info.code, trap_info.opcode, trap_info.message, trap_info.pc)
|
|
})?;
|
|
|
|
let stack_idx = crate::local_addressing::local_index(frame, slot);
|
|
self.operand_stack[stack_idx] = val;
|
|
}
|
|
OpCode::Call => {
|
|
self.check_call_depth()
|
|
.map_err(|error| self.resource_trap(error, opcode, start_pc as u32))?;
|
|
let func_id = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?
|
|
as usize;
|
|
let callee = self.program.functions.get(func_id).ok_or_else(|| {
|
|
self.trap(
|
|
TRAP_INVALID_FUNC,
|
|
opcode as u16,
|
|
format!("Invalid func_id {}", func_id),
|
|
start_pc as u32,
|
|
)
|
|
})?;
|
|
|
|
if self.temporary_slots() < callee.param_slots as usize {
|
|
return Err(self.trap(
|
|
TRAP_STACK_UNDERFLOW,
|
|
opcode as u16,
|
|
format!(
|
|
"Stack underflow during CALL to func {}: expected at least {} arguments, got {}",
|
|
func_id,
|
|
callee.param_slots,
|
|
self.operand_stack.len()
|
|
),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
|
|
let stack_base = self.operand_stack.len() - callee.param_slots as usize;
|
|
|
|
self.check_signature_group(func_id, false, &self.operand_stack[stack_base..])
|
|
.map_err(|(_, error)| self.value_trap(error, opcode, start_pc as u32))?;
|
|
|
|
let callee_local_slots = callee.local_slots;
|
|
let callee_offset = callee.code_offset;
|
|
let stack_growth = self
|
|
.operand_stack
|
|
.prepare_growth(callee_local_slots as usize)
|
|
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
let frame_growth = self
|
|
.call_stack
|
|
.prepare_growth(1)
|
|
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
self.operand_stack.commit_growth(stack_growth);
|
|
self.call_stack.commit_growth(frame_growth);
|
|
// Allocate and zero-init local_slots
|
|
for _ in 0..callee_local_slots {
|
|
self.operand_stack
|
|
.push(Value::Null)
|
|
.map_err(|error| self.resource_trap(error, opcode, start_pc as u32))?;
|
|
}
|
|
|
|
self.call_stack
|
|
.push(CallFrame {
|
|
return_pc: self.pc as u32,
|
|
stack_base,
|
|
func_idx: func_id,
|
|
closure: None,
|
|
})
|
|
.map_err(|error| self.resource_trap(error, opcode, start_pc as u32))?;
|
|
self.pc = callee_offset as usize;
|
|
}
|
|
OpCode::Ret => self.finish_return(opcode, start_pc as u32)?,
|
|
OpCode::Syscall => {
|
|
let pc_at_syscall = start_pc as u32;
|
|
let id = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
let syscall = prometeu_hal::syscalls::Syscall::from_u32(id).ok_or_else(|| {
|
|
self.trap(
|
|
TRAP_INVALID_SYSCALL,
|
|
OpCode::Syscall as u16,
|
|
format!("Unknown syscall: 0x{:08X}", id),
|
|
pc_at_syscall,
|
|
)
|
|
})?;
|
|
|
|
// Capability check before any side effects or argument consumption.
|
|
let meta = prometeu_hal::syscalls::meta_for(syscall);
|
|
if (self.capabilities & meta.caps) != meta.caps {
|
|
return Err(self.trap(
|
|
TRAP_INVALID_SYSCALL,
|
|
OpCode::Syscall as u16,
|
|
format!(
|
|
"Missing capability for syscall {} (required=0x{:X})",
|
|
syscall.name(),
|
|
meta.caps
|
|
),
|
|
pc_at_syscall,
|
|
));
|
|
}
|
|
|
|
let args_count = syscall.args_count();
|
|
|
|
let mut args = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes);
|
|
args.reserve(args_count)
|
|
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
for _ in 0..args_count {
|
|
let v = self.pop().map_err(|_e| {
|
|
self.trap(
|
|
TRAP_STACK_UNDERFLOW,
|
|
OpCode::Syscall as u16,
|
|
"Syscall argument stack underflow".to_string(),
|
|
pc_at_syscall,
|
|
)
|
|
})?;
|
|
args.push(v).map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
}
|
|
args.reverse();
|
|
|
|
let stack_height_before = self.operand_stack.len();
|
|
self.operand_stack
|
|
.reserve(syscall.results_count())
|
|
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
let mut arrays = native_arrays::SessionArrays {
|
|
heap: &mut self.heap,
|
|
registry: self.validated_image.as_ref().map(|image| image.registry().as_ref()),
|
|
work: 0,
|
|
};
|
|
let mut strings = strings::SessionStringAllocator {
|
|
ledger: &mut self.strings,
|
|
budget: self.budget.clone(),
|
|
};
|
|
let mut ret = crate::HostReturn::new(
|
|
self.operand_stack.native_result_buffer(),
|
|
syscall.results_count(),
|
|
&mut strings,
|
|
)
|
|
.with_arrays(&mut arrays);
|
|
let native_result = native.syscall(id, &args, &mut ret, ctx);
|
|
let return_overflow = ret.overflowed();
|
|
let return_failure = ret.failure().cloned();
|
|
self.cycles += arrays.work;
|
|
let native_result = return_failure.map(Err).unwrap_or(native_result);
|
|
if native_result.is_err() {
|
|
self.operand_stack.truncate(stack_height_before);
|
|
}
|
|
native_result.map_err(|fault| match fault {
|
|
VmFault::ResourceLimit(resource) => {
|
|
self.resource_trap(resource, opcode, pc_at_syscall)
|
|
}
|
|
VmFault::Trap(code, msg) => {
|
|
self.trap(code, OpCode::Syscall as u16, msg, pc_at_syscall)
|
|
}
|
|
VmFault::Panic(msg) => LogicalFrameEndingReason::Panic(msg),
|
|
VmFault::Unavailable => {
|
|
LogicalFrameEndingReason::Panic("Host feature unavailable".into())
|
|
}
|
|
})?;
|
|
|
|
let stack_height_after = self.operand_stack.len();
|
|
let results_pushed = stack_height_after - stack_height_before;
|
|
if return_overflow || results_pushed != syscall.results_count() {
|
|
return Err(LogicalFrameEndingReason::Panic(format!(
|
|
"Syscall {} (0x{:08X}) results mismatch: expected {}, got {} (overflow={})",
|
|
syscall.name(),
|
|
id,
|
|
syscall.results_count(),
|
|
results_pushed,
|
|
return_overflow
|
|
)));
|
|
}
|
|
if syscall == prometeu_hal::syscalls::Syscall::MemBootstrap {
|
|
let context = self.pop_integer().map_err(LogicalFrameEndingReason::Panic)?;
|
|
if !self.begin_memcard_boot(context).map_err(|e| {
|
|
LogicalFrameEndingReason::Panic(format!("Invalid memcard bootstrap: {e:?}"))
|
|
})? {
|
|
return Err(LogicalFrameEndingReason::Panic(
|
|
"Missing memcard boot binding".into(),
|
|
));
|
|
}
|
|
}
|
|
}
|
|
OpCode::Intrinsic => {
|
|
let pc_at_intrinsic = start_pc as u32;
|
|
let id = instr
|
|
.imm_u32()
|
|
.map_err(|e| LogicalFrameEndingReason::Panic(format!("{:?}", e)))?;
|
|
let intrinsic = lookup_intrinsic_by_id(id).ok_or_else(|| {
|
|
self.trap(
|
|
TRAP_INVALID_INTRINSIC,
|
|
OpCode::Intrinsic as u16,
|
|
format!("Unknown intrinsic: 0x{:08X}", id),
|
|
pc_at_intrinsic,
|
|
)
|
|
})?;
|
|
|
|
if matches!(intrinsic.implementation, crate::IntrinsicImplementation::VmOwned) {
|
|
return self.execute_random(intrinsic, pc_at_intrinsic);
|
|
}
|
|
|
|
let args_count = intrinsic.arg_slots();
|
|
let mut args = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes);
|
|
args.reserve(args_count)
|
|
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
for _ in 0..args_count {
|
|
let value = self.pop().map_err(|_e| {
|
|
self.trap(
|
|
TRAP_STACK_UNDERFLOW,
|
|
OpCode::Intrinsic as u16,
|
|
"Intrinsic argument stack underflow".to_string(),
|
|
pc_at_intrinsic,
|
|
)
|
|
})?;
|
|
args.push(value).map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
}
|
|
args.reverse();
|
|
|
|
let _result_storage = self
|
|
.budget
|
|
.reserve(
|
|
RuntimeResource::TemporaryBytes,
|
|
self.budget
|
|
.bytes::<Value>(intrinsic.ret_slots(), RuntimeResource::TemporaryBytes)
|
|
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?,
|
|
)
|
|
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
self.operand_stack
|
|
.reserve(intrinsic.ret_slots())
|
|
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
|
|
let results = intrinsic
|
|
.validate_argument_values(&args)
|
|
.and_then(|()| {
|
|
(intrinsic.implementation.host_callback().expect("host intrinsic"))(
|
|
&args, ctx,
|
|
)
|
|
})
|
|
.map_err(|err| match err {
|
|
crate::IntrinsicExecutionError::ArityMismatch { expected, got } => self
|
|
.trap(
|
|
TRAP_INVALID_INTRINSIC,
|
|
OpCode::Intrinsic as u16,
|
|
format!(
|
|
"Intrinsic {}.{} argument mismatch: expected {}, got {}",
|
|
intrinsic.owner, intrinsic.name, expected, got
|
|
),
|
|
pc_at_intrinsic,
|
|
),
|
|
crate::IntrinsicExecutionError::TypeMismatch { index, expected } => self
|
|
.trap(
|
|
TRAP_TYPE,
|
|
OpCode::Intrinsic as u16,
|
|
format!(
|
|
"Intrinsic {}.{} argument {} type mismatch: expected {:?}",
|
|
intrinsic.owner, intrinsic.name, index, expected
|
|
),
|
|
pc_at_intrinsic,
|
|
),
|
|
crate::IntrinsicExecutionError::Numeric(error) => self.trap(
|
|
error.code,
|
|
opcode as u16,
|
|
format!(
|
|
"Intrinsic {}.{}: {:?}",
|
|
intrinsic.owner, intrinsic.name, error
|
|
),
|
|
pc_at_intrinsic,
|
|
),
|
|
crate::IntrinsicExecutionError::HardwareUnavailable => self.trap(
|
|
TRAP_UNAVAILABLE,
|
|
OpCode::Intrinsic as u16,
|
|
format!(
|
|
"Input query {}.{} unavailable",
|
|
intrinsic.owner, intrinsic.name
|
|
),
|
|
pc_at_intrinsic,
|
|
),
|
|
})?;
|
|
|
|
intrinsic.validate_result_values(&results).map_err(|err| match err {
|
|
crate::IntrinsicExecutionError::ArityMismatch { expected, got } => self.trap(
|
|
TRAP_INVALID_INTRINSIC,
|
|
OpCode::Intrinsic as u16,
|
|
format!(
|
|
"Intrinsic {}.{} results mismatch: expected {}, got {}",
|
|
intrinsic.owner, intrinsic.name, expected, got
|
|
),
|
|
pc_at_intrinsic,
|
|
),
|
|
crate::IntrinsicExecutionError::TypeMismatch { index, expected } => self.trap(
|
|
TRAP_INVALID_INTRINSIC,
|
|
OpCode::Intrinsic as u16,
|
|
format!(
|
|
"Intrinsic {}.{} result {} type mismatch: expected {:?}",
|
|
intrinsic.owner, intrinsic.name, index, expected
|
|
),
|
|
pc_at_intrinsic,
|
|
),
|
|
crate::IntrinsicExecutionError::Numeric(error) => self.trap(
|
|
error.code,
|
|
opcode as u16,
|
|
format!(
|
|
"Intrinsic {}.{} result: {:?}",
|
|
intrinsic.owner, intrinsic.name, error
|
|
),
|
|
pc_at_intrinsic,
|
|
),
|
|
crate::IntrinsicExecutionError::HardwareUnavailable => self.trap(
|
|
TRAP_UNAVAILABLE,
|
|
OpCode::Intrinsic as u16,
|
|
format!("Input query {}.{} unavailable", intrinsic.owner, intrinsic.name),
|
|
pc_at_intrinsic,
|
|
),
|
|
})?;
|
|
|
|
for value in results {
|
|
self.push_trap(value, opcode, start_pc as u32)?;
|
|
}
|
|
}
|
|
OpCode::DynPack | OpCode::DynUnpack | OpCode::DynCanUnpack => {
|
|
self.cycles += opcode.cycles();
|
|
let target = instr.imm_u32().unwrap();
|
|
return self.execute_dynamic(opcode, target, start_pc as u32);
|
|
}
|
|
OpCode::RefIsExact | OpCode::RefImplements | OpCode::RefToTrait | OpCode::RefCast => {
|
|
self.cycles += opcode.cycles();
|
|
let (source, target) = instr.imm_u32x2().unwrap();
|
|
return self.execute_reference(opcode, source, target, start_pc as u32);
|
|
}
|
|
OpCode::StructNew
|
|
| OpCode::StructGet
|
|
| OpCode::StructSet
|
|
| OpCode::ArrayNew
|
|
| OpCode::ArrayLen
|
|
| OpCode::ArrayGet
|
|
| OpCode::ArraySet => {
|
|
let (ty, field) = if matches!(opcode, OpCode::StructGet | OpCode::StructSet) {
|
|
instr.imm_u32x2().unwrap()
|
|
} else {
|
|
(instr.imm_u32().unwrap(), 0)
|
|
};
|
|
return self.execute_collection(opcode, ty, field, start_pc as u32);
|
|
}
|
|
OpCode::FrameSync => {
|
|
if self.memcard_boot_required && self.memcard_boot_result != Some(0) {
|
|
return Err(LogicalFrameEndingReason::Panic(
|
|
"Frame entered before memcard bootstrap admission".into(),
|
|
));
|
|
}
|
|
if self.lifecycle.is_some() {
|
|
return Err(self.trap(
|
|
TRAP_TYPE,
|
|
opcode as u16,
|
|
"FRAME_SYNC is forbidden in lifecycle hooks".into(),
|
|
start_pc as u32,
|
|
));
|
|
}
|
|
// Marks the logical end of a frame: consume cycles and signal to the driver
|
|
self.cycles += OpCode::FrameSync.cycles();
|
|
self.handle_safepoint()
|
|
.map_err(|error| self.resource_trap(error, opcode, start_pc as u32))?;
|
|
return Err(LogicalFrameEndingReason::FrameSync);
|
|
}
|
|
}
|
|
|
|
// Control attempts were already charged before validation.
|
|
if !charged_control && charged_math.is_none() {
|
|
self.cycles += opcode.cycles();
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::sync::Arc;
|
|
|
|
fn fault_cache(
|
|
rom: Vec<u8>,
|
|
constant_pool: Vec<Value>,
|
|
functions: Vec<ExecutionFunction>,
|
|
debug_info: Option<prometeu_bytecode::model::DebugInfo>,
|
|
exports: std::collections::HashMap<String, u32>,
|
|
) -> ProgramImage {
|
|
ProgramImage {
|
|
rom: rom.into(),
|
|
constant_pool: constant_pool.into(),
|
|
functions: functions.into(),
|
|
debug_info: debug_info.map(Arc::new),
|
|
exports: Arc::new(exports),
|
|
}
|
|
}
|
|
fn entry_auxiliary_bytes() -> u64 {
|
|
(size_of::<CallFrame>()) as u64
|
|
}
|
|
|
|
fn scalar_signature(p: usize, r: usize, result: u32) -> prometeu_bytecode::registry::Signature {
|
|
use prometeu_bytecode::registry::*;
|
|
Signature {
|
|
parameters: vec![NamedType { type_id: TypeId(1), name: None }; p],
|
|
results: vec![TypeId(result); r],
|
|
}
|
|
}
|
|
fn typed_test_vm(
|
|
mut code: Vec<u8>,
|
|
constants: Vec<Value>,
|
|
mut functions: Vec<FunctionDecl>,
|
|
) -> VirtualMachine {
|
|
// Test producer emits final syscall identities as canonical HOSTCALL declarations.
|
|
let mut syscalls = vec![];
|
|
let mut at = 0;
|
|
while at < code.len() {
|
|
let instruction = prometeu_bytecode::decode_next(at, &code).unwrap();
|
|
let next_pc = instruction.next_pc;
|
|
if instruction.opcode == OpCode::Syscall {
|
|
let syscall =
|
|
prometeu_hal::syscalls::Syscall::from_u32(instruction.imm_u32().unwrap())
|
|
.unwrap();
|
|
let meta = prometeu_hal::syscalls::meta_for(syscall);
|
|
let index = syscalls.len() as u32;
|
|
syscalls.push(SyscallDecl {
|
|
module: meta.module.into(),
|
|
name: meta.name.into(),
|
|
version: meta.version,
|
|
arg_slots: meta.arg_slots as u16,
|
|
ret_slots: meta.ret_slots,
|
|
});
|
|
code[at..at + 2].copy_from_slice(&(OpCode::Hostcall as u16).to_le_bytes());
|
|
code[at + 2..at + 6].copy_from_slice(&index.to_le_bytes());
|
|
}
|
|
at = next_pc;
|
|
}
|
|
let end = code.len() as u32;
|
|
for i in 0..functions.len() {
|
|
functions[i].code_len =
|
|
functions.get(i + 1).map_or(end, |f| f.code_offset) - functions[i].code_offset;
|
|
}
|
|
let const_pool = constants
|
|
.into_iter()
|
|
.map(|v| match v {
|
|
Value::Null => prometeu_bytecode::model::ConstantPoolEntry::Null,
|
|
Value::Int32(n) => prometeu_bytecode::model::ConstantPoolEntry::Int32(n),
|
|
Value::Int64(n) => prometeu_bytecode::model::ConstantPoolEntry::Int64(n),
|
|
Value::Float(n) => prometeu_bytecode::model::ConstantPoolEntry::Float64(n),
|
|
Value::Boolean(n) => prometeu_bytecode::model::ConstantPoolEntry::Boolean(n),
|
|
Value::String(n) => {
|
|
prometeu_bytecode::model::ConstantPoolEntry::String(n.to_string())
|
|
}
|
|
_ => panic!("non-constant fixture"),
|
|
})
|
|
.collect();
|
|
let bytes =
|
|
TestProgram { code, functions, const_pool, syscalls, ..Default::default() }.serialize();
|
|
let image = crate::ValidatedProgramImage::load(
|
|
&bytes,
|
|
&mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()),
|
|
prometeu_hal::syscalls::caps::ALL,
|
|
)
|
|
.unwrap();
|
|
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
|
|
vm.prepare_boot_call().unwrap();
|
|
vm
|
|
}
|
|
fn new_test_vm(mut code: Vec<u8>, constant_pool: Vec<Value>) -> VirtualMachine {
|
|
// Explicit scalar fixture entry; append HALT to instruction fragments.
|
|
code.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
typed_test_vm(
|
|
code,
|
|
constant_pool,
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
max_stack_slots: 256,
|
|
..Default::default()
|
|
}],
|
|
)
|
|
}
|
|
fn limited_session(code: Vec<u8>, limits: RuntimeLimits) -> VirtualMachine {
|
|
let v = new_test_vm(code, vec![]);
|
|
VirtualMachine::from_image(v.validated_image.unwrap(), limits)
|
|
}
|
|
fn fault_vm(rom: Vec<u8>, constant_pool: Vec<Value>) -> VirtualMachine {
|
|
let rom_len = rom.len() as u32;
|
|
let mut vm = VirtualMachine::fault_session(rom, constant_pool);
|
|
vm.program.functions = std::sync::Arc::from(vec![prometeu_bytecode::ExecutionFunction {
|
|
code_offset: 0,
|
|
code_len: rom_len,
|
|
..Default::default()
|
|
}]);
|
|
// Ensure tests start with a properly initialized entry context at func 0
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
vm
|
|
}
|
|
use crate::HostReturn;
|
|
use prometeu_bytecode::model::SyscallDecl;
|
|
use prometeu_bytecode::{
|
|
ExecutionFunction, TRAP_EXPLICIT, TRAP_INVALID_LOCAL, TRAP_OOB, TRAP_STACK_UNDERFLOW,
|
|
TRAP_TYPE, assemble, disassemble,
|
|
};
|
|
use prometeu_hal::expect_int;
|
|
|
|
struct MockNative;
|
|
impl NativeInterface for MockNative {
|
|
fn syscall(
|
|
&mut self,
|
|
_id: u32,
|
|
_args: &[Value],
|
|
_ret: &mut HostReturn,
|
|
_ctx: &mut HostContext,
|
|
) -> Result<(), VmFault> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn serialized_single_function_module(code: Vec<u8>, syscalls: Vec<SyscallDecl>) -> Vec<u8> {
|
|
TestProgram {
|
|
const_pool: vec![],
|
|
functions: vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
code_len: code.len() as u32,
|
|
|
|
signature: int64_signature(0, 0),
|
|
captures: vec![],
|
|
name: None,
|
|
local_slots: 0,
|
|
max_stack_slots: 256,
|
|
}],
|
|
code,
|
|
debug_info: None,
|
|
exports: vec![],
|
|
syscalls,
|
|
}
|
|
.serialize()
|
|
}
|
|
|
|
fn serialized_single_hostcall_module(syscall: SyscallDecl) -> Vec<u8> {
|
|
let mut source = String::new();
|
|
for _ in 0..syscall.arg_slots {
|
|
source.push_str("PUSH_I32 0\n");
|
|
}
|
|
source.push_str("HOSTCALL 0\nHALT");
|
|
let code = assemble(&source).expect("assemble");
|
|
serialized_single_function_module(code, vec![syscall])
|
|
}
|
|
|
|
#[test]
|
|
fn test_deterministic_pc_and_tick_trace_across_runs() {
|
|
// Program:
|
|
// PUSH_I32 1; YIELD; FrameSync;
|
|
// PUSH_I32 2; YIELD; FrameSync;
|
|
// PUSH_I32 3; FrameSync; HALT
|
|
// We collect (pc, tick, stack_height) after each run_budget slice and
|
|
// compare two independent VMs initialized from the same ROM.
|
|
let mut rom = Vec::new();
|
|
// PUSH 1
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1i32.to_le_bytes());
|
|
// YIELD + FrameSync
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
// PUSH 2
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&2i32.to_le_bytes());
|
|
// YIELD + FrameSync
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
// PUSH 3 + FrameSync + HALT
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&3i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm1 = new_test_vm(rom.clone(), vec![]);
|
|
let mut vm2 = new_test_vm(rom.clone(), vec![]);
|
|
|
|
let mut native = MockNative;
|
|
let mut ctx1 = HostContext::new(None);
|
|
let mut ctx2 = HostContext::new(None);
|
|
|
|
let mut trace1 = Vec::new();
|
|
let mut trace2 = Vec::new();
|
|
|
|
// Run both VMs in lockstep slices until both halt
|
|
for _ in 0..10 {
|
|
if !vm1.halted {
|
|
let rep = vm1.run_budget(4, &mut native, &mut ctx1).expect("vm1 ok");
|
|
trace1.push((
|
|
vm1.pc,
|
|
vm1.cycles,
|
|
vm1.operand_stack.len(),
|
|
format!("{:?}", rep.reason),
|
|
));
|
|
}
|
|
if !vm2.halted {
|
|
let rep = vm2.run_budget(4, &mut native, &mut ctx2).expect("vm2 ok");
|
|
trace2.push((
|
|
vm2.pc,
|
|
vm2.cycles,
|
|
vm2.operand_stack.len(),
|
|
format!("{:?}", rep.reason),
|
|
));
|
|
}
|
|
if vm1.halted && vm2.halted {
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert!(vm1.halted && vm2.halted, "Both VMs should reach HALT deterministically");
|
|
assert_eq!(trace1, trace2, "Per-slice traces must be identical across runs");
|
|
// Also verify final stack content deterministic
|
|
assert_eq!(vm1.pop().unwrap(), Value::Int32(3));
|
|
assert_eq!(vm1.pop().unwrap(), Value::Int32(2));
|
|
assert_eq!(vm1.pop().unwrap(), Value::Int32(1));
|
|
assert!(vm1.operand_stack.is_empty());
|
|
assert_eq!(vm2.pop().unwrap(), Value::Int32(3));
|
|
assert_eq!(vm2.pop().unwrap(), Value::Int32(2));
|
|
assert_eq!(vm2.pop().unwrap(), Value::Int32(1));
|
|
assert!(vm2.operand_stack.is_empty());
|
|
}
|
|
|
|
// fn test_arithmetic_chain() {
|
|
// let mut native = MockNative;
|
|
// let mut ctx = HostContext::new(None);
|
|
//
|
|
// // (10 + 20) * 2 / 5 % 4 = 12 * 2 / 5 % 4 = 60 / 5 % 4 = 12 % 4 = 0
|
|
// // wait: (10 + 20) = 30. 30 * 2 = 60. 60 / 5 = 12. 12 % 4 = 0.
|
|
// let mut rom = Vec::new();
|
|
// rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&10i32.to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&20i32.to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::Add as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&2i32.to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::Mul as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&5i32.to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::Div as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&4i32.to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::Mod as u16).to_le_bytes());
|
|
// rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
//
|
|
// let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
// vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
//
|
|
// assert_eq!(vm.pop().unwrap(), Value::Int32(0));
|
|
// }
|
|
|
|
#[test]
|
|
fn test_div_by_zero_trap() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&10i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Div as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_DIV_ZERO);
|
|
assert_eq!(trap.opcode, OpCode::Div as u16);
|
|
}
|
|
_ => panic!("Expected Trap, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_comparisons_polymorphic() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// 10 < 20.5 (true)
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&10i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushF64 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&20.5f64.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Lt as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.pop().unwrap(), Value::Boolean(true));
|
|
}
|
|
|
|
#[test]
|
|
fn test_push_i64_immediate() {
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI64 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i64.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.peek().unwrap(), &Value::Int64(42));
|
|
}
|
|
|
|
#[test]
|
|
fn test_push_f64_immediate() {
|
|
let value = 3.125f64;
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushF64 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&value.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.peek().unwrap(), &Value::Float(value));
|
|
}
|
|
|
|
#[test]
|
|
fn test_push_bool_immediate() {
|
|
let mut rom = Vec::new();
|
|
// True
|
|
rom.extend_from_slice(&(OpCode::PushBool as u16).to_le_bytes());
|
|
rom.push(1);
|
|
// False
|
|
rom.extend_from_slice(&(OpCode::PushBool as u16).to_le_bytes());
|
|
rom.push(0);
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.step(&mut native, &mut ctx).unwrap(); // Push true
|
|
assert_eq!(vm.peek().unwrap(), &Value::Boolean(true));
|
|
vm.step(&mut native, &mut ctx).unwrap(); // Push false
|
|
assert_eq!(vm.peek().unwrap(), &Value::Boolean(false));
|
|
}
|
|
|
|
#[test]
|
|
fn test_push_const_string() {
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushConst as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let cp = vec![Value::String("hello".into())];
|
|
let mut vm = new_test_vm(rom, cp);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.peek().unwrap(), &Value::String("hello".into()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_shared_string_clone_reuses_materialized_payload() {
|
|
let mut vm = VirtualMachine::default();
|
|
let payload: Arc<str> = "shared-global".into();
|
|
vm.globals.push(Value::String(payload.clone())).unwrap();
|
|
|
|
let cloned = vm.globals[0].clone();
|
|
match cloned {
|
|
Value::String(cloned_payload) => assert!(Arc::ptr_eq(&payload, &cloned_payload)),
|
|
other => panic!("expected string clone from globals, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_push_const_invalid_index_traps_oob() {
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushConst as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_OOB);
|
|
assert_eq!(trap.opcode, OpCode::PushConst as u16);
|
|
assert!(trap.message.contains("Invalid constant index"));
|
|
}
|
|
other => panic!("Expected Trap(OOB), got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_call_ret_scope_separation() {
|
|
let mut rom = Vec::new();
|
|
|
|
// entrypoint:
|
|
// PUSH_I64 10
|
|
// CALL func_id 1
|
|
// HALT
|
|
rom.extend_from_slice(&(OpCode::PushI64 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&10i64.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes()); // func_id 1
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let func_addr = rom.len();
|
|
|
|
// func:
|
|
// PUSH_I64 20
|
|
// GET_LOCAL 0 -- should be 10 (arg)
|
|
// ADD -- 10 + 20 = 30
|
|
// SET_LOCAL 0 -- store result in local 0 (the arg slot)
|
|
// GET_LOCAL 0 -- read 30 back
|
|
// RET
|
|
rom.extend_from_slice(&(OpCode::PushI64 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&20i64.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::GetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Add as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::SetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::GetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom,
|
|
vec![],
|
|
vec![
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
max_stack_slots: 256,
|
|
..Default::default()
|
|
},
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: func_addr as u32,
|
|
signature: int64_signature(1, 1),
|
|
max_stack_slots: 256,
|
|
..Default::default()
|
|
},
|
|
],
|
|
);
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// Run until Halt
|
|
let mut steps = 0;
|
|
while !vm.halted && steps < 100 {
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
steps += 1;
|
|
}
|
|
|
|
assert!(vm.halted);
|
|
assert_eq!(vm.pop_integer().unwrap(), 30);
|
|
assert_eq!(vm.operand_stack.len(), 0);
|
|
assert_eq!(vm.call_stack.len(), 1);
|
|
// Scope frames removed: no scope stack to assert on
|
|
}
|
|
|
|
#[test]
|
|
fn test_ret_mandatory_value() {
|
|
let mut rom = Vec::new();
|
|
// entrypoint: CALL func_id 1; HALT
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes()); // func_id 1
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let func_addr = rom.len();
|
|
// func: RET (SEM VALOR ANTES)
|
|
rom.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
|
|
let functions = vec![
|
|
ExecutionFunction { code_offset: 0, code_len: func_addr as u32, ..Default::default() },
|
|
ExecutionFunction {
|
|
code_offset: func_addr as u32,
|
|
code_len: (rom.len() - func_addr) as u32,
|
|
param_slots: 0,
|
|
return_slots: 1,
|
|
..Default::default()
|
|
},
|
|
];
|
|
|
|
let mut vm = VirtualMachine {
|
|
program: fault_cache(rom, vec![], functions, None, std::collections::HashMap::new()),
|
|
..Default::default()
|
|
};
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.step(&mut native, &mut ctx).unwrap(); // CALL
|
|
let res = vm.step(&mut native, &mut ctx); // RET -> should fail
|
|
assert!(res.is_err());
|
|
match res.unwrap_err() {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_BAD_RET_SLOTS);
|
|
}
|
|
_ => panic!("Expected Trap(TRAP_BAD_RET_SLOTS)"),
|
|
}
|
|
|
|
// Agora com valor de retorno
|
|
let mut rom2 = Vec::new();
|
|
rom2.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom2.extend_from_slice(&1u32.to_le_bytes());
|
|
rom2.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
let func_addr2 = rom2.len();
|
|
rom2.extend_from_slice(&(OpCode::PushI64 as u16).to_le_bytes());
|
|
rom2.extend_from_slice(&123i64.to_le_bytes());
|
|
rom2.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
|
|
let mut vm2 = typed_test_vm(
|
|
rom2,
|
|
vec![],
|
|
vec![
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
max_stack_slots: 256,
|
|
..Default::default()
|
|
},
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: func_addr2 as u32,
|
|
signature: int64_signature(0, 1),
|
|
max_stack_slots: 256,
|
|
..Default::default()
|
|
},
|
|
],
|
|
);
|
|
vm2.prepare_call("0").expect("prepare entry call");
|
|
vm2.step(&mut native, &mut ctx).unwrap(); // CALL
|
|
vm2.step(&mut native, &mut ctx).unwrap(); // PUSH_I64
|
|
vm2.step(&mut native, &mut ctx).unwrap(); // RET
|
|
|
|
assert_eq!(vm2.operand_stack.len(), 1);
|
|
assert_eq!(vm2.pop().unwrap(), Value::Int64(123));
|
|
}
|
|
|
|
// Scope tests removed under PR-2.1 (scope frames eliminated)
|
|
|
|
#[test]
|
|
fn test_push_i32() {
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.peek().unwrap(), &Value::Int32(42));
|
|
}
|
|
|
|
#[test]
|
|
fn test_bitwise_promotion() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// i32 & i32 -> i32
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0xF0i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0x0Fi32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::BitAnd as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.pop().unwrap(), Value::Int32(0));
|
|
|
|
// i32 | i64 -> i64
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0xF0i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI64 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0x0Fi64.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::BitOr as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.pop().unwrap(), Value::Int64(0xFF));
|
|
}
|
|
|
|
#[test]
|
|
fn test_comparisons_lte_gte() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// 10 <= 20 (true)
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&10i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&20i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Lte as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.pop().unwrap(), Value::Boolean(true));
|
|
|
|
// 20 >= 20 (true)
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&20i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&20i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Gte as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.pop().unwrap(), Value::Boolean(true));
|
|
}
|
|
|
|
#[test]
|
|
fn test_negation() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Neg as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.pop().unwrap(), Value::Int32(-42));
|
|
}
|
|
|
|
#[test]
|
|
fn test_jmp_if_true() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// Corrected Calculations:
|
|
// 0-1: PushBool
|
|
// 2: 1 (u8)
|
|
// 3-4: JmpIfTrue
|
|
// 5-8: addr (u32)
|
|
// 9-10: Halt (Offset 9)
|
|
// 11-12: PushI32 (Offset 11)
|
|
// 13-16: 100 (i32)
|
|
// 17-18: Halt
|
|
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushBool as u16).to_le_bytes());
|
|
rom.push(1);
|
|
rom.extend_from_slice(&(OpCode::JmpIfTrue as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(11u32).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes()); // Offset 9
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes()); // Offset 11
|
|
rom.extend_from_slice(&100i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
vm.step(&mut native, &mut ctx).unwrap(); // PushBool
|
|
vm.step(&mut native, &mut ctx).unwrap(); // JmpIfTrue
|
|
assert_eq!(vm.pc, 11);
|
|
vm.step(&mut native, &mut ctx).unwrap(); // PushI32
|
|
assert_eq!(vm.pop().unwrap(), Value::Int32(100));
|
|
}
|
|
|
|
#[test]
|
|
fn test_trap_opcode() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Trap as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_EXPLICIT);
|
|
assert_eq!(trap.opcode, OpCode::Trap as u16);
|
|
assert_eq!(trap.pc, 6);
|
|
assert!(trap.message.contains("Program requested trap"));
|
|
}
|
|
other => panic!("Expected Trap(TRAP_EXPLICIT), got {:?}", other),
|
|
}
|
|
assert_eq!(vm.pc, 8); // PushI32 (6 bytes) + Trap (2 bytes)
|
|
assert_eq!(vm.peek().unwrap(), &Value::Int32(42));
|
|
}
|
|
|
|
#[test]
|
|
fn test_debugger_breakpoint_remains_distinct_from_trap_opcode() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Trap as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom, vec![]);
|
|
vm.insert_breakpoint(6);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
assert_eq!(report.reason, LogicalFrameEndingReason::Breakpoint);
|
|
assert_eq!(vm.pc, 6);
|
|
assert_eq!(vm.peek().unwrap(), &Value::Int32(42));
|
|
}
|
|
|
|
#[test]
|
|
fn test_pop_n_opcode() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&2i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&3i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PopN as u16).to_le_bytes());
|
|
rom.extend_from_slice(&2u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
assert_eq!(vm.pop().unwrap(), Value::Int32(1));
|
|
assert!(vm.pop().is_err()); // Stack should be empty
|
|
}
|
|
|
|
#[test]
|
|
fn test_entry_point_ret_with_prepare_call() {
|
|
// PushI32 0 (0x17), then Ret (0x51)
|
|
let rom = vec![
|
|
0x17, 0x00, // PushI32
|
|
0x00, 0x00, 0x00, 0x00, // value 0
|
|
0x11, 0x00, // Pop
|
|
0x51, 0x00, // Ret
|
|
];
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
}],
|
|
);
|
|
|
|
let mut ctx = HostContext::new(None);
|
|
struct TestNative;
|
|
impl NativeInterface for TestNative {
|
|
fn syscall(
|
|
&mut self,
|
|
_id: u32,
|
|
_args: &[Value],
|
|
_ret: &mut HostReturn,
|
|
_ctx: &mut HostContext,
|
|
) -> Result<(), VmFault> {
|
|
Ok(())
|
|
}
|
|
}
|
|
let mut native = TestNative;
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let result = vm.run_budget(100, &mut native, &mut ctx).expect("VM run failed");
|
|
assert_eq!(result.reason, LogicalFrameEndingReason::EndOfRom);
|
|
}
|
|
|
|
#[test]
|
|
fn test_syscall_abi_multi_slot_return() {
|
|
let rom = vec![
|
|
0x70, 0x00, // Syscall + Reserved
|
|
0x01, 0x00, 0x00, 0x00, // Syscall ID 1
|
|
];
|
|
|
|
struct MultiReturnNative;
|
|
impl NativeInterface for MultiReturnNative {
|
|
fn syscall(
|
|
&mut self,
|
|
_id: u32,
|
|
_args: &[Value],
|
|
ret: &mut HostReturn,
|
|
_ctx: &mut HostContext,
|
|
) -> Result<(), VmFault> {
|
|
ret.push_bool(true);
|
|
ret.push_int(42);
|
|
ret.push_int(255);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let mut native = MultiReturnNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
// Ensure we have SYSTEM capability so we pass capability gate
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::SYSTEM);
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
// Under PR5, VM enforces return-slot count based on SyscallMeta during syscall
|
|
// execution. A mismatch yields a Panic with a descriptive message.
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Panic(msg) => {
|
|
assert!(msg.contains("results mismatch"));
|
|
}
|
|
_ => panic!("Expected Panic with results mismatch, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_syscall_abi_void_return() {
|
|
let rom = vec![
|
|
0x70, 0x00, // Syscall + Reserved
|
|
0x01, 0x00, 0x00, 0x00, // Syscall ID 1
|
|
];
|
|
|
|
struct VoidReturnNative;
|
|
impl NativeInterface for VoidReturnNative {
|
|
fn syscall(
|
|
&mut self,
|
|
_id: u32,
|
|
_args: &[Value],
|
|
_ret: &mut HostReturn,
|
|
_ctx: &mut HostContext,
|
|
) -> Result<(), VmFault> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let mut native = VoidReturnNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
vm.operand_stack.push(Value::Int32(100)).unwrap();
|
|
vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
assert_eq!(vm.pop().unwrap(), Value::Int32(100));
|
|
assert!(vm.operand_stack.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_syscall_arg_type_mismatch_trap() {
|
|
// GfxClear (0x1001) takes 1 argument
|
|
let rom = vec![
|
|
0x16, 0x00, // PushBool + Reserved
|
|
0x01, // value 1 (true)
|
|
0x70, 0x00, // Syscall + Reserved
|
|
0x01, 0x10, 0x00, 0x00, // Syscall ID 0x1001
|
|
];
|
|
|
|
struct ArgCheckNative;
|
|
impl NativeInterface for ArgCheckNative {
|
|
fn syscall(
|
|
&mut self,
|
|
_id: u32,
|
|
args: &[Value],
|
|
_ret: &mut HostReturn,
|
|
_ctx: &mut HostContext,
|
|
) -> Result<(), VmFault> {
|
|
expect_int(args, 0)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
let mut native = ArgCheckNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
// Ensure we have GFX capability so we reach type checking inside native handler
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_TYPE);
|
|
assert_eq!(trap.opcode, OpCode::Syscall as u16);
|
|
}
|
|
_ => panic!("Expected Trap, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_add_invalid_types_traps_type() {
|
|
let rom = assemble("PUSH_I32 1\nPUSH_BOOL 1\nADD\nHALT").expect("assemble");
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_TYPE);
|
|
assert_eq!(trap.opcode, OpCode::Add as u16);
|
|
assert!(trap.message.contains("Invalid types for ADD"));
|
|
}
|
|
other => panic!("Expected Trap(TYPE), got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_add_stack_underflow_traps() {
|
|
let rom = assemble("PUSH_I32 1\nADD\nHALT").expect("assemble");
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_STACK_UNDERFLOW);
|
|
assert_eq!(trap.opcode, OpCode::Add as u16);
|
|
assert!(trap.message.contains("requires two operands"));
|
|
}
|
|
other => panic!("Expected Trap(STACK_UNDERFLOW), got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_and_invalid_types_traps_type() {
|
|
let rom = assemble("PUSH_I32 1\nPUSH_BOOL 1\nAND\nHALT").expect("assemble");
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_TYPE);
|
|
assert_eq!(trap.opcode, OpCode::And as u16);
|
|
assert!(trap.message.contains("Invalid types for AND"));
|
|
}
|
|
other => panic!("Expected Trap(TYPE), got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_not_invalid_type_traps_type() {
|
|
let rom = assemble("PUSH_I32 1\nNOT\nHALT").expect("assemble");
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_TYPE);
|
|
assert_eq!(trap.opcode, OpCode::Not as u16);
|
|
assert!(trap.message.contains("Invalid type for NOT"));
|
|
}
|
|
other => panic!("Expected Trap(TYPE), got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_neg_invalid_type_traps_type() {
|
|
let rom = assemble("PUSH_BOOL 1\nNEG\nHALT").expect("assemble");
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_TYPE);
|
|
assert_eq!(trap.opcode, OpCode::Neg as u16);
|
|
assert!(trap.message.contains("Invalid type for Neg"));
|
|
}
|
|
other => panic!("Expected Trap(TYPE), got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_pop_underflow_traps() {
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::Pop as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_STACK_UNDERFLOW);
|
|
assert_eq!(trap.opcode, OpCode::Pop as u16);
|
|
assert!(trap.message.contains("POP requires one operand"));
|
|
}
|
|
other => panic!("Expected Trap(STACK_UNDERFLOW), got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_invalid_syscall_trap() {
|
|
let rom = vec![
|
|
0x70, 0x00, // Syscall + Reserved
|
|
0xEF, 0xBE, 0xAD, 0xDE, // 0xDEADBEEF
|
|
];
|
|
let mut vm = fault_vm(rom.clone(), vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
// Grant GFX capability so arg underflow is checked (capability gate is first)
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_INVALID_SYSCALL);
|
|
assert_eq!(trap.opcode, OpCode::Syscall as u16);
|
|
assert!(trap.message.contains("Unknown syscall"));
|
|
assert_eq!(trap.pc, 0);
|
|
}
|
|
_ => panic!("Expected Trap, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_intrinsic_vec2_dot_executes_without_syscalls() {
|
|
let mut rom = Vec::new();
|
|
for value in [1.0f64, 2.0, 3.0, 4.0] {
|
|
rom.extend_from_slice(&(OpCode::PushF64 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&value.to_bits().to_le_bytes());
|
|
}
|
|
rom.extend_from_slice(&(OpCode::Intrinsic as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0x1000u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
let mut vm = new_test_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert!(matches!(report.reason, LogicalFrameEndingReason::Halted));
|
|
assert_eq!(vm.operand_stack, vec![Value::Float(11.0)]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_intrinsic_vec2_length_executes_without_syscalls() {
|
|
let mut rom = Vec::new();
|
|
for value in [3.0f64, 4.0] {
|
|
rom.extend_from_slice(&(OpCode::PushF64 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&value.to_bits().to_le_bytes());
|
|
}
|
|
rom.extend_from_slice(&(OpCode::Intrinsic as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0x1001u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
let mut vm = new_test_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert!(matches!(report.reason, LogicalFrameEndingReason::Halted));
|
|
assert_eq!(vm.operand_stack, vec![Value::Float(5.0)]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_removed_input_endpoint_is_an_unknown_intrinsic() {
|
|
let rom = assemble("INTRINSIC 0x2000\nHALT").expect("assemble");
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert!(
|
|
matches!(report.reason, LogicalFrameEndingReason::Trap(trap) if trap.code == TRAP_INVALID_INTRINSIC)
|
|
);
|
|
assert!(vm.operand_stack.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_intrinsic_input_touch_x_requires_hardware_context() {
|
|
let rom = assemble("INTRINSIC 0x2134\nHALT").expect("assemble");
|
|
let mut vm = new_test_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_UNAVAILABLE);
|
|
assert_eq!(trap.pc, 0);
|
|
assert_eq!(trap.opcode, OpCode::Intrinsic as u16);
|
|
}
|
|
other => panic!("Expected unavailable input trap, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_invalid_intrinsic_trap_is_distinct_from_syscall() {
|
|
let rom = assemble("INTRINSIC 0xDEADBEEF\nHALT").expect("assemble");
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_INVALID_INTRINSIC);
|
|
assert_eq!(trap.opcode, OpCode::Intrinsic as u16);
|
|
assert!(trap.message.contains("Unknown intrinsic"));
|
|
}
|
|
_ => panic!("Expected intrinsic trap, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_intrinsic_argument_underflow_trap() {
|
|
let rom = assemble("PUSH_I32 1\nINTRINSIC 0x1000\nHALT").expect("assemble");
|
|
let mut vm = fault_vm(rom, vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_STACK_UNDERFLOW);
|
|
assert_eq!(trap.opcode, OpCode::Intrinsic as u16);
|
|
assert!(trap.message.contains("Intrinsic argument stack underflow"));
|
|
}
|
|
_ => panic!("Expected intrinsic underflow trap, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_syscall_arg_underflow_trap() {
|
|
// GfxClear (0x1001) expects 1 arg
|
|
let rom = vec![
|
|
0x70, 0x00, // Syscall + Reserved
|
|
0x01, 0x10, 0x00, 0x00, // Syscall ID 0x1001
|
|
];
|
|
let mut vm = fault_vm(rom.clone(), vec![]);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
// Grant GFX capability so arg underflow is checked (capability gate is first)
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_STACK_UNDERFLOW);
|
|
assert_eq!(trap.opcode, OpCode::Syscall as u16);
|
|
assert!(trap.message.contains("underflow"));
|
|
assert_eq!(trap.pc, 0);
|
|
}
|
|
_ => panic!("Expected Trap, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_syscall_missing_capability_trap() {
|
|
// Program: directly call GfxClear (0x1001). We check caps before args, so no underflow.
|
|
let mut rom = vec![
|
|
0x70, 0x00, // Syscall + Reserved
|
|
0x01, 0x10, 0x00, 0x00, // Syscall ID 0x1001 (LE)
|
|
];
|
|
|
|
// Seal a valid invocation; then explicitly corrupt installed capabilities.
|
|
let mut prefix = assemble("PUSH_I64 0").unwrap();
|
|
prefix.append(&mut rom);
|
|
let mut vm = new_test_vm(prefix, vec![]);
|
|
// Remove all capabilities
|
|
vm.set_capabilities(0);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_INVALID_SYSCALL);
|
|
assert_eq!(trap.opcode, OpCode::Syscall as u16);
|
|
assert!(trap.message.contains("Missing capability"));
|
|
assert_eq!(trap.pc, 10);
|
|
}
|
|
other => panic!("Expected Trap, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_syscall_with_capability_success() {
|
|
// Program: push arg 0; call GfxClear (0x1001)
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Syscall as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0x1001u32.to_le_bytes()); // GfxClear
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
// Grant only GFX capability
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
// Any non-trap outcome is considered success here
|
|
if let LogicalFrameEndingReason::Trap(trap) = report.reason {
|
|
panic!("Unexpected trap: {:?}", trap);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_syscall_results_count_mismatch_panic() {
|
|
// GfxClear (0x1001) expects 0 results
|
|
let rom = vec![
|
|
0x17, 0x00, // PushI32
|
|
0x00, 0x00, 0x00, 0x00, // value 0
|
|
0x70, 0x00, // Syscall + Reserved
|
|
0x01, 0x10, 0x00, 0x00, // Syscall ID 0x1001
|
|
];
|
|
|
|
struct BadNative;
|
|
impl NativeInterface for BadNative {
|
|
fn syscall(
|
|
&mut self,
|
|
_id: u32,
|
|
_args: &[Value],
|
|
ret: &mut HostReturn,
|
|
_ctx: &mut HostContext,
|
|
) -> Result<(), VmFault> {
|
|
// Wrong: GfxClear is void but we push something
|
|
ret.push_int(42);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
let mut vm = new_test_vm(rom.clone(), vec![]);
|
|
// Grant GFX capability so results mismatch path is exercised
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
let mut native = BadNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Panic(msg) => assert!(msg.contains("results mismatch")),
|
|
_ => panic!("Expected Panic, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_status_first_syscall_results_count_mismatch_panic() {
|
|
// ComposerBindScene (0x1101) expects 1 result.
|
|
let code = assemble("PUSH_I32 0\nSYSCALL 0x1101").expect("assemble");
|
|
|
|
struct BadNativeNoReturn;
|
|
impl NativeInterface for BadNativeNoReturn {
|
|
fn syscall(
|
|
&mut self,
|
|
_id: u32,
|
|
_args: &[Value],
|
|
_ret: &mut HostReturn,
|
|
_ctx: &mut HostContext,
|
|
) -> Result<(), VmFault> {
|
|
// Wrong: status-first syscall must return one status slot.
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
let mut vm = new_test_vm(code, vec![]);
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
let mut native = BadNativeNoReturn;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).expect("run");
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Panic(msg) => assert!(msg.contains("results mismatch")),
|
|
other => panic!("Expected Panic, got {:?}", other),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_hardening_invalid_magic() {
|
|
let mut vm = VirtualMachine::default();
|
|
let res = vm.initialize(vec![0, 0, 0, 0]);
|
|
assert!(matches!(res, Err(VmInitError::RegistryLoadFailed(_))));
|
|
// VM should remain empty
|
|
assert_eq!(vm.program.rom.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_hardening_unsupported_version() {
|
|
let mut vm = VirtualMachine::default();
|
|
let mut header = vec![0u8; 32];
|
|
header[0..4].copy_from_slice(&prometeu_bytecode::PBX_MAGIC);
|
|
header[4..6].copy_from_slice(&1u16.to_le_bytes()); // unsupported version
|
|
|
|
let res = vm.initialize(header);
|
|
assert!(
|
|
matches!(res,Err(VmInitError::RegistryLoadFailed(e)) if e.reason == prometeu_bytecode::load_limits::LoadReason::Version)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_hardening_malformed_pbx_v0() {
|
|
let mut vm = VirtualMachine::default();
|
|
let mut header = vec![0u8; 32];
|
|
header[0..4].copy_from_slice(&prometeu_bytecode::PBX_MAGIC);
|
|
header[4..6].copy_from_slice(&0u16.to_le_bytes());
|
|
header[8..12].copy_from_slice(&1u32.to_le_bytes()); // missing directory
|
|
|
|
let res = vm.initialize(header);
|
|
match res {
|
|
Err(VmInitError::RegistryLoadFailed(_)) => {}
|
|
_ => panic!("Expected PBX v0 load failure UnexpectedEof, got {:?}", res),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_hardening_boot_protocol_entrypoint_not_found() {
|
|
let mut vm = VirtualMachine::default();
|
|
let header = TestProgram {
|
|
const_pool: vec![],
|
|
functions: vec![],
|
|
code: vec![],
|
|
debug_info: None,
|
|
exports: vec![],
|
|
syscalls: vec![],
|
|
}
|
|
.serialize();
|
|
|
|
let res = vm.initialize(header);
|
|
assert!(matches!(res, Err(VmInitError::RegistryLoadFailed(_))));
|
|
|
|
// VM state should not be updated
|
|
assert_eq!(vm.pc, 0);
|
|
assert_eq!(vm.program.rom.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_hardening_successful_init() {
|
|
let mut vm = VirtualMachine { pc: 123, ..Default::default() };
|
|
let code = assemble("HALT").expect("assemble");
|
|
|
|
let header = TestProgram {
|
|
const_pool: vec![],
|
|
functions: vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
code_len: code.len() as u32,
|
|
|
|
signature: int64_signature(0, 0),
|
|
captures: vec![],
|
|
name: None,
|
|
local_slots: 0,
|
|
max_stack_slots: 256,
|
|
}],
|
|
code,
|
|
debug_info: None,
|
|
exports: vec![],
|
|
syscalls: vec![],
|
|
}
|
|
.serialize();
|
|
|
|
let res = vm.initialize(header);
|
|
assert!(res.is_ok());
|
|
assert_eq!(vm.pc, 0);
|
|
assert_eq!(vm.program.rom.len(), 2);
|
|
assert_eq!(vm.cycles, 0);
|
|
|
|
vm.prepare_boot_call().expect("prepare entry call");
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).expect("run loaded PBX");
|
|
assert_eq!(report.reason, LogicalFrameEndingReason::Halted);
|
|
assert!(vm.is_halted());
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_rewrites_hostcall_before_verification() {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
|
|
let code = assemble("PUSH_I32 0\nHOSTCALL 0\nHALT").expect("assemble");
|
|
let bytes = serialized_single_function_module(
|
|
code,
|
|
vec![SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "clear".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
}],
|
|
);
|
|
|
|
let res = vm.initialize(bytes);
|
|
|
|
assert!(res.is_ok(), "patched hostcall should initialize");
|
|
|
|
let text = disassemble(&vm.program.rom).expect("disassemble patched rom");
|
|
assert!(text.contains("SYSCALL 0x1001"));
|
|
assert!(!text.contains("HOSTCALL"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_rejects_hostcall_index_out_of_bounds() {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
|
|
let code = assemble("HOSTCALL 1\nHALT").expect("assemble");
|
|
let bytes = serialized_single_function_module(
|
|
code,
|
|
vec![SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "clear".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
}],
|
|
);
|
|
|
|
let res = vm.initialize(bytes);
|
|
|
|
assert_eq!(
|
|
res,
|
|
Err(VmInitError::LoaderPatchFailed(
|
|
crate::vm_init_error::LoaderPatchError::HostcallIndexOutOfBounds {
|
|
pc: 0,
|
|
sysc_index: 1,
|
|
syscalls_len: 1,
|
|
},
|
|
))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_rejects_unused_syscall_decl() {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
|
|
let code = assemble("PUSH_I32 0\nHOSTCALL 0\nHALT").expect("assemble");
|
|
let bytes = serialized_single_function_module(
|
|
code,
|
|
vec![
|
|
SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "clear".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
},
|
|
SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "draw_text".into(),
|
|
version: 1,
|
|
arg_slots: 4,
|
|
ret_slots: 0,
|
|
},
|
|
],
|
|
);
|
|
|
|
let res = vm.initialize(bytes);
|
|
|
|
assert_eq!(
|
|
res,
|
|
Err(VmInitError::LoaderPatchFailed(
|
|
crate::vm_init_error::LoaderPatchError::UnusedSyscallDecl {
|
|
sysc_index: 1,
|
|
module: "gfx2d".into(),
|
|
name: "draw_text".into(),
|
|
version: 1,
|
|
},
|
|
))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_rejects_raw_syscall_in_preload_artifact() {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
|
|
let code = assemble("PUSH_I32 0\nSYSCALL 0x1001\nHALT").expect("assemble");
|
|
let bytes = serialized_single_function_module(
|
|
code,
|
|
vec![SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "clear".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
}],
|
|
);
|
|
|
|
let res = vm.initialize(bytes);
|
|
|
|
assert_eq!(
|
|
res,
|
|
Err(VmInitError::LoaderPatchFailed(
|
|
crate::vm_init_error::LoaderPatchError::RawSyscallInPreloadArtifact {
|
|
pc: 6,
|
|
syscall_id: 0x1001,
|
|
},
|
|
))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_propagates_resolution_failure() {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
|
|
let code = assemble("HOSTCALL 0\nHALT").expect("assemble");
|
|
let bytes = serialized_single_function_module(
|
|
code,
|
|
vec![SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "missing".into(),
|
|
version: 1,
|
|
arg_slots: 0,
|
|
ret_slots: 0,
|
|
}],
|
|
);
|
|
|
|
let res = vm.initialize(bytes);
|
|
|
|
assert_eq!(
|
|
res,
|
|
Err(VmInitError::LoaderPatchFailed(
|
|
crate::vm_init_error::LoaderPatchError::ResolveFailed(
|
|
prometeu_hal::syscalls::DeclaredLoadError::UnknownSyscall {
|
|
module: "gfx2d".into(),
|
|
name: "missing".into(),
|
|
version: 1,
|
|
},
|
|
),
|
|
))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_propagates_missing_capability() {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::NONE);
|
|
|
|
let code = assemble("HOSTCALL 0\nHALT").expect("assemble");
|
|
let bytes = serialized_single_function_module(
|
|
code,
|
|
vec![SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "clear".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
}],
|
|
);
|
|
|
|
let res = vm.initialize(bytes);
|
|
|
|
assert_eq!(
|
|
res,
|
|
Err(VmInitError::LoaderPatchFailed(
|
|
crate::vm_init_error::LoaderPatchError::ResolveFailed(
|
|
prometeu_hal::syscalls::DeclaredLoadError::MissingCapability {
|
|
required: prometeu_hal::syscalls::caps::GFX2D,
|
|
provided: prometeu_hal::syscalls::caps::NONE,
|
|
module: "gfx2d".into(),
|
|
name: "clear".into(),
|
|
version: 1,
|
|
},
|
|
),
|
|
))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_propagates_abi_mismatch() {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::GFX);
|
|
|
|
let code = assemble("HOSTCALL 0\nHALT").expect("assemble");
|
|
let bytes = serialized_single_function_module(
|
|
code,
|
|
vec![SyscallDecl {
|
|
module: "gfx2d".into(),
|
|
name: "draw_line".into(),
|
|
version: 1,
|
|
arg_slots: 4,
|
|
ret_slots: 0,
|
|
}],
|
|
);
|
|
|
|
let res = vm.initialize(bytes);
|
|
|
|
assert_eq!(
|
|
res,
|
|
Err(VmInitError::LoaderPatchFailed(
|
|
crate::vm_init_error::LoaderPatchError::ResolveFailed(
|
|
prometeu_hal::syscalls::DeclaredLoadError::AbiMismatch {
|
|
module: "gfx2d".into(),
|
|
name: "draw_line".into(),
|
|
version: 1,
|
|
declared_arg_slots: 4,
|
|
declared_ret_slots: 0,
|
|
expected_arg_slots: 5,
|
|
expected_ret_slots: 0,
|
|
},
|
|
),
|
|
))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_accepts_status_first_signatures() {
|
|
let cases = vec![
|
|
SyscallDecl {
|
|
module: "composer".into(),
|
|
name: "bind_scene".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 1,
|
|
},
|
|
SyscallDecl {
|
|
module: "composer".into(),
|
|
name: "unbind_scene".into(),
|
|
version: 1,
|
|
arg_slots: 0,
|
|
ret_slots: 1,
|
|
},
|
|
SyscallDecl {
|
|
module: "composer".into(),
|
|
name: "emit_sprite".into(),
|
|
version: 1,
|
|
arg_slots: 9,
|
|
ret_slots: 1,
|
|
},
|
|
SyscallDecl {
|
|
module: "audio".into(),
|
|
name: "play_sample".into(),
|
|
version: 1,
|
|
arg_slots: 5,
|
|
ret_slots: 1,
|
|
},
|
|
SyscallDecl {
|
|
module: "audio".into(),
|
|
name: "play".into(),
|
|
version: 1,
|
|
arg_slots: 7,
|
|
ret_slots: 1,
|
|
},
|
|
SyscallDecl {
|
|
module: "asset".into(),
|
|
name: "load".into(),
|
|
version: 1,
|
|
arg_slots: 2,
|
|
ret_slots: 2,
|
|
},
|
|
SyscallDecl {
|
|
module: "asset".into(),
|
|
name: "commit".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 1,
|
|
},
|
|
SyscallDecl {
|
|
module: "asset".into(),
|
|
name: "cancel".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 1,
|
|
},
|
|
];
|
|
|
|
for syscall in cases {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::ALL);
|
|
let bytes = serialized_single_hostcall_module(syscall);
|
|
let res = vm.initialize(bytes);
|
|
assert!(res.is_ok(), "status-first signature must be accepted: {:?}", res);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_patching_rejects_legacy_status_first_ret_slots() {
|
|
let cases = vec![
|
|
SyscallDecl {
|
|
module: "composer".into(),
|
|
name: "bind_scene".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
},
|
|
SyscallDecl {
|
|
module: "audio".into(),
|
|
name: "play_sample".into(),
|
|
version: 1,
|
|
arg_slots: 5,
|
|
ret_slots: 0,
|
|
},
|
|
SyscallDecl {
|
|
module: "audio".into(),
|
|
name: "play".into(),
|
|
version: 1,
|
|
arg_slots: 7,
|
|
ret_slots: 0,
|
|
},
|
|
SyscallDecl {
|
|
module: "asset".into(),
|
|
name: "load".into(),
|
|
version: 1,
|
|
arg_slots: 2,
|
|
ret_slots: 1,
|
|
},
|
|
SyscallDecl {
|
|
module: "asset".into(),
|
|
name: "commit".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
},
|
|
SyscallDecl {
|
|
module: "asset".into(),
|
|
name: "cancel".into(),
|
|
version: 1,
|
|
arg_slots: 1,
|
|
ret_slots: 0,
|
|
},
|
|
];
|
|
|
|
for syscall in cases {
|
|
let mut vm = VirtualMachine::default();
|
|
vm.set_capabilities(prometeu_hal::syscalls::caps::ALL);
|
|
let bytes = serialized_single_hostcall_module(syscall.clone());
|
|
let err = vm.initialize(bytes).expect_err("legacy ABI must be rejected");
|
|
match err {
|
|
VmInitError::LoaderPatchFailed(
|
|
crate::vm_init_error::LoaderPatchError::ResolveFailed(
|
|
prometeu_hal::syscalls::DeclaredLoadError::AbiMismatch {
|
|
module,
|
|
name,
|
|
version,
|
|
declared_arg_slots,
|
|
declared_ret_slots,
|
|
expected_arg_slots,
|
|
expected_ret_slots,
|
|
},
|
|
),
|
|
) => {
|
|
assert_eq!(module, syscall.module);
|
|
assert_eq!(name, syscall.name);
|
|
assert_eq!(version, syscall.version);
|
|
assert_eq!(declared_arg_slots, syscall.arg_slots);
|
|
assert_eq!(declared_ret_slots, syscall.ret_slots);
|
|
|
|
assert_eq!(expected_arg_slots, declared_arg_slots);
|
|
assert_ne!(expected_ret_slots, declared_ret_slots);
|
|
}
|
|
other => panic!("expected ABI mismatch, got {:?}", other),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_hardening_missing_sysc_section() {
|
|
let mut vm = VirtualMachine::default();
|
|
let base = serialized_single_function_module(assemble("HALT").unwrap(), vec![]);
|
|
// Deliberately malformed envelope: remove one directory record and relocate payloads.
|
|
let mut header = base;
|
|
let count = u32::from_le_bytes(header[8..12].try_into().unwrap()) as usize;
|
|
let index = (0..count)
|
|
.find(|i| u32::from_le_bytes(header[32 + 12 * i..36 + 12 * i].try_into().unwrap()) == 5)
|
|
.unwrap();
|
|
header.drain(32 + 12 * index..44 + 12 * index);
|
|
header[8..12].copy_from_slice(&((count - 1) as u32).to_le_bytes());
|
|
for i in 0..count - 1 {
|
|
let pos = 36 + 12 * i;
|
|
let offset = u32::from_le_bytes(header[pos..pos + 4].try_into().unwrap()) - 12;
|
|
header[pos..pos + 4].copy_from_slice(&offset.to_le_bytes());
|
|
}
|
|
let res = vm.initialize(header);
|
|
|
|
assert!(
|
|
matches!(res,Err(VmInitError::RegistryLoadFailed(e)) if e.reason==prometeu_bytecode::load_limits::LoadReason::MissingSection && e.section==Some(5))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_loader_hardening_duplicate_sysc_identity() {
|
|
let mut vm = VirtualMachine::default();
|
|
|
|
use prometeu_bytecode::registry_codec::{PbxEnvelope, SectionData, encode_envelope};
|
|
let base = serialized_single_function_module(
|
|
assemble("HOSTCALL 0\nHALT").unwrap(),
|
|
vec![SyscallDecl {
|
|
module: "system".into(),
|
|
name: "has_cart".into(),
|
|
version: 1,
|
|
arg_slots: 0,
|
|
ret_slots: 1,
|
|
}],
|
|
);
|
|
let mut budget = prometeu_bytecode::load_limits::LoadBudget::new(Default::default());
|
|
let envelope = PbxEnvelope::parse(&base, &mut budget).unwrap();
|
|
let syscall = envelope.section(5).unwrap().bytes;
|
|
let mut duplicate = 2u32.to_le_bytes().to_vec();
|
|
duplicate.extend_from_slice(&syscall[4..]);
|
|
duplicate.extend_from_slice(&syscall[4..]);
|
|
let sections: Vec<_> = (0..9)
|
|
.filter_map(|kind| {
|
|
envelope.section(kind).map(|section| SectionData {
|
|
kind,
|
|
bytes: if kind == 5 { &duplicate } else { section.bytes },
|
|
})
|
|
})
|
|
.collect();
|
|
let bytes = encode_envelope(§ions, &mut budget).unwrap();
|
|
let res = vm.initialize(bytes);
|
|
|
|
assert!(
|
|
matches!(res,Err(VmInitError::RegistryLoadFailed(e)) if e.reason==prometeu_bytecode::load_limits::LoadReason::DuplicateSyscall)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_calling_convention_add() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// F0 (entry):
|
|
// PUSH_I32 10
|
|
// PUSH_I32 20
|
|
// CALL 1 (add)
|
|
// HALT
|
|
// F1 (add):
|
|
// GET_LOCAL 0 (a)
|
|
// GET_LOCAL 1 (b)
|
|
// ADD
|
|
// RET (1 slot)
|
|
|
|
let mut rom = Vec::new();
|
|
// F0
|
|
let f0_start = 0;
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&10i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&20i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
// F1
|
|
let f1_start = rom.len() as u32;
|
|
rom.extend_from_slice(&(OpCode::GetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::GetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Add as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: f0_start as u32,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
},
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: f1_start,
|
|
|
|
signature: scalar_signature(2, 1, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
},
|
|
],
|
|
);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert_eq!(report.reason, LogicalFrameEndingReason::Halted);
|
|
assert_eq!(vm.operand_stack.last().unwrap(), &Value::Int32(30));
|
|
}
|
|
|
|
#[test]
|
|
fn test_calling_convention_multi_slot_return() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// F0:
|
|
// CALL 1
|
|
// HALT
|
|
// F1:
|
|
// PUSH_I32 100
|
|
// PUSH_I32 200
|
|
// RET (2 slots)
|
|
|
|
let mut rom = Vec::new();
|
|
// F0
|
|
let f0_start = 0;
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
// F1
|
|
let f1_start = rom.len() as u32;
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&100i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&200i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: f0_start as u32,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
},
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: f1_start,
|
|
|
|
signature: scalar_signature(0, 2, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
},
|
|
],
|
|
);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert_eq!(report.reason, LogicalFrameEndingReason::Halted);
|
|
// Stack should be [100, 200]
|
|
assert_eq!(vm.operand_stack.len(), 2);
|
|
assert_eq!(vm.operand_stack[0], Value::Int32(100));
|
|
assert_eq!(vm.operand_stack[1], Value::Int32(200));
|
|
}
|
|
|
|
#[test]
|
|
fn test_calling_convention_void_call() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// F0:
|
|
// PUSH_I32 42
|
|
// CALL 1
|
|
// HALT
|
|
// F1:
|
|
// POP
|
|
// RET (0 slots)
|
|
|
|
let mut rom = Vec::new();
|
|
let f0_start = 0;
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let f1_start = rom.len() as u32;
|
|
rom.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: f0_start as u32,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
},
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: f1_start,
|
|
|
|
signature: scalar_signature(1, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
},
|
|
],
|
|
);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert_eq!(report.reason, LogicalFrameEndingReason::Halted);
|
|
assert_eq!(vm.operand_stack.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_trap_invalid_func() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// CALL 99 (invalid)
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&99u32.to_le_bytes());
|
|
|
|
let mut vm = fault_vm(rom.clone(), vec![]);
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_INVALID_FUNC);
|
|
assert_eq!(trap.opcode, OpCode::Call as u16);
|
|
}
|
|
_ => panic!("Expected Trap(TRAP_INVALID_FUNC), got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_trap_bad_ret_slots() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// F0: CALL 1; HALT
|
|
// F1: PUSH_I32 42; RET (expected 0 slots)
|
|
|
|
let mut rom = Vec::new();
|
|
let f0_start = 0;
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
let f0_len = rom.len() - f0_start;
|
|
|
|
let f1_start = rom.len() as u32;
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
let f1_len = rom.len() as u32 - f1_start;
|
|
|
|
let mut vm = fault_vm(rom.clone(), vec![]);
|
|
vm.program.functions = std::sync::Arc::from(vec![
|
|
ExecutionFunction {
|
|
code_offset: f0_start as u32,
|
|
code_len: f0_len as u32,
|
|
..Default::default()
|
|
},
|
|
ExecutionFunction {
|
|
code_offset: f1_start,
|
|
code_len: f1_len,
|
|
param_slots: 0,
|
|
return_slots: 0, // ERROR: function pushes 42 but returns 0
|
|
..Default::default()
|
|
},
|
|
]);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_BAD_RET_SLOTS);
|
|
assert_eq!(trap.opcode, OpCode::Ret as u16);
|
|
assert!(trap.message.contains("Incorrect stack height"));
|
|
}
|
|
_ => panic!("Expected Trap(TRAP_BAD_RET_SLOTS), got {:?}", report.reason),
|
|
}
|
|
}
|
|
#[test]
|
|
fn test_locals_round_trip() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// PUSH_I32 42
|
|
// SET_LOCAL 0
|
|
// PUSH_I32 0 (garbage)
|
|
// GET_LOCAL 0
|
|
// RET (1 slot)
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::SetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Pop as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::GetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
local_slots: 1,
|
|
|
|
signature: scalar_signature(0, 1, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
}],
|
|
);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert_eq!(report.reason, LogicalFrameEndingReason::EndOfRom);
|
|
// RET pops return values and pushes them back on the caller stack (which is the sentinel frame's stack here).
|
|
assert_eq!(vm.operand_stack, vec![Value::Int32(42)]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_locals_per_call_isolation() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// Function 0 (entry):
|
|
// CALL 1
|
|
// POP
|
|
// CALL 1
|
|
// HALT
|
|
// Function 1:
|
|
// GET_LOCAL 0 (should be Null initially)
|
|
// PUSH_I32 42
|
|
// SET_LOCAL 0
|
|
// RET (1 slot: the initial Null)
|
|
|
|
let mut rom = Vec::new();
|
|
// F0
|
|
let f0_start = 0;
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Pop as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
// F1
|
|
let f1_start = rom.len() as u32;
|
|
rom.extend_from_slice(&(OpCode::GetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::SetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&0u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: f0_start as u32,
|
|
|
|
signature: scalar_signature(0, 0, 4),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
},
|
|
FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: f1_start,
|
|
local_slots: 1,
|
|
|
|
signature: scalar_signature(0, 1, 4),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
},
|
|
],
|
|
);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert_eq!(report.reason, LogicalFrameEndingReason::Halted);
|
|
|
|
// The last value on stack is the return of the second CALL 1,
|
|
// which should be Value::Null because locals are zero-initialized on each call.
|
|
assert_eq!(vm.operand_stack.last().unwrap(), &Value::Null);
|
|
}
|
|
|
|
#[test]
|
|
fn test_invalid_local_index_traps() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// Function with 0 params, 1 local.
|
|
// GET_LOCAL 1 (OOB)
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::GetLocal as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = fault_vm(rom.clone(), vec![]);
|
|
vm.program.functions = std::sync::Arc::from(vec![ExecutionFunction {
|
|
code_offset: 0,
|
|
code_len: 8,
|
|
local_slots: 1,
|
|
..Default::default()
|
|
}]);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_INVALID_LOCAL);
|
|
assert_eq!(trap.opcode, OpCode::GetLocal as u16);
|
|
assert!(trap.message.contains("out of bounds"));
|
|
}
|
|
_ => panic!("Expected Trap, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_nested_if() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// if (true) {
|
|
// if (false) {
|
|
// PUSH 1
|
|
// } else {
|
|
// PUSH 2
|
|
// }
|
|
// } else {
|
|
// PUSH 3
|
|
// }
|
|
// HALT
|
|
let mut rom = Vec::new();
|
|
// 0: PUSH_BOOL true
|
|
rom.extend_from_slice(&(OpCode::PushBool as u16).to_le_bytes());
|
|
rom.push(1);
|
|
// 3: JMP_IF_FALSE -> ELSE1 (offset 42)
|
|
rom.extend_from_slice(&(OpCode::JmpIfFalse as u16).to_le_bytes());
|
|
rom.extend_from_slice(&42u32.to_le_bytes());
|
|
|
|
// INNER IF:
|
|
// 9: PUSH_BOOL false
|
|
rom.extend_from_slice(&(OpCode::PushBool as u16).to_le_bytes());
|
|
rom.push(0);
|
|
// 12: JMP_IF_FALSE -> ELSE2 (offset 30)
|
|
rom.extend_from_slice(&(OpCode::JmpIfFalse as u16).to_le_bytes());
|
|
rom.extend_from_slice(&30u32.to_le_bytes());
|
|
// 18: PUSH_I32 1
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1i32.to_le_bytes());
|
|
// 24: JMP -> END (offset 48)
|
|
rom.extend_from_slice(&(OpCode::Jmp as u16).to_le_bytes());
|
|
rom.extend_from_slice(&48u32.to_le_bytes());
|
|
|
|
// ELSE2:
|
|
// 30: PUSH_I32 2
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&2i32.to_le_bytes());
|
|
// 36: JMP -> END (offset 48)
|
|
rom.extend_from_slice(&(OpCode::Jmp as u16).to_le_bytes());
|
|
rom.extend_from_slice(&48u32.to_le_bytes());
|
|
|
|
// ELSE1:
|
|
// 42: PUSH_I32 3
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&3i32.to_le_bytes());
|
|
|
|
// END:
|
|
// 48: HALT
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
}],
|
|
);
|
|
// We need to set up the function meta for absolute jumps to work correctly
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
|
|
vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.pop().unwrap(), Value::Int32(2));
|
|
}
|
|
|
|
#[test]
|
|
fn test_if_with_empty_branches() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// PUSH_BOOL true
|
|
// JMP_IF_FALSE -> ELSE (offset 15)
|
|
// // Empty then
|
|
// JMP -> END (offset 15)
|
|
// ELSE:
|
|
// // Empty else
|
|
// END:
|
|
// HALT
|
|
let mut rom = Vec::new();
|
|
// 0-2: PUSH_BOOL true
|
|
rom.extend_from_slice(&(OpCode::PushBool as u16).to_le_bytes());
|
|
rom.push(1);
|
|
// 3-8: JMP_IF_FALSE -> 15
|
|
rom.extend_from_slice(&(OpCode::JmpIfFalse as u16).to_le_bytes());
|
|
rom.extend_from_slice(&15u32.to_le_bytes());
|
|
// 9-14: JMP -> 15
|
|
rom.extend_from_slice(&(OpCode::Jmp as u16).to_le_bytes());
|
|
rom.extend_from_slice(&15u32.to_le_bytes());
|
|
// 15-16: HALT
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
}],
|
|
);
|
|
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
assert_eq!(report.reason, LogicalFrameEndingReason::Halted);
|
|
assert_eq!(vm.operand_stack.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_jmp_if_non_boolean_trap() {
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// PUSH_I32 1
|
|
// JMP_IF_TRUE 9
|
|
// HALT
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::PushI32 as u16).to_le_bytes());
|
|
rom.extend_from_slice(&1i32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::JmpIfTrue as u16).to_le_bytes());
|
|
rom.extend_from_slice(&9u32.to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = fault_vm(rom.clone(), vec![]);
|
|
vm.program.functions = std::sync::Arc::from(vec![ExecutionFunction {
|
|
code_offset: 0,
|
|
code_len: 14,
|
|
..Default::default()
|
|
}]);
|
|
vm.prepare_call("0").expect("prepare entry call");
|
|
|
|
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
|
match report.reason {
|
|
LogicalFrameEndingReason::Trap(trap) => {
|
|
assert_eq!(trap.code, TRAP_TYPE);
|
|
assert_eq!(trap.opcode, OpCode::JmpIfTrue as u16);
|
|
assert!(trap.message.contains("Expected boolean"));
|
|
}
|
|
_ => panic!("Expected Trap, got {:?}", report.reason),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_gc_triggers_only_at_frame_sync() {
|
|
#[cfg(test)]
|
|
use crate::object::ObjectKind;
|
|
|
|
// ROM: NOP; FRAME_SYNC; HALT
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::Nop as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
}],
|
|
);
|
|
|
|
// Set a very low threshold to trigger GC as soon as we hit FRAME_SYNC
|
|
vm.gc_alloc_threshold = 1;
|
|
|
|
// Allocate an unreachable object (no roots referencing it)
|
|
let _orphan = vm.heap.allocate_object(ObjectKind::Bytes, &[1, 2, 3]).unwrap();
|
|
// Entry preparation allocates no heap object.
|
|
assert_eq!(vm.heap.len(), 1);
|
|
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// Step 1: NOP — should not run GC
|
|
vm.step(&mut native, &mut ctx).unwrap();
|
|
assert_eq!(vm.heap.len(), 1, "GC must not run except at safepoints");
|
|
|
|
// Step 2: FRAME_SYNC — GC should run and reclaim the unreachable object
|
|
match vm.step(&mut native, &mut ctx) {
|
|
Err(LogicalFrameEndingReason::FrameSync) => {}
|
|
other => panic!("Expected FrameSync, got {:?}", other),
|
|
}
|
|
// No execution object remains
|
|
assert_eq!(vm.heap.len(), 0, "Unreachable object must be reclaimed at FRAME_SYNC");
|
|
}
|
|
|
|
#[test]
|
|
fn test_gc_keeps_roots_and_collects_unreachable_at_frame_sync() {
|
|
#[cfg(test)]
|
|
use crate::object::ObjectKind;
|
|
|
|
// ROM: FRAME_SYNC; FRAME_SYNC; HALT
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
}],
|
|
);
|
|
|
|
vm.gc_alloc_threshold = 1;
|
|
|
|
// Allocate two objects; make one a root by placing it on the operand stack
|
|
let rooted = vm.heap.allocate_object(ObjectKind::Bytes, &[9, 9]).unwrap();
|
|
let unreachable = vm.heap.allocate_object(ObjectKind::Bytes, &[8, 8, 8]).unwrap();
|
|
// Entry preparation allocates no heap object.
|
|
assert_eq!(vm.heap.len(), 2);
|
|
vm.operand_stack.push(Value::HeapRef(rooted)).unwrap();
|
|
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// Execute FRAME_SYNC: should trigger GC
|
|
match vm.step(&mut native, &mut ctx) {
|
|
Err(LogicalFrameEndingReason::FrameSync) => {}
|
|
other => panic!("Expected FrameSync, got {:?}", other),
|
|
}
|
|
|
|
// Rooted survives and unreachable is collected
|
|
assert_eq!(vm.heap.len(), 1);
|
|
assert!(vm.heap.is_valid(rooted));
|
|
assert!(!vm.heap.is_valid(unreachable));
|
|
}
|
|
|
|
#[test]
|
|
fn test_gc_simple_allocation_collection_cycle() {
|
|
#[cfg(test)]
|
|
use crate::object::ObjectKind;
|
|
|
|
// ROM: FRAME_SYNC; FRAME_SYNC; HALT
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
}],
|
|
);
|
|
|
|
// Make GC trigger on any allocation delta
|
|
vm.gc_alloc_threshold = 1;
|
|
|
|
// Cycle 1: allocate one unreachable object
|
|
let _h1 = vm.heap.allocate_object(ObjectKind::Bytes, &[1]).unwrap();
|
|
// Entry preparation allocates no heap object.
|
|
assert_eq!(vm.heap.len(), 1);
|
|
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// FRAME_SYNC should collect it (first FRAME_SYNC)
|
|
match vm.step(&mut native, &mut ctx) {
|
|
Err(LogicalFrameEndingReason::FrameSync) => {}
|
|
other => panic!("Expected FrameSync, got {:?}", other),
|
|
}
|
|
// No execution object remains
|
|
assert_eq!(vm.heap.len(), 0);
|
|
|
|
// Cycle 2: allocate again and collect again deterministically
|
|
let _h2 = vm.heap.allocate_object(ObjectKind::Bytes, &[2]).unwrap();
|
|
assert_eq!(vm.heap.len(), 1);
|
|
// Second FRAME_SYNC should also be reached deterministically
|
|
match vm.step(&mut native, &mut ctx) {
|
|
Err(LogicalFrameEndingReason::FrameSync) => {}
|
|
other => panic!("Expected FrameSync, got {:?}", other),
|
|
}
|
|
assert_eq!(vm.heap.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_gc_many_short_lived_objects_stress() {
|
|
#[cfg(test)]
|
|
use crate::object::ObjectKind;
|
|
|
|
// ROM: FRAME_SYNC; HALT
|
|
let mut rom = Vec::new();
|
|
rom.extend_from_slice(&(OpCode::FrameSync as u16).to_le_bytes());
|
|
rom.extend_from_slice(&(OpCode::Halt as u16).to_le_bytes());
|
|
|
|
let mut vm = typed_test_vm(
|
|
rom.clone(),
|
|
vec![],
|
|
vec![FunctionDecl {
|
|
lifecycle_role: Default::default(),
|
|
code_offset: 0,
|
|
|
|
signature: scalar_signature(0, 0, 1),
|
|
captures: vec![],
|
|
name: None,
|
|
code_len: 0,
|
|
max_stack_slots: 256,
|
|
local_slots: 0,
|
|
}],
|
|
);
|
|
|
|
// Deterministic: trigger collection when any growth since last sweep occurs
|
|
vm.gc_alloc_threshold = 1;
|
|
|
|
// Allocate many small, unreferenced objects
|
|
let count = 2048usize; // stress but still quick
|
|
for i in 0..count {
|
|
let byte = (i & 0xFF) as u8;
|
|
let _ = vm.heap.allocate_object(ObjectKind::Bytes, &[byte]).unwrap();
|
|
}
|
|
// Entry preparation allocates no heap object.
|
|
assert_eq!(vm.heap.len(), count);
|
|
|
|
let mut native = MockNative;
|
|
let mut ctx = HostContext::new(None);
|
|
|
|
// Single FRAME_SYNC should reclaim all since there are no roots
|
|
match vm.step(&mut native, &mut ctx) {
|
|
Err(LogicalFrameEndingReason::FrameSync) => {}
|
|
other => panic!("Expected FrameSync, got {:?}", other),
|
|
}
|
|
|
|
assert_eq!(vm.heap.len(), 0, "All short-lived objects must be reclaimed deterministically");
|
|
}
|
|
|
|
#[test]
|
|
fn call_depth_includes_entry_and_traps_before_frame_growth() {
|
|
for limit in [1, 3, 1024] {
|
|
let limits =
|
|
RuntimeLimits::default().lowered(RuntimeResource::CallDepth, limit).unwrap();
|
|
let mut vm = limited_session(assemble("CALL 0").unwrap(), limits);
|
|
vm.prepare_call("0").unwrap();
|
|
let report =
|
|
vm.run_budget(100_000, &mut MockNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
|
if trap.code == TRAP_RESOURCE_LIMIT && trap.pc == 0 && trap.opcode == OpCode::Call as u16));
|
|
assert_eq!(vm.call_stack.len(), limit as usize);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn entry_depth_zero_returns_typed_setup_failure_without_allocating() {
|
|
let limits = RuntimeLimits::default().lowered(RuntimeResource::CallDepth, 0).unwrap();
|
|
let mut vm = limited_session(assemble("HALT").unwrap(), limits);
|
|
let error = vm.prepare_boot_call().unwrap_err();
|
|
let VmInitError::RuntimeResourceLimit(error) = error else { panic!("{error:?}") };
|
|
assert_eq!(
|
|
(error.resource, error.requested, error.limit),
|
|
(RuntimeResource::CallDepth, 1, 0)
|
|
);
|
|
assert!(vm.call_stack.is_empty());
|
|
assert_eq!(vm.heap.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn operand_globals_and_frames_share_one_auxiliary_limit() {
|
|
let frame = entry_auxiliary_bytes();
|
|
let slot = size_of::<Value>() as u64;
|
|
for (source, extra, expected_pc, expected_op) in [
|
|
("PUSH_I32 1\nPUSH_I32 2", slot, 6, OpCode::PushI32),
|
|
("GET_GLOBAL 0\nGET_GLOBAL 1", 2 * slot, 6, OpCode::GetGlobal),
|
|
("GET_GLOBAL 4294967295", 0, 0, OpCode::GetGlobal),
|
|
("CALL 0", 0, 0, OpCode::Call),
|
|
] {
|
|
let limits = RuntimeLimits::default()
|
|
.lowered(RuntimeResource::AuxiliaryBytes, frame + extra)
|
|
.unwrap();
|
|
let code = assemble(source).unwrap();
|
|
let mut vm = limited_session(code.clone(), limits);
|
|
vm.prepare_boot_call().unwrap();
|
|
let report = vm.run_budget(100, &mut MockNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(
|
|
matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
|
if trap.code == TRAP_RESOURCE_LIMIT && trap.pc == expected_pc && trap.opcode == expected_op as u16),
|
|
"{source}"
|
|
);
|
|
assert!(vm.budget.used(RuntimeResource::AuxiliaryBytes) <= frame + extra);
|
|
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), 0);
|
|
assert_eq!(vm.call_stack.len(), 1);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gc_scratch_failure_traps_before_sweep_and_preserves_roots() {
|
|
let limits = RuntimeLimits::default().lowered(RuntimeResource::TemporaryBytes, 0).unwrap();
|
|
let mut vm = limited_session(assemble("FRAME_SYNC").unwrap(), limits);
|
|
vm.prepare_boot_call().unwrap();
|
|
vm.gc_alloc_threshold = 1;
|
|
let current = vm.heap.alloc_closure(0, &[]).unwrap();
|
|
vm.globals.push(Value::HeapRef(current)).unwrap();
|
|
let guest = vm.budget.used(RuntimeResource::GuestBytes);
|
|
let report = vm.run_budget(100, &mut MockNative, &mut HostContext::new(None)).unwrap();
|
|
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
|
if trap.code == TRAP_RESOURCE_LIMIT && trap.pc == 0 && trap.opcode == OpCode::FrameSync as u16));
|
|
assert!(vm.heap.is_valid(current));
|
|
assert!(!vm.heap.header(current).unwrap().is_marked());
|
|
assert_eq!(vm.budget.used(RuntimeResource::GuestBytes), guest);
|
|
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn entry_preparation_needs_no_guest_heap_quota() {
|
|
let limits = RuntimeLimits::default().lowered(RuntimeResource::GuestBytes, 0).unwrap();
|
|
let mut vm = limited_session(assemble("HALT").unwrap(), limits);
|
|
vm.prepare_boot_call().unwrap();
|
|
assert_eq!(vm.call_stack.len(), 1);
|
|
assert_eq!(vm.heap.len(), 0);
|
|
assert_eq!(vm.budget.used(RuntimeResource::GuestBytes), 0);
|
|
assert_eq!(vm.budget.used(RuntimeResource::HandleSlots), 0);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "virtual_machine/callable_tests.rs"]
|
|
mod callable_tests;
|
|
|
|
#[cfg(feature = "resource-diagnostics")]
|
|
pub mod string_provenance_qualification;
|