chore: restructure runtime

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

Author: explodingcamera

CHANGELOG.md

@@ -12,7 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Improved support for WebAssembly 2.0 features
 - Simplify and optimize the interpreter loop
 - Use a seperate stack and locals for 32, 64 and 128 bit values and references (#21)
-- Updated to latest wasmparser version
+- Updated to latest `wasmparser` version
 
 ## [0.7.0] - 2024-05-15
 

crates/parser/src/conversion.rs

@@ -225,14 +225,6 @@ pub(crate) fn convert_module_type(ty: wasmparser::RecGroup) -> Result<FuncType>
     Ok(FuncType { params, results })
 }
 
-pub(crate) fn convert_blocktype(blocktype: wasmparser::BlockType) -> BlockArgs {
-    match blocktype {
-        wasmparser::BlockType::Empty => BlockArgs::Empty,
-        wasmparser::BlockType::Type(ty) => BlockArgs::Type(convert_valtype(&ty)),
-        wasmparser::BlockType::FuncType(ty) => BlockArgs::FuncType(ty),
-    }
-}
-
 pub(crate) fn convert_reftype(reftype: &wasmparser::RefType) -> ValType {
     match reftype {
         _ if reftype.is_func_ref() => ValType::RefFunc,

crates/parser/src/visit.rs

@@ -1,6 +1,6 @@
-use crate::{conversion::convert_blocktype, Result};
+use crate::Result;
 
-use crate::conversion::convert_heaptype;
+use crate::conversion::{convert_heaptype, convert_valtype};
 use alloc::string::ToString;
 use alloc::{boxed::Box, vec::Vec};
 use tinywasm_types::{Instruction, MemoryArg};
@@ -357,7 +357,13 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
     }
 
     fn visit_local_get(&mut self, idx: u32) -> Self::Output {
-        let resolved_idx = self.local_addr_map[idx as usize];
+        let Ok(resolved_idx) = self.local_addr_map[idx as usize].try_into() else {
+            self.errors.push(crate::ParseError::UnsupportedOperator(
+                "Local index is too large, tinywasm does not support local indexes that large".to_string(),
+            ));
+            return;
+        };
+
         match self.validator.get_local_type(idx) {
             Some(t) => self.instructions.push(match t {
                 wasmparser::ValType::I32 => Instruction::LocalGet32(resolved_idx),
@@ -372,7 +378,13 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
     }
 
     fn visit_local_set(&mut self, idx: u32) -> Self::Output {
-        let resolved_idx = self.local_addr_map[idx as usize];
+        let Ok(resolved_idx) = self.local_addr_map[idx as usize].try_into() else {
+            self.errors.push(crate::ParseError::UnsupportedOperator(
+                "Local index is too large, tinywasm does not support local indexes that large".to_string(),
+            ));
+            return;
+        };
+
         match self.validator.get_operand_type(0) {
             Some(Some(t)) => self.instructions.push(match t {
                 wasmparser::ValType::I32 => Instruction::LocalSet32(resolved_idx),
@@ -387,7 +399,13 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
     }
 
     fn visit_local_tee(&mut self, idx: u32) -> Self::Output {
-        let resolved_idx = self.local_addr_map[idx as usize];
+        let Ok(resolved_idx) = self.local_addr_map[idx as usize].try_into() else {
+            self.errors.push(crate::ParseError::UnsupportedOperator(
+                "Local index is too large, tinywasm does not support local indexes that large".to_string(),
+            ));
+            return;
+        };
+
         match self.validator.get_operand_type(0) {
             Some(Some(t)) => self.instructions.push(match t {
                 wasmparser::ValType::I32 => Instruction::LocalTee32(resolved_idx),
@@ -411,17 +429,29 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
 
     fn visit_block(&mut self, blockty: wasmparser::BlockType) -> Self::Output {
         self.label_ptrs.push(self.instructions.len());
-        self.instructions.push(Instruction::Block(convert_blocktype(blockty), 0))
+        self.instructions.push(match blockty {
+            wasmparser::BlockType::Empty => Instruction::Block(0),
+            wasmparser::BlockType::FuncType(idx) => Instruction::BlockWithFuncType(idx, 0),
+            wasmparser::BlockType::Type(ty) => Instruction::BlockWithType(convert_valtype(&ty), 0),
+        })
     }
 
     fn visit_loop(&mut self, ty: wasmparser::BlockType) -> Self::Output {
         self.label_ptrs.push(self.instructions.len());
-        self.instructions.push(Instruction::Loop(convert_blocktype(ty), 0))
+        self.instructions.push(match ty {
+            wasmparser::BlockType::Empty => Instruction::Loop(0),
+            wasmparser::BlockType::FuncType(idx) => Instruction::LoopWithFuncType(idx, 0),
+            wasmparser::BlockType::Type(ty) => Instruction::LoopWithType(convert_valtype(&ty), 0),
+        })
     }
 
     fn visit_if(&mut self, ty: wasmparser::BlockType) -> Self::Output {
         self.label_ptrs.push(self.instructions.len());
-        self.instructions.push(Instruction::If(convert_blocktype(ty).into(), 0, 0))
+        self.instructions.push(match ty {
+            wasmparser::BlockType::Empty => Instruction::If(0, 0),
+            wasmparser::BlockType::FuncType(idx) => Instruction::IfWithFuncType(idx, 0, 0),
+            wasmparser::BlockType::Type(ty) => Instruction::IfWithType(convert_valtype(&ty), 0, 0),
+        })
     }
 
     fn visit_else(&mut self) -> Self::Output {
@@ -451,12 +481,18 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
                 };
 
                 let if_instruction = &mut self.instructions[if_label_pointer];
-                let Instruction::If(_, else_offset, end_offset) = if_instruction else {
-                    self.errors.push(crate::ParseError::UnsupportedOperator(
-                        "Expected to end an if block, but the last label was not an if".to_string(),
-                    ));
 
-                    return;
+                let (else_offset, end_offset) = match if_instruction {
+                    Instruction::If(else_offset, end_offset)
+                    | Instruction::IfWithFuncType(_, else_offset, end_offset)
+                    | Instruction::IfWithType(_, else_offset, end_offset) => (else_offset, end_offset),
+                    _ => {
+                        self.errors.push(crate::ParseError::UnsupportedOperator(
+                            "Expected to end an if block, but the last label was not an if".to_string(),
+                        ));
+
+                        return;
+                    }
                 };
 
                 *else_offset = (label_pointer - if_label_pointer)
@@ -467,9 +503,15 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
                     .try_into()
                     .expect("else_instr_end_offset is too large, tinywasm does not support blocks that large");
             }
-            Some(Instruction::Block(_, end_offset))
-            | Some(Instruction::Loop(_, end_offset))
-            | Some(Instruction::If(_, _, end_offset)) => {
+            Some(Instruction::Block(end_offset))
+            | Some(Instruction::BlockWithType(_, end_offset))
+            | Some(Instruction::BlockWithFuncType(_, end_offset))
+            | Some(Instruction::Loop(end_offset))
+            | Some(Instruction::LoopWithFuncType(_, end_offset))
+            | Some(Instruction::LoopWithType(_, end_offset))
+            | Some(Instruction::If(_, end_offset))
+            | Some(Instruction::IfWithFuncType(_, _, end_offset))
+            | Some(Instruction::IfWithType(_, _, end_offset)) => {
                 *end_offset = (current_instr_ptr - label_pointer)
                     .try_into()
                     .expect("else_instr_end_offset is too large, tinywasm does not support  blocks that large");

crates/tinywasm/Cargo.toml

@@ -19,16 +19,6 @@ tinywasm-parser={version="0.7.0", path="../parser", default-features=false, opti
 tinywasm-types={version="0.7.0", path="../types", default-features=false}
 libm={version="0.2", default-features=false}
 
-# maybe?
-# arrayvec={version="0.7"}          instead of the custom implementation
-# bumpalo={version="3.16"}
-# wide=                             for simd
-# vec1=                             might be useful? fast .last() and .first() access
-# https://github.com/lumol-org/soa-derive       could be useful for the memory layout of Stacks
-
-#https://alic.dev/blog/dense-enums
-# https://docs.rs/tagged-pointer/latest/tagged_pointer/
-
 [dev-dependencies]
 wasm-testsuite={path="../wasm-testsuite"}
 wast={version="212.0"}

crates/tinywasm/src/func.rs

@@ -1,4 +1,4 @@
-use crate::runtime::{CallFrame, Stack};
+use crate::interpreter::{CallFrame, Stack};
 use crate::{log, unlikely, Function};
 use crate::{Error, FuncContext, Result, Store};
 use alloc::{boxed::Box, format, string::String, string::ToString, vec, vec::Vec};
@@ -59,7 +59,7 @@ impl FuncHandle {
         };
 
         // 6. Let f be the dummy frame
-        let call_frame = CallFrame::new(wasm_func.clone(), func_inst.owner, params, 0);
+        let call_frame = CallFrame::new(wasm_func.clone(), func_inst._owner, params, 0);
 
         // 7. Push the frame f to the call stack
         // & 8. Push the values to the stack (Not needed since the call frame owns the values)

crates/tinywasm/src/imports.rs

@@ -348,7 +348,7 @@ impl Imports {
     ) -> Result<ResolvedImports> {
         let mut imports = ResolvedImports::new();
 
-        for import in module.data.imports.iter() {
+        for import in module.0.imports.iter() {
             let val = self.take(store, import).ok_or_else(|| LinkingError::unknown_import(import))?;
 
             match val {
@@ -368,7 +368,7 @@ impl Imports {
                     }
                     (Extern::Function(extern_func), ImportKind::Function(ty)) => {
                         let import_func_type = module
-                            .data
+                            .0
                             .func_types
                             .get(*ty as usize)
                             .ok_or_else(|| LinkingError::incompatible_import_type(import))?;
@@ -409,7 +409,7 @@ impl Imports {
                         (ExternVal::Func(func_addr), ImportKind::Function(ty)) => {
                             let func = store.get_func(func_addr)?;
                             let import_func_type = module
-                                .data
+                                .0
                                 .func_types
                                 .get(*ty as usize)
                                 .ok_or_else(|| LinkingError::incompatible_import_type(import))?;

crates/tinywasm/src/instance.rs

@@ -64,45 +64,39 @@ impl ModuleInstance {
 
         let idx = store.next_module_instance_idx();
         let mut addrs = imports.unwrap_or_default().link(store, &module, idx)?;
-        let data = module.data;
 
-        addrs.funcs.extend(store.init_funcs(data.funcs.into(), idx)?);
-        addrs.tables.extend(store.init_tables(data.table_types.into(), idx)?);
-        addrs.memories.extend(store.init_memories(data.memory_types.into(), idx)?);
+        addrs.funcs.extend(store.init_funcs(module.0.funcs.into(), idx)?);
+        addrs.tables.extend(store.init_tables(module.0.table_types.into(), idx)?);
+        addrs.memories.extend(store.init_memories(module.0.memory_types.into(), idx)?);
 
-        let global_addrs = store.init_globals(addrs.globals, data.globals.into(), &addrs.funcs, idx)?;
+        let global_addrs = store.init_globals(addrs.globals, module.0.globals.into(), &addrs.funcs, idx)?;
         let (elem_addrs, elem_trapped) =
-            store.init_elements(&addrs.tables, &addrs.funcs, &global_addrs, &data.elements, idx)?;
-        let (data_addrs, data_trapped) = store.init_datas(&addrs.memories, data.data.into(), idx)?;
+            store.init_elements(&addrs.tables, &addrs.funcs, &global_addrs, &module.0.elements, idx)?;
+        let (data_addrs, data_trapped) = store.init_datas(&addrs.memories, module.0.data.into(), idx)?;
 
         let instance = ModuleInstanceInner {
             failed_to_instantiate: elem_trapped.is_some() || data_trapped.is_some(),
             store_id: store.id(),
             idx,
-            types: data.func_types,
+            types: module.0.func_types,
             func_addrs: addrs.funcs.into_boxed_slice(),
             table_addrs: addrs.tables.into_boxed_slice(),
             mem_addrs: addrs.memories.into_boxed_slice(),
             global_addrs: global_addrs.into_boxed_slice(),
             elem_addrs,
             data_addrs,
-            func_start: data.start_func,
-            imports: data.imports,
-            exports: data.exports,
+            func_start: module.0.start_func,
+            imports: module.0.imports,
+            exports: module.0.exports,
         };
 
         let instance = ModuleInstance::new(instance);
         store.add_instance(instance.clone());
 
-        if let Some(trap) = elem_trapped {
-            return Err(trap.into());
-        };
-
-        if let Some(trap) = data_trapped {
-            return Err(trap.into());
-        };
-
-        Ok(instance)
+        match (elem_trapped, data_trapped) {
+            (Some(trap), _) | (_, Some(trap)) => Err(trap.into()),
+            _ => Ok(instance),
+        }
     }
 
     /// Get a export by name
@@ -224,13 +218,13 @@ impl ModuleInstance {
     /// Get a memory by address
     pub fn memory<'a>(&self, store: &'a mut Store, addr: MemAddr) -> Result<MemoryRef<'a>> {
         let mem = store.get_mem(self.resolve_mem_addr(addr)?)?;
-        Ok(MemoryRef { instance: mem.borrow() })
+        Ok(MemoryRef(mem.borrow()))
     }
 
     /// Get a memory by address (mutable)
     pub fn memory_mut<'a>(&self, store: &'a mut Store, addr: MemAddr) -> Result<MemoryRefMut<'a>> {
         let mem = store.get_mem(self.resolve_mem_addr(addr)?)?;
-        Ok(MemoryRefMut { instance: mem.borrow_mut() })
+        Ok(MemoryRefMut(mem.borrow_mut()))
     }
 
     /// Get the start function of the module