fix(vm): enforce return boundaries and amortize budgeted growth
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Validate and complete function-end branches through the shared return path. Handle integer DIV/MOD overflow with wrapping and charge CALL/RET refusals exactly once. Amortize budgeted vector growth with exact-capacity fallback at quota limits. Add execution and accounting regressions, clarify ISA contracts, and include existing lint cleanups.
This commit is contained in:
@@ -0,0 +1,218 @@
|
||||
mod support {
|
||||
pub mod callables;
|
||||
}
|
||||
|
||||
use prometeu_bytecode::{Value, assemble, load_limits::*, registry::*};
|
||||
use prometeu_hal::{HostContext, syscalls::caps};
|
||||
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
use prometeu_vm::{
|
||||
LogicalFrameEndingReason, ValidatedProgramImage, VirtualMachine, VmInitError,
|
||||
resource_budget::{RuntimeLimits, RuntimeResource},
|
||||
};
|
||||
use support::callables::{Native, image, run, sig, vm};
|
||||
|
||||
#[test]
|
||||
fn root_end_branch_returns_without_executing_neighbor_or_retaining_locals() {
|
||||
let mut machine =
|
||||
vm(&[("PUSH_I32 42\nJMP 12", sig(&[], &[0]), vec![]), ("HALT", sig(&[], &[]), vec![])]);
|
||||
let report = run(&mut machine, 100);
|
||||
assert_eq!(report.reason, LogicalFrameEndingReason::EndOfRom);
|
||||
assert_eq!(report.cycles_used, 4); // PUSH_I32 + JMP; no decoded RET.
|
||||
assert!(machine.call_stack_is_empty());
|
||||
assert_eq!(machine.operand_stack_top(10), vec![Value::Int32(42)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn end_branch_returns_to_caller_from_direct_closure_and_trait_calls() {
|
||||
let mut direct = vm(&[
|
||||
("CALL 1\nPUSH_I32 1\nADD\nRET", sig(&[], &[0]), vec![]),
|
||||
("PUSH_I32 41\nJMP 12", sig(&[], &[0]), vec![]),
|
||||
("HALT", sig(&[], &[]), vec![]),
|
||||
]);
|
||||
let mut closure = vm(&[
|
||||
("PUSH_I32 42\nMAKE_CLOSURE fn=1,type=4\nCALL_CLOSURE 4\nRET", sig(&[], &[0]), vec![]),
|
||||
("GET_CAPTURE 0\nJMP 12", sig(&[], &[0]), vec![TypeId(0)]),
|
||||
("HALT", sig(&[], &[]), vec![]),
|
||||
]);
|
||||
let trait_image = image(
|
||||
&[
|
||||
(
|
||||
"STRUCT_NEW 5\nREF_TO_TRAIT source=5,target=7\nCALL_TRAIT type=7,method=0\nRET",
|
||||
sig(&[], &[0]),
|
||||
vec![],
|
||||
),
|
||||
("PUSH_I32 42\nJMP 12", sig(&[5], &[0]), vec![]),
|
||||
("HALT", sig(&[], &[]), vec![]),
|
||||
],
|
||||
vec![ImplementationDecl {
|
||||
owner: TypeId(5),
|
||||
trait_id: TypeId(7),
|
||||
methods: vec![FunctionId(1)],
|
||||
}],
|
||||
)
|
||||
.unwrap();
|
||||
let mut trait_call = VirtualMachine::from_image(trait_image, Default::default());
|
||||
trait_call.prepare_boot_call().unwrap();
|
||||
for machine in [&mut direct, &mut closure, &mut trait_call] {
|
||||
assert_eq!(run(machine, 1000).reason, LogicalFrameEndingReason::EndOfRom);
|
||||
assert!(machine.call_stack_is_empty());
|
||||
assert_eq!(machine.operand_stack_top(10), vec![Value::Int32(42)]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn conditional_end_branches_return_only_on_the_taken_edge() {
|
||||
for (op, taken) in [("JMP_IF_TRUE", true), ("JMP_IF_FALSE", false)] {
|
||||
for condition in [false, true] {
|
||||
let source = format!(
|
||||
"PUSH_I32 42\nPUSH_BOOL {}\n{op} 25\nPOP\nPUSH_I32 99\nRET",
|
||||
u8::from(condition)
|
||||
);
|
||||
let mut machine =
|
||||
vm(&[(&source, sig(&[], &[0]), vec![]), ("HALT", sig(&[], &[]), vec![])]);
|
||||
assert_eq!(run(&mut machine, 100).reason, LogicalFrameEndingReason::EndOfRom);
|
||||
assert!(machine.call_stack_is_empty());
|
||||
let expected = if condition == taken { 42 } else { 99 };
|
||||
assert_eq!(machine.operand_stack_top(10), vec![Value::Int32(expected)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn end_branch_preserves_multislot_results_and_frame_continuation() {
|
||||
let mut machine = vm(&[
|
||||
("CALL 1\nRET", sig(&[], &[2]), vec![]),
|
||||
(
|
||||
"FRAME_SYNC\nPUSH_F64 f64:0x3ff0000000000000\nPUSH_F64 f64:0x4000000000000000\nJMP 28",
|
||||
sig(&[], &[2]),
|
||||
vec![],
|
||||
),
|
||||
("HALT", sig(&[], &[]), vec![]),
|
||||
]);
|
||||
assert_eq!(run(&mut machine, 100).reason, LogicalFrameEndingReason::FrameSync);
|
||||
assert!(!machine.call_stack_is_empty());
|
||||
assert_eq!(run(&mut machine, 100).reason, LogicalFrameEndingReason::EndOfRom);
|
||||
assert!(machine.call_stack_is_empty());
|
||||
assert_eq!(machine.operand_stack_top(10), vec![Value::Float(2.), Value::Float(1.)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn root_end_branch_roots_closure_result_before_safepoint_collection() {
|
||||
let mut source = "MAKE_CLOSURE fn=1,type=4\nPOP\n".repeat(1030);
|
||||
source.push_str("PUSH_I32 42\nMAKE_CLOSURE fn=2,type=4\n");
|
||||
let end = assemble(&source).unwrap().len() + 6;
|
||||
source.push_str(&format!("JMP {end}"));
|
||||
let mut machine = vm(&[
|
||||
(&source, sig(&[], &[4]), vec![]),
|
||||
("PUSH_I32 0\nRET", sig(&[], &[0]), vec![]),
|
||||
("GET_CAPTURE 0\nRET", sig(&[], &[0]), vec![TypeId(0)]),
|
||||
]);
|
||||
assert_eq!(run(&mut machine, 100_000).reason, LogicalFrameEndingReason::EndOfRom);
|
||||
assert!(machine.call_stack_is_empty());
|
||||
assert_eq!(machine.heap().len(), 1);
|
||||
let snapshot = machine.operand_stack_top(10);
|
||||
assert_eq!(snapshot.len(), 1);
|
||||
let Value::HeapRef(owner) = snapshot[0] else { panic!("expected closure result") };
|
||||
assert!(machine.heap().is_valid(owner));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn end_branches_reject_proven_bad_results_at_load() {
|
||||
for source in [
|
||||
"PUSH_BOOL 1\nJMP 9",
|
||||
"PUSH_BOOL 1\nPUSH_BOOL 1\nJMP_IF_TRUE 22\nPOP\nPUSH_I32 42\nRET",
|
||||
"PUSH_BOOL 1\nPUSH_BOOL 0\nJMP_IF_FALSE 22\nPOP\nPUSH_I32 42\nRET",
|
||||
] {
|
||||
assert!(matches!(
|
||||
image(&[(source, sig(&[], &[0]), vec![])], vec![]),
|
||||
Err(VmInitError::RegistryLoadFailed(e))
|
||||
if e.code == LoadCode::InvalidCode && e.reason == LoadReason::TypeMismatch
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn end_branch_checks_unknown_results_without_releasing_frame() {
|
||||
let mut machine = vm(&[
|
||||
("PUSH_BOOL 1\nSET_GLOBAL 0\nCALL 1\nRET", sig(&[], &[0]), vec![]),
|
||||
("GET_GLOBAL 0\nJMP 12", sig(&[], &[0]), vec![]),
|
||||
]);
|
||||
let report = run(&mut machine, 100);
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(t)
|
||||
if t.code == prometeu_bytecode::TRAP_TYPE && t.opcode == 0x02 && t.pc == 23));
|
||||
assert!(!machine.call_stack_is_empty());
|
||||
assert_eq!(machine.operand_stack_top(1), vec![Value::Boolean(true)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn direct_call_depth_refusal_is_charged_once_and_zero_budget_is_inert() {
|
||||
let image = image(&[("CALL 0\nRET", sig(&[], &[]), vec![])], vec![]).unwrap();
|
||||
let limits = RuntimeLimits::default().lowered(RuntimeResource::CallDepth, 1).unwrap();
|
||||
let mut machine = VirtualMachine::from_image(image, limits);
|
||||
machine.prepare_boot_call().unwrap();
|
||||
let pc = machine.pc();
|
||||
let zero = run(&mut machine, 0);
|
||||
assert_eq!((zero.cycles_used, zero.steps_executed), (0, 0));
|
||||
assert_eq!(machine.pc(), pc);
|
||||
let failed = run(&mut machine, 1);
|
||||
assert_eq!((failed.cycles_used, failed.steps_executed), (5, 0));
|
||||
assert!(matches!(failed.reason, LogicalFrameEndingReason::Trap(t)
|
||||
if t.code == prometeu_bytecode::TRAP_RESOURCE_LIMIT && t.pc == pc as u32));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn direct_return_type_refusal_is_charged_once() {
|
||||
let mut machine = vm(&[("GET_GLOBAL 0\nRET", sig(&[], &[1]), vec![])]);
|
||||
assert_eq!(run(&mut machine, 1).steps_executed, 1);
|
||||
let report = run(&mut machine, 1);
|
||||
assert_eq!((report.cycles_used, report.steps_executed), (4, 0));
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(t)
|
||||
if t.code == prometeu_bytecode::TRAP_TYPE && t.pc == 6));
|
||||
assert!(!machine.call_stack_is_empty());
|
||||
assert_eq!(machine.operand_stack_top(1), vec![Value::Int32(0)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn integer_division_and_remainder_overflow_wrap_without_host_panic() {
|
||||
for (push, minimum, type_id) in [("PUSH_I32", i32::MIN as i64, 1), ("PUSH_I64", i64::MIN, 0)] {
|
||||
for (op, expected) in [("DIV", minimum), ("MOD", 0)] {
|
||||
let code = assemble(&format!("{push} {minimum}\n{push} -1\n{op}\nRET")).unwrap();
|
||||
let program = TestProgram::single(
|
||||
code,
|
||||
Signature { parameters: vec![], results: vec![TypeId(type_id)] },
|
||||
0,
|
||||
2,
|
||||
);
|
||||
let image = ValidatedProgramImage::load(
|
||||
&program.serialize(),
|
||||
&mut LoadBudget::new(Default::default()),
|
||||
caps::NONE,
|
||||
)
|
||||
.unwrap();
|
||||
let mut machine = VirtualMachine::from_image(image, Default::default());
|
||||
machine.prepare_boot_call().unwrap();
|
||||
assert_eq!(run(&mut machine, 100).reason, LogicalFrameEndingReason::EndOfRom);
|
||||
let value =
|
||||
if type_id == 1 { Value::Int32(expected as i32) } else { Value::Int64(expected) };
|
||||
assert_eq!(machine.operand_stack_top(1), vec![value]);
|
||||
}
|
||||
}
|
||||
// Promotion must happen before division: the Int32 minimum fits in Int64.
|
||||
for (source, expected) in [
|
||||
("PUSH_I32 -2147483648\nPUSH_I64 -1\nDIV\nRET", 2_147_483_648),
|
||||
("PUSH_I64 -9223372036854775808\nPUSH_I32 -1\nDIV\nRET", i64::MIN),
|
||||
] {
|
||||
let program = TestProgram::single(assemble(source).unwrap(), int64_signature(0, 1), 0, 2);
|
||||
let image = ValidatedProgramImage::load(
|
||||
&program.serialize(),
|
||||
&mut LoadBudget::new(Default::default()),
|
||||
caps::NONE,
|
||||
)
|
||||
.unwrap();
|
||||
let mut machine = VirtualMachine::from_image(image, Default::default());
|
||||
machine.prepare_boot_call().unwrap();
|
||||
let report = machine.run_budget(100, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||
assert_eq!(report.reason, LogicalFrameEndingReason::EndOfRom);
|
||||
assert_eq!(machine.operand_stack_top(1), vec![Value::Int64(expected)]);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user