Struct node_testing::client::sc_executor::sp_wasm_interface::wasmtime::WasmBacktrace

pub struct WasmBacktrace { /* private fields */ }

Representation of a backtrace of function frames in a WebAssembly module for where an error happened.

This structure is attached to the anyhow::Error returned from many Wasmtime functions that execute WebAssembly such as Instance::new or Func::call. This can be acquired with the anyhow::Error::downcast family of methods to programmatically inspect the backtrace. Otherwise since it’s part of the error returned this will get printed along with the rest of the error when the error is logged.

Capturing of wasm backtraces can be configured through the Config::wasm_backtrace method.

For more information about errors in wasmtime see the documentation of the Trap type.

Examples

let engine = Engine::default();
let module = Module::new(
    &engine,
    r#"
        (module
            (func $start (export "run")
                call $trap)
            (func $trap
                unreachable)
        )
    "#,
)?;
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let error = func.call(&mut store, ()).unwrap_err();
let bt = error.downcast_ref::<WasmBacktrace>().unwrap();
let frames = bt.frames();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].func_name(), Some("trap"));
assert_eq!(frames[1].func_name(), Some("start"));

Implementations

impl WasmBacktrace

pub fn capture(store: impl AsContext) -> WasmBacktrace

Captures a trace of the WebAssembly frames on the stack for the provided store.

This will return a WasmBacktrace which holds captured FrameInfos for each frame of WebAssembly on the call stack of the current thread. If no WebAssembly is on the stack then the returned backtrace will have no frames in it.

Note that this function will respect the Config::wasm_backtrace configuration option and will return an empty backtrace if that is disabled. To always capture a backtrace use the WasmBacktrace::force_capture method.

Also note that this function will only capture frames from the specified store on the stack, ignoring frames from other stores if present.

Example

let engine = Engine::default();
let module = Module::new(
    &engine,
    r#"
        (module
            (import "" "" (func $host))
            (func $foo (export "f") call $bar)
            (func $bar call $host)
        )
    "#,
)?;

let mut store = Store::new(&engine, ());
let func = Func::wrap(&mut store, |cx: Caller<'_, ()>| {
    let trace = WasmBacktrace::capture(&cx);
    println!("{trace:?}");
});
let instance = Instance::new(&mut store, &module, &[func.into()])?;
let func = instance.get_typed_func::<(), ()>(&mut store, "f")?;
func.call(&mut store, ())?;

pub fn force_capture(store: impl AsContext) -> WasmBacktrace

Unconditionally captures a trace of the WebAssembly frames on the stack for the provided store.

Same as WasmBacktrace::capture except that it disregards the Config::wasm_backtrace setting and always captures a backtrace.

pub fn frames(&self) -> &[FrameInfo]

Returns a list of function frames in WebAssembly this backtrace represents.

Trait Implementations

impl Debug for WasmBacktrace

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for WasmBacktrace

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.