chore: support partially initialized module instances

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

Author: explodingcamera

crates/parser/src/lib.rs

@@ -120,7 +120,11 @@ impl TryFrom<ModuleReader> for TinyWasmModule {
                     WasmFunction {
                         instructions: f.body,
                         locals: f.locals,
-                        ty: reader.func_types.get(ty_idx as usize).unwrap().clone(),
+                        ty: reader
+                            .func_types
+                            .get(ty_idx as usize)
+                            .expect("No func type for func, this is a bug")
+                            .clone(),
                     },
                 )
             })

crates/tinywasm/src/instance.rs

@@ -20,6 +20,8 @@ pub struct ModuleInstance(Arc<ModuleInstanceInner>);
 #[allow(dead_code)]
 #[derive(Debug)]
 pub(crate) struct ModuleInstanceInner {
+    pub(crate) failed_to_instantiate: bool,
+
     pub(crate) store_id: usize,
     pub(crate) idx: ModuleInstanceAddr,
 
@@ -69,10 +71,11 @@ impl ModuleInstance {
         addrs.tables.extend(store.init_tables(data.table_types.into(), idx)?);
         addrs.memories.extend(store.init_memories(data.memory_types.into(), idx)?);
 
-        let elem_addrs = store.init_elements(&addrs.tables, &addrs.funcs, data.elements.into(), idx)?;
-        let data_addrs = store.init_datas(&addrs.memories, data.data.into(), idx)?;
+        let (elem_addrs, elem_trapped) = store.init_elements(&addrs.tables, &addrs.funcs, data.elements.into(), idx)?;
+        let (data_addrs, data_trapped) = store.init_datas(&addrs.memories, data.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,
@@ -90,6 +93,14 @@ impl ModuleInstance {
         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)
     }
 

crates/tinywasm/src/runtime/executor/mod.rs

@@ -6,7 +6,7 @@ use crate::{
     runtime::{BlockType, LabelFrame},
     CallFrame, Error, FuncContext, LabelArgs, ModuleInstance, Result, Store, Trap,
 };
-use alloc::{string::ToString, vec::Vec};
+use alloc::{format, string::ToString, vec::Vec};
 use tinywasm_types::{ElementKind, Instruction, ValType};
 
 mod macros;
@@ -25,10 +25,7 @@ impl DefaultRuntime {
         // The function to execute, gets updated from ExecResult::Call
         let mut instrs = &wasm_func.instructions;
 
-        let mut current_module = store
-            .get_module_instance(func_inst.owner)
-            .expect("exec expected module instance to exist for function")
-            .clone();
+        let mut current_module = store.get_module_instance(func_inst.owner).unwrap().clone();
 
         while let Some(instr) = instrs.get(cf.instr_ptr) {
             match exec_one(&mut cf, instr, instrs, stack, store, &current_module)? {
@@ -40,7 +37,15 @@ impl DefaultRuntime {
                     instrs = &wasm_func.instructions;
 
                     if cf.func_instance.owner != current_module.id() {
-                        current_module.swap(store.get_module_instance(cf.func_instance.owner).unwrap().clone());
+                        current_module.swap(
+                            store
+                                .get_module_instance(cf.func_instance.owner)
+                                .expect(&format!(
+                                    "exec expected module instance {} to exist for function",
+                                    cf.func_instance.owner
+                                ))
+                                .clone(),
+                        );
                     }
 
                     continue;

crates/tinywasm/src/store.rs

@@ -46,6 +46,7 @@ impl Store {
 
     /// Get a module instance by the internal id
     pub fn get_module_instance(&self, addr: ModuleInstanceAddr) -> Option<&ModuleInstance> {
+        log::debug!("existing module instances: {:?}", self.module_instances.len());
         self.module_instances.get(addr as usize)
     }
 
@@ -180,7 +181,7 @@ impl Store {
         func_addrs: &[FuncAddr],
         elements: Vec<Element>,
         idx: ModuleInstanceAddr,
-    ) -> Result<Box<[Addr]>> {
+    ) -> Result<(Box<[Addr]>, Option<Trap>)> {
         let elem_count = self.data.elements.len();
         let mut elem_addrs = Vec::with_capacity(elem_count);
         for (i, element) in elements.into_iter().enumerate() {
@@ -214,15 +215,17 @@ impl Store {
                         .copied()
                         .ok_or_else(|| Error::Other(format!("table {} not found for element {}", table, i)))?;
 
-                    // a. Let n be the length of the vector elem[i].init
-                    // b. Execute the instruction sequence einstrs
-                    // c. Execute the instruction i32.const 0
-                    // d. Execute the instruction i32.const n
-                    // e. Execute the instruction table.init tableidx i
                     if let Some(table) = self.data.tables.get_mut(table_addr as usize) {
-                        table.borrow_mut().init(func_addrs, offset, &init)?;
+                        // In wasm 2.0, it's possible to call a function that hasn't been instantiated yet,
+                        // when using a partially initialized active element segments.
+                        // This isn't mentioned in the spec, but the "unofficial" testsuite has a test for it:
+                        // https://github.com/WebAssembly/testsuite/blob/5a1a590603d81f40ef471abba70a90a9ae5f4627/linking.wast#L264-L276
+                        // I have NO IDEA why this is allowed, but it is.
+                        if let Err(Error::Trap(trap)) = table.borrow_mut().init(func_addrs, offset, &init) {
+                            return Ok((elem_addrs.into_boxed_slice(), Some(trap)));
+                        }
                     } else {
-                        log::error!("table {} not found", table);
+                        return Err(Error::Other(format!("table {} not found for element {}", table, i)));
                     }
 
                     // f. Execute the instruction elm.drop i
@@ -235,7 +238,7 @@ impl Store {
         }
 
         // this should be optimized out by the compiler
-        Ok(elem_addrs.into_boxed_slice())
+        Ok((elem_addrs.into_boxed_slice(), None))
     }
 
     /// Add data to the store, returning their addresses in the store
@@ -244,7 +247,7 @@ impl Store {
         mem_addrs: &[MemAddr],
         datas: Vec<Data>,
         idx: ModuleInstanceAddr,
-    ) -> Result<Box<[Addr]>> {
+    ) -> Result<(Box<[Addr]>, Option<Trap>)> {
         let data_count = self.data.datas.len();
         let mut data_addrs = Vec::with_capacity(data_count);
         for (i, data) in datas.into_iter().enumerate() {
@@ -268,7 +271,10 @@ impl Store {
                             Error::Other(format!("memory {} not found for data segment {}", mem_addr, i))
                         })?;
 
-                    mem.borrow_mut().store(offset as usize, 0, &data.data)?;
+                    // See comment for active element sections in the function above why we need to do this here
+                    if let Err(Error::Trap(trap)) = mem.borrow_mut().store(offset as usize, 0, &data.data) {
+                        return Ok((data_addrs.into_boxed_slice(), Some(trap)));
+                    }
 
                     // drop the data
                     continue;
@@ -281,7 +287,7 @@ impl Store {
         }
 
         // this should be optimized out by the compiler
-        Ok(data_addrs.into_boxed_slice())
+        Ok((data_addrs.into_boxed_slice(), None))
     }
 
     pub(crate) fn add_global(&mut self, ty: GlobalType, value: RawWasmValue, idx: ModuleInstanceAddr) -> Result<Addr> {