WIP.

Author: cfallin

crates/wasmtime/src/runtime/func.rs

@@ -2410,9 +2410,11 @@ impl HostContext {
         //
         // SAFETY: this is an entrypoint of wasm which requires correct type
         // ascription of `T` itself, meaning that this should be safe to call.
-        crate::runtime::vm::catch_unwind_and_record_trap(move || unsafe {
-            Caller::with(caller_vmctx, run)
-        })
+        crate::runtime::vm::catch_unwind_and_record_trap(
+            caller_vmctx,
+            |caller| unsafe { Caller::with(caller_vmctx, run) },
+            |caller| unsafe { Caller::with(caller_vmctx, |caller| AutoAssertNoGc::new(caller)) },
+        )
     }
 }
 

crates/wasmtime/src/runtime/gc/enabled/exnref.rs

@@ -557,7 +557,7 @@ impl ExnRef {
         Ok(store.require_gc_store()?.header(gc_ref))
     }
 
-    fn exnref<'a>(&self, store: &'a AutoAssertNoGc<'_>) -> Result<&'a VMExnRef> {
+    pub(crate) fn exnref<'a>(&self, store: &'a AutoAssertNoGc<'_>) -> Result<&'a VMExnRef> {
         assert!(self.comes_from_same_store(&store));
         let gc_ref = self.inner.try_gc_ref(store)?;
         debug_assert!(self.header(store)?.kind().matches(VMGcKind::ExnRef));

crates/wasmtime/src/runtime/store.rs

@@ -122,6 +122,9 @@ pub(crate) use token::StoreToken;
 mod async_;
 #[cfg(all(feature = "async", feature = "call-hook"))]
 pub use self::async_::CallHookHandler;
+
+use super::ExnRef;
+use super::vm::VMExnRef;
 #[cfg(feature = "gc")]
 mod gc;
 
@@ -355,6 +358,12 @@ pub struct StoreOpaque {
     // Types for which the embedder has created an allocator for.
     #[cfg(feature = "gc")]
     gc_host_alloc_types: crate::hash_set::HashSet<crate::type_registry::RegisteredType>,
+    /// Pending exception, if any. This is also a GC root, because it
+    /// needs to be rooted somewhere between the time that a pending
+    /// exception is set and the time that the Wasm-to-host entry
+    /// trampoline starts the unwind (right before it would return).
+    #[cfg(feature = "gc")]
+    pending_exception: Option<VMGcRef>,
 
     // Numbers of resources instantiated in this store, and their limits
     instance_count: usize,
@@ -573,6 +582,8 @@ impl<T> Store<T> {
             gc_roots_list: GcRootsList::default(),
             #[cfg(feature = "gc")]
             gc_host_alloc_types: Default::default(),
+            #[cfg(feature = "gc")]
+            pending_exception: None,
             modules: ModuleRegistry::default(),
             func_refs: FuncRefs::default(),
             host_globals: PrimaryMap::new(),
@@ -1657,6 +1668,7 @@ impl StoreOpaque {
         self.trace_wasm_continuation_roots(gc_roots_list);
         self.trace_vmctx_roots(gc_roots_list);
         self.trace_user_roots(gc_roots_list);
+        self.trace_pending_exception_roots(gc_roots_list);
 
         log::trace!("End trace GC roots")
     }
@@ -1778,6 +1790,13 @@ impl StoreOpaque {
         log::trace!("End trace GC roots :: user");
     }
 
+    #[cfg(feature = "gc")]
+    fn trace_pending_exception_roots(&mut self, gc_roots_list: &mut GcRootsList) {
+        log::trace!("Begin trace GC roots :: pending exception");
+        gc_roots_list.add_root(self.pending_exception.as_mut().into(), "Pending exception");
+        log::trace!("End trace GC roots :: pending exception");
+    }
+
     /// Insert a host-allocated GC type into this store.
     ///
     /// This makes it suitable for the embedder to allocate instances of this
@@ -2217,6 +2236,24 @@ at https://bytecodealliance.org/security.
 
         Ok(id)
     }
+
+    /// Set a pending exception. The `exnref` is taken and held on
+    /// this store to be fetched later by an unwind. This method does
+    /// *not* set up an unwind request on the TLS call state; that
+    /// must be done separately.
+    #[cfg(feature = "gc")]
+    pub(crate) fn set_pending_exception(&mut self, exnref: VMExnRef) {
+        self.pending_exception = Some(exnref.into());
+    }
+
+    /// Take a pending exception.
+    #[cfg(feature = "gc")]
+    pub(crate) fn take_pending_exception(&mut self) -> VMExnRef {
+        self.pending_exception
+            .take()
+            .expect("No pending exception set")
+            .into_exnref_unchecked()
+    }
 }
 
 /// Helper parameter to [`StoreOpaque::allocate_instance`].

crates/wasmtime/src/runtime/store/async_.rs

@@ -230,6 +230,8 @@ impl StoreOpaque {
         self.trace_vmctx_roots(gc_roots_list);
         Yield::new().await;
         self.trace_user_roots(gc_roots_list);
+        Yield::new().await;
+        self.trace_pending_exception_roots(gc_roots_list);
 
         log::trace!("End trace GC roots")
     }

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

@@ -1571,15 +1571,17 @@ unsafe fn get_instance_id(_store: &mut dyn VMStore, instance: Pin<&mut Instance>
 
 #[cfg(feature = "gc")]
 unsafe fn throw_ref(
-    store: &mut dyn VMStore,
+    mut store: &mut dyn VMStore,
     _instance: Pin<&mut Instance>,
     exnref: u32,
-) -> Result<()> {
-    use super::TrapOrException;
+) -> Result<(), TrapReason> {
+    use crate::AsStoreOpaqueMut;
 
     let exnref = VMGcRef::from_raw_u32(exnref).ok_or_else(|| Trap::NullReference)?;
+    let exnref = store.unwrap_gc_store_mut().clone_gc_ref(&exnref);
     let exnref = exnref
         .into_exnref(&*store.unwrap_gc_store().gc_heap)
         .expect("gc ref should be an exception object");
-    Err(TrapOrException::Exception(exnref))
+    store.as_store_opaque_mut().set_pending_exception(exnref);
+    Err(TrapReason::Exception)
 }

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

@@ -1,11 +1,9 @@
 //! Exception-throw logic for Wasm exceptions.
 
-use core::ptr::NonNull;
-
 use wasmtime_environ::TagIndex;
 use wasmtime_unwinder::{Frame, ThrowAction};
 
-use super::{UnwindReason, UnwindState, VMContext, VMExnRef};
+use super::{VMContext, VMExnRef};
 use crate::store::AutoAssertNoGc;
 
 /// Implementation of exception throw.
@@ -14,7 +12,7 @@ use crate::store::AutoAssertNoGc;
 ///
 /// Must be invoked when Wasm is in the stack and control has
 /// re-entered the runtime.
-pub unsafe fn compute_throw(nogc: &mut AutoAssertNoGc, exnref: VMExnRef) -> UnwindState {
+pub unsafe fn compute_throw(nogc: &mut AutoAssertNoGc, exnref: &VMExnRef) -> ThrowAction {
     // Get the tag identity relative to the store.
     let (throwing_tag_instance_id, throwing_tag_defined_tag_index) =
         exnref.tag(nogc).expect("cannot read tag");
@@ -110,20 +108,5 @@ pub unsafe fn compute_throw(nogc: &mut AutoAssertNoGc, exnref: VMExnRef) -> Unwi
     };
 
     log::trace!("throw action: {action:?}");
-
-    match action {
-        ThrowAction::Handler { pc, sp, fp } => UnwindState::UnwindIntoWasm {
-            pc,
-            sp,
-            fp,
-            payload1: usize::try_from(exnref.as_gc_ref().as_raw_u32())
-                .expect("gcref does not fit in usize"),
-            payload2: 0,
-        },
-        ThrowAction::None => UnwindState::UnwindPastWasm {
-            reason: UnwindReason::Exception(exnref),
-            backtrace: None,
-            coredump_stack: None,
-        },
-    }
+    action
 }