feat: Bulk Memory Operations Proposal

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

Author: explodingcamera

README.md

@@ -12,7 +12,7 @@
 
 # Status
 
-TinyWasm, starting from version `0.3.0`, passes all the WebAssembly 1.0 tests in the [WebAssembly Test Suite](https://github.com/WebAssembly/testsuite). The 2.0 tests are in progress (notably `simd` and `bulk-memory-operations` are not implemented yet). This is enough to run most WebAssembly programs, including TinyWasm itself compiled to WebAssembly (see [examples/wasm-rust.rs](./examples/wasm-rust.rs)).
+TinyWasm, starting from version `0.3.0`, passes all the WebAssembly 1.0 tests in the [WebAssembly Test Suite](https://github.com/WebAssembly/testsuite). The 2.0 tests are in progress. This is enough to run most WebAssembly programs, including TinyWasm itself compiled to WebAssembly (see [examples/wasm-rust.rs](./examples/wasm-rust.rs)).
 
 Some APIs to interact with the runtime are not yet exposed, and the existing ones are subject to change, but the core functionality is mostly complete.
 Results of the tests can be found [here](https://github.com/explodingcamera/tinywasm/tree/main/crates/tinywasm/tests/generated).
@@ -24,7 +24,7 @@ TinyWasm is not designed for performance, but rather for size and portability. H
 - [**Mutable Globals**](https://github.com/WebAssembly/mutable-global/blob/master/proposals/mutable-global/Overview.md) - **Fully implemented**
 - [**Multi-value**](https://github.com/WebAssembly/spec/blob/master/proposals/multi-value/Overview.md) - **Fully implemented**
 - [**Sign-extension operators**](https://github.com/WebAssembly/spec/blob/master/proposals/sign-extension-ops/Overview.md) - **Fully implemented**
-- [**Bulk Memory Operations**](https://github.com/WebAssembly/spec/blob/master/proposals/bulk-memory-operations/Overview.md) - **_Partially implemented_**
+- [**Bulk Memory Operations**](https://github.com/WebAssembly/spec/blob/master/proposals/bulk-memory-operations/Overview.md) - **Fully implemented** (as of version `0.4.0`)
 - [**Reference Types**](https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md) - **_Partially implemented_**
 - [**Multiple Memories**](https://github.com/WebAssembly/multi-memory/blob/master/proposals/multi-memory/Overview.md) - **_Partially implemented_** (not tested yet)
 - [**Memory64**](https://github.com/WebAssembly/memory64/blob/master/proposals/memory64/Overview.md) - **_Partially implemented_** (only 32-bit addressing is supported at the moment, but larger memories can be created)

crates/parser/src/conversion.rs

@@ -107,7 +107,6 @@ pub(crate) fn convert_module_tables<T: IntoIterator<Item = wasmparser::Result<wa
     table_types: T,
 ) -> Result<Vec<TableType>> {
     let table_type = table_types.into_iter().map(|table| convert_module_table(table?)).collect::<Result<Vec<_>>>()?;
-
     Ok(table_type)
 }
 

crates/parser/src/module.rs

@@ -112,7 +112,6 @@ impl ModuleReader {
                 if !self.table_types.is_empty() {
                     return Err(ParseError::DuplicateSection("Table section".into()));
                 }
-
                 debug!("Found table section");
                 validator.table_section(&reader)?;
                 self.table_types = conversion::convert_module_tables(reader)?;
@@ -140,6 +139,13 @@ impl ModuleReader {
                 validator.data_section(&reader)?;
                 self.data = conversion::convert_module_data_sections(reader)?;
             }
+            DataCountSection { count, range } => {
+                debug!("Found data count section");
+                if !self.data.is_empty() {
+                    return Err(ParseError::DuplicateSection("Data count section".into()));
+                }
+                validator.data_count_section(count, &range)?;
+            }
             CodeSectionStart { count, range, .. } => {
                 debug!("Found code section ({} functions)", count);
                 if !self.code.is_empty() {

crates/tinywasm/src/imports.rs

@@ -62,13 +62,13 @@ pub struct FuncContext<'a> {
 }
 
 impl FuncContext<'_> {
-    /// Get a mutable reference to the store
-    pub fn store_mut(&mut self) -> &mut crate::Store {
+    /// Get a reference to the store
+    pub fn store(&self) -> &crate::Store {
         self.store
     }
 
-    /// Get a reference to the store
-    pub fn store(&self) -> &crate::Store {
+    /// Get a mutable reference to the store
+    pub fn store_mut(&mut self) -> &mut crate::Store {
         self.store
     }
 
@@ -78,9 +78,14 @@ impl FuncContext<'_> {
     }
 
     /// Get a reference to an exported memory
-    pub fn memory(&mut self, name: &str) -> Result<crate::MemoryRef> {
+    pub fn exported_memory(&mut self, name: &str) -> Result<crate::MemoryRef<'_>> {
         self.module().exported_memory(self.store, name)
     }
+
+    /// Get a reference to an exported memory
+    pub fn exported_memory_mut(&mut self, name: &str) -> Result<crate::MemoryRefMut<'_>> {
+        self.module().exported_memory_mut(self.store, name)
+    }
 }
 
 impl Debug for HostFunction {

crates/tinywasm/src/instance.rs

@@ -3,7 +3,7 @@ use tinywasm_types::*;
 
 use crate::{
     func::{FromWasmValueTuple, IntoWasmValueTuple},
-    log, Error, FuncHandle, FuncHandleTyped, Imports, MemoryRef, Module, Result, Store,
+    log, Error, FuncHandle, FuncHandleTyped, Imports, MemoryRef, MemoryRefMut, Module, Result, Store,
 };
 
 /// An instanciated WebAssembly module
@@ -152,6 +152,11 @@ impl ModuleInstance {
         *self.0.mem_addrs.get(addr as usize).expect("No mem addr for mem, this is a bug")
     }
 
+    // resolve a data address to the global store address
+    pub(crate) fn resolve_data_addr(&self, addr: DataAddr) -> MemAddr {
+        *self.0.data_addrs.get(addr as usize).expect("No data addr for data, this is a bug")
+    }
+
     // resolve a memory address to the global store address
     pub(crate) fn resolve_elem_addr(&self, addr: ElemAddr) -> ElemAddr {
         *self.0.elem_addrs.get(addr as usize).expect("No elem addr for elem, this is a bug")
@@ -190,7 +195,7 @@ impl ModuleInstance {
     }
 
     /// Get an exported memory by name
-    pub fn exported_memory(&self, store: &mut Store, name: &str) -> Result<MemoryRef> {
+    pub fn exported_memory<'a>(&self, store: &'a mut Store, name: &str) -> Result<MemoryRef<'a>> {
         let export = self.export_addr(name).ok_or_else(|| Error::Other(format!("Export not found: {}", name)))?;
         let ExternVal::Memory(mem_addr) = export else {
             return Err(Error::Other(format!("Export is not a memory: {}", name)));
@@ -199,11 +204,28 @@ impl ModuleInstance {
         Ok(mem)
     }
 
+    /// Get an exported memory by name
+    pub fn exported_memory_mut<'a>(&self, store: &'a mut Store, name: &str) -> Result<MemoryRefMut<'a>> {
+        let export = self.export_addr(name).ok_or_else(|| Error::Other(format!("Export not found: {}", name)))?;
+        let ExternVal::Memory(mem_addr) = export else {
+            return Err(Error::Other(format!("Export is not a memory: {}", name)));
+        };
+        let mem = self.memory_mut(store, mem_addr)?;
+        Ok(mem)
+    }
+
     /// Get a memory by address
-    pub fn memory(&self, store: &Store, addr: MemAddr) -> Result<MemoryRef> {
+    pub fn memory<'a>(&self, store: &'a mut Store, addr: MemAddr) -> Result<MemoryRef<'a>> {
+        let addr = self.resolve_mem_addr(addr);
+        let mem = store.get_mem(addr as usize)?;
+        Ok(MemoryRef { instance: mem.borrow() })
+    }
+
+    /// Get a memory by address (mutable)
+    pub fn memory_mut<'a>(&self, store: &'a mut Store, addr: MemAddr) -> Result<MemoryRefMut<'a>> {
         let addr = self.resolve_mem_addr(addr);
         let mem = store.get_mem(addr as usize)?;
-        Ok(MemoryRef { instance: mem.clone() })
+        Ok(MemoryRefMut { instance: mem.borrow_mut() })
     }
 
     /// Get the start function of the module

crates/tinywasm/src/reference.rs

@@ -1,5 +1,5 @@
 use core::{
-    cell::{Ref, RefCell},
+    cell::{Ref, RefCell, RefMut},
     ffi::CStr,
 };
 
@@ -15,91 +15,121 @@ use tinywasm_types::WasmValue;
 // This module essentially contains the public APIs to interact with the data stored in the store
 
 /// A reference to a memory instance
-#[derive(Debug, Clone)]
-pub struct MemoryRef {
-    pub(crate) instance: Rc<RefCell<MemoryInstance>>,
+#[derive(Debug)]
+pub struct MemoryRef<'a> {
+    pub(crate) instance: Ref<'a, MemoryInstance>,
 }
 
 /// A borrowed reference to a memory instance
 #[derive(Debug)]
-pub struct BorrowedMemory<'a> {
-    pub(crate) instance: Ref<'a, MemoryInstance>,
+pub struct MemoryRefMut<'a> {
+    pub(crate) instance: RefMut<'a, MemoryInstance>,
 }
 
-impl<'a> BorrowedMemory<'a> {
+impl<'a> MemoryRefLoad for MemoryRef<'a> {
     /// Load a slice of memory
-    pub fn load(&self, offset: usize, len: usize) -> Result<&[u8]> {
+    fn load(&self, offset: usize, len: usize) -> Result<&[u8]> {
         self.instance.load(offset, 0, len)
     }
+}
 
-    /// Load a C-style string from memory
-    pub fn load_cstr(&self, offset: usize, len: usize) -> Result<&CStr> {
-        let bytes = self.load(offset, len)?;
-        CStr::from_bytes_with_nul(bytes).map_err(|_| crate::Error::Other("Invalid C-style string".to_string()))
+impl<'a> MemoryRefLoad for MemoryRefMut<'a> {
+    /// Load a slice of memory
+    fn load(&self, offset: usize, len: usize) -> Result<&[u8]> {
+        self.instance.load(offset, 0, len)
     }
+}
 
-    /// Load a C-style string from memory, stopping at the first nul byte
-    pub fn load_cstr_until_nul(&self, offset: usize, max_len: usize) -> Result<&CStr> {
-        let bytes = self.load(offset, max_len)?;
-        CStr::from_bytes_until_nul(bytes).map_err(|_| crate::Error::Other("Invalid C-style string".to_string()))
+impl MemoryRef<'_> {
+    /// Load a slice of memory
+    pub fn load(&self, offset: usize, len: usize) -> Result<&[u8]> {
+        self.instance.load(offset, 0, len)
     }
-}
 
-impl MemoryRef {
-    /// Borrow the memory instance
-    ///
-    /// This is useful for when you want to load only a reference to a slice of memory
-    /// without copying the data. The borrow should be dropped before any other memory
-    /// operations are performed.
-    pub fn borrow(&self) -> BorrowedMemory<'_> {
-        BorrowedMemory { instance: self.instance.borrow() }
+    /// Load a slice of memory as a vector
+    pub fn load_vec(&self, offset: usize, len: usize) -> Result<Vec<u8>> {
+        self.load(offset, len).map(|x| x.to_vec())
     }
+}
 
+impl MemoryRefMut<'_> {
     /// Load a slice of memory
+    pub fn load(&self, offset: usize, len: usize) -> Result<&[u8]> {
+        self.instance.load(offset, 0, len)
+    }
+
+    /// Load a slice of memory as a vector
     pub fn load_vec(&self, offset: usize, len: usize) -> Result<Vec<u8>> {
-        self.instance.borrow().load(offset, 0, len).map(|x| x.to_vec())
+        self.load(offset, len).map(|x| x.to_vec())
     }
 
     /// Grow the memory by the given number of pages
-    pub fn grow(&self, delta_pages: i32) -> Option<i32> {
-        self.instance.borrow_mut().grow(delta_pages)
+    pub fn grow(&mut self, delta_pages: i32) -> Option<i32> {
+        self.instance.grow(delta_pages)
     }
 
     /// Get the current size of the memory in pages
-    pub fn page_count(&self) -> usize {
-        self.instance.borrow().page_count()
+    pub fn page_count(&mut self) -> usize {
+        self.instance.page_count()
     }
 
     /// Copy a slice of memory to another place in memory
-    pub fn copy_within(&self, src: usize, dst: usize, len: usize) -> Result<()> {
-        self.instance.borrow_mut().copy_within(src, dst, len)
+    pub fn copy_within(&mut self, src: usize, dst: usize, len: usize) -> Result<()> {
+        self.instance.copy_within(src, dst, len)
     }
 
     /// Fill a slice of memory with a value
-    pub fn fill(&self, offset: usize, len: usize, val: u8) -> Result<()> {
-        self.instance.borrow_mut().fill(offset, len, val)
+    pub fn fill(&mut self, offset: usize, len: usize, val: u8) -> Result<()> {
+        self.instance.fill(offset, len, val)
+    }
+
+    /// Store a slice of memory
+    pub fn store(&mut self, offset: usize, len: usize, data: &[u8]) -> Result<()> {
+        self.instance.store(offset, 0, data, len)
+    }
+}
+
+#[doc(hidden)]
+pub trait MemoryRefLoad {
+    fn load(&self, offset: usize, len: usize) -> Result<&[u8]>;
+    fn load_vec(&self, offset: usize, len: usize) -> Result<Vec<u8>> {
+        self.load(offset, len).map(|x| x.to_vec())
+    }
+}
+
+/// Convenience methods for loading strings from memory
+pub trait MemoryStringExt: MemoryRefLoad {
+    /// Load a C-style string from memory
+    fn load_cstr(&self, offset: usize, len: usize) -> Result<&CStr> {
+        let bytes = self.load(offset, len)?;
+        CStr::from_bytes_with_nul(bytes).map_err(|_| crate::Error::Other("Invalid C-style string".to_string()))
+    }
+
+    /// Load a C-style string from memory, stopping at the first nul byte
+    fn load_cstr_until_nul(&self, offset: usize, max_len: usize) -> Result<&CStr> {
+        let bytes = self.load(offset, max_len)?;
+        CStr::from_bytes_until_nul(bytes).map_err(|_| crate::Error::Other("Invalid C-style string".to_string()))
     }
 
     /// Load a UTF-8 string from memory
-    pub fn load_string(&self, offset: usize, len: usize) -> Result<String> {
-        let bytes = self.load_vec(offset, len)?;
-        String::from_utf8(bytes).map_err(|_| crate::Error::Other("Invalid UTF-8 string".to_string()))
+    fn load_string(&self, offset: usize, len: usize) -> Result<String> {
+        let bytes = self.load(offset, len)?;
+        String::from_utf8(bytes.to_vec()).map_err(|_| crate::Error::Other("Invalid UTF-8 string".to_string()))
     }
 
     /// Load a C-style string from memory
-    pub fn load_cstring(&self, offset: usize, len: usize) -> Result<CString> {
-        Ok(CString::from(self.borrow().load_cstr(offset, len)?))
+    fn load_cstring(&self, offset: usize, len: usize) -> Result<CString> {
+        Ok(CString::from(self.load_cstr(offset, len)?))
     }
 
     /// Load a C-style string from memory, stopping at the first nul byte
-    pub fn load_cstring_until_nul(&self, offset: usize, max_len: usize) -> Result<CString> {
-        Ok(CString::from(self.borrow().load_cstr_until_nul(offset, max_len)?))
+    fn load_cstring_until_nul(&self, offset: usize, max_len: usize) -> Result<CString> {
+        Ok(CString::from(self.load_cstr_until_nul(offset, max_len)?))
     }
 
     /// Load a JavaScript-style utf-16 string from memory
-    pub fn load_js_string(&self, offset: usize, len: usize) -> Result<String> {
-        let memref = self.borrow();
-        let bytes = memref.load(offset, len)?;
+    fn load_js_string(&self, offset: usize, len: usize) -> Result<String> {
+        let bytes = self.load(offset, len)?;
         let mut string = String::new();
         for i in 0..(len / 2) {
             let c = u16::from_le_bytes([bytes[i * 2], bytes[i * 2 + 1]]);
@@ -109,13 +139,11 @@ impl MemoryRef {
         }
         Ok(string)
     }
-
-    /// Store a slice of memory
-    pub fn store(&self, offset: usize, len: usize, data: &[u8]) -> Result<()> {
-        self.instance.borrow_mut().store(offset, 0, data, len)
-    }
 }
 
+impl MemoryStringExt for MemoryRef<'_> {}
+impl MemoryStringExt for MemoryRefMut<'_> {}
+
 /// A reference to a global instance
 #[derive(Debug, Clone)]
 pub struct GlobalRef {

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

@@ -418,12 +418,39 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M
             mem.fill(dst as usize, size as usize, val as u8)?;
         }
 
-        // MemoryInit(data_index, mem_index) => {}
-        // DataDrop(data_index) => {
-        //     // let data_idx = module.resolve_data_addr(*data_index);
-        //     // let data = store.get_data(data_idx as usize)?;
-        //     // data.borrow_mut().drop()?;
-        // }
+        MemoryInit(data_index, mem_index) => {
+            let size = stack.values.pop_t::<i32>()? as usize;
+            let offset = stack.values.pop_t::<i32>()? as usize;
+            let dst = stack.values.pop_t::<i32>()? as usize;
+
+            let data_idx = module.resolve_data_addr(*data_index);
+            let Some(ref data) = store.get_data(data_idx as usize)?.data else {
+                cold();
+                return Err(Trap::MemoryOutOfBounds { offset: 0, len: 0, max: 0 }.into());
+            };
+
+            let mem_idx = module.resolve_mem_addr(*mem_index);
+            let mem = store.get_mem(mem_idx as usize)?;
+
+            let data_len = data.len();
+            if offset + size > data_len {
+                cold();
+                return Err(Trap::MemoryOutOfBounds { offset, len: size, max: data_len }.into());
+            }
+
+            let mut mem = mem.borrow_mut();
+            let data = &data[offset..(offset + size)];
+
+            // mem.store checks bounds
+            mem.store(dst, 0, data, size)?;
+        }
+
+        DataDrop(data_index) => {
+            let data_idx = module.resolve_data_addr(*data_index);
+            let data = store.get_data_mut(data_idx as usize)?;
+            data.drop();
+        }
+
         I32Store(arg) => mem_store!(i32, arg, stack, store, module),
         I64Store(arg) => mem_store!(i64, arg, stack, store, module),
         F32Store(arg) => mem_store!(f32, arg, stack, store, module),