feat(vm): add deterministic gameplay math and domain coverage gates
Intrepid/Prometeu/Runtime/pipeline/pr-master There was a failure building this commit

This commit is contained in:
2026-10-09 10:25:11 +01:00
parent 2e041266f1
commit 9318cf7cd3
47 changed files with 8825 additions and 281 deletions
+86 -120
View File
@@ -1,3 +1,4 @@
use crate::numeric;
use crate::resource_budget::BudgetVec;
mod callable;
mod collections;
@@ -65,6 +66,12 @@ pub(crate) enum OpError {
Trap(u32, String),
}
impl From<crate::numeric::NumericError> for OpError {
fn from(error: crate::numeric::NumericError) -> Self {
Self::Trap(error.code, format!("Numeric operation failed: {error:?}"))
}
}
impl From<TrapInfo> for LogicalFrameEndingReason {
fn from(info: TrapInfo) -> Self {
LogicalFrameEndingReason::Trap(info)
@@ -276,6 +283,15 @@ impl VirtualMachine {
self.cycles += opcode.cycles();
}
let charged_math = if opcode == OpCode::Intrinsic {
lookup_intrinsic_by_id(instr.imm_u32().unwrap())
.filter(|m| m.owner == "vec2" || m.owner == "mathf" || m.owner.starts_with("math."))
} else {
None
};
if let Some(meta) = charged_math {
self.cycles += meta.cost_cycles;
}
// Execute
match opcode {
OpCode::Nop => {}
@@ -436,117 +452,40 @@ impl VirtualMachine {
{
self.execute_string_add(opcode, start_pc as u32)?;
} else {
self.binary_op(opcode, start_pc as u32, |a, b| match (&a, &b) {
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_add(*b))),
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_add(*b))),
(Value::Int32(a), Value::Int64(b)) => {
Ok(Value::Int64((*a as i64).wrapping_add(*b)))
}
(Value::Int64(a), Value::Int32(b)) => {
Ok(Value::Int64(a.wrapping_add(*b as i64)))
}
(Value::Float(a), Value::Float(b)) => Ok(Value::Float(a + b)),
(Value::Int32(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)),
(Value::Float(a), Value::Int32(b)) => Ok(Value::Float(a + *b as f64)),
(Value::Int64(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)),
(Value::Float(a), Value::Int64(b)) => Ok(Value::Float(a + *b as f64)),
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for ADD".into())),
self.binary_op(opcode, start_pc as u32, |a, b| {
numeric::opcode_binary(opcode, &a, &b).map_err(|e| {
if e.code == TRAP_TYPE {
OpError::Trap(
TRAP_TYPE,
format!(
"Invalid types for {}",
format!("{opcode:?}").to_uppercase()
),
)
} else {
OpError::from(e)
}
})
})?;
}
}
OpCode::Sub => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_sub(b))),
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_sub(b))),
(Value::Int32(a), Value::Int64(b)) => Ok(Value::Int64((a as i64).wrapping_sub(b))),
(Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a.wrapping_sub(b as i64))),
(Value::Float(a), Value::Float(b)) => Ok(Value::Float(a - b)),
(Value::Int32(a), Value::Float(b)) => Ok(Value::Float(a as f64 - b)),
(Value::Float(a), Value::Int32(b)) => Ok(Value::Float(a - b as f64)),
(Value::Int64(a), Value::Float(b)) => Ok(Value::Float(a as f64 - b)),
(Value::Float(a), Value::Int64(b)) => Ok(Value::Float(a - b as f64)),
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for SUB".into())),
})?,
OpCode::Mul => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
(Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_mul(b))),
(Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_mul(b))),
(Value::Int32(a), Value::Int64(b)) => Ok(Value::Int64((a as i64).wrapping_mul(b))),
(Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a.wrapping_mul(b as i64))),
(Value::Float(a), Value::Float(b)) => Ok(Value::Float(a * b)),
(Value::Int32(a), Value::Float(b)) => Ok(Value::Float(a as f64 * b)),
(Value::Float(a), Value::Int32(b)) => Ok(Value::Float(a * b as f64)),
(Value::Int64(a), Value::Float(b)) => Ok(Value::Float(a as f64 * b)),
(Value::Float(a), Value::Int64(b)) => Ok(Value::Float(a * b as f64)),
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for MUL".into())),
})?,
OpCode::Div => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
(Value::Int32(a), Value::Int32(b)) => {
if b == 0 {
return Err(OpError::Trap(
TRAP_DIV_ZERO,
"Integer division by zero".into(),
));
}
Ok(Value::Int32(a.wrapping_div(b)))
}
(Value::Int64(a), Value::Int64(b)) => {
if b == 0 {
return Err(OpError::Trap(
TRAP_DIV_ZERO,
"Integer division by zero".into(),
));
}
Ok(Value::Int64(a.wrapping_div(b)))
}
(Value::Int32(a), Value::Int64(b)) => {
if b == 0 {
return Err(OpError::Trap(
TRAP_DIV_ZERO,
"Integer division by zero".into(),
));
}
Ok(Value::Int64((a as i64).wrapping_div(b)))
}
(Value::Int64(a), Value::Int32(b)) => {
if b == 0 {
return Err(OpError::Trap(
TRAP_DIV_ZERO,
"Integer division by zero".into(),
));
}
Ok(Value::Int64(a.wrapping_div(b as i64)))
}
(Value::Float(a), Value::Float(b)) => {
if b == 0.0 {
return Err(OpError::Trap(TRAP_DIV_ZERO, "Float division by zero".into()));
}
Ok(Value::Float(a / b))
}
(Value::Int32(a), Value::Float(b)) => {
if b == 0.0 {
return Err(OpError::Trap(TRAP_DIV_ZERO, "Float division by zero".into()));
}
Ok(Value::Float(a as f64 / b))
}
(Value::Float(a), Value::Int32(b)) => {
if b == 0 {
return Err(OpError::Trap(TRAP_DIV_ZERO, "Float division by zero".into()));
}
Ok(Value::Float(a / b as f64))
}
(Value::Int64(a), Value::Float(b)) => {
if b == 0.0 {
return Err(OpError::Trap(TRAP_DIV_ZERO, "Float division by zero".into()));
}
Ok(Value::Float(a as f64 / b))
}
(Value::Float(a), Value::Int64(b)) => {
if b == 0 {
return Err(OpError::Trap(TRAP_DIV_ZERO, "Float division by zero".into()));
}
Ok(Value::Float(a / b as f64))
}
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for DIV".into())),
})?,
OpCode::Sub | OpCode::Mul | OpCode::Div => {
self.binary_op(opcode, start_pc as u32, |a, b| {
numeric::opcode_binary(opcode, &a, &b).map_err(|e| {
if e.code == TRAP_TYPE {
OpError::Trap(
TRAP_TYPE,
format!(
"Invalid types for {}",
format!("{opcode:?}").to_uppercase()
),
)
} else {
OpError::from(e)
}
})
})?
}
OpCode::Mod => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) {
(Value::Int32(a), Value::Int32(b)) => {
if b == 0 {
@@ -562,29 +501,33 @@ impl VirtualMachine {
}
_ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for MOD".into())),
})?,
OpCode::Eq => {
self.binary_op(opcode, start_pc as u32, |a, b| Ok(Value::Boolean(a == b)))?
}
OpCode::Neq => {
self.binary_op(opcode, start_pc as u32, |a, b| Ok(Value::Boolean(a != b)))?
}
OpCode::Eq => self.binary_op(opcode, start_pc as u32, |a, b| {
numeric::equal_values(&a, &b).map(Value::Boolean).map_err(OpError::from)
})?,
OpCode::Neq => self.binary_op(opcode, start_pc as u32, |a, b| {
numeric::equal_values(&a, &b).map(|v| Value::Boolean(!v)).map_err(OpError::from)
})?,
OpCode::Lt => self.binary_op(opcode, start_pc as u32, |a, b| {
a.partial_cmp(&b)
numeric::compare_values(&a, &b)
.map_err(OpError::from)?
.map(|o| Value::Boolean(o == std::cmp::Ordering::Less))
.ok_or_else(|| OpError::Trap(TRAP_TYPE, "Invalid types for LT".into()))
})?,
OpCode::Gt => self.binary_op(opcode, start_pc as u32, |a, b| {
a.partial_cmp(&b)
numeric::compare_values(&a, &b)
.map_err(OpError::from)?
.map(|o| Value::Boolean(o == std::cmp::Ordering::Greater))
.ok_or_else(|| OpError::Trap(TRAP_TYPE, "Invalid types for GT".into()))
})?,
OpCode::Lte => self.binary_op(opcode, start_pc as u32, |a, b| {
a.partial_cmp(&b)
numeric::compare_values(&a, &b)
.map_err(OpError::from)?
.map(|o| Value::Boolean(o != std::cmp::Ordering::Greater))
.ok_or_else(|| OpError::Trap(TRAP_TYPE, "Invalid types for LTE".into()))
})?,
OpCode::Gte => self.binary_op(opcode, start_pc as u32, |a, b| {
a.partial_cmp(&b)
numeric::compare_values(&a, &b)
.map_err(OpError::from)?
.map(|o| Value::Boolean(o != std::cmp::Ordering::Less))
.ok_or_else(|| OpError::Trap(TRAP_TYPE, "Invalid types for GTE".into()))
})?,
@@ -657,7 +600,12 @@ impl VirtualMachine {
Value::Int64(a) => {
self.push_trap(Value::Int64(a.wrapping_neg()), opcode, start_pc as u32)?
}
Value::Float(a) => self.push_trap(Value::Float(-a), opcode, start_pc as u32)?,
Value::Float(a) => {
let result = numeric::neg(a).map_err(|e| {
self.trap(e.code, opcode as u16, format!("NEG: {e:?}"), start_pc as u32)
})?;
self.push_trap(Value::Float(result), opcode, start_pc as u32)?;
}
_ => {
return Err(self.trap(
TRAP_TYPE,
@@ -997,6 +945,15 @@ impl VirtualMachine {
),
pc_at_intrinsic,
),
crate::IntrinsicExecutionError::Numeric(error) => self.trap(
error.code,
opcode as u16,
format!(
"Intrinsic {}.{}: {:?}",
intrinsic.owner, intrinsic.name, error
),
pc_at_intrinsic,
),
crate::IntrinsicExecutionError::HardwareUnavailable => self.trap(
TRAP_UNAVAILABLE,
OpCode::Intrinsic as u16,
@@ -1027,6 +984,15 @@ impl VirtualMachine {
),
pc_at_intrinsic,
),
crate::IntrinsicExecutionError::Numeric(error) => self.trap(
error.code,
opcode as u16,
format!(
"Intrinsic {}.{} result: {:?}",
intrinsic.owner, intrinsic.name, error
),
pc_at_intrinsic,
),
crate::IntrinsicExecutionError::HardwareUnavailable => self.trap(
TRAP_UNAVAILABLE,
OpCode::Intrinsic as u16,
@@ -1073,7 +1039,7 @@ impl VirtualMachine {
}
// Control attempts were already charged before validation.
if !charged_control {
if !charged_control && charged_math.is_none() {
self.cycles += opcode.cycles();
}
Ok(())