161 lines
6.6 KiB
Rust
161 lines
6.6 KiB
Rust
//! Exact scalar identities. Public math overloads are a consumer projection.
|
|
use crate::builtins::{AbiType, BuiltinScalarType, IntrinsicExecutionError as E, IntrinsicMeta};
|
|
use crate::numeric::{self, NumericError};
|
|
use prometeu_bytecode::{TRAP_NUMERIC_DOMAIN, TRAP_NUMERIC_RANGE, Value};
|
|
use prometeu_hal::HostContext;
|
|
const I32: AbiType = AbiType::Scalar(BuiltinScalarType::Int32);
|
|
const I64: AbiType = AbiType::Scalar(BuiltinScalarType::Int64);
|
|
const FLOAT: AbiType = AbiType::Scalar(BuiltinScalarType::Float);
|
|
const fn entry<const ID: u32>(
|
|
owner: &'static str,
|
|
name: &'static str,
|
|
arg_layout: &'static [AbiType],
|
|
ret_layout: &'static [AbiType],
|
|
parameter_names: &'static [&'static str],
|
|
cost_cycles: u64,
|
|
) -> IntrinsicMeta {
|
|
IntrinsicMeta {
|
|
id: ID,
|
|
owner,
|
|
name,
|
|
version: 1,
|
|
arg_layout,
|
|
arg_nullable: match arg_layout.len() {
|
|
1 => &[false],
|
|
2 => &[false, false],
|
|
_ => &[false, false, false],
|
|
},
|
|
ret_layout,
|
|
parameter_names,
|
|
cost_cycles,
|
|
cost_model: crate::IntrinsicCostModel::Fixed,
|
|
cost_arg_index: None,
|
|
cost_per_byte: 0,
|
|
attempt_cost_cycles: 0,
|
|
max_attempts: 0,
|
|
mutates_guest_state: false,
|
|
deterministic: true,
|
|
may_allocate: false,
|
|
implementation: crate::IntrinsicImplementation::Host(execute::<ID>),
|
|
}
|
|
}
|
|
pub(crate) const MATH_INTRINSICS: [IntrinsicMeta; 26] = [
|
|
entry::<0x3000>("math.i32", "min", &[I32, I32], &[I32], &["a", "b"], 2),
|
|
entry::<0x3001>("math.i32", "max", &[I32, I32], &[I32], &["a", "b"], 2),
|
|
entry::<0x3002>("math.i32", "clamp", &[I32, I32, I32], &[I32], &["value", "min", "max"], 4),
|
|
entry::<0x3003>("math.i32", "abs", &[I32], &[I32], &["value"], 2),
|
|
entry::<0x3004>("math.i64", "min", &[I64, I64], &[I64], &["a", "b"], 2),
|
|
entry::<0x3005>("math.i64", "max", &[I64, I64], &[I64], &["a", "b"], 2),
|
|
entry::<0x3006>("math.i64", "clamp", &[I64, I64, I64], &[I64], &["value", "min", "max"], 4),
|
|
entry::<0x3007>("math.i64", "abs", &[I64], &[I64], &["value"], 2),
|
|
entry::<0x3008>("mathf", "min", &[FLOAT, FLOAT], &[FLOAT], &["a", "b"], 2),
|
|
entry::<0x3009>("mathf", "max", &[FLOAT, FLOAT], &[FLOAT], &["a", "b"], 2),
|
|
entry::<0x300a>(
|
|
"mathf",
|
|
"clamp",
|
|
&[FLOAT, FLOAT, FLOAT],
|
|
&[FLOAT],
|
|
&["value", "min", "max"],
|
|
4,
|
|
),
|
|
entry::<0x300b>("mathf", "abs", &[FLOAT], &[FLOAT], &["value"], 2),
|
|
entry::<0x300c>("mathf", "floor", &[FLOAT], &[FLOAT], &["value"], 4),
|
|
entry::<0x300d>("mathf", "ceil", &[FLOAT], &[FLOAT], &["value"], 4),
|
|
entry::<0x300e>("mathf", "trunc", &[FLOAT], &[FLOAT], &["value"], 4),
|
|
entry::<0x300f>("mathf", "round", &[FLOAT], &[FLOAT], &["value"], 4),
|
|
entry::<0x3010>("mathf", "sqrt", &[FLOAT], &[FLOAT], &["value"], 16),
|
|
entry::<0x3011>("mathf", "sin", &[FLOAT], &[FLOAT], &["angle"], 32),
|
|
entry::<0x3012>("mathf", "cos", &[FLOAT], &[FLOAT], &["angle"], 32),
|
|
entry::<0x3013>("mathf", "atan2", &[FLOAT, FLOAT], &[FLOAT], &["y", "x"], 48),
|
|
entry::<0x3014>("math.i32", "to_i64", &[I32], &[I64], &["value"], 2),
|
|
entry::<0x3015>("math.i64", "to_i32", &[I64], &[I32], &["value"], 2),
|
|
entry::<0x3016>("math.i32", "to_float", &[I32], &[FLOAT], &["value"], 2),
|
|
entry::<0x3017>("math.i64", "to_float", &[I64], &[FLOAT], &["value"], 2),
|
|
entry::<0x3018>("mathf", "to_i32", &[FLOAT], &[I32], &["value"], 2),
|
|
entry::<0x3019>("mathf", "to_i64", &[FLOAT], &[I64], &["value"], 2),
|
|
];
|
|
impl From<NumericError> for E {
|
|
fn from(error: NumericError) -> Self {
|
|
Self::Numeric(error)
|
|
}
|
|
}
|
|
fn integer(args: &[Value], offset: u32, narrow: bool) -> Result<Value, E> {
|
|
let mut a = [0i64; 3];
|
|
for (i, value) in args.iter().enumerate() {
|
|
a[i] = match value {
|
|
Value::Int32(v) => i64::from(*v),
|
|
Value::Int64(v) => *v,
|
|
_ => unreachable!("validated exact integer carrier"),
|
|
};
|
|
}
|
|
let result = match offset {
|
|
0 => a[0].min(a[1]),
|
|
1 => a[0].max(a[1]),
|
|
2 => {
|
|
if a[1] > a[2] {
|
|
return Err(NumericError::new(TRAP_NUMERIC_DOMAIN).into());
|
|
}
|
|
a[0].clamp(a[1], a[2])
|
|
}
|
|
3 => {
|
|
if (narrow && a[0] == i64::from(i32::MIN)) || a[0] == i64::MIN {
|
|
return Err(NumericError::new(TRAP_NUMERIC_RANGE).into());
|
|
}
|
|
a[0].abs()
|
|
}
|
|
_ => unreachable!("private integer operation"),
|
|
};
|
|
Ok(if narrow { Value::Int32(result as i32) } else { Value::Int64(result) })
|
|
}
|
|
fn execute<const ID: u32>(args: &[Value], _: &mut HostContext<'_>) -> Result<Vec<Value>, E> {
|
|
let meta = crate::lookup_intrinsic_by_id(ID).expect("static scalar identity");
|
|
meta.validate_argument_values(args)?;
|
|
if ID < 0x3008 {
|
|
return Ok(vec![integer(args, (ID - 0x3000) % 4, ID < 0x3004)?]);
|
|
}
|
|
let mut floats = [0.0; 3];
|
|
for (i, value) in args.iter().enumerate() {
|
|
if let Value::Float(v) = value {
|
|
floats[i] = *v;
|
|
}
|
|
}
|
|
if (0x3008..=0x3013).contains(&ID) || ID >= 0x3018 {
|
|
numeric::check_inputs(&floats[..args.len()])?;
|
|
}
|
|
let x = floats[0];
|
|
let value = match ID {
|
|
0x3008 => Value::Float(numeric::min(x, floats[1])),
|
|
0x3009 => Value::Float(numeric::max(x, floats[1])),
|
|
0x300a => Value::Float(numeric::clamp(x, floats[1], floats[2])?),
|
|
0x300b => Value::Float(numeric::abs(x)),
|
|
0x300c => Value::Float(numeric::floor(x)?),
|
|
0x300d => Value::Float(numeric::ceil(x)?),
|
|
0x300e => Value::Float(numeric::trunc(x)?),
|
|
0x300f => Value::Float(numeric::round(x)?),
|
|
0x3010 => Value::Float(numeric::sqrt(x)?),
|
|
0x3011 => Value::Float(numeric::sin(x)?),
|
|
0x3012 => Value::Float(numeric::cos(x)?),
|
|
0x3013 => Value::Float(numeric::atan2(x, floats[1])?),
|
|
0x3014 => {
|
|
let Value::Int32(v) = args[0] else { unreachable!() };
|
|
Value::Int64(i64::from(v))
|
|
}
|
|
0x3015 => {
|
|
let Value::Int64(v) = args[0] else { unreachable!() };
|
|
Value::Int32(i32::try_from(v).map_err(|_| NumericError::new(TRAP_NUMERIC_RANGE))?)
|
|
}
|
|
0x3016 => {
|
|
let Value::Int32(v) = args[0] else { unreachable!() };
|
|
Value::Float(numeric::from_i64(i64::from(v)))
|
|
}
|
|
0x3017 => {
|
|
let Value::Int64(v) = args[0] else { unreachable!() };
|
|
Value::Float(numeric::from_i64(v))
|
|
}
|
|
0x3018 => Value::Int32(numeric::to_i64(x, 32)? as i32),
|
|
0x3019 => Value::Int64(numeric::to_i64(x, 64)?),
|
|
_ => unreachable!("static scalar identity"),
|
|
};
|
|
Ok(vec![value])
|
|
}
|