114 lines
4.0 KiB
Rust
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(())
|
|
}
|
|
}
|