Fold component-model feature into rr

Author: arjunr2

crates/wasmtime/Cargo.toml

@@ -428,4 +428,4 @@ debug = [
 compile-time-builtins = ['dep:wasm-compose', 'dep:tempfile']
 
 # Enable support for the common base infrastructure of record/replay
-rr = ["dep:embedded-io"]
+rr = ["component-model", "dep:embedded-io"]

crates/wasmtime/build.rs

@@ -33,10 +33,6 @@ fn main() {
     custom_cfg("has_custom_sync", has_custom_sync);
     custom_cfg("has_host_compiler_backend", has_host_compiler_backend);
 
-    // Component model support for record/replay
-    let rr_component = cfg!(feature = "rr") && cfg!(feature = "component-model");
-    custom_cfg("rr_component", rr_component);
-
     // If this OS isn't supported and no debug-builtins or if Cranelift doesn't support
     // the host or there's no need to build these helpers.
     #[cfg(feature = "runtime")]

crates/wasmtime/src/runtime/component/func/host.rs

@@ -8,7 +8,7 @@ use crate::component::types::ComponentFunc;
 use crate::component::{ComponentNamedList, ComponentType, Instance, Lift, Lower, Val};
 use crate::prelude::*;
 use crate::rr;
-#[cfg(rr_component)]
+#[cfg(feature = "rr")]
 use crate::rr::component_hooks::ReplayLoweringPhase;
 use crate::runtime::vm::component::{
     ComponentInstance, VMComponentContext, VMLowering, VMLoweringCallee,
@@ -941,7 +941,7 @@ where
             store.0.store_opaque_mut(),
         )?;
         // Replay host function path: Just lower the results from the trace
-        #[cfg(rr_component)]
+        #[cfg(feature = "rr")]
         {
             let mut cx = LowerContext::new(store, options, instance);
             // Skip lifting/lowering logic, and just replaying the lowering state
@@ -966,11 +966,9 @@ where
                 }
             }
         }
-        #[cfg(not(rr_component))]
+        #[cfg(not(feature = "rr"))]
         {
-            unreachable!(
-                "cannot reach host function replay when rr and component-model is disabled"
-            );
+            unreachable!("cannot reach host function replay when rr is disabled");
         }
     }
 
@@ -1018,7 +1016,7 @@ unsafe fn dynamic_params_load(
 }
 
 /// Replay of return values from `dynamic_params_load`. Keep in sync
-#[cfg(rr_component)]
+#[cfg(feature = "rr")]
 unsafe fn dynamic_params_load_replay(param_tys: &TypeTuple, max_flat_params: usize) -> usize {
     if let Some(param_count) = param_tys.abi.flat_count(max_flat_params) {
         param_count

crates/wasmtime/src/runtime/component/func/options.rs

@@ -1,13 +1,13 @@
 use crate::StoreContextMut;
-#[cfg(rr_component)]
+#[cfg(feature = "rr")]
 use crate::ValRaw;
 use crate::component::concurrent::ConcurrentState;
 use crate::component::matching::InstanceType;
 use crate::component::resources::{HostResourceData, HostResourceIndex, HostResourceTables};
 use crate::component::{Instance, ResourceType};
 use crate::prelude::*;
 use crate::rr::{DynamicMemorySlice, FixedMemorySlice};
-#[cfg(rr_component)]
+#[cfg(feature = "rr")]
 use crate::rr::{
     RREvent, RecordBuffer, ReplayError, Replayer, ResultEvent, Validate,
     component_events::ReallocEntryEvent, component_events::ReallocReturnEvent,
@@ -19,7 +19,7 @@ use crate::runtime::vm::component::{
 };
 use crate::store::{StoreId, StoreOpaque};
 use alloc::sync::Arc;
-#[cfg(rr_component)]
+#[cfg(feature = "rr")]
 use core::mem::MaybeUninit;
 use core::pin::Pin;
 use core::ptr::NonNull;
@@ -126,7 +126,7 @@ impl<'a, T: 'static> LowerContext<'a, T> {
     }
 
     /// Return the `InstanceFlags` for this context
-    #[cfg(rr_component)]
+    #[cfg(feature = "rr")]
     fn instance_flags(&self) -> InstanceFlags {
         let vminstance = self.instance.id().get(self.store.0);
         let opts = self.options();
@@ -139,7 +139,7 @@ impl<'a, T: 'static> LowerContext<'a, T> {
     /// # Panics
     ///
     /// See [`as_slice`](Self::as_slice)
-    #[cfg(rr_component)]
+    #[cfg(feature = "rr")]
     fn as_slice_mut_with_recorder(&mut self) -> (&mut [u8], Option<&mut RecordBuffer>) {
         self.instance
             .options_memory_mut_with_recorder(self.store.0, self.options)
@@ -243,15 +243,15 @@ impl<'a, T: 'static> LowerContext<'a, T> {
         old_align: u32,
         new_size: usize,
     ) -> Result<usize> {
-        #[cfg(rr_component)]
+        #[cfg(feature = "rr")]
         self.store.0.record_event(|| ReallocEntryEvent {
             old_addr: old,
             old_size,
             old_align,
             new_size,
         })?;
         let result = self.realloc_inner(old, old_size, old_align, new_size);
-        #[cfg(rr_component)]
+        #[cfg(feature = "rr")]
         self.store.0.record_event_validation(|| {
             ReallocReturnEvent(ResultEvent::from_anyhow_result(&result))
         })?;
@@ -271,7 +271,7 @@ impl<'a, T: 'static> LowerContext<'a, T> {
     #[inline]
     pub fn get<const N: usize>(&mut self, offset: usize) -> FixedMemorySlice<'_, N> {
         cfg_if::cfg_if! {
-            if #[cfg(rr_component)] {
+            if #[cfg(feature = "rr")] {
                 let (slice_mut, recorder) = self.as_slice_mut_with_recorder();
             } else {
                 let slice_mut = self.as_slice_mut();
@@ -289,9 +289,9 @@ impl<'a, T: 'static> LowerContext<'a, T> {
         // of `unsafe`.
         FixedMemorySlice {
             bytes: slice_mut[offset..].first_chunk_mut().unwrap(),
-            #[cfg(rr_component)]
+            #[cfg(feature = "rr")]
             offset: offset,
-            #[cfg(rr_component)]
+            #[cfg(feature = "rr")]
             recorder: recorder,
         }
     }
@@ -305,17 +305,17 @@ impl<'a, T: 'static> LowerContext<'a, T> {
     #[inline]
     pub fn get_dyn(&mut self, offset: usize, size: usize) -> DynamicMemorySlice<'_> {
         cfg_if::cfg_if! {
-            if #[cfg(rr_component)] {
+            if #[cfg(feature = "rr")] {
                 let (slice_mut, recorder) = self.as_slice_mut_with_recorder();
             } else {
                 let slice_mut = self.as_slice_mut();
             }
         }
         DynamicMemorySlice {
             bytes: &mut slice_mut[offset..][..size],
-            #[cfg(rr_component)]
+            #[cfg(feature = "rr")]
             offset: offset,
-            #[cfg(rr_component)]
+            #[cfg(feature = "rr")]
             recorder: recorder,
         }
     }
@@ -418,7 +418,7 @@ impl<'a, T: 'static> LowerContext<'a, T> {
     /// * It is assumed that this is only invoked at the root lower/store calls
     /// * Panics if invoked while replay is not enabled
     ///
-    #[cfg(rr_component)]
+    #[cfg(feature = "rr")]
     pub fn replay_lowering(
         &mut self,
         mut result_storage: Option<&mut [MaybeUninit<ValRaw>]>,

crates/wasmtime/src/runtime/component/instance.rs

@@ -8,8 +8,8 @@ use crate::component::{
 use crate::instance::OwnedImports;
 use crate::linker::DefinitionType;
 use crate::prelude::*;
-#[cfg(rr_component)]
-use crate::rr::RecordBuffer;
+#[cfg(feature = "rr")]
+use crate::rr::{RecordBuffer, component_events::InstantiationEvent};
 use crate::runtime::vm::component::{
     CallContexts, ComponentInstance, ResourceTables, TypedResource, TypedResourceIndex,
 };
@@ -530,7 +530,7 @@ impl Instance {
         }
     }
 
-    #[cfg(rr_component)]
+    #[cfg(feature = "rr")]
     pub(crate) fn options_memory_mut_with_recorder<'a>(
         &self,
         store: &'a mut StoreOpaque,
@@ -1080,7 +1080,7 @@ impl<'a> Instantiator<'a> {
 
     /// Convenience helper to return the instance ID of the `ComponentInstance` that's
     /// being instantiated
-    #[cfg(rr_component)]
+    #[cfg(feature = "rr")]
     fn id(&self) -> ComponentInstanceId {
         self.id
     }
@@ -1193,14 +1193,13 @@ impl<T: 'static> InstancePre<T> {
             .allocator()
             .increment_component_instance_count()?;
         let mut instantiator = Instantiator::new(&self.component, store.0, &self.imports);
-        #[cfg(rr_component)]
-        {
-            use crate::rr::component_events::InstantiationEvent;
-            store.0.record_event(|| InstantiationEvent {
-                component: *self.component.checksum(),
-                instance: instantiator.id(),
-            })?;
-        }
+
+        #[cfg(feature = "rr")]
+        store.0.record_event(|| InstantiationEvent {
+            component: *self.component.checksum(),
+            instance: instantiator.id(),
+        })?;
+
         instantiator.run(&mut store).await.map_err(|e| {
             store
                 .engine()

crates/wasmtime/src/runtime/rr/core.rs

@@ -2,17 +2,13 @@ use crate::config::ModuleVersionStrategy;
 use crate::prelude::*;
 use core::fmt;
 use events::EventError;
+pub use events::{
+    RRFuncArgVals, ResultEvent, Validate, common_events, component_events, core_events,
+    marker_events,
+};
+pub use io::{IOError, RecordWriter, ReplayReader};
 use serde::{Deserialize, Serialize};
 use wasmtime_environ::{EntityIndex, WasmChecksum};
-// Use component events internally even without feature flags enabled
-// so that [`RREvent`] has a well-defined serialization format, but export
-// it for other modules only when enabled
-pub use events::Validate;
-#[cfg(rr_component)]
-pub use events::component_events;
-use events::component_events as __component_events;
-pub use events::{RRFuncArgVals, ResultEvent, common_events, core_events, marker_events};
-pub use io::{IOError, RecordWriter, ReplayReader};
 
 /// Settings for execution recording.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -141,23 +137,23 @@ rr_event! {
     ///
     /// This is distinguished from `ComponentWasmFuncEntry` as there may
     /// be multiple lowering steps before actually entering the Wasm function
-    ComponentWasmFuncBegin(__component_events::WasmFuncBeginEvent),
+    ComponentWasmFuncBegin(component_events::WasmFuncBeginEvent),
     /// Entry from the host into the Wasm component function
-    ComponentWasmFuncEntry(__component_events::WasmFuncEntryEvent),
+    ComponentWasmFuncEntry(component_events::WasmFuncEntryEvent),
     /// Instantiation of a component
-    ComponentInstantiation(__component_events::InstantiationEvent),
+    ComponentInstantiation(component_events::InstantiationEvent),
     /// Component ABI realloc call in linear wasm memory
-    ComponentReallocEntry(__component_events::ReallocEntryEvent),
+    ComponentReallocEntry(component_events::ReallocEntryEvent),
     /// Return from a type lowering operation
-    ComponentLowerFlatReturn(__component_events::LowerFlatReturnEvent),
+    ComponentLowerFlatReturn(component_events::LowerFlatReturnEvent),
     /// Return from a store during a type lowering operation
-    ComponentLowerMemoryReturn(__component_events::LowerMemoryReturnEvent),
+    ComponentLowerMemoryReturn(component_events::LowerMemoryReturnEvent),
     /// An attempt to obtain a mutable slice into Wasm linear memory
-    ComponentMemorySliceWrite(__component_events::MemorySliceWriteEvent),
+    ComponentMemorySliceWrite(component_events::MemorySliceWriteEvent),
     /// Return from a component builtin
-    ComponentBuiltinReturn(__component_events::BuiltinReturnEvent),
+    ComponentBuiltinReturn(component_events::BuiltinReturnEvent),
     /// Call to `post_return` (after the function call)
-    ComponentPostReturn(__component_events::PostReturnEvent),
+    ComponentPostReturn(component_events::PostReturnEvent),
 
     // OPTIONAL events for replay validation (Component)
 
@@ -166,13 +162,13 @@ rr_event! {
     /// Since realloc is deterministic, ReallocReturn is optional.
     /// Any error is subsumed by the containing LowerReturn/LowerStoreReturn
     /// that triggered realloc
-    ComponentReallocReturn(__component_events::ReallocReturnEvent),
+    ComponentReallocReturn(component_events::ReallocReturnEvent),
     /// Call into type lowering for flat destination
-    ComponentLowerFlatEntry(__component_events::LowerFlatEntryEvent),
+    ComponentLowerFlatEntry(component_events::LowerFlatEntryEvent),
     /// Call into type lowering for memory destination
-    ComponentLowerMemoryEntry(__component_events::LowerMemoryEntryEvent),
+    ComponentLowerMemoryEntry(component_events::LowerMemoryEntryEvent),
     /// Call into a component builtin
-    ComponentBuiltinEntry(__component_events::BuiltinEntryEvent)
+    ComponentBuiltinEntry(component_events::BuiltinEntryEvent)
 }
 
 impl RREvent {
@@ -708,7 +704,7 @@ mod tests {
                     origin: origin.clone(),
                     args: RRFuncArgVals::from_flat_iter(&values, flat_sizes.iter().copied()),
                 })?;
-                recorder.record_event(|| __component_events::WasmFuncEntryEvent {
+                recorder.record_event(|| component_events::WasmFuncEntryEvent {
                     args: RRFuncArgVals::from_flat_iter(
                         &return_values,
                         return_flat_sizes.iter().copied(),
@@ -724,7 +720,7 @@ mod tests {
                 assert!(origin == replay_origin.unwrap());
                 verify_equal_slices(&values, &replay_values, &flat_sizes)?;
 
-                replayer.next_event_and(|event: __component_events::WasmFuncEntryEvent| {
+                replayer.next_event_and(|event: component_events::WasmFuncEntryEvent| {
                     event.args.into_raw_slice(&mut return_replay_values);
                     Ok(())
                 })?;
@@ -735,7 +731,7 @@ mod tests {
 
     #[test]
     fn builtin_event_entry() -> Result<()> {
-        use __component_events::{
+        use component_events::{
             BuiltinEntryEvent, ResourceDropEntryEvent, ResourceEnterCallEntryEvent,
             ResourceExitCallEntryEvent, ResourceTransferBorrowEntryEvent,
             ResourceTransferOwnEntryEvent,
@@ -781,7 +777,7 @@ mod tests {
 
     #[test]
     fn builtin_event_return() -> Result<()> {
-        use __component_events::{
+        use component_events::{
             BuiltinError, BuiltinReturnEvent, ResourceDropReturnEvent, ResourceExitCallReturnEvent,
             ResourceRep32ReturnEvent, ResourceTransferBorrowReturnEvent,
             ResourceTransferOwnReturnEvent,
@@ -870,7 +866,7 @@ mod tests {
 
     #[test]
     fn lower_flat_events() -> Result<()> {
-        use __component_events::{LowerFlatEntryEvent, LowerFlatReturnEvent};
+        use component_events::{LowerFlatEntryEvent, LowerFlatReturnEvent};
         use wasmtime_environ::component::InterfaceType;
 
         let entry = LowerFlatEntryEvent {
@@ -900,7 +896,7 @@ mod tests {
 
     #[test]
     fn lower_memory_events() -> Result<()> {
-        use __component_events::{LowerMemoryEntryEvent, LowerMemoryReturnEvent};
+        use component_events::{LowerMemoryEntryEvent, LowerMemoryReturnEvent};
         use wasmtime_environ::component::InterfaceType;
 
         let entry = LowerMemoryEntryEvent {
@@ -932,7 +928,7 @@ mod tests {
 
     #[test]
     fn realloc_events() -> Result<()> {
-        use __component_events::{ReallocEntryEvent, ReallocReturnEvent};
+        use component_events::{ReallocEntryEvent, ReallocReturnEvent};
 
         let entry = ReallocEntryEvent {
             old_addr: 0x1000,
@@ -967,7 +963,7 @@ mod tests {
 
     #[test]
     fn memory_slice_write_event() -> Result<()> {
-        use __component_events::MemorySliceWriteEvent;
+        use component_events::MemorySliceWriteEvent;
 
         let event = MemorySliceWriteEvent {
             offset: 512,
@@ -994,7 +990,7 @@ mod tests {
     fn instantiation_event() -> Result<()> {
         use crate::component::ComponentInstanceId;
         use crate::store::InstanceId;
-        use __component_events::InstantiationEvent as ComponentInstantiationEvent;
+        use component_events::InstantiationEvent as ComponentInstantiationEvent;
         use core_events::InstantiationEvent as CoreInstantiationEvent;
         use wasmtime_environ::WasmChecksum;
 

crates/wasmtime/src/runtime/rr/core/events.rs

@@ -4,7 +4,6 @@ use crate::{AsContextMut, Val, prelude::*};
 use crate::{ValRaw, ValType};
 use core::fmt;
 use serde::{Deserialize, Serialize};
-#[cfg(rr_component)]
 use wasmtime_environ::component::FlatTypesStorage;
 
 /// A serde compatible representation of errors produced during execution
@@ -76,7 +75,6 @@ impl RRFuncArgVals {
     }
 
     /// Construct [`RRFuncArgVals`] from raw value buffer and a [`FlatTypesStorage`]
-    #[cfg(rr_component)]
     #[inline]
     pub fn from_flat_storage<T>(args: &[T], flat: FlatTypesStorage) -> RRFuncArgVals
     where