Implement bulk-memory Wasm proposal

crates/arena/src/lib.rs

@@ -32,6 +32,7 @@ mod tests;
 pub use self::{component_vec::ComponentVec, dedup::DedupArena, guarded::GuardedEntity};
 use alloc::vec::Vec;
 use core::{
+    cmp::max,
     iter::{DoubleEndedIterator, Enumerate, ExactSizeIterator},
     marker::PhantomData,
     ops::{Index, IndexMut},
@@ -149,6 +150,21 @@ where
     pub fn get_mut(&mut self, index: Idx) -> Option<&mut T> {
         self.entities.get_mut(index.into_usize())
     }
+
+    /// Returns an exclusive reference to the pair of entities at the given indices if any.
+    ///
+    /// Returns `None` if `fst` and `snd` refer to the same entity.
+    /// Returns `None` if either `fst` or `snd` is invalid for this [`Arena`].
+    #[inline]
+    pub fn get_pair_mut(&mut self, fst: Idx, snd: Idx) -> Option<(&mut T, &mut T)> {
+        let fst_index = fst.into_usize();
+        let snd_index = snd.into_usize();
+        let max_index = max(fst_index, snd_index);
+        let (fst_set, snd_set) = self.entities.split_at_mut(max_index);
+        let fst = fst_set.get_mut(fst_index)?;
+        let snd = snd_set.get_mut(0)?;
+        Some((fst, snd))
+    }
 }
 
 impl<Idx, T> FromIterator<T> for Arena<Idx, T> {

crates/wasmi/src/element.rs

@@ -0,0 +1,100 @@
+use crate::{module, module::FuncIdx, store::Stored, AsContextMut};
+use alloc::sync::Arc;
+use wasmi_arena::ArenaIndex;
+
+/// A raw index to a element segment entity.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ElementSegmentIdx(u32);
+
+impl ArenaIndex for ElementSegmentIdx {
+    fn into_usize(self) -> usize {
+        self.0 as usize
+    }
+
+    fn from_usize(value: usize) -> Self {
+        let value = value.try_into().unwrap_or_else(|error| {
+            panic!("index {value} is out of bounds as element segment index: {error}")
+        });
+        Self(value)
+    }
+}
+
+/// A Wasm data segment reference.
+#[derive(Debug, Copy, Clone)]
+#[repr(transparent)]
+pub struct ElementSegment(Stored<ElementSegmentIdx>);
+
+impl ElementSegment {
+    /// Creates a new linear memory reference.
+    pub fn from_inner(stored: Stored<ElementSegmentIdx>) -> Self {
+        Self(stored)
+    }
+
+    /// Returns the underlying stored representation.
+    pub fn as_inner(&self) -> &Stored<ElementSegmentIdx> {
+        &self.0
+    }
+
+    /// Allocates a new [`ElementSegment`] on the store.
+    ///
+    /// # Errors
+    ///
+    /// If more than [`u32::MAX`] much linear memory is allocated.
+    pub fn new(mut ctx: impl AsContextMut, segment: &module::ElementSegment) -> Self {
+        let entity = ElementSegmentEntity::from(segment);
+        ctx.as_context_mut()
+            .store
+            .inner
+            .alloc_element_segment(entity)
+    }
+}
+
+/// An instantiated [`ElementSegmentEntity`].
+///
+/// # Note
+///
+/// With the `bulk-memory` Wasm proposal it is possible to interact
+/// with element segments at runtime. Therefore Wasm instances now have
+/// a need to have an instantiated representation of data segments.
+#[derive(Debug)]
+pub struct ElementSegmentEntity {
+    /// The underlying items of the instance element segment.
+    ///
+    /// # Note
+    ///
+    /// These items are just readable after instantiation.
+    /// Using Wasm `elem.drop` simply replaces the instance
+    /// with an empty one.
+    items: Option<Arc<[Option<FuncIdx>]>>,
+}
+
+impl From<&'_ module::ElementSegment> for ElementSegmentEntity {
+    fn from(segment: &'_ module::ElementSegment) -> Self {
+        match segment.kind() {
+            module::ElementSegmentKind::Passive => Self {
+                items: Some(segment.clone_items()),
+            },
+            module::ElementSegmentKind::Active(_) => Self::empty(),
+        }
+    }
+}
+
+impl ElementSegmentEntity {
+    /// Create an empty [`ElementSegmentEntity`] representing dropped element segments.
+    fn empty() -> Self {
+        Self { items: None }
+    }
+
+    /// Returns the items of the [`ElementSegmentEntity`].
+    pub fn items(&self) -> &[Option<FuncIdx>] {
+        self.items
+            .as_ref()
+            .map(|items| &items[..])
+            .unwrap_or_else(|| &[])
+    }
+
+    /// Drops the items of the [`ElementSegmentEntity`].
+    pub fn drop_items(&mut self) {
+        self.items = None;
+    }
+}

crates/wasmi/src/engine/bytecode/mod.rs

@@ -8,8 +8,10 @@ mod tests;
 pub use self::utils::{
     BranchOffset,
     BranchParams,
+    DataSegmentIdx,
     DropKeep,
     DropKeepError,
+    ElementSegmentIdx,
     FuncIdx,
     GlobalIdx,
     LocalDepth,
@@ -70,6 +72,13 @@ pub enum Instruction {
     I64Store32(Offset),
     MemorySize,
     MemoryGrow,
+    MemoryFill,
+    MemoryCopy,
+    MemoryInit(DataSegmentIdx),
+    DataDrop(DataSegmentIdx),
+    TableCopy,
+    TableInit(ElementSegmentIdx),
+    ElemDrop(ElementSegmentIdx),
     Const(UntypedValue),
     I32Eqz,
     I32Eq,

crates/wasmi/src/engine/bytecode/utils.rs

@@ -130,7 +130,7 @@ impl LocalDepth {
 ///
 /// Refers to a global variable of a [`Store`].
 ///
-/// [`Store`]: [`crate::v2::Store`]
+/// [`Store`]: [`crate::Store`]
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(transparent)]
 pub struct GlobalIdx(u32);
@@ -148,6 +148,54 @@ impl GlobalIdx {
     }
 }
 
+/// A data segment index.
+///
+/// # Note
+///
+/// Refers to a data segment of a [`Store`].
+///
+/// [`Store`]: [`crate::Store`]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct DataSegmentIdx(u32);
+
+impl From<u32> for DataSegmentIdx {
+    fn from(index: u32) -> Self {
+        Self(index)
+    }
+}
+
+impl DataSegmentIdx {
+    /// Returns the inner `u32` index.
+    pub fn into_inner(self) -> u32 {
+        self.0
+    }
+}
+
+/// An element segment index.
+///
+/// # Note
+///
+/// Refers to a data segment of a [`Store`].
+///
+/// [`Store`]: [`crate::Store`]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct ElementSegmentIdx(u32);
+
+impl From<u32> for ElementSegmentIdx {
+    fn from(index: u32) -> Self {
+        Self(index)
+    }
+}
+
+impl ElementSegmentIdx {
+    /// Returns the inner `u32` index.
+    pub fn into_inner(self) -> u32 {
+        self.0
+    }
+}
+
 /// A linear memory access offset.
 ///
 /// # Note

crates/wasmi/src/engine/cache.rs

@@ -1,5 +1,9 @@
 use crate::{
+    element::{ElementSegment, ElementSegmentEntity},
+    instance::InstanceEntity,
+    memory::DataSegment,
     module::{DEFAULT_MEMORY_INDEX, DEFAULT_TABLE_INDEX},
+    table::TableEntity,
     Func,
     Instance,
     Memory,
@@ -9,6 +13,8 @@ use crate::{
 use core::ptr::NonNull;
 use wasmi_core::UntypedValue;
 
+use super::bytecode::{DataSegmentIdx, ElementSegmentIdx};
+
 /// A cache for frequently used entities of an [`Instance`].
 #[derive(Debug)]
 pub struct InstanceCache {
@@ -63,21 +69,89 @@ impl InstanceCache {
         self.set_instance(instance);
     }
 
+    /// Loads the [`DataSegment`] at `index` of the currently used [`Instance`].
+    ///
+    /// # Panics
+    ///
+    /// If there is no [`DataSegment`] for the [`Instance`] at the `index`.
+    #[inline]
+    pub fn get_data_segment(&mut self, ctx: &mut StoreInner, index: u32) -> DataSegment {
+        let instance = self.instance();
+        ctx.resolve_instance(self.instance())
+            .get_data_segment(index)
+            .unwrap_or_else(|| {
+                panic!("missing data segment ({index:?}) for instance: {instance:?}",)
+            })
+    }
+
+    /// Loads the [`ElementSegment`] at `index` of the currently used [`Instance`].
+    ///
+    /// # Panics
+    ///
+    /// If there is no [`ElementSegment`] for the [`Instance`] at the `index`.
+    #[inline]
+    pub fn get_element_segment(
+        &mut self,
+        ctx: &mut StoreInner,
+        index: ElementSegmentIdx,
+    ) -> ElementSegment {
+        let instance = self.instance();
+        ctx.resolve_instance(self.instance())
+            .get_element_segment(index.into_inner())
+            .unwrap_or_else(|| {
+                panic!("missing element segment ({index:?}) for instance: {instance:?}",)
+            })
+    }
+
+    /// Loads the [`DataSegment`] at `index` of the currently used [`Instance`].
+    ///
+    /// # Panics
+    ///
+    /// If there is no [`DataSegment`] for the [`Instance`] at the `index`.
+    #[inline]
+    pub fn get_default_memory_and_data_segment<'a>(
+        &mut self,
+        ctx: &'a mut StoreInner,
+        segment: DataSegmentIdx,
+    ) -> (&'a mut [u8], &'a [u8]) {
+        let mem = self.default_memory(ctx);
+        let seg = self.get_data_segment(ctx, segment.into_inner());
+        let (memory, segment) = ctx.resolve_memory_mut_and_data_segment(&mem, &seg);
+        (memory.data_mut(), segment.bytes())
+    }
+
+    /// Loads the [`ElementSegment`] at `index` of the currently used [`Instance`].
+    ///
+    /// # Panics
+    ///
+    /// If there is no [`ElementSegment`] for the [`Instance`] at the `index`.
+    #[inline]
+    pub fn get_default_table_and_element_segment<'a>(
+        &mut self,
+        ctx: &'a mut StoreInner,
+        segment: ElementSegmentIdx,
+    ) -> (
+        &'a InstanceEntity,
+        &'a mut TableEntity,
+        &'a ElementSegmentEntity,
+    ) {
+        let tab = self.default_table(ctx);
+        let seg = self.get_element_segment(ctx, segment);
+        let inst = self.instance();
+        ctx.resolve_instance_table_element(inst, &tab, &seg)
+    }
+
     /// Loads the default [`Memory`] of the currently used [`Instance`].
     ///
     /// # Panics
     ///
     /// If the currently used [`Instance`] does not have a default linear memory.
     fn load_default_memory(&mut self, ctx: &StoreInner) -> Memory {
+        let instance = self.instance();
         let default_memory = ctx
-            .resolve_instance(self.instance())
+            .resolve_instance(instance)
             .get_memory(DEFAULT_MEMORY_INDEX)
-            .unwrap_or_else(|| {
-                panic!(
-                    "missing default linear memory for instance: {:?}",
-                    self.instance
-                )
-            });
+            .unwrap_or_else(|| panic!("missing default linear memory for instance: {instance:?}",));
         self.default_memory = Some(default_memory);
         default_memory
     }
@@ -88,10 +162,11 @@ impl InstanceCache {
     ///
     /// If the currently used [`Instance`] does not have a default table.
     fn load_default_table(&mut self, ctx: &StoreInner) -> Table {
+        let instance = self.instance();
         let default_table = ctx
-            .resolve_instance(self.instance())
+            .resolve_instance(instance)
             .get_table(DEFAULT_TABLE_INDEX)
-            .unwrap_or_else(|| panic!("missing default table for instance: {:?}", self.instance));
+            .unwrap_or_else(|| panic!("missing default table for instance: {instance:?}"));
         self.default_table = Some(default_table);
         default_table
     }

crates/wasmi/src/engine/config.rs

@@ -21,6 +21,8 @@ pub struct Config {
     saturating_float_to_int: bool,
     /// Is `true` if the [`multi-value`] Wasm proposal is enabled.
     multi_value: bool,
+    /// Is `true` if the [`bulk-memory`] Wasm proposal is enabled.
+    bulk_memory: bool,
 }
 
 impl Default for Config {
@@ -32,6 +34,7 @@ impl Default for Config {
             sign_extension: true,
             saturating_float_to_int: true,
             multi_value: true,
+            bulk_memory: true,
         }
     }
 }
@@ -112,15 +115,27 @@ impl Config {
         self
     }
 
+    /// Enable or disable the [`bulk-memory`] Wasm proposal for the [`Config`].
+    ///
+    /// # Note
+    ///
+    /// Enabled by default.
+    ///
+    /// [`multi-value`]: https://github.com/WebAssembly/bulk-memory-operations
+    pub fn wasm_bulk_memory(&mut self, enable: bool) -> &mut Self {
+        self.bulk_memory = enable;
+        self
+    }
+
     /// Returns the [`WasmFeatures`] represented by the [`Config`].
     pub fn wasm_features(&self) -> WasmFeatures {
         WasmFeatures {
             multi_value: self.multi_value,
             mutable_global: self.mutable_global,
             saturating_float_to_int: self.saturating_float_to_int,
             sign_extension: self.sign_extension,
+            bulk_memory: self.bulk_memory,
             reference_types: false,
-            bulk_memory: false,
             component_model: false,
             simd: false,
             relaxed_simd: false,