working exception throw to/from host

Author: cfallin

crates/cranelift/src/compiler.rs

@@ -1374,10 +1374,21 @@ fn save_last_wasm_exit_fp_and_pc(
     ptr: &impl PtrSize,
     limits: Value,
 ) {
+    // Save the trampoline FP to the limits. Exception unwind needs
+    // this so that it can know the SP (bottom of frame) for the very
+    // last Wasm frame.
+    let trampoline_fp = builder.ins().get_frame_pointer(pointer_type);
+    builder.ins().store(
+        MemFlags::trusted(),
+        trampoline_fp,
+        limits,
+        ptr.vmstore_context_last_wasm_exit_trampoline_fp(),
+    );
+
     // Save the exit Wasm FP to the limits. We dereference the current FP to get
     // the previous FP because the current FP is the trampoline's FP, and we
     // want the Wasm function's FP, which is the caller of this trampoline.
-    let trampoline_fp = builder.ins().get_frame_pointer(pointer_type);
+
     let wasm_fp = builder.ins().load(
         pointer_type,
         MemFlags::trusted(),

crates/environ/src/vmoffsets.rs

@@ -190,20 +190,26 @@ pub trait PtrSize {
     /// Return the offset of the `gc_heap.base` field within a `VMStoreContext`.
     fn vmstore_context_gc_heap_base(&self) -> u8 {
         let offset = self.vmstore_context_gc_heap() + self.vmmemory_definition_base();
-        debug_assert!(offset < self.vmstore_context_last_wasm_exit_fp());
+        debug_assert!(offset < self.vmstore_context_last_wasm_exit_trampoline_fp());
         offset
     }
 
     /// Return the offset of the `gc_heap.current_length` field within a `VMStoreContext`.
     fn vmstore_context_gc_heap_current_length(&self) -> u8 {
         let offset = self.vmstore_context_gc_heap() + self.vmmemory_definition_current_length();
-        debug_assert!(offset < self.vmstore_context_last_wasm_exit_fp());
+        debug_assert!(offset < self.vmstore_context_last_wasm_exit_trampoline_fp());
         offset
     }
 
+    /// Return the offset of the `last_wasm_exit_trampoline_fp` field
+    /// of `VMStoreContext`.
+    fn vmstore_context_last_wasm_exit_trampoline_fp(&self) -> u8 {
+        self.vmstore_context_gc_heap() + self.size_of_vmmemory_definition()
+    }
+
     /// Return the offset of the `last_wasm_exit_fp` field of `VMStoreContext`.
     fn vmstore_context_last_wasm_exit_fp(&self) -> u8 {
-        self.vmstore_context_gc_heap() + self.size_of_vmmemory_definition()
+        self.vmstore_context_last_wasm_exit_trampoline_fp() + self.size()
     }
 
     /// Return the offset of the `last_wasm_exit_pc` field of `VMStoreContext`.

crates/unwinder/src/throw.rs

@@ -50,33 +50,39 @@ pub unsafe fn compute_throw_action<F: Fn(&Frame) -> Option<usize>>(
     unwind: &dyn Unwind,
     frame_handler: F,
     exit_pc: usize,
-    exit_frame: usize,
+    exit_trampoline_frame: usize,
     entry_frame: usize,
 ) -> ThrowAction {
     // SAFETY: the safety of `visit_frames` relies on the correctness of the
     // parameters passed in which is forwarded as a contract to this function
     // tiself.
     let result = unsafe {
-        crate::stackwalk::visit_frames(unwind, exit_pc, exit_frame, entry_frame, |frame| {
-            log::trace!("visit_frame: frame {frame:?}");
-            let Some(sp) = frame.sp() else {
-                // Cannot possibly unwind to this frame if SP is not
-                // known. This is only the case for the first
-                // (trampoline) frame; after that, we know SP at the
-                // callsite because we know the offset from the lower
-                // FP to the next frame's SP.
-                return ControlFlow::Continue(());
-            };
+        crate::stackwalk::visit_frames(
+            unwind,
+            exit_pc,
+            exit_trampoline_frame,
+            entry_frame,
+            |frame| {
+                log::trace!("visit_frame: frame {frame:?}");
+                let Some(sp) = frame.sp() else {
+                    // Cannot possibly unwind to this frame if SP is not
+                    // known. This is only the case for the first
+                    // (trampoline) frame; after that, we know SP at the
+                    // callsite because we know the offset from the lower
+                    // FP to the next frame's SP.
+                    return ControlFlow::Continue(());
+                };
 
-            if let Some(handler_pc) = frame_handler(&frame) {
-                return ControlFlow::Break(ThrowAction::Handler {
-                    pc: handler_pc,
-                    sp,
-                    fp: frame.fp(),
-                });
-            }
-            ControlFlow::Continue(())
-        })
+                if let Some(handler_pc) = frame_handler(&frame) {
+                    return ControlFlow::Break(ThrowAction::Handler {
+                        pc: handler_pc,
+                        sp,
+                        fp: frame.fp(),
+                    });
+                }
+                ControlFlow::Continue(())
+            },
+        )
     };
     match result {
         ControlFlow::Break(action) => action,

crates/wasmtime/src/runtime/func.rs

@@ -1546,6 +1546,9 @@ pub(crate) struct EntryStoreContext {
     /// Contains value of `last_wasm_exit_fp` field to restore in
     /// `VMStoreContext` when exiting Wasm.
     pub last_wasm_exit_fp: usize,
+    /// Contains value of `last_wasm_exit_trampoline_fp` field to restore in
+    /// `VMStoreContext` when exiting Wasm.
+    pub last_wasm_exit_trampoline_fp: usize,
     /// Contains value of `last_wasm_entry_fp` field to restore in
     /// `VMStoreContext` when exiting Wasm.
     pub last_wasm_entry_fp: usize,
@@ -1639,6 +1642,11 @@ impl EntryStoreContext {
         unsafe {
             let last_wasm_exit_pc = *store.0.vm_store_context().last_wasm_exit_pc.get();
             let last_wasm_exit_fp = *store.0.vm_store_context().last_wasm_exit_fp.get();
+            let last_wasm_exit_trampoline_fp = *store
+                .0
+                .vm_store_context()
+                .last_wasm_exit_trampoline_fp
+                .get();
             let last_wasm_entry_fp = *store.0.vm_store_context().last_wasm_entry_fp.get();
 
             let stack_chain = (*store.0.vm_store_context().stack_chain.get()).clone();
@@ -1652,6 +1660,7 @@ impl EntryStoreContext {
                 stack_limit,
                 last_wasm_exit_pc,
                 last_wasm_exit_fp,
+                last_wasm_exit_trampoline_fp,
                 last_wasm_entry_fp,
                 stack_chain,
                 vm_store_context,
@@ -1671,6 +1680,8 @@ impl EntryStoreContext {
             }
 
             *(*self.vm_store_context).last_wasm_exit_fp.get() = self.last_wasm_exit_fp;
+            *(*self.vm_store_context).last_wasm_exit_trampoline_fp.get() =
+                self.last_wasm_exit_trampoline_fp;
             *(*self.vm_store_context).last_wasm_exit_pc.get() = self.last_wasm_exit_pc;
             *(*self.vm_store_context).last_wasm_entry_fp.get() = self.last_wasm_entry_fp;
             *(*self.vm_store_context).stack_chain.get() = self.stack_chain.clone();

crates/wasmtime/src/runtime/vm/throw.rs

@@ -23,10 +23,10 @@ pub unsafe fn compute_throw(nogc: &mut AutoAssertNoGc, exnref: &VMExnRef) -> Thr
     );
 
     // Get the state needed for a stack walk.
-    let (exit_pc, exit_fp, entry_fp) = unsafe {
+    let (exit_pc, exit_trampoline_fp, entry_fp) = unsafe {
         (
             *nogc.vm_store_context().last_wasm_exit_pc.get(),
-            *nogc.vm_store_context().last_wasm_exit_fp.get(),
+            *nogc.vm_store_context().last_wasm_exit_trampoline_fp.get(),
             *nogc.vm_store_context().last_wasm_entry_fp.get(),
         )
     };
@@ -104,7 +104,7 @@ pub unsafe fn compute_throw(nogc: &mut AutoAssertNoGc, exnref: &VMExnRef) -> Thr
             &wasmtime_unwinder::UnwindHost,
             handler_lookup,
             exit_pc,
-            exit_fp,
+            exit_trampoline_fp,
             entry_fp,
         )
     };

crates/wasmtime/src/runtime/vm/traphandlers.rs

@@ -681,6 +681,10 @@ mod call_thread_state {
                     &cx.last_wasm_exit_fp,
                     &mut (*self.old_state).last_wasm_exit_fp,
                 );
+                swap(
+                    &cx.last_wasm_exit_trampoline_fp,
+                    &mut (*self.old_state).last_wasm_exit_trampoline_fp,
+                );
                 swap(
                     &cx.last_wasm_exit_pc,
                     &mut (*self.old_state).last_wasm_exit_pc,

crates/wasmtime/src/runtime/vm/vmcontext.rs

@@ -1109,6 +1109,19 @@ pub struct VMStoreContext {
     /// The `VMMemoryDefinition` for this store's GC heap.
     pub gc_heap: VMMemoryDefinition,
 
+    /// The value of the frame pointer register in the trampoline used
+    /// to call from Wasm to the host.
+    ///
+    /// Maintained by our Wasm-to-host trampoline, and cleared just
+    /// before calling into Wasm in `catch_traps`.
+    ///
+    /// This member is `0` when Wasm is actively running and has not called out
+    /// to the host.
+    ///
+    /// Used to find the size of the bottom-most Wasm frame (relative
+    /// to `last_wasm_exit_fp`) when walking the stack.
+    pub last_wasm_exit_trampoline_fp: UnsafeCell<usize>,
+
     /// The value of the frame pointer register when we last called from Wasm to
     /// the host.
     ///
@@ -1189,6 +1202,7 @@ impl Default for VMStoreContext {
                 current_length: AtomicUsize::new(0),
             },
             last_wasm_exit_fp: UnsafeCell::new(0),
+            last_wasm_exit_trampoline_fp: UnsafeCell::new(0),
             last_wasm_exit_pc: UnsafeCell::new(0),
             last_wasm_entry_fp: UnsafeCell::new(0),
             stack_chain: UnsafeCell::new(VMStackChain::Absent),
@@ -1231,6 +1245,10 @@ mod test_vmstore_context {
             offset_of!(VMStoreContext, gc_heap) + offset_of!(VMMemoryDefinition, current_length),
             usize::from(offsets.ptr.vmstore_context_gc_heap_current_length())
         );
+        assert_eq!(
+            offset_of!(VMStoreContext, last_wasm_exit_trampoline_fp),
+            usize::from(offsets.ptr.vmstore_context_last_wasm_exit_trampoline_fp())
+        );
         assert_eq!(
             offset_of!(VMStoreContext, last_wasm_exit_fp),
             usize::from(offsets.ptr.vmstore_context_last_wasm_exit_fp())