chore: refactor optimizer/add more superinstructions

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

Author: explodingcamera

crates/parser/src/lib.rs

@@ -32,6 +32,7 @@ pub(crate) mod log {
 mod conversion;
 mod error;
 mod module;
+mod optimize;
 mod visit;
 pub use error::*;
 use module::ModuleReader;
@@ -41,14 +42,18 @@ pub use tinywasm_types::TinyWasmModule;
 
 /// Parser optimization and lowering options.
 #[non_exhaustive]
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct ParserOptions {
-    // /// Enable control-flow graph cleanup rewrites.
-    // pub cfg_cleanup: bool,
-    // /// Enable dead-code pruning.
-    // pub dce: bool,
-    // /// Enable return-call rewrites when safe.
-    // pub tailcall_rewrite: bool,
+    /// Enable post-lowering DCE pass.
+    /// Should be enabled by default, since the parser performs some optimizations that can result in dead code.
+    /// Disabling this may result in larger modules, but faster parsing time.
+    pub dce: bool,
+}
+
+impl Default for ParserOptions {
+    fn default() -> Self {
+        Self { dce: true }
+    }
 }
 
 /// A WebAssembly parser
@@ -133,7 +138,7 @@ impl Parser {
             return Err(ParseError::EndNotReached);
         }
 
-        reader.into_module()
+        reader.into_module(&self.options)
     }
 
     #[cfg(feature = "std")]
@@ -173,7 +178,7 @@ impl Parser {
                     reader.process_payload(payload, &mut validator)?;
                     buffer.drain(..consumed);
                     if eof || reader.end_reached {
-                        return reader.into_module();
+                        return reader.into_module(&self.options);
                     }
                 }
             };
@@ -185,6 +190,6 @@ impl TryFrom<ModuleReader> for TinyWasmModule {
     type Error = ParseError;
 
     fn try_from(reader: ModuleReader) -> Result<Self> {
-        reader.into_module()
+        reader.into_module(&ParserOptions::default())
     }
 }

crates/parser/src/module.rs

@@ -1,15 +1,14 @@
 use crate::log::debug;
-use crate::{ParseError, Result, conversion};
+use crate::{ParseError, ParserOptions, Result, conversion, optimize};
 use alloc::string::ToString;
-use alloc::sync::Arc;
 use alloc::{format, vec::Vec};
 use tinywasm_types::{
     ArcSlice, Data, Element, Export, FuncType, Global, Import, ImportKind, Instruction, MemoryType, TableType,
     TinyWasmModule, ValueCounts, ValueCountsSmall, WasmFunction, WasmFunctionData,
 };
 use wasmparser::{FuncValidatorAllocations, Payload, Validator};
 
-pub(crate) type Code = (Arc<[Instruction]>, WasmFunctionData, ValueCounts);
+pub(crate) type Code = (Vec<Instruction>, WasmFunctionData, ValueCounts);
 
 #[derive(Default)]
 pub(crate) struct ModuleReader {
@@ -31,16 +30,6 @@ pub(crate) struct ModuleReader {
 }
 
 impl ModuleReader {
-    fn apply_instruction_rewrites(instructions: &mut [Instruction], self_func_addr: u32) {
-        for instr in instructions.iter_mut() {
-            if matches!(instr, Instruction::Call(addr) if *addr == self_func_addr) {
-                *instr = Instruction::CallSelf;
-            } else if matches!(instr, Instruction::ReturnCall(addr) if *addr == self_func_addr) {
-                *instr = Instruction::ReturnCallSelf;
-            }
-        }
-    }
-
     pub(crate) fn new() -> Self {
         Self::default()
     }
@@ -190,7 +179,7 @@ impl ModuleReader {
         Ok(())
     }
 
-    pub(crate) fn into_module(self) -> Result<TinyWasmModule> {
+    pub(crate) fn into_module(self, options: &ParserOptions) -> Result<TinyWasmModule> {
         if !self.end_reached {
             return Err(ParseError::EndNotReached);
         }
@@ -217,8 +206,7 @@ impl ModuleReader {
                     cref: u16::try_from(locals.cref).unwrap_or_else(|_| unreachable!("local count exceeds u16")),
                 };
                 let self_func_addr = imported_func_count + func_idx as u32;
-                let mut instructions = instructions.to_vec();
-                Self::apply_instruction_rewrites(&mut instructions, self_func_addr);
+                let instructions = optimize::optimize_instructions(instructions, self_func_addr, options);
 
                 WasmFunction { instructions: ArcSlice::from(instructions), data, locals, params, ty }
             })