Return anyhow::Error from host functions instead of Trap, redesign Trap

cranelift/codegen/src/ir/immediates.rs

@@ -473,7 +473,7 @@ impl FromStr for Offset32 {
 /// containing the bit pattern.
 ///
 /// We specifically avoid using a f32 here since some architectures may silently alter floats.
-/// See: https://github.com/bytecodealliance/wasmtime/pull/2251#discussion_r498508646
+/// See: <https://github.com/bytecodealliance/wasmtime/pull/2251#discussion_r498508646>
 ///
 /// The [PartialEq] and [Hash] implementations are over the underlying bit pattern, but
 /// [PartialOrd] respects IEEE754 semantics.
@@ -488,7 +488,7 @@ pub struct Ieee32(u32);
 /// containing the bit pattern.
 ///
 /// We specifically avoid using a f64 here since some architectures may silently alter floats.
-/// See: https://github.com/bytecodealliance/wasmtime/pull/2251#discussion_r498508646
+/// See: <https://github.com/bytecodealliance/wasmtime/pull/2251#discussion_r498508646>
 ///
 /// The [PartialEq] and [Hash] implementations are over the underlying bit pattern, but
 /// [PartialOrd] respects IEEE754 semantics.

crates/bench-api/src/lib.rs

@@ -136,14 +136,14 @@
 mod unsafe_send_sync;
 
 use crate::unsafe_send_sync::UnsafeSendSync;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use std::os::raw::{c_int, c_void};
 use std::slice;
 use std::{env, path::PathBuf};
 use target_lexicon::Triple;
 use wasmtime::{Config, Engine, Instance, Linker, Module, Store};
 use wasmtime_cli_flags::{CommonOptions, WasiModules};
-use wasmtime_wasi::{sync::WasiCtxBuilder, WasiCtx};
+use wasmtime_wasi::{sync::WasiCtxBuilder, I32Exit, WasiCtx};
 
 pub type ExitCode = c_int;
 pub const OK: ExitCode = 0;
@@ -539,14 +539,13 @@ impl BenchState {
  Err(trap) => {
  // Since _start will likely return by using the system `exit` call, we must
  // check the trap code to see if it actually represents a successful exit.
- match trap.i32_exit_status() {
- Some(0) => Ok(()),
- Some(n) => Err(anyhow!("_start exited with a non-zero code: {}", n)),
- None => Err(anyhow!(
- "executing the benchmark resulted in a trap: {}",
- trap
- )),
+ if let Some(exit) = trap.downcast_ref::<I32Exit>() {
+ if exit.0 == 0 {
+ return Ok(());
+ }
  }
+
+ Err(trap)
  }
  }
  }

crates/c-api/src/func.rs

@@ -3,6 +3,8 @@ use crate::{
  wasm_extern_t, wasm_functype_t, wasm_store_t, wasm_val_t, wasm_val_vec_t, wasmtime_error_t,
  wasmtime_extern_t, wasmtime_val_t, wasmtime_val_union, CStoreContext, CStoreContextMut,
 };
+use anyhow::{Error, Result};
+use std::any::Any;
 use std::ffi::c_void;
 use std::mem::{self, MaybeUninit};
 use std::panic::{self, AssertUnwindSafe};
@@ -67,7 +69,7 @@ unsafe fn create_function(
  let mut out_results: wasm_val_vec_t = vec![wasm_val_t::default(); results.len()].into();
  let out = func(&params, &mut out_results);
  if let Some(trap) = out {
- return Err(trap.trap.clone());
+ return Err(trap.error);
  }
 
  let out_results = out_results.as_slice();
@@ -152,24 +154,25 @@ pub unsafe extern "C" fn wasm_func_call(
  }
  ptr::null_mut()
  }
- Ok(Err(trap)) => match trap.downcast::<Trap>() {
- Ok(trap) => Box::into_raw(Box::new(wasm_trap_t::new(trap))),
- Err(err) => Box::into_raw(Box::new(wasm_trap_t::new(err.into()))),
- },
+ Ok(Err(err)) => Box::into_raw(Box::new(wasm_trap_t::new(err))),
  Err(panic) => {
- let trap = if let Some(msg) = panic.downcast_ref::<String>() {
- Trap::new(msg)
- } else if let Some(msg) = panic.downcast_ref::<&'static str>() {
- Trap::new(*msg)
- } else {
- Trap::new("rust panic happened")
- };
- let trap = Box::new(wasm_trap_t::new(trap));
+ let err = error_from_panic(panic);
+ let trap = Box::new(wasm_trap_t::new(err));
  Box::into_raw(trap)
  }
  }
 }
 
+fn error_from_panic(panic: Box<dyn Any + Send>) -> Error {
+ if let Some(msg) = panic.downcast_ref::<String>() {
+ Error::msg(msg.clone())
+ } else if let Some(msg) = panic.downcast_ref::<&'static str>() {
+ Error::msg(*msg)
+ } else {
+ Error::msg("rust panic happened")
+ }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn wasm_func_type(f: &wasm_func_t) -> Box<wasm_functype_t> {
  Box::new(wasm_functype_t::new(f.func().ty(f.ext.store.context())))
@@ -235,7 +238,7 @@ pub(crate) unsafe fn c_callback_to_rust_fn(
  callback: wasmtime_func_callback_t,
  data: *mut c_void,
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
-) -> impl Fn(Caller<'_, crate::StoreData>, &[Val], &mut [Val]) -> Result<(), Trap> {
+) -> impl Fn(Caller<'_, crate::StoreData>, &[Val], &mut [Val]) -> Result<()> {
  let foreign = crate::ForeignData { data, finalizer };
  move |mut caller, params, results| {
  drop(&foreign); // move entire foreign into this closure
@@ -264,7 +267,7 @@ pub(crate) unsafe fn c_callback_to_rust_fn(
  out_results.len(),
  );
  if let Some(trap) = out {
- return Err(trap.trap);
+ return Err(trap.error);
  }
 
  // Translate the `wasmtime_val_t` results into the `results` space
@@ -299,14 +302,14 @@ pub(crate) unsafe fn c_unchecked_callback_to_rust_fn(
  callback: wasmtime_func_unchecked_callback_t,
  data: *mut c_void,
  finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
-) -> impl Fn(Caller<'_, crate::StoreData>, &mut [ValRaw]) -> Result<(), Trap> {
+) -> impl Fn(Caller<'_, crate::StoreData>, &mut [ValRaw]) -> Result<()> {
  let foreign = crate::ForeignData { data, finalizer };
  move |caller, values| {
  drop(&foreign); // move entire foreign into this closure
  let mut caller = wasmtime_caller_t { caller };
  match callback(foreign.data, &mut caller, values.as_mut_ptr(), values.len()) {
  None => Ok(()),
- Some(trap) => Err(trap.trap),
+ Some(trap) => Err(trap.error),
  }
  }
 }
@@ -348,22 +351,17 @@ pub unsafe extern "C" fn wasmtime_func_call(
  store.data_mut().wasm_val_storage = params;
  None
  }
- Ok(Err(trap)) => match trap.downcast::<Trap>() {
- Ok(trap) => {
+ Ok(Err(trap)) => {
+ if trap.is::<Trap>() {
  *trap_ret = Box::into_raw(Box::new(wasm_trap_t::new(trap)));
  None
+ } else {
+ Some(Box::new(wasmtime_error_t::from(trap)))
  }
- Err(err) => Some(Box::new(wasmtime_error_t::from(err))),
- },
+ }
  Err(panic) => {
- let trap = if let Some(msg) = panic.downcast_ref::<String>() {
- Trap::new(msg)
- } else if let Some(msg) = panic.downcast_ref::<&'static str>() {
- Trap::new(*msg)
- } else {
- Trap::new("rust panic happened")
- };
- *trap_ret = Box::into_raw(Box::new(wasm_trap_t::new(trap)));
+ let err = error_from_panic(panic);
+ *trap_ret = Box::into_raw(Box::new(wasm_trap_t::new(err)));
  None
  }
  }

crates/c-api/src/instance.rs

@@ -41,7 +41,7 @@ pub unsafe extern "C" fn wasm_instance_new(
  ))),
  Err(e) => {
  if let Some(ptr) = result {
- *ptr = Box::into_raw(Box::new(wasm_trap_t::new(e.into())));
+ *ptr = Box::into_raw(Box::new(wasm_trap_t::new(e)));
  }
  None
  }
@@ -100,7 +100,7 @@ pub(crate) fn handle_instantiate(
  }
  Err(e) => match e.downcast::<Trap>() {
  Ok(trap) => {
- *trap_ptr = Box::into_raw(Box::new(wasm_trap_t::new(trap)));
+ *trap_ptr = Box::into_raw(Box::new(wasm_trap_t::new(trap.into())));
  None
  }
  Err(e) => Some(Box::new(e.into())),

crates/c-api/src/trap.rs

@@ -1,18 +1,30 @@
 use crate::{wasm_frame_vec_t, wasm_instance_t, wasm_name_t, wasm_store_t};
+use anyhow::{anyhow, Error};
 use once_cell::unsync::OnceCell;
-use wasmtime::{Trap, TrapCode};
+use wasmtime::{BacktraceContext, Trap};
 
 #[repr(C)]
-#[derive(Clone)]
 pub struct wasm_trap_t {
- pub(crate) trap: Trap,
+ pub(crate) error: Error,
+}
+
+// This is currently only needed for the `wasm_trap_copy` API in the C API.
+//
+// For now the impl here is "fake it til you make it" since this is losing
+// context by only cloning the error string.
+impl Clone for wasm_trap_t {
+ fn clone(&self) -> wasm_trap_t {
+ wasm_trap_t {
+ error: anyhow!("{:?}", self.error),
+ }
+ }
 }
 
 wasmtime_c_api_macros::declare_ref!(wasm_trap_t);
 
 impl wasm_trap_t {
- pub(crate) fn new(trap: Trap) -> wasm_trap_t {
- wasm_trap_t { trap: trap }
+ pub(crate) fn new(error: Error) -> wasm_trap_t {
+ wasm_trap_t { error }
  }
 }
 
@@ -40,7 +52,7 @@ pub extern "C" fn wasm_trap_new(
  }
  let message = String::from_utf8_lossy(&message[..message.len() - 1]);
  Box::new(wasm_trap_t {
- trap: Trap::new(message),
+ error: Error::msg(message.into_owned()),
  })
 }
 
@@ -49,24 +61,28 @@ pub unsafe extern "C" fn wasmtime_trap_new(message: *const u8, len: usize) -> Bo
  let bytes = crate::slice_from_raw_parts(message, len);
  let message = String::from_utf8_lossy(&bytes);
  Box::new(wasm_trap_t {
- trap: Trap::new(message),
+ error: Error::msg(message.into_owned()),
  })
 }
 
 #[no_mangle]
 pub extern "C" fn wasm_trap_message(trap: &wasm_trap_t, out: &mut wasm_message_t) {
  let mut buffer = Vec::new();
- buffer.extend_from_slice(trap.trap.to_string().as_bytes());
+ buffer.extend_from_slice(format!("{:?}", trap.error).as_bytes());
  buffer.reserve_exact(1);
  buffer.push(0);
  out.set_buffer(buffer);
 }
 
 #[no_mangle]
 pub extern "C" fn wasm_trap_origin(raw: &wasm_trap_t) -> Option<Box<wasm_frame_t>> {
- if raw.trap.trace().unwrap_or(&[]).len() > 0 {
+ let trap = match raw.error.downcast_ref::<BacktraceContext>() {
+ Some(trap) => trap,
+ None => return None,
+ };
+ if trap.frames().len() > 0 {
  Some(Box::new(wasm_frame_t {
- trap: raw.trap.clone(),
+ trap: trap.clone(),
  idx: 0,
  func_name: OnceCell::new(),
  module_name: OnceCell::new(),
@@ -78,10 +94,14 @@ pub extern "C" fn wasm_trap_origin(raw: &wasm_trap_t) -> Option<Box<wasm_frame_t
 
 #[no_mangle]
 pub extern "C" fn wasm_trap_trace(raw: &wasm_trap_t, out: &mut wasm_frame_vec_t) {
- let vec = (0..raw.trap.trace().unwrap_or(&[]).len())
+ let trap = match raw.error.downcast_ref::<Trap>() {
+ Some(trap) => trap,
+ None => return out.set_buffer(Vec::new()),
+ };
+ let vec = (0..trap.trace().unwrap_or(&[]).len())
  .map(|idx| {
  Some(Box::new(wasm_frame_t {
- trap: raw.trap.clone(),
+ trap: trap.clone(),
  idx,
  func_name: OnceCell::new(),
  module_name: OnceCell::new(),
@@ -93,37 +113,36 @@ pub extern "C" fn wasm_trap_trace(raw: &wasm_trap_t, out: &mut wasm_frame_vec_t)
 
 #[no_mangle]
 pub extern "C" fn wasmtime_trap_code(raw: &wasm_trap_t, code: &mut i32) -> bool {
- match raw.trap.trap_code() {
- Some(c) => {
- *code = match c {
- TrapCode::StackOverflow => 0,
- TrapCode::MemoryOutOfBounds => 1,
- TrapCode::HeapMisaligned => 2,
- TrapCode::TableOutOfBounds => 3,
- TrapCode::IndirectCallToNull => 4,
- TrapCode::BadSignature => 5,
- TrapCode::IntegerOverflow => 6,
- TrapCode::IntegerDivisionByZero => 7,
- TrapCode::BadConversionToInteger => 8,
- TrapCode::UnreachableCodeReached => 9,
- TrapCode::Interrupt => 10,
- _ => unreachable!(),
- };
- true
- }
- None => false,
- }
+ let trap = match raw.error.downcast_ref::<Trap>() {
+ Some(trap) => trap,
+ None => return false,
+ };
+ *code = match trap {
+ Trap::StackOverflow => 0,
+ Trap::MemoryOutOfBounds => 1,
+ Trap::HeapMisaligned => 2,
+ Trap::TableOutOfBounds => 3,
+ Trap::IndirectCallToNull => 4,
+ Trap::BadSignature => 5,
+ Trap::IntegerOverflow => 6,
+ Trap::IntegerDivisionByZero => 7,
+ Trap::BadConversionToInteger => 8,
+ Trap::UnreachableCodeReached => 9,
+ Trap::Interrupt => 10,
+ _ => unreachable!(),
+ };
+ true
 }
 
 #[no_mangle]
 pub extern "C" fn wasmtime_trap_exit_status(raw: &wasm_trap_t, status: &mut i32) -> bool {
- match raw.trap.i32_exit_status() {
- Some(i) => {
- *status = i;
- true
- }
- None => false,
+ #[cfg(feature = "wasi")]
+ if let Some(exit) = raw.error.downcast_ref::<wasmtime_wasi::I32Exit>() {
+ *status = exit.0;
+ return true;
  }
+
+ false
 }
 
 #[no_mangle]

crates/fuzzing/src/oracles.rs

@@ -374,8 +374,7 @@ pub fn differential(
  // falls through to checking the intermediate state otherwise.
  (Err(lhs), Err(rhs)) => {
  let err = rhs.downcast::<Trap>().expect("not a trap");
- let poisoned = err.trap_code() == Some(TrapCode::StackOverflow)
- || lhs_engine.is_stack_overflow(&lhs);
+ let poisoned = err == Trap::StackOverflow || lhs_engine.is_stack_overflow(&lhs);
 
  if poisoned {
  return Ok(false);
@@ -675,14 +674,9 @@ pub fn table_ops(
  .downcast::<Trap>()
  .unwrap();
 
- match trap.trap_code() {
- Some(TrapCode::TableOutOfBounds) => {}
- None if trap
- .to_string()
- .contains("all fuel consumed by WebAssembly") => {}
- _ => {
- panic!("unexpected trap: {}", trap);
- }
+ match trap {
+ Trap::TableOutOfBounds | Trap::OutOfFuel => {}
+ _ => panic!("unexpected trap: {trap}"),
  }
 
  // Do a final GC after running the Wasm.