chore: progress on v2 tables

explodingcamera · explodingcamera · commit dce86f8f9ad9 · 2024-05-27T23:38:59.000+02:00
Signed-off-by: Henry Gressmann &lt;mail@henrygressmann.de&gt;
diff --git a/crates/tinywasm/src/runtime/interpreter/mod.rs b/crates/tinywasm/src/runtime/interpreter/mod.rs
@@ -507,9 +507,10 @@ impl<'store, 'stack> Executor<'store, 'stack> {
     fn exec_table_set(&mut self, table_index: u32) -> Result<()> {
         let table_idx = self.module.resolve_table_addr(table_index);
         let table = self.store.get_table(table_idx)?;
-        let val = self.stack.values.pop()?.into();
+        let val = self.stack.values.pop()?.as_reference();
         let idx = self.stack.values.pop()?.into();
-        table.borrow_mut().set(idx, val)?;
+        table.borrow_mut().set(idx, val.into())?;
+
         Ok(())
     }
 
@@ -557,18 +558,42 @@ impl<'store, 'stack> Executor<'store, 'stack> {
     #[inline(always)]
     // todo: this is just a placeholder, need to check the spec
     fn exec_table_grow(&mut self, table_index: u32) -> Result<()> {
-        let table_idx = self.module.resolve_table_addr(table_index);
-        let table = self.store.get_table(table_idx)?;
-        let delta: i32 = self.stack.values.pop()?.into();
-        let prev_size = table.borrow().size();
-        table.borrow_mut().grow_to_fit((prev_size + delta) as usize)?;
-        self.stack.values.push(prev_size.into());
+        let table = self.store.get_table(self.module.resolve_table_addr(table_index))?;
+        let sz = table.borrow().size();
+
+        let n: i32 = self.stack.values.pop()?.into();
+        let val = self.stack.values.pop()?.as_reference();
+
+        match table.borrow_mut().grow(n, val.into()) {
+            Ok(_) => self.stack.values.push(sz.into()),
+            Err(_) => self.stack.values.push((-1_i32).into()),
+        }
+
         Ok(())
     }
 
     #[inline(always)]
-    fn exec_table_fill(&mut self, _table_index: u32) -> Result<()> {
-        // TODO: implement
+    fn exec_table_fill(&mut self, table_index: u32) -> Result<()> {
+        let table = self.store.get_table(self.module.resolve_table_addr(table_index))?;
+
+        let n: i32 = self.stack.values.pop()?.into();
+        let val = self.stack.values.pop()?.as_reference();
+        let i: i32 = self.stack.values.pop()?.into();
+
+        if unlikely(i + n > table.borrow().size()) {
+            return Err(Trap::TableOutOfBounds {
+                offset: i as usize,
+                len: n as usize,
+                max: table.borrow().size() as usize,
+            }
+            .into());
+        }
+
+        if n == 0 {
+            return Ok(());
+        }
+
+        table.borrow_mut().fill(self.module.func_addrs(), i as usize, n as usize, val.into())?;
         Ok(())
     }
 
@@ -742,7 +767,11 @@ impl<'store, 'stack> Executor<'store, 'stack> {
             let table_idx: u32 = self.stack.values.pop()?.into();
             let table = table.borrow();
             assert!(table.kind.element_type == ValType::RefFunc, "table is not of type funcref");
-            table.get(table_idx)?.addr().ok_or(Trap::UninitializedElement { index: table_idx as usize })?
+            table
+                .get(table_idx)
+                .map_err(|_| Error::Trap(Trap::UndefinedElement { index: table_idx as usize }))?
+                .addr()
+                .ok_or(Trap::UninitializedElement { index: table_idx as usize })?
         };
 
         let func_inst = self.store.get_func(func_ref)?;
diff --git a/crates/tinywasm/src/runtime/raw.rs b/crates/tinywasm/src/runtime/raw.rs
@@ -31,14 +31,20 @@ impl RawWasmValue {
             ValType::F32 => WasmValue::F32(f32::from_bits(self.into())),
             ValType::F64 => WasmValue::F64(f64::from_bits(self.into())),
             ValType::V128 => panic!("RawWasmValue cannot be converted to V128"),
-            ValType::RefExtern => match i64::from(self) {
-                v if v < 0 => WasmValue::RefNull(ValType::RefExtern),
-                addr => WasmValue::RefExtern(addr as u32),
-            },
-            ValType::RefFunc => match i64::from(self) {
-                v if v < 0 => WasmValue::RefNull(ValType::RefFunc),
-                addr => WasmValue::RefFunc(addr as u32),
-            },
+            ValType::RefExtern => {
+                self.as_reference().map(WasmValue::RefExtern).unwrap_or(WasmValue::RefNull(ValType::RefExtern))
+            }
+            ValType::RefFunc => {
+                self.as_reference().map(WasmValue::RefFunc).unwrap_or(WasmValue::RefNull(ValType::RefFunc))
+            }
+        }
+    }
+
+    #[inline]
+    pub(crate) fn as_reference(&self) -> Option<u32> {
+        match i64::from(*self) {
+            v if v < 0 => None,
+            addr => Some(addr as u32),
         }
     }
 }
diff --git a/crates/tinywasm/src/store/table.rs b/crates/tinywasm/src/store/table.rs
@@ -1,4 +1,4 @@
-use crate::{log, unlikely};
+use crate::log;
 use crate::{Error, Result, Trap};
 use alloc::{vec, vec::Vec};
 use tinywasm_types::*;
@@ -36,8 +36,22 @@ impl TableInstance {
         })
     }
 
+    pub(crate) fn fill(&mut self, func_addrs: &[u32], addr: usize, len: usize, val: TableElement) -> Result<()> {
+        let val = val.map(|addr| self.resolve_func_ref(func_addrs, addr));
+        let end = addr.checked_add(len).ok_or_else(|| self.trap_oob(addr, len))?;
+        if end > self.elements.len() {
+            return Err(self.trap_oob(addr, len));
+        }
+
+        self.elements[addr..end].fill(val);
+        Ok(())
+    }
+
     pub(crate) fn get(&self, addr: TableAddr) -> Result<&TableElement> {
-        self.elements.get(addr as usize).ok_or_else(|| Error::Trap(Trap::UndefinedElement { index: addr as usize }))
+        // self.elements.get(addr as usize).ok_or_else(|| Error::Trap(Trap::UndefinedElement { index: addr as usize }))
+        self.elements.get(addr as usize).ok_or_else(|| {
+            Error::Trap(Trap::TableOutOfBounds { offset: addr as usize, len: 1, max: self.elements.len() })
+        })
     }
 
     pub(crate) fn copy_from_slice(&mut self, dst: usize, src: &[TableElement]) -> Result<()> {
@@ -81,19 +95,28 @@ impl TableInstance {
         Ok(())
     }
 
-    pub(crate) fn set(&mut self, table_idx: TableAddr, value: Addr) -> Result<()> {
-        self.grow_to_fit(table_idx as usize + 1)
-            .map(|_| self.elements[table_idx as usize] = TableElement::Initialized(value))
+    pub(crate) fn set(&mut self, table_idx: TableAddr, value: TableElement) -> Result<()> {
+        if table_idx as usize >= self.elements.len() {
+            return Err(self.trap_oob(table_idx as usize, 1));
+        }
+
+        self.elements[table_idx as usize] = value;
+        Ok(())
     }
 
-    pub(crate) fn grow_to_fit(&mut self, new_size: usize) -> Result<()> {
-        if new_size > self.elements.len() {
-            if unlikely(new_size > self.kind.size_max.unwrap_or(MAX_TABLE_SIZE) as usize) {
-                return Err(crate::Trap::TableOutOfBounds { offset: new_size, len: 1, max: self.elements.len() }.into());
-            }
+    pub(crate) fn grow(&mut self, n: i32, init: TableElement) -> Result<()> {
+        let len = n + self.elements.len() as i32;
+        let max = self.kind.size_max.unwrap_or(MAX_TABLE_SIZE) as i32;
 
-            self.elements.resize(new_size, TableElement::Uninitialized);
+        if len > max {
+            return Err(Error::Trap(crate::Trap::TableOutOfBounds {
+                offset: len as usize,
+                len: 1,
+                max: self.elements.len(),
+            }));
         }
+
+        self.elements.resize(len as usize, init);
         Ok(())
     }
 
@@ -186,15 +209,21 @@ mod tests {
         let kind = dummy_table_type();
         let mut table_instance = TableInstance::new(kind, 0);
 
-        table_instance.set(0, 0).expect("Setting table element failed");
+        table_instance.set(0, TableElement::Initialized(0)).expect("Setting table element failed");
+        table_instance.set(1, TableElement::Uninitialized).expect("Setting table element failed");
 
         match table_instance.get_wasm_val(0) {
             Ok(WasmValue::RefFunc(_)) => {}
             _ => assert!(false, "get_wasm_val failed to return the correct WasmValue"),
         }
 
+        match table_instance.get_wasm_val(1) {
+            Ok(WasmValue::RefNull(ValType::RefFunc)) => {}
+            _ => assert!(false, "get_wasm_val failed to return the correct WasmValue"),
+        }
+
         match table_instance.get_wasm_val(999) {
-            Err(Error::Trap(Trap::UndefinedElement { .. })) => {}
+            Err(Error::Trap(Trap::TableOutOfBounds { .. })) => {}
             _ => assert!(false, "get_wasm_val failed to handle undefined element correctly"),
         }
     }
@@ -204,7 +233,7 @@ mod tests {
         let kind = dummy_table_type();
         let mut table_instance = TableInstance::new(kind, 0);
 
-        let result = table_instance.set(0, 1);
+        let result = table_instance.set(0, TableElement::Initialized(1));
         assert!(result.is_ok(), "Setting table element failed");
 
         let elem = table_instance.get(0);
@@ -219,7 +248,7 @@ mod tests {
         let kind = dummy_table_type();
         let mut table_instance = TableInstance::new(kind, 0);
 
-        let result = table_instance.set(15, 1);
+        let result = table_instance.set(15, TableElement::Initialized(1));
         assert!(result.is_ok(), "Table grow on set failed");
 
         let size = table_instance.size();
diff --git a/crates/tinywasm/tests/generated/2.0.csv b/crates/tinywasm/tests/generated/2.0.csv
