WIP.

Author: cfallin

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

@@ -630,6 +630,15 @@ impl ExnRef {
     }
 }
 
+/// Rooted<ExnRef> implements Error so that it can be boxed and
+/// returned in an `anyhow::Result` from host-to-Wasm function calls.
+impl core::error::Error for Rooted<ExnRef> {}
+impl core::fmt::Display for Rooted<ExnRef> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "Wasm exception")
+    }
+}
+
 unsafe impl WasmTy for Rooted<ExnRef> {
     #[inline]
     fn valtype() -> ValType {

crates/wasmtime/src/runtime/store.rs

@@ -123,7 +123,6 @@ 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;
@@ -1793,7 +1792,11 @@ impl StoreOpaque {
     #[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");
+        if let Some(pending_exception) = self.pending_exception.as_mut() {
+            unsafe {
+                gc_roots_list.add_root(pending_exception.into(), "Pending exception");
+            }
+        }
         log::trace!("End trace GC roots :: pending exception");
     }
 

crates/wasmtime/src/runtime/trap.rs

@@ -1,5 +1,7 @@
+use super::ExnRef;
 #[cfg(feature = "coredump")]
 use super::coredump::WasmCoreDump;
+use super::store::AutoAssertNoGc;
 use crate::prelude::*;
 use crate::store::StoreOpaque;
 use crate::{AsContext, Module};
@@ -110,6 +112,13 @@ pub(crate) fn from_runtime_box(
             (err, Some(pc))
         }
         crate::runtime::vm::TrapReason::Wasm(trap_code) => (trap_code.into(), None),
+        crate::runtime::vm::TrapReason::Exception => {
+            let mut nogc = AutoAssertNoGc::new(store);
+            let exnref = nogc.take_pending_exception();
+            let exnref = ExnRef::_from_raw(&mut nogc, exnref.as_gc_ref().as_raw_u32())
+                .expect("Exception should be non-null");
+            (exnref.into(), None)
+        }
     };
 
     if let Some(bt) = backtrace {

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

@@ -1533,13 +1533,13 @@ fn trap(
     ))
 }
 
-fn raise(_store: &mut dyn VMStore, _instance: Pin<&mut Instance>) {
+fn raise(store: &mut dyn VMStore, _instance: Pin<&mut Instance>) {
     // SAFETY: this is only called from compiled wasm so we know that wasm has
     // already been entered. It's a dynamic safety precondition that the trap
     // information has already been arranged to be present.
     #[cfg(has_host_compiler_backend)]
     unsafe {
-        crate::runtime::vm::traphandlers::raise_preexisting_trap()
+        crate::runtime::vm::traphandlers::raise_preexisting_trap(store)
     }
 
     // When Cranelift isn't in use then this is an unused libcall for Pulley, so

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

@@ -1,5 +1,7 @@
 //! Exception-throw logic for Wasm exceptions.
 
+use core::ptr::NonNull;
+
 use wasmtime_environ::TagIndex;
 use wasmtime_unwinder::{Frame, ThrowAction};
 

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

@@ -91,8 +91,9 @@ fn lazy_per_thread_init() {
 /// have been previously called. Additionally no Rust destructors can be on the
 /// stack. They will be skipped and not executed.
 #[cfg(has_host_compiler_backend)]
-pub(super) unsafe fn raise_preexisting_trap() -> ! {
-    tls::with(|info| unsafe { info.unwrap().unwind() })
+pub(super) unsafe fn raise_preexisting_trap(store: &mut dyn crate::vm::VMStore) -> ! {
+    let mut nogc = AutoAssertNoGc::new(store.store_opaque_mut());
+    tls::with(|info| unsafe { info.unwrap().unwind(&mut nogc) })
 }
 
 /// Invokes the closure `f` and returns a `bool` if it succeeded.
@@ -334,7 +335,8 @@ pub struct Trap {
     pub coredumpstack: Option<CoreDumpStack>,
 }
 
-/// Enumeration of different methods of raising a trap.
+/// Enumeration of different methods of raising a trap (or a sentinel
+/// for an exception).
 #[derive(Debug)]
 pub enum TrapReason {
     /// A user-raised trap through `raise_user_trap`.
@@ -756,7 +758,7 @@ impl CallThreadState {
             // An unwind due to an already-set pending exception sets
             // a special UnwindState that triggers the handler-search
             // stack-walk on unwind().
-            UnwindReason::Exception => {
+            UnwindReason::Trap(TrapReason::Exception) => {
                 self.unwind.set(UnwindState::ThrowException);
             }
             // And if we are just propagating an existing trap that already has
@@ -934,7 +936,7 @@ impl CallThreadState {
     ) {
         let backtrace = self.capture_backtrace(self.vm_store_context.as_ptr(), Some((pc, fp)));
         let coredump_stack = self.capture_coredump(self.vm_store_context.as_ptr(), Some((pc, fp)));
-        self.unwind.set(UnwindState::UnwindPastWasm {
+        self.unwind.set(UnwindState::UnwindToHost {
             reason: UnwindReason::Trap(TrapReason::Jit {
                 pc,
                 faulting_addr,