263 lines
11 KiB
Rust
263 lines
11 KiB
Rust
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)]);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn maximum_width_mixed_return_preserves_order_and_caller_locals() {
|
|
// TestProgram catalog: Int64, Vec2, Float = 0, 6, 2.
|
|
let mut caller = String::from("PUSH_I64 73\nSET_LOCAL 0\nCALL 1\n");
|
|
caller.push_str(&"POP\n".repeat(1024));
|
|
caller.push_str("GET_LOCAL 0\nRET");
|
|
let mut callee = String::new();
|
|
let mut results = vec![];
|
|
let mut expected = vec![];
|
|
for i in 0..256 {
|
|
callee.push_str(&format!("PUSH_I64 {i}\nPUSH_F64 f64:0x3ff0000000000000\nPUSH_F64 f64:0x4000000000000000\nPUSH_F64 f64:0x4008000000000000\n"));
|
|
results.extend([TypeId(0), TypeId(6), TypeId(2)]);
|
|
expected.extend([Value::Int64(i), Value::Float(1.), Value::Float(2.), Value::Float(3.)]);
|
|
}
|
|
callee.push_str("RET");
|
|
let caller_code = assemble(&caller).unwrap();
|
|
let body = assemble(&callee).unwrap();
|
|
let mut program = TestProgram::single(caller_code.clone(), int64_signature(0, 1), 1, 1024);
|
|
program.functions.push(FunctionDecl {
|
|
signature: Signature { parameters: vec![], results },
|
|
code_offset: caller_code.len() as u32,
|
|
code_len: body.len() as u32,
|
|
local_slots: 3,
|
|
max_stack_slots: 1024,
|
|
..Default::default()
|
|
});
|
|
program.code.extend(body);
|
|
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();
|
|
for _ in 0..3 + 1024 + 1 {
|
|
machine.step(&mut Native, &mut HostContext::new(None)).unwrap();
|
|
}
|
|
expected.reverse();
|
|
assert_eq!(machine.operand_stack_top(1024), expected);
|
|
assert_eq!(run(&mut machine, 10000).reason, LogicalFrameEndingReason::EndOfRom);
|
|
assert_eq!(machine.operand_stack_top(1), vec![Value::Int64(73)]);
|
|
}
|