wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-21.0.1/src/runtime/vm/threads/shared_memory.rs

@@ -0,0 +1,233 @@
+use crate::prelude::*;
+use crate::runtime::vm::memory::{validate_atomic_addr, MmapMemory};
+use crate::runtime::vm::threads::parking_spot::{ParkingSpot, Waiter};
+use crate::runtime::vm::vmcontext::VMMemoryDefinition;
+use crate::runtime::vm::{Memory, RuntimeLinearMemory, Store, WaitResult};
+use anyhow::Error;
+use anyhow::{bail, Result};
+use std::cell::RefCell;
+use std::ops::Range;
+use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
+use std::sync::{Arc, RwLock};
+use std::time::{Duration, Instant};
+use wasmtime_environ::{MemoryPlan, MemoryStyle, Trap};
+
+/// For shared memory (and only for shared memory), this lock-version restricts
+/// access when growing the memory or checking its size. This is to conform with
+/// the [thread proposal]: "When `IsSharedArrayBuffer(...)` is true, the return
+/// value should be the result of an atomic read-modify-write of the new size to
+/// the internal `length` slot."
+///
+/// [thread proposal]:
+///     https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md#webassemblymemoryprototypegrow
+#[derive(Clone)]
+pub struct SharedMemory(Arc<SharedMemoryInner>);
+
+struct SharedMemoryInner {
+    memory: RwLock<Box<dyn RuntimeLinearMemory>>,
+    spot: ParkingSpot,
+    ty: wasmtime_environ::Memory,
+    def: LongTermVMMemoryDefinition,
+}
+
+impl SharedMemory {
+    /// Construct a new [`SharedMemory`].
+    pub fn new(plan: MemoryPlan) -> Result<Self> {
+        let (minimum_bytes, maximum_bytes) = Memory::limit_new(&plan, None)?;
+        let mmap_memory = MmapMemory::new(&plan, minimum_bytes, maximum_bytes, None)?;
+        Self::wrap(&plan, Box::new(mmap_memory), plan.memory)
+    }
+
+    /// Wrap an existing [Memory] with the locking provided by a [SharedMemory].
+    pub fn wrap(
+        plan: &MemoryPlan,
+        mut memory: Box<dyn RuntimeLinearMemory>,
+        ty: wasmtime_environ::Memory,
+    ) -> Result<Self> {
+        if !ty.shared {
+            bail!("shared memory must have a `shared` memory type");
+        }
+        if !matches!(plan.style, MemoryStyle::Static { .. }) {
+            bail!("shared memory can only be built from a static memory allocation")
+        }
+        assert!(
+            memory.as_any_mut().type_id() != std::any::TypeId::of::<SharedMemory>(),
+            "cannot re-wrap a shared memory"
+        );
+        Ok(Self(Arc::new(SharedMemoryInner {
+            ty,
+            spot: ParkingSpot::default(),
+            def: LongTermVMMemoryDefinition(memory.vmmemory()),
+            memory: RwLock::new(memory),
+        })))
+    }
+
+    /// Return the memory type for this [`SharedMemory`].
+    pub fn ty(&self) -> wasmtime_environ::Memory {
+        self.0.ty
+    }
+
+    /// Convert this shared memory into a [`Memory`].
+    pub fn as_memory(self) -> Memory {
+        Memory(Box::new(self))
+    }
+
+    /// Return a pointer to the shared memory's [VMMemoryDefinition].
+    pub fn vmmemory_ptr(&self) -> *const VMMemoryDefinition {
+        &self.0.def.0
+    }
+
+    /// Same as `RuntimeLinearMemory::grow`, except with `&self`.
+    pub fn grow(
+        &self,
+        delta_pages: u64,
+        store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>, Error> {
+        let mut memory = self.0.memory.write().unwrap();
+        let result = memory.grow(delta_pages, store)?;
+        if let Some((_old_size_in_bytes, new_size_in_bytes)) = result {
+            // Store the new size to the `VMMemoryDefinition` for JIT-generated
+            // code (and runtime functions) to access. No other code can be
+            // growing this memory due to the write lock, but code in other
+            // threads could have access to this shared memory and we want them
+            // to see the most consistent version of the `current_length`; a
+            // weaker consistency is possible if we accept them seeing an older,
+            // smaller memory size (assumption: memory only grows) but presently
+            // we are aiming for accuracy.
+            //
+            // Note that it could be possible to access a memory address that is
+            // now-valid due to changes to the page flags in `grow` above but
+            // beyond the `memory.size` that we are about to assign to. In these
+            // and similar cases, discussion in the thread proposal concluded
+            // that: "multiple accesses in one thread racing with another
+            // thread's `memory.grow` that are in-bounds only after the grow
+            // commits may independently succeed or trap" (see
+            // https://github.com/WebAssembly/threads/issues/26#issuecomment-433930711).
+            // In other words, some non-determinism is acceptable when using
+            // `memory.size` on work being done by `memory.grow`.
+            self.0
+                .def
+                .0
+                .current_length
+                .store(new_size_in_bytes, Ordering::SeqCst);
+        }
+        Ok(result)
+    }
+
+    /// Implementation of `memory.atomic.notify` for this shared memory.
+    pub fn atomic_notify(&self, addr_index: u64, count: u32) -> Result<u32, Trap> {
+        let ptr = validate_atomic_addr(&self.0.def.0, addr_index, 4, 4)?;
+        log::trace!("memory.atomic.notify(addr={addr_index:#x}, count={count})");
+        let ptr = unsafe { &*ptr };
+        Ok(self.0.spot.notify(ptr, count))
+    }
+
+    /// Implementation of `memory.atomic.wait32` for this shared memory.
+    pub fn atomic_wait32(
+        &self,
+        addr_index: u64,
+        expected: u32,
+        timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        let addr = validate_atomic_addr(&self.0.def.0, addr_index, 4, 4)?;
+        log::trace!(
+            "memory.atomic.wait32(addr={addr_index:#x}, expected={expected}, timeout={timeout:?})"
+        );
+
+        // SAFETY: `addr_index` was validated by `validate_atomic_addr` above.
+        assert!(std::mem::size_of::<AtomicU32>() == 4);
+        assert!(std::mem::align_of::<AtomicU32>() <= 4);
+        let atomic = unsafe { AtomicU32::from_ptr(addr.cast()) };
+        let deadline = timeout.map(|d| Instant::now() + d);
+
+        WAITER.with(|waiter| {
+            let mut waiter = waiter.borrow_mut();
+            Ok(self.0.spot.wait32(atomic, expected, deadline, &mut waiter))
+        })
+    }
+
+    /// Implementation of `memory.atomic.wait64` for this shared memory.
+    pub fn atomic_wait64(
+        &self,
+        addr_index: u64,
+        expected: u64,
+        timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        let addr = validate_atomic_addr(&self.0.def.0, addr_index, 8, 8)?;
+        log::trace!(
+            "memory.atomic.wait64(addr={addr_index:#x}, expected={expected}, timeout={timeout:?})"
+        );
+
+        // SAFETY: `addr_index` was validated by `validate_atomic_addr` above.
+        assert!(std::mem::size_of::<AtomicU64>() == 8);
+        assert!(std::mem::align_of::<AtomicU64>() <= 8);
+        let atomic = unsafe { AtomicU64::from_ptr(addr.cast()) };
+        let deadline = timeout.map(|d| Instant::now() + d);
+
+        WAITER.with(|waiter| {
+            let mut waiter = waiter.borrow_mut();
+            Ok(self.0.spot.wait64(atomic, expected, deadline, &mut waiter))
+        })
+    }
+}
+
+thread_local! {
+    /// Structure used in conjunction with `ParkingSpot` to block the current
+    /// thread if necessary. Note that this is lazily initialized.
+    static WAITER: RefCell<Waiter> = const { RefCell::new(Waiter::new()) };
+}
+
+/// Shared memory needs some representation of a `VMMemoryDefinition` for
+/// JIT-generated code to access. This structure owns the base pointer and
+/// length to the actual memory and we share this definition across threads by:
+/// - never changing the base pointer; according to the specification, shared
+///   memory must be created with a known maximum size so it can be allocated
+///   once and never moved
+/// - carefully changing the length, using atomic accesses in both the runtime
+///   and JIT-generated code.
+struct LongTermVMMemoryDefinition(VMMemoryDefinition);
+unsafe impl Send for LongTermVMMemoryDefinition {}
+unsafe impl Sync for LongTermVMMemoryDefinition {}
+
+/// Proxy all calls through the [`RwLock`].
+impl RuntimeLinearMemory for SharedMemory {
+    fn byte_size(&self) -> usize {
+        self.0.memory.read().unwrap().byte_size()
+    }
+
+    fn maximum_byte_size(&self) -> Option<usize> {
+        self.0.memory.read().unwrap().maximum_byte_size()
+    }
+
+    fn grow(
+        &mut self,
+        delta_pages: u64,
+        store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>, Error> {
+        SharedMemory::grow(self, delta_pages, store)
+    }
+
+    fn grow_to(&mut self, size: usize) -> Result<()> {
+        self.0.memory.write().unwrap().grow_to(size)
+    }
+
+    fn vmmemory(&mut self) -> VMMemoryDefinition {
+        // `vmmemory()` is used for writing the `VMMemoryDefinition` of a memory
+        // into its `VMContext`; this should never be possible for a shared
+        // memory because the only `VMMemoryDefinition` for it should be stored
+        // in its own `def` field.
+        unreachable!()
+    }
+
+    fn needs_init(&self) -> bool {
+        self.0.memory.read().unwrap().needs_init()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+
+    fn wasm_accessible(&self) -> Range<usize> {
+        self.0.memory.read().unwrap().wasm_accessible()
+    }
+}

data/ext/cargo-vendor/wasmtime-21.0.1/src/runtime/vm/threads/shared_memory_disabled.rs

@@ -0,0 +1,101 @@
+#![allow(missing_docs)]
+
+use crate::prelude::*;
+use crate::runtime::vm::{RuntimeLinearMemory, Store, VMMemoryDefinition, WaitResult};
+use anyhow::{bail, Result};
+use core::ops::Range;
+use core::time::Duration;
+use wasmtime_environ::{MemoryPlan, Trap};
+
+#[derive(Clone)]
+pub enum SharedMemory {}
+
+impl SharedMemory {
+    pub fn wrap(
+        _plan: &MemoryPlan,
+        _memory: Box<dyn RuntimeLinearMemory>,
+        _ty: wasmtime_environ::Memory,
+    ) -> Result<Self> {
+        bail!("support for shared memories was disabled at compile time");
+    }
+
+    pub fn ty(&self) -> wasmtime_environ::Memory {
+        match *self {}
+    }
+
+    pub fn as_memory(self) -> crate::runtime::vm::Memory {
+        match self {}
+    }
+
+    pub fn vmmemory_ptr(&self) -> *const VMMemoryDefinition {
+        match *self {}
+    }
+
+    pub fn grow(
+        &self,
+        _delta_pages: u64,
+        _store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>> {
+        match *self {}
+    }
+
+    pub fn atomic_notify(&self, _addr_index: u64, _count: u32) -> Result<u32, Trap> {
+        match *self {}
+    }
+
+    pub fn atomic_wait32(
+        &self,
+        _addr_index: u64,
+        _expected: u32,
+        _timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        match *self {}
+    }
+
+    pub fn atomic_wait64(
+        &self,
+        _addr_index: u64,
+        _expected: u64,
+        _timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        match *self {}
+    }
+}
+
+impl RuntimeLinearMemory for SharedMemory {
+    fn byte_size(&self) -> usize {
+        match *self {}
+    }
+
+    fn maximum_byte_size(&self) -> Option<usize> {
+        match *self {}
+    }
+
+    fn grow(
+        &mut self,
+        _delta_pages: u64,
+        _store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>> {
+        match *self {}
+    }
+
+    fn grow_to(&mut self, _size: usize) -> Result<()> {
+        match *self {}
+    }
+
+    fn vmmemory(&mut self) -> VMMemoryDefinition {
+        match *self {}
+    }
+
+    fn needs_init(&self) -> bool {
+        match *self {}
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn core::any::Any {
+        match *self {}
+    }
+
+    fn wasm_accessible(&self) -> Range<usize> {
+        match *self {}
+    }
+}

data/ext/cargo-vendor/wasmtime-21.0.1/src/runtime/vm/traphandlers/backtrace.rs

@@ -0,0 +1,267 @@
+//! Backtrace and stack walking functionality for Wasm.
+//!
+//! Walking the Wasm stack is comprised of
+//!
+//! 1. identifying sequences of contiguous Wasm frames on the stack
+//!    (i.e. skipping over native host frames), and
+//!
+//! 2. walking the Wasm frames within such a sequence.
+//!
+//! To perform (1) we maintain the entry stack pointer (SP) and exit frame
+//! pointer (FP) and program counter (PC) each time we call into Wasm and Wasm
+//! calls into the host via trampolines (see
+//! `crates/wasmtime/src/runtime/vm/trampolines`). The most recent entry is
+//! stored in `VMRuntimeLimits` and older entries are saved in
+//! `CallThreadState`. This lets us identify ranges of contiguous Wasm frames on
+//! the stack.
+//!
+//! To solve (2) and walk the Wasm frames within a region of contiguous Wasm
+//! frames on the stack, we configure Cranelift's `preserve_frame_pointers =
+//! true` setting. Then we can do simple frame pointer traversal starting at the
+//! exit FP and stopping once we reach the entry SP (meaning that the next older
+//! frame is a host frame).
+
+use crate::prelude::*;
+use crate::runtime::vm::arch;
+use crate::runtime::vm::{
+    traphandlers::{tls, CallThreadState},
+    VMRuntimeLimits,
+};
+use core::ops::ControlFlow;
+
+/// A WebAssembly stack trace.
+#[derive(Debug)]
+pub struct Backtrace(Vec<Frame>);
+
+/// A stack frame within a Wasm stack trace.
+#[derive(Debug)]
+pub struct Frame {
+    pc: usize,
+    fp: usize,
+}
+
+impl Frame {
+    /// Get this frame's program counter.
+    pub fn pc(&self) -> usize {
+        self.pc
+    }
+
+    /// Get this frame's frame pointer.
+    pub fn fp(&self) -> usize {
+        self.fp
+    }
+}
+
+impl Backtrace {
+    /// Returns an empty backtrace
+    pub fn empty() -> Backtrace {
+        Backtrace(Vec::new())
+    }
+
+    /// Capture the current Wasm stack in a backtrace.
+    pub fn new(limits: *const VMRuntimeLimits) -> Backtrace {
+        tls::with(|state| match state {
+            Some(state) => unsafe { Self::new_with_trap_state(limits, state, None) },
+            None => Backtrace(vec![]),
+        })
+    }
+
+    /// Capture the current Wasm stack trace.
+    ///
+    /// If Wasm hit a trap, and we calling this from the trap handler, then the
+    /// Wasm exit trampoline didn't run, and we use the provided PC and FP
+    /// instead of looking them up in `VMRuntimeLimits`.
+    pub(crate) unsafe fn new_with_trap_state(
+        limits: *const VMRuntimeLimits,
+        state: &CallThreadState,
+        trap_pc_and_fp: Option<(usize, usize)>,
+    ) -> Backtrace {
+        let mut frames = vec![];
+        Self::trace_with_trap_state(limits, state, trap_pc_and_fp, |frame| {
+            frames.push(frame);
+            ControlFlow::Continue(())
+        });
+        Backtrace(frames)
+    }
+
+    /// Walk the current Wasm stack, calling `f` for each frame we walk.
+    pub fn trace(limits: *const VMRuntimeLimits, f: impl FnMut(Frame) -> ControlFlow<()>) {
+        tls::with(|state| match state {
+            Some(state) => unsafe { Self::trace_with_trap_state(limits, state, None, f) },
+            None => {}
+        });
+    }
+
+    /// Walk the current Wasm stack, calling `f` for each frame we walk.
+    ///
+    /// If Wasm hit a trap, and we calling this from the trap handler, then the
+    /// Wasm exit trampoline didn't run, and we use the provided PC and FP
+    /// instead of looking them up in `VMRuntimeLimits`.
+    pub(crate) unsafe fn trace_with_trap_state(
+        limits: *const VMRuntimeLimits,
+        state: &CallThreadState,
+        trap_pc_and_fp: Option<(usize, usize)>,
+        mut f: impl FnMut(Frame) -> ControlFlow<()>,
+    ) {
+        log::trace!("====== Capturing Backtrace ======");
+
+        let (last_wasm_exit_pc, last_wasm_exit_fp) = match trap_pc_and_fp {
+            // If we exited Wasm by catching a trap, then the Wasm-to-host
+            // trampoline did not get a chance to save the last Wasm PC and FP,
+            // and we need to use the plumbed-through values instead.
+            Some((pc, fp)) => {
+                assert!(core::ptr::eq(limits, state.limits));
+                (pc, fp)
+            }
+            // Either there is no Wasm currently on the stack, or we exited Wasm
+            // through the Wasm-to-host trampoline.
+            None => {
+                let pc = *(*limits).last_wasm_exit_pc.get();
+                let fp = *(*limits).last_wasm_exit_fp.get();
+                (pc, fp)
+            }
+        };
+
+        let activations = core::iter::once((
+            last_wasm_exit_pc,
+            last_wasm_exit_fp,
+            *(*limits).last_wasm_entry_sp.get(),
+        ))
+        .chain(
+            state
+                .iter()
+                .filter(|state| core::ptr::eq(limits, state.limits))
+                .map(|state| {
+                    (
+                        state.old_last_wasm_exit_pc(),
+                        state.old_last_wasm_exit_fp(),
+                        state.old_last_wasm_entry_sp(),
+                    )
+                }),
+        )
+        .take_while(|&(pc, fp, sp)| {
+            if pc == 0 {
+                debug_assert_eq!(fp, 0);
+                debug_assert_eq!(sp, 0);
+            }
+            pc != 0
+        });
+
+        for (pc, fp, sp) in activations {
+            if let ControlFlow::Break(()) = Self::trace_through_wasm(pc, fp, sp, &mut f) {
+                log::trace!("====== Done Capturing Backtrace (closure break) ======");
+                return;
+            }
+        }
+
+        log::trace!("====== Done Capturing Backtrace (reached end of activations) ======");
+    }
+
+    /// Walk through a contiguous sequence of Wasm frames starting with the
+    /// frame at the given PC and FP and ending at `trampoline_sp`.
+    unsafe fn trace_through_wasm(
+        mut pc: usize,
+        mut fp: usize,
+        trampoline_sp: usize,
+        mut f: impl FnMut(Frame) -> ControlFlow<()>,
+    ) -> ControlFlow<()> {
+        log::trace!("=== Tracing through contiguous sequence of Wasm frames ===");
+        log::trace!("trampoline_sp = 0x{:016x}", trampoline_sp);
+        log::trace!("   initial pc = 0x{:016x}", pc);
+        log::trace!("   initial fp = 0x{:016x}", fp);
+
+        // We already checked for this case in the `trace_with_trap_state`
+        // caller.
+        assert_ne!(pc, 0);
+        assert_ne!(fp, 0);
+        assert_ne!(trampoline_sp, 0);
+
+        arch::assert_entry_sp_is_aligned(trampoline_sp);
+
+        loop {
+            // At the start of each iteration of the loop, we know that `fp` is
+            // a frame pointer from Wasm code. Therefore, we know it is not
+            // being used as an extra general-purpose register, and it is safe
+            // dereference to get the PC and the next older frame pointer.
+
+            // The stack grows down, and therefore any frame pointer we are
+            // dealing with should be less than the stack pointer on entry
+            // to Wasm.
+            assert!(trampoline_sp >= fp, "{trampoline_sp:#x} >= {fp:#x}");
+
+            arch::assert_fp_is_aligned(fp);
+
+            log::trace!("--- Tracing through one Wasm frame ---");
+            log::trace!("pc = {:p}", pc as *const ());
+            log::trace!("fp = {:p}", fp as *const ());
+
+            f(Frame { pc, fp })?;
+
+            pc = arch::get_next_older_pc_from_fp(fp);
+
+            // We rely on this offset being zero for all supported architectures
+            // in `crates/cranelift/src/component/compiler.rs` when we set the
+            // Wasm exit FP. If this ever changes, we will need to update that
+            // code as well!
+            assert_eq!(arch::NEXT_OLDER_FP_FROM_FP_OFFSET, 0);
+
+            // Get the next older frame pointer from the current Wasm frame
+            // pointer.
+            //
+            // The next older frame pointer may or may not be a Wasm frame's
+            // frame pointer, but it is trusted either way (i.e. is actually a
+            // frame pointer and not being used as a general-purpose register)
+            // because we always enter Wasm from the host via a trampoline, and
+            // this trampoline maintains a proper frame pointer.
+            //
+            // We want to detect when we've reached the trampoline, and break
+            // out of this stack-walking loop. All of our architectures' stacks
+            // grow down and look something vaguely like this:
+            //
+            //     | ...               |
+            //     | Native Frames     |
+            //     | ...               |
+            //     |-------------------|
+            //     | ...               | <-- Trampoline FP            |
+            //     | Trampoline Frame  |                              |
+            //     | ...               | <-- Trampoline SP            |
+            //     |-------------------|                            Stack
+            //     | Return Address    |                            Grows
+            //     | Previous FP       | <-- Wasm FP                Down
+            //     | ...               |                              |
+            //     | Wasm Frames       |                              |
+            //     | ...               |                              V
+            //
+            // The trampoline records its own stack pointer (`trampoline_sp`),
+            // which is guaranteed to be above all Wasm frame pointers but at or
+            // below its own frame pointer. It is usually two words above the
+            // Wasm frame pointer (at least on x86-64, exact details vary across
+            // architectures) but not always: if the first Wasm function called
+            // by the host has many arguments, some of them could be passed on
+            // the stack in between the return address and the trampoline's
+            // frame.
+            //
+            // To check when we've reached the trampoline frame, it is therefore
+            // sufficient to check when the next frame pointer is greater than
+            // or equal to `trampoline_sp` (except s390x, where it needs to be
+            // strictly greater than).
+            let next_older_fp = *(fp as *mut usize).add(arch::NEXT_OLDER_FP_FROM_FP_OFFSET);
+            if arch::reached_entry_sp(next_older_fp, trampoline_sp) {
+                log::trace!("=== Done tracing contiguous sequence of Wasm frames ===");
+                return ControlFlow::Continue(());
+            }
+
+            // Because the stack always grows down, the older FP must be greater
+            // than the current FP.
+            assert!(next_older_fp > fp, "{next_older_fp:#x} > {fp:#x}");
+            fp = next_older_fp;
+        }
+    }
+
+    /// Iterate over the frames inside this backtrace.
+    pub fn frames<'a>(
+        &'a self,
+    ) -> impl ExactSizeIterator<Item = &'a Frame> + DoubleEndedIterator + 'a {
+        self.0.iter()
+    }
+}

data/ext/cargo-vendor/wasmtime-21.0.1/src/runtime/vm/traphandlers/coredump_disabled.rs

@@ -0,0 +1,16 @@
+use crate::runtime::vm::traphandlers::CallThreadState;
+use crate::runtime::vm::VMRuntimeLimits;
+
+/// A WebAssembly Coredump
+#[derive(Debug)]
+pub enum CoreDumpStack {}
+
+impl CallThreadState {
+    pub(super) fn capture_coredump(
+        &self,
+        _limits: *const VMRuntimeLimits,
+        _trap_pc_and_fp: Option<(usize, usize)>,
+    ) -> Option<CoreDumpStack> {
+        None
+    }
+}

data/ext/cargo-vendor/wasmtime-21.0.1/src/runtime/vm/traphandlers/coredump_enabled.rs

@@ -0,0 +1,42 @@
+use super::CallThreadState;
+use crate::prelude::*;
+use crate::runtime::vm::{Backtrace, VMRuntimeLimits};
+use wasm_encoder::CoreDumpValue;
+
+/// A WebAssembly Coredump
+#[derive(Debug)]
+pub struct CoreDumpStack {
+    /// The backtrace containing the stack frames for the CoreDump
+    pub bt: Backtrace,
+
+    /// The locals for each frame in the backtrace.
+    ///
+    /// This is not currently implemented.
+    #[allow(dead_code)]
+    pub locals: Vec<Vec<CoreDumpValue>>,
+
+    /// The operands for each stack frame
+    ///
+    /// This is not currently implemented.
+    #[allow(dead_code)]
+    pub operand_stack: Vec<Vec<CoreDumpValue>>,
+}
+
+impl CallThreadState {
+    pub(super) fn capture_coredump(
+        &self,
+        limits: *const VMRuntimeLimits,
+        trap_pc_and_fp: Option<(usize, usize)>,
+    ) -> Option<CoreDumpStack> {
+        if !self.capture_coredump {
+            return None;
+        }
+        let bt = unsafe { Backtrace::new_with_trap_state(limits, self, trap_pc_and_fp) };
+
+        Some(CoreDumpStack {
+            bt,
+            locals: vec![],
+            operand_stack: vec![],
+        })
+    }
+}