direct host-to-host functions work too

Author: cfallin

crates/wasmtime/src/runtime/func.rs

@@ -1527,7 +1527,7 @@ pub(crate) fn invoke_wasm_and_catch_traps<T>(
         let result = crate::runtime::vm::catch_traps(store, &mut previous_runtime_state, closure);
         core::mem::drop(previous_runtime_state);
         store.0.call_hook(CallHook::ReturningFromWasm)?;
-        result.map_err(|t| crate::trap::from_runtime_box(store.0, t))
+        result
     }
 }
 

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

@@ -20,7 +20,7 @@ use crate::runtime::store::{ExecutorRef, StoreOpaque};
 use crate::runtime::vm::sys::traphandlers;
 use crate::runtime::vm::{InterpreterRef, VMContext, VMStoreContext, f32x4, f64x2, i8x16};
 use crate::store::AutoAssertNoGc;
-use crate::{EntryStoreContext, prelude::*};
+use crate::{EntryStoreContext, ExnRef, prelude::*};
 use crate::{StoreContextMut, WasmBacktrace};
 use core::cell::Cell;
 use core::num::NonZeroU32;
@@ -415,7 +415,7 @@ pub unsafe fn catch_traps<T, F>(
     store: &mut StoreContextMut<'_, T>,
     old_state: &mut EntryStoreContext,
     mut closure: F,
-) -> Result<(), Box<Trap>>
+) -> Result<()>
 where
     F: FnMut(NonNull<VMContext>, Option<InterpreterRef<'_>>) -> bool,
 {
@@ -461,16 +461,40 @@ where
         },
     });
 
-    return match result {
+    match result {
         Ok(x) => Ok(x),
-        Err((UnwindReason::Trap(reason), backtrace, coredumpstack)) => Err(Box::new(Trap {
-            reason,
+        Err(UnwindState::UnwindToHost {
+            reason: UnwindReason::Trap(reason),
             backtrace,
-            coredumpstack,
-        })),
+            coredump_stack,
+        }) => Err(crate::trap::from_runtime_box(
+            store.0,
+            Box::new(Trap {
+                reason,
+                backtrace,
+                coredumpstack: coredump_stack,
+            }),
+        )),
         #[cfg(all(feature = "std", panic = "unwind"))]
-        Err((UnwindReason::Panic(panic), _, _)) => std::panic::resume_unwind(panic),
-    };
+        Err(UnwindState::UnwindToHost {
+            reason: UnwindReason::Panic(panic),
+            ..
+        }) => std::panic::resume_unwind(panic),
+        #[cfg(feature = "gc")]
+        Err(UnwindState::ThrowException) => {
+            // We may have gotten here if a host function (created via
+            // `Func::new`) was called directly with `Func::call` and
+            // returned an exception: in that case, no trampoline to
+            // call `unwind()` exists, so we have to fetch the pending
+            // exception explicitly here.
+            let exnref = store.0.take_pending_exception();
+            let exnref = ExnRef::from_raw(store, exnref.as_gc_ref().as_raw_u32()).unwrap();
+            Err(exnref.into())
+        }
+        Err(UnwindState::None) => {
+            unreachable!("We should not have gotten an error with no unwind state");
+        }
+    }
 }
 
 // Module to hide visibility of the `CallThreadState::prev` field and force
@@ -719,32 +743,18 @@ where
 
 impl CallThreadState {
     #[inline]
-    fn with(
-        mut self,
-        closure: impl FnOnce(&CallThreadState) -> bool,
-    ) -> Result<(), (UnwindReason, Option<Backtrace>, Option<CoreDumpStack>)> {
+    fn with(mut self, closure: impl FnOnce(&CallThreadState) -> bool) -> Result<(), UnwindState> {
         let succeeded = tls::set(&mut self, |me| closure(me));
         if succeeded {
             Ok(())
         } else {
-            Err(self.read_unwind_to_host())
+            Err(self.read_unwind())
         }
     }
 
     #[cold]
-    fn read_unwind_to_host(&self) -> (UnwindReason, Option<Backtrace>, Option<CoreDumpStack>) {
-        match self.unwind.replace(UnwindState::None) {
-            UnwindState::UnwindToHost {
-                reason,
-                backtrace,
-                coredump_stack,
-            } => (reason, backtrace, coredump_stack),
-            #[cfg(feature = "gc")]
-            UnwindState::ThrowException => {
-                panic!("Exception should have been resolved by unwind() before reaching caller")
-            }
-            UnwindState::None => panic!("No unwind state with erroneous return code"),
-        }
+    fn read_unwind(&self) -> UnwindState {
+        self.unwind.replace(UnwindState::None)
     }
 
     /// Records the unwind information provided within this `CallThreadState`,

tests/all/exceptions.rs

@@ -168,3 +168,28 @@ fn exception_from_host() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn exception_across_no_wasm() -> Result<()> {
+    let mut store = gc_and_exceptions_store()?;
+    let engine = store.engine();
+
+    let functy = FuncType::new(&engine, [ValType::I32], []);
+    let tagty = TagType::new(functy.clone());
+    let exnty = ExnType::from_tag_type(&tagty).unwrap();
+    let exnpre = ExnRefPre::new(&mut store, exnty);
+    let tag = Tag::new(&mut store, &tagty)?;
+    let extfunc = Func::new(&mut store, functy, move |caller, args, _rets| {
+        let exn = ExnRef::new(caller, &exnpre, &tag, &[Val::I32(args[0].unwrap_i32())]).unwrap();
+        Err(exn.into())
+    });
+    let mut results = [];
+    let result = extfunc.call(&mut store, &[Val::I32(42)], &mut results[..]);
+    assert!(result.is_err());
+    let exn = result.unwrap_err().downcast::<Rooted<ExnRef>>().unwrap();
+    let exntag = exn.tag(&mut store)?;
+    assert!(Tag::eq(&exntag, &tag, &store));
+    assert_eq!(exn.field(&mut store, 0)?.unwrap_i32(), 42);
+
+    Ok(())
+}