Integrate Wasmi IR 3.0 into wasmi

Cargo.toml

@@ -61,3 +61,6 @@ codegen-units = 1
 [profile.miri]
 inherits = "dev"
 debug-assertions = false
+
+[profile.release]
+codegen-units = 1 # required to avoid stackoverflows when _not_ using `wasmi`'s `portable-dispatch` feature

crates/core/src/trap.rs

@@ -263,18 +263,22 @@ macro_rules! generate_trap_code {
     };
 }
 generate_trap_code! {
+    // Note: we deliberately do _not_ assign the zero value so that it can be used as success state
+    //       in `Result<(), TrapCode>` or `Control<(), TrapCode>` as the compiler can then generate
+    //       slightly better code.
+
     /// Wasm code executed `unreachable` opcode.
     ///
     /// This indicates that unreachable Wasm code was actually reached.
     /// This opcode have a similar purpose as `ud2` in x86.
-    UnreachableCodeReached = 0,
+    UnreachableCodeReached = 1,
 
     /// Attempt to load or store at the address which
     /// lies outside of bounds of the memory.
     ///
     /// Since addresses are interpreted as unsigned integers, out of bounds access
     /// can't happen with negative addresses (i.e. they will always wrap).
-    MemoryOutOfBounds = 1,
+    MemoryOutOfBounds = 2,
 
     /// Attempt to access table element at index which
     /// lies outside of bounds.
@@ -284,58 +288,62 @@ generate_trap_code! {
     ///
     /// Since indexes are interpreted as unsigned integers, out of bounds access
     /// can't happen with negative indexes (i.e. they will always wrap).
-    TableOutOfBounds = 2,
+    TableOutOfBounds = 3,
 
     /// Indicates that a `call_indirect` instruction called a function at
     /// an uninitialized (i.e. `null`) table index.
-    IndirectCallToNull = 3,
+    IndirectCallToNull = 4,
 
     /// Attempt to divide by zero.
     ///
     /// This trap typically can happen if `div` or `rem` is executed with
     /// zero as divider.
-    IntegerDivisionByZero = 4,
+    IntegerDivisionByZero = 5,
 
     /// An integer arithmetic operation caused an overflow.
     ///
     /// This can happen when trying to do signed division (or get the remainder)
     /// -2<sup>N-1</sup> over -1. This is because the result +2<sup>N-1</sup>
     /// isn't representable as a N-bit signed integer.
-    IntegerOverflow = 5,
+    IntegerOverflow = 6,
 
     /// Attempted to make an invalid conversion to an integer type.
     ///
     /// This can for example happen when trying to truncate NaNs,
     /// infinity, or value for which the result is out of range into an integer.
-    BadConversionToInteger = 6,
+    BadConversionToInteger = 7,
 
     /// Stack overflow.
     ///
     /// This is likely caused by some infinite or very deep recursion.
     /// Extensive inlining might also be the cause of stack overflow.
-    StackOverflow = 7,
+    StackOverflow = 8,
 
     /// Attempt to invoke a function with mismatching signature.
     ///
     /// This can happen with indirect calls as they always
     /// specify the expected signature of function. If an indirect call is executed
     /// with an index that points to a function with signature different of what is
     /// expected by this indirect call, this trap is raised.
-    BadSignature = 8,
+    BadSignature = 9,
 
     /// This trap is raised when a WebAssembly execution ran out of fuel.
     ///
     /// The Wasmi execution engine can be configured to instrument its
     /// internal bytecode so that fuel is consumed for each executed instruction.
     /// This is useful to deterministically halt or yield a WebAssembly execution.
-    OutOfFuel = 9,
+    OutOfFuel = 10,
 
     /// This trap is raised when a growth operation was attempted and an
     /// installed `wasmi::ResourceLimiter` returned `Err(...)` from the
     /// associated `table_growing` or `memory_growing` method, indicating a
     /// desire on the part of the embedder to trap the interpreter rather than
     /// merely fail the growth operation.
-    GrowthOperationLimited = 10,
+    GrowthOperationLimited = 11,
+
+    /// This trap is raised when a WebAssembly operation demanded a memory
+    /// allocation and the host system could not supply the requested amount.
+    OutOfSystemMemory = 12,
 }
 
 impl TrapCode {
@@ -358,6 +366,7 @@ impl TrapCode {
             Self::BadSignature => "indirect call type mismatch",
             Self::OutOfFuel => "all fuel consumed by WebAssembly",
             Self::GrowthOperationLimited => "growth operation limited",
+            Self::OutOfSystemMemory => "out of system memory",
         }
     }
 }

crates/core/src/value.rs

@@ -95,7 +95,7 @@ pub trait Integer: Sized + Unsigned {
     /// Signed shift-right `self` by `other`.
     fn shr_s(lhs: Self, rhs: Self) -> Self;
     /// Unsigned shift-right `self` by `other`.
-    fn shr_u(lhs: Self, rhs: Self) -> Self;
+    fn shr_u(lhs: Self::Uint, rhs: Self::Uint) -> Self::Uint;
     /// Get left bit rotation result.
     fn rotl(lhs: Self, rhs: Self) -> Self;
     /// Get right bit rotation result.
@@ -130,25 +130,14 @@ pub trait Integer: Sized + Unsigned {
 pub trait Unsigned {
     /// The unsigned type.
     type Uint;
-
-    /// Converts `self` losslessly to the unsigned type.
-    fn to_unsigned(self) -> Self::Uint;
 }
 
 impl Unsigned for i32 {
     type Uint = u32;
-    #[inline]
-    fn to_unsigned(self) -> Self::Uint {
-        self as _
-    }
 }
 
 impl Unsigned for i64 {
     type Uint = u64;
-    #[inline]
-    fn to_unsigned(self) -> Self::Uint {
-        self as _
-    }
 }
 
 /// Float-point value.
@@ -270,8 +259,8 @@ macro_rules! impl_integer {
                 lhs.wrapping_shr(rhs as u32)
             }
             #[inline]
-            fn shr_u(lhs: Self, rhs: Self) -> Self {
-                lhs.to_unsigned().wrapping_shr(rhs as u32) as _
+            fn shr_u(lhs: Self::Uint, rhs: Self::Uint) -> Self::Uint {
+                lhs.wrapping_shr(rhs as u32) as _
             }
             #[inline]
             fn rotl(lhs: Self, rhs: Self) -> Self {

crates/core/src/wasm.rs

@@ -96,8 +96,8 @@ impl_untyped_val! {
     fn i64_shl(lhs: i64, rhs: i64) -> i64 = Integer::shl;
     fn i32_shr_s(lhs: i32, rhs: i32) -> i32 = Integer::shr_s;
     fn i64_shr_s(lhs: i64, rhs: i64) -> i64 = Integer::shr_s;
-    fn i32_shr_u(lhs: i32, rhs: i32) -> i32 = Integer::shr_u;
-    fn i64_shr_u(lhs: i64, rhs: i64) -> i64 = Integer::shr_u;
+    fn i32_shr_u(lhs: u32, rhs: u32) -> u32 = <i32 as Integer>::shr_u;
+    fn i64_shr_u(lhs: u64, rhs: u64) -> u64 = <i64 as Integer>::shr_u;
     fn i32_rotl(lhs: i32, rhs: i32) -> i32 = Integer::rotl;
     fn i64_rotl(lhs: i64, rhs: i64) -> i64 = Integer::rotl;
     fn i32_rotr(lhs: i32, rhs: i32) -> i32 = Integer::rotr;

crates/fuzz/Cargo.toml

@@ -15,7 +15,7 @@ exclude.workspace = true
 publish = false
 
 [dependencies]
-wasmi = { workspace = true, features = ["std", "simd"] }
+wasmi = { workspace = true, features = ["std", "simd", "portable-dispatch", "extra-checks"] }
 wasmtime = { workspace = true, optional = true, features = [
     "cranelift",
     "runtime",

crates/fuzz/src/oracle/wasmi.rs

@@ -176,7 +176,9 @@ impl From<wasmi::Error> for FuzzError {
             | TrapCode::BadConversionToInteger => crate::TrapCode::BadConversionToInteger,
             | TrapCode::StackOverflow => crate::TrapCode::StackOverflow,
             | TrapCode::BadSignature => crate::TrapCode::BadSignature,
-            | TrapCode::OutOfFuel | TrapCode::GrowthOperationLimited => return FuzzError::Other,
+            | TrapCode::OutOfFuel
+            | TrapCode::GrowthOperationLimited
+            | TrapCode::OutOfSystemMemory => return FuzzError::Other,
         };
         FuzzError::Trap(trap_code)
     }

crates/ir2/build/display/decode.rs

@@ -9,7 +9,6 @@ use crate::build::{
         BinaryOp,
         CmpBranchOp,
         CmpSelectOp,
-        FieldTy,
         GenericOp,
         LaneWidth,
         LoadOp,
@@ -62,8 +61,8 @@ impl Display for DisplayDecode<&'_ Isa> {
 impl Display for DisplayDecode<&'_ UnaryOp> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let camel_ident = DisplayIdent::camel(self.value);
-        let slot_ty = FieldTy::Slot;
-        writeln!(f, "pub type {camel_ident} = UnaryOp<{slot_ty}>;")
+        let value_ty = self.value.value_field().ty;
+        writeln!(f, "pub type {camel_ident} = UnaryOp<{value_ty}>;")
     }
 }
 

crates/wasmi/Cargo.toml

@@ -21,7 +21,7 @@ exclude = [
 [dependencies]
 wasmi_core = { workspace = true }
 wasmi_collections = { workspace = true }
-wasmi_ir = { workspace = true }
+wasmi_ir2 = { workspace = true }
 wasmparser = { workspace = true, features = ["validate", "features"] }
 wat = { workspace = true, optional = true }
 spin = { version = "0.9", default-features = false, features = [
@@ -51,7 +51,14 @@ prefer-btree-collections = [
     "wasmparser/prefer-btree-collections",
 ]
 wat = ["dep:wat", "std"]
-simd = ["wasmi_core/simd", "wasmi_ir/simd", "wasmparser/simd"]
+simd = ["wasmi_core/simd", "wasmi_ir2/simd", "wasmparser/simd"]
+
+# Enables a portable dispatch scheme that avoids tail-call reliance.
+# Recommended for targets without stable or guaranteed tail-call support.
+portable-dispatch = []
+# Enables an indirect dispatch scheme using op-codes instead of
+# embedded function pointers for more compact bytecode.
+indirect-dispatch = []
 
 # Enables extra checks performed during Wasmi bytecode execution.
 #

crates/wasmi/src/engine/code_map.rs

@@ -8,10 +8,10 @@
 use super::{FuncTranslationDriver, FuncTranslator, TranslationError, ValidatingFuncTranslator};
 use crate::{
     collections::arena::{Arena, ArenaIndex},
-    core::{Fuel, FuelCostsProvider, UntypedVal},
+    core::{Fuel, FuelCostsProvider},
     engine::{utils::unreachable_unchecked, ResumableOutOfFuelError},
     errors::FuelError,
-    ir::{index::InternalFunc, Op},
+    ir::index::InternalFunc,
     module::{FuncIdx, ModuleHeader},
     Config,
     Error,
@@ -28,6 +28,9 @@ use core::{
 use spin::Mutex;
 use wasmparser::{FuncToValidate, ValidatorResources, WasmFeatures};
 
+#[cfg(doc)]
+use crate::ir::Op;
+
 /// A reference to a compiled function stored in the [`CodeMap`] of an [`Engine`](crate::Engine).
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct EngineFunc(u32);
@@ -785,9 +788,7 @@ impl<'a> From<&'a [u8]> for SmallByteSlice {
 #[derive(Debug)]
 pub struct CompiledFuncEntity {
     /// The sequence of [`Op`] of the [`CompiledFuncEntity`].
-    instrs: Pin<Box<[Op]>>,
-    /// The constant values local to the [`EngineFunc`].
-    consts: Pin<Box<[UntypedVal]>>,
+    ops: Pin<Box<[u8]>>,
     /// The number of stack slots used by the [`EngineFunc`] in total.
     ///
     /// # Note
@@ -802,31 +803,25 @@ impl CompiledFuncEntity {
     ///
     /// # Panics
     ///
-    /// - If `instrs` is empty.
-    /// - If `instrs` contains more than `i32::MAX` instructions.
-    pub fn new<I, C>(len_stack_slots: u16, instrs: I, consts: C) -> Self
-    where
-        I: IntoIterator<Item = Op>,
-        C: IntoIterator<Item = UntypedVal>,
-    {
-        let instrs: Pin<Box<[Op]>> = Pin::new(instrs.into_iter().collect());
-        let consts: Pin<Box<[UntypedVal]>> = Pin::new(consts.into_iter().collect());
+    /// - If `ops` is empty.
+    /// - If `ops` contains more than `i32::MAX` encoded bytes.
+    pub fn new(len_stack_slots: u16, ops: &[u8]) -> Self {
+        let ops: Pin<Box<[u8]>> = Pin::new(ops.into());
         assert!(
-            !instrs.is_empty(),
+            !ops.is_empty(),
             "compiled functions must have at least one instruction"
         );
         assert!(
             // Generally, Wasmi has no issues with more than `i32::MAX` instructions.
             // However, Wasmi's branch instructions can jump across at most `i32::MAX`
             // forwards or `i32::MIN` instructions backwards and thus having more than
             // `i32::MAX` instructions might introduce problems.
-            instrs.len() <= i32::MAX as usize,
+            ops.len() <= i32::MAX as usize,
             "compiled function has too many instructions: {}",
-            instrs.len(),
+            ops.len(),
         );
         Self {
-            instrs,
-            consts,
+            ops,
             len_stack_slots,
         }
     }
@@ -835,10 +830,8 @@ impl CompiledFuncEntity {
 /// A shared reference to the data of a [`EngineFunc`].
 #[derive(Debug, Copy, Clone)]
 pub struct CompiledFuncRef<'a> {
-    /// The sequence of [`Op`] of the [`CompiledFuncEntity`].
-    instrs: Pin<&'a [Op]>,
-    /// The constant values local to the [`EngineFunc`].
-    consts: Pin<&'a [UntypedVal]>,
+    /// The sequence of encoded [`Op`]s of the [`CompiledFuncEntity`].
+    ops: Pin<&'a [u8]>,
     /// The number of stack slots used by the [`EngineFunc`] in total.
     len_stack_slots: u16,
 }
@@ -847,29 +840,22 @@ impl<'a> From<&'a CompiledFuncEntity> for CompiledFuncRef<'a> {
     #[inline]
     fn from(func: &'a CompiledFuncEntity) -> Self {
         Self {
-            instrs: func.instrs.as_ref(),
-            consts: func.consts.as_ref(),
+            ops: func.ops.as_ref(),
             len_stack_slots: func.len_stack_slots,
         }
     }
 }
 
 impl<'a> CompiledFuncRef<'a> {
-    /// Returns the sequence of [`Op`] of the [`EngineFunc`].
+    /// Returns the sequence of encoded [`Op`]s of the [`EngineFunc`].
     #[inline]
-    pub fn instrs(&self) -> &'a [Op] {
-        self.instrs.get_ref()
+    pub fn ops(&self) -> &'a [u8] {
+        self.ops.get_ref()
     }
 
     /// Returns the number of stack slots used by the [`EngineFunc`].
     #[inline]
     pub fn len_stack_slots(&self) -> u16 {
         self.len_stack_slots
     }
-
-    /// Returns the function local constant values of the [`EngineFunc`].
-    #[inline]
-    pub fn consts(&self) -> &'a [UntypedVal] {
-        self.consts.get_ref()
-    }
 }