118 lines
2.8 KiB
Rust
118 lines
2.8 KiB
Rust
use crate::instance::Instance;
|
|
use crate::r#ref::HostRef;
|
|
use std::fmt;
|
|
use std::sync::{Arc, Mutex};
|
|
use thiserror::Error;
|
|
|
|
#[derive(Debug)]
|
|
pub struct FrameInfo;
|
|
|
|
impl FrameInfo {
|
|
pub fn instance(&self) -> *const Instance {
|
|
unimplemented!("FrameInfo::instance");
|
|
}
|
|
|
|
pub fn func_index() -> usize {
|
|
unimplemented!("FrameInfo::func_index");
|
|
}
|
|
|
|
pub fn func_offset() -> usize {
|
|
unimplemented!("FrameInfo::func_offset");
|
|
}
|
|
|
|
pub fn module_offset() -> usize {
|
|
unimplemented!("FrameInfo::module_offset");
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct TrapInfo {
|
|
message: String,
|
|
trace: Vec<FrameInfo>,
|
|
}
|
|
|
|
impl TrapInfo {
|
|
pub fn new<I: Into<String>>(message: I) -> Self {
|
|
Self {
|
|
message: message.into(),
|
|
trace: vec![],
|
|
}
|
|
}
|
|
|
|
/// Returns a reference the `message` stored in `Trap`.
|
|
pub fn message(&self) -> &str {
|
|
&self.message
|
|
}
|
|
|
|
pub fn origin(&self) -> Option<&FrameInfo> {
|
|
self.trace.first()
|
|
}
|
|
|
|
pub fn trace(&self) -> &[FrameInfo] {
|
|
&self.trace
|
|
}
|
|
}
|
|
|
|
/// A struct to hold unsafe TrapInfo host reference, designed
|
|
/// to be Send-able. The only access for it provided via the
|
|
/// Trap::trap_info_unchecked() method.
|
|
struct UnsafeTrapInfo(HostRef<TrapInfo>);
|
|
|
|
impl UnsafeTrapInfo {
|
|
fn trap_info(&self) -> HostRef<TrapInfo> {
|
|
self.0.clone()
|
|
}
|
|
}
|
|
|
|
unsafe impl Send for UnsafeTrapInfo {}
|
|
|
|
impl fmt::Debug for UnsafeTrapInfo {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(f, "UnsafeTrapInfo")
|
|
}
|
|
}
|
|
|
|
/// A struct representing an aborted instruction execution, with a message
|
|
/// indicating the cause.
|
|
#[derive(Error, Debug)]
|
|
#[error("Wasm trap: {message}")]
|
|
pub struct Trap {
|
|
message: String,
|
|
info: Arc<Mutex<UnsafeTrapInfo>>,
|
|
}
|
|
|
|
fn _assert_trap_is_sync_and_send(t: &Trap) -> (&dyn Sync, &dyn Send) {
|
|
(t, t)
|
|
}
|
|
|
|
impl Trap {
|
|
/// Creates a new `Trap` with `message`.
|
|
/// # Example
|
|
/// ```
|
|
/// let trap = wasmtime::Trap::new("unexpected error");
|
|
/// assert_eq!("unexpected error", trap.message());
|
|
/// ```
|
|
pub fn new<I: Into<String>>(message: I) -> Self {
|
|
Trap::from(HostRef::new(TrapInfo::new(message)))
|
|
}
|
|
|
|
/// Returns a reference the `message` stored in `Trap`.
|
|
pub fn message(&self) -> &str {
|
|
&self.message
|
|
}
|
|
|
|
/// Returns inner TrapInfo assotiated with the Trap.
|
|
/// The method is unsafe: obtained TrapInfo is not thread safe.
|
|
pub(crate) unsafe fn trap_info_unchecked(&self) -> HostRef<TrapInfo> {
|
|
self.info.lock().unwrap().trap_info()
|
|
}
|
|
}
|
|
|
|
impl From<HostRef<TrapInfo>> for Trap {
|
|
fn from(trap_info: HostRef<TrapInfo>) -> Self {
|
|
let message = trap_info.borrow().message().to_string();
|
|
let info = Arc::new(Mutex::new(UnsafeTrapInfo(trap_info)));
|
|
Trap { message, info }
|
|
}
|
|
}
|