Simplify fetching memory bytes in the executor (#2010)

simplify fetching memory bytes in the executor

Author: Robbepop

crates/wasmi/src/engine/executor/handler/args.rs

@@ -145,19 +145,6 @@ impl Args {
         self.ip = unsafe { self.ip.offset(i32::from(offset) as isize) };
     }
 
-    /// Returns the bytes of the `memory`.
-    #[inline]
-    pub fn fetch_memory_bytes<'a>(
-        &mut self,
-        state: &'a mut VmState,
-        addr: ir::MemoryAddr,
-    ) -> &'a mut [u8] {
-        if utils::is_default_memory(self.instance, addr) {
-            return self.fetch_default_memory_bytes();
-        }
-        self.fetch_memory(state, addr).data_mut()
-    }
-
     /// Returns the bytes of the default memory at index 0.
     #[inline]
     pub fn fetch_default_memory_bytes<'a>(&mut self) -> &'a mut [u8] {

crates/wasmi/src/engine/executor/handler/exec.rs

@@ -2194,7 +2194,7 @@ macro_rules! handler_load_ri {
                         memory,
                     } = unsafe { args.decode_op() };
                     let address = args.get(address);
-                    let bytes = args.fetch_memory_bytes(state, memory);
+                    let bytes = args.fetch_memory(state, memory).data();
                     let loaded = $load(bytes, usize::from(address)).into_control()?;
                     args.set(result, loaded);
                     dispatch!(state, args)
@@ -2353,7 +2353,7 @@ macro_rules! handler_store_ix {
                     } = unsafe { args.decode_op() };
                     let address = args.get(address);
                     let value: $hint = args.get(value);
-                    let bytes = args.fetch_memory_bytes(state, memory);
+                    let bytes = args.fetch_memory(state, memory).data_mut();
                     $store(bytes, usize::from(address), value.into()).into_control()?;
                     dispatch!(state, args)
                 }

crates/wasmi/src/engine/executor/handler/exec/macros.rs

@@ -167,7 +167,7 @@ macro_rules! handler_load {
                     } = unsafe { args.decode_op() };
                     let ptr: u64 = args.get(ptr);
                     let offset: u64 = args.get(offset);
-                    let bytes = args.fetch_memory_bytes(state, memory);
+                    let bytes = args.fetch_memory(state, memory).data();
                     let loaded = $load(bytes, ptr, offset).into_control()?;
                     args.set(result, loaded);
                     dispatch!(state, args)
@@ -235,7 +235,7 @@ macro_rules! handler_store {
                     let ptr = args.get(ptr);
                     let offset = args.get(offset);
                     let value: $hint = args.get(value);
-                    let bytes = args.fetch_memory_bytes(state, memory);
+                    let bytes = args.fetch_memory(state, memory).data_mut();
                     $store(bytes, ptr, offset, value.into()).into_control()?;
                     dispatch!(state, args)
                 }

crates/wasmi/src/engine/executor/handler/exec/simd.rs

@@ -505,7 +505,7 @@ macro_rules! handler_store_lane_ss {
                     let ptr = args.get(ptr);
                     let offset = args.get(offset);
                     let value = args.get(value);
-                    let bytes = args.fetch_memory_bytes(state, memory);
+                    let bytes = args.fetch_memory(state, memory).data_mut();
                     $eval(bytes, ptr, offset, value, lane).into_control()?;
                     dispatch!(state, args)
                 }

crates/wasmi/src/engine/executor/handler/utils.rs

@@ -531,19 +531,13 @@ pub fn exec_copy_span_des(sp: Sp, dst: SlotSpan, src: SlotSpan, len: u16) {
 }
 
 /// Returns `true` if `memory` addresses the default linear memory (Wasm index 0).
-///
-/// # Note
-///
-/// `memory` is an instance address, not the raw Wasm memory index,
-/// so the default memory's address is not guaranteed to be zero.
 #[inline]
-pub fn is_default_memory(instance: Inst, memory: ir::MemoryAddr) -> bool {
-    // SAFETY: `instance` refers to a live instance for the duration of the call.
-    let layout = unsafe { instance.as_ptr().layout() };
-    matches!(
-        layout.memory_addr(0),
-        Some(addr) if u32::from(addr) == u32::from(memory)
-    )
+pub fn is_default_memory(_instance: Inst, memory: ir::MemoryAddr) -> bool {
+    // Note: this returns `true` even if the instance does not contain a memory.
+    //       It is guaranteed that linear memories are placed first in an instance's
+    //       handle buffer, therefore `MemoryAddr(0)` always refers to the default
+    //       memory if one exists.
+    u32::from(memory) == 0
 }
 
 pub fn extract_mem0(_store: &mut PrunedStore, inst: Inst) -> (Mem0Ptr, Mem0Len) {