wasmtime 37.0.2 → 38.0.4

data/ext/cargo-vendor/wasmtime-37.0.2/src/runtime/store.rs

@@ -1,2782 +0,0 @@
-//! Wasmtime's "store" type
-//!
-//! This module, and its submodules, contain the `Store` type and various types
-//! used to interact with it. At first glance this is a pretty confusing module
-//! where you need to know the difference between:
-//!
-//! * `Store<T>`
-//! * `StoreContext<T>`
-//! * `StoreContextMut<T>`
-//! * `AsContext`
-//! * `AsContextMut`
-//! * `StoreInner<T>`
-//! * `StoreOpaque`
-//! * `StoreData`
-//!
-//! There's... quite a lot going on here, and it's easy to be confused. This
-//! comment is ideally going to serve the purpose of clarifying what all these
-//! types are for and why they're motivated.
-//!
-//! First it's important to know what's "internal" and what's "external". Almost
-//! everything above is defined as `pub`, but only some of the items are
-//! reexported to the outside world to be usable from this crate. Otherwise all
-//! items are `pub` within this `store` module, and the `store` module is
-//! private to the `wasmtime` crate. Notably `Store<T>`, `StoreContext<T>`,
-//! `StoreContextMut<T>`, `AsContext`, and `AsContextMut` are all public
-//! interfaces to the `wasmtime` crate. You can think of these as:
-//!
-//! * `Store<T>` - an owned reference to a store, the "root of everything"
-//! * `StoreContext<T>` - basically `&StoreInner<T>`
-//! * `StoreContextMut<T>` - more-or-less `&mut StoreInner<T>` with caveats.
-//!   Explained later.
-//! * `AsContext` - similar to `AsRef`, but produces `StoreContext<T>`
-//! * `AsContextMut` - similar to `AsMut`, but produces `StoreContextMut<T>`
-//!
-//! Next comes the internal structure of the `Store<T>` itself. This looks like:
-//!
-//! * `Store<T>` - this type is just a pointer large. It's primarily just
-//!   intended to be consumed by the outside world. Note that the "just a
-//!   pointer large" is a load-bearing implementation detail in Wasmtime. This
-//!   enables it to store a pointer to its own trait object which doesn't need
-//!   to change over time.
-//!
-//! * `StoreInner<T>` - the first layer of the contents of a `Store<T>`, what's
-//!   stored inside the `Box`. This is the general Rust pattern when one struct
-//!   is a layer over another. The surprising part, though, is that this is
-//!   further subdivided. This structure only contains things which actually
-//!   need `T` itself. The downside of this structure is that it's always
-//!   generic and means that code is monomorphized into consumer crates. We
-//!   strive to have things be as monomorphic as possible in `wasmtime` so this
-//!   type is not heavily used.
-//!
-//! * `StoreOpaque` - this is the primary contents of the `StoreInner<T>` type.
-//!   Stored inline in the outer type the "opaque" here means that it's a
-//!   "store" but it doesn't have access to the `T`. This is the primary
-//!   "internal" reference that Wasmtime uses since `T` is rarely needed by the
-//!   internals of Wasmtime.
-//!
-//! * `StoreData` - this is a final helper struct stored within `StoreOpaque`.
-//!   All references of Wasm items into a `Store` are actually indices into a
-//!   table in this structure, and the `StoreData` being separate makes it a bit
-//!   easier to manage/define/work with. There's no real fundamental reason this
-//!   is split out, although sometimes it's useful to have separate borrows into
-//!   these tables than the `StoreOpaque`.
-//!
-//! A major caveat with these representations is that the internal `&mut
-//! StoreInner<T>` is never handed out publicly to consumers of this crate, only
-//! through a wrapper of `StoreContextMut<'_, T>`. The reason for this is that
-//! we want to provide mutable, but not destructive, access to the contents of a
-//! `Store`. For example if a `StoreInner<T>` were replaced with some other
-//! `StoreInner<T>` then that would drop live instances, possibly those
-//! currently executing beneath the current stack frame. This would not be a
-//! safe operation.
-//!
-//! This means, though, that the `wasmtime` crate, which liberally uses `&mut
-//! StoreOpaque` internally, has to be careful to never actually destroy the
-//! contents of `StoreOpaque`. This is an invariant that we, as the authors of
-//! `wasmtime`, must uphold for the public interface to be safe.
-
-use crate::RootSet;
-#[cfg(feature = "gc")]
-use crate::ThrownException;
-#[cfg(feature = "component-model-async")]
-use crate::component::ComponentStoreData;
-#[cfg(feature = "component-model-async")]
-use crate::component::concurrent;
-#[cfg(feature = "async")]
-use crate::fiber;
-use crate::module::RegisteredModuleId;
-use crate::prelude::*;
-#[cfg(feature = "gc")]
-use crate::runtime::vm::GcRootsList;
-#[cfg(feature = "stack-switching")]
-use crate::runtime::vm::VMContRef;
-use crate::runtime::vm::mpk::ProtectionKey;
-use crate::runtime::vm::{
-    self, GcStore, Imports, InstanceAllocationRequest, InstanceAllocator, InstanceHandle,
-    Interpreter, InterpreterRef, ModuleRuntimeInfo, OnDemandInstanceAllocator, SendSyncPtr,
-    SignalHandler, StoreBox, Unwind, VMContext, VMFuncRef, VMGcRef, VMStore, VMStoreContext,
-};
-use crate::trampoline::VMHostGlobalContext;
-use crate::{Engine, Module, Val, ValRaw, module::ModuleRegistry};
-#[cfg(feature = "gc")]
-use crate::{ExnRef, Rooted};
-use crate::{Global, Instance, Memory, Table, Uninhabited};
-use alloc::sync::Arc;
-use core::fmt;
-use core::marker;
-use core::mem::{self, ManuallyDrop, MaybeUninit};
-use core::num::NonZeroU64;
-use core::ops::{Deref, DerefMut};
-use core::pin::Pin;
-use core::ptr::NonNull;
-use wasmtime_environ::{DefinedGlobalIndex, DefinedTableIndex, EntityRef, PrimaryMap, TripleExt};
-
-mod context;
-pub use self::context::*;
-mod data;
-pub use self::data::*;
-mod func_refs;
-use func_refs::FuncRefs;
-#[cfg(feature = "component-model-async")]
-mod token;
-#[cfg(feature = "component-model-async")]
-pub(crate) use token::StoreToken;
-#[cfg(feature = "async")]
-mod async_;
-#[cfg(all(feature = "async", feature = "call-hook"))]
-pub use self::async_::CallHookHandler;
-
-#[cfg(feature = "gc")]
-use super::vm::VMExnRef;
-#[cfg(feature = "gc")]
-mod gc;
-
-/// A [`Store`] is a collection of WebAssembly instances and host-defined state.
-///
-/// All WebAssembly instances and items will be attached to and refer to a
-/// [`Store`]. For example instances, functions, globals, and tables are all
-/// attached to a [`Store`]. Instances are created by instantiating a
-/// [`Module`](crate::Module) within a [`Store`].
-///
-/// A [`Store`] is intended to be a short-lived object in a program. No form
-/// of GC is implemented at this time so once an instance is created within a
-/// [`Store`] it will not be deallocated until the [`Store`] itself is dropped.
-/// This makes [`Store`] unsuitable for creating an unbounded number of
-/// instances in it because [`Store`] will never release this memory. It's
-/// recommended to have a [`Store`] correspond roughly to the lifetime of a
-/// "main instance" that an embedding is interested in executing.
-///
-/// ## Type parameter `T`
-///
-/// Each [`Store`] has a type parameter `T` associated with it. This `T`
-/// represents state defined by the host. This state will be accessible through
-/// the [`Caller`](crate::Caller) type that host-defined functions get access
-/// to. This `T` is suitable for storing `Store`-specific information which
-/// imported functions may want access to.
-///
-/// The data `T` can be accessed through methods like [`Store::data`] and
-/// [`Store::data_mut`].
-///
-/// ## Stores, contexts, oh my
-///
-/// Most methods in Wasmtime take something of the form
-/// [`AsContext`](crate::AsContext) or [`AsContextMut`](crate::AsContextMut) as
-/// the first argument. These two traits allow ergonomically passing in the
-/// context you currently have to any method. The primary two sources of
-/// contexts are:
-///
-/// * `Store<T>`
-/// * `Caller<'_, T>`
-///
-/// corresponding to what you create and what you have access to in a host
-/// function. You can also explicitly acquire a [`StoreContext`] or
-/// [`StoreContextMut`] and pass that around as well.
-///
-/// Note that all methods on [`Store`] are mirrored onto [`StoreContext`],
-/// [`StoreContextMut`], and [`Caller`](crate::Caller). This way no matter what
-/// form of context you have you can call various methods, create objects, etc.
-///
-/// ## Stores and `Default`
-///
-/// You can create a store with default configuration settings using
-/// `Store::default()`. This will create a brand new [`Engine`] with default
-/// configuration (see [`Config`](crate::Config) for more information).
-///
-/// ## Cross-store usage of items
-///
-/// In `wasmtime` wasm items such as [`Global`] and [`Memory`] "belong" to a
-/// [`Store`]. The store they belong to is the one they were created with
-/// (passed in as a parameter) or instantiated with. This store is the only
-/// store that can be used to interact with wasm items after they're created.
-///
-/// The `wasmtime` crate will panic if the [`Store`] argument passed in to these
-/// operations is incorrect. In other words it's considered a programmer error
-/// rather than a recoverable error for the wrong [`Store`] to be used when
-/// calling APIs.
-pub struct Store<T: 'static> {
-    // for comments about `ManuallyDrop`, see `Store::into_data`
-    inner: ManuallyDrop<Box<StoreInner<T>>>,
-}
-
-#[derive(Copy, Clone, Debug)]
-/// Passed to the argument of [`Store::call_hook`] to indicate a state transition in
-/// the WebAssembly VM.
-pub enum CallHook {
-    /// Indicates the VM is calling a WebAssembly function, from the host.
-    CallingWasm,
-    /// Indicates the VM is returning from a WebAssembly function, to the host.
-    ReturningFromWasm,
-    /// Indicates the VM is calling a host function, from WebAssembly.
-    CallingHost,
-    /// Indicates the VM is returning from a host function, to WebAssembly.
-    ReturningFromHost,
-}
-
-impl CallHook {
-    /// Indicates the VM is entering host code (exiting WebAssembly code)
-    pub fn entering_host(&self) -> bool {
-        match self {
-            CallHook::ReturningFromWasm | CallHook::CallingHost => true,
-            _ => false,
-        }
-    }
-    /// Indicates the VM is exiting host code (entering WebAssembly code)
-    pub fn exiting_host(&self) -> bool {
-        match self {
-            CallHook::ReturningFromHost | CallHook::CallingWasm => true,
-            _ => false,
-        }
-    }
-}
-
-/// Internal contents of a `Store<T>` that live on the heap.
-///
-/// The members of this struct are those that need to be generic over `T`, the
-/// store's internal type storage. Otherwise all things that don't rely on `T`
-/// should go into `StoreOpaque`.
-pub struct StoreInner<T: 'static> {
-    /// Generic metadata about the store that doesn't need access to `T`.
-    inner: StoreOpaque,
-
-    limiter: Option<ResourceLimiterInner<T>>,
-    call_hook: Option<CallHookInner<T>>,
-    #[cfg(target_has_atomic = "64")]
-    epoch_deadline_behavior:
-        Option<Box<dyn FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync>>,
-    // for comments about `ManuallyDrop`, see `Store::into_data`
-    data: ManuallyDrop<T>,
-}
-
-enum ResourceLimiterInner<T> {
-    Sync(Box<dyn (FnMut(&mut T) -> &mut dyn crate::ResourceLimiter) + Send + Sync>),
-    #[cfg(feature = "async")]
-    Async(Box<dyn (FnMut(&mut T) -> &mut dyn crate::ResourceLimiterAsync) + Send + Sync>),
-}
-
-/// Representation of a configured resource limiter for a store.
-///
-/// This is acquired with `resource_limiter_and_store_opaque` for example and is
-/// threaded through to growth operations on tables/memories. Note that this is
-/// passed around as `Option<&mut StoreResourceLimiter<'_>>` to make it
-/// efficient to pass around (nullable pointer) and it's also notably passed
-/// around as an `Option` to represent how this is optionally specified within a
-/// store.
-pub enum StoreResourceLimiter<'a> {
-    Sync(&'a mut dyn crate::ResourceLimiter),
-    #[cfg(feature = "async")]
-    Async(&'a mut dyn crate::ResourceLimiterAsync),
-}
-
-impl StoreResourceLimiter<'_> {
-    pub(crate) async fn memory_growing(
-        &mut self,
-        current: usize,
-        desired: usize,
-        maximum: Option<usize>,
-    ) -> Result<bool, Error> {
-        match self {
-            Self::Sync(s) => s.memory_growing(current, desired, maximum),
-            #[cfg(feature = "async")]
-            Self::Async(s) => s.memory_growing(current, desired, maximum).await,
-        }
-    }
-
-    pub(crate) fn memory_grow_failed(&mut self, error: anyhow::Error) -> Result<()> {
-        match self {
-            Self::Sync(s) => s.memory_grow_failed(error),
-            #[cfg(feature = "async")]
-            Self::Async(s) => s.memory_grow_failed(error),
-        }
-    }
-
-    pub(crate) async fn table_growing(
-        &mut self,
-        current: usize,
-        desired: usize,
-        maximum: Option<usize>,
-    ) -> Result<bool, Error> {
-        match self {
-            Self::Sync(s) => s.table_growing(current, desired, maximum),
-            #[cfg(feature = "async")]
-            Self::Async(s) => s.table_growing(current, desired, maximum).await,
-        }
-    }
-
-    pub(crate) fn table_grow_failed(&mut self, error: anyhow::Error) -> Result<()> {
-        match self {
-            Self::Sync(s) => s.table_grow_failed(error),
-            #[cfg(feature = "async")]
-            Self::Async(s) => s.table_grow_failed(error),
-        }
-    }
-}
-
-enum CallHookInner<T: 'static> {
-    #[cfg(feature = "call-hook")]
-    Sync(Box<dyn FnMut(StoreContextMut<'_, T>, CallHook) -> Result<()> + Send + Sync>),
-    #[cfg(all(feature = "async", feature = "call-hook"))]
-    Async(Box<dyn CallHookHandler<T> + Send + Sync>),
-    #[expect(
-        dead_code,
-        reason = "forcing, regardless of cfg, the type param to be used"
-    )]
-    ForceTypeParameterToBeUsed {
-        uninhabited: Uninhabited,
-        _marker: marker::PhantomData<T>,
-    },
-}
-
-/// What to do after returning from a callback when the engine epoch reaches
-/// the deadline for a Store during execution of a function using that store.
-#[non_exhaustive]
-pub enum UpdateDeadline {
-    /// Halt execution of WebAssembly, don't update the epoch deadline, and
-    /// raise a trap.
-    Interrupt,
-    /// Extend the deadline by the specified number of ticks.
-    Continue(u64),
-    /// Extend the deadline by the specified number of ticks after yielding to
-    /// the async executor loop. This can only be used with an async [`Store`]
-    /// configured via [`Config::async_support`](crate::Config::async_support).
-    #[cfg(feature = "async")]
-    Yield(u64),
-    /// Extend the deadline by the specified number of ticks after yielding to
-    /// the async executor loop. This can only be used with an async [`Store`]
-    /// configured via [`Config::async_support`](crate::Config::async_support).
-    ///
-    /// The yield will be performed by the future provided; when using `tokio`
-    /// it is recommended to provide [`tokio::task::yield_now`](https://docs.rs/tokio/latest/tokio/task/fn.yield_now.html)
-    /// here.
-    #[cfg(feature = "async")]
-    YieldCustom(
-        u64,
-        ::core::pin::Pin<Box<dyn ::core::future::Future<Output = ()> + Send>>,
-    ),
-}
-
-// Forward methods on `StoreOpaque` to also being on `StoreInner<T>`
-impl<T> Deref for StoreInner<T> {
-    type Target = StoreOpaque;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<T> DerefMut for StoreInner<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-
-/// Monomorphic storage for a `Store<T>`.
-///
-/// This structure contains the bulk of the metadata about a `Store`. This is
-/// used internally in Wasmtime when dependence on the `T` of `Store<T>` isn't
-/// necessary, allowing code to be monomorphic and compiled into the `wasmtime`
-/// crate itself.
-pub struct StoreOpaque {
-    // This `StoreOpaque` structure has references to itself. These aren't
-    // immediately evident, however, so we need to tell the compiler that it
-    // contains self-references. This notably suppresses `noalias` annotations
-    // when this shows up in compiled code because types of this structure do
-    // indeed alias itself. An example of this is `default_callee` holds a
-    // `*mut dyn Store` to the address of this `StoreOpaque` itself, indeed
-    // aliasing!
-    //
-    // It's somewhat unclear to me at this time if this is 100% sufficient to
-    // get all the right codegen in all the right places. For example does
-    // `Store` need to internally contain a `Pin<Box<StoreInner<T>>>`? Do the
-    // contexts need to contain `Pin<&mut StoreInner<T>>`? I'm not familiar
-    // enough with `Pin` to understand if it's appropriate here (we do, for
-    // example want to allow movement in and out of `data: T`, just not movement
-    // of most of the other members). It's also not clear if using `Pin` in a
-    // few places buys us much other than a bunch of `unsafe` that we already
-    // sort of hand-wave away.
-    //
-    // In any case this seems like a good mid-ground for now where we're at
-    // least telling the compiler something about all the aliasing happening
-    // within a `Store`.
-    _marker: marker::PhantomPinned,
-
-    engine: Engine,
-    vm_store_context: VMStoreContext,
-
-    // Contains all continuations ever allocated throughout the lifetime of this
-    // store.
-    #[cfg(feature = "stack-switching")]
-    continuations: Vec<Box<VMContRef>>,
-
-    instances: PrimaryMap<InstanceId, StoreInstance>,
-
-    #[cfg(feature = "component-model")]
-    num_component_instances: usize,
-    signal_handler: Option<SignalHandler>,
-    modules: ModuleRegistry,
-    func_refs: FuncRefs,
-    host_globals: PrimaryMap<DefinedGlobalIndex, StoreBox<VMHostGlobalContext>>,
-    // GC-related fields.
-    gc_store: Option<GcStore>,
-    gc_roots: RootSet,
-    #[cfg(feature = "gc")]
-    gc_roots_list: GcRootsList,
-    // Types for which the embedder has created an allocator for.
-    #[cfg(feature = "gc")]
-    gc_host_alloc_types: crate::hash_set::HashSet<crate::type_registry::RegisteredType>,
-    /// Pending exception, if any. This is also a GC root, because it
-    /// needs to be rooted somewhere between the time that a pending
-    /// exception is set and the time that the handling code takes the
-    /// exception object. We use this rooting strategy rather than a
-    /// root in an `Err` branch of a `Result` on the host side because
-    /// it is less error-prone with respect to rooting behavior. See
-    /// `throw()`, `take_pending_exception()`,
-    /// `peek_pending_exception()`, `has_pending_exception()`, and
-    /// `catch()`.
-    #[cfg(feature = "gc")]
-    pending_exception: Option<VMExnRef>,
-
-    // Numbers of resources instantiated in this store, and their limits
-    instance_count: usize,
-    instance_limit: usize,
-    memory_count: usize,
-    memory_limit: usize,
-    table_count: usize,
-    table_limit: usize,
-    #[cfg(feature = "async")]
-    async_state: fiber::AsyncState,
-
-    // If fuel_yield_interval is enabled, then we store the remaining fuel (that isn't in
-    // runtime_limits) here. The total amount of fuel is the runtime limits and reserve added
-    // together. Then when we run out of gas, we inject the yield amount from the reserve
-    // until the reserve is empty.
-    fuel_reserve: u64,
-    pub(crate) fuel_yield_interval: Option<NonZeroU64>,
-    /// Indexed data within this `Store`, used to store information about
-    /// globals, functions, memories, etc.
-    store_data: StoreData,
-    traitobj: StorePtr,
-    default_caller_vmctx: SendSyncPtr<VMContext>,
-
-    /// Used to optimized wasm->host calls when the host function is defined with
-    /// `Func::new` to avoid allocating a new vector each time a function is
-    /// called.
-    hostcall_val_storage: Vec<Val>,
-    /// Same as `hostcall_val_storage`, but for the direction of the host
-    /// calling wasm.
-    wasm_val_raw_storage: Vec<ValRaw>,
-
-    /// Keep track of what protection key is being used during allocation so
-    /// that the right memory pages can be enabled when entering WebAssembly
-    /// guest code.
-    pkey: Option<ProtectionKey>,
-
-    /// Runtime state for components used in the handling of resources, borrow,
-    /// and calls. These also interact with the `ResourceAny` type and its
-    /// internal representation.
-    #[cfg(feature = "component-model")]
-    component_host_table: vm::component::HandleTable,
-    #[cfg(feature = "component-model")]
-    component_calls: vm::component::CallContexts,
-    #[cfg(feature = "component-model")]
-    host_resource_data: crate::component::HostResourceData,
-
-    #[cfg(feature = "component-model-async")]
-    concurrent_async_state: concurrent::AsyncState,
-
-    /// State related to the executor of wasm code.
-    ///
-    /// For example if Pulley is enabled and configured then this will store a
-    /// Pulley interpreter.
-    executor: Executor,
-}
-
-/// Self-pointer to `StoreInner<T>` from within a `StoreOpaque` which is chiefly
-/// used to copy into instances during instantiation.
-///
-/// FIXME: ideally this type would get deleted and Wasmtime's reliance on it
-/// would go away.
-struct StorePtr(Option<NonNull<dyn VMStore>>);
-
-// We can't make `VMStore: Send + Sync` because that requires making all of
-// Wastime's internals generic over the `Store`'s `T`. So instead, we take care
-// in the whole VM layer to only use the `VMStore` in ways that are `Send`- and
-// `Sync`-safe and we have to have these unsafe impls.
-unsafe impl Send for StorePtr {}
-unsafe impl Sync for StorePtr {}
-
-/// Executor state within `StoreOpaque`.
-///
-/// Effectively stores Pulley interpreter state and handles conditional support
-/// for Cranelift at compile time.
-pub(crate) enum Executor {
-    Interpreter(Interpreter),
-    #[cfg(has_host_compiler_backend)]
-    Native,
-}
-
-impl Executor {
-    pub(crate) fn new(engine: &Engine) -> Self {
-        #[cfg(has_host_compiler_backend)]
-        if cfg!(feature = "pulley") && engine.target().is_pulley() {
-            Executor::Interpreter(Interpreter::new(engine))
-        } else {
-            Executor::Native
-        }
-        #[cfg(not(has_host_compiler_backend))]
-        {
-            debug_assert!(engine.target().is_pulley());
-            Executor::Interpreter(Interpreter::new(engine))
-        }
-    }
-}
-
-/// A borrowed reference to `Executor` above.
-pub(crate) enum ExecutorRef<'a> {
-    Interpreter(InterpreterRef<'a>),
-    #[cfg(has_host_compiler_backend)]
-    Native,
-}
-
-/// An RAII type to automatically mark a region of code as unsafe for GC.
-#[doc(hidden)]
-pub struct AutoAssertNoGc<'a> {
-    store: &'a mut StoreOpaque,
-    entered: bool,
-}
-
-impl<'a> AutoAssertNoGc<'a> {
-    #[inline]
-    pub fn new(store: &'a mut StoreOpaque) -> Self {
-        let entered = if !cfg!(feature = "gc") {
-            false
-        } else if let Some(gc_store) = store.gc_store.as_mut() {
-            gc_store.gc_heap.enter_no_gc_scope();
-            true
-        } else {
-            false
-        };
-
-        AutoAssertNoGc { store, entered }
-    }
-
-    /// Creates an `AutoAssertNoGc` value which is forcibly "not entered" and
-    /// disables checks for no GC happening for the duration of this value.
-    ///
-    /// This is used when it is statically otherwise known that a GC doesn't
-    /// happen for the various types involved.
-    ///
-    /// # Unsafety
-    ///
-    /// This method is `unsafe` as it does not provide the same safety
-    /// guarantees as `AutoAssertNoGc::new`. It must be guaranteed by the
-    /// caller that a GC doesn't happen.
-    #[inline]
-    pub unsafe fn disabled(store: &'a mut StoreOpaque) -> Self {
-        if cfg!(debug_assertions) {
-            AutoAssertNoGc::new(store)
-        } else {
-            AutoAssertNoGc {
-                store,
-                entered: false,
-            }
-        }
-    }
-}
-
-impl core::ops::Deref for AutoAssertNoGc<'_> {
-    type Target = StoreOpaque;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &*self.store
-    }
-}
-
-impl core::ops::DerefMut for AutoAssertNoGc<'_> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut *self.store
-    }
-}
-
-impl Drop for AutoAssertNoGc<'_> {
-    #[inline]
-    fn drop(&mut self) {
-        if self.entered {
-            self.store.unwrap_gc_store_mut().gc_heap.exit_no_gc_scope();
-        }
-    }
-}
-
-/// Used to associate instances with the store.
-///
-/// This is needed to track if the instance was allocated explicitly with the on-demand
-/// instance allocator.
-struct StoreInstance {
-    handle: InstanceHandle,
-    kind: StoreInstanceKind,
-}
-
-enum StoreInstanceKind {
-    /// An actual, non-dummy instance.
-    Real {
-        /// The id of this instance's module inside our owning store's
-        /// `ModuleRegistry`.
-        module_id: RegisteredModuleId,
-    },
-
-    /// This is a dummy instance that is just an implementation detail for
-    /// something else. For example, host-created memories internally create a
-    /// dummy instance.
-    ///
-    /// Regardless of the configured instance allocator for the engine, dummy
-    /// instances always use the on-demand allocator to deallocate the instance.
-    Dummy,
-}
-
-impl<T> Store<T> {
-    /// Creates a new [`Store`] to be associated with the given [`Engine`] and
-    /// `data` provided.
-    ///
-    /// The created [`Store`] will place no additional limits on the size of
-    /// linear memories or tables at runtime. Linear memories and tables will
-    /// be allowed to grow to any upper limit specified in their definitions.
-    /// The store will limit the number of instances, linear memories, and
-    /// tables created to 10,000. This can be overridden with the
-    /// [`Store::limiter`] configuration method.
-    pub fn new(engine: &Engine, data: T) -> Self {
-        let store_data = StoreData::new();
-        log::trace!("creating new store {:?}", store_data.id());
-
-        let pkey = engine.allocator().next_available_pkey();
-
-        let inner = StoreOpaque {
-            _marker: marker::PhantomPinned,
-            engine: engine.clone(),
-            vm_store_context: Default::default(),
-            #[cfg(feature = "stack-switching")]
-            continuations: Vec::new(),
-            instances: PrimaryMap::new(),
-            #[cfg(feature = "component-model")]
-            num_component_instances: 0,
-            signal_handler: None,
-            gc_store: None,
-            gc_roots: RootSet::default(),
-            #[cfg(feature = "gc")]
-            gc_roots_list: GcRootsList::default(),
-            #[cfg(feature = "gc")]
-            gc_host_alloc_types: Default::default(),
-            #[cfg(feature = "gc")]
-            pending_exception: None,
-            modules: ModuleRegistry::default(),
-            func_refs: FuncRefs::default(),
-            host_globals: PrimaryMap::new(),
-            instance_count: 0,
-            instance_limit: crate::DEFAULT_INSTANCE_LIMIT,
-            memory_count: 0,
-            memory_limit: crate::DEFAULT_MEMORY_LIMIT,
-            table_count: 0,
-            table_limit: crate::DEFAULT_TABLE_LIMIT,
-            #[cfg(feature = "async")]
-            async_state: Default::default(),
-            fuel_reserve: 0,
-            fuel_yield_interval: None,
-            store_data,
-            traitobj: StorePtr(None),
-            default_caller_vmctx: SendSyncPtr::new(NonNull::dangling()),
-            hostcall_val_storage: Vec::new(),
-            wasm_val_raw_storage: Vec::new(),
-            pkey,
-            #[cfg(feature = "component-model")]
-            component_host_table: Default::default(),
-            #[cfg(feature = "component-model")]
-            component_calls: Default::default(),
-            #[cfg(feature = "component-model")]
-            host_resource_data: Default::default(),
-            executor: Executor::new(engine),
-            #[cfg(feature = "component-model-async")]
-            concurrent_async_state: Default::default(),
-        };
-        let mut inner = Box::new(StoreInner {
-            inner,
-            limiter: None,
-            call_hook: None,
-            #[cfg(target_has_atomic = "64")]
-            epoch_deadline_behavior: None,
-            data: ManuallyDrop::new(data),
-        });
-
-        inner.traitobj = StorePtr(Some(NonNull::from(&mut *inner)));
-
-        // Wasmtime uses the callee argument to host functions to learn about
-        // the original pointer to the `Store` itself, allowing it to
-        // reconstruct a `StoreContextMut<T>`. When we initially call a `Func`,
-        // however, there's no "callee" to provide. To fix this we allocate a
-        // single "default callee" for the entire `Store`. This is then used as
-        // part of `Func::call` to guarantee that the `callee: *mut VMContext`
-        // is never null.
-        let module = Arc::new(wasmtime_environ::Module::default());
-        let shim = ModuleRuntimeInfo::bare(module);
-        let allocator = OnDemandInstanceAllocator::default();
-
-        allocator
-            .validate_module(shim.env_module(), shim.offsets())
-            .unwrap();
-
-        unsafe {
-            // Note that this dummy instance doesn't allocate tables or memories
-            // (also no limiter is passed in) so it won't have an async await
-            // point meaning that it should be ok to assert the future is
-            // always ready.
-            let id = vm::assert_ready(inner.allocate_instance(
-                None,
-                AllocateInstanceKind::Dummy {
-                    allocator: &allocator,
-                },
-                &shim,
-                Default::default(),
-            ))
-            .expect("failed to allocate default callee");
-            let default_caller_vmctx = inner.instance(id).vmctx();
-            inner.default_caller_vmctx = default_caller_vmctx.into();
-        }
-
-        Self {
-            inner: ManuallyDrop::new(inner),
-        }
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    #[inline]
-    pub fn data(&self) -> &T {
-        self.inner.data()
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    #[inline]
-    pub fn data_mut(&mut self) -> &mut T {
-        self.inner.data_mut()
-    }
-
-    fn run_manual_drop_routines(&mut self) {
-        // We need to drop the fibers of each component instance before
-        // attempting to drop the instances themselves since the fibers may need
-        // to be resumed and allowed to exit cleanly before we yank the state
-        // out from under them.
-        //
-        // This will also drop any futures which might use a `&Accessor` fields
-        // in their `Drop::drop` implementations, in which case they'll need to
-        // be called from with in the context of a `tls::set` closure.
-        #[cfg(feature = "component-model-async")]
-        ComponentStoreData::drop_fibers_and_futures(&mut **self.inner);
-
-        // Ensure all fiber stacks, even cached ones, are all flushed out to the
-        // instance allocator.
-        self.inner.flush_fiber_stack();
-    }
-
-    /// Consumes this [`Store`], destroying it, and returns the underlying data.
-    pub fn into_data(mut self) -> T {
-        self.run_manual_drop_routines();
-
-        // This is an unsafe operation because we want to avoid having a runtime
-        // check or boolean for whether the data is actually contained within a
-        // `Store`. The data itself is stored as `ManuallyDrop` since we're
-        // manually managing the memory here, and there's also a `ManuallyDrop`
-        // around the `Box<StoreInner<T>>`. The way this works though is a bit
-        // tricky, so here's how things get dropped appropriately:
-        //
-        // * When a `Store<T>` is normally dropped, the custom destructor for
-        //   `Store<T>` will drop `T`, then the `self.inner` field. The
-        //   rustc-glue destructor runs for `Box<StoreInner<T>>` which drops
-        //   `StoreInner<T>`. This cleans up all internal fields and doesn't
-        //   touch `T` because it's wrapped in `ManuallyDrop`.
-        //
-        // * When calling this method we skip the top-level destructor for
-        //   `Store<T>` with `mem::forget`. This skips both the destructor for
-        //   `T` and the destructor for `StoreInner<T>`. We do, however, run the
-        //   destructor for `Box<StoreInner<T>>` which, like above, will skip
-        //   the destructor for `T` since it's `ManuallyDrop`.
-        //
-        // In both cases all the other fields of `StoreInner<T>` should all get
-        // dropped, and the manual management of destructors is basically
-        // between this method and `Drop for Store<T>`. Note that this also
-        // means that `Drop for StoreInner<T>` cannot access `self.data`, so
-        // there is a comment indicating this as well.
-        unsafe {
-            let mut inner = ManuallyDrop::take(&mut self.inner);
-            core::mem::forget(self);
-            ManuallyDrop::take(&mut inner.data)
-        }
-    }
-
-    /// Configures the [`ResourceLimiter`] used to limit resource creation
-    /// within this [`Store`].
-    ///
-    /// Whenever resources such as linear memory, tables, or instances are
-    /// allocated the `limiter` specified here is invoked with the store's data
-    /// `T` and the returned [`ResourceLimiter`] is used to limit the operation
-    /// being allocated. The returned [`ResourceLimiter`] is intended to live
-    /// within the `T` itself, for example by storing a
-    /// [`StoreLimits`](crate::StoreLimits).
-    ///
-    /// Note that this limiter is only used to limit the creation/growth of
-    /// resources in the future, this does not retroactively attempt to apply
-    /// limits to the [`Store`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use wasmtime::*;
-    ///
-    /// struct MyApplicationState {
-    ///     my_state: u32,
-    ///     limits: StoreLimits,
-    /// }
-    ///
-    /// let engine = Engine::default();
-    /// let my_state = MyApplicationState {
-    ///     my_state: 42,
-    ///     limits: StoreLimitsBuilder::new()
-    ///         .memory_size(1 << 20 /* 1 MB */)
-    ///         .instances(2)
-    ///         .build(),
-    /// };
-    /// let mut store = Store::new(&engine, my_state);
-    /// store.limiter(|state| &mut state.limits);
-    ///
-    /// // Creation of smaller memories is allowed
-    /// Memory::new(&mut store, MemoryType::new(1, None)).unwrap();
-    ///
-    /// // Creation of a larger memory, however, will exceed the 1MB limit we've
-    /// // configured
-    /// assert!(Memory::new(&mut store, MemoryType::new(1000, None)).is_err());
-    ///
-    /// // The number of instances in this store is limited to 2, so the third
-    /// // instance here should fail.
-    /// let module = Module::new(&engine, "(module)").unwrap();
-    /// assert!(Instance::new(&mut store, &module, &[]).is_ok());
-    /// assert!(Instance::new(&mut store, &module, &[]).is_ok());
-    /// assert!(Instance::new(&mut store, &module, &[]).is_err());
-    /// ```
-    ///
-    /// [`ResourceLimiter`]: crate::ResourceLimiter
-    pub fn limiter(
-        &mut self,
-        mut limiter: impl (FnMut(&mut T) -> &mut dyn crate::ResourceLimiter) + Send + Sync + 'static,
-    ) {
-        // Apply the limits on instances, tables, and memory given by the limiter:
-        let inner = &mut self.inner;
-        let (instance_limit, table_limit, memory_limit) = {
-            let l = limiter(&mut inner.data);
-            (l.instances(), l.tables(), l.memories())
-        };
-        let innermost = &mut inner.inner;
-        innermost.instance_limit = instance_limit;
-        innermost.table_limit = table_limit;
-        innermost.memory_limit = memory_limit;
-
-        // Save the limiter accessor function:
-        inner.limiter = Some(ResourceLimiterInner::Sync(Box::new(limiter)));
-    }
-
-    /// Configure a function that runs on calls and returns between WebAssembly
-    /// and host code.
-    ///
-    /// The function is passed a [`CallHook`] argument, which indicates which
-    /// state transition the VM is making.
-    ///
-    /// This function may return a [`Trap`]. If a trap is returned when an
-    /// import was called, it is immediately raised as-if the host import had
-    /// returned the trap. If a trap is returned after wasm returns to the host
-    /// then the wasm function's result is ignored and this trap is returned
-    /// instead.
-    ///
-    /// After this function returns a trap, it may be called for subsequent returns
-    /// to host or wasm code as the trap propagates to the root call.
-    #[cfg(feature = "call-hook")]
-    pub fn call_hook(
-        &mut self,
-        hook: impl FnMut(StoreContextMut<'_, T>, CallHook) -> Result<()> + Send + Sync + 'static,
-    ) {
-        self.inner.call_hook = Some(CallHookInner::Sync(Box::new(hook)));
-    }
-
-    /// Returns the [`Engine`] that this store is associated with.
-    pub fn engine(&self) -> &Engine {
-        self.inner.engine()
-    }
-
-    /// Perform garbage collection.
-    ///
-    /// Note that it is not required to actively call this function. GC will
-    /// automatically happen according to various internal heuristics. This is
-    /// provided if fine-grained control over the GC is desired.
-    ///
-    /// If you are calling this method after an attempted allocation failed, you
-    /// may pass in the [`GcHeapOutOfMemory`][crate::GcHeapOutOfMemory] error.
-    /// When you do so, this method will attempt to create enough space in the
-    /// GC heap for that allocation, so that it will succeed on the next
-    /// attempt.
-    ///
-    /// This method is only available when the `gc` Cargo feature is enabled.
-    #[cfg(feature = "gc")]
-    pub fn gc(&mut self, why: Option<&crate::GcHeapOutOfMemory<()>>) {
-        StoreContextMut(&mut self.inner).gc(why)
-    }
-
-    /// Returns the amount fuel in this [`Store`]. When fuel is enabled, it must
-    /// be configured via [`Store::set_fuel`].
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if fuel consumption is not enabled
-    /// via [`Config::consume_fuel`](crate::Config::consume_fuel).
-    pub fn get_fuel(&self) -> Result<u64> {
-        self.inner.get_fuel()
-    }
-
-    /// Set the fuel to this [`Store`] for wasm to consume while executing.
-    ///
-    /// For this method to work fuel consumption must be enabled via
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel). By default a
-    /// [`Store`] starts with 0 fuel for wasm to execute with (meaning it will
-    /// immediately trap). This function must be called for the store to have
-    /// some fuel to allow WebAssembly to execute.
-    ///
-    /// Most WebAssembly instructions consume 1 unit of fuel. Some
-    /// instructions, such as `nop`, `drop`, `block`, and `loop`, consume 0
-    /// units, as any execution cost associated with them involves other
-    /// instructions which do consume fuel.
-    ///
-    /// Note that when fuel is entirely consumed it will cause wasm to trap.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if fuel consumption is not enabled via
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel).
-    pub fn set_fuel(&mut self, fuel: u64) -> Result<()> {
-        self.inner.set_fuel(fuel)
-    }
-
-    /// Configures a [`Store`] to yield execution of async WebAssembly code
-    /// periodically.
-    ///
-    /// When a [`Store`] is configured to consume fuel with
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel) this method will
-    /// configure WebAssembly to be suspended and control will be yielded back to the
-    /// caller every `interval` units of fuel consumed. This is only suitable with use of
-    /// a store associated with an [async config](crate::Config::async_support) because
-    /// only then are futures used and yields are possible.
-    ///
-    /// The purpose of this behavior is to ensure that futures which represent
-    /// execution of WebAssembly do not execute too long inside their
-    /// `Future::poll` method. This allows for some form of cooperative
-    /// multitasking where WebAssembly will voluntarily yield control
-    /// periodically (based on fuel consumption) back to the running thread.
-    ///
-    /// Note that futures returned by this crate will automatically flag
-    /// themselves to get re-polled if a yield happens. This means that
-    /// WebAssembly will continue to execute, just after giving the host an
-    /// opportunity to do something else.
-    ///
-    /// The `interval` parameter indicates how much fuel should be
-    /// consumed between yields of an async future. When fuel runs out wasm will trap.
-    ///
-    /// # Error
-    ///
-    /// This method will error if it is not called on a store associated with an [async
-    /// config](crate::Config::async_support).
-    pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()> {
-        self.inner.fuel_async_yield_interval(interval)
-    }
-
-    /// Sets the epoch deadline to a certain number of ticks in the future.
-    ///
-    /// When the Wasm guest code is compiled with epoch-interruption
-    /// instrumentation
-    /// ([`Config::epoch_interruption()`](crate::Config::epoch_interruption)),
-    /// and when the `Engine`'s epoch is incremented
-    /// ([`Engine::increment_epoch()`](crate::Engine::increment_epoch))
-    /// past a deadline, execution can be configured to either trap or
-    /// yield and then continue.
-    ///
-    /// This deadline is always set relative to the current epoch:
-    /// `ticks_beyond_current` ticks in the future. The deadline can
-    /// be set explicitly via this method, or refilled automatically
-    /// on a yield if configured via
-    /// [`epoch_deadline_async_yield_and_update()`](Store::epoch_deadline_async_yield_and_update). After
-    /// this method is invoked, the deadline is reached when
-    /// [`Engine::increment_epoch()`] has been invoked at least
-    /// `ticks_beyond_current` times.
-    ///
-    /// By default a store will trap immediately with an epoch deadline of 0
-    /// (which has always "elapsed"). This method is required to be configured
-    /// for stores with epochs enabled to some future epoch deadline.
-    ///
-    /// See documentation on
-    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
-    /// for an introduction to epoch-based interruption.
-    #[cfg(target_has_atomic = "64")]
-    pub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64) {
-        self.inner.set_epoch_deadline(ticks_beyond_current);
-    }
-
-    /// Configures epoch-deadline expiration to trap.
-    ///
-    /// When epoch-interruption-instrumented code is executed on this
-    /// store and the epoch deadline is reached before completion,
-    /// with the store configured in this way, execution will
-    /// terminate with a trap as soon as an epoch check in the
-    /// instrumented code is reached.
-    ///
-    /// This behavior is the default if the store is not otherwise
-    /// configured via
-    /// [`epoch_deadline_trap()`](Store::epoch_deadline_trap),
-    /// [`epoch_deadline_callback()`](Store::epoch_deadline_callback) or
-    /// [`epoch_deadline_async_yield_and_update()`](Store::epoch_deadline_async_yield_and_update).
-    ///
-    /// This setting is intended to allow for coarse-grained
-    /// interruption, but not a deterministic deadline of a fixed,
-    /// finite interval. For deterministic interruption, see the
-    /// "fuel" mechanism instead.
-    ///
-    /// Note that when this is used it's required to call
-    /// [`Store::set_epoch_deadline`] or otherwise wasm will always immediately
-    /// trap.
-    ///
-    /// See documentation on
-    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
-    /// for an introduction to epoch-based interruption.
-    #[cfg(target_has_atomic = "64")]
-    pub fn epoch_deadline_trap(&mut self) {
-        self.inner.epoch_deadline_trap();
-    }
-
-    /// Configures epoch-deadline expiration to invoke a custom callback
-    /// function.
-    ///
-    /// When epoch-interruption-instrumented code is executed on this
-    /// store and the epoch deadline is reached before completion, the
-    /// provided callback function is invoked.
-    ///
-    /// This callback should either return an [`UpdateDeadline`], or
-    /// return an error, which will terminate execution with a trap.
-    ///
-    /// The [`UpdateDeadline`] is a positive number of ticks to
-    /// add to the epoch deadline, as well as indicating what
-    /// to do after the callback returns. If the [`Store`] is
-    /// configured with async support, then the callback may return
-    /// [`UpdateDeadline::Yield`] or [`UpdateDeadline::YieldCustom`]
-    /// to yield to the async executor before updating the epoch deadline.
-    /// Alternatively, the callback may return [`UpdateDeadline::Continue`] to
-    /// update the epoch deadline immediately.
-    ///
-    /// This setting is intended to allow for coarse-grained
-    /// interruption, but not a deterministic deadline of a fixed,
-    /// finite interval. For deterministic interruption, see the
-    /// "fuel" mechanism instead.
-    ///
-    /// See documentation on
-    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
-    /// for an introduction to epoch-based interruption.
-    #[cfg(target_has_atomic = "64")]
-    pub fn epoch_deadline_callback(
-        &mut self,
-        callback: impl FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync + 'static,
-    ) {
-        self.inner.epoch_deadline_callback(Box::new(callback));
-    }
-
-    /// Set an exception as the currently pending exception, and
-    /// return an error that propagates the throw.
-    ///
-    /// This method takes an exception object and stores it in the
-    /// `Store` as the currently pending exception. This is a special
-    /// rooted slot that holds the exception as long as it is
-    /// propagating. This method then returns a `ThrownException`
-    /// error, which is a special type that indicates a pending
-    /// exception exists. When this type propagates as an error
-    /// returned from a Wasm-to-host call, the pending exception is
-    /// thrown within the Wasm context, and either caught or
-    /// propagated further to the host-to-Wasm call boundary. If an
-    /// exception is thrown out of Wasm (or across Wasm from a
-    /// hostcall) back to the host-to-Wasm call boundary, *that*
-    /// invocation returns a `ThrownException`, and the pending
-    /// exception slot is again set. In other words, the
-    /// `ThrownException` error type should propagate upward exactly
-    /// and only when a pending exception is set.
-    ///
-    /// To inspect or take the pending exception, use
-    /// [`peek_pending_exception`] and [`take_pending_exception`]. For
-    /// a convenient wrapper that invokes a closure and provides any
-    /// caught exception from the closure to a separate handler
-    /// closure, see [`StoreContextMut::catch`].
-    ///
-    /// This method is parameterized over `R` for convenience, but
-    /// will always return an `Err`.
-    ///
-    /// # Panics
-    ///
-    /// - Will panic if `exception` has been unrooted.
-    /// - Will panic if `exception` is a null reference.
-    /// - Will panic if a pending exception has already been set.
-    #[cfg(feature = "gc")]
-    pub fn throw<R>(&mut self, exception: Rooted<ExnRef>) -> Result<R, ThrownException> {
-        self.inner.throw_impl(exception);
-        Err(ThrownException)
-    }
-
-    /// Take the currently pending exception, if any, and return it,
-    /// removing it from the "pending exception" slot.
-    ///
-    /// If there is no pending exception, returns `None`.
-    ///
-    /// Note: the returned exception is a LIFO root (see
-    /// [`crate::Rooted`]), rooted in the current handle scope. Take
-    /// care to ensure that it is re-rooted or otherwise does not
-    /// escape this scope! It is usually best to allow an exception
-    /// object to be rooted in the store's "pending exception" slot
-    /// until the final consumer has taken it, rather than root it and
-    /// pass it up the callstack in some other way.
-    ///
-    /// This method is useful to implement ad-hoc exception plumbing
-    /// in various ways, but for the most idiomatic handling, see
-    /// [`StoreContextMut::catch`].
-    #[cfg(feature = "gc")]
-    pub fn take_pending_exception(&mut self) -> Option<Rooted<ExnRef>> {
-        self.inner.take_pending_exception_rooted()
-    }
-
-    /// Tests whether there is a pending exception.
-    ///
-    /// Ordinarily, a pending exception will be set on a store if and
-    /// only if a host-side callstack is propagating a
-    /// [`crate::ThrownException`] error. The final consumer that
-    /// catches the exception takes it; it may re-place it to re-throw
-    /// (using [`throw`]) if it chooses not to actually handle the
-    /// exception.
-    ///
-    /// This method is useful to tell whether a store is in this
-    /// state, but should not be used as part of the ordinary
-    /// exception-handling flow. For the most idiomatic handling, see
-    /// [`StoreContextMut::catch`].
-    #[cfg(feature = "gc")]
-    pub fn has_pending_exception(&self) -> bool {
-        self.inner.pending_exception.is_some()
-    }
-}
-
-impl<'a, T> StoreContext<'a, T> {
-    pub(crate) fn async_support(&self) -> bool {
-        self.0.async_support()
-    }
-
-    /// Returns the underlying [`Engine`] this store is connected to.
-    pub fn engine(&self) -> &Engine {
-        self.0.engine()
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    ///
-    /// Same as [`Store::data`].
-    pub fn data(&self) -> &'a T {
-        self.0.data()
-    }
-
-    /// Returns the remaining fuel in this store.
-    ///
-    /// For more information see [`Store::get_fuel`].
-    pub fn get_fuel(&self) -> Result<u64> {
-        self.0.get_fuel()
-    }
-}
-
-impl<'a, T> StoreContextMut<'a, T> {
-    /// Access the underlying data owned by this `Store`.
-    ///
-    /// Same as [`Store::data`].
-    pub fn data(&self) -> &T {
-        self.0.data()
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    ///
-    /// Same as [`Store::data_mut`].
-    pub fn data_mut(&mut self) -> &mut T {
-        self.0.data_mut()
-    }
-
-    /// Returns the underlying [`Engine`] this store is connected to.
-    pub fn engine(&self) -> &Engine {
-        self.0.engine()
-    }
-
-    /// Perform garbage collection of `ExternRef`s.
-    ///
-    /// Same as [`Store::gc`].
-    ///
-    /// This method is only available when the `gc` Cargo feature is enabled.
-    #[cfg(feature = "gc")]
-    pub fn gc(&mut self, why: Option<&crate::GcHeapOutOfMemory<()>>) {
-        assert!(!self.0.async_support());
-        let (mut limiter, store) = self.0.resource_limiter_and_store_opaque();
-        vm::assert_ready(store.gc(limiter.as_mut(), None, why.map(|e| e.bytes_needed())));
-    }
-
-    /// Returns remaining fuel in this store.
-    ///
-    /// For more information see [`Store::get_fuel`]
-    pub fn get_fuel(&self) -> Result<u64> {
-        self.0.get_fuel()
-    }
-
-    /// Set the amount of fuel in this store.
-    ///
-    /// For more information see [`Store::set_fuel`]
-    pub fn set_fuel(&mut self, fuel: u64) -> Result<()> {
-        self.0.set_fuel(fuel)
-    }
-
-    /// Configures this `Store` to periodically yield while executing futures.
-    ///
-    /// For more information see [`Store::fuel_async_yield_interval`]
-    pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()> {
-        self.0.fuel_async_yield_interval(interval)
-    }
-
-    /// Sets the epoch deadline to a certain number of ticks in the future.
-    ///
-    /// For more information see [`Store::set_epoch_deadline`].
-    #[cfg(target_has_atomic = "64")]
-    pub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64) {
-        self.0.set_epoch_deadline(ticks_beyond_current);
-    }
-
-    /// Configures epoch-deadline expiration to trap.
-    ///
-    /// For more information see [`Store::epoch_deadline_trap`].
-    #[cfg(target_has_atomic = "64")]
-    pub fn epoch_deadline_trap(&mut self) {
-        self.0.epoch_deadline_trap();
-    }
-
-    /// Set an exception as the currently pending exception, and
-    /// return an error that propagates the throw.
-    ///
-    /// See [`Store::throw`] for more details.
-    #[cfg(feature = "gc")]
-    pub fn throw<R>(&mut self, exception: Rooted<ExnRef>) -> Result<R, ThrownException> {
-        self.0.inner.throw_impl(exception);
-        Err(ThrownException)
-    }
-
-    /// Take the currently pending exception, if any, and return it,
-    /// removing it from the "pending exception" slot.
-    ///
-    /// See [`Store::take_pending_exception`] for more details.
-    #[cfg(feature = "gc")]
-    pub fn take_pending_exception(&mut self) -> Option<Rooted<ExnRef>> {
-        self.0.inner.take_pending_exception_rooted()
-    }
-
-    /// Tests whether there is a pending exception.
-    ///
-    ///
-    /// See [`Store::has_pending_exception`] for more details.
-    #[cfg(feature = "gc")]
-    pub fn has_pending_exception(&self) -> bool {
-        self.0.inner.pending_exception.is_some()
-    }
-}
-
-impl<T> StoreInner<T> {
-    #[inline]
-    fn data(&self) -> &T {
-        &self.data
-    }
-
-    #[inline]
-    fn data_mut(&mut self) -> &mut T {
-        &mut self.data
-    }
-
-    #[inline]
-    pub fn call_hook(&mut self, s: CallHook) -> Result<()> {
-        if self.inner.pkey.is_none() && self.call_hook.is_none() {
-            Ok(())
-        } else {
-            self.call_hook_slow_path(s)
-        }
-    }
-
-    fn call_hook_slow_path(&mut self, s: CallHook) -> Result<()> {
-        if let Some(pkey) = &self.inner.pkey {
-            let allocator = self.engine().allocator();
-            match s {
-                CallHook::CallingWasm | CallHook::ReturningFromHost => {
-                    allocator.restrict_to_pkey(*pkey)
-                }
-                CallHook::ReturningFromWasm | CallHook::CallingHost => allocator.allow_all_pkeys(),
-            }
-        }
-
-        // Temporarily take the configured behavior to avoid mutably borrowing
-        // multiple times.
-        if let Some(mut call_hook) = self.call_hook.take() {
-            let result = self.invoke_call_hook(&mut call_hook, s);
-            self.call_hook = Some(call_hook);
-            return result;
-        }
-
-        Ok(())
-    }
-
-    fn invoke_call_hook(&mut self, call_hook: &mut CallHookInner<T>, s: CallHook) -> Result<()> {
-        match call_hook {
-            #[cfg(feature = "call-hook")]
-            CallHookInner::Sync(hook) => hook((&mut *self).as_context_mut(), s),
-
-            #[cfg(all(feature = "async", feature = "call-hook"))]
-            CallHookInner::Async(handler) => {
-                if !self.can_block() {
-                    bail!("couldn't grab async_cx for call hook")
-                }
-                return (&mut *self)
-                    .as_context_mut()
-                    .with_blocking(|store, cx| cx.block_on(handler.handle_call_event(store, s)))?;
-            }
-
-            CallHookInner::ForceTypeParameterToBeUsed { uninhabited, .. } => {
-                let _ = s;
-                match *uninhabited {}
-            }
-        }
-    }
-
-    #[cfg(not(feature = "async"))]
-    fn flush_fiber_stack(&mut self) {
-        // noop shim so code can assume this always exists.
-    }
-}
-
-fn get_fuel(injected_fuel: i64, fuel_reserve: u64) -> u64 {
-    fuel_reserve.saturating_add_signed(-injected_fuel)
-}
-
-// Add remaining fuel from the reserve into the active fuel if there is any left.
-fn refuel(
-    injected_fuel: &mut i64,
-    fuel_reserve: &mut u64,
-    yield_interval: Option<NonZeroU64>,
-) -> bool {
-    let fuel = get_fuel(*injected_fuel, *fuel_reserve);
-    if fuel > 0 {
-        set_fuel(injected_fuel, fuel_reserve, yield_interval, fuel);
-        true
-    } else {
-        false
-    }
-}
-
-fn set_fuel(
-    injected_fuel: &mut i64,
-    fuel_reserve: &mut u64,
-    yield_interval: Option<NonZeroU64>,
-    new_fuel_amount: u64,
-) {
-    let interval = yield_interval.unwrap_or(NonZeroU64::MAX).get();
-    // If we're yielding periodically we only store the "active" amount of fuel into consumed_ptr
-    // for the VM to use.
-    let injected = core::cmp::min(interval, new_fuel_amount);
-    // Fuel in the VM is stored as an i64, so we have to cap the amount of fuel we inject into the
-    // VM at once to be i64 range.
-    let injected = core::cmp::min(injected, i64::MAX as u64);
-    // Add whatever is left over after injection to the reserve for later use.
-    *fuel_reserve = new_fuel_amount - injected;
-    // Within the VM we increment to count fuel, so inject a negative amount. The VM will halt when
-    // this counter is positive.
-    *injected_fuel = -(injected as i64);
-}
-
-#[doc(hidden)]
-impl StoreOpaque {
-    pub fn id(&self) -> StoreId {
-        self.store_data.id()
-    }
-
-    pub fn bump_resource_counts(&mut self, module: &Module) -> Result<()> {
-        fn bump(slot: &mut usize, max: usize, amt: usize, desc: &str) -> Result<()> {
-            let new = slot.saturating_add(amt);
-            if new > max {
-                bail!(
-                    "resource limit exceeded: {} count too high at {}",
-                    desc,
-                    new
-                );
-            }
-            *slot = new;
-            Ok(())
-        }
-
-        let module = module.env_module();
-        let memories = module.num_defined_memories();
-        let tables = module.num_defined_tables();
-
-        bump(&mut self.instance_count, self.instance_limit, 1, "instance")?;
-        bump(
-            &mut self.memory_count,
-            self.memory_limit,
-            memories,
-            "memory",
-        )?;
-        bump(&mut self.table_count, self.table_limit, tables, "table")?;
-
-        Ok(())
-    }
-
-    #[inline]
-    pub fn async_support(&self) -> bool {
-        cfg!(feature = "async") && self.engine().config().async_support
-    }
-
-    #[inline]
-    pub fn engine(&self) -> &Engine {
-        &self.engine
-    }
-
-    #[inline]
-    pub fn store_data(&self) -> &StoreData {
-        &self.store_data
-    }
-
-    #[inline]
-    pub fn store_data_mut(&mut self) -> &mut StoreData {
-        &mut self.store_data
-    }
-
-    #[inline]
-    pub(crate) fn modules(&self) -> &ModuleRegistry {
-        &self.modules
-    }
-
-    #[inline]
-    pub(crate) fn modules_mut(&mut self) -> &mut ModuleRegistry {
-        &mut self.modules
-    }
-
-    pub(crate) fn func_refs_and_modules(&mut self) -> (&mut FuncRefs, &ModuleRegistry) {
-        (&mut self.func_refs, &self.modules)
-    }
-
-    pub(crate) fn host_globals(
-        &self,
-    ) -> &PrimaryMap<DefinedGlobalIndex, StoreBox<VMHostGlobalContext>> {
-        &self.host_globals
-    }
-
-    pub(crate) fn host_globals_mut(
-        &mut self,
-    ) -> &mut PrimaryMap<DefinedGlobalIndex, StoreBox<VMHostGlobalContext>> {
-        &mut self.host_globals
-    }
-
-    pub fn module_for_instance(&self, instance: StoreInstanceId) -> Option<&'_ Module> {
-        instance.store_id().assert_belongs_to(self.id());
-        match self.instances[instance.instance()].kind {
-            StoreInstanceKind::Dummy => None,
-            StoreInstanceKind::Real { module_id } => {
-                let module = self
-                    .modules()
-                    .lookup_module_by_id(module_id)
-                    .expect("should always have a registered module for real instances");
-                Some(module)
-            }
-        }
-    }
-
-    /// Accessor from `InstanceId` to `&vm::Instance`.
-    ///
-    /// Note that if you have a `StoreInstanceId` you should use
-    /// `StoreInstanceId::get` instead. This assumes that `id` has been
-    /// validated to already belong to this store.
-    #[inline]
-    pub fn instance(&self, id: InstanceId) -> &vm::Instance {
-        self.instances[id].handle.get()
-    }
-
-    /// Accessor from `InstanceId` to `Pin<&mut vm::Instance>`.
-    ///
-    /// Note that if you have a `StoreInstanceId` you should use
-    /// `StoreInstanceId::get_mut` instead. This assumes that `id` has been
-    /// validated to already belong to this store.
-    #[inline]
-    pub fn instance_mut(&mut self, id: InstanceId) -> Pin<&mut vm::Instance> {
-        self.instances[id].handle.get_mut()
-    }
-
-    /// Access multiple instances specified via `ids`.
-    ///
-    /// # Panics
-    ///
-    /// This method will panic if any indices in `ids` overlap.
-    ///
-    /// # Safety
-    ///
-    /// This method is not safe if the returned instances are used to traverse
-    /// "laterally" between other instances. For example accessing imported
-    /// items in an instance may traverse laterally to a sibling instance thus
-    /// aliasing a returned value here. The caller must ensure that only defined
-    /// items within the instances themselves are accessed.
-    #[inline]
-    pub unsafe fn optional_gc_store_and_instances_mut<const N: usize>(
-        &mut self,
-        ids: [InstanceId; N],
-    ) -> (Option<&mut GcStore>, [Pin<&mut vm::Instance>; N]) {
-        let instances = self
-            .instances
-            .get_disjoint_mut(ids)
-            .unwrap()
-            .map(|h| h.handle.get_mut());
-        (self.gc_store.as_mut(), instances)
-    }
-
-    /// Pair of `Self::optional_gc_store_mut` and `Self::instance_mut`
-    pub fn optional_gc_store_and_instance_mut(
-        &mut self,
-        id: InstanceId,
-    ) -> (Option<&mut GcStore>, Pin<&mut vm::Instance>) {
-        (self.gc_store.as_mut(), self.instances[id].handle.get_mut())
-    }
-
-    /// Get all instances (ignoring dummy instances) within this store.
-    pub fn all_instances<'a>(&'a mut self) -> impl ExactSizeIterator<Item = Instance> + 'a {
-        let instances = self
-            .instances
-            .iter()
-            .filter_map(|(id, inst)| {
-                if let StoreInstanceKind::Dummy = inst.kind {
-                    None
-                } else {
-                    Some(id)
-                }
-            })
-            .collect::<Vec<_>>();
-        instances
-            .into_iter()
-            .map(|i| Instance::from_wasmtime(i, self))
-    }
-
-    /// Get all memories (host- or Wasm-defined) within this store.
-    pub fn all_memories<'a>(&'a self) -> impl Iterator<Item = Memory> + 'a {
-        // NB: Host-created memories have dummy instances. Therefore, we can get
-        // all memories in the store by iterating over all instances (including
-        // dummy instances) and getting each of their defined memories.
-        let id = self.id();
-        self.instances
-            .iter()
-            .flat_map(move |(_, instance)| instance.handle.get().defined_memories(id))
-    }
-
-    /// Iterate over all tables (host- or Wasm-defined) within this store.
-    pub fn for_each_table(&mut self, mut f: impl FnMut(&mut Self, Table)) {
-        // NB: Host-created tables have dummy instances. Therefore, we can get
-        // all tables in the store by iterating over all instances (including
-        // dummy instances) and getting each of their defined memories.
-        for id in self.instances.keys() {
-            let instance = StoreInstanceId::new(self.id(), id);
-            for table in 0..self.instance(id).env_module().num_defined_tables() {
-                let table = DefinedTableIndex::new(table);
-                f(self, Table::from_raw(instance, table));
-            }
-        }
-    }
-
-    /// Iterate over all globals (host- or Wasm-defined) within this store.
-    pub fn for_each_global(&mut self, mut f: impl FnMut(&mut Self, Global)) {
-        // First enumerate all the host-created globals.
-        for global in self.host_globals.keys() {
-            let global = Global::new_host(self, global);
-            f(self, global);
-        }
-
-        // Then enumerate all instances' defined globals.
-        for id in self.instances.keys() {
-            for index in 0..self.instance(id).env_module().num_defined_globals() {
-                let index = DefinedGlobalIndex::new(index);
-                let global = Global::new_instance(self, id, index);
-                f(self, global);
-            }
-        }
-    }
-
-    #[cfg(all(feature = "std", any(unix, windows)))]
-    pub fn set_signal_handler(&mut self, handler: Option<SignalHandler>) {
-        self.signal_handler = handler;
-    }
-
-    #[inline]
-    pub fn vm_store_context(&self) -> &VMStoreContext {
-        &self.vm_store_context
-    }
-
-    #[inline]
-    pub fn vm_store_context_mut(&mut self) -> &mut VMStoreContext {
-        &mut self.vm_store_context
-    }
-
-    /// Performs a lazy allocation of the `GcStore` within this store, returning
-    /// the previous allocation if it's already present.
-    ///
-    /// This method will, if necessary, allocate a new `GcStore` -- linear
-    /// memory and all. This is a blocking operation due to
-    /// `ResourceLimiterAsync` which means that this should only be executed
-    /// in a fiber context at this time.
-    #[inline]
-    pub(crate) async fn ensure_gc_store(
-        &mut self,
-        limiter: Option<&mut StoreResourceLimiter<'_>>,
-    ) -> Result<&mut GcStore> {
-        if self.gc_store.is_some() {
-            return Ok(self.gc_store.as_mut().unwrap());
-        }
-        self.allocate_gc_store(limiter).await
-    }
-
-    #[inline(never)]
-    async fn allocate_gc_store(
-        &mut self,
-        limiter: Option<&mut StoreResourceLimiter<'_>>,
-    ) -> Result<&mut GcStore> {
-        log::trace!("allocating GC heap for store {:?}", self.id());
-
-        assert!(self.gc_store.is_none());
-        assert_eq!(
-            self.vm_store_context.gc_heap.base.as_non_null(),
-            NonNull::dangling(),
-        );
-        assert_eq!(self.vm_store_context.gc_heap.current_length(), 0);
-
-        let gc_store = allocate_gc_store(self, limiter).await?;
-        self.vm_store_context.gc_heap = gc_store.vmmemory_definition();
-        return Ok(self.gc_store.insert(gc_store));
-
-        #[cfg(feature = "gc")]
-        async fn allocate_gc_store(
-            store: &mut StoreOpaque,
-            limiter: Option<&mut StoreResourceLimiter<'_>>,
-        ) -> Result<GcStore> {
-            use wasmtime_environ::packed_option::ReservedValue;
-
-            let engine = store.engine();
-            let mem_ty = engine.tunables().gc_heap_memory_type();
-            ensure!(
-                engine.features().gc_types(),
-                "cannot allocate a GC store when GC is disabled at configuration time"
-            );
-
-            // First, allocate the memory that will be our GC heap's storage.
-            let mut request = InstanceAllocationRequest {
-                id: InstanceId::reserved_value(),
-                runtime_info: &ModuleRuntimeInfo::bare(Arc::new(
-                    wasmtime_environ::Module::default(),
-                )),
-                imports: vm::Imports::default(),
-                store,
-                limiter,
-            };
-
-            let (mem_alloc_index, mem) = engine
-                .allocator()
-                .allocate_memory(&mut request, &mem_ty, None)
-                .await?;
-
-            // Then, allocate the actual GC heap, passing in that memory
-            // storage.
-            let gc_runtime = engine
-                .gc_runtime()
-                .context("no GC runtime: GC disabled at compile time or configuration time")?;
-            let (index, heap) =
-                engine
-                    .allocator()
-                    .allocate_gc_heap(engine, &**gc_runtime, mem_alloc_index, mem)?;
-
-            Ok(GcStore::new(index, heap))
-        }
-
-        #[cfg(not(feature = "gc"))]
-        async fn allocate_gc_store(
-            _: &mut StoreOpaque,
-            _: Option<&mut StoreResourceLimiter<'_>>,
-        ) -> Result<GcStore> {
-            bail!("cannot allocate a GC store: the `gc` feature was disabled at compile time")
-        }
-    }
-
-    /// Helper method to require that a `GcStore` was previously allocated for
-    /// this store, failing if it has not yet been allocated.
-    ///
-    /// Note that this should only be used in a context where allocation of a
-    /// `GcStore` is sure to have already happened prior, otherwise this may
-    /// return a confusing error to embedders which is a bug in Wasmtime.
-    ///
-    /// Some situations where it's safe to call this method:
-    ///
-    /// * There's already a non-null and non-i31 `VMGcRef` in scope. By existing
-    ///   this shows proof that the `GcStore` was previously allocated.
-    /// * During instantiation and instance's `needs_gc_heap` flag will be
-    ///   handled and instantiation will automatically create a GC store.
-    #[inline]
-    #[cfg(feature = "gc")]
-    pub(crate) fn require_gc_store(&self) -> Result<&GcStore> {
-        match &self.gc_store {
-            Some(gc_store) => Ok(gc_store),
-            None => bail!("GC heap not initialized yet"),
-        }
-    }
-
-    /// Same as [`Self::require_gc_store`], but mutable.
-    #[inline]
-    #[cfg(feature = "gc")]
-    pub(crate) fn require_gc_store_mut(&mut self) -> Result<&mut GcStore> {
-        match &mut self.gc_store {
-            Some(gc_store) => Ok(gc_store),
-            None => bail!("GC heap not initialized yet"),
-        }
-    }
-
-    /// Attempts to access the GC store that has been previously allocated.
-    ///
-    /// This method will return `Some` if the GC store was previously allocated.
-    /// A `None` return value means either that the GC heap hasn't yet been
-    /// allocated or that it does not need to be allocated for this store. Note
-    /// that to require a GC store in a particular situation it's recommended to
-    /// use [`Self::require_gc_store_mut`] instead.
-    #[inline]
-    pub(crate) fn optional_gc_store_mut(&mut self) -> Option<&mut GcStore> {
-        if cfg!(not(feature = "gc")) || !self.engine.features().gc_types() {
-            debug_assert!(self.gc_store.is_none());
-            None
-        } else {
-            self.gc_store.as_mut()
-        }
-    }
-
-    /// Helper to assert that a GC store was previously allocated and is
-    /// present.
-    ///
-    /// # Panics
-    ///
-    /// This method will panic if the GC store has not yet been allocated. This
-    /// should only be used in a context where there's an existing GC reference,
-    /// for example, or if `ensure_gc_store` has already been called.
-    #[inline]
-    #[track_caller]
-    pub(crate) fn unwrap_gc_store(&self) -> &GcStore {
-        self.gc_store
-            .as_ref()
-            .expect("attempted to access the store's GC heap before it has been allocated")
-    }
-
-    /// Same as [`Self::unwrap_gc_store`], but mutable.
-    #[inline]
-    #[track_caller]
-    pub(crate) fn unwrap_gc_store_mut(&mut self) -> &mut GcStore {
-        self.gc_store
-            .as_mut()
-            .expect("attempted to access the store's GC heap before it has been allocated")
-    }
-
-    #[inline]
-    pub(crate) fn gc_roots(&self) -> &RootSet {
-        &self.gc_roots
-    }
-
-    #[inline]
-    #[cfg(feature = "gc")]
-    pub(crate) fn gc_roots_mut(&mut self) -> &mut RootSet {
-        &mut self.gc_roots
-    }
-
-    #[inline]
-    pub(crate) fn exit_gc_lifo_scope(&mut self, scope: usize) {
-        self.gc_roots.exit_lifo_scope(self.gc_store.as_mut(), scope);
-    }
-
-    #[cfg(feature = "gc")]
-    async fn do_gc(&mut self) {
-        // If the GC heap hasn't been initialized, there is nothing to collect.
-        if self.gc_store.is_none() {
-            return;
-        }
-
-        log::trace!("============ Begin GC ===========");
-
-        // Take the GC roots out of `self` so we can borrow it mutably but still
-        // call mutable methods on `self`.
-        let mut roots = core::mem::take(&mut self.gc_roots_list);
-
-        self.trace_roots(&mut roots).await;
-        let async_yield = self.async_support();
-        self.unwrap_gc_store_mut()
-            .gc(async_yield, unsafe { roots.iter() })
-            .await;
-
-        // Restore the GC roots for the next GC.
-        roots.clear();
-        self.gc_roots_list = roots;
-
-        log::trace!("============ End GC ===========");
-    }
-
-    #[cfg(feature = "gc")]
-    async fn trace_roots(&mut self, gc_roots_list: &mut GcRootsList) {
-        log::trace!("Begin trace GC roots");
-
-        // We shouldn't have any leftover, stale GC roots.
-        assert!(gc_roots_list.is_empty());
-
-        self.trace_wasm_stack_roots(gc_roots_list);
-        #[cfg(feature = "async")]
-        if self.async_support() {
-            vm::Yield::new().await;
-        }
-        #[cfg(feature = "stack-switching")]
-        {
-            self.trace_wasm_continuation_roots(gc_roots_list);
-            #[cfg(feature = "async")]
-            if self.async_support() {
-                vm::Yield::new().await;
-            }
-        }
-        self.trace_vmctx_roots(gc_roots_list);
-        #[cfg(feature = "async")]
-        if self.async_support() {
-            vm::Yield::new().await;
-        }
-        self.trace_user_roots(gc_roots_list);
-        self.trace_pending_exception_roots(gc_roots_list);
-
-        log::trace!("End trace GC roots")
-    }
-
-    #[cfg(feature = "gc")]
-    fn trace_wasm_stack_frame(
-        &self,
-        gc_roots_list: &mut GcRootsList,
-        frame: crate::runtime::vm::Frame,
-    ) {
-        use crate::runtime::vm::SendSyncPtr;
-        use core::ptr::NonNull;
-
-        let pc = frame.pc();
-        debug_assert!(pc != 0, "we should always get a valid PC for Wasm frames");
-
-        let fp = frame.fp() as *mut usize;
-        debug_assert!(
-            !fp.is_null(),
-            "we should always get a valid frame pointer for Wasm frames"
-        );
-
-        let module_info = self
-            .modules()
-            .lookup_module_by_pc(pc)
-            .expect("should have module info for Wasm frame");
-
-        let stack_map = match module_info.lookup_stack_map(pc) {
-            Some(sm) => sm,
-            None => {
-                log::trace!("No stack map for this Wasm frame");
-                return;
-            }
-        };
-        log::trace!(
-            "We have a stack map that maps {} bytes in this Wasm frame",
-            stack_map.frame_size()
-        );
-
-        let sp = unsafe { stack_map.sp(fp) };
-        for stack_slot in unsafe { stack_map.live_gc_refs(sp) } {
-            let raw: u32 = unsafe { core::ptr::read(stack_slot) };
-            log::trace!("Stack slot @ {stack_slot:p} = {raw:#x}");
-
-            let gc_ref = vm::VMGcRef::from_raw_u32(raw);
-            if gc_ref.is_some() {
-                unsafe {
-                    gc_roots_list
-                        .add_wasm_stack_root(SendSyncPtr::new(NonNull::new(stack_slot).unwrap()));
-                }
-            }
-        }
-    }
-
-    #[cfg(feature = "gc")]
-    fn trace_wasm_stack_roots(&mut self, gc_roots_list: &mut GcRootsList) {
-        use crate::runtime::vm::Backtrace;
-        log::trace!("Begin trace GC roots :: Wasm stack");
-
-        Backtrace::trace(self, |frame| {
-            self.trace_wasm_stack_frame(gc_roots_list, frame);
-            core::ops::ControlFlow::Continue(())
-        });
-
-        log::trace!("End trace GC roots :: Wasm stack");
-    }
-
-    #[cfg(all(feature = "gc", feature = "stack-switching"))]
-    fn trace_wasm_continuation_roots(&mut self, gc_roots_list: &mut GcRootsList) {
-        use crate::{runtime::vm::Backtrace, vm::VMStackState};
-        log::trace!("Begin trace GC roots :: continuations");
-
-        for continuation in &self.continuations {
-            let state = continuation.common_stack_information.state;
-
-            // FIXME(frank-emrich) In general, it is not enough to just trace
-            // through the stacks of continuations; we also need to look through
-            // their `cont.bind` arguments. However, we don't currently have
-            // enough RTTI information to check if any of the values in the
-            // buffers used by `cont.bind` are GC values. As a workaround, note
-            // that we currently disallow cont.bind-ing GC values altogether.
-            // This way, it is okay not to check them here.
-            match state {
-                VMStackState::Suspended => {
-                    Backtrace::trace_suspended_continuation(self, continuation.deref(), |frame| {
-                        self.trace_wasm_stack_frame(gc_roots_list, frame);
-                        core::ops::ControlFlow::Continue(())
-                    });
-                }
-                VMStackState::Running => {
-                    // Handled by `trace_wasm_stack_roots`.
-                }
-                VMStackState::Parent => {
-                    // We don't know whether our child is suspended or running, but in
-                    // either case things should be hanlded correctly when traversing
-                    // further along in the chain, nothing required at this point.
-                }
-                VMStackState::Fresh | VMStackState::Returned => {
-                    // Fresh/Returned continuations have no gc values on their stack.
-                }
-            }
-        }
-
-        log::trace!("End trace GC roots :: continuations");
-    }
-
-    #[cfg(feature = "gc")]
-    fn trace_vmctx_roots(&mut self, gc_roots_list: &mut GcRootsList) {
-        log::trace!("Begin trace GC roots :: vmctx");
-        self.for_each_global(|store, global| global.trace_root(store, gc_roots_list));
-        self.for_each_table(|store, table| table.trace_roots(store, gc_roots_list));
-        log::trace!("End trace GC roots :: vmctx");
-    }
-
-    #[cfg(feature = "gc")]
-    fn trace_user_roots(&mut self, gc_roots_list: &mut GcRootsList) {
-        log::trace!("Begin trace GC roots :: user");
-        self.gc_roots.trace_roots(gc_roots_list);
-        log::trace!("End trace GC roots :: user");
-    }
-
-    #[cfg(feature = "gc")]
-    fn trace_pending_exception_roots(&mut self, gc_roots_list: &mut GcRootsList) {
-        log::trace!("Begin trace GC roots :: pending exception");
-        if let Some(pending_exception) = self.pending_exception.as_mut() {
-            unsafe {
-                let root = pending_exception.as_gc_ref_mut();
-                gc_roots_list.add_root(root.into(), "Pending exception");
-            }
-        }
-        log::trace!("End trace GC roots :: pending exception");
-    }
-
-    /// Insert a host-allocated GC type into this store.
-    ///
-    /// This makes it suitable for the embedder to allocate instances of this
-    /// type in this store, and we don't have to worry about the type being
-    /// reclaimed (since it is possible that none of the Wasm modules in this
-    /// store are holding it alive).
-    #[cfg(feature = "gc")]
-    pub(crate) fn insert_gc_host_alloc_type(&mut self, ty: crate::type_registry::RegisteredType) {
-        self.gc_host_alloc_types.insert(ty);
-    }
-
-    /// Helper function execute a `init_gc_ref` when placing `gc_ref` in `dest`.
-    ///
-    /// This avoids allocating `GcStore` where possible.
-    pub(crate) fn init_gc_ref(
-        &mut self,
-        dest: &mut MaybeUninit<Option<VMGcRef>>,
-        gc_ref: Option<&VMGcRef>,
-    ) {
-        if GcStore::needs_init_barrier(gc_ref) {
-            self.unwrap_gc_store_mut().init_gc_ref(dest, gc_ref)
-        } else {
-            dest.write(gc_ref.map(|r| r.copy_i31()));
-        }
-    }
-
-    /// Helper function execute a write barrier when placing `gc_ref` in `dest`.
-    ///
-    /// This avoids allocating `GcStore` where possible.
-    pub(crate) fn write_gc_ref(&mut self, dest: &mut Option<VMGcRef>, gc_ref: Option<&VMGcRef>) {
-        GcStore::write_gc_ref_optional_store(self.optional_gc_store_mut(), dest, gc_ref)
-    }
-
-    /// Helper function to clone `gc_ref` notably avoiding allocating a
-    /// `GcStore` where possible.
-    pub(crate) fn clone_gc_ref(&mut self, gc_ref: &VMGcRef) -> VMGcRef {
-        if gc_ref.is_i31() {
-            gc_ref.copy_i31()
-        } else {
-            self.unwrap_gc_store_mut().clone_gc_ref(gc_ref)
-        }
-    }
-
-    pub fn get_fuel(&self) -> Result<u64> {
-        anyhow::ensure!(
-            self.engine().tunables().consume_fuel,
-            "fuel is not configured in this store"
-        );
-        let injected_fuel = unsafe { *self.vm_store_context.fuel_consumed.get() };
-        Ok(get_fuel(injected_fuel, self.fuel_reserve))
-    }
-
-    pub(crate) fn refuel(&mut self) -> bool {
-        let injected_fuel = unsafe { &mut *self.vm_store_context.fuel_consumed.get() };
-        refuel(
-            injected_fuel,
-            &mut self.fuel_reserve,
-            self.fuel_yield_interval,
-        )
-    }
-
-    pub fn set_fuel(&mut self, fuel: u64) -> Result<()> {
-        anyhow::ensure!(
-            self.engine().tunables().consume_fuel,
-            "fuel is not configured in this store"
-        );
-        let injected_fuel = unsafe { &mut *self.vm_store_context.fuel_consumed.get() };
-        set_fuel(
-            injected_fuel,
-            &mut self.fuel_reserve,
-            self.fuel_yield_interval,
-            fuel,
-        );
-        Ok(())
-    }
-
-    pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()> {
-        anyhow::ensure!(
-            self.engine().tunables().consume_fuel,
-            "fuel is not configured in this store"
-        );
-        anyhow::ensure!(
-            self.engine().config().async_support,
-            "async support is not configured in this store"
-        );
-        anyhow::ensure!(
-            interval != Some(0),
-            "fuel_async_yield_interval must not be 0"
-        );
-        self.fuel_yield_interval = interval.and_then(|i| NonZeroU64::new(i));
-        // Reset the fuel active + reserve states by resetting the amount.
-        self.set_fuel(self.get_fuel()?)
-    }
-
-    #[inline]
-    pub fn signal_handler(&self) -> Option<*const SignalHandler> {
-        let handler = self.signal_handler.as_ref()?;
-        Some(handler)
-    }
-
-    #[inline]
-    pub fn vm_store_context_ptr(&self) -> NonNull<VMStoreContext> {
-        NonNull::from(&self.vm_store_context)
-    }
-
-    #[inline]
-    pub fn default_caller(&self) -> NonNull<VMContext> {
-        self.default_caller_vmctx.as_non_null()
-    }
-
-    #[inline]
-    pub fn traitobj(&self) -> NonNull<dyn VMStore> {
-        self.traitobj.0.unwrap()
-    }
-
-    /// Takes the cached `Vec<Val>` stored internally across hostcalls to get
-    /// used as part of calling the host in a `Func::new` method invocation.
-    #[inline]
-    pub fn take_hostcall_val_storage(&mut self) -> Vec<Val> {
-        mem::take(&mut self.hostcall_val_storage)
-    }
-
-    /// Restores the vector previously taken by `take_hostcall_val_storage`
-    /// above back into the store, allowing it to be used in the future for the
-    /// next wasm->host call.
-    #[inline]
-    pub fn save_hostcall_val_storage(&mut self, storage: Vec<Val>) {
-        if storage.capacity() > self.hostcall_val_storage.capacity() {
-            self.hostcall_val_storage = storage;
-        }
-    }
-
-    /// Same as `take_hostcall_val_storage`, but for the direction of the host
-    /// calling wasm.
-    #[inline]
-    pub fn take_wasm_val_raw_storage(&mut self) -> Vec<ValRaw> {
-        mem::take(&mut self.wasm_val_raw_storage)
-    }
-
-    /// Same as `save_hostcall_val_storage`, but for the direction of the host
-    /// calling wasm.
-    #[inline]
-    pub fn save_wasm_val_raw_storage(&mut self, storage: Vec<ValRaw>) {
-        if storage.capacity() > self.wasm_val_raw_storage.capacity() {
-            self.wasm_val_raw_storage = storage;
-        }
-    }
-
-    /// Translates a WebAssembly fault at the native `pc` and native `addr` to a
-    /// WebAssembly-relative fault.
-    ///
-    /// This function may abort the process if `addr` is not found to actually
-    /// reside in any linear memory. In such a situation it means that the
-    /// segfault was erroneously caught by Wasmtime and is possibly indicative
-    /// of a code generator bug.
-    ///
-    /// This function returns `None` for dynamically-bounds-checked-memories
-    /// with spectre mitigations enabled since the hardware fault address is
-    /// always zero in these situations which means that the trapping context
-    /// doesn't have enough information to report the fault address.
-    pub(crate) fn wasm_fault(&self, pc: usize, addr: usize) -> Option<vm::WasmFault> {
-        // There are a few instances where a "close to zero" pointer is loaded
-        // and we expect that to happen:
-        //
-        // * Explicitly bounds-checked memories with spectre-guards enabled will
-        //   cause out-of-bounds accesses to get routed to address 0, so allow
-        //   wasm instructions to fault on the null address.
-        // * `call_indirect` when invoking a null function pointer may load data
-        //   from the a `VMFuncRef` whose address is null, meaning any field of
-        //   `VMFuncRef` could be the address of the fault.
-        //
-        // In these situations where the address is so small it won't be in any
-        // instance, so skip the checks below.
-        if addr <= mem::size_of::<VMFuncRef>() {
-            const _: () = {
-                // static-assert that `VMFuncRef` isn't too big to ensure that
-                // it lives solely within the first page as we currently only
-                // have the guarantee that the first page of memory is unmapped,
-                // no more.
-                assert!(mem::size_of::<VMFuncRef>() <= 512);
-            };
-            return None;
-        }
-
-        // Search all known instances in this store for this address. Note that
-        // this is probably not the speediest way to do this. Traps, however,
-        // are generally not expected to be super fast and additionally stores
-        // probably don't have all that many instances or memories.
-        //
-        // If this loop becomes hot in the future, however, it should be
-        // possible to precompute maps about linear memories in a store and have
-        // a quicker lookup.
-        let mut fault = None;
-        for (_, instance) in self.instances.iter() {
-            if let Some(f) = instance.handle.get().wasm_fault(addr) {
-                assert!(fault.is_none());
-                fault = Some(f);
-            }
-        }
-        if fault.is_some() {
-            return fault;
-        }
-
-        cfg_if::cfg_if! {
-            if #[cfg(feature = "std")] {
-                // With the standard library a rich error can be printed here
-                // to stderr and the native abort path is used.
-                eprintln!(
-                    "\
-Wasmtime caught a segfault for a wasm program because the faulting instruction
-is allowed to segfault due to how linear memories are implemented. The address
-that was accessed, however, is not known to any linear memory in use within this
-Store. This may be indicative of a critical bug in Wasmtime's code generation
-because all addresses which are known to be reachable from wasm won't reach this
-message.
-
-    pc:      0x{pc:x}
-    address: 0x{addr:x}
-
-This is a possible security issue because WebAssembly has accessed something it
-shouldn't have been able to. Other accesses may have succeeded and this one just
-happened to be caught. The process will now be aborted to prevent this damage
-from going any further and to alert what's going on. If this is a security
-issue please reach out to the Wasmtime team via its security policy
-at https://bytecodealliance.org/security.
-"
-                );
-                std::process::abort();
-            } else if #[cfg(panic = "abort")] {
-                // Without the standard library but with `panic=abort` then
-                // it's safe to panic as that's known to halt execution. For
-                // now avoid the above error message as well since without
-                // `std` it's probably best to be a bit more size-conscious.
-                let _ = pc;
-                panic!("invalid fault");
-            } else {
-                // Without `std` and with `panic = "unwind"` there's no
-                // dedicated API to abort the process portably, so manufacture
-                // this with a double-panic.
-                let _ = pc;
-
-                struct PanicAgainOnDrop;
-
-                impl Drop for PanicAgainOnDrop {
-                    fn drop(&mut self) {
-                        panic!("panicking again to trigger a process abort");
-                    }
-
-                }
-
-                let _bomb = PanicAgainOnDrop;
-
-                panic!("invalid fault");
-            }
-        }
-    }
-
-    /// Retrieve the store's protection key.
-    #[inline]
-    #[cfg(feature = "pooling-allocator")]
-    pub(crate) fn get_pkey(&self) -> Option<ProtectionKey> {
-        self.pkey
-    }
-
-    #[inline]
-    #[cfg(feature = "component-model")]
-    pub(crate) fn component_resource_state(
-        &mut self,
-    ) -> (
-        &mut vm::component::CallContexts,
-        &mut vm::component::HandleTable,
-        &mut crate::component::HostResourceData,
-    ) {
-        (
-            &mut self.component_calls,
-            &mut self.component_host_table,
-            &mut self.host_resource_data,
-        )
-    }
-
-    #[cfg(feature = "component-model")]
-    pub(crate) fn push_component_instance(&mut self, instance: crate::component::Instance) {
-        // We don't actually need the instance itself right now, but it seems
-        // like something we will almost certainly eventually want to keep
-        // around, so force callers to provide it.
-        let _ = instance;
-
-        self.num_component_instances += 1;
-    }
-
-    #[inline]
-    #[cfg(feature = "component-model")]
-    pub(crate) fn component_resource_state_with_instance(
-        &mut self,
-        instance: crate::component::Instance,
-    ) -> (
-        &mut vm::component::CallContexts,
-        &mut vm::component::HandleTable,
-        &mut crate::component::HostResourceData,
-        Pin<&mut vm::component::ComponentInstance>,
-    ) {
-        (
-            &mut self.component_calls,
-            &mut self.component_host_table,
-            &mut self.host_resource_data,
-            instance.id().from_data_get_mut(&mut self.store_data),
-        )
-    }
-
-    #[cfg(feature = "async")]
-    pub(crate) fn fiber_async_state_mut(&mut self) -> &mut fiber::AsyncState {
-        &mut self.async_state
-    }
-
-    #[cfg(feature = "component-model-async")]
-    pub(crate) fn concurrent_async_state_mut(&mut self) -> &mut concurrent::AsyncState {
-        &mut self.concurrent_async_state
-    }
-
-    #[cfg(feature = "async")]
-    pub(crate) fn has_pkey(&self) -> bool {
-        self.pkey.is_some()
-    }
-
-    pub(crate) fn executor(&mut self) -> ExecutorRef<'_> {
-        match &mut self.executor {
-            Executor::Interpreter(i) => ExecutorRef::Interpreter(i.as_interpreter_ref()),
-            #[cfg(has_host_compiler_backend)]
-            Executor::Native => ExecutorRef::Native,
-        }
-    }
-
-    #[cfg(feature = "async")]
-    pub(crate) fn swap_executor(&mut self, executor: &mut Executor) {
-        mem::swap(&mut self.executor, executor);
-    }
-
-    pub(crate) fn unwinder(&self) -> &'static dyn Unwind {
-        match &self.executor {
-            Executor::Interpreter(i) => i.unwinder(),
-            #[cfg(has_host_compiler_backend)]
-            Executor::Native => &vm::UnwindHost,
-        }
-    }
-
-    /// Allocates a new continuation. Note that we currently don't support
-    /// deallocating them. Instead, all continuations remain allocated
-    /// throughout the store's lifetime.
-    #[cfg(feature = "stack-switching")]
-    pub fn allocate_continuation(&mut self) -> Result<*mut VMContRef> {
-        // FIXME(frank-emrich) Do we need to pin this?
-        let mut continuation = Box::new(VMContRef::empty());
-        let stack_size = self.engine.config().async_stack_size;
-        let stack = crate::vm::VMContinuationStack::new(stack_size)?;
-        continuation.stack = stack;
-        let ptr = continuation.deref_mut() as *mut VMContRef;
-        self.continuations.push(continuation);
-        Ok(ptr)
-    }
-
-    /// Constructs and executes an `InstanceAllocationRequest` and pushes the
-    /// returned instance into the store.
-    ///
-    /// This is a helper method for invoking
-    /// `InstanceAllocator::allocate_module` with the appropriate parameters
-    /// from this store's own configuration. The `kind` provided is used to
-    /// distinguish between "real" modules and dummy ones that are synthesized
-    /// for embedder-created memories, globals, tables, etc. The `kind` will
-    /// also use a different instance allocator by default, the one passed in,
-    /// rather than the engine's default allocator.
-    ///
-    /// This method will push the instance within `StoreOpaque` onto the
-    /// `instances` array and return the `InstanceId` which can be use to look
-    /// it up within the store.
-    ///
-    /// # Safety
-    ///
-    /// The `imports` provided must be correctly sized/typed for the module
-    /// being allocated.
-    pub(crate) async unsafe fn allocate_instance(
-        &mut self,
-        limiter: Option<&mut StoreResourceLimiter<'_>>,
-        kind: AllocateInstanceKind<'_>,
-        runtime_info: &ModuleRuntimeInfo,
-        imports: Imports<'_>,
-    ) -> Result<InstanceId> {
-        let id = self.instances.next_key();
-
-        let allocator = match kind {
-            AllocateInstanceKind::Module(_) => self.engine().allocator(),
-            AllocateInstanceKind::Dummy { allocator } => allocator,
-        };
-        // SAFETY: this function's own contract is the same as
-        // `allocate_module`, namely the imports provided are valid.
-        let handle = unsafe {
-            allocator
-                .allocate_module(InstanceAllocationRequest {
-                    id,
-                    runtime_info,
-                    imports,
-                    store: self,
-                    limiter,
-                })
-                .await?
-        };
-
-        let actual = match kind {
-            AllocateInstanceKind::Module(module_id) => {
-                log::trace!(
-                    "Adding instance to store: store={:?}, module={module_id:?}, instance={id:?}",
-                    self.id()
-                );
-                self.instances.push(StoreInstance {
-                    handle,
-                    kind: StoreInstanceKind::Real { module_id },
-                })
-            }
-            AllocateInstanceKind::Dummy { .. } => {
-                log::trace!(
-                    "Adding dummy instance to store: store={:?}, instance={id:?}",
-                    self.id()
-                );
-                self.instances.push(StoreInstance {
-                    handle,
-                    kind: StoreInstanceKind::Dummy,
-                })
-            }
-        };
-
-        // double-check we didn't accidentally allocate two instances and our
-        // prediction of what the id would be is indeed the id it should be.
-        assert_eq!(id, actual);
-
-        Ok(id)
-    }
-
-    /// Set a pending exception. The `exnref` is taken and held on
-    /// this store to be fetched later by an unwind. This method does
-    /// *not* set up an unwind request on the TLS call state; that
-    /// must be done separately.
-    #[cfg(feature = "gc")]
-    pub(crate) fn set_pending_exception(&mut self, exnref: VMExnRef) {
-        self.pending_exception = Some(exnref);
-    }
-
-    /// Take a pending exception, if any.
-    #[cfg(feature = "gc")]
-    pub(crate) fn take_pending_exception(&mut self) -> Option<VMExnRef> {
-        self.pending_exception.take()
-    }
-
-    #[cfg(feature = "gc")]
-    fn take_pending_exception_rooted(&mut self) -> Option<Rooted<ExnRef>> {
-        let vmexnref = self.take_pending_exception()?;
-        let mut nogc = AutoAssertNoGc::new(self);
-        Some(Rooted::new(&mut nogc, vmexnref.into()))
-    }
-
-    #[cfg(feature = "gc")]
-    fn throw_impl(&mut self, exception: Rooted<ExnRef>) {
-        let mut nogc = AutoAssertNoGc::new(self);
-        let exnref = exception._to_raw(&mut nogc).unwrap();
-        let exnref = VMGcRef::from_raw_u32(exnref)
-            .expect("exception cannot be null")
-            .into_exnref_unchecked();
-        nogc.set_pending_exception(exnref);
-    }
-
-    #[cfg(target_has_atomic = "64")]
-    pub(crate) fn set_epoch_deadline(&mut self, delta: u64) {
-        // Set a new deadline based on the "epoch deadline delta".
-        //
-        // Also, note that when this update is performed while Wasm is
-        // on the stack, the Wasm will reload the new value once we
-        // return into it.
-        let current_epoch = self.engine().current_epoch();
-        let epoch_deadline = self.vm_store_context.epoch_deadline.get_mut();
-        *epoch_deadline = current_epoch + delta;
-    }
-
-    pub(crate) fn get_epoch_deadline(&mut self) -> u64 {
-        *self.vm_store_context.epoch_deadline.get_mut()
-    }
-}
-
-/// Helper parameter to [`StoreOpaque::allocate_instance`].
-pub(crate) enum AllocateInstanceKind<'a> {
-    /// An embedder-provided module is being allocated meaning that the default
-    /// engine's allocator will be used.
-    Module(RegisteredModuleId),
-
-    /// Add a dummy instance that to the store.
-    ///
-    /// These are instances that are just implementation details of something
-    /// else (e.g. host-created memories that are not actually defined in any
-    /// Wasm module) and therefore shouldn't show up in things like core dumps.
-    ///
-    /// A custom, typically OnDemand-flavored, allocator is provided to execute
-    /// the allocation.
-    Dummy {
-        allocator: &'a dyn InstanceAllocator,
-    },
-}
-
-unsafe impl<T> VMStore for StoreInner<T> {
-    #[cfg(feature = "component-model-async")]
-    fn component_async_store(
-        &mut self,
-    ) -> &mut dyn crate::runtime::component::VMComponentAsyncStore {
-        self
-    }
-
-    fn store_opaque(&self) -> &StoreOpaque {
-        &self.inner
-    }
-
-    fn store_opaque_mut(&mut self) -> &mut StoreOpaque {
-        &mut self.inner
-    }
-
-    fn resource_limiter_and_store_opaque(
-        &mut self,
-    ) -> (Option<StoreResourceLimiter<'_>>, &mut StoreOpaque) {
-        (
-            self.limiter.as_mut().map(|l| match l {
-                ResourceLimiterInner::Sync(s) => StoreResourceLimiter::Sync(s(&mut self.data)),
-                #[cfg(feature = "async")]
-                ResourceLimiterInner::Async(s) => StoreResourceLimiter::Async(s(&mut self.data)),
-            }),
-            &mut self.inner,
-        )
-    }
-
-    #[cfg(target_has_atomic = "64")]
-    fn new_epoch_updated_deadline(&mut self) -> Result<UpdateDeadline> {
-        // Temporarily take the configured behavior to avoid mutably borrowing
-        // multiple times.
-        let mut behavior = self.epoch_deadline_behavior.take();
-        let update = match &mut behavior {
-            Some(callback) => callback((&mut *self).as_context_mut()),
-            None => Ok(UpdateDeadline::Interrupt),
-        };
-
-        // Put back the original behavior which was replaced by `take`.
-        self.epoch_deadline_behavior = behavior;
-        update
-    }
-
-    #[cfg(feature = "component-model")]
-    fn component_calls(&mut self) -> &mut vm::component::CallContexts {
-        &mut self.component_calls
-    }
-}
-
-impl<T> StoreInner<T> {
-    #[cfg(target_has_atomic = "64")]
-    fn epoch_deadline_trap(&mut self) {
-        self.epoch_deadline_behavior = None;
-    }
-
-    #[cfg(target_has_atomic = "64")]
-    fn epoch_deadline_callback(
-        &mut self,
-        callback: Box<dyn FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync>,
-    ) {
-        self.epoch_deadline_behavior = Some(callback);
-    }
-}
-
-impl<T: Default> Default for Store<T> {
-    fn default() -> Store<T> {
-        Store::new(&Engine::default(), T::default())
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for Store<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let inner = &**self.inner as *const StoreInner<T>;
-        f.debug_struct("Store")
-            .field("inner", &inner)
-            .field("data", &self.inner.data)
-            .finish()
-    }
-}
-
-impl<T> Drop for Store<T> {
-    fn drop(&mut self) {
-        self.run_manual_drop_routines();
-
-        // for documentation on this `unsafe`, see `into_data`.
-        unsafe {
-            ManuallyDrop::drop(&mut self.inner.data);
-            ManuallyDrop::drop(&mut self.inner);
-        }
-    }
-}
-
-impl Drop for StoreOpaque {
-    fn drop(&mut self) {
-        // NB it's important that this destructor does not access `self.data`.
-        // That is deallocated by `Drop for Store<T>` above.
-
-        unsafe {
-            let allocator = self.engine.allocator();
-            let ondemand = OnDemandInstanceAllocator::default();
-            let store_id = self.id();
-
-            #[cfg(feature = "gc")]
-            if let Some(gc_store) = self.gc_store.take() {
-                let gc_alloc_index = gc_store.allocation_index;
-                log::trace!("store {store_id:?} is deallocating GC heap {gc_alloc_index:?}");
-                debug_assert!(self.engine.features().gc_types());
-                let (mem_alloc_index, mem) =
-                    allocator.deallocate_gc_heap(gc_alloc_index, gc_store.gc_heap);
-                allocator.deallocate_memory(None, mem_alloc_index, mem);
-            }
-
-            for (id, instance) in self.instances.iter_mut() {
-                log::trace!("store {store_id:?} is deallocating {id:?}");
-                let allocator = match instance.kind {
-                    StoreInstanceKind::Dummy => &ondemand,
-                    _ => allocator,
-                };
-                allocator.deallocate_module(&mut instance.handle);
-            }
-
-            #[cfg(feature = "component-model")]
-            {
-                for _ in 0..self.num_component_instances {
-                    allocator.decrement_component_instance_count();
-                }
-            }
-        }
-    }
-}
-
-#[cfg_attr(
-    not(any(feature = "gc", feature = "async")),
-    // NB: Rust 1.89, current stable, does not fire this lint. Rust 1.90,
-    // however, does, so use #[allow] until our MSRV is 1.90.
-    allow(dead_code, reason = "don't want to put #[cfg] on all impls below too")
-)]
-pub(crate) trait AsStoreOpaque {
-    fn as_store_opaque(&mut self) -> &mut StoreOpaque;
-}
-
-impl AsStoreOpaque for StoreOpaque {
-    fn as_store_opaque(&mut self) -> &mut StoreOpaque {
-        self
-    }
-}
-
-impl AsStoreOpaque for dyn VMStore {
-    fn as_store_opaque(&mut self) -> &mut StoreOpaque {
-        self
-    }
-}
-
-impl<T: 'static> AsStoreOpaque for StoreInner<T> {
-    fn as_store_opaque(&mut self) -> &mut StoreOpaque {
-        self
-    }
-}
-
-impl<T: AsStoreOpaque + ?Sized> AsStoreOpaque for &mut T {
-    fn as_store_opaque(&mut self) -> &mut StoreOpaque {
-        T::as_store_opaque(self)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{get_fuel, refuel, set_fuel};
-    use std::num::NonZeroU64;
-
-    struct FuelTank {
-        pub consumed_fuel: i64,
-        pub reserve_fuel: u64,
-        pub yield_interval: Option<NonZeroU64>,
-    }
-
-    impl FuelTank {
-        fn new() -> Self {
-            FuelTank {
-                consumed_fuel: 0,
-                reserve_fuel: 0,
-                yield_interval: None,
-            }
-        }
-        fn get_fuel(&self) -> u64 {
-            get_fuel(self.consumed_fuel, self.reserve_fuel)
-        }
-        fn refuel(&mut self) -> bool {
-            refuel(
-                &mut self.consumed_fuel,
-                &mut self.reserve_fuel,
-                self.yield_interval,
-            )
-        }
-        fn set_fuel(&mut self, fuel: u64) {
-            set_fuel(
-                &mut self.consumed_fuel,
-                &mut self.reserve_fuel,
-                self.yield_interval,
-                fuel,
-            );
-        }
-    }
-
-    #[test]
-    fn smoke() {
-        let mut tank = FuelTank::new();
-        tank.set_fuel(10);
-        assert_eq!(tank.consumed_fuel, -10);
-        assert_eq!(tank.reserve_fuel, 0);
-
-        tank.yield_interval = NonZeroU64::new(10);
-        tank.set_fuel(25);
-        assert_eq!(tank.consumed_fuel, -10);
-        assert_eq!(tank.reserve_fuel, 15);
-    }
-
-    #[test]
-    fn does_not_lose_precision() {
-        let mut tank = FuelTank::new();
-        tank.set_fuel(u64::MAX);
-        assert_eq!(tank.get_fuel(), u64::MAX);
-
-        tank.set_fuel(i64::MAX as u64);
-        assert_eq!(tank.get_fuel(), i64::MAX as u64);
-
-        tank.set_fuel(i64::MAX as u64 + 1);
-        assert_eq!(tank.get_fuel(), i64::MAX as u64 + 1);
-    }
-
-    #[test]
-    fn yielding_does_not_lose_precision() {
-        let mut tank = FuelTank::new();
-
-        tank.yield_interval = NonZeroU64::new(10);
-        tank.set_fuel(u64::MAX);
-        assert_eq!(tank.get_fuel(), u64::MAX);
-        assert_eq!(tank.consumed_fuel, -10);
-        assert_eq!(tank.reserve_fuel, u64::MAX - 10);
-
-        tank.yield_interval = NonZeroU64::new(u64::MAX);
-        tank.set_fuel(u64::MAX);
-        assert_eq!(tank.get_fuel(), u64::MAX);
-        assert_eq!(tank.consumed_fuel, -i64::MAX);
-        assert_eq!(tank.reserve_fuel, u64::MAX - (i64::MAX as u64));
-
-        tank.yield_interval = NonZeroU64::new((i64::MAX as u64) + 1);
-        tank.set_fuel(u64::MAX);
-        assert_eq!(tank.get_fuel(), u64::MAX);
-        assert_eq!(tank.consumed_fuel, -i64::MAX);
-        assert_eq!(tank.reserve_fuel, u64::MAX - (i64::MAX as u64));
-    }
-
-    #[test]
-    fn refueling() {
-        // It's possible to fuel to have consumed over the limit as some instructions can consume
-        // multiple units of fuel at once. Refueling should be strict in it's consumption and not
-        // add more fuel than there is.
-        let mut tank = FuelTank::new();
-
-        tank.yield_interval = NonZeroU64::new(10);
-        tank.reserve_fuel = 42;
-        tank.consumed_fuel = 4;
-        assert!(tank.refuel());
-        assert_eq!(tank.reserve_fuel, 28);
-        assert_eq!(tank.consumed_fuel, -10);
-
-        tank.yield_interval = NonZeroU64::new(1);
-        tank.reserve_fuel = 8;
-        tank.consumed_fuel = 4;
-        assert_eq!(tank.get_fuel(), 4);
-        assert!(tank.refuel());
-        assert_eq!(tank.reserve_fuel, 3);
-        assert_eq!(tank.consumed_fuel, -1);
-        assert_eq!(tank.get_fuel(), 4);
-
-        tank.yield_interval = NonZeroU64::new(10);
-        tank.reserve_fuel = 3;
-        tank.consumed_fuel = 4;
-        assert_eq!(tank.get_fuel(), 0);
-        assert!(!tank.refuel());
-        assert_eq!(tank.reserve_fuel, 3);
-        assert_eq!(tank.consumed_fuel, 4);
-        assert_eq!(tank.get_fuel(), 0);
-    }
-}