add memory.{size,grow} execution handlers

Author: Robbepop

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

@@ -366,6 +366,9 @@ pub fn op_code_to_handler(code: OpCode) -> Handler {
         OpCode::CallInternal => exec::call_internal,
         OpCode::CallImported => exec::call_imported,
         OpCode::CallIndirect => exec::call_indirect,
+        // memory
+        OpCode::MemorySize => exec::memory_size,
+        OpCode::MemoryGrow => exec::memory_grow,
         // unconditional branch
         OpCode::Branch => exec::branch,
         // unary

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

@@ -12,19 +12,22 @@ use crate::{
             utils::{
                 exec_copy_span_asc,
                 exec_copy_span_des,
+                extract_mem0,
                 resolve_global,
                 resolve_indirect_func,
+                resolve_memory,
                 set_global,
                 update_instance,
             },
         },
         EngineFunc,
     },
-    errors::FuelError,
+    errors::{FuelError, MemoryError},
     func::FuncEntity,
     instance::InstanceEntity,
     ir,
     ir::{Slot, SlotSpan},
+    TrapCode,
 };
 use core::ptr::NonNull;
 
@@ -355,6 +358,79 @@ handler_return! {
     fn return64(Return64) = identity::<u64>;
 }
 
+pub fn memory_size(
+    state: &mut VmState,
+    ip: Ip,
+    sp: Sp,
+    mem0: Mem0Ptr,
+    mem0_len: Mem0Len,
+    instance: NonNull<InstanceEntity>,
+) -> Done {
+    let (ip, crate::ir::decode::MemorySize { memory, result }) = unsafe { decode_op(ip) };
+    let memory = resolve_memory(instance, memory);
+    let size = state.store.inner().resolve_memory(&memory).size();
+    set_value(sp, result, size);
+    dispatch!(state, ip, sp, mem0, mem0_len, instance)
+}
+
+pub fn memory_grow(
+    state: &mut VmState,
+    ip: Ip,
+    sp: Sp,
+    mem0: Mem0Ptr,
+    mem0_len: Mem0Len,
+    instance: NonNull<InstanceEntity>,
+) -> Done {
+    let (
+        ip,
+        crate::ir::decode::MemoryGrow {
+            memory,
+            result,
+            delta,
+        },
+    ) = unsafe { decode_op(ip) };
+    let delta: u64 = get_value(delta, sp);
+    let memref = resolve_memory(instance, memory);
+    let mut mem0 = mem0;
+    let mut mem0_len = mem0_len;
+    let return_value = match state.store.grow_memory(&memref, delta) {
+        Ok(return_value) => {
+            // The `memory.grow` operation might have invalidated the cached
+            // linear memory so we need to reset it in order for the cache to
+            // reload in case it is used again.
+            if memory.is_default() {
+                (mem0, mem0_len) = extract_mem0(state.store, instance);
+            }
+            return_value
+        }
+        Err(MemoryError::OutOfBoundsGrowth | MemoryError::OutOfSystemMemory) => {
+            let memory_ty = state.store.inner().resolve_memory(&memref).ty();
+            match memory_ty.is_64() {
+                true => u64::MAX,
+                false => u64::from(u32::MAX),
+            }
+        }
+        Err(MemoryError::OutOfFuel { required_fuel }) => {
+            state.done(DoneReason::OutOfFuel { required_fuel });
+            return exec_break!(ip, sp, mem0, mem0_len, instance);
+        }
+        Err(MemoryError::ResourceLimiterDeniedAllocation) => {
+            break_with_trap!(
+                TrapCode::GrowthOperationLimited,
+                state,
+                ip,
+                sp,
+                mem0,
+                mem0_len,
+                instance
+            )
+        }
+        Err(error) => panic!("encountered an unexpected error: {error}"),
+    };
+    set_value(sp, result, return_value);
+    dispatch!(state, ip, sp, mem0, mem0_len, instance)
+}
+
 macro_rules! handler_unary {
     ( $( fn $handler:ident($op:ident) = $eval:expr );* $(;)? ) => {
         $(

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

@@ -8,6 +8,7 @@ use crate::{
     Error,
     Func,
     Global,
+    Memory,
     Ref,
     Table,
     TrapCode,
@@ -159,7 +160,10 @@ pub fn exec_copy_span_des(sp: Sp, dst: SlotSpan, src: SlotSpan, len: u16) {
     }
 }
 
-pub fn extract_mem0(store: &mut PrunedStore, instance: NonNull<InstanceEntity>) -> (Mem0Ptr, Mem0Len) {
+pub fn extract_mem0(
+    store: &mut PrunedStore,
+    instance: NonNull<InstanceEntity>,
+) -> (Mem0Ptr, Mem0Len) {
     let instance = unsafe { instance.as_ref() };
     let Some(memory) = instance.get_memory(0) else {
         return (Mem0Ptr::from([].as_mut_ptr()), Mem0Len::from(0));
@@ -213,6 +217,14 @@ pub fn resolve_global(instance: NonNull<InstanceEntity>, global: index::Global)
     global
 }
 
+pub fn resolve_memory(instance: NonNull<InstanceEntity>, memory: index::Memory) -> Memory {
+    let inst = unsafe { instance.as_ref() };
+    let Some(memory) = inst.get_memory(u32::from(u16::from(memory))) else {
+        unreachable!("missing memory at: {}", u16::from(memory))
+    };
+    memory
+}
+
 pub fn resolve_table(instance: NonNull<InstanceEntity>, table: index::Table) -> Table {
     let inst = unsafe { instance.as_ref() };
     let Some(table) = inst.get_table(u32::from(table)) else {