Files

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)]);
}