Feature-gate ser, deser, and parser

- introduce features to enable operation modes:
  - default (current way)
  - parser + serialization
  - deserialization

Author: FedorSmirnov89

crates/cli/Cargo.toml

@@ -17,7 +17,8 @@ exclude.workspace = true
 wasmi = { workspace = true, default-features = false, features = [
     "wat",
     "serialization",
-    "deserialization"
+    "deserialization",
+    "parser",
 ] }
 wasmi_wasi = { workspace = true }
 anyhow = "1"

crates/cli/src/args.rs

@@ -6,7 +6,6 @@ use std::{
     path::{Path, PathBuf},
     str::FromStr,
 };
-use wasmi::serialization::RequiredFeatures;
 use wasmi_wasi::{ambient_authority, Dir, TcpListener, WasiCtx, WasiCtxBuilder};
 
 #[derive(Parser, Debug)]
@@ -24,33 +23,6 @@ pub struct SerializeArgs {
     /// The output file for the serialized module (or '-' for stdout).
     #[clap(long, value_name = "OUTPUT", value_hint = clap::ValueHint::FilePath)]
     pub output: Option<PathBuf>,
-    /// Enable the simd feature.
-    #[clap(long)]
-    pub simd: bool,
-    /// Enable the bulk-memory feature.
-    #[clap(long = "bulk-memory")]
-    pub bulk_memory: bool,
-    /// Enable the reference-types feature.
-    #[clap(long = "reference-types")]
-    pub reference_types: bool,
-    /// Enable the tail-calls feature.
-    #[clap(long = "tail-calls")]
-    pub tail_calls: bool,
-    /// Enable the function-references feature.
-    #[clap(long = "function-references")]
-    pub function_references: bool,
-}
-
-impl SerializeArgs {
-    pub fn to_required_features(&self) -> RequiredFeatures {
-        RequiredFeatures {
-            simd: self.simd,
-            bulk_memory: self.bulk_memory,
-            reference_types: self.reference_types,
-            tail_calls: self.tail_calls,
-            function_references: self.function_references,
-        }
-    }
 }
 
 #[derive(Debug, Clone)]

crates/cli/src/serialize.rs

@@ -9,8 +9,6 @@ use wasmi::{
 use crate::args::SerializeArgs;
 
 pub(super) fn serialize(args: SerializeArgs) -> Result<()> {
-    let required_features = args.to_required_features();
-    println!("req feautures: {required_features:?}");
     let engine = wasmi::Engine::default();
 
     let wasm_file = args.module;
@@ -20,16 +18,15 @@ pub(super) fn serialize(args: SerializeArgs) -> Result<()> {
         anyhow!("failed to parse and validate Wasm module {wasm_file:?}: {error}")
     })?;
 
-    let bytes = serialize_module(&module, &required_features)
+    let bytes = serialize_module(&module, &engine)
         .map_err(|error| anyhow!("failed to serialize Wasm module {wasm_file:?}: {error}"))?;
 
     let output = args
         .output
         .unwrap_or_else(|| wasm_file.with_extension("wasm.ser"));
 
-    let other_engine = Engine::default();
-    let _deser_module =
-        deserialize_module(&other_engine, &bytes).expect("failed to deserialize back");
+    let (deser_module, other_engine) =
+        deserialize_module(&bytes).expect("failed to deserialize back");
 
     if output == PathBuf::from("-") {
         std::io::stdout().write_all(&bytes)?;
@@ -38,9 +35,8 @@ pub(super) fn serialize(args: SerializeArgs) -> Result<()> {
     }
 
     let read_bytes = fs::read(&output).expect("failed to read bytes");
-    let other_engine = Engine::default();
-    let _deser_module =
-        deserialize_module(&other_engine, &read_bytes).expect("failed to deserialize back");
+    let (deser_module, other_engine) =
+        deserialize_module(&read_bytes).expect("failed to deserialize back");
 
     println!("deser from read okay");
 

crates/wasmi/Cargo.toml

@@ -17,7 +17,10 @@ exclude = ["benches/wat", "benches/wasm", "tests/spec/testsuite", "**.wast"]
 wasmi_core = { workspace = true }
 wasmi_collections = { workspace = true }
 wasmi_ir = { workspace = true }
-wasmparser = { workspace = true, features = ["validate", "features"] }
+wasmparser = { workspace = true, features = [
+    "validate",
+    "features",
+], optional = true }
 wat = { workspace = true, optional = true }
 spin = { version = "0.9", default-features = false, features = [
     "mutex",
@@ -40,7 +43,7 @@ assert_matches = "1.5"
 criterion = { version = "0.5", default-features = false }
 
 [features]
-default = ["std", "wat"]
+default = ["std", "wat", "parser"]
 std = [
     "wasmi_core/std",
     "wasmi_collections/std",
@@ -59,6 +62,10 @@ prefer-btree-collections = [
 wat = ["dep:wat", "std"]
 simd = ["wasmi_core/simd", "wasmi_ir/simd", "wasmparser/simd"]
 
+# New feature flags for parser and translation
+parser = ["dep:wasmparser", "wasmparser/validate", "wasmparser/features"]
+translation = ["parser"]                                                  # Translation implies parser
+
 serialization = [
     "dep:serde",
     "serde/derive",

crates/wasmi/src/engine/code_map.rs

@@ -5,25 +5,33 @@
 //! This is the data structure specialized to handle compiled
 //! register machine based bytecode functions.
 
-use super::{FuncTranslationDriver, FuncTranslator, TranslationError, ValidatingFuncTranslator};
 use crate::{
     collections::arena::{Arena, ArenaIndex},
-    core::{Fuel, FuelCostsProvider, FuelError, UntypedVal},
-    engine::{utils::unreachable_unchecked, ResumableOutOfFuelError},
+    core::{Fuel, UntypedVal},
+    engine::utils::unreachable_unchecked,
     ir::{index::InternalFunc, Instruction},
-    module::{FuncIdx, ModuleHeader},
-    Config,
-    Error,
+    Config, Error,
 };
 use alloc::boxed::Box;
 use core::{
-    fmt,
-    mem::{self, MaybeUninit},
+    mem::{self},
     ops::{self, Range},
     pin::Pin,
     slice,
 };
 use spin::Mutex;
+
+#[cfg(feature = "parser")]
+use super::{FuncTranslationDriver, FuncTranslator, TranslationError, ValidatingFuncTranslator};
+#[cfg(feature = "parser")]
+use crate::{
+    core::{FuelCostsProvider, FuelError},
+    engine::ResumableOutOfFuelError,
+    module::{FuncIdx, ModuleHeader},
+};
+#[cfg(feature = "parser")]
+use core::{fmt, mem::MaybeUninit};
+#[cfg(feature = "parser")]
 use wasmparser::{FuncToValidate, ValidatorResources, WasmFeatures};
 
 /// A reference to a compiled function stored in the [`CodeMap`] of an [`Engine`](crate::Engine).
@@ -71,6 +79,7 @@ impl ArenaIndex for EngineFunc {
 #[derive(Debug)]
 pub struct CodeMap {
     funcs: Mutex<Arena<EngineFunc, FuncEntity>>,
+    #[cfg(feature = "parser")]
     features: WasmFeatures,
 }
 
@@ -213,6 +222,7 @@ impl CodeMap {
     pub fn new(config: &Config) -> Self {
         Self {
             funcs: Mutex::new(Arena::default()),
+            #[cfg(feature = "parser")]
             features: config.wasm_features(),
         }
     }
@@ -244,32 +254,6 @@ impl CodeMap {
         func.init_compiled(entity);
     }
 
-    /// Initializes the [`EngineFunc`] for lazy translation.
-    ///
-    /// # Panics
-    ///
-    /// - If `func` is an invalid [`EngineFunc`] reference for this [`CodeMap`].
-    /// - If `func` refers to an already initialized [`EngineFunc`].
-    pub fn init_func_as_uncompiled(
-        &self,
-        func: EngineFunc,
-        func_idx: FuncIdx,
-        bytes: &[u8],
-        module: &ModuleHeader,
-        func_to_validate: Option<FuncToValidate<ValidatorResources>>,
-    ) {
-        let mut funcs = self.funcs.lock();
-        let Some(func) = funcs.get_mut(func) else {
-            panic!("encountered invalid internal function: {func:?}")
-        };
-        func.init_uncompiled(UncompiledFuncEntity::new(
-            func_idx,
-            bytes,
-            module.clone(),
-            func_to_validate,
-        ));
-    }
-
     /// Returns the [`FuncEntity`] of the [`EngineFunc`].
     ///
     /// # Errors
@@ -285,26 +269,12 @@ impl CodeMap {
     ) -> Result<CompiledFuncRef<'a>, Error> {
         match self.get_compiled(func) {
             Some(cref) => Ok(cref),
+            #[cfg(feature = "parser")]
             None => self.compile_or_wait(fuel, func),
-        }
-    }
-
-    /// Compile `func` or wait for result if another process already started compilation.
-    ///
-    /// # Errors
-    ///
-    /// - If translation or Wasm validation of `func` failed.
-    /// - If `ctx` ran out of fuel in case fuel consumption is enabled.
-    #[cold]
-    #[inline]
-    fn compile_or_wait<'a>(
-        &'a self,
-        fuel: Option<&mut Fuel>,
-        func: EngineFunc,
-    ) -> Result<CompiledFuncRef<'a>, Error> {
-        match self.get_uncompiled(func) {
-            Some(entity) => self.compile(fuel, func, entity),
-            None => self.wait_for_compilation(func),
+            #[cfg(not(feature = "parser"))]
+            None => Err(Error::new(
+                "Function not compiled - parser feature required",
+            )),
         }
     }
 
@@ -327,6 +297,7 @@ impl CodeMap {
     /// Returns the [`UncompiledFuncEntity`] of `func` if possible, otherwise returns `None`.
     ///
     /// After this operation `func` will be in [`FuncEntity::Compiling`] state.
+    #[cfg(feature = "parser")]
     #[inline]
     fn get_uncompiled(&self, func: EngineFunc) -> Option<UncompiledFuncEntity> {
         let mut funcs = self.funcs.lock();
@@ -353,6 +324,54 @@ impl CodeMap {
         //         returned `CompiledFuncRef` only references `Pin`ned data.
         unsafe { mem::transmute::<CompiledFuncRef<'_>, CompiledFuncRef<'a>>(cref) }
     }
+}
+
+#[cfg(feature = "parser")]
+impl CodeMap {
+    /// Compile `func` or wait for result if another process already started compilation.
+    ///
+    /// # Errors
+    ///
+    /// - If translation or Wasm validation of `func` failed.
+    /// - If `ctx` ran out of fuel in case fuel consumption is enabled.
+    #[cold]
+    #[inline]
+    fn compile_or_wait<'a>(
+        &'a self,
+        fuel: Option<&mut Fuel>,
+        func: EngineFunc,
+    ) -> Result<CompiledFuncRef<'a>, Error> {
+        match self.get_uncompiled(func) {
+            Some(entity) => self.compile(fuel, func, entity),
+            None => self.wait_for_compilation(func),
+        }
+    }
+
+    /// Initializes the [`EngineFunc`] for lazy translation.
+    ///
+    /// # Panics
+    ///
+    /// - If `func` is an invalid [`EngineFunc`] reference for this [`CodeMap`].
+    /// - If `func` refers to an already initialized [`EngineFunc`].
+    pub fn init_func_as_uncompiled(
+        &self,
+        func: EngineFunc,
+        func_idx: FuncIdx,
+        bytes: &[u8],
+        module: &ModuleHeader,
+        func_to_validate: Option<FuncToValidate<ValidatorResources>>,
+    ) {
+        let mut funcs = self.funcs.lock();
+        let Some(func) = funcs.get_mut(func) else {
+            panic!("encountered invalid internal function: {func:?}")
+        };
+        func.init_uncompiled(UncompiledFuncEntity::new(
+            func_idx,
+            bytes,
+            module.clone(),
+            func_to_validate,
+        ));
+    }
 
     /// Compile and validate the [`UncompiledFuncEntity`] identified by `func`.
     ///
@@ -426,6 +445,7 @@ impl CodeMap {
 enum FuncEntity {
     /// The function entity has not yet been initialized.
     Uninit,
+    #[cfg(feature = "parser")]
     /// An internal function that has not yet been compiled.
     Uncompiled(UncompiledFuncEntity),
     /// The function entity is currently compiling.
@@ -461,6 +481,7 @@ impl FuncEntity {
     ///
     /// If `func` has already been initialized.
     #[inline]
+    #[cfg(feature = "parser")]
     pub fn init_uncompiled(&mut self, entity: UncompiledFuncEntity) {
         assert!(matches!(self, Self::Uninit));
         *self = Self::Uncompiled(entity);
@@ -483,6 +504,7 @@ impl FuncEntity {
     ///
     /// Returns a proper error if the [`FuncEntity`] is not uncompiled.
     #[inline]
+    #[cfg(feature = "parser")]
     pub fn get_uncompiled(&mut self) -> Option<UncompiledFuncEntity> {
         match self {
             Self::Uncompiled(_) => {}
@@ -535,6 +557,7 @@ impl FuncEntity {
 #[repr(transparent)]
 pub struct TypeIndex(u32);
 
+#[cfg(feature = "parser")]
 /// An internal uncompiled function entity.
 pub struct UncompiledFuncEntity {
     /// The index of the function within the Wasm module.
@@ -552,6 +575,7 @@ pub struct UncompiledFuncEntity {
     validation: Option<(TypeIndex, ValidatorResources)>,
 }
 
+#[cfg(feature = "parser")]
 impl UncompiledFuncEntity {
     /// Creates a new [`UncompiledFuncEntity`].
     pub fn new(
@@ -676,6 +700,7 @@ impl UncompiledFuncEntity {
     }
 }
 
+#[cfg(feature = "parser")]
 impl fmt::Debug for UncompiledFuncEntity {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("UncompiledFuncEntity")