Rebase on current master of upstream

Author: FedorSmirnov89

crates/ir/src/enum.rs

@@ -40,7 +40,7 @@ macro_rules! define_enum {
         /// The documentation of each [`Instruction`] describes its encoding in the
         /// `#Encoding` section of its documentation if it requires more than a single
         /// instruction for its encoding.
-        #[derive(Debug)]
+        #[derive(Debug, PartialEq, Eq)]
         #[cfg_attr(feature = "serialization", derive(serde::Serialize))]
         #[cfg_attr(feature = "deserialization", derive(serde::Deserialize))]
         #[non_exhaustive]

crates/wasmi/src/engine/code_map.rs

@@ -25,11 +25,7 @@ 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},
-};
+use crate::module::{FuncIdx, ModuleHeader};
 #[cfg(feature = "parser")]
 use core::{fmt, mem::MaybeUninit};
 #[cfg(feature = "parser")]

crates/wasmi/src/engine/config.rs

@@ -82,68 +82,6 @@ impl Config {
         features
     }
 
-    /// Sets the maximum recursion depth of the [`Engine`]'s stack during execution.
-    ///
-    /// # Note
-    ///
-    /// An execution traps if it exceeds this limits.
-    ///
-    /// [`Engine`]: [`crate::Engine`]
-    pub fn set_max_recursion_depth(&mut self, value: usize) -> &mut Self {
-        self.stack.set_max_recursion_depth(value);
-        self
-    }
-
-    /// Sets the minimum (or initial) height of the [`Engine`]'s value stack in bytes.
-    ///
-    /// # Note
-    ///
-    /// - Lower initial heights may improve memory consumption.
-    /// - Higher initial heights may improve cold start times.
-    ///
-    /// # Panics
-    ///
-    /// If `value` is greater than the current maximum height of the value stack.
-    ///
-    /// [`Engine`]: [`crate::Engine`]
-    pub fn set_min_stack_height(&mut self, value: usize) -> &mut Self {
-        if self.stack.set_min_stack_height(value).is_err() {
-            let max = self.stack.max_stack_height();
-            panic!("minimum stack height exceeds maximum: min={value}, max={max}");
-        }
-        self
-    }
-
-    /// Sets the maximum height of the [`Engine`]'s value stack in bytes.
-    ///
-    /// # Note
-    ///
-    /// An execution traps if it exceeds this limits.
-    ///
-    /// # Panics
-    ///
-    /// If `value` is less than the current minimum height of the value stack.
-    ///
-    /// [`Engine`]: [`crate::Engine`]
-    pub fn set_max_stack_height(&mut self, value: usize) -> &mut Self {
-        if self.stack.set_max_stack_height(value).is_err() {
-            let max = self.stack.min_stack_height();
-            panic!("maximum stack height is lower than minimum: min={value}, max={max}");
-        }
-        self
-    }
-
-    /// Sets the maximum number of cached stacks for reuse for the [`Config`].
-    ///
-    /// # Note
-    ///
-    /// - A higher value may improve execution performance.
-    /// - A lower value may improve memory consumption.
-    pub fn set_max_cached_stacks(&mut self, value: usize) -> &mut Self {
-        self.stack.set_max_cached_stacks(value);
-        self
-    }
-
     /// Enable or disable the [`mutable-global`] Wasm proposal for the [`Config`].
     ///
     /// # Note
@@ -326,30 +264,66 @@ impl Config {
 }
 
 impl Config {
-    /// Sets the [`StackLimits`] for the [`Config`].
-    pub fn set_stack_limits(&mut self, stack_limits: StackLimits) -> &mut Self {
-        self.stack_limits = stack_limits;
+    /// Sets the maximum recursion depth of the [`Engine`]'s stack during execution.
+    ///
+    /// # Note
+    ///
+    /// An execution traps if it exceeds this limits.
+    ///
+    /// [`Engine`]: [`crate::Engine`]
+    pub fn set_max_recursion_depth(&mut self, value: usize) -> &mut Self {
+        self.stack.set_max_recursion_depth(value);
         self
     }
 
-    /// Returns the [`StackLimits`] of the [`Config`].
-    pub(super) fn stack_limits(&self) -> StackLimits {
-        self.stack_limits
+    /// Sets the minimum (or initial) height of the [`Engine`]'s value stack in bytes.
+    ///
+    /// # Note
+    ///
+    /// - Lower initial heights may improve memory consumption.
+    /// - Higher initial heights may improve cold start times.
+    ///
+    /// # Panics
+    ///
+    /// If `value` is greater than the current maximum height of the value stack.
+    ///
+    /// [`Engine`]: [`crate::Engine`]
+    pub fn set_min_stack_height(&mut self, value: usize) -> &mut Self {
+        if self.stack.set_min_stack_height(value).is_err() {
+            let max = self.stack.max_stack_height();
+            panic!("minimum stack height exceeds maximum: min={value}, max={max}");
+        }
+        self
     }
 
-    /// Sets the maximum amount of cached stacks for reuse for the [`Config`].
+    /// Sets the maximum height of the [`Engine`]'s value stack in bytes.
     ///
     /// # Note
     ///
-    /// Defaults to 2.
-    pub fn set_cached_stacks(&mut self, amount: usize) -> &mut Self {
-        self.cached_stacks = amount;
+    /// An execution traps if it exceeds this limits.
+    ///
+    /// # Panics
+    ///
+    /// If `value` is less than the current minimum height of the value stack.
+    ///
+    /// [`Engine`]: [`crate::Engine`]
+    pub fn set_max_stack_height(&mut self, value: usize) -> &mut Self {
+        if self.stack.set_max_stack_height(value).is_err() {
+            let max = self.stack.min_stack_height();
+            panic!("maximum stack height is lower than minimum: min={value}, max={max}");
+        }
         self
     }
 
-    /// Returns the maximum amount of cached stacks for reuse of the [`Config`].
-    pub(super) fn cached_stacks(&self) -> usize {
-        self.cached_stacks
+    /// Sets the maximum number of cached stacks for reuse for the [`Config`].
+    ///
+    /// # Note
+    ///
+    /// - A higher value may improve execution performance.
+    /// - A lower value may improve memory consumption.
+    pub fn set_max_cached_stacks(&mut self, value: usize) -> &mut Self {
+        self.stack.set_max_cached_stacks(value);
+        self
     }
 
     /// Configures whether Wasmi will consume fuel during execution to either halt execution as desired.

crates/wasmi/src/engine/mod.rs

@@ -14,9 +14,6 @@ mod block_type;
 #[cfg(feature = "parser")]
 mod translator;
 
-#[cfg(all(test, feature = "parser"))]
-mod tests;
-
 #[cfg(feature = "parser")]
 pub(crate) use self::translator::TranslationError;
 

crates/wasmi/src/error.rs

@@ -2,7 +2,7 @@ use super::errors::{
     EnforcedLimitsError, FuncError, GlobalError, InstantiationError, IrError, LinkerError,
 };
 use crate::{
-    engine::{ResumableError, ResumableHostTrapError, ResumableOutOfFuelError, TranslationError},
+    engine::{ResumableError, ResumableHostTrapError, ResumableOutOfFuelError},
     module::ReadError,
     TrapCode,
 };

crates/wasmi/src/module/init_expr.rs

@@ -251,48 +251,6 @@ impl ConstExprStack {
     }
 }
 
-/// Stack to translate [`ConstExpr`].
-#[derive(Debug, Default)]
-pub struct ConstExprStack {
-    /// The top-most [`Op`] on the stack.
-    ///
-    /// # Note
-    /// This is an optimization so that the [`ConstExprStack`] does not
-    /// require heap allocations for the common case where only a single
-    /// stack slot is needed.
-    top: Option<Op>,
-    /// The remaining ops on the stack.
-    ops: Vec<Op>,
-}
-
-impl ConstExprStack {
-    /// Returns `true` if [`ConstExprStack`] is empty.
-    pub fn is_empty(&self) -> bool {
-        self.ops.is_empty()
-    }
-
-    /// Pushes an [`Op`] to the [`ConstExprStack`].
-    pub fn push(&mut self, op: Op) {
-        let old_top = self.top.replace(op);
-        if let Some(old_top) = old_top {
-            self.ops.push(old_top);
-        }
-    }
-
-    /// Pops the top-most [`Op`] from the [`ConstExprStack`] if any.
-    pub fn pop(&mut self) -> Option<Op> {
-        let new_top = self.ops.pop();
-        mem::replace(&mut self.top, new_top)
-    }
-
-    /// Pops the 2 top-most [`Op`]s from the [`ConstExprStack`] if any.
-    pub fn pop2(&mut self) -> Option<(Op, Op)> {
-        let rhs = self.pop()?;
-        let lhs = self.pop()?;
-        Some((lhs, rhs))
-    }
-}
-
 #[cfg(feature = "parser")]
 impl ConstExpr {
     /// Creates a new [`ConstExpr`] from the given Wasm [`ConstExpr`].

crates/wasmi/src/module/mod.rs

@@ -214,32 +214,6 @@ impl ModuleImports {
 
 #[cfg(feature = "parser")]
 impl Module {
-    /// Creates a new Wasm [`Module`] from the given Wasm bytecode stream.
-    ///
-    /// # Note
-    ///
-    /// This parses, validates and translates the Wasm bytecode yielded by `stream`.
-    ///
-    /// # Errors
-    ///
-    /// - If the Wasm bytecode is malformed or fails to validate.
-    /// - If the Wasm bytecode violates restrictions
-    ///   set in the [`Config`] used by the `engine`.
-    /// - If Wasmi cannot translate the Wasm bytecode.
-    ///
-    /// [`Config`]: crate::Config
-    #[deprecated(
-        since = "0.48.0",
-        note = "\
-            This API has been deprecated because it is inefficient and unserused. \
-            Please use the `Module::new` API instead if possible. \
-            If you have an urgent need for this API, please tell us at: https://github.com/wasmi-labs/wasmi \
-        "
-    )]
-    pub fn new_streaming(engine: &Engine, stream: impl Read) -> Result<Self, Error> {
-        ModuleParser::new(engine).parse_streaming(stream)
-    }
-
     /// Creates a new Wasm [`Module`] from the given Wasm bytecode buffer.
     ///
     /// # Note

crates/wasmi/src/preparsed/deserialization/tests.rs

@@ -19,8 +19,7 @@ fn imports_roundtrip() {
     let engine = Engine::default();
     let module = Module::new(&engine, &wasm_bytes).expect("Failed to create Module");
     // Serialize
-    let ser =
-        crate::preparsed::SerializedModule::from_module(&module, &engine).expect("serialize");
+    let ser = crate::preparsed::SerializedModule::from_module(&module, &engine).expect("serialize");
     let bytes = postcard::to_allocvec(&ser).expect("postcard serialize");
     // Deserialize
     let (deser_mod, _other_engine) = deserialize_module(&bytes).expect("failed to deserialize");
@@ -64,8 +63,7 @@ fn addition_module_serialize_deserialize_and_run() {
     let engine = Engine::default();
     let module = Module::new(&engine, &wasm_bytes).expect("Failed to create Module");
     // Serialize
-    let ser =
-        crate::preparsed::SerializedModule::from_module(&module, &engine).expect("serialize");
+    let ser = crate::preparsed::SerializedModule::from_module(&module, &engine).expect("serialize");
     let bytes = postcard::to_allocvec(&ser).expect("postcard serialize");
     // Deserialize with a new engine
     let (deser_mod, other_engine) =
@@ -74,10 +72,9 @@ fn addition_module_serialize_deserialize_and_run() {
 
     let mut store = Store::new(&other_engine, ());
     let linker = <Linker<()>>::new(&other_engine);
-    let instantiated = linker
-        .instantiate(&mut store, &deser_mod)
+    let started = linker
+        .instantiate_and_start(&mut store, &deser_mod)
         .expect("failed to instantiate");
-    let started = instantiated.start(&mut store).expect("failed to start");
     let add = started
         .get_typed_func::<(i32, i32), i32>(&mut store, "add")
         .expect("failed to get function");
@@ -109,10 +106,9 @@ fn memory_export_roundtrip() {
     // Instantiate and check that memory is exported
     let mut store = Store::new(&other_engine, ());
     let linker = <Linker<()>>::new(&other_engine);
-    let instantiated = linker
-        .instantiate(&mut store, &deser_mod)
+    let started = linker
+        .instantiate_and_start(&mut store, &deser_mod)
         .expect("failed to instantiate");
-    let started = instantiated.start(&mut store).expect("failed to start");
 
     // Check that memory is exported
     let memory = started
@@ -176,12 +172,10 @@ fn module_with_host_import_roundtrip() {
         .expect("Failed to define host function");
 
     // Instantiate the module
-    let instance = linker
-        .instantiate(&mut store, &deserialized_module)
+    let started = linker
+        .instantiate_and_start(&mut store, &deserialized_module)
         .expect("Failed to instantiate module");
 
-    let started = instance.start(&mut store).expect("failed to start");
-
     // Get the exported function
     let add_reduced = started
         .get_typed_func::<(i32, i32), i32>(&store, "add_reduced")

crates/wasmi/src/preparsed/serialization/tests.rs

@@ -5,52 +5,6 @@ use crate::{
 };
 use wat::parse_str as parse_wat;
 
-#[test]
-fn serialization_succeeds() {
-    // Minimal valid Wasm module: (module (func))
-    let wat = "(module (func))";
-    let wasm_bytes = parse_wat(wat).expect("Failed to parse WAT");
-    let engine = Engine::default();
-    let module = Module::new(&engine, &wasm_bytes).expect("Failed to create Module");
-    let result = SerializedModule::from_module(&module, &engine);
-    assert!(
-        result.is_ok(),
-        "from_module should succeed for minimal module"
-    );
-    let serialized = result.unwrap();
-    assert_eq!(serialized.version, SERIALIZATION_VERSION);
-    // Check that instructions match engine's instructions for internal functions
-    let mut expected_instrs = Vec::new();
-    for (_dedup_fn, engine_func) in module.internal_funcs() {
-        let mut instrs = Vec::new();
-        let mut idx = 0;
-        loop {
-            match engine.resolve_instr(engine_func, idx) {
-                Ok(Some(instr)) => instrs.push(instr),
-                Ok(None) => break,
-                Err(e) => panic!("Failed to extract instructions: {e}"),
-            }
-            idx += 1;
-        }
-        expected_instrs.push(instrs);
-    }
-    assert_eq!(
-        serialized.internal_functions.len(),
-        expected_instrs.len(),
-        "Number of serialized functions should match"
-    );
-    for (serialized_func, expected_instrs) in serialized
-        .internal_functions
-        .iter()
-        .zip(expected_instrs.iter())
-    {
-        assert_eq!(
-            serialized_func.instructions, *expected_instrs,
-            "Serialized instructions should match engine instructions"
-        );
-    }
-}
-
 #[test]
 fn functions_extraction() {
     // WAT with three functions: (func) (func (param i32)) (func (param i32) (result i64))