Make all usize serialized types into u64

Author: arjunr2

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

@@ -245,15 +245,15 @@ impl<'a, T: 'static> LowerContext<'a, T> {
     ) -> Result<usize> {
         #[cfg(feature = "rr")]
         self.store.0.record_event(|| ReallocEntryEvent {
-            old_addr: old,
-            old_size,
+            old_addr: old as u64,
+            old_size: old_size as u64,
             old_align,
-            new_size,
+            new_size: new_size as u64,
         })?;
         let result = self.realloc_inner(old, old_size, old_align, new_size);
         #[cfg(feature = "rr")]
         self.store.0.record_event_validation(|| {
-            ReallocReturnEvent(ResultEvent::from_anyhow_result(&result))
+            ReallocReturnEvent(ResultEvent::from_anyhow_result_usize(&result))
         })?;
         result
     }
@@ -473,8 +473,12 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                     complete = true;
                 }
                 RREvent::ComponentReallocEntry(e) => {
-                    let result =
-                        self.realloc_inner(e.old_addr, e.old_size, e.old_align, e.new_size);
+                    let result = self.realloc_inner(
+                        e.old_addr as usize,
+                        e.old_size as usize,
+                        e.old_align,
+                        e.new_size as usize,
+                    );
                     if run_validate {
                         realloc_stack.push(result);
                     }
@@ -495,9 +499,10 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                     lowering_error = e.0.ret().map_err(Into::into).err();
                 }
                 RREvent::ComponentMemorySliceWrite(e) => {
+                    let offset = e.offset as usize;
                     // The bounds check is performed here is required here (in the absence of
                     // trace validation) to protect against malicious out-of-bounds slice writes
-                    self.as_slice_mut()[e.offset..e.offset + e.bytes.len()]
+                    self.as_slice_mut()[offset..offset + e.bytes.len()]
                         .copy_from_slice(e.bytes.as_slice());
                 }
                 // Optional events
@@ -510,7 +515,9 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                 // Unwrapping should never occur on valid executions since *Entry should be before *Return in trace
                 RREvent::ComponentReallocReturn(e) => {
                     if run_validate {
-                        lowering_error = e.0.validate(&realloc_stack.pop().unwrap()).err()
+                        lowering_error =
+                            e.0.validate(&realloc_stack.pop().unwrap().map(|r| r as u64))
+                                .err()
                     }
                 }
                 RREvent::ComponentLowerFlatEntry(_) => {

crates/wasmtime/src/runtime/rr/backend/crimp/events.rs

@@ -117,6 +117,19 @@ where
     }
 }
 
+impl<E> ResultEvent<u64, E>
+where
+    E: EventError,
+{
+    pub fn from_anyhow_result_usize(ret: &Result<usize>) -> Self {
+        Self(
+            ret.as_ref()
+                .map(|t| *t as u64)
+                .map_err(|e| E::new(e.to_string())),
+        )
+    }
+}
+
 impl<T, E> Validate<Result<T>> for ResultEvent<T, E>
 where
     T: fmt::Debug + PartialEq,

crates/wasmtime/src/runtime/rr/backend/crimp/events/component_events.rs

@@ -50,10 +50,10 @@ pub struct WasmFuncEntryEvent {
 /// A reallocation call event in the Wasm Component Model canonical ABI.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ReallocEntryEvent {
-    pub old_addr: usize,
-    pub old_size: usize,
+    pub old_addr: u64,
+    pub old_size: u64,
     pub old_align: u32,
-    pub new_size: usize,
+    pub new_size: u64,
 }
 
 /// Entry to a type lowering invocation to flat destination.
@@ -66,7 +66,7 @@ pub struct LowerFlatEntryEvent {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LowerMemoryEntryEvent {
     pub ty: InterfaceType,
-    pub offset: usize,
+    pub offset: u64,
 }
 
 /// A write to a mutable slice of Wasm linear memory by the host. This is the
@@ -78,7 +78,7 @@ pub struct LowerMemoryEntryEvent {
 /// larger granularity operations in the future at either the recording or the replay level.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MemorySliceWriteEvent {
-    pub offset: usize,
+    pub offset: u64,
     pub bytes: Vec<u8>,
 }
 
@@ -92,7 +92,7 @@ event_error_types! {
 /// Return from a reallocation call in the Component Model canonical ABI, providing
 /// the address of allocation if successful.
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ReallocReturnEvent(pub ResultEvent<usize, ReallocError>);
+pub struct ReallocReturnEvent(pub ResultEvent<u64, ReallocError>);
 
 /// Return from type lowering to flat destination.
 #[derive(Debug, Clone, Serialize, Deserialize)]

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

@@ -181,7 +181,10 @@ where
     #[cfg(feature = "rr")]
     cx.store
         .0
-        .record_event_validation(|| LowerMemoryEntryEvent { ty, offset })?;
+        .record_event_validation(|| LowerMemoryEntryEvent {
+            ty,
+            offset: offset as u64,
+        })?;
     let store_result = lower_store(cx, ty, offset);
     #[cfg(feature = "rr")]
     cx.store
@@ -283,7 +286,7 @@ impl Drop for DynamicMemorySlice<'_> {
             // We don't need to record empty slices
             if !self.bytes.is_empty() {
                 buf.record_event(|| MemorySliceWriteEvent {
-                    offset: self.offset,
+                    offset: self.offset as u64,
                     bytes: self.bytes.to_vec(),
                 })
                 .unwrap();
@@ -346,7 +349,7 @@ impl<'a, const N: usize> Drop for FixedMemorySlice<'a, N> {
             // We don't need to record empty slices
             if !self.bytes.is_empty() {
                 buf.record_event(|| MemorySliceWriteEvent {
-                    offset: self.offset,
+                    offset: self.offset as u64,
                     bytes: self.bytes.to_vec(),
                 })
                 .unwrap();

crates/wasmtime/src/runtime/vm/stack_switching/stack/unix.rs

@@ -258,7 +258,7 @@ impl VMContinuationStack {
 
             let to_store = [
                 // Data near top of stack:
-                (0x08, wasmtime_continuation_start as usize),
+                (0x08, wasmtime_continuation_start as *const () as usize),
                 (0x10, tos.sub(0x10).addr()),
                 (0x18, tos.sub(0x40 + args_data_size).addr()),
                 (0x20, usize::try_from(args_capacity).unwrap()),

crates/wasmtime/src/runtime/vm/sys/unix/signals.rs

@@ -49,7 +49,7 @@ impl TrapHandler {
             // crash while handling the signal, and fall through to the
             // Breakpad handler by testing handlingSegFault.
             handler.sa_flags = libc::SA_SIGINFO | libc::SA_NODEFER | libc::SA_ONSTACK;
-            handler.sa_sigaction = trap_handler as usize;
+            handler.sa_sigaction = trap_handler as *const () as usize;
             unsafe {
                 libc::sigemptyset(&mut handler.sa_mask);
                 if libc::sigaction(signal, &handler, slot) != 0 {
@@ -111,7 +111,7 @@ impl Drop for TrapHandler {
                 // signal handler state and don't know how to remove ourselves
                 // from the signal handling state. Inform the user of this and
                 // abort the process.
-                if prev.sa_sigaction != trap_handler as usize {
+                if prev.sa_sigaction != trap_handler as *const () as usize {
                     eprintln!(
                         "
 Wasmtime's signal handler was not the last signal handler to be installed