Add support for memory/table.grow record and replay

Author: arjunr2

crates/wasmtime/src/runtime/rr/backend/crimp.rs

@@ -137,6 +137,10 @@ rr_event! {
     // REQUIRED events
     /// Return from host function (core or component) to host
     HostFuncReturn(common_events::HostFuncReturnEvent),
+    /// Return value of a memory.grow instruction
+    MemoryGrow(common_events::MemoryGrowEvent),
+    /// Return value of a table.grow instruction
+    TableGrow(common_events::TableGrowEvent),
     // OPTIONAL events
     /// Call into host function from Wasm (core or component)
     HostFuncEntry(common_events::HostFuncEntryEvent),

crates/wasmtime/src/runtime/rr/backend/crimp/events/common_events.rs

@@ -63,6 +63,20 @@ impl Validate<str> for TraceSignatureEvent {
     }
 }
 
+/// A memory.grow return event
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct MemoryGrowEvent {
+    /// Result of the grow
+    pub result: u32,
+}
+
+/// A table.grow return event
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct TableGrowEvent {
+    /// Result of the grow
+    pub result: u32,
+}
+
 /// A diagnostic event for custom String messages.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CustomMessageEvent(pub String);

crates/wasmtime/src/runtime/rr/hooks/core_hooks.rs

@@ -4,7 +4,7 @@ use crate::rr::FlatBytes;
 #[cfg(feature = "rr")]
 use crate::rr::{
     RREvent, RRFuncArgVals, RRFuncArgValsConvertable, ReplayError, Replayer, ResultEvent, Validate,
-    common_events::{HostFuncEntryEvent, HostFuncReturnEvent, WasmFuncReturnEvent},
+    common_events::{HostFuncEntryEvent, HostFuncReturnEvent, MemoryGrowEvent, TableGrowEvent, WasmFuncReturnEvent},
     core_events::{InstantiationEvent, WasmFuncEntryEvent},
 };
 use crate::store::{InstanceId, StoreOpaque};
@@ -215,6 +215,40 @@ pub fn record_and_replay_validate_instantiation<T: 'static>(
     Ok(())
 }
 
+/// Record and replay hook for memory.grow return value
+#[inline]
+pub fn record_and_replay_validate_memory_grow(
+    result: u32,
+    store: &mut StoreOpaque,
+) -> Result<()> {
+    let _ = (result, &store);
+    #[cfg(feature = "rr")]
+    {
+        store.record_event(|| MemoryGrowEvent { result })?;
+        store.next_replay_event_validation::<MemoryGrowEvent, _, _>(|| MemoryGrowEvent {
+            result,
+        })?;
+    }
+    Ok(())
+}
+
+/// Record and replay hook for table.grow return value
+#[inline]
+pub fn record_and_replay_validate_table_grow(
+    result: u32,
+    store: &mut StoreOpaque,
+) -> Result<()> {
+    let _ = (result, &store);
+    #[cfg(feature = "rr")]
+    {
+        store.record_event(|| TableGrowEvent { result })?;
+        store.next_replay_event_validation::<TableGrowEvent, _, _>(|| TableGrowEvent {
+            result,
+        })?;
+    }
+    Ok(())
+}
+
 /// Ensure that memories are not exported memories in Core wasm modules when
 /// recording is enabled.
 pub fn rr_validate_module_unexported_memory(module: &Module) -> Result<()> {

crates/wasmtime/src/runtime/vm/libcalls.rs

@@ -57,6 +57,7 @@
 #[cfg(feature = "stack-switching")]
 use super::stack_switching::VMContObj;
 use crate::prelude::*;
+use crate::rr;
 use crate::runtime::store::{InstanceId, StoreInstanceId, StoreOpaque};
 #[cfg(feature = "gc")]
 use crate::runtime::vm::VMGcRef;
@@ -229,6 +230,15 @@ fn memory_grow(
             .await?
             .map(|size_in_bytes| AllocationSize(size_in_bytes >> page_size_log2));
 
+        // Record/replay hook for memory.grow
+        rr::core_hooks::record_and_replay_validate_memory_grow(
+            match &result {
+                Some(a) => a.0 as u32,
+                None => u32::MAX,
+            },
+            store,
+        )?;
+
         Ok(result)
     })?
 }
@@ -295,6 +305,16 @@ unsafe fn table_grow_func_ref(
             })
             .await?
             .map(AllocationSize);
+
+        // Record/replay hook for table.grow
+        rr::core_hooks::record_and_replay_validate_table_grow(
+            match &result {
+                Some(a) => a.0 as u32,
+                None => u32::MAX,
+            },
+            store,
+        )?;
+
         Ok(result)
     })?
 }
@@ -328,6 +348,16 @@ fn table_grow_gc_ref(
             })
             .await?
             .map(AllocationSize);
+
+        // Record/replay hook for table.grow
+        rr::core_hooks::record_and_replay_validate_table_grow(
+            match &result {
+                Some(a) => a.0 as u32,
+                None => u32::MAX,
+            },
+            store,
+        )?;
+
         Ok(result)
     })?
 }
@@ -360,6 +390,16 @@ unsafe fn table_grow_cont_obj(
             })
             .await?
             .map(AllocationSize);
+
+        // Record/replay hook for table.grow
+        rr::core_hooks::record_and_replay_validate_table_grow(
+            match &result {
+                Some(a) => a.0 as u32,
+                None => u32::MAX,
+            },
+            store,
+        )?;
+
         Ok(result)
     })?
 }