Added tests for rr; reduce func size with packed option; commonize host func entry event

Author: arjunr2

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

@@ -32,11 +32,9 @@ typedef struct wasmtime_func {
   /// Private field for Wasmtime, undefined if `store_id` is zero.
   void *__private1;
   /// Private field for Wasmtime
-  uint32_t *__private2;
-  /// Private field for Wasmtime
-  uint32_t *__private3;
+  uint32_t __private2;
   /// Private field for Wasmtime
-  uint32_t *__private4;
+  uint32_t __private3;
 } wasmtime_func_t;
 
 /// \brief Representation of a table in Wasmtime.

crates/c-api/include/wasmtime/val.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) == 32, "should be 16-bytes large");
+  static_assert(sizeof(wasmtime_valunion_t) == 24, "should be 24-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/src/val.rs

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

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

@@ -651,8 +651,8 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                 //
                 // Realloc or any lowering methods cannot call back to the host. Hence, you cannot
                 // have host calls entries during this method
-                RREvent::ComponentHostFuncEntry(_) => {
-                    bail!("Cannot call into host during lowering")
+                RREvent::HostFuncEntry(_) => {
+                    bail!("Cannot call back into host during lowering")
                 }
                 // Unwrapping should never occur on valid executions since *Entry should be before *Return in trace
                 RREvent::ComponentReallocReturn(e) => {

crates/wasmtime/src/runtime/func.rs

@@ -18,7 +18,9 @@ use core::future::Future;
 use core::mem::{self, MaybeUninit};
 use core::ptr::NonNull;
 use serde::{Deserialize, Serialize};
-use wasmtime_environ::{FuncIndex, VMSharedTypeIndex};
+use wasmtime_environ::{
+    FuncIndex, VMSharedTypeIndex, packed_option::PackedOption, packed_option::ReservedValue,
+};
 
 /// A reference to the abstract `nofunc` heap value.
 ///
@@ -112,6 +114,19 @@ pub struct WasmFuncOrigin {
     pub index: FuncIndex,
 }
 
+impl ReservedValue for WasmFuncOrigin {
+    fn reserved_value() -> Self {
+        WasmFuncOrigin {
+            instance: InstanceId::reserved_value(),
+            index: FuncIndex::reserved_value(),
+        }
+    }
+
+    fn is_reserved_value(&self) -> bool {
+        self.instance.is_reserved_value() && self.index.is_reserved_value()
+    }
+}
+
 /// A WebAssembly function which can be called.
 ///
 /// This type typically represents an exported function from a WebAssembly
@@ -294,14 +309,14 @@ pub struct Func {
     /// This field is populated when a [`Func`] is generated from a known instance
     /// (i.e. exported Wasm functions), and is usually `None` for internal
     /// Wasm functions and host functions.
-    origin: Option<WasmFuncOrigin>,
+    origin: PackedOption<WasmFuncOrigin>,
 }
 
 // Double-check that the C representation in `extern.h` matches our in-Rust
 // representation here in terms of size/alignment/etc.
 const _: () = {
     #[repr(C)]
-    struct C(u64, *mut u8, (u32, u32, u32));
+    struct C(u64, *mut u8, (u32, u32));
     assert!(core::mem::size_of::<C>() == core::mem::size_of::<Func>());
     assert!(core::mem::align_of::<C>() == core::mem::align_of::<Func>());
     assert!(core::mem::offset_of!(Func, store) == 0);
@@ -566,7 +581,7 @@ impl Func {
         Func {
             store,
             unsafe_func_ref: func_ref.into(),
-            origin: None,
+            origin: PackedOption::default(),
         }
     }
 
@@ -1035,7 +1050,7 @@ impl Func {
             },
             unsafe { params_and_returns.as_ref() },
             &self.ty(&store),
-            self.origin.clone(),
+            self.origin.expand(),
             &mut store,
         )
     }
@@ -1536,12 +1551,12 @@ impl Func {
 
     /// Set the origin of this function.
     pub(crate) fn set_origin(&mut self, origin: WasmFuncOrigin) {
-        self.origin = Some(origin);
+        self.origin = PackedOption::from(origin);
     }
 
     // Get the origin of this function
     pub(crate) fn origin(&self) -> Option<WasmFuncOrigin> {
-        self.origin
+        self.origin.expand()
     }
 }
 

crates/wasmtime/src/runtime/rr.rs

@@ -30,7 +30,8 @@ impl FlatBytes for MaybeUninit<ValRaw> {
     #[inline]
     fn bytes_ref(&self, size: u8) -> &[u8] {
         // Uninitialized data is assumed and serialized, so hence
-        // may contain some undefined values
+        // may contain some undefined values. But these are irrelevant
+        // when serializing to `RRFuncArgVals`
         let val = unsafe { self.assume_init_ref() };
         val.bytes_ref(size)
     }