table: Add table.fill and table.init

This commit introduces support for WebAssembly 2.0 (Draft
2025-01-28)[1] bulk table operations, specifically `table.fill` and
`table.init`.

These methods allow for efficient filling and initialization of table
ranges.

The implementation includes bounds-checked `fill` and `init`
operations in `VMTable` for low-level functionality, with these
methods exposed through the `Table` abstraction and system backend for
consistent API access. These additions align with WebAssembly 2.0's
bulk memory and table instructions (Section 7.6).

[1]: https://webassembly.github.io/spec/core/bikeshed/#bulk-memory-and-table-instructions%E2%91%A0

Signed-off-by: Charalampos Mitrodimas <[email protected]>

Author: charmitro

lib/api/src/backend/sys/entities/table.rs

@@ -132,6 +132,45 @@ impl Table {
             .ok_or_else(|| RuntimeError::new(format!("failed to grow table by `{delta}`")))
     }
 
+    pub(crate) fn fill(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        len: u32,
+        value: Value,
+    ) -> Result<(), RuntimeError> {
+        let item = value_to_table_element(store, value)?;
+        let obj_mut = store.objects_mut().as_sys_mut();
+
+        self.handle
+            .get_mut(obj_mut)
+            .fill(index, len, item)
+            .map_err(Into::<RuntimeError>::into)?;
+        Ok(())
+    }
+
+    pub(crate) fn init(
+        &self,
+        store: &mut impl AsStoreMut,
+        dst_index: u32,
+        src_index: u32,
+        len: u32,
+        values: &[Value],
+    ) -> Result<(), RuntimeError> {
+        let mut table_elements = Vec::with_capacity(len as usize);
+        for value in &values[src_index as usize..(src_index + len) as usize] {
+            table_elements.push(value_to_table_element(store, value.clone())?);
+        }
+        let obj_mut = store.objects_mut().as_sys_mut();
+
+        self.handle
+            .get_mut(obj_mut)
+            .init(dst_index, src_index, len, &table_elements)
+            .map_err(Into::<RuntimeError>::into)?;
+
+        Ok(())
+    }
+
     pub(crate) fn copy(
         store: &mut impl AsStoreMut,
         dst_table: &Self,

lib/api/src/entities/table/inner.rs

@@ -119,6 +119,43 @@ impl BackendTable {
         })
     }
 
+    /// Fills `len` elements starting at `index` with the provided `value`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds for the table.
+    #[inline]
+    pub fn fill(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        len: u32,
+        value: Value,
+    ) -> Result<(), RuntimeError> {
+        match_rt!(on self => s {
+            s.fill(store, index, len, value)
+        })
+    }
+
+    /// Initializes `len` elements at `dst_index` with values from `values[src_index..]`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds for the table or values.
+    #[inline]
+    pub fn init(
+        &self,
+        store: &mut impl AsStoreMut,
+        dst_index: u32,
+        src_index: u32,
+        len: u32,
+        values: &[Value],
+    ) -> Result<(), RuntimeError> {
+        match_rt!(on self => s {
+            s.init(store, dst_index, src_index, len, values)
+        })
+    }
+
     /// Copies the `len` elements of `src_table` starting at `src_index`
     /// to the destination table `dst_table` at index `dst_index`.
     ///

lib/api/src/entities/table/mod.rs

@@ -98,6 +98,37 @@ impl Table {
         BackendTable::copy(store, &dst_table.0, dst_index, &src_table.0, src_index, len)
     }
 
+    /// Fills `len` elements in the table starting at `index` with `value`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds or `value` mismatches the table type.
+    pub fn fill(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        len: u32,
+        value: Value,
+    ) -> Result<(), RuntimeError> {
+        self.0.fill(store, index, len, value)
+    }
+
+    /// Initializes `len` elements in the table at `dst_index` from `values[src_index..]`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the table or segment range is out of bounds or values mismatch the table type.
+    pub fn init(
+        &self,
+        store: &mut impl AsStoreMut,
+        dst_index: u32,
+        src_index: u32,
+	len: u32,
+	values: &[Value],
+    ) -> Result<(), RuntimeError> {
+        self.0.init(store, dst_index, src_index, len, values)
+    }
+
     pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, ext: VMExternTable) -> Self {
         Self(BackendTable::from_vm_extern(store, ext))
     }

lib/vm/src/table.rs

@@ -347,4 +347,43 @@ impl VMTable {
 
         Ok(())
     }
+
+    /// Fill `len` elements starting at `index` with the given `value`.
+    ///
+    /// # Errors
+    /// Returns an error if the range is out of bounds.
+    pub fn fill(&mut self, index: u32, len: u32, value: TableElement) -> Result<(), Trap> {
+	if index.checked_add(len).map_or(true, |n| n > self.size()) {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+	}
+	for i in index..index + len {
+            self.set(i, value.clone())?;
+	}
+	Ok(())
+    }
+
+    /// Initialize a range of the table with elements from an element segment.
+    ///
+    /// # Errors
+    /// Returns an error if:
+    /// - The range is out of bounds of the table.
+    /// - The segment range is out of bounds of the provided elements.
+    pub fn init(
+	&mut self,
+	dst_index: u32,
+	src_index: u32,
+	len: u32,
+	elements: &[TableElement],
+    ) -> Result<(), Trap> {
+	if dst_index.checked_add(len).map_or(true, |n| n > self.size()) {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+	}
+	if src_index.checked_add(len).map_or(true, |n| n > elements.len() as u32) {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+	}
+	for (dst, src) in (dst_index..dst_index + len).zip(src_index..src_index + len) {
+            self.set(dst, elements[src as usize].clone())?;
+	}
+	Ok(())
+    }
 }