WIP.

Author: cfallin

crates/wasmtime/src/runtime/func.rs

@@ -2410,11 +2410,9 @@ 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(
-            caller_vmctx,
-            |caller| unsafe { Caller::with(caller_vmctx, run) },
-            |caller| unsafe { Caller::with(caller_vmctx, |caller| AutoAssertNoGc::new(caller)) },
-        )
+        crate::runtime::vm::catch_unwind_and_record_trap(move || unsafe {
+            Caller::with(caller_vmctx, run)
+        })
     }
 }
 

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

@@ -557,7 +557,7 @@ impl ExnRef {
         Ok(store.require_gc_store()?.header(gc_ref))
     }
 
-    pub(crate) fn exnref<'a>(&self, store: &'a AutoAssertNoGc<'_>) -> Result<&'a VMExnRef> {
+    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/trampoline/func.rs

@@ -3,7 +3,6 @@
 use crate::prelude::*;
 use crate::runtime::vm::{StoreBox, VMArrayCallHostFuncContext, VMContext, VMOpaqueContext};
 use crate::type_registry::RegisteredType;
-use crate::vm::InstanceAndStore;
 use crate::{FuncType, ValRaw};
 use core::ptr::NonNull;
 
@@ -35,32 +34,30 @@ unsafe extern "C" fn array_call_shim<F>(
 where
     F: Fn(NonNull<VMContext>, &mut [ValRaw]) -> Result<()> + 'static,
 {
-    InstanceAndStore::from_vmctx(vmctx, |pair| {
-        // Be sure to catch Rust panics to manually shepherd them across the wasm
-        // boundary, and then otherwise delegate as normal.
-        crate::runtime::vm::catch_unwind_and_record_trap(pair, |_| {
-            // SAFETY: this function itself requires that the `vmctx` is valid to
-            // use here.
-            let state = unsafe {
-                let vmctx = VMArrayCallHostFuncContext::from_opaque(vmctx);
-                vmctx.as_ref().host_state()
-            };
+    // Be sure to catch Rust panics to manually shepherd them across the wasm
+    // boundary, and then otherwise delegate as normal.
+    crate::runtime::vm::catch_unwind_and_record_trap(|| {
+        // SAFETY: this function itself requires that the `vmctx` is valid to
+        // use here.
+        let state = unsafe {
+            let vmctx = VMArrayCallHostFuncContext::from_opaque(vmctx);
+            vmctx.as_ref().host_state()
+        };
 
-            // Double-check ourselves in debug mode, but we control
-            // the `Any` here so an unsafe downcast should also
-            // work.
-            //
-            // SAFETY: this function is only usable with `TrampolineState<F>`.
-            let state = unsafe {
-                debug_assert!(state.is::<TrampolineState<F>>());
-                &*(state as *const _ as *const TrampolineState<F>)
-            };
-            let mut values_vec = NonNull::slice_from_raw_parts(values_vec, values_vec_len);
-            // SAFETY: it's a contract of this function itself that the values
-            // provided are valid to view as a slice.
-            let values_vec = unsafe { values_vec.as_mut() };
-            (state.func)(caller_vmctx, values_vec)
-        })
+        // Double-check ourselves in debug mode, but we control
+        // the `Any` here so an unsafe downcast should also
+        // work.
+        //
+        // SAFETY: this function is only usable with `TrampolineState<F>`.
+        let state = unsafe {
+            debug_assert!(state.is::<TrampolineState<F>>());
+            &*(state as *const _ as *const TrampolineState<F>)
+        };
+        let mut values_vec = NonNull::slice_from_raw_parts(values_vec, values_vec_len);
+        // SAFETY: it's a contract of this function itself that the values
+        // provided are valid to view as a slice.
+        let values_vec = unsafe { values_vec.as_mut() };
+        (state.func)(caller_vmctx, values_vec)
     })
 }
 

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

@@ -121,10 +121,9 @@ pub mod raw {
                 ) $(-> libcall!(@ty $result))? {
                     $(#[cfg($attr)])?
                     {
-                        InstanceAndStore::from_vmctx(vmctx, |pair| {
-                            crate::runtime::vm::traphandlers::catch_unwind_and_record_trap(pair, |pair| unsafe {
+                        crate::runtime::vm::traphandlers::catch_unwind_and_record_trap(|| unsafe {
+                            InstanceAndStore::from_vmctx(vmctx, |pair| {
                                 let (instance, store) = pair.unpack_mut();
-
                                 super::$name(store, instance, $($pname),*)
                             })
                         })

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

@@ -107,7 +107,7 @@ pub(super) unsafe fn raise_preexisting_trap() -> ! {
 ///
 /// * `Result<(), E>` - this represents an ABI return value of `bool` which
 ///   indicates whether the call succeeded. This return value will catch panics
-///   and record trap or exception information as `E`.
+///   and record trap information as `E`.
 ///
 /// * `Result<u32, E>` - the ABI return value here is `u64` where on success
 ///   the 32-bit result is zero-extended and `u64::MAX` as a return value
@@ -125,7 +125,7 @@ where
     // return value is always provided and if unwind information is provided
     // (e.g. `ret` is a "false"-y value) then it's recorded in TLS for the
     // unwind operation that's about to happen from Cranelift-generated code.
-    let (ret, unwind) = R::maybe_catch_unwind(|| f());
+    let (ret, unwind) = R::maybe_catch_unwind(f);
     if let Some(unwind) = unwind {
         tls::with(|info| info.unwrap().record_unwind(unwind));
     }
@@ -218,7 +218,7 @@ impl HostResult for NonNull<u8> {
 impl<T, E> HostResult for Result<T, E>
 where
     T: HostResultHasUnwindSentinel,
-    E: Into<UnwindReason>,
+    E: Into<TrapReason>,
 {
     type Abi = T::Abi;