feat: new parser architecture

Signed-off-by: Henry Gressmann <[email protected]>

Author: explodingcamera

BENCHMARKS.md

@@ -30,13 +30,12 @@ All runtimes are compiled with the following settings:
 
 | Benchmark    | Native   | TinyWasm\* | Wasmi     | Wasmer (Single Pass) |
 | ------------ | -------- | ---------- | --------- | -------------------- |
-| `fib`        | \*\*     | ` 44.11µs` | `49.46µs` | ` 50.65µs`           |
+| `fib`        | \*\*     | ` 43.81µs` | `48.60µs` | ` 43.97µs`           |
 | `fib-rec`    | `0.26ms` | ` 20.99ms` | ` 4.64ms` | `  0.50ms`           |
-| `argon2id`   | `0.53ms` | `109.38ms` | `45.85ms` | `  4.82ms`           |
-| `selfhosted` | `0.05ms` | `  1.97ms` | ` 4.26ms` | `260.32ms`           |
+| `argon2id`   | `0.53ms` | `107.77ms` | `47.76ms` | `  4.49ms`           |
+| `selfhosted` | `0.06ms` | `  2.88ms` | ` 6.20ms` | `359.33ms`           |
 
 _\* converting WASM to TinyWasm bytecode is not included. I takes ~7ms to convert `tinywasm.wasm` to TinyWasm bytecode._
-
 _\*\* essentially instant as it gets computed at compile time._
 
 ### Fib

crates/benchmarks/benches/selfhosted.rs

@@ -55,7 +55,7 @@ const TINYWASM: &[u8] = include_bytes!("../../../examples/rust/out/tinywasm.wasm
 fn criterion_benchmark(c: &mut Criterion) {
     {
         let mut group = c.benchmark_group("selfhosted-parse");
-        group.bench_function("tinywasm", |b| b.iter(|| util::wasm_to_twasm(TINYWASM)));
+        group.bench_function("tinywasm", |b| b.iter(|| util::parse_wasm(TINYWASM)));
     }
 
     {

crates/benchmarks/benches/util/mod.rs

@@ -2,6 +2,11 @@
 
 use tinywasm::{self, parser::Parser, types::TinyWasmModule};
 
+pub fn parse_wasm(wasm: &[u8]) -> TinyWasmModule {
+    let parser = Parser::new();
+    parser.parse_module_bytes(wasm).expect("parse_module_bytes")
+}
+
 pub fn wasm_to_twasm(wasm: &[u8]) -> Vec<u8> {
     let parser = Parser::new();
     let res = parser.parse_module_bytes(wasm).expect("parse_module_bytes");

crates/parser/src/conversion.rs

@@ -7,6 +7,7 @@
 #![forbid(unsafe_code)]
 #![cfg_attr(not(feature = "std"), feature(error_in_core))]
 //! See [`tinywasm`](https://docs.rs/tinywasm) for documentation.
+#![recursion_limit = "1028"]
 
 mod std;
 extern crate alloc;
@@ -28,6 +29,7 @@ mod log {
 mod conversion;
 mod error;
 mod module;
+mod visit;
 use alloc::{string::ToString, vec::Vec};
 pub use error::*;
 use module::ModuleReader;
@@ -155,11 +157,11 @@ impl TryFrom<ModuleReader> for TinyWasmModule {
             .code
             .into_iter()
             .zip(code_type_addrs)
-            .map(|(f, ty_idx)| TypedWasmFunction {
+            .map(|((instructions, locals), ty_idx)| TypedWasmFunction {
                 type_addr: ty_idx,
                 wasm_function: WasmFunction {
-                    instructions: f.body,
-                    locals: f.locals,
+                    instructions,
+                    locals,
                     ty: reader.func_types.get(ty_idx as usize).expect("No func type for func, this is a bug").clone(),
                 },
             })

crates/parser/src/lib.rs

@@ -1,24 +1,17 @@
 use crate::log::debug;
 use crate::{conversion, ParseError, Result};
 use alloc::{boxed::Box, format, vec::Vec};
-use core::fmt::Debug;
 use tinywasm_types::{Data, Element, Export, FuncType, Global, Import, Instruction, MemoryType, TableType, ValType};
 use wasmparser::{Payload, Validator};
 
-#[derive(Debug, Clone)]
-pub(crate) struct CodeSection {
-    pub(crate) locals: Box<[ValType]>,
-    pub(crate) body: Box<[Instruction]>,
-}
-
 #[derive(Default)]
 pub(crate) struct ModuleReader {
     pub(crate) version: Option<u16>,
     pub(crate) start_func: Option<u32>,
     pub(crate) func_types: Vec<FuncType>,
     pub(crate) code_type_addrs: Vec<u32>,
     pub(crate) exports: Vec<Export>,
-    pub(crate) code: Vec<CodeSection>,
+    pub(crate) code: Vec<(Box<[Instruction]>, Box<[ValType]>)>,
     pub(crate) globals: Vec<Global>,
     pub(crate) table_types: Vec<TableType>,
     pub(crate) memory_types: Vec<MemoryType>,
@@ -66,15 +59,7 @@ impl ModuleReader {
                     .map(|t| conversion::convert_module_type(t?))
                     .collect::<Result<Vec<FuncType>>>()?;
             }
-            FunctionSection(reader) => {
-                if !self.code_type_addrs.is_empty() {
-                    return Err(ParseError::DuplicateSection("Function section".into()));
-                }
 
-                debug!("Found function section");
-                validator.function_section(&reader)?;
-                self.code_type_addrs = reader.into_iter().map(|f| Ok(f?)).collect::<Result<Vec<_>>>()?;
-            }
             GlobalSection(reader) => {
                 if !self.globals.is_empty() {
                     return Err(ParseError::DuplicateSection("Global section".into()));
@@ -122,11 +107,21 @@ impl ModuleReader {
                 }
                 validator.data_count_section(count, &range)?;
             }
+            FunctionSection(reader) => {
+                if !self.code_type_addrs.is_empty() {
+                    return Err(ParseError::DuplicateSection("Function section".into()));
+                }
+
+                debug!("Found function section");
+                validator.function_section(&reader)?;
+                self.code_type_addrs = reader.into_iter().map(|f| Ok(f?)).collect::<Result<Vec<_>>>()?;
+            }
             CodeSectionStart { count, range, .. } => {
                 debug!("Found code section ({} functions)", count);
                 if !self.code.is_empty() {
                     return Err(ParseError::DuplicateSection("Code section".into()));
                 }
+                self.code.reserve(count as usize);
                 validator.code_section_start(count, &range)?;
             }
             CodeSectionEntry(function) => {