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