Feature-complete RR

.github/workflows/publish-artifacts.yml

@@ -13,7 +13,8 @@ jobs:
   publish:
     name: Publish artifacts of build
     runs-on: ubuntu-latest
-    if: github.repository == 'bytecodealliance/wasmtime'
+    if: github.repository == 'bytecodealliance/wasmtime' || github.repository == 'bytecodealliance/wasmtime-rr-prototyping'
+
     steps:
     - uses: actions/checkout@v4
     - uses: ./.github/actions/fetch-run-id

Cargo.toml

@@ -425,6 +425,7 @@ tokio-util = "0.7.16"
 arbtest = "0.3.2"
 rayon = "1.5.3"
 regex = "1.9.1"
+sha2 = { version = "0.10.2", default-features = false }
 
 # =============================================================================
 #
@@ -508,6 +509,7 @@ component-model-async = [
   "wasmtime-wasi-http?/p3",
   "dep:futures",
 ]
+rr = ["wasmtime/rr", "component-model", "wasmtime-cli-flags/rr", "run"]
 
 # This feature, when enabled, will statically compile out all logging statements
 # throughout Wasmtime and its dependencies.

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

@@ -30,7 +30,11 @@ 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;
 } wasmtime_func_t;
 
 /// \brief Representation of a table in Wasmtime.

crates/cli-flags/Cargo.toml

@@ -41,3 +41,4 @@ memory-protection-keys = ["wasmtime/memory-protection-keys"]
 pulley = ["wasmtime/pulley"]
 stack-switching = ["wasmtime/stack-switching"]
 debug = ["wasmtime/debug"]
+rr = ["wasmtime/rr", "component-model"]

crates/cli-flags/src/lib.rs

@@ -497,6 +497,25 @@ wasmtime_option_group! {
     }
 }
 
+wasmtime_option_group! {
+    #[derive(PartialEq, Clone, Deserialize)]
+    #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+    pub struct RecordOptions {
+        /// Filename for the recorded execution trace (or empty string to skip writing a file).
+        pub path: Option<String>,
+        /// Include (optional) signatures to facilitate validation checks during replay
+        /// (see `wasmtime replay` for details).
+        pub validation_metadata: Option<bool>,
+        /// Window size of internal buffering for record events (large windows offer more opportunities
+        /// for coalescing events at the cost of memory usage).
+        pub event_window_size: Option<usize>,
+    }
+
+    enum Record {
+        ...
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct WasiNnGraph {
     pub format: String,
@@ -547,6 +566,18 @@ pub struct CommonOptions {
     #[serde(skip)]
     wasi_raw: Vec<opt::CommaSeparated<Wasi>>,
 
+    /// Options to enable and configure execution recording, `-R help` to see all.
+    ///
+    /// Generates a serialized trace of the Wasm module execution that captures all
+    /// non-determinism observable by the module. This trace can subsequently be
+    /// re-executed in a determinstic, embedding-agnostic manner (see the `wasmtime replay` command).
+    ///
+    /// Note: Minimal configuration options for deterministic Wasm semantics will be
+    /// enforced during recording by default (NaN canonicalization, deterministic relaxed SIMD).
+    #[arg(short = 'R', long = "record", value_name = "KEY[=VAL[,..]]")]
+    #[serde(skip)]
+    record_raw: Vec<opt::CommaSeparated<Record>>,
+
     // These fields are filled in by the `configure` method below via the
     // options parsed from the CLI above. This is what the CLI should use.
     #[arg(skip)]
@@ -573,6 +604,10 @@ pub struct CommonOptions {
     #[serde(rename = "wasi", default)]
     pub wasi: WasiOptions,
 
+    #[arg(skip)]
+    #[serde(rename = "record", default)]
+    pub record: RecordOptions,
+
     /// The target triple; default is the host triple
     #[arg(long, value_name = "TARGET")]
     #[serde(skip)]
@@ -619,12 +654,14 @@ impl CommonOptions {
             debug_raw: Vec::new(),
             wasm_raw: Vec::new(),
             wasi_raw: Vec::new(),
+            record_raw: Vec::new(),
             configured: true,
             opts: Default::default(),
             codegen: Default::default(),
             debug: Default::default(),
             wasm: Default::default(),
             wasi: Default::default(),
+            record: Default::default(),
             target: None,
             config: None,
         }
@@ -642,12 +679,14 @@ impl CommonOptions {
             self.debug = toml_options.debug;
             self.wasm = toml_options.wasm;
             self.wasi = toml_options.wasi;
+            self.record = toml_options.record;
         }
         self.opts.configure_with(&self.opts_raw);
         self.codegen.configure_with(&self.codegen_raw);
         self.debug.configure_with(&self.debug_raw);
         self.wasm.configure_with(&self.wasm_raw);
         self.wasi.configure_with(&self.wasi_raw);
+        self.record.configure_with(&self.record_raw);
         Ok(())
     }
 
@@ -1004,6 +1043,15 @@ impl CommonOptions {
             config.gc_support(enable);
         }
 
+        let record = &self.record;
+        match_feature! {
+            ["rr" : &record.path]
+            _path => {
+                config.rr(wasmtime::RRConfig::Recording);
+            },
+            _ => err,
+        }
+
         Ok(config)
     }
 
@@ -1113,6 +1161,7 @@ mod tests {
             [debug]
             [wasm]
             [wasi]
+            [record]
         "#;
         let mut common_options: CommonOptions = toml::from_str(basic_toml).unwrap();
         common_options.config(None).unwrap();
@@ -1235,6 +1284,8 @@ impl fmt::Display for CommonOptions {
             wasm,
             wasi_raw,
             wasi,
+            record_raw,
+            record,
             configured,
             target,
             config,
@@ -1251,13 +1302,15 @@ impl fmt::Display for CommonOptions {
         let wasi_flags;
         let wasm_flags;
         let debug_flags;
+        let record_flags;
 
         if *configured {
             codegen_flags = codegen.to_options();
             debug_flags = debug.to_options();
             wasi_flags = wasi.to_options();
             wasm_flags = wasm.to_options();
             opts_flags = opts.to_options();
+            record_flags = record.to_options();
         } else {
             codegen_flags = codegen_raw
                 .iter()
@@ -1268,6 +1321,11 @@ impl fmt::Display for CommonOptions {
             wasi_flags = wasi_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
             wasm_flags = wasm_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
             opts_flags = opts_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
+            record_flags = record_raw
+                .iter()
+                .flat_map(|t| t.0.iter())
+                .cloned()
+                .collect();
         }
 
         for flag in codegen_flags {
@@ -1285,6 +1343,9 @@ impl fmt::Display for CommonOptions {
         for flag in debug_flags {
             write!(f, "-D{flag} ")?;
         }
+        for flag in record_flags {
+            write!(f, "-R{flag} ")?;
+        }
 
         Ok(())
     }

crates/environ/Cargo.toml

@@ -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/src/compile/module_artifacts.rs

@@ -1,6 +1,7 @@
 //! Definitions of runtime structures and metadata which are serialized into ELF
 //! with `postcard` as part of a module's compilation process.
 
+use crate::WasmChecksum;
 use crate::prelude::*;
 use crate::{
     CompiledModuleInfo, DebugInfoData, FunctionName, MemoryInitialization, Metadata,
@@ -118,6 +119,7 @@ impl<'a> ObjectBuilder<'a> {
             debuginfo,
             has_unparsed_debuginfo,
             data,
+            wasm,
             data_align,
             passive_data,
             ..
@@ -220,6 +222,7 @@ impl<'a> ObjectBuilder<'a> {
                 has_wasm_debuginfo: self.tunables.parse_wasm_debuginfo,
                 dwarf,
             },
+            checksum: WasmChecksum::from_binary(wasm),
         })
     }
 

crates/environ/src/component.rs

@@ -81,22 +81,69 @@ pub use self::types_builder::*;
 
 /// Helper macro, like `foreach_transcoder`, to iterate over builtins for
 /// components unrelated to transcoding.
+///
+/// Note: RR is not supported for component model async builtins yet; enabling
+/// both will currently throw a compile error.
 #[macro_export]
 macro_rules! foreach_builtin_component_function {
     ($mac:ident) => {
         $mac! {
+            #[rr_builtin(
+                variant = ResourceNew32,
+                entry = ResourceNew32EntryEvent,
+                exit = ResourceNew32ReturnEvent,
+                success_ty = u32
+            )]
             resource_new32(vmctx: vmctx, caller_instance: u32, resource: u32, rep: u32) -> u64;
+
+            #[rr_builtin(
+                variant = ResourceRep32,
+                entry = ResourceRep32EntryEvent,
+                exit = ResourceRep32ReturnEvent,
+                success_ty = u32
+            )]
             resource_rep32(vmctx: vmctx, caller_instance: u32, resource: u32, idx: u32) -> u64;
 
             // Returns an `Option<u32>` where `None` is "no destructor needed"
             // and `Some(val)` is "run the destructor on this rep". The option
             // is encoded as a 64-bit integer where the low bit is Some/None
             // and bits 1-33 are the payload.
+            #[rr_builtin(
+                variant = ResourceDrop,
+                entry = ResourceDropEntryEvent,
+                exit = ResourceDropReturnEvent,
+                success_ty = ResourceDropRet
+            )]
             resource_drop(vmctx: vmctx, caller_instance: u32, resource: u32, idx: u32) -> u64;
 
+            #[rr_builtin(
+                variant = ResourceTransferOwn,
+                entry = ResourceTransferOwnEntryEvent,
+                exit = ResourceTransferOwnReturnEvent,
+                success_ty = u32
+            )]
             resource_transfer_own(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u64;
+
+            #[rr_builtin(
+                variant = ResourceTransferBorrow,
+                entry = ResourceTransferBorrowEntryEvent,
+                exit = ResourceTransferBorrowReturnEvent,
+                success_ty = u32
+            )]
             resource_transfer_borrow(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u64;
+
+            #[rr_builtin(
+                variant = ResourceEnterCall,
+                entry = ResourceEnterCallEntryEvent
+            )]
             resource_enter_call(vmctx: vmctx);
+
+            #[rr_builtin(
+                variant = ResourceExitCall,
+                entry = ResourceExitCallEntryEvent,
+                exit = ResourceExitCallReturnEvent,
+                success_ty = ()
+            )]
             resource_exit_call(vmctx: vmctx) -> bool;
 
             #[cfg(feature = "component-model-async")]

crates/environ/src/component/artifacts.rs

@@ -2,7 +2,7 @@
 //! which are serialized with `bincode` into output ELF files.
 
 use crate::{
-    CompiledFunctionsTable, CompiledModuleInfo, PrimaryMap, StaticModuleIndex,
+    CompiledFunctionsTable, CompiledModuleInfo, PrimaryMap, StaticModuleIndex, WasmChecksum,
     component::{Component, ComponentTypes, TypeComponentIndex},
 };
 use serde_derive::{Deserialize, Serialize};
@@ -20,6 +20,8 @@ pub struct ComponentArtifacts {
     pub types: ComponentTypes,
     /// Serialized metadata about all included core wasm modules.
     pub static_modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
+    /// A checksum of the source Wasm binary from which the component was compiled.
+    pub checksum: WasmChecksum,
 }
 
 /// Runtime state that a component retains to support its operation.