Files
prometeu-runtime/crates/console/prometeu-vm/src/virtual_machine/intrinsic.rs
T

114 lines
4.0 KiB
Rust

//! Shared borrowed invocation; algorithms receive no host/VM context.
use super::*;
use crate::{
AbiType, IntrinsicExecutionError as E, IntrinsicImplementation as I, IntrinsicMeta,
IntrinsicResults,
};
impl VirtualMachine {
fn inline_values(
&self,
values: &[Value],
layout: &[AbiType],
) -> Result<(), crate::value_contract::ValueError> {
use crate::value_contract::ValueError;
for (value, abi) in values.iter().zip(layout) {
match value {
Value::String(content) if self.validated_image.is_some() => {
if !self.validated_image.as_ref().unwrap().retains_string(content)
&& !self.strings.as_ref().is_some_and(|domain| domain.retains(content))
{
return Err(ValueError::Type);
}
}
Value::HeapRef(reference) if matches!(abi, AbiType::Builtin(key) if key.name == "Random") =>
{
self.heap.random_state(*reference)?;
}
_ => {}
}
}
Ok(())
}
pub(super) fn execute_inline_intrinsic(
&mut self,
meta: &IntrinsicMeta,
pc: u32,
) -> Result<(), LogicalFrameEndingReason> {
let op = OpCode::Intrinsic;
let consumed = meta.arg_slots();
let enough = self.temporary_slots() >= consumed;
let args =
if enough { &self.operand_stack[self.operand_stack.len() - consumed..] } else { &[] };
let Some(cost) = meta.attempted_cost(args) else {
self.cycles += meta.cost_cycles;
return Err(self.trap(
TRAP_RESOURCE_LIMIT,
op as u16,
"Intrinsic attempted cost overflow".into(),
pc,
));
};
self.cycles += cost;
meta.validate_descriptor()
.map_err(|message| self.trap(TRAP_INVALID_INTRINSIC, op as u16, message.into(), pc))?;
if !enough {
return Err(self.trap(
TRAP_STACK_UNDERFLOW,
op as u16,
"Incomplete intrinsic operands".into(),
pc,
));
}
let I::BorrowedInline(handler) = meta.implementation else {
return Err(self.trap(
TRAP_INVALID_INTRINSIC,
op as u16,
"Wrong invocation profile".into(),
pc,
));
};
let base = self.operand_stack.len() - consumed;
let args = &self.operand_stack[base..];
meta.validate_argument_values(args).map_err(|_| {
self.trap(TRAP_TYPE, op as u16, "Invalid intrinsic argument carrier".into(), pc)
})?;
self.inline_values(args, meta.arg_layout)
.map_err(|error| self.value_trap(error, op, pc))?;
let mut out = IntrinsicResults::new(meta.ret_slots());
handler(args, &mut out).map_err(|error| match error {
E::Numeric(error) => {
self.trap(error.code, op as u16, format!("Intrinsic numeric fault: {error:?}"), pc)
}
_ => self.trap(
TRAP_INVALID_INTRINSIC,
op as u16,
format!("Invalid intrinsic handler output: {error:?}"),
pc,
),
})?;
out.validate(meta).map_err(|error| {
self.trap(
TRAP_INVALID_INTRINSIC,
op as u16,
format!("Invalid intrinsic result: {error:?}"),
pc,
)
})?;
self.inline_values(out.as_slice(), meta.ret_layout).map_err(|_| {
self.trap(
TRAP_INVALID_INTRINSIC,
op as u16,
"Invalid intrinsic result ownership".into(),
pc,
)
})?;
self.operand_stack.truncate(base);
for value in out.into_values() {
self.operand_stack.push(value).expect("bounded result replaces admitted inputs");
}
Ok(())
}
}