Resolve straightforward comments

Author: arjunr2

Cargo.lock

@@ -501,7 +501,7 @@ wasmtime_option_group! {
     #[derive(PartialEq, Clone, Deserialize)]
     #[serde(rename_all = "kebab-case", deny_unknown_fields)]
     pub struct RecordOptions {
-        /// Filesystem endpoint to store the recorded execution trace (empty string "" for void endpoint)
+        /// 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).
@@ -568,12 +568,12 @@ pub struct CommonOptions {
 
     /// Options to enable and configure execution recording, `-R help` to see all.
     ///
-    /// Generates of a serialized trace of the Wasm module execution that captures 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 configs for deterministic Wasm semantics will be
-    /// enforced during recording by default (NaN canonicalization, deterministic relaxed SIMD)
+    /// 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>>,

crates/cli-flags/src/lib.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,
@@ -9,7 +10,6 @@ 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.
@@ -222,7 +222,7 @@ impl<'a> ObjectBuilder<'a> {
                 has_wasm_debuginfo: self.tunables.parse_wasm_debuginfo,
                 dwarf,
             },
-            checksum: Sha256::digest(wasm).into(),
+            checksum: WasmChecksum::from_binary(wasm),
         })
     }
 

crates/environ/src/compile/module_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,8 +20,8 @@ pub struct ComponentArtifacts {
     pub types: ComponentTypes,
     /// Serialized metadata about all included core wasm modules.
     pub static_modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
-    /// A SHA-256 checksum of the source Wasm binary from which the component was compiled
-    pub checksum: [u8; 32],
+    /// 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.

crates/environ/src/component/artifacts.rs

@@ -379,7 +379,7 @@ impl ComponentTypes {
     /// The intention of this method is to determine the flat ABI on host-to-wasm
     /// transitions (return from hostcall, or entry into wasmcall). When the type is
     /// not encodable in flat types, the values are all lowered to memory, implied by
-    /// the pointer storage
+    /// the pointer storage.
     pub fn flat_types_storage_or_pointer(
         &self,
         ty: &InterfaceType,
@@ -391,6 +391,7 @@ impl ComponentTypes {
         );
         self.flat_types_storage_inner(ty, limit).unwrap_or_else(|| {
             let mut flat = FlatTypesStorage::new();
+            // Pointer representation for wasm32 and wasm64 respectively
             flat.push(FlatType::I32, FlatType::I64);
             flat
         })

crates/environ/src/component/types.rs

@@ -8,6 +8,7 @@ use core::{fmt, u32};
 use core::{iter, str};
 use cranelift_entity::{EntityRef, PrimaryMap};
 use serde_derive::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
 
 /// Description of where a function is located in the text section of a
 /// compiled image.
@@ -28,6 +29,28 @@ impl FunctionLoc {
     }
 }
 
+/// The checksum of a Wasm binary.
+///
+/// Allows for features requiring the exact same Wasm Module (e.g. deterministic replay)
+/// to verify that the binary used matches the one originally compiled.
+#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug, Serialize, Deserialize)]
+pub struct WasmChecksum([u8; 32]);
+
+impl WasmChecksum {
+    /// Construct a [`WasmChecksum`] from the given wasm binary.
+    pub fn from_binary(bin: &[u8]) -> WasmChecksum {
+        WasmChecksum(Sha256::digest(bin).into())
+    }
+}
+
+impl core::ops::Deref for WasmChecksum {
+    type Target = [u8; 32];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 /// A builder for a `CompiledFunctionsTable`.
 pub struct CompiledFunctionsTableBuilder {
     inner: CompiledFunctionsTable,
@@ -546,8 +569,8 @@ pub struct CompiledModuleInfo {
     /// Sorted list, by function index, of names we have for this module.
     pub func_names: Vec<FunctionName>,
 
-    /// Checksum of the source Wasm binary from which this module was compiled
-    pub checksum: [u8; 32],
+    /// Checksum of the source Wasm binary from which this module was compiled.
+    pub checksum: WasmChecksum,
 }
 
 /// The name of a function stored in the

crates/environ/src/module_artifacts.rs

@@ -64,7 +64,6 @@ 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 = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
 workspace = true

crates/wasmtime/Cargo.toml

@@ -26,8 +26,6 @@ use crate::Engine;
 use crate::hash_map::HashMap;
 use crate::hash_set::HashSet;
 use crate::prelude::*;
-#[cfg(feature = "component-model")]
-use sha2::{Digest, Sha256};
 use std::{any::Any, borrow::Cow, collections::BTreeMap, mem, ops::Range};
 
 use call_graph::CallGraph;
@@ -38,7 +36,7 @@ use wasmtime_environ::{
     CompiledFunctionsTableBuilder, CompiledModuleInfo, Compiler, DefinedFuncIndex, FilePos,
     FinishedObject, FuncKey, FunctionBodyData, InliningCompiler, IntraModuleInlining,
     ModuleEnvironment, ModuleTranslation, ModuleTypes, ModuleTypesBuilder, ObjectKind, PrimaryMap,
-    StaticModuleIndex, Tunables,
+    StaticModuleIndex, Tunables, WasmChecksum,
 };
 
 mod call_graph;
@@ -208,7 +206,7 @@ pub(crate) fn build_component_artifacts<T: FinishedObject>(
         ty,
         types,
         static_modules: compilation_artifacts.modules,
-        checksum: Sha256::digest(binary).into(),
+        checksum: WasmChecksum::from_binary(binary),
     };
     object.serialize_info(&artifacts);
 

crates/wasmtime/src/compile.rs

@@ -92,7 +92,7 @@ impl Default for ModuleVersionStrategy {
 impl core::hash::Hash for ModuleVersionStrategy {
     fn hash<H: core::hash::Hasher>(&self, hasher: &mut H) {
         match self {
-            Self::WasmtimeVersion => env!("CARGO_PKG_VERSION_MAJOR").hash(hasher),
+            Self::WasmtimeVersion => env!("CARGO_PKG_VERSION").hash(hasher),
             Self::Custom(s) => s.hash(hasher),
             Self::None => {}
         };

crates/wasmtime/src/config.rs

@@ -20,7 +20,7 @@ use wasmtime_environ::component::{
     GlobalInitializer, InstantiateModule, NameMapNoIntern, OptionsIndex, StaticModuleIndex,
     TrampolineIndex, TypeComponentIndex, TypeFuncIndex, UnsafeIntrinsic, VMComponentOffsets,
 };
-use wasmtime_environ::{Abi, CompiledFunctionsTable, FuncKey, TypeTrace};
+use wasmtime_environ::{Abi, CompiledFunctionsTable, FuncKey, TypeTrace, WasmChecksum};
 use wasmtime_environ::{FunctionLoc, HostPtr, ObjectKind, PrimaryMap};
 
 /// A compiled WebAssembly Component.
@@ -95,8 +95,8 @@ struct ComponentInner {
     /// locks when calling `realloc` via `TypedFunc::call_raw`.
     realloc_func_type: Arc<FuncType>,
 
-    /// The SHA-256 checksum of the source binary
-    checksum: [u8; 32],
+    /// The checksum of the source binary from which the module was compiled.
+    checksum: WasmChecksum,
 }
 
 pub(crate) struct AllCallFuncPointers {
@@ -875,7 +875,7 @@ impl Component {
         reason = "used only for verification with wasmtime `rr` feature \
         and requires a lot of unnecessary gating across crates"
     )]
-    pub(crate) fn checksum(&self) -> &[u8; 32] {
+    pub(crate) fn checksum(&self) -> &WasmChecksum {
         &self.inner.checksum
     }