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

crates/core/src/trap.rs

@@ -336,6 +336,10 @@ generate_trap_code! {
     /// desire on the part of the embedder to trap the interpreter rather than
     /// merely fail the growth operation.
     GrowthOperationLimited = 10,
+
+    /// This trap is raised when a WebAssembly operation demanded a memory
+    /// allocation and the host system could not supply the requested amount.
+    OutOfSystemMemory = 11,
 }
 
 impl TrapCode {
@@ -358,6 +362,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/config.rs

@@ -89,8 +89,8 @@ impl Arbitrary<'_> for FuzzSmithConfig {
             custom_page_sizes_enabled: true,
             bulk_memory_enabled: true,
             reference_types_enabled: false, // TODO: re-enable reference-types for differential fuzzing
-            simd_enabled: true,
-            relaxed_simd_enabled: true,
+            simd_enabled: false,
+            relaxed_simd_enabled: false,
             multi_value_enabled: true,
             memory64_enabled: true,
             saturating_float_to_int_enabled: true,

crates/fuzz/src/oracle/wasmi.rs

@@ -175,7 +175,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/op.rs

@@ -144,7 +144,9 @@ impl Display for DisplayOp<&'_ Isa> {
             {indent}#[macro_export]\n\
             {indent}macro_rules! for_each_op {{\n\
             {indent}    ($mac:ident) => {{\n\
-                            {for_each_op_body},\n\
+            {indent}        $mac! {{\n\
+                                {for_each_op_body},\n\
+            {indent}        }}\n\
             {indent}    }};\n\
             {indent}}}\n\
         "

crates/ir2/build/isa.rs

@@ -418,15 +418,15 @@ fn add_control_ops(isa: &mut Isa) {
         Op::from(GenericOp::new(
             Ident::BranchTable,
             [
-                Field::new(Ident::Index, FieldTy::Slot),
                 Field::new(Ident::LenTargets, FieldTy::U32),
+                Field::new(Ident::Index, FieldTy::Slot),
             ],
         )),
         Op::from(GenericOp::new(
             Ident::BranchTableSpan,
             [
-                Field::new(Ident::Index, FieldTy::Slot),
                 Field::new(Ident::LenTargets, FieldTy::U32),
+                Field::new(Ident::Index, FieldTy::Slot),
                 Field::new(Ident::Values, FieldTy::SlotSpan),
                 Field::new(Ident::LenValues, FieldTy::U16),
             ],
@@ -542,8 +542,8 @@ fn add_global_ops(isa: &mut Isa) {
         Op::from(GenericOp::new(
             Ident::GlobalGet,
             [
-                Field::new(Ident::Result, FieldTy::Slot),
                 Field::new(Ident::Global, FieldTy::Global),
+                Field::new(Ident::Result, FieldTy::Slot),
             ],
         )),
         Op::from(GenericOp::new(
@@ -563,8 +563,8 @@ fn add_global_ops(isa: &mut Isa) {
         Op::from(GenericOp::new(
             Ident::GlobalSet64,
             [
-                Field::new(Ident::Global, FieldTy::Global),
                 Field::new(Ident::Value, FieldTy::U64),
+                Field::new(Ident::Global, FieldTy::Global),
             ],
         )),
     ];

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()
-    }
 }