From ba603ce64a3bb7e01d8a3ce433656ec0072065d0 Mon Sep 17 00:00:00 2001 From: bQUARKz Date: Wed, 7 Oct 2026 20:32:09 +0100 Subject: [PATCH] feat(vm): enforce typed CALL RET and native entry boundaries for PLN-0176 step 26 --- .../src/services/vm_runtime/tick.rs | 8 +- .../prometeu-vm/src/program_image/tests.rs | 3 +- .../prometeu-vm/src/virtual_machine.rs | 51 +++- .../prometeu-vm/src/virtual_machine/loader.rs | 61 +++- .../prometeu-vm/src/virtual_machine/stack.rs | 6 + .../prometeu-vm/src/virtual_machine/typed.rs | 79 +++++ .../src/virtual_machine/typed_tests.rs | 284 ++++++++++++++++++ .../console/prometeu-vm/src/vm_init_error.rs | 7 + .../src/automation/wire.rs | 2 + 9 files changed, 477 insertions(+), 24 deletions(-) create mode 100644 crates/console/prometeu-vm/src/virtual_machine/typed.rs create mode 100644 crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs diff --git a/crates/console/prometeu-system/src/services/vm_runtime/tick.rs b/crates/console/prometeu-system/src/services/vm_runtime/tick.rs index 4026801..e4e5b29 100644 --- a/crates/console/prometeu-system/src/services/vm_runtime/tick.rs +++ b/crates/console/prometeu-system/src/services/vm_runtime/tick.rs @@ -78,9 +78,7 @@ impl VirtualMachineRuntime { ) -> Option { if vm.call_stack_is_empty() { if let Err(error) = vm.prepare_boot_call() { - let report = CrashReport::VmInit { - error: prometeu_vm::VmInitError::RuntimeResourceLimit(error), - }; + let report = CrashReport::VmInit { error }; self.last_crash_report = Some(report.clone()); return Some(report); } @@ -175,9 +173,7 @@ impl VirtualMachineRuntime { if self.needs_prepare_entry_call || vm.call_stack_is_empty() { if let Err(error) = vm.prepare_boot_call() { - let report = CrashReport::VmInit { - error: prometeu_vm::VmInitError::RuntimeResourceLimit(error), - }; + let report = CrashReport::VmInit { error }; self.last_crash_report = Some(report.clone()); return Some(report); } diff --git a/crates/console/prometeu-vm/src/program_image/tests.rs b/crates/console/prometeu-vm/src/program_image/tests.rs index 47704d8..763a4f8 100644 --- a/crates/console/prometeu-vm/src/program_image/tests.rs +++ b/crates/console/prometeu-vm/src/program_image/tests.rs @@ -199,8 +199,7 @@ fn late_work_refusal_releases_all_new_owners() { let bytes = fixture(&[1, 0], 0, &[K::String("abc".into())], None, &[]); let mut full = budget(); ValidatedProgramImage::load(&bytes, &mut full, caps::NONE).unwrap(); - let mut b = - LoadBudget::new(LoadLimits { work: full.used(Q::Work) - 1, ..Default::default() }); + let mut b = LoadBudget::new(LoadLimits { work: full.used(Q::Work) - 1, ..Default::default() }); b.charge(Q::TemporaryBytes, 7).unwrap(); b.charge(Q::RegistryBytes, 3).unwrap(); let VmInitError::RegistryLoadFailed(error) = diff --git a/crates/console/prometeu-vm/src/virtual_machine.rs b/crates/console/prometeu-vm/src/virtual_machine.rs index b7bad66..ebce5b6 100644 --- a/crates/console/prometeu-vm/src/virtual_machine.rs +++ b/crates/console/prometeu-vm/src/virtual_machine.rs @@ -3,6 +3,9 @@ mod gc; mod loader; mod runtime; mod stack; +mod typed; +#[cfg(test)] +mod typed_tests; use crate::call_frame::CallFrame; use crate::heap::{CoroutineState, Heap}; @@ -81,6 +84,7 @@ pub struct VirtualMachine { globals: BudgetVec, /// The loaded executable (Bytecode + Constant Pool), that is the ROM translated. program: ProgramImage, + validated_image: Option>, /// Heap Memory: Dynamic allocation pool. heap: Heap, /// Total virtual cycles consumed since the VM started. @@ -197,6 +201,7 @@ impl VirtualMachine { None, std::collections::HashMap::new(), ), + validated_image: None, heap: Heap::with_budget(&budget), cycles: 0, halted: false, @@ -213,6 +218,20 @@ impl VirtualMachine { } } + /// 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, + limits: RuntimeLimits, + ) -> Self { + let mut vm = Self::with_runtime_limits(Vec::new(), Vec::new(), 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: @@ -1056,7 +1075,7 @@ impl VirtualMachine { ) })?; - if self.operand_stack.len() < callee.param_slots as usize { + if self.temporary_slots() < callee.param_slots as usize { return Err(self.trap( TRAP_STACK_UNDERFLOW, opcode as u16, @@ -1072,14 +1091,21 @@ impl VirtualMachine { 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; - self.operand_stack - .reserve(callee_local_slots as usize) + 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))?; - self.call_stack - .reserve(1) + 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 @@ -1093,7 +1119,7 @@ impl VirtualMachine { self.pc = callee_offset as usize; } OpCode::Ret => { - let frame = self.call_stack.pop().ok_or_else(|| { + let frame = self.call_stack.last().cloned().ok_or_else(|| { self.trap( TRAP_STACK_UNDERFLOW, opcode as u16, @@ -1117,6 +1143,13 @@ impl VirtualMachine { ), start_pc as u32)); } + self.check_signature_group( + frame.func_idx, + true, + &self.operand_stack[current_height - return_slots..], + ) + .map_err(|(_, error)| self.value_trap(error, opcode, start_pc as u32))?; + // Copy return values (preserving order: pop return_slots values, then reverse to push back) let mut return_vals = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes); return_vals @@ -1129,6 +1162,7 @@ impl VirtualMachine { } return_vals.reverse(); + self.call_stack.pop(); self.operand_stack.truncate(frame.stack_base); for val in return_vals.drain(..) { self.push_trap(val, opcode, start_pc as u32)?; @@ -4897,6 +4931,7 @@ mod tests { let limits = RuntimeLimits::default().lowered(RuntimeResource::CallDepth, 0).unwrap(); let mut vm = VirtualMachine::with_runtime_limits(assemble("HALT").unwrap(), vec![], 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) @@ -5056,7 +5091,9 @@ mod tests { fn guest_quota_failure_does_not_publish_an_entry_context() { let limits = RuntimeLimits::default().lowered(RuntimeResource::GuestBytes, 0).unwrap(); let mut vm = VirtualMachine::with_runtime_limits(assemble("HALT").unwrap(), vec![], limits); - assert_eq!(vm.prepare_boot_call().unwrap_err().resource, RuntimeResource::GuestBytes); + assert!( + matches!(vm.prepare_boot_call().unwrap_err(), VmInitError::RuntimeResourceLimit(error) if error.resource == RuntimeResource::GuestBytes) + ); assert!(vm.current_coro.is_none()); assert!(vm.call_stack.is_empty()); assert_eq!(vm.heap.len(), 0); diff --git a/crates/console/prometeu-vm/src/virtual_machine/loader.rs b/crates/console/prometeu-vm/src/virtual_machine/loader.rs index 440951e..35a0a27 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/loader.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/loader.rs @@ -70,6 +70,7 @@ fn patch_module_hostcalls( impl VirtualMachine { pub fn initialize(&mut self, program_bytes: Vec) -> Result<(), VmInitError> { self.program = ProgramImage::default(); + self.validated_image = None; self.pc = 0; self.operand_stack.clear(); self.call_stack.clear(); @@ -128,26 +129,61 @@ impl VirtualMachine { self.capabilities = caps; } - pub fn prepare_boot_call(&mut self) -> Result<(), ResourceFailure> { - self.prepare_call_by_index(0) + pub fn prepare_boot_call(&mut self) -> Result<(), VmInitError> { + self.prepare_call_by_index(0, &[]) } - pub fn prepare_call(&mut self, entrypoint: &str) -> Result<(), ResourceFailure> { + pub fn prepare_call(&mut self, entrypoint: &str) -> Result<(), VmInitError> { + self.prepare_call_with_args(entrypoint, &[]) + } + + pub fn prepare_call_with_args( + &mut self, + entrypoint: &str, + arguments: &[Value], + ) -> Result<(), VmInitError> { let func_idx = if let Ok(idx) = entrypoint.parse::() { idx + } else if let Some(image) = &self.validated_image { + image + .exports() + .iter() + .rfind(|export| export.symbol == entrypoint) + .map(|export| export.func_idx as usize) + .ok_or(VmInitError::EntrypointNotFound)? } else { self.program.exports.get(entrypoint).map(|&idx| idx as usize).ok_or(()).unwrap_or(0) }; - self.prepare_call_by_index(func_idx) + self.prepare_call_by_index(func_idx, arguments) } - fn prepare_call_by_index(&mut self, func_idx: usize) -> Result<(), ResourceFailure> { + fn prepare_call_by_index( + &mut self, + func_idx: usize, + arguments: &[Value], + ) -> Result<(), VmInitError> { + if self.validated_image.is_some() { + self.check_signature_group(func_idx, false, arguments).map_err(|(slot, error)| { + if self.program.functions.get(func_idx).is_none() { + VmInitError::EntrypointNotFound + } else { + VmInitError::EntrypointArgumentsInvalid { + function: func_idx as u32, + slot: slot as u32, + trap_code: Self::value_error_code(error), + } + } + })?; + } self.budget.check(RuntimeResource::CallDepth, 1)?; let callee = self.program.functions.get(func_idx).cloned().unwrap_or_default(); let total_slots = callee.param_slots as usize + callee.local_slots as usize; - self.operand_stack.reserve(total_slots.saturating_sub(self.operand_stack.len()))?; - self.call_stack.reserve(1usize.saturating_sub(self.call_stack.len()))?; + let stack_growth = self + .operand_stack + .prepare_growth(total_slots.saturating_sub(self.operand_stack.len()))?; + let frame_growth = + self.call_stack.prepare_growth(1usize.saturating_sub(self.call_stack.len()))?; let main_href = self.heap.allocate_coroutine( callee.code_offset as usize, CoroutineState::Running, @@ -155,6 +191,8 @@ impl VirtualMachine { BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes), BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes), )?; + self.operand_stack.commit_growth(stack_growth); + self.call_stack.commit_growth(frame_growth); self.pc = callee.code_offset as usize; self.halted = false; @@ -162,8 +200,13 @@ impl VirtualMachine { self.call_stack.clear(); if let Some(func) = self.program.functions.get(func_idx) { - let total_slots = func.param_slots as u32 + func.local_slots as u32; - for _ in 0..total_slots { + let typed = self.validated_image.is_some(); + if typed { + self.operand_stack.extend_from_slice(arguments)?; + } + let null_slots = + func.local_slots as usize + if typed { 0 } else { func.param_slots as usize }; + for _ in 0..null_slots { self.operand_stack.push(Value::Null)?; } } diff --git a/crates/console/prometeu-vm/src/virtual_machine/stack.rs b/crates/console/prometeu-vm/src/virtual_machine/stack.rs index a1f0519..111439f 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/stack.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/stack.rs @@ -45,6 +45,9 @@ impl VirtualMachine { } pub fn pop(&mut self) -> Result { + if self.temporary_slots() == 0 { + return Err("Stack underflow".into()); + } self.operand_stack.pop().ok_or("Stack underflow".into()) } @@ -62,6 +65,9 @@ impl VirtualMachine { } pub fn peek(&self) -> Result<&Value, String> { + if self.temporary_slots() == 0 { + return Err("Stack underflow".into()); + } self.operand_stack.last().ok_or("Stack underflow".into()) } diff --git a/crates/console/prometeu-vm/src/virtual_machine/typed.rs b/crates/console/prometeu-vm/src/virtual_machine/typed.rs new file mode 100644 index 0000000..ae03505 --- /dev/null +++ b/crates/console/prometeu-vm/src/virtual_machine/typed.rs @@ -0,0 +1,79 @@ +use super::*; +use crate::value_contract::{self, ValueError}; + +impl VirtualMachine { + pub(super) fn temporary_slots(&self) -> usize { + if self.validated_image.is_none() { + return self.operand_stack.len(); + } + let floor = self + .call_stack + .last() + .map(|frame| { + let function = &self.program.functions[frame.func_idx]; + frame.stack_base + function.param_slots as usize + function.local_slots as usize + }) + .unwrap_or(0); + self.operand_stack.len().saturating_sub(floor) + } + + pub(super) fn value_error_code(error: ValueError) -> u32 { + match error { + ValueError::Type => TRAP_TYPE, + ValueError::InvalidHandle => TRAP_INVALID_HANDLE, + ValueError::NullReference => TRAP_NULL_REFERENCE, + ValueError::Bounds => TRAP_OOB, + ValueError::Resource(_) => TRAP_RESOURCE_LIMIT, + } + } + + pub(super) fn value_trap( + &self, + error: ValueError, + opcode: OpCode, + pc: u32, + ) -> LogicalFrameEndingReason { + if let ValueError::Resource(resource) = error { + return self.resource_trap(resource, opcode, pc); + } + self.trap( + Self::value_error_code(error), + opcode as u16, + format!("Invalid typed value: {error:?}"), + pc, + ) + } + + pub(super) fn check_signature_group( + &self, + function: usize, + results: bool, + values: &[Value], + ) -> Result<(), (usize, ValueError)> { + let Some(image) = &self.validated_image else { + return Ok(()); + }; + let declaration = + image.registry().declarations().functions.get(function).ok_or((0, ValueError::Type))?; + let signature = &declaration.signature; + let count = if results { signature.results.len() } else { signature.parameters.len() }; + let mut slot = 0; + for index in 0..count { + let ty = if results { + signature.results[index] + } else { + signature.parameters[index].type_id + }; + let width = image.registry().type_layout(ty).unwrap().storage.slots as usize; + let end = slot + width; + let values = values.get(slot..end).ok_or((slot, ValueError::Type))?; + value_contract::validate(image.registry(), &self.heap, ty, values) + .map_err(|e| (slot, e))?; + slot = end; + } + if values.len() != slot { + return Err((slot, ValueError::Type)); + } + Ok(()) + } +} diff --git a/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs b/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs new file mode 100644 index 0000000..ac1562d --- /dev/null +++ b/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs @@ -0,0 +1,284 @@ +use super::*; +use crate::{HostReturn, ValidatedProgramImage}; +use prometeu_bytecode::load_limits::LoadBudget; +use prometeu_bytecode::registry::{ + BuiltinId as B, FunctionDecl, ImplementationDecl, NamedType, Registry, RegistryDeclarations, + Signature, TypeDecl, TypeId, TypeKind, +}; +use prometeu_bytecode::registry_codec::PbxModule; +use std::sync::Arc; + +struct Native; +impl NativeInterface for Native { + fn syscall( + &mut self, + _id: u32, + _args: &[Value], + _ret: &mut HostReturn, + _ctx: &mut HostContext, + ) -> Result<(), VmFault> { + Ok(()) + } +} +fn op(code: &mut Vec, opcode: OpCode) { + code.extend_from_slice(&(opcode as u16).to_le_bytes()); +} +fn arg(code: &mut Vec, opcode: OpCode, argument: u32) { + op(code, opcode); + code.extend_from_slice(&argument.to_le_bytes()); +} +fn function( + offset: usize, + len: usize, + parameters: &[u32], + results: &[u32], + locals: u32, + max: u32, +) -> FunctionDecl { + FunctionDecl { + name: Some(format!("f{offset}")), + code_offset: offset as u32, + code_len: len as u32, + local_slots: locals, + max_stack_slots: max, + signature: Signature { + parameters: parameters + .iter() + .map(|&id| NamedType { type_id: TypeId(id), name: None }) + .collect(), + results: results.iter().copied().map(TypeId).collect(), + }, + } +} +fn image(code: &[u8], functions: Vec) -> Arc { + let kind = |kind| TypeDecl { name: None, kind }; + let mut types: Vec<_> = + [B::INT32, B::INT64, B::FLOAT, B::BOOL, B::STRING, B::VEC2, B::COLOR, B::PIXEL, B::DYNAMIC] + .into_iter() + .map(|id| kind(TypeKind::Builtin(id))) + .collect(); + types.extend([ + kind(TypeKind::Struct(vec![])), + kind(TypeKind::Struct(vec![])), + kind(TypeKind::Trait(vec![])), + kind(TypeKind::Trait(vec![])), + kind(TypeKind::Array(TypeId(0))), + kind(TypeKind::Array(TypeId(3))), + ]); + let registry = Registry::resolve( + RegistryDeclarations { + types, + functions, + implementations: vec![ + ImplementationDecl { owner: TypeId(9), trait_id: TypeId(11), methods: vec![] }, + ImplementationDecl { owner: TypeId(9), trait_id: TypeId(12), methods: vec![] }, + ], + }, + code.len(), + &mut LoadBudget::new(Default::default()), + ) + .unwrap(); + let bytes = PbxModule { + registry: ®istry, + code, + constants: &[], + debug: None, + exports: &[], + syscalls: &[], + } + .serialize(&mut LoadBudget::new(Default::default())) + .unwrap(); + ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), NONE).unwrap() +} +fn run(vm: &mut VirtualMachine) -> LogicalFrameEndingReason { + vm.run_budget(1000, &mut Native, &mut HostContext::new(None)).unwrap().reason +} + +#[test] +fn typed_sessions_share_image_but_have_independent_execution_and_heap() { + let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 0)]); + let mut first = VirtualMachine::from_image(image.clone(), RuntimeLimits::default()); + let mut second = VirtualMachine::from_image(image.clone(), RuntimeLimits::default()); + assert!(Arc::ptr_eq(&first.program.rom, &second.program.rom)); + assert!(Arc::ptr_eq(&first.program.constant_pool, &second.program.constant_pool)); + first.prepare_boot_call().unwrap(); + second.prepare_boot_call().unwrap(); + assert_eq!(run(&mut first), LogicalFrameEndingReason::Halted); + assert!(!second.halted); + assert_eq!(second.pc, 0); + drop(first); + drop(image); + assert_eq!(run(&mut second), LogicalFrameEndingReason::Halted); +} + +#[test] +fn entry_rejects_bad_complete_groups_before_frame_or_heap_publication() { + let image = image(&[1, 0], vec![function(0, 2, &[5, 8], &[], 2, 0)]); + let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default()); + for args in [ + vec![], + vec![Value::Float(1.), Value::Int32(2), Value::Null, Value::Null], + vec![Value::Float(1.), Value::Float(2.), Value::Int64(0), Value::Boolean(true)], + ] { + assert!(matches!( + vm.prepare_call_with_args("0", &args), + Err(VmInitError::EntrypointArgumentsInvalid { trap_code: TRAP_TYPE, .. }) + )); + assert_eq!(vm.heap.len(), 0); + assert!(vm.call_stack.is_empty()); + assert!(vm.operand_stack.is_empty()); + assert_eq!(vm.budget.used(RuntimeResource::AuxiliaryBytes), 0); + } + vm.prepare_call_with_args("0", &[Value::Float(1.), Value::Float(2.), Value::Null, Value::Null]) + .unwrap(); + assert_eq!(&vm.operand_stack[4..], &[Value::Null, Value::Null]); + assert!(vm.pop().is_err()); // A generic pop cannot consume parameters/locals. +} + +#[test] +fn unknown_at_call_is_checked_after_branch_merge_without_publishing_bad_frame() { + let mut code = vec![]; + arg(&mut code, OpCode::GetLocal, 0); + let branch = code.len(); + arg(&mut code, OpCode::JmpIfTrue, 0); + arg(&mut code, OpCode::PushI32, 17); + let jump = code.len(); + arg(&mut code, OpCode::Jmp, 0); + let right = code.len(); + op(&mut code, OpCode::PushBool); + code.push(1); + let join = code.len(); + arg(&mut code, OpCode::Call, 1); + op(&mut code, OpCode::Halt); + let end = code.len(); + op(&mut code, OpCode::Ret); + code[branch + 2..branch + 6].copy_from_slice(&(right as u32).to_le_bytes()); + code[jump + 2..jump + 6].copy_from_slice(&(join as u32).to_le_bytes()); + let image = + image(&code, vec![function(0, end, &[3], &[], 0, 1), function(end, 2, &[0], &[], 0, 0)]); + for (condition, success) in [(false, true), (true, false)] { + let mut vm = VirtualMachine::from_image(image.clone(), RuntimeLimits::default()); + vm.prepare_call_with_args("0", &[Value::Boolean(condition)]).unwrap(); + let result = run(&mut vm); + if success { + assert_eq!(result, LogicalFrameEndingReason::Halted); + } else { + assert!( + matches!(result,LogicalFrameEndingReason::Trap(info) if info.code==TRAP_TYPE && info.pc==join as u32 && info.opcode==OpCode::Call as u16) + ); + assert_eq!(vm.call_stack.len(), 1); + assert_eq!(vm.operand_stack.last(), Some(&Value::Boolean(true))); + } + } +} + +#[test] +fn ordered_multi_group_return_preserves_native_owners_and_receiver_identity() { + let mut code = vec![]; + // vec2, trait, Dynamic and string occupy seven slots together. + for slot in 0..7 { + arg(&mut code, OpCode::GetLocal, slot); + } + op(&mut code, OpCode::Ret); + let image = image(&code, vec![function(0, code.len(), &[5, 11, 8, 4], &[5, 11, 8, 4], 2, 7)]); + let registry = image.registry().clone(); + let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default()); + let receiver = vm.heap.allocate_typed_struct(registry, TypeId(9)).unwrap(); + let text: Arc = Arc::from("retained"); + let args = [ + Value::Float(1.), + Value::Float(2.), + Value::HeapRef(receiver), + Value::Int64(0), + Value::Int64(0), + Value::Int32(17), + Value::String(text.clone()), + ]; + vm.prepare_call_with_args("0", &args).unwrap(); + assert_eq!(run(&mut vm), LogicalFrameEndingReason::EndOfRom); + assert_eq!(vm.operand_stack.as_slice(), &args); + assert!(vm.call_stack.is_empty()); + let Value::String(returned) = &vm.operand_stack[6] else { panic!() }; + assert!(Arc::ptr_eq(returned, &text)); +} + +#[test] +fn unknown_return_and_late_return_resource_failures_keep_current_frame_and_operands() { + let mut code = vec![]; + arg(&mut code, OpCode::GetGlobal, 0); + op(&mut code, OpCode::Ret); + let image = image(&code, vec![function(0, code.len(), &[], &[0], 0, 1)]); + for (value, limits, expected) in [ + (Value::Boolean(true), RuntimeLimits::default(), TRAP_TYPE), + ( + Value::Int32(3), + RuntimeLimits::default().lowered(RuntimeResource::TemporaryBytes, 0).unwrap(), + TRAP_RESOURCE_LIMIT, + ), + ] { + let mut vm = VirtualMachine::from_image(image.clone(), limits); + vm.prepare_boot_call().unwrap(); + vm.globals.push(value.clone()).unwrap(); + let result = run(&mut vm); + assert!( + matches!(result,LogicalFrameEndingReason::Trap(info) if info.code==expected && info.pc==6) + ); + assert_eq!(vm.call_stack.len(), 1); + assert_eq!(vm.operand_stack.as_slice(), &[value]); + } +} + +#[test] +fn direct_call_returns_zero_or_one_result_and_initializes_generic_locals() { + for results in [&[][..], &[0][..]] { + let mut code = vec![]; + arg(&mut code, OpCode::Call, 1); + op(&mut code, OpCode::Halt); + let end = code.len(); + if !results.is_empty() { + arg(&mut code, OpCode::PushI32, 42); + } + op(&mut code, OpCode::Ret); + let image = image( + &code, + vec![ + function(0, end, &[], &[], 0, 1), + function(end, code.len() - end, &[], results, 3, results.len() as u32), + ], + ); + let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default()); + vm.prepare_boot_call().unwrap(); + vm.step(&mut Native, &mut HostContext::new(None)).unwrap(); + assert_eq!(vm.call_stack.len(), 2); + assert_eq!(vm.operand_stack.as_slice(), &[Value::Null, Value::Null, Value::Null]); + assert_eq!(run(&mut vm), LogicalFrameEndingReason::Halted); + assert_eq!(vm.operand_stack.len(), results.len()); + if !results.is_empty() { + assert_eq!(vm.operand_stack[0], Value::Int32(42)); + } + } +} + +#[test] +fn call_growth_refusal_does_not_publish_frame_or_keep_provisional_capacity() { + let mut code = vec![]; + arg(&mut code, OpCode::Call, 1); + op(&mut code, OpCode::Halt); + let end = code.len(); + op(&mut code, OpCode::Ret); + let image = + image(&code, vec![function(0, end, &[], &[], 0, 0), function(end, 2, &[], &[], 100, 0)]); + let mut vm = VirtualMachine::from_image( + image, + RuntimeLimits::default().lowered(RuntimeResource::AuxiliaryBytes, 2048).unwrap(), + ); + vm.prepare_boot_call().unwrap(); + let before = vm.budget.used(RuntimeResource::AuxiliaryBytes); + assert!( + matches!(run(&mut vm),LogicalFrameEndingReason::Trap(info) if info.code==TRAP_RESOURCE_LIMIT && info.pc==0) + ); + assert_eq!(vm.call_stack.len(), 1); + assert!(vm.operand_stack.is_empty()); + assert_eq!(vm.budget.used(RuntimeResource::AuxiliaryBytes), before); + assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), 0); +} diff --git a/crates/console/prometeu-vm/src/vm_init_error.rs b/crates/console/prometeu-vm/src/vm_init_error.rs index 96d176b..f1b51b1 100644 --- a/crates/console/prometeu-vm/src/vm_init_error.rs +++ b/crates/console/prometeu-vm/src/vm_init_error.rs @@ -17,9 +17,16 @@ pub enum VmInitError { ImageLoadFailed(prometeu_bytecode::LoadError), LoaderPatchFailed(LoaderPatchError), EntrypointNotFound, + EntrypointArgumentsInvalid { function: u32, slot: u32, trap_code: u32 }, VerificationFailed(crate::verifier::VerifierError), } +impl From for VmInitError { + fn from(value: crate::resource_budget::ResourceFailure) -> Self { + Self::RuntimeResourceLimit(value) + } +} + impl From for VmInitError { fn from(value: prometeu_bytecode::load_limits::LoadFailure) -> Self { Self::RegistryLoadFailed(value) diff --git a/crates/host/prometeu-host-headless/src/automation/wire.rs b/crates/host/prometeu-host-headless/src/automation/wire.rs index f58c0bd..a82795a 100644 --- a/crates/host/prometeu-host-headless/src/automation/wire.rs +++ b/crates/host/prometeu-host-headless/src/automation/wire.rs @@ -289,12 +289,14 @@ pub(super) fn fault(report: &CrashReport) -> Value { } CrashReport::VmInit { error } => { let code = match error { + VmInitError::RegistryLoadFailed(_) => "registry_load_failed", VmInitError::RuntimeResourceLimit(_) => "runtime_resource_limit", VmInitError::InvalidFormat => "invalid_format", VmInitError::UnsupportedFormat => "unsupported_format", VmInitError::ImageLoadFailed(_) => "image_load_failed", VmInitError::LoaderPatchFailed(_) => "loader_patch_failed", VmInitError::EntrypointNotFound => "entrypoint_not_found", + VmInitError::EntrypointArgumentsInvalid { .. } => "entrypoint_arguments_invalid", VmInitError::VerificationFailed(_) => "verification_failed", }; result["initError"] = json!({"code":code,"message":format!("{error:?}")});