Fix warnings and replace call_unchecked_raw to use RR arg

Author: arjunr2

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

@@ -1803,7 +1803,7 @@ impl Instance {
                     } else {
                         RRWasmFuncType::None
                     };
-                    crate::Func::call_unchecked_raw_with_rr(
+                    crate::Func::call_unchecked_raw(
                         &mut store,
                         callee.as_non_null(),
                         NonNull::new(
@@ -1992,6 +1992,7 @@ impl Instance {
                                     &mut store,
                                     func.as_non_null(),
                                     slice::from_ref(&post_return_arg).into(),
+                                    RRWasmFuncType::None,
                                 )?;
                             }
                         }
@@ -2137,13 +2138,15 @@ impl Instance {
                 // for details) we know it takes count parameters and returns
                 // `dst.len()` results.
                 unsafe {
+                    // No RR on guest->guest calls
                     crate::Func::call_unchecked_raw(
                         &mut store,
                         start.as_non_null(),
                         NonNull::new(
                             &mut src[..count.max(dst.len())] as *mut [MaybeUninit<ValRaw>] as _,
                         )
                         .unwrap(),
+                        RRWasmFuncType::None,
                     )?;
                 }
                 dst.copy_from_slice(&src[..dst.len()]);
@@ -2172,10 +2175,12 @@ impl Instance {
                     // for details) we know it takes `src.len()` parameters and
                     // returns up to 1 result.
                     unsafe {
+                        // No RR on guest->guest calls
                         crate::Func::call_unchecked_raw(
                             &mut store,
                             return_.as_non_null(),
                             my_src.as_mut_slice().into(),
+                            RRWasmFuncType::None,
                         )?;
                     }
                     let state = store.0.concurrent_state_mut();
@@ -2265,6 +2270,7 @@ impl Instance {
                 &mut store,
                 function.as_non_null(),
                 params.as_mut_slice().into(),
+                RRWasmFuncType::None,
             )?;
             flags.set_may_enter(may_enter_after_call);
         }

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

@@ -633,7 +633,7 @@ impl Func {
 
             let type_idx = self.abi_info(store.0).2;
             let types = self.instance.id().get(store.0).component().types().clone();
-            crate::Func::call_unchecked_raw_with_rr(
+            crate::Func::call_unchecked_raw(
                 &mut store,
                 export,
                 params_and_returns,
@@ -791,6 +791,7 @@ impl Func {
                     func,
                     NonNull::new(core::ptr::slice_from_raw_parts(&post_return_arg, 1).cast_mut())
                         .unwrap(),
+                    RRWasmFuncType::None,
                 )?;
             }
 

crates/wasmtime/src/runtime/component/resources/any.rs

@@ -211,7 +211,15 @@ impl ResourceAny {
         // destructors have al been previously type-checked and are guaranteed
         // to take one i32 argument and return no results, so the parameters
         // here should be configured correctly.
-        unsafe { crate::Func::call_unchecked_raw(store, dtor, NonNull::from(&mut args)) }
+        unsafe {
+            // No recording since builtins are recorded
+            crate::Func::call_unchecked_raw(
+                store,
+                dtor,
+                NonNull::from(&mut args),
+                crate::rr::RRWasmFuncType::None,
+            )
+        }
     }
 
     fn lower_to_index<U>(&self, cx: &mut LowerContext<'_, U>, ty: InterfaceType) -> Result<u32> {

crates/wasmtime/src/runtime/func.rs

@@ -1046,7 +1046,7 @@ impl Func {
         unsafe {
             let ty = &self.ty(&store);
             let origin = self.origin.expand();
-            Self::call_unchecked_raw_with_rr(
+            Self::call_unchecked_raw(
                 &mut store,
                 func_ref,
                 params_and_returns,
@@ -1055,17 +1055,11 @@ impl Func {
         }
     }
 
-    /// Same as [`Func::call_unchecked_raw`] but enables recording and replaying
-    /// hooks for func entry/exit based on whether the intended call was from a component or
-    /// core wasm module.
+    /// Raw, unchecked call to the underlying func_ref.
     ///
-    /// This method is essentially a wrapper over [`Func::call_unchecked_raw`] and operates exactly like it
-    /// when recording/replay is not enabled, so use this for all calls that will potentially need
-    /// to be recorded/replayed.
-    ///
-    /// `RRWasmFuncType::None` can be used to disable recording/replaying and passthrough to `call_unchecked_raw`.
-    /// Eventually we can replace all occurences of `call_unchecked_raw` with this method with `RRWasmFuncType::None``
-    pub(crate) unsafe fn call_unchecked_raw_with_rr<T>(
+    /// This method contains record/replay hooks for either component or core wasm source that
+    /// invoked it based on `rr`. `RRWasmFuncType::None` can be used to disable record/replay for the call
+    pub(crate) unsafe fn call_unchecked_raw<T>(
         mut store: &mut StoreContextMut<'_, T>,
         func_ref: NonNull<VMFuncRef>,
         params_and_returns: NonNull<[ValRaw]>,
@@ -1080,7 +1074,7 @@ impl Func {
                         // SAFETY: the safety of this function call is the same as the contract
                         // of this function.
                         unsafe {
-                            Self::call_unchecked_raw(&mut store, func_ref, params_and_returns)
+                            Self::call_unchecked_raw_inner(&mut store, func_ref, params_and_returns)
                         }
                     },
                     unsafe { params_and_returns.as_ref() },
@@ -1093,7 +1087,7 @@ impl Func {
             RRWasmFuncType::Component { type_idx, types } => {
                 rr::component_hooks::record_and_replay_validate_wasm_func(
                     |mut store| unsafe {
-                        Self::call_unchecked_raw(&mut store, func_ref, params_and_returns)
+                        Self::call_unchecked_raw_inner(&mut store, func_ref, params_and_returns)
                     },
                     unsafe { params_and_returns.as_ref() },
                     type_idx,
@@ -1102,13 +1096,14 @@ impl Func {
                 )
             }
             // Passthrough
+            #[cfg(feature = "component-model")]
             RRWasmFuncType::None => unsafe {
-                Self::call_unchecked_raw(&mut store, func_ref, params_and_returns)
+                Self::call_unchecked_raw_inner(&mut store, func_ref, params_and_returns)
             },
         }
     }
 
-    pub(crate) unsafe fn call_unchecked_raw<T>(
+    unsafe fn call_unchecked_raw_inner<T>(
         store: &mut StoreContextMut<'_, T>,
         func_ref: NonNull<VMFuncRef>,
         params_and_returns: NonNull<[ValRaw]>,

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

@@ -12,8 +12,6 @@ use wasmtime_environ::component::{ComponentTypes, TypeFuncIndex};
 
 /// Wasm function type information for RR hooks
 pub enum RRWasmFuncType<'a> {
-    /// No RR hooks to be performed
-    None,
     /// Core RR hooks to be performed
     Core {
         ty: &'a FuncType,
@@ -25,4 +23,7 @@ pub enum RRWasmFuncType<'a> {
         type_idx: TypeFuncIndex,
         types: Arc<ComponentTypes>,
     },
+    /// No RR hooks to be performed
+    #[cfg(feature = "component-model")]
+    None,
 }