Change RuntimeError type

lib/clif-backend/src/signal/mod.rs

@@ -2,7 +2,7 @@ use crate::relocation::{TrapData, TrapSink};
 use crate::trampoline::Trampolines;
 use hashbrown::HashSet;
 use libc::c_void;
-use std::{cell::Cell, sync::Arc};
+use std::{any::Any, cell::Cell, sync::Arc};
 use wasmer_runtime_core::{
     backend::{ProtectedCaller, Token, UserTrapper},
     error::RuntimeResult,
@@ -25,14 +25,14 @@ pub use self::unix::*;
 pub use self::windows::*;
 
 thread_local! {
-    pub static TRAP_EARLY_DATA: Cell<Option<String>> = Cell::new(None);
+    pub static TRAP_EARLY_DATA: Cell<Option<Box<dyn Any>>> = Cell::new(None);
 }
 
 pub struct Trapper;
 
 impl UserTrapper for Trapper {
-    unsafe fn do_early_trap(&self, msg: String) -> ! {
-        TRAP_EARLY_DATA.with(|cell| cell.set(Some(msg)));
+    unsafe fn do_early_trap(&self, data: Box<dyn Any>) -> ! {
+        TRAP_EARLY_DATA.with(|cell| cell.set(Some(data)));
         trigger_trap()
     }
 }

lib/clif-backend/src/signal/unix.rs

@@ -79,8 +79,8 @@ pub fn call_protected<T>(handler_data: &HandlerData, f: impl FnOnce() -> T) -> R
         if signum != 0 {
             *jmp_buf = prev_jmp_buf;
 
-            if let Some(msg) = super::TRAP_EARLY_DATA.with(|cell| cell.replace(None)) {
-                Err(RuntimeError::User { msg })
+            if let Some(data) = super::TRAP_EARLY_DATA.with(|cell| cell.replace(None)) {
+                Err(RuntimeError::Panic { data })
             } else {
                 let (faulting_addr, inst_ptr) = CAUGHT_ADDRESSES.with(|cell| cell.get());
 
@@ -91,28 +91,28 @@ pub fn call_protected<T>(handler_data: &HandlerData, f: impl FnOnce() -> T) -> R
                 {
                     Err(match Signal::from_c_int(signum) {
                         Ok(SIGILL) => match trapcode {
-                            TrapCode::BadSignature => RuntimeError::IndirectCallSignature {
-                                table: TableIndex::new(0),
+                            TrapCode::BadSignature => RuntimeError::Trap {
+                                msg: "incorrect call_indirect signature".into(),
                             },
-                            TrapCode::IndirectCallToNull => RuntimeError::IndirectCallToNull {
-                                table: TableIndex::new(0),
+                            TrapCode::IndirectCallToNull => RuntimeError::Trap {
+                                msg: "indirect call to null".into(),
                             },
-                            TrapCode::HeapOutOfBounds => RuntimeError::OutOfBoundsAccess {
-                                memory: MemoryIndex::new(0),
-                                addr: None,
+                            TrapCode::HeapOutOfBounds => RuntimeError::Trap {
+                                msg: "memory out-of-bounds access".into(),
                             },
-                            TrapCode::TableOutOfBounds => RuntimeError::TableOutOfBounds {
-                                table: TableIndex::new(0),
+                            TrapCode::TableOutOfBounds => RuntimeError::Trap {
+                                msg: "table out-of-bounds access".into(),
                             },
-                            _ => RuntimeError::Unknown {
-                                msg: "unknown trap".to_string(),
+                            _ => RuntimeError::Trap {
+                                msg: "unknown trap".into(),
                             },
                         },
-                        Ok(SIGSEGV) | Ok(SIGBUS) => RuntimeError::OutOfBoundsAccess {
-                            memory: MemoryIndex::new(0),
-                            addr: None,
+                        Ok(SIGSEGV) | Ok(SIGBUS) => RuntimeError::Trap {
+                            msg: "memory out-of-bounds access".into(),
+                        },
+                        Ok(SIGFPE) => RuntimeError::Trap {
+                            msg: "illegal arithmetic operation".into(),
                         },
-                        Ok(SIGFPE) => RuntimeError::IllegalArithmeticOperation,
                         _ => unimplemented!(),
                     }
                     .into())
@@ -126,8 +126,8 @@ pub fn call_protected<T>(handler_data: &HandlerData, f: impl FnOnce() -> T) -> R
                         _ => "unkown trapped signal",
                     };
                     // When the trap-handler is fully implemented, this will return more information.
-                    Err(RuntimeError::Unknown {
-                        msg: format!("trap at {:p} - {}", faulting_addr, signal),
+                    Err(RuntimeError::Trap {
+                        msg: format!("unknown trap at {:p} - {}", faulting_addr, signal).into(),
                     }
                     .into())
                 }

lib/runtime-core/src/backend.rs

@@ -12,7 +12,7 @@ use crate::{
     module::ModuleInfo,
     sys::Memory,
 };
-use std::ptr::NonNull;
+use std::{any::Any, ptr::NonNull};
 
 pub mod sys {
     pub use crate::sys::*;
@@ -78,7 +78,7 @@ pub trait ProtectedCaller: Send + Sync {
 }
 
 pub trait UserTrapper {
-    unsafe fn do_early_trap(&self, msg: String) -> !;
+    unsafe fn do_early_trap(&self, data: Box<dyn Any>) -> !;
 }
 
 pub trait FuncResolver: Send + Sync {

lib/runtime-core/src/error.rs

@@ -1,8 +1,9 @@
 use crate::types::{
     FuncSig, GlobalDescriptor, MemoryDescriptor, MemoryIndex, TableDescriptor, TableIndex, Type,
+    Value,
 };
 use core::borrow::Borrow;
-use std::sync::Arc;
+use std::{any::Any, sync::Arc};
 
 pub type Result<T> = std::result::Result<T, Error>;
 pub type CompileResult<T> = std::result::Result<T, CompileError>;
@@ -120,28 +121,11 @@ impl std::error::Error for LinkError {}
 /// The main way to do this is `Instance.call`.
 ///
 /// Comparing two `RuntimeError`s always evaluates to false.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum RuntimeError {
-    OutOfBoundsAccess {
-        memory: MemoryIndex,
-        addr: Option<u32>,
-    },
-    TableOutOfBounds {
-        table: TableIndex,
-    },
-    IndirectCallSignature {
-        table: TableIndex,
-    },
-    IndirectCallToNull {
-        table: TableIndex,
-    },
-    IllegalArithmeticOperation,
-    User {
-        msg: String,
-    },
-    Unknown {
-        msg: String,
-    },
+    Trap { msg: Box<str> },
+    Exception { data: Box<[Value]> },
+    Panic { data: Box<dyn Any> },
 }
 
 impl PartialEq for RuntimeError {
@@ -153,30 +137,13 @@ impl PartialEq for RuntimeError {
 impl std::fmt::Display for RuntimeError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
-            RuntimeError::IndirectCallSignature { table } => write!(
-                f,
-                "Indirect call signature error with Table Index \"{:?}\"",
-                table
-            ),
-            RuntimeError::IndirectCallToNull { table } => {
-                write!(f, "Indirect call to null with table index \"{:?}\"", table)
-            }
-            RuntimeError::IllegalArithmeticOperation => write!(f, "Illegal arithmetic operation"),
-            RuntimeError::OutOfBoundsAccess { memory, addr } => match addr {
-                Some(addr) => write!(
-                    f,
-                    "Out-of-bounds access with memory index {:?} and address {}",
-                    memory, addr
-                ),
-                None => write!(f, "Out-of-bounds access with memory index {:?}", memory),
-            },
-            RuntimeError::TableOutOfBounds { table } => {
-                write!(f, "Table out of bounds with table index \"{:?}\"", table)
+            RuntimeError::Trap { ref msg } => {
+                write!(f, "WebAssembly trap occured during runtime: {}", msg)
             }
-            RuntimeError::Unknown { msg } => {
-                write!(f, "Unknown runtime error with message: \"{}\"", msg)
+            RuntimeError::Exception { ref data } => {
+                write!(f, "Uncaught WebAssembly exception: {:?}", data)
             }
-            RuntimeError::User { msg } => write!(f, "User runtime error with message: \"{}\"", msg),
+            RuntimeError::Panic { data: _ } => write!(f, "User-defined \"panic\""),
         }
     }
 }
@@ -239,7 +206,7 @@ impl std::error::Error for ResolveError {}
 /// be the `CallError::Runtime(RuntimeError)` variant.
 ///
 /// Comparing two `CallError`s always evaluates to false.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum CallError {
     Resolve(ResolveError),
     Runtime(RuntimeError),
@@ -298,7 +265,7 @@ impl std::error::Error for CreationError {}
 /// of a webassembly module.
 ///
 /// Comparing two `Error`s always evaluates to false.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum Error {
     CompileError(CompileError),
     LinkError(Vec<LinkError>),

lib/runtime-core/src/typed_func.rs

@@ -6,7 +6,7 @@ use crate::{
     types::{FuncSig, Type, WasmExternType},
     vm::Ctx,
 };
-use std::{cell::UnsafeCell, fmt, marker::PhantomData, mem, panic, ptr, sync::Arc};
+use std::{any::Any, cell::UnsafeCell, fmt, marker::PhantomData, mem, panic, ptr, sync::Arc};
 
 thread_local! {
     pub static EARLY_TRAPPER: UnsafeCell<Option<Box<dyn UserTrapper>>> = UnsafeCell::new(None);
@@ -40,25 +40,25 @@ pub trait TrapEarly<Rets>
 where
     Rets: WasmTypeList,
 {
-    fn report(self) -> Result<Rets, String>;
+    fn report(self) -> Result<Rets, Box<dyn Any>>;
 }
 
 impl<Rets> TrapEarly<Rets> for Rets
 where
     Rets: WasmTypeList,
 {
-    fn report(self) -> Result<Rets, String> {
+    fn report(self) -> Result<Rets, Box<dyn Any>> {
         Ok(self)
     }
 }
 
 impl<Rets, E> TrapEarly<Rets> for Result<Rets, E>
 where
     Rets: WasmTypeList,
-    E: fmt::Debug,
+    E: Any,
 {
-    fn report(self) -> Result<Rets, String> {
-        self.map_err(|err| format!("Error: {:?}", err))
+    fn report(self) -> Result<Rets, Box<dyn Any>> {
+        self.map_err(|err| Box::new(err) as Box<dyn Any>)
     }
 }
 
@@ -191,25 +191,17 @@ macro_rules! impl_traits {
                 extern fn wrap<$( $x: WasmExternType, )* Rets: WasmTypeList, Trap: TrapEarly<Rets>, FN: Fn( &mut Ctx $( ,$x )* ) -> Trap>( ctx: &mut Ctx $( ,$x: $x )* ) -> Rets::CStruct {
                     let f: FN = unsafe { mem::transmute_copy(&()) };
 
-                    let msg = match panic::catch_unwind(panic::AssertUnwindSafe(|| {
+                    let err = match panic::catch_unwind(panic::AssertUnwindSafe(|| {
                         f( ctx $( ,$x )* ).report()
                     })) {
                         Ok(Ok(returns)) => return returns.into_c_struct(),
                         Ok(Err(err)) => err,
-                        Err(err) => {
-                            if let Some(s) = err.downcast_ref::<&str>() {
-                                s.to_string()
-                            } else if let Some(s) = err.downcast_ref::<String>() {
-                                s.clone()
-                            } else {
-                                "a panic occurred, but no additional information is available".to_string()
-                            }
-                        },
+                        Err(err) => err,
                     };
 
                     unsafe {
                         if let Some(early_trapper) = &*EARLY_TRAPPER.with(|ucell| ucell.get()) {
-                            early_trapper.do_early_trap(msg)
+                            early_trapper.do_early_trap(err)
                         } else {
                             eprintln!("panic handling not setup");
                             std::process::exit(1)