WIP.

Author: cfallin

crates/environ/src/trap_encoding.rs

@@ -107,10 +107,6 @@ pub enum Trap {
     /// that all host tasks have completed and any/all host-owned stream/future
     /// handles have been dropped.
     AsyncDeadlock,
-
-    /// An exception was thrown out of Wasm into the host and this is
-    /// not supported in the current configuration.
-    ExceptionToHost,
     // if adding a variant here be sure to update the `check!` macro below
 }
 
@@ -152,7 +148,6 @@ impl Trap {
             ContinuationAlreadyConsumed
             DisabledOpcode
             AsyncDeadlock
-            ExceptionToHost
         }
 
         None
@@ -188,7 +183,6 @@ impl fmt::Display for Trap {
             ContinuationAlreadyConsumed => "continuation already consumed",
             DisabledOpcode => "pulley opcode disabled at compile time was executed",
             AsyncDeadlock => "deadlock detected: event loop cannot make further progress",
-            ExceptionToHost => "Wasm exception thrown across host boundary",
         };
         write!(f, "wasm trap: {desc}")
     }

crates/unwinder/src/throw.rs

@@ -58,6 +58,7 @@ pub unsafe fn compute_throw_action<F: Fn(&Frame) -> Option<usize>>(
     // 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

crates/wasmtime/src/runtime/func.rs

@@ -1,15 +1,16 @@
-use crate::prelude::*;
 use crate::runtime::Uninhabited;
 use crate::runtime::vm::{
     InterpreterRef, SendSyncPtr, StoreBox, VMArrayCallHostFuncContext, VMCommonStackInformation,
     VMContext, VMFuncRef, VMFunctionImport, VMOpaqueContext, VMStoreContext,
 };
 use crate::store::{AutoAssertNoGc, StoreId, StoreOpaque};
 use crate::type_registry::RegisteredType;
+use crate::vm::{ExceptionTombstone, VMGcRef};
 use crate::{
     AsContext, AsContextMut, CallHook, Engine, Extern, FuncType, Instance, ModuleExport, Ref,
     StoreContext, StoreContextMut, Val, ValRaw, ValType,
 };
+use crate::{ExnRef, Rooted, prelude::*};
 use alloc::sync::Arc;
 use core::ffi::c_void;
 #[cfg(feature = "async")]
@@ -1265,7 +1266,20 @@ impl Func {
 
         val_vec.extend((0..ty.results().len()).map(|_| Val::null_func_ref()));
         let (params, results) = val_vec.split_at_mut(nparams);
-        func(caller.sub_caller(), params, results)?;
+        match func(caller.sub_caller(), params, results) {
+            Ok(()) => {}
+            Err(e) if e.is::<Rooted<ExnRef>>() => {
+                let exnref = e.downcast::<Rooted<ExnRef>>().unwrap();
+                let exnref = VMGcRef::from_raw_u32(exnref.to_raw(&mut caller.store.0).unwrap())
+                    .unwrap()
+                    .into_exnref_unchecked();
+                caller.store.0.set_pending_exception(exnref);
+                return Err(ExceptionTombstone.into());
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        }
 
         // Unlike our arguments we need to dynamically check that the return
         // values produced are correct. There could be a bug in `func` that

crates/wasmtime/src/runtime/trap.rs

@@ -2,6 +2,7 @@ use super::ExnRef;
 #[cfg(feature = "coredump")]
 use super::coredump::WasmCoreDump;
 use super::store::AutoAssertNoGc;
+use super::vm::ExceptionTombstone;
 use crate::prelude::*;
 use crate::store::StoreOpaque;
 use crate::{AsContext, Module};
@@ -81,6 +82,14 @@ pub(crate) fn from_runtime_box(
         coredumpstack,
     } = *runtime_trap;
     let (mut error, pc) = match reason {
+        crate::runtime::vm::TrapReason::User(error) if error.is::<ExceptionTombstone>() => {
+            println!("from_runtime_box: ExceptionTombstone");
+            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)
+        }
         // For user-defined errors they're already an `anyhow::Error` so no
         // conversion is really necessary here, but a `backtrace` may have
         // been captured so it's attempted to get inserted here.
@@ -112,13 +121,6 @@ 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

@@ -1574,13 +1574,13 @@ unsafe fn throw_ref(
     _instance: Pin<&mut Instance>,
     exnref: u32,
 ) -> Result<(), TrapReason> {
-    use crate::AsStoreOpaqueMut;
+    use crate::{AsStoreOpaqueMut, vm::ExceptionTombstone};
 
     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");
     store.as_store_opaque_mut().set_pending_exception(exnref);
-    Err(TrapReason::Exception)
+    Err(TrapReason::User(ExceptionTombstone.into()))
 }

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

@@ -367,9 +367,29 @@ pub enum TrapReason {
 
     /// A trap raised from a wasm libcall
     Wasm(wasmtime_environ::Trap),
+}
 
-    /// A pending exception (stored in and rooted by the `Store`).
-    Exception,
+/// Special tombstone Error object that we use to indicate a thrown
+/// exception. We use this tombstone directly in the libcall
+/// implementing `throw_ref` (throws from Wasm), and we create the
+/// tombstone when intercepting a `Rooted<ExnRef>` when wrapping a
+/// host function into a `Func`.
+///
+/// This will be captured in a `TrapReason::User` as a boxed
+/// error. When provided as a `TrapReason`, the rooted
+/// pending-exception slot on the `Store` must have already been
+/// set. Both of the above creation sites ensure this invariant.
+pub(crate) struct ExceptionTombstone;
+impl core::error::Error for ExceptionTombstone {}
+impl core::fmt::Debug for ExceptionTombstone {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "Wasm exception")
+    }
+}
+impl core::fmt::Display for ExceptionTombstone {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "Wasm exception")
+    }
 }
 
 impl From<Error> for TrapReason {
@@ -758,7 +778,10 @@ 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::Trap(TrapReason::Exception) => {
+            UnwindReason::Trap(TrapReason::User(err))
+                if err.downcast_ref::<ExceptionTombstone>().is_some() =>
+            {
+                println!("record_unwind: ExceptionTombstone");
                 self.unwind.set(UnwindState::ThrowException);
             }
             // And if we are just propagating an existing trap that already has
@@ -799,7 +822,9 @@ impl CallThreadState {
         use wasmtime_unwinder::ThrowAction;
 
         let mut unwind = self.unwind.replace(UnwindState::None);
+        println!("unwind!");
         if let UnwindState::ThrowException = &unwind {
+            println!("throw exception");
             // Take the pending exception from the store and resolve its throw action.
             let exnref = nogc.take_pending_exception();
             let action = unsafe { compute_throw(nogc, &exnref) };
@@ -816,10 +841,11 @@ impl CallThreadState {
                     );
                 },
                 ThrowAction::None => {
+                    println!("no handler");
                     // Throw all the way to entry from host, and put the exnref back on the store.
                     nogc.set_pending_exception(exnref);
                     unwind = UnwindState::UnwindToHost {
-                        reason: UnwindReason::Trap(TrapReason::Exception),
+                        reason: UnwindReason::Trap(TrapReason::User(ExceptionTombstone.into())),
                         backtrace: None,
                         coredump_stack: None,
                     }

tests/all/exceptions.rs

@@ -104,22 +104,67 @@ fn exception_escape_to_host() -> Result<()> {
         &engine,
         r#"
         (module
-          (tag $e0)
+          (import "test" "e0" (tag $e0 (param i32)))
 
           (func $throw (export "throw")
-                (throw $e0)))
+                (throw $e0 (i32.const 42))))
           "#,
     )?;
 
-    let instance = Instance::new(&mut store, &module, &[])?;
+    let functy = FuncType::new(&engine, [ValType::I32], []);
+    let tagty = TagType::new(functy);
+    let tag = Tag::new(&mut store, &tagty)?;
+    let instance = Instance::new(&mut store, &module, &[Extern::Tag(tag)])?;
     let func = instance.get_func(&mut store, "throw").unwrap();
     let mut results = [];
     let result = func.call(&mut store, &[], &mut results[..]);
     assert!(result.is_err());
-    assert_eq!(
-        result.unwrap_err().downcast::<Trap>().unwrap(),
-        Trap::ExceptionToHost
-    );
+    let exn = result.unwrap_err().downcast::<Rooted<ExnRef>>().unwrap();
+    let exntag = exn.tag(&mut store)?;
+    assert!(Tag::eq(&exntag, &tag, &store));
+
+    Ok(())
+}
+
+#[test]
+fn exception_from_host() -> Result<()> {
+    let mut store = gc_and_exceptions_store()?;
+    let engine = store.engine();
+
+    let module = Module::new(
+        &engine,
+        r#"
+        (module
+          (import "test" "e0" (tag $e0 (param i32)))
+          (import "test" "f" (func $f (param i32)))
+
+          (func $catch (export "catch") (result i32)
+                (block $b (result i32)
+                  (try_table (result i32) (catch $e0 $b)
+                   i32.const 42
+                   call $f
+                   i32.const 0))))
+          "#,
+    )?;
+
+    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 instance = Instance::new(
+        &mut store,
+        &module,
+        &[Extern::Tag(tag), Extern::Func(extfunc)],
+    )?;
+    let func = instance.get_func(&mut store, "catch").unwrap();
+    let mut results = [Val::null_any_ref()];
+    func.call(&mut store, &[], &mut results[..])?;
+    assert_eq!(results[0].unwrap_i32(), 42);
 
     Ok(())
 }