Added support for recording all boundaries of Func and TypedFunc; completed core wasm rr

Author: arjunr2

Cargo.lock

@@ -411,6 +411,7 @@ webpki-roots = "0.26.0"
 itertools = "0.14.0"
 base64 = "0.22.1"
 termcolor = "1.4.1"
+sha2 = { version = "0.10.2", default-features = false }
 
 # =============================================================================
 #

Cargo.toml

@@ -30,7 +30,13 @@ typedef struct wasmtime_func {
   /// this field is otherwise never zero.
   uint64_t store_id;
   /// Private field for Wasmtime, undefined if `store_id` is zero.
-  void *__private;
+  void *__private1;
+  /// Private field for Wasmtime
+  uint32_t *__private2;
+  /// Private field for Wasmtime
+  uint32_t *__private3;
+  /// Private field for Wasmtime
+  uint32_t *__private4;
 } wasmtime_func_t;
 
 /// \brief Representation of a table in Wasmtime.

crates/c-api/include/wasmtime/extern.h

@@ -418,7 +418,7 @@ typedef union wasmtime_val_raw {
 // Assert that the shape of this type is as expected since it needs to match
 // Rust.
 static inline void __wasmtime_val_assertions() {
-  static_assert(sizeof(wasmtime_valunion_t) == 16, "should be 16-bytes large");
+  static_assert(sizeof(wasmtime_valunion_t) == 32, "should be 16-bytes large");
   static_assert(__alignof(wasmtime_valunion_t) == 8,
                 "should be 8-byte aligned");
   static_assert(sizeof(wasmtime_val_raw_t) == 16, "should be 16 bytes large");

crates/c-api/include/wasmtime/val.h

@@ -152,7 +152,7 @@ pub union wasmtime_val_union {
 }
 
 const _: () = {
-    assert!(std::mem::size_of::<wasmtime_val_union>() == 16);
+    assert!(std::mem::size_of::<wasmtime_val_union>() == 32);
     assert!(std::mem::align_of::<wasmtime_val_union>() == std::mem::align_of::<u64>());
 };
 

crates/c-api/src/val.rs

@@ -37,6 +37,7 @@ wasmprinter = { workspace = true, optional = true }
 wasmtime-component-util = { workspace = true, optional = true }
 semver = { workspace = true, optional = true, features = ['serde'] }
 smallvec = { workspace = true, features = ['serde'] }
+sha2 = { workspace = true }
 
 [dev-dependencies]
 clap = { workspace = true, features = ['default'] }

crates/environ/Cargo.toml

@@ -10,6 +10,7 @@ use crate::{
 use anyhow::{Result, bail};
 use object::SectionKind;
 use object::write::{Object, SectionId, StandardSegment, WritableBuffer};
+use sha2::{Digest, Sha256};
 use std::ops::Range;
 
 /// Helper structure to create an ELF file as a compilation artifact.
@@ -124,6 +125,7 @@ impl<'a> ObjectBuilder<'a> {
             debuginfo,
             has_unparsed_debuginfo,
             data,
+            wasm,
             data_align,
             passive_data,
             ..
@@ -228,6 +230,7 @@ impl<'a> ObjectBuilder<'a> {
                 has_wasm_debuginfo: self.tunables.parse_wasm_debuginfo,
                 dwarf,
             },
+            checksum: Sha256::digest(wasm).into(),
         })
     }
 

crates/environ/src/compile/module_artifacts.rs

@@ -52,6 +52,9 @@ pub struct CompiledModuleInfo {
 
     /// General compilation metadata.
     pub meta: Metadata,
+
+    /// Checksum of the source Wasm binary from which this module was compiled
+    pub checksum: [u8; 32],
 }
 
 /// The name of a function stored in the

crates/environ/src/module_artifacts.rs

@@ -63,7 +63,7 @@ bitflags = { workspace = true }
 futures = { workspace = true, features = ["alloc"], optional = true }
 bytes = { workspace = true, optional = true }
 embedded-io = { version = "0.6.1", features = ["alloc"], optional = true }
-sha2 = { version = "0.10.2", default-features = false }
+sha2 = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
 workspace = true

crates/wasmtime/Cargo.toml

@@ -4,8 +4,6 @@ use crate::component::matching::InstanceType;
 use crate::component::resources::{HostResourceData, HostResourceIndex, HostResourceTables};
 use crate::component::{Instance, ResourceType};
 use crate::prelude::*;
-#[cfg(all(feature = "rr-component", feature = "rr-validate"))]
-use crate::rr::component_events::ResultEvent;
 #[cfg(feature = "rr-component")]
 use crate::rr::component_hooks::ReplayLoweringPhase;
 use crate::rr::{ConstMemorySliceCell, MemorySliceCell};
@@ -14,7 +12,7 @@ use crate::rr::{
     RREvent, RecordBuffer, ReplayError, Replayer, component_events::ReallocEntryEvent,
 };
 #[cfg(all(feature = "rr-component", feature = "rr-validate"))]
-use crate::rr::{Validate, component_events::ReallocReturnEvent};
+use crate::rr::{ResultEvent, Validate, component_events::ReallocReturnEvent};
 use crate::runtime::vm::component::{
     CallContexts, ComponentInstance, InstanceFlags, ResourceTable, ResourceTables,
 };
@@ -139,7 +137,7 @@ impl Options {
 
         // Invoke the wasm malloc function using its raw and statically known
         // signature.
-        let result = unsafe { ReallocFunc::call_raw(store, realloc_ty, realloc, params)? };
+        let result = unsafe { ReallocFunc::call_raw(store, realloc_ty, realloc, params, None)? };
 
         if result % old_align != 0 {
             bail!("realloc return: result not aligned");
@@ -560,40 +558,6 @@ impl<'a, T: 'static> LowerContext<'a, T> {
         )
     }
 
-    /// Perform a replay of only [`ReallocEntryEvent`] + [`ReallocReturnEvent`] events
-    ///
-    /// Panics if replay not enabled
-    #[cfg(feature = "rr-component")]
-    pub fn replay_realloc(&mut self) -> Result<usize> {
-        let get_event = |cx: &mut Self| cx.store.0.replay_buffer_mut().unwrap().next_event();
-        let (record_has_validation, _replay_validate) = {
-            let buf = self.store.0.replay_buffer_mut().unwrap();
-            (buf.trace_settings().add_validation, buf.settings().validate)
-        };
-
-        let ptr = match get_event(self)? {
-            RREvent::ComponentReallocEntry(e) => {
-                self.realloc_inner(e.old_addr, e.old_size, e.old_align, e.new_size)
-            }
-            _ => bail!(ReplayError::IncorrectEventVariant),
-        };
-
-        if record_has_validation {
-            match get_event(self)? {
-                RREvent::ComponentReallocReturn(e) =>
-                {
-                    #[cfg(feature = "rr-validate")]
-                    if _replay_validate {
-                        e.0.validate(&ptr)?
-                    }
-                }
-                _ => bail!(ReplayError::IncorrectEventVariant),
-            };
-        }
-
-        ptr
-    }
-
     /// Perform a replay of all the type lowering-associated events for this context
     ///
     /// These typically include all `Lower*` and `Realloc*` event, along with the putting