Struct CPU 

pub struct CPU { /* private fields */ }

Trait Implementations

impl Capabilities for CPU

const DESCRIPTION: &'static Description

Raw generated data. Internal reporting uses the validated capabilities.

impl Component for CPU

impl Debug for CPU

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CPU

fn default() -> CPU

Returns the “default value” for a type.

impl Execute<AddF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &AddF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<AddF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &AddF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<AddI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &AddI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<AddI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &AddI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<AddU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &AddU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<AddU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &AddU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<And> for CPU

type Message = PopFromStack<(bool, bool)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &And, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitAndI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitAndI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitAndI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitAndI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitAndU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitAndU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitAndU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitAndU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitOrI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitOrI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitOrI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitOrI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitOrU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitOrU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitOrU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitOrU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitXorI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitXorI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitXorI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitXorI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitXorU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitXorU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<BitXorU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &BitXorU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<DivF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &DivF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<DivF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &DivF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<DivI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &DivI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<DivI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &DivI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<DivU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &DivU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<DivU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &DivU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<EqF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &EqF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<EqF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &EqF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<EqI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &EqI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<EqI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &EqI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<EqU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &EqU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<EqU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &EqU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GeF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GeF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GeF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GeF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GeI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GeI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GeI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GeI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GeU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GeU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GeU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GeU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GetItem> for CPU

type Message = PopFromStack<(u32, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GetItem, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GtF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GtF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GtF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GtF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GtI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GtI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GtI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GtI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GtU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GtU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<GtU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &GtU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<HeapAlloc> for CPU

type Message = PopFromStack<StackBatch<u64>>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &HeapAlloc, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<HeapDealloc> for CPU

type Message = PopFromStack<(u32,)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<()>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &HeapDealloc, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<HeapLen> for CPU

type Message = PopFromStack<(u32,)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &HeapLen, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<HeapPush> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &HeapPush, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<HeapReserve> for CPU

type Message = PopFromStack<(u64,)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &HeapReserve, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LeF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LeF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LeF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LeF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LeI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LeI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LeI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LeI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LeU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LeU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LeU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LeU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LtF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LtF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LtF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LtF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LtI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LtI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LtI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LtI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LtU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LtU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<LtU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &LtU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<MulF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &MulF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<MulF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &MulF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<MulI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &MulI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<MulI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &MulI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<MulU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &MulU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<MulU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &MulU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NeF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NeF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NeF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NeF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NeI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NeI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NeI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NeI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NeU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NeU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NeU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NeU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NegF32> for CPU

type Message = PopFromStack<(f32,)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NegF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NegF64> for CPU

type Message = PopFromStack<(f64,)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NegF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NegI32> for CPU

type Message = PopFromStack<(i32,)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NegI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<NegI64> for CPU

type Message = PopFromStack<(i64,)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &NegI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<Not> for CPU

type Message = PopFromStack<(bool,)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &Not, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<Or> for CPU

type Message = PopFromStack<(bool, bool)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &Or, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RemF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RemF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RemF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RemF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RemI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RemI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RemI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RemI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RemU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RemU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RemU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RemU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RolI32> for CPU

type Message = PopFromStack<(i32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RolI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RolI64> for CPU

type Message = PopFromStack<(i64, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RolI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RolU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RolU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RolU64> for CPU

type Message = PopFromStack<(u64, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RolU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RorI32> for CPU

type Message = PopFromStack<(i32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RorI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RorI64> for CPU

type Message = PopFromStack<(i64, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RorI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RorU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RorU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<RorU64> for CPU

type Message = PopFromStack<(u64, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &RorU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<ShlI32> for CPU

type Message = PopFromStack<(i32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &ShlI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<ShlI64> for CPU

type Message = PopFromStack<(i64, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &ShlI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<ShlU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &ShlU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<ShlU64> for CPU

type Message = PopFromStack<(u64, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &ShlU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<ShrI32> for CPU

type Message = PopFromStack<(i32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &ShrI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<ShrI64> for CPU

type Message = PopFromStack<(i64, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &ShrI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<ShrU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &ShrU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<ShrU64> for CPU

type Message = PopFromStack<(u64, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &ShrU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<SubF32> for CPU

type Message = PopFromStack<(f32, f32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &SubF32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<SubF64> for CPU

type Message = PopFromStack<(f64, f64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(f64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &SubF64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<SubI32> for CPU

type Message = PopFromStack<(i32, i32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &SubI32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<SubI64> for CPU

type Message = PopFromStack<(i64, i64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(i64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &SubI64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<SubU32> for CPU

type Message = PopFromStack<(u32, u32)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u32,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &SubU32, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<SubU64> for CPU

type Message = PopFromStack<(u64, u64)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(u64,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &SubU64, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl Execute<Xor> for CPU

type Message = PopFromStack<(bool, bool)>

Input supplied by the runtime, rather than encoded in the instruction.

type Effect = PushToStack<(bool,)>

The successful result.

type Error = Report

The component’s execution error, usually eyre::Report.

fn execute( &mut self, _: &Xor, PopFromStack: Self::Message, ) -> Result<Self::Effect>

Execute a borrowed instruction without consuming its payload.

impl HasInventory for CPU

type Provider = Provider

impl Reset for CPU

fn reset(&mut self)

reset the component state into initial state

impl StackInputCount<HeapAlloc> for CPU

fn input_count(instruction: &HeapAlloc) -> Result<InputCount>