use prometeu_bytecode::load_limits::{LoadBudget, LoadCode as C, LoadReason as R}; use prometeu_bytecode::{ TRAP_DIV_ZERO, TRAP_NON_FINITE as NON_FINITE, TRAP_NUMERIC_DOMAIN as DOMAIN, TRAP_NUMERIC_RANGE as RANGE, TRAP_TYPE, Value, assemble, }; use prometeu_hal::vm_fault::VmFault; use prometeu_test_support::program::TestProgram; use prometeu_vm::resource_budget::RuntimeLimits; use prometeu_vm::{ HostContext, HostReturn, IntrinsicExecutionError as E, LogicalFrameEndingReason as End, NativeInterface, ValidatedProgramImage, VirtualMachine, VmInitError, lookup_intrinsic_by_id, materialize_builtin_constant, }; struct NoNative; impl NativeInterface for NoNative { fn syscall( &mut self, _: u32, _: &[Value], _: &mut HostReturn, _: &mut HostContext, ) -> Result<(), VmFault> { panic!("unexpected native call") } } fn call(id: u32, args: &[Value]) -> Result { let m = lookup_intrinsic_by_id(id).unwrap(); (m.implementation.host_callback().expect("host intrinsic"))(args, &mut HostContext::new(None)) .map(|mut v| v.remove(0)) } fn floats(id: u32, xs: &[f64]) -> Result { match call(id, &xs.iter().copied().map(Value::Float).collect::>()) { Ok(Value::Float(x)) => Ok(x.to_bits()), Err(E::Numeric(e)) => Err(e.code), v => panic!("{v:?}"), } } fn vm(source: &str, limits: RuntimeLimits) -> VirtualMachine { let bytes = TestProgram::single(assemble(source).unwrap(), Default::default(), 0, 8).serialize(); let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), 0).unwrap(); let mut vm = VirtualMachine::from_image(image, limits); vm.prepare_call("0").unwrap(); vm } fn run(vm: &mut VirtualMachine, budget: u64) -> prometeu_vm::BudgetReport { vm.run_budget(budget, &mut NoNative, &mut HostContext::new(None)).unwrap() } fn trap(r: &prometeu_vm::BudgetReport) -> &prometeu_bytecode::TrapInfo { let End::Trap(t) = &r.reason else { panic!("{r:?}") }; t } #[test] fn integer_limits_are_exact_and_abs_does_not_wrap() { for (base, a, b) in [ (0x3000, Value::Int32(i32::MIN), Value::Int32(i32::MAX)), (0x3004, Value::Int64(i64::MIN), Value::Int64(i64::MAX)), ] { assert_eq!(call(base, &[b.clone(), a.clone()]).unwrap(), a); assert_eq!(call(base + 1, &[a.clone(), b.clone()]).unwrap(), b); assert!( matches!(call(base+3,std::slice::from_ref(&a)),Err(E::Numeric(e)) if e.code==RANGE) ); assert!(matches!(call(base+2,&[b.clone(),b,a]),Err(E::Numeric(e)) if e.code==DOMAIN)); } assert_eq!( call(0x3002, &[Value::Int32(-5), Value::Int32(0), Value::Int32(10)]).unwrap(), Value::Int32(0) ); assert!( matches!(call(0x3002,&[Value::Int32(5),Value::Int32(10),Value::Int32(0)]),Err(E::Numeric(e)) if e.code==DOMAIN) ); } #[test] fn signed_zero_limits_and_rounding_follow_bits() { for a in [0.0f64, -0.0] { for b in [0.0f64, -0.0] { let same = a.to_bits() == b.to_bits(); assert_eq!( floats(0x3008, &[a, b]), Ok(if same { a.to_bits() } else { (-0.0f64).to_bits() }) ); assert_eq!(floats(0x3009, &[a, b]), Ok(if same { a.to_bits() } else { 0 })); } } assert_eq!(floats(0x300a, &[-0.0, 0.0, 1.0]), Ok(0)); assert_eq!(floats(0x300b, &[-0.0]), Ok(0)); assert_eq!(floats(0x3010, &[-0.0]), Ok((-0.0f64).to_bits())); for id in 0x300c..=0x300f { assert_eq!(floats(id, &[-0.0]), Ok((-0.0f64).to_bits())); } for (x, y) in [ (0.5, 0.0f64), (-0.5, -0.0), (1.5, 2.0), (2.5, 2.0), (3.5, 4.0), (-2.5, -2.0), (-3.5, -4.0), (f64::from_bits(0x3fe0000000000001), 1.0), (f64::from_bits(0x3fdfffffffffffff), 0.0), ] { assert_eq!(floats(0x300f, &[x]), Ok(y.to_bits())); } assert_eq!(floats(0x300c, &[-2.7]), Ok((-3.0f64).to_bits())); assert_eq!(floats(0x300d, &[-2.7]), Ok((-2.0f64).to_bits())); assert_eq!(floats(0x300e, &[-2.7]), Ok((-2.0f64).to_bits())); } #[test] fn atan2_has_explicit_zero_vector_and_signed_axis_contract() { for y in [0.0, -0.0] { for x in [0.0, -0.0] { assert_eq!(floats(0x3013, &[y, x]), Err(DOMAIN)); } } for (y, x, bits) in [ (0.0, 1.0, 0), (-0.0, 1.0, 1 << 63), (0.0, -1.0, 0x400921fb54442d18), (-0.0, -1.0, 0xc00921fb54442d18), (1.0, 0.0, 0x3ff921fb54442d18), (1.0, -0.0, 0x3ff921fb54442d18), (-1.0, 0.0, 0xbff921fb54442d18), (-1.0, -0.0, 0xbff921fb54442d18), ] { assert_eq!(floats(0x3013, &[y, x]), Ok(bits)); } assert_eq!(floats(0x3011, &[-0.0]), Ok(1 << 63)); assert_eq!(floats(0x3012, &[-0.0]), Ok(1.0f64.to_bits())); } #[test] fn conversions_check_the_truncated_integer_without_saturating() { for (x, expected) in [(3.9, 3), (-3.9, -3), (-2147483648.9, i32::MIN)] { assert_eq!(call(0x3018, &[Value::Float(x)]).unwrap(), Value::Int32(expected)); } assert!( matches!(call(0x3018,&[Value::Float(2147483648.0)]),Err(E::Numeric(e)) if e.code==RANGE) ); let minimum = f64::from_bits(0xc3e0000000000000); assert_eq!(call(0x3019, &[Value::Float(minimum)]).unwrap(), Value::Int64(i64::MIN)); let Value::Float(wide) = call(0x3017, &[Value::Int64(i64::MAX)]).unwrap() else { panic!() }; assert_eq!(wide.to_bits(), 0x43e0000000000000); assert!(matches!(call(0x3019,&[Value::Float(wide)]),Err(E::Numeric(e)) if e.code==RANGE)); assert_eq!( call(0x3019, &[Value::Float(f64::from_bits(0x43dfffffffffffff))]).unwrap(), Value::Int64(9223372036854774784) ); assert_eq!(call(0x3014, &[Value::Int32(i32::MIN)]).unwrap(), Value::Int64(i64::from(i32::MIN))); assert!(matches!(call(0x3015,&[Value::Int64(i64::MAX)]),Err(E::Numeric(e)) if e.code==RANGE)); assert_eq!(call(0x3018, &[Value::Float(-0.0)]).unwrap(), Value::Int32(0)); for (integer, bits) in [(9007199254740993, 0x4340000000000000), (9007199254740995, 0x4340000000000002)] { let Value::Float(v) = call(0x3017, &[Value::Int64(integer)]).unwrap() else { panic!() }; assert_eq!(v.to_bits(), bits); } } #[test] fn faults_validate_all_types_then_finitude_then_domain() { assert!(matches!( call(0x300a, &[Value::Float(f64::NAN), Value::Float(2.), Value::Int32(1)]), Err(E::TypeMismatch { index: 2, .. }) )); assert_eq!(floats(0x300a, &[f64::NAN, 2., 1.]), Err(NON_FINITE)); assert_eq!(floats(0x300a, &[0., 2., 1.]), Err(DOMAIN)); assert_eq!(floats(0x3010, &[-1.]), Err(DOMAIN)); for x in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] { assert_eq!(floats(0x3010, &[x]), Err(NON_FINITE)); } assert!(matches!( call( 0x1000, &[Value::Float(f64::NAN), Value::Float(1.), Value::Float(2.), Value::Int32(3)] ), Err(E::TypeMismatch { index: 3, .. }) )); } #[test] fn vector_sequences_keep_stage_rounding_and_scaled_extremes() { assert_eq!(floats(0x1001, &[1e200, 0.]), Ok(1e200f64.to_bits())); assert_eq!(floats(0x1001, &[f64::from_bits(1), 0.]), Ok(1)); assert_eq!(floats(0x1001, &[-0., -0.]), Ok(0)); assert_eq!(floats(0x1001, &[f64::MAX, f64::MAX]), Err(RANGE)); assert_eq!(floats(0x1000, &[f64::MAX, f64::MAX, 2., -2.]), Err(RANGE)); // (1+2^-27)*(1-2^-27) rounds to 1 before subtracting 1. assert_eq!( floats( 0x1000, &[f64::from_bits(0x3ff0000002000000), 1., f64::from_bits(0x3feffffffc000000), -1.] ), Ok(0) ); } #[test] fn math_attempts_charge_before_failure_and_positive_budget_overshoots() { for (bits, expected) in [(0x4010000000000000u64, None), (0xbff0000000000000, Some(DOMAIN))] { let mut v = vm(&format!("PUSH_F64 f64:0x{bits:016x}\nINTRINSIC 0x3010\nHALT"), Default::default()); assert_eq!(run(&mut v, 1).cycles_used, 2); let before = v.operand_stack_top(1); let zero = run(&mut v, 0); assert_eq!((zero.cycles_used, zero.steps_executed), (0, 0)); assert_eq!(&*before, &*v.operand_stack_top(1)); let attempt = run(&mut v, 1); assert_eq!(attempt.cycles_used, 16); if let Some(code) = expected { assert_eq!((trap(&attempt).code, trap(&attempt).pc), (code, 10)); } else { assert_eq!(attempt.reason, End::BudgetExhausted); let Value::Float(x) = v.operand_stack_top(1)[0] else { panic!() }; assert_eq!(x.to_bits(), 2.0f64.to_bits()); assert_eq!(run(&mut v, 1).cycles_used, 1); } } let mut v = vm("PUSH_I32 1\nSET_GLOBAL 0\nGET_GLOBAL 0\nINTRINSIC 0x3010\nHALT", Default::default()); run(&mut v, 8); let attempt = run(&mut v, 1); assert_eq!((attempt.cycles_used, trap(&attempt).code), (16, TRAP_TYPE)); let mut v = vm( "PUSH_F64 f64:0x4010000000000000\nINTRINSIC 0x3010\nHALT", RuntimeLimits::default() .lowered(prometeu_bytecode::RuntimeResource::TemporaryBytes, 0) .unwrap(), ); run(&mut v, 1); let attempt = run(&mut v, 1); assert_eq!( (attempt.cycles_used, trap(&attempt).code), (16, prometeu_bytecode::TRAP_RESOURCE_LIMIT) ); } #[test] fn float_opcodes_preserve_underflow_zero_division_and_numeric_faults() { for (source, bits) in [ ("PUSH_F64 f64:0x0000000000000001\nPUSH_F64 f64:0x3ff0000000000000\nMUL\nHALT", 1), ("PUSH_F64 f64:0x0000000000000001\nPUSH_F64 f64:0x4000000000000000\nDIV\nHALT", 0), ("PUSH_F64 f64:0x8000000000000000\nNEG\nHALT", 0), ( "PUSH_I64 9007199254740993\nPUSH_F64 f64:0x0000000000000000\nADD\nHALT", 0x4340000000000000, ), ] { let mut v = vm(source, Default::default()); assert_eq!(run(&mut v, 100).reason, End::Halted); let Value::Float(x) = v.operand_stack_top(1)[0] else { panic!() }; assert_eq!(x.to_bits(), bits); } for (source, code) in [ ("PUSH_F64 f64:0x7fefffffffffffff\nPUSH_F64 f64:0x4000000000000000\nMUL\nHALT", RANGE), ( "PUSH_F64 f64:0x3ff0000000000000\nPUSH_F64 f64:0x8000000000000000\nDIV\nHALT", TRAP_DIV_ZERO, ), ] { let mut v = vm(source, Default::default()); assert_eq!(trap(&run(&mut v, 100)).code, code); } } #[test] fn load_rejects_nonfinite_immediates_and_unknown_intrinsics_even_when_dead() { for (source, reason) in [ ("HALT\nPUSH_F64 f64:0x7ff0000000000000", R::NonFiniteValue), ("HALT\nPUSH_F64 f64:0x7ff8000000000042", R::NonFiniteValue), ("HALT\nINTRINSIC 0xffffffff", R::NativeId), ] { let bytes = TestProgram::single(assemble(source).unwrap(), Default::default(), 0, 8).serialize(); let Err(VmInitError::RegistryLoadFailed(e)) = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), 0) else { panic!() }; assert_eq!( (e.code, e.reason, e.function, e.pc), (C::InvalidCode, reason, Some(0), Some(2)) ); } } #[test] fn native_signature_checks_all_types_before_rejecting_nonfinite() { use prometeu_bytecode::registry::{NamedType, Signature, TypeId}; let mut program = TestProgram::single(assemble("HALT").unwrap(), Default::default(), 0, 8); program.functions[0].signature = Signature { parameters: vec![NamedType { type_id: TypeId(2), name: None }; 2], results: vec![], }; let image = ValidatedProgramImage::load( &program.serialize(), &mut LoadBudget::new(Default::default()), 0, ) .unwrap(); let mut v = VirtualMachine::from_image(image, Default::default()); for (args, slot, code) in [ ([Value::Float(f64::NAN), Value::Int32(1)], 1, TRAP_TYPE), ([Value::Float(f64::NAN), Value::Float(1.)], 0, NON_FINITE), ] { assert_eq!( v.prepare_call_with_args("0", &args), Err(VmInitError::EntrypointArgumentsInvalid { function: 0, slot, trap_code: code }) ); assert!(v.operand_stack_top(10).is_empty()); } assert!(matches!(v.push(Value::Float(f64::INFINITY)), Err(VmFault::Trap(NON_FINITE, _)))); assert!(v.operand_stack_top(10).is_empty()); } #[test] fn catalog_has_exact_ids_costs_names_and_canonical_constants() { let costs = [2, 2, 4, 2, 2, 2, 4, 2, 2, 2, 4, 2, 4, 4, 4, 4, 16, 32, 32, 48, 2, 2, 2, 2, 2, 2]; for (offset, cost) in costs.into_iter().enumerate() { let m = lookup_intrinsic_by_id(0x3000 + offset as u32).unwrap(); assert_eq!((m.version, m.cost_cycles), (1, cost)); assert_eq!(m.parameter_names.len(), m.arg_layout.len()); assert!(m.deterministic && !m.may_allocate); } for (id, cost) in [(0x1000, 10), (0x1001, 40), (0x1101, 1), (0x2100, 1)] { assert_eq!(lookup_intrinsic_by_id(id).unwrap().cost_cycles, cost); } for (name, bits) in [("pi", 0x400921fb54442d18), ("tau", 0x401921fb54442d18)] { let constants = materialize_builtin_constant("mathf", name, 1).unwrap().unwrap(); let Value::Float(x) = constants[0] else { panic!() }; assert_eq!(x.to_bits(), bits); } assert_eq!(lookup_intrinsic_by_id(0x3013).unwrap().parameter_names, &["y", "x"]); } #[test] fn exported_artifacts_match_the_single_runtime_catalog() { assert_eq!( prometeu_vm::intrinsic_catalog_csv(), include_str!("../../../../docs/vm-arch/INTRINSICS.csv") ); assert_eq!( prometeu_vm::builtin_constant_catalog_csv(), include_str!("../../../../docs/vm-arch/BUILTIN_CONSTANTS.csv") ); let mut ids = std::collections::HashSet::new(); let mut keys = std::collections::HashSet::new(); for m in prometeu_vm::intrinsic_catalog() { assert!(ids.insert(m.id)); assert!(keys.insert(m.key())); assert_eq!(m.parameter_names.len(), m.arg_slots()); } } fn fixture_value(token: &str) -> Value { let (kind, v) = token.split_once(':').unwrap(); match kind { "f" => Value::Float(f64::from_bits(u64::from_str_radix(v, 16).unwrap())), "i" => Value::Int32(v.parse().unwrap()), "l" => Value::Int64(v.parse().unwrap()), _ => panic!("numeric fixture"), } } fn value_token(v: &Value) -> String { match v { Value::Float(v) => format!("f:{:016x}", v.to_bits()), Value::Int32(v) => format!("i:{v}"), Value::Int64(v) => format!("l:{v}"), _ => panic!("numeric fixture result"), } } fn push_source(v: &Value) -> String { match v { Value::Float(v) => format!("PUSH_F64 f64:0x{:016x}\n", v.to_bits()), Value::Int32(v) => format!("PUSH_I32 {v}\n"), Value::Int64(v) => format!("PUSH_I64 {v}\n"), _ => panic!("numeric fixture argument"), } } #[test] fn mpfr_fixed_corpus_replays_without_a_runtime_or_test_mpfr_dependency() { for row in include_str!("fixtures/numeric-conformance.tsv").lines() { let tokens: Vec<_> = row.split_whitespace().collect(); let op = tokens[0]; let expected = tokens[tokens.len() - 2]; let cycles: u64 = tokens[tokens.len() - 1].parse().unwrap(); let args: Vec<_> = tokens[1..tokens.len() - 2].iter().map(|t| fixture_value(t)).collect(); if matches!(op, "ADD" | "SUB" | "MUL" | "DIV") { let source = args.iter().map(push_source).collect::() + op + "\nHALT"; let mut v = vm(&source, Default::default()); let report = run(&mut v, 100); assert_eq!(report.cycles_used, cycles, "{row}"); let actual = match report.reason { End::Halted => value_token(&v.operand_stack_top(1)[0]), End::Trap(t) => format!("trap:{:x}", t.code), e => panic!("{row}: {e:?}"), }; assert_eq!(actual, expected, "{row}"); } else { let id = u32::from_str_radix(op, 16).unwrap(); let actual = match call(id, &args) { Ok(v) => value_token(&v), Err(E::Numeric(e)) => format!("trap:{:x}", e.code), e => panic!("{e:?}"), }; assert_eq!(actual, expected, "{row}"); assert_eq!(lookup_intrinsic_by_id(id).unwrap().cost_cycles, cycles); } } } #[test] fn every_scalar_and_vector_call_has_the_published_total_execution_cost() { for m in prometeu_vm::intrinsic_catalog() .filter(|m| m.owner == "vec2" || m.owner == "mathf" || m.owner.starts_with("math.")) { let args: Vec<_> = m .arg_layout .iter() .enumerate() .map(|(i, t)| { let n = if m.name == "clamp" { [1, 0, 2][i] } else { 1 }; match t { prometeu_vm::AbiType::Scalar(prometeu_vm::BuiltinScalarType::Int32) => { Value::Int32(n) } prometeu_vm::AbiType::Scalar(prometeu_vm::BuiltinScalarType::Int64) => { Value::Int64(i64::from(n)) } _ => Value::Float(f64::from(n)), } }) .collect(); let source = args.iter().map(push_source).collect::() + &format!("INTRINSIC 0x{:x}\nHALT", m.id); let mut v = vm(&source, Default::default()); let prefix = run(&mut v, 2 * args.len() as u64); assert_eq!(prefix.cycles_used, 2 * args.len() as u64); let attempt = run(&mut v, 1); assert_eq!(attempt.cycles_used, m.cost_cycles, "{}", m.id); assert_eq!(attempt.reason, End::BudgetExhausted, "{}", m.id); } }