Enum Trap
#[non_exhaustive]pub enum Trap {
Show 19 variants
StackOverflow,
MemoryOutOfBounds,
HeapMisaligned,
TableOutOfBounds,
IndirectCallToNull,
BadSignature,
IntegerOverflow,
IntegerDivisionByZero,
BadConversionToInteger,
UnreachableCodeReached,
Interrupt,
AlwaysTrapAdapter,
OutOfFuel,
AtomicWaitNonSharedMemory,
NullReference,
ArrayOutOfBounds,
AllocationTooLarge,
CastFailure,
CannotEnterComponent,
}
Expand description
Representation of a WebAssembly trap and what caused it to occur.
WebAssembly traps happen explicitly for instructions such as unreachable
but can also happen as side effects of other instructions such as i32.load
loading an out-of-bounds address. Traps halt the execution of WebAssembly
and cause an error to be returned to the host. This enumeration is a list of
all possible traps that can happen in wasm, in addition to some
Wasmtime-specific trap codes listed here as well.
§Errors in Wasmtime
Error-handling in Wasmtime is primarily done through the
anyhow
crate where most results are a
Result<T>
which is an alias for Result<T, anyhow::Error>
. Errors in Wasmtime are represented
with anyhow::Error
which acts as a container for any type of error in
addition to optional context for this error. The “base” error or
anyhow::Error::root_cause
is a Trap
whenever WebAssembly hits a
trap, or otherwise it’s whatever the host created the error with when
returning an error for a host call.
Any error which happens while WebAssembly is executing will also, by
default, capture a backtrace of the wasm frames while executing. This
backtrace is represented with a WasmBacktrace
instance and is attached
to the anyhow::Error
return value as a
context
. Inspecting a WasmBacktrace
can be
done with the downcast_ref
function. For
information on this see the WasmBacktrace
documentation.
§Examples
let engine = Engine::default();
let module = Module::new(
&engine,
r#"
(module
(func (export "trap")
unreachable)
(func $overflow (export "overflow")
call $overflow)
)
"#,
)?;
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let trap = instance.get_typed_func::<(), ()>(&mut store, "trap")?;
let error = trap.call(&mut store, ()).unwrap_err();
assert_eq!(*error.downcast_ref::<Trap>().unwrap(), Trap::UnreachableCodeReached);
assert!(error.root_cause().is::<Trap>());
let overflow = instance.get_typed_func::<(), ()>(&mut store, "overflow")?;
let error = overflow.call(&mut store, ()).unwrap_err();
assert_eq!(*error.downcast_ref::<Trap>().unwrap(), Trap::StackOverflow);
Variants (Non-exhaustive)§
This enum is marked as non-exhaustive
StackOverflow
The current stack space was exhausted.
MemoryOutOfBounds
An out-of-bounds memory access.
HeapMisaligned
A wasm atomic operation was presented with a not-naturally-aligned linear-memory address.
TableOutOfBounds
An out-of-bounds access to a table.
IndirectCallToNull
Indirect call to a null table entry.
BadSignature
Signature mismatch on indirect call.
IntegerOverflow
An integer arithmetic operation caused an overflow.
IntegerDivisionByZero
An integer division by zero.
BadConversionToInteger
Failed float-to-int conversion.
UnreachableCodeReached
Code that was supposed to have been unreachable was reached.
Interrupt
Execution has potentially run too long and may be interrupted.
AlwaysTrapAdapter
When the component-model
feature is enabled this trap represents a
function that was canon lift
’d, then canon lower
’d, then called.
This combination of creation of a function in the component model
generates a function that always traps and, when called, produces this
flavor of trap.
OutOfFuel
When wasm code is configured to consume fuel and it runs out of fuel then this trap will be raised.
Used to indicate that a trap was raised by atomic wait operations on non shared memory.
NullReference
Call to a null reference.
ArrayOutOfBounds
Attempt to access beyond the bounds of an array.
AllocationTooLarge
Attempted an allocation that was too large to succeed.
CastFailure
Attempted to cast a reference to a type that it is not an instance of.
CannotEnterComponent
When the component-model
feature is enabled this trap represents a
scenario where one component tried to call another component but it
would have violated the reentrance rules of the component model,
triggering a trap instead.
Implementations§
Trait Implementations§
§impl Error for Trap
Available on crate feature std
only.
impl Error for Trap
std
only.1.30.0 · Source§fn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
1.0.0 · Source§fn description(&self) -> &str
fn description(&self) -> &str
impl Copy for Trap
impl Eq for Trap
impl StructuralPartialEq for Trap
Auto Trait Implementations§
impl Freeze for Trap
impl RefUnwindSafe for Trap
impl Send for Trap
impl Sync for Trap
impl Unpin for Trap
impl UnwindSafe for Trap
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<T> IntoAnyhow for T
impl<T> IntoAnyhow for T
§fn into_anyhow(self) -> Error
fn into_anyhow(self) -> Error
self
into an anyhow::Error
.Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more