feat(vm): enforce typed CALL RET and native entry boundaries for PLN-0176 step 26
This commit is contained in:
@@ -78,9 +78,7 @@ impl VirtualMachineRuntime {
|
|||||||
) -> Option<CrashReport> {
|
) -> Option<CrashReport> {
|
||||||
if vm.call_stack_is_empty() {
|
if vm.call_stack_is_empty() {
|
||||||
if let Err(error) = vm.prepare_boot_call() {
|
if let Err(error) = vm.prepare_boot_call() {
|
||||||
let report = CrashReport::VmInit {
|
let report = CrashReport::VmInit { error };
|
||||||
error: prometeu_vm::VmInitError::RuntimeResourceLimit(error),
|
|
||||||
};
|
|
||||||
self.last_crash_report = Some(report.clone());
|
self.last_crash_report = Some(report.clone());
|
||||||
return Some(report);
|
return Some(report);
|
||||||
}
|
}
|
||||||
@@ -175,9 +173,7 @@ impl VirtualMachineRuntime {
|
|||||||
|
|
||||||
if self.needs_prepare_entry_call || vm.call_stack_is_empty() {
|
if self.needs_prepare_entry_call || vm.call_stack_is_empty() {
|
||||||
if let Err(error) = vm.prepare_boot_call() {
|
if let Err(error) = vm.prepare_boot_call() {
|
||||||
let report = CrashReport::VmInit {
|
let report = CrashReport::VmInit { error };
|
||||||
error: prometeu_vm::VmInitError::RuntimeResourceLimit(error),
|
|
||||||
};
|
|
||||||
self.last_crash_report = Some(report.clone());
|
self.last_crash_report = Some(report.clone());
|
||||||
return Some(report);
|
return Some(report);
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -199,8 +199,7 @@ fn late_work_refusal_releases_all_new_owners() {
|
|||||||
let bytes = fixture(&[1, 0], 0, &[K::String("abc".into())], None, &[]);
|
let bytes = fixture(&[1, 0], 0, &[K::String("abc".into())], None, &[]);
|
||||||
let mut full = budget();
|
let mut full = budget();
|
||||||
ValidatedProgramImage::load(&bytes, &mut full, caps::NONE).unwrap();
|
ValidatedProgramImage::load(&bytes, &mut full, caps::NONE).unwrap();
|
||||||
let mut b =
|
let mut b = LoadBudget::new(LoadLimits { work: full.used(Q::Work) - 1, ..Default::default() });
|
||||||
LoadBudget::new(LoadLimits { work: full.used(Q::Work) - 1, ..Default::default() });
|
|
||||||
b.charge(Q::TemporaryBytes, 7).unwrap();
|
b.charge(Q::TemporaryBytes, 7).unwrap();
|
||||||
b.charge(Q::RegistryBytes, 3).unwrap();
|
b.charge(Q::RegistryBytes, 3).unwrap();
|
||||||
let VmInitError::RegistryLoadFailed(error) =
|
let VmInitError::RegistryLoadFailed(error) =
|
||||||
|
|||||||
@@ -3,6 +3,9 @@ mod gc;
|
|||||||
mod loader;
|
mod loader;
|
||||||
mod runtime;
|
mod runtime;
|
||||||
mod stack;
|
mod stack;
|
||||||
|
mod typed;
|
||||||
|
#[cfg(test)]
|
||||||
|
mod typed_tests;
|
||||||
|
|
||||||
use crate::call_frame::CallFrame;
|
use crate::call_frame::CallFrame;
|
||||||
use crate::heap::{CoroutineState, Heap};
|
use crate::heap::{CoroutineState, Heap};
|
||||||
@@ -81,6 +84,7 @@ pub struct VirtualMachine {
|
|||||||
globals: BudgetVec<Value>,
|
globals: BudgetVec<Value>,
|
||||||
/// The loaded executable (Bytecode + Constant Pool), that is the ROM translated.
|
/// The loaded executable (Bytecode + Constant Pool), that is the ROM translated.
|
||||||
program: ProgramImage,
|
program: ProgramImage,
|
||||||
|
validated_image: Option<std::sync::Arc<crate::ValidatedProgramImage>>,
|
||||||
/// Heap Memory: Dynamic allocation pool.
|
/// Heap Memory: Dynamic allocation pool.
|
||||||
heap: Heap,
|
heap: Heap,
|
||||||
/// Total virtual cycles consumed since the VM started.
|
/// Total virtual cycles consumed since the VM started.
|
||||||
@@ -197,6 +201,7 @@ impl VirtualMachine {
|
|||||||
None,
|
None,
|
||||||
std::collections::HashMap::new(),
|
std::collections::HashMap::new(),
|
||||||
),
|
),
|
||||||
|
validated_image: None,
|
||||||
heap: Heap::with_budget(&budget),
|
heap: Heap::with_budget(&budget),
|
||||||
cycles: 0,
|
cycles: 0,
|
||||||
halted: false,
|
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<crate::ValidatedProgramImage>,
|
||||||
|
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).
|
/// Executes a single instruction at the current Program Counter (PC).
|
||||||
///
|
///
|
||||||
/// This follows the classic CPU cycle:
|
/// 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(
|
return Err(self.trap(
|
||||||
TRAP_STACK_UNDERFLOW,
|
TRAP_STACK_UNDERFLOW,
|
||||||
opcode as u16,
|
opcode as u16,
|
||||||
@@ -1072,14 +1091,21 @@ impl VirtualMachine {
|
|||||||
|
|
||||||
let stack_base = self.operand_stack.len() - callee.param_slots as usize;
|
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_local_slots = callee.local_slots;
|
||||||
let callee_offset = callee.code_offset;
|
let callee_offset = callee.code_offset;
|
||||||
self.operand_stack
|
let stack_growth = self
|
||||||
.reserve(callee_local_slots as usize)
|
.operand_stack
|
||||||
|
.prepare_growth(callee_local_slots as usize)
|
||||||
.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.call_stack
|
let frame_growth = self
|
||||||
.reserve(1)
|
.call_stack
|
||||||
|
.prepare_growth(1)
|
||||||
.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.commit_growth(stack_growth);
|
||||||
|
self.call_stack.commit_growth(frame_growth);
|
||||||
// Allocate and zero-init local_slots
|
// Allocate and zero-init local_slots
|
||||||
for _ in 0..callee_local_slots {
|
for _ in 0..callee_local_slots {
|
||||||
self.operand_stack
|
self.operand_stack
|
||||||
@@ -1093,7 +1119,7 @@ impl VirtualMachine {
|
|||||||
self.pc = callee_offset as usize;
|
self.pc = callee_offset as usize;
|
||||||
}
|
}
|
||||||
OpCode::Ret => {
|
OpCode::Ret => {
|
||||||
let frame = self.call_stack.pop().ok_or_else(|| {
|
let frame = self.call_stack.last().cloned().ok_or_else(|| {
|
||||||
self.trap(
|
self.trap(
|
||||||
TRAP_STACK_UNDERFLOW,
|
TRAP_STACK_UNDERFLOW,
|
||||||
opcode as u16,
|
opcode as u16,
|
||||||
@@ -1117,6 +1143,13 @@ impl VirtualMachine {
|
|||||||
), start_pc as u32));
|
), 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)
|
// Copy return values (preserving order: pop return_slots values, then reverse to push back)
|
||||||
let mut return_vals = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes);
|
let mut return_vals = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes);
|
||||||
return_vals
|
return_vals
|
||||||
@@ -1129,6 +1162,7 @@ impl VirtualMachine {
|
|||||||
}
|
}
|
||||||
return_vals.reverse();
|
return_vals.reverse();
|
||||||
|
|
||||||
|
self.call_stack.pop();
|
||||||
self.operand_stack.truncate(frame.stack_base);
|
self.operand_stack.truncate(frame.stack_base);
|
||||||
for val in return_vals.drain(..) {
|
for val in return_vals.drain(..) {
|
||||||
self.push_trap(val, opcode, start_pc as u32)?;
|
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 limits = RuntimeLimits::default().lowered(RuntimeResource::CallDepth, 0).unwrap();
|
||||||
let mut vm = VirtualMachine::with_runtime_limits(assemble("HALT").unwrap(), vec![], limits);
|
let mut vm = VirtualMachine::with_runtime_limits(assemble("HALT").unwrap(), vec![], limits);
|
||||||
let error = vm.prepare_boot_call().unwrap_err();
|
let error = vm.prepare_boot_call().unwrap_err();
|
||||||
|
let VmInitError::RuntimeResourceLimit(error) = error else { panic!("{error:?}") };
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
(error.resource, error.requested, error.limit),
|
(error.resource, error.requested, error.limit),
|
||||||
(RuntimeResource::CallDepth, 1, 0)
|
(RuntimeResource::CallDepth, 1, 0)
|
||||||
@@ -5056,7 +5091,9 @@ mod tests {
|
|||||||
fn guest_quota_failure_does_not_publish_an_entry_context() {
|
fn guest_quota_failure_does_not_publish_an_entry_context() {
|
||||||
let limits = RuntimeLimits::default().lowered(RuntimeResource::GuestBytes, 0).unwrap();
|
let limits = RuntimeLimits::default().lowered(RuntimeResource::GuestBytes, 0).unwrap();
|
||||||
let mut vm = VirtualMachine::with_runtime_limits(assemble("HALT").unwrap(), vec![], limits);
|
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.current_coro.is_none());
|
||||||
assert!(vm.call_stack.is_empty());
|
assert!(vm.call_stack.is_empty());
|
||||||
assert_eq!(vm.heap.len(), 0);
|
assert_eq!(vm.heap.len(), 0);
|
||||||
|
|||||||
@@ -70,6 +70,7 @@ fn patch_module_hostcalls(
|
|||||||
impl VirtualMachine {
|
impl VirtualMachine {
|
||||||
pub fn initialize(&mut self, program_bytes: Vec<u8>) -> Result<(), VmInitError> {
|
pub fn initialize(&mut self, program_bytes: Vec<u8>) -> Result<(), VmInitError> {
|
||||||
self.program = ProgramImage::default();
|
self.program = ProgramImage::default();
|
||||||
|
self.validated_image = None;
|
||||||
self.pc = 0;
|
self.pc = 0;
|
||||||
self.operand_stack.clear();
|
self.operand_stack.clear();
|
||||||
self.call_stack.clear();
|
self.call_stack.clear();
|
||||||
@@ -128,26 +129,61 @@ impl VirtualMachine {
|
|||||||
self.capabilities = caps;
|
self.capabilities = caps;
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn prepare_boot_call(&mut self) -> Result<(), ResourceFailure> {
|
pub fn prepare_boot_call(&mut self) -> Result<(), VmInitError> {
|
||||||
self.prepare_call_by_index(0)
|
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::<usize>() {
|
let func_idx = if let Ok(idx) = entrypoint.parse::<usize>() {
|
||||||
idx
|
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 {
|
} else {
|
||||||
self.program.exports.get(entrypoint).map(|&idx| idx as usize).ok_or(()).unwrap_or(0)
|
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)?;
|
self.budget.check(RuntimeResource::CallDepth, 1)?;
|
||||||
let callee = self.program.functions.get(func_idx).cloned().unwrap_or_default();
|
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;
|
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()))?;
|
let stack_growth = self
|
||||||
self.call_stack.reserve(1usize.saturating_sub(self.call_stack.len()))?;
|
.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(
|
let main_href = self.heap.allocate_coroutine(
|
||||||
callee.code_offset as usize,
|
callee.code_offset as usize,
|
||||||
CoroutineState::Running,
|
CoroutineState::Running,
|
||||||
@@ -155,6 +191,8 @@ impl VirtualMachine {
|
|||||||
BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes),
|
BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes),
|
||||||
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.pc = callee.code_offset as usize;
|
||||||
self.halted = false;
|
self.halted = false;
|
||||||
|
|
||||||
@@ -162,8 +200,13 @@ impl VirtualMachine {
|
|||||||
self.call_stack.clear();
|
self.call_stack.clear();
|
||||||
|
|
||||||
if let Some(func) = self.program.functions.get(func_idx) {
|
if let Some(func) = self.program.functions.get(func_idx) {
|
||||||
let total_slots = func.param_slots as u32 + func.local_slots as u32;
|
let typed = self.validated_image.is_some();
|
||||||
for _ in 0..total_slots {
|
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)?;
|
self.operand_stack.push(Value::Null)?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -45,6 +45,9 @@ impl VirtualMachine {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub fn pop(&mut self) -> Result<Value, String> {
|
pub fn pop(&mut self) -> Result<Value, String> {
|
||||||
|
if self.temporary_slots() == 0 {
|
||||||
|
return Err("Stack underflow".into());
|
||||||
|
}
|
||||||
self.operand_stack.pop().ok_or("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> {
|
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())
|
self.operand_stack.last().ok_or("Stack underflow".into())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -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(())
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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<u8>, opcode: OpCode) {
|
||||||
|
code.extend_from_slice(&(opcode as u16).to_le_bytes());
|
||||||
|
}
|
||||||
|
fn arg(code: &mut Vec<u8>, 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<FunctionDecl>) -> Arc<ValidatedProgramImage> {
|
||||||
|
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<str> = 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);
|
||||||
|
}
|
||||||
@@ -17,9 +17,16 @@ pub enum VmInitError {
|
|||||||
ImageLoadFailed(prometeu_bytecode::LoadError),
|
ImageLoadFailed(prometeu_bytecode::LoadError),
|
||||||
LoaderPatchFailed(LoaderPatchError),
|
LoaderPatchFailed(LoaderPatchError),
|
||||||
EntrypointNotFound,
|
EntrypointNotFound,
|
||||||
|
EntrypointArgumentsInvalid { function: u32, slot: u32, trap_code: u32 },
|
||||||
VerificationFailed(crate::verifier::VerifierError),
|
VerificationFailed(crate::verifier::VerifierError),
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl From<crate::resource_budget::ResourceFailure> for VmInitError {
|
||||||
|
fn from(value: crate::resource_budget::ResourceFailure) -> Self {
|
||||||
|
Self::RuntimeResourceLimit(value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
impl From<prometeu_bytecode::load_limits::LoadFailure> for VmInitError {
|
impl From<prometeu_bytecode::load_limits::LoadFailure> for VmInitError {
|
||||||
fn from(value: prometeu_bytecode::load_limits::LoadFailure) -> Self {
|
fn from(value: prometeu_bytecode::load_limits::LoadFailure) -> Self {
|
||||||
Self::RegistryLoadFailed(value)
|
Self::RegistryLoadFailed(value)
|
||||||
|
|||||||
@@ -289,12 +289,14 @@ pub(super) fn fault(report: &CrashReport) -> Value {
|
|||||||
}
|
}
|
||||||
CrashReport::VmInit { error } => {
|
CrashReport::VmInit { error } => {
|
||||||
let code = match error {
|
let code = match error {
|
||||||
|
VmInitError::RegistryLoadFailed(_) => "registry_load_failed",
|
||||||
VmInitError::RuntimeResourceLimit(_) => "runtime_resource_limit",
|
VmInitError::RuntimeResourceLimit(_) => "runtime_resource_limit",
|
||||||
VmInitError::InvalidFormat => "invalid_format",
|
VmInitError::InvalidFormat => "invalid_format",
|
||||||
VmInitError::UnsupportedFormat => "unsupported_format",
|
VmInitError::UnsupportedFormat => "unsupported_format",
|
||||||
VmInitError::ImageLoadFailed(_) => "image_load_failed",
|
VmInitError::ImageLoadFailed(_) => "image_load_failed",
|
||||||
VmInitError::LoaderPatchFailed(_) => "loader_patch_failed",
|
VmInitError::LoaderPatchFailed(_) => "loader_patch_failed",
|
||||||
VmInitError::EntrypointNotFound => "entrypoint_not_found",
|
VmInitError::EntrypointNotFound => "entrypoint_not_found",
|
||||||
|
VmInitError::EntrypointArgumentsInvalid { .. } => "entrypoint_arguments_invalid",
|
||||||
VmInitError::VerificationFailed(_) => "verification_failed",
|
VmInitError::VerificationFailed(_) => "verification_failed",
|
||||||
};
|
};
|
||||||
result["initError"] = json!({"code":code,"message":format!("{error:?}")});
|
result["initError"] = json!({"code":code,"message":format!("{error:?}")});
|
||||||
|
|||||||
Reference in New Issue
Block a user