wip: better bulk memory support

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

Author: explodingcamera

benchmarks/benches/argon2id.rs

@@ -43,10 +43,10 @@ fn criterion_benchmark(c: &mut Criterion) {
     group.measurement_time(std::time::Duration::from_secs(7));
     group.sample_size(10);
 
-    group.bench_function("native", |b| b.iter(|| run_native(black_box(params))));
+    // group.bench_function("native", |b| b.iter(|| run_native(black_box(params))));
     group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(ARGON2ID, black_box(params), "argon2id")));
-    group.bench_function("wasmi", |b| b.iter(|| run_wasmi(ARGON2ID, black_box(params), "argon2id")));
-    group.bench_function("wasmer", |b| b.iter(|| run_wasmer(ARGON2ID, black_box(params), "argon2id")));
+    // group.bench_function("wasmi", |b| b.iter(|| run_wasmi(ARGON2ID, black_box(params), "argon2id")));
+    // group.bench_function("wasmer", |b| b.iter(|| run_wasmer(ARGON2ID, black_box(params), "argon2id")));
 }
 
 criterion_group!(

crates/parser/src/visit.rs

@@ -534,12 +534,8 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder {
     }
     define_primitive_operands! {
         visit_memory_fill, Instruction::MemoryFill, u32,
-        visit_data_drop, Instruction::DataDrop, u32
-    }
-
-    #[inline(always)]
-    fn visit_elem_drop(&mut self, _elem_index: u32) -> Self::Output {
-        self.unsupported("elem_drop")
+        visit_data_drop, Instruction::DataDrop, u32,
+        visit_elem_drop, Instruction::ElemDrop, u32
     }
 
     #[inline(always)]

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

@@ -102,6 +102,8 @@ impl<'store, 'stack> Executor<'store, 'stack> {
             MemoryFill(addr) => self.exec_memory_fill(*addr)?,
             MemoryInit(data_idx, mem_idx) => self.exec_memory_init(*data_idx, *mem_idx)?,
             DataDrop(data_index) => self.exec_data_drop(*data_index)?,
+            ElemDrop(elem_index) => self.exec_elem_drop(*elem_index)?,
+            TableCopy { from, to } => self.exec_table_copy(*from, *to)?,
 
             I32Store { mem_addr, offset } => mem_store!(i32, (mem_addr, offset), self),
             I64Store { mem_addr, offset } => mem_store!(i64, (mem_addr, offset), self),
@@ -609,6 +611,31 @@ impl<'store, 'stack> Executor<'store, 'stack> {
         Ok(())
     }
 
+    #[inline(always)]
+    fn exec_elem_drop(&mut self, elem_index: u32) -> Result<()> {
+        self.store.get_elem_mut(self.module.resolve_elem_addr(elem_index))?.drop();
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn exec_table_copy(&mut self, from: u32, to: u32) -> Result<()> {
+        let size: i32 = self.stack.values.pop()?.into();
+        let src: i32 = self.stack.values.pop()?.into();
+        let dst: i32 = self.stack.values.pop()?.into();
+
+        if from == to {
+            let mut table_from = self.store.get_table(self.module.resolve_table_addr(from))?.borrow_mut();
+            // copy within the same memory
+            table_from.copy_within(dst as usize, src as usize, size as usize)?;
+        } else {
+            // copy between two memories
+            let table_from = self.store.get_table(self.module.resolve_table_addr(from))?.borrow();
+            let mut table_to = self.store.get_table(self.module.resolve_table_addr(to))?.borrow_mut();
+            table_to.copy_from_slice(dst as usize, table_from.load(src as usize, size as usize)?)?;
+        }
+        Ok(())
+    }
+
     #[inline(always)]
     fn exec_call(&mut self, v: u32) -> Result<ExecResult> {
         let func_inst = self.store.get_func(self.module.resolve_func_addr(v))?;

crates/tinywasm/src/store/element.rs

@@ -16,4 +16,8 @@ impl ElementInstance {
     pub(crate) fn new(kind: ElementKind, owner: ModuleInstanceAddr, items: Option<Vec<TableElement>>) -> Self {
         Self { kind, _owner: owner, items }
     }
+
+    pub(crate) fn drop(&mut self) {
+        self.items.is_some().then(|| self.items.take());
+    }
 }

crates/tinywasm/src/store/mod.rs

@@ -147,6 +147,12 @@ impl Store {
         self.data.elements.get(addr as usize).ok_or_else(|| Self::not_found_error("element"))
     }
 
+    /// Get the element at the actual index in the store
+    #[inline]
+    pub(crate) fn get_elem_mut(&mut self, addr: ElemAddr) -> Result<&mut ElementInstance> {
+        self.data.elements.get_mut(addr as usize).ok_or_else(|| Self::not_found_error("element"))
+    }
+
     /// Get the global at the actual index in the store
     #[inline]
     pub(crate) fn get_global(&self, addr: GlobalAddr) -> Result<&GlobalInstance> {

crates/tinywasm/src/store/table.rs

@@ -20,6 +20,12 @@ impl TableInstance {
         Self { elements: vec![TableElement::Uninitialized; kind.size_initial as usize], kind, _owner: owner }
     }
 
+    #[inline(never)]
+    #[cold]
+    fn trap_oob(&self, addr: usize, len: usize) -> Error {
+        Error::Trap(crate::Trap::TableOutOfBounds { offset: addr, len, max: self.elements.len() })
+    }
+
     pub(crate) fn get_wasm_val(&self, addr: TableAddr) -> Result<WasmValue> {
         let val = self.get(addr)?.addr();
 
@@ -34,6 +40,47 @@ impl TableInstance {
         self.elements.get(addr as usize).ok_or_else(|| Error::Trap(Trap::UndefinedElement { index: addr as usize }))
     }
 
+    pub(crate) fn copy_from_slice(&mut self, dst: usize, src: &[TableElement]) -> Result<()> {
+        let end = dst.checked_add(src.len()).ok_or_else(|| self.trap_oob(dst, src.len()))?;
+
+        if end > self.elements.len() {
+            return Err(self.trap_oob(dst, src.len()));
+        }
+
+        self.elements[dst..end].copy_from_slice(src);
+        Ok(())
+    }
+
+    pub(crate) fn load(&self, addr: usize, len: usize) -> Result<&[TableElement]> {
+        let Some(end) = addr.checked_add(len) else {
+            return Err(self.trap_oob(addr, len));
+        };
+
+        if end > self.elements.len() || end < addr {
+            return Err(self.trap_oob(addr, len));
+        }
+
+        Ok(&self.elements[addr..end])
+    }
+
+    pub(crate) fn copy_within(&mut self, dst: usize, src: usize, len: usize) -> Result<()> {
+        // Calculate the end of the source slice
+        let src_end = src.checked_add(len).ok_or_else(|| self.trap_oob(src, len))?;
+        if src_end > self.elements.len() {
+            return Err(self.trap_oob(src, len));
+        }
+
+        // Calculate the end of the destination slice
+        let dst_end = dst.checked_add(len).ok_or_else(|| self.trap_oob(dst, len))?;
+        if dst_end > self.elements.len() {
+            return Err(self.trap_oob(dst, len));
+        }
+
+        // Perform the copy
+        self.elements.copy_within(src..src_end, dst);
+        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))

crates/tinywasm/tests/generated/2.0.csv

@@ -211,6 +211,7 @@ pub enum Instruction {
     MemoryCopy(MemAddr, MemAddr),
     MemoryFill(MemAddr),
     DataDrop(DataAddr),
+    ElemDrop(ElemAddr),
 }
 
 #[cfg(test)]