chore: simplify operands, extract more exec_ methods

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

benches/fibonacci.rs

@@ -44,7 +44,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     group.bench_function("fibonacci_from_twasm", |b| b.iter(|| fibonacci_from_twasm(&twasm)));
 
     group.measurement_time(std::time::Duration::from_secs(10));
-    group.bench_function("fibonacci_iterative_60", |b| b.iter(|| fibonacci_run(module.clone(), false, 60)));
+    group.bench_function("fibonacci_iterative_100", |b| b.iter(|| fibonacci_run(module.clone(), false, 100)));
     group.bench_function("fibonacci_recursive_26", |b| b.iter(|| fibonacci_run(module.clone(), true, 26)));
 }
 

crates/parser/src/conversion.rs

@@ -186,9 +186,9 @@ pub(crate) fn convert_module_code(
     }
 
     #[cfg(feature = "validate")]
-    let (body, data, validator_allocs, reader_allocs) = match validator {
+    let (body, data, uses_local_memory, validator_allocs, reader_allocs) = match validator {
         Some(validator) => {
-            let (body, data, validator_allocs, reader_allocs) = process_operators_and_validate(
+            let (body, data, uses_local_memory, validator_allocs, reader_allocs) = process_operators_and_validate(
                 validator,
                 func,
                 (local_types, local_addr_map),
@@ -197,34 +197,38 @@ pub(crate) fn convert_module_code(
                 reader_allocs,
                 options.deduplicate_operands(),
             )?;
-            (body, data, Some(validator_allocs), reader_allocs)
+            (body, data, uses_local_memory, Some(validator_allocs), reader_allocs)
         }
         None => {
-            let (body, data, reader_allocs) = process_operators(
+            let (body, data, uses_local_memory, reader_allocs) = process_operators(
                 func,
                 (local_types, local_addr_map),
                 metadata,
                 ty_idx,
                 reader_allocs,
                 options.deduplicate_operands(),
             )?;
-            (body, data, None, reader_allocs)
+            (body, data, uses_local_memory, None, reader_allocs)
         }
     };
     #[cfg(not(feature = "validate"))]
-    let (body, data, validator_allocs, reader_allocs) = {
+    let (body, data, uses_local_memory, validator_allocs, reader_allocs) = {
         let _ = validator;
-        let (body, data, reader_allocs) = process_operators(
+        let (body, data, uses_local_memory, reader_allocs) = process_operators(
             func,
             (local_types, local_addr_map),
             metadata,
             ty_idx,
             reader_allocs,
             options.deduplicate_operands(),
         )?;
-        (body, data, None, reader_allocs)
+        (body, data, uses_local_memory, None, reader_allocs)
     };
-    Ok((FunctionCode { instructions: body, data, locals: local_counts }, validator_allocs, reader_allocs))
+    Ok((
+        FunctionCode { instructions: body, data, locals: local_counts, uses_local_memory },
+        validator_allocs,
+        reader_allocs,
+    ))
 }
 
 pub(crate) fn convert_rec_group(ty: wasmparser::RecGroup, group_start: u32, types: &mut Vec<SubType>) -> Result<u32> {

crates/parser/src/lib.rs

@@ -61,11 +61,11 @@ pub struct ParserOptions {
     /// Disable this only for trusted input. Parsing without validation may produce
     /// a module that violates runtime assumptions.
     pub validation: bool,
+
     /// Whether to run the peephole rewrite optimizer.
     pub optimize_rewrite: bool,
+
     /// Whether to deduplicate immutable function operands while parsing.
-    ///
-    /// This uses more parse CPU to reduce precompiled module and archive size.
     pub deduplicate_operands: bool,
 
     #[cfg(parallel_parser)]

crates/parser/src/macros.rs

@@ -72,7 +72,10 @@ pub(crate) mod visit {
         ) => {
             fn $visit(&mut self, memarg: wasmparser::MemArg $(, $lane: $ty)?) -> Self::Output {
                 let address = self.metadata.memory_size(memarg.memory)?;
-                let memory_arg_idx = self.push_operand(MemoryArg::new(memarg.offset, memarg.memory))?;
+                self.mark_memory(memarg.memory);
+                let memory_arg_idx = self.push_operand128(tinywasm_types::Operand128::<
+                    tinywasm_types::MemoryOperand,
+                >::new(memarg.offset, memarg.memory))?;
                 lowering_ops!(@emit self address(address) [$($input),*] => [$($output),*]
                     lowering_ops!(@memory_instruction $instr memory_arg_idx $(, $lane)?))
             }
@@ -87,7 +90,17 @@ pub(crate) mod visit {
             lowering_ops!(@resolved global_size $inputs => $outputs $($operator)*);
         };
         (@memory_index $inputs:tt => $outputs:tt $($operator:tt)*) => {
-            lowering_ops!(@resolved memory_size $inputs => $outputs $($operator)*);
+            lowering_ops!(@memory_index_impl $inputs => $outputs $($operator)*);
+        };
+        (@memory_index_impl [$($input:ident),*] => [$($output:ident),*]
+            $visit:ident($index:ident: $ty:ty) => $instr:ident
+        ) => {
+            fn $visit(&mut self, $index: $ty) -> Self::Output {
+                let address = self.metadata.memory_size($index)?;
+                self.mark_memory($index);
+                lowering_ops!(@emit self address(address) [$($input),*] => [$($output),*]
+                    Instruction::$instr($index).into())
+            }
         };
         (@table $inputs:tt => $outputs:tt $($operator:tt)*) => {
             lowering_ops!(@resolved table_size $inputs => $outputs $($operator)*);

crates/parser/src/module.rs

@@ -13,12 +13,14 @@ pub(crate) struct FunctionCode {
     pub instructions: Vec<Instruction>,
     pub data: crate::visit::FunctionDataBuilder,
     pub locals: ValueCounts,
+    pub uses_local_memory: bool,
 }
 
 pub(crate) struct OptimizedFunctionCode {
     pub instructions: Vec<Instruction>,
     pub data: WasmFunctionData,
     pub locals: ValueCounts,
+    pub uses_local_memory: bool,
 }
 
 pub(crate) fn optimize_function_code(
@@ -30,7 +32,12 @@ pub(crate) fn optimize_function_code(
     let optimized =
         optimize::optimize_instructions(code.instructions, &mut code.data, options, function_results, self_func_addr)?;
     let data = code.data.finish();
-    Ok(OptimizedFunctionCode { instructions: optimized.instructions, data, locals: code.locals })
+    Ok(OptimizedFunctionCode {
+        instructions: optimized.instructions,
+        data,
+        locals: code.locals,
+        uses_local_memory: code.uses_local_memory,
+    })
 }
 
 #[derive(Default)]
@@ -535,6 +542,20 @@ impl<'a> ModuleReader<'a> {
             .chain(self.code_type_addrs.iter().copied())
             .collect();
 
+        let imported_memory_count =
+            self.imports.iter().filter(|import| matches!(import.kind, ImportKind::Memory(_))).count();
+        let uses_local_memory = self.code.iter().any(|code| code.uses_local_memory);
+        let exports_local_memory = self
+            .exports
+            .iter()
+            .any(|export| export.kind == ExternalKind::Memory && export.index as usize >= imported_memory_count);
+        let initializes_local_memory = self
+            .data
+            .iter()
+            .any(|data| matches!(data.kind, DataKind::Active { mem, .. } if mem as usize >= imported_memory_count));
+        let skip_local_memory_allocation =
+            !self.memory_types.is_empty() && !uses_local_memory && !exports_local_memory && !initializes_local_memory;
+
         let funcs = self
             .code
             .into_iter()
@@ -567,6 +588,7 @@ impl<'a> ModuleReader<'a> {
             exports: self.exports,
             elements: self.elements,
             memory_types: self.memory_types,
+            skip_local_memory_allocation,
             tags: self.tags,
         }
         .into())