Refactor: make use of Store available during catch_traps and HostResult conversion.

Author: cfallin

crates/wasmtime/src/runtime/func.rs

@@ -7,14 +7,10 @@ use crate::runtime::vm::{
 };
 use crate::store::{AutoAssertNoGc, InstanceId, StoreId, StoreOpaque};
 use crate::type_registry::RegisteredType;
-#[cfg(feature = "gc")]
-use crate::vm::{ExceptionTombstone, VMGcRef};
 use crate::{
     AsContext, AsContextMut, CallHook, Engine, Extern, FuncType, Instance, ModuleExport, Ref,
     StoreContext, StoreContextMut, Val, ValRaw, ValType,
 };
-#[cfg(feature = "gc")]
-use crate::{ExnRef, Rooted};
 use alloc::sync::Arc;
 use core::ffi::c_void;
 #[cfg(feature = "async")]
@@ -1270,21 +1266,7 @@ impl Func {
 
         val_vec.extend((0..ty.results().len()).map(|_| Val::null_func_ref()));
         let (params, results) = val_vec.split_at_mut(nparams);
-        match func(caller.sub_caller(), params, results) {
-            Ok(()) => {}
-            #[cfg(feature = "gc")]
-            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);
-            }
-        }
+        func(caller.sub_caller(), params, results)?;
 
         // 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/store.rs

@@ -2247,6 +2247,7 @@ at https://bytecodealliance.org/security.
     /// must be done separately.
     #[cfg(feature = "gc")]
     pub(crate) fn set_pending_exception(&mut self, exnref: VMExnRef) {
+        debug_assert!(self.pending_exception.is_none());
         self.pending_exception = Some(exnref.into());
     }
 

crates/wasmtime/src/runtime/trap.rs

@@ -1,7 +1,7 @@
 #[cfg(feature = "coredump")]
 use super::coredump::WasmCoreDump;
 #[cfg(feature = "gc")]
-use super::{ExnRef, store::AutoAssertNoGc, vm::ExceptionTombstone};
+use super::{ExnRef, store::AutoAssertNoGc};
 use crate::prelude::*;
 use crate::store::StoreOpaque;
 use crate::{AsContext, Module};
@@ -82,7 +82,7 @@ pub(crate) fn from_runtime_box(
     } = *runtime_trap;
     let (mut error, pc) = match reason {
         #[cfg(feature = "gc")]
-        crate::runtime::vm::TrapReason::User(error) if error.is::<ExceptionTombstone>() => {
+        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())

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

@@ -168,7 +168,7 @@ fn memory_grow(
     mut instance: Pin<&mut Instance>,
     delta: u64,
     memory_index: u32,
-) -> Result<Option<AllocationSize>, TrapReason> {
+) -> Result<Option<AllocationSize>> {
     let memory_index = DefinedMemoryIndex::from_u32(memory_index);
     let module = instance.env_module();
     let page_size_log2 = module.memories[module.memory_index(memory_index)].page_size_log2;
@@ -1540,30 +1540,30 @@ fn cont_new(
     func: *mut u8,
     param_count: u32,
     result_count: u32,
-) -> Result<Option<AllocationSize>, TrapReason> {
+) -> Result<Option<AllocationSize>> {
     let ans =
         crate::vm::stack_switching::cont_new(store, instance, func, param_count, result_count)?;
     Ok(Some(AllocationSize(ans.cast::<u8>() as usize)))
 }
 
 #[cfg(feature = "gc")]
-unsafe fn get_instance_id(_store: &mut dyn VMStore, instance: Pin<&mut Instance>) -> u32 {
+fn get_instance_id(_store: &mut dyn VMStore, instance: Pin<&mut Instance>) -> u32 {
     instance.id().as_u32()
 }
 
 #[cfg(feature = "gc")]
-unsafe fn throw_ref(
+fn throw_ref(
     mut store: &mut dyn VMStore,
     _instance: Pin<&mut Instance>,
     exnref: u32,
 ) -> Result<(), TrapReason> {
-    use crate::{AsStoreOpaqueMut, vm::ExceptionTombstone};
+    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");
     store.as_store_opaque_mut().set_pending_exception(exnref);
-    Err(TrapReason::User(ExceptionTombstone.into()))
+    Err(TrapReason::Exception)
 }

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

@@ -306,7 +306,7 @@ pub fn cont_new(
     func: *mut u8,
     param_count: u32,
     result_count: u32,
-) -> Result<*mut VMContRef, crate::vm::TrapReason> {
+) -> anyhow::Result<*mut VMContRef> {
     let caller_vmctx = instance.vmctx();
 
     let stack_size = store.engine().config().async_stack_size;

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

@@ -5,19 +5,23 @@ use core::ptr::NonNull;
 use wasmtime_environ::TagIndex;
 use wasmtime_unwinder::{Frame, ThrowAction};
 
-use super::{VMContext, VMExnRef};
+use super::{VMContext, VMStore};
 use crate::store::AutoAssertNoGc;
 
-/// Implementation of exception throw.
+/// Compute the target of the pending exception on the store.
 ///
 /// # Safety
 ///
 /// 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) -> ThrowAction {
+pub unsafe fn compute_throw_action(store: &mut dyn VMStore) -> ThrowAction {
+    let mut nogc = AutoAssertNoGc::new(store.store_opaque_mut());
+
     // Get the tag identity relative to the store.
+    let exnref = nogc.take_pending_exception(); // Temporarily take, to avoid borrowing issues.
     let (throwing_tag_instance_id, throwing_tag_defined_tag_index) =
-        exnref.tag(nogc).expect("cannot read tag");
+        exnref.tag(&mut nogc).expect("cannot read tag");
+    nogc.set_pending_exception(exnref);
     log::trace!(
         "throwing: tag defined in instance {throwing_tag_instance_id:?} defined-tag {throwing_tag_defined_tag_index:?}"
     );