feat(vm): add deterministic gameplay math and domain coverage gates
Intrepid/Prometeu/Runtime/pipeline/pr-master There was a failure building this commit
Intrepid/Prometeu/Runtime/pipeline/pr-master There was a failure building this commit
This commit is contained in:
@@ -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(())
|
||||
|
||||
Reference in New Issue
Block a user