wasmtime 20.0.2 → 21.0.1

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

@@ -1,243 +0,0 @@
-use crate::store::{Store, StoreInner};
-
-/// A temporary handle to a [`&Store<T>`][`Store`].
-///
-/// This type is suitable for [`AsContext`] trait bounds on methods if desired.
-/// For more information, see [`Store`].
-// NB the repr(transparent) here is for the C API and it's important that the
-// representation of this `struct` is a pointer for now. If the representation
-// changes then the C API will need to be updated
-#[repr(transparent)]
-pub struct StoreContext<'a, T>(pub(crate) &'a StoreInner<T>);
-
-/// A temporary handle to a [`&mut Store<T>`][`Store`].
-///
-/// This type is suitable for [`AsContextMut`] or [`AsContext`] trait bounds on
-/// methods if desired.  For more information, see [`Store`].
-// NB the repr(transparent) here is for the same reason as above.
-#[repr(transparent)]
-pub struct StoreContextMut<'a, T>(pub(crate) &'a mut StoreInner<T>);
-
-impl<'a, T> StoreContextMut<'a, T> {
-    /// One of the unsafe lynchpins of Wasmtime.
-    ///
-    /// This method is called from one location, `Caller::with`, and is where we
-    /// load the raw unsafe trait object pointer from a `*mut VMContext` and
-    /// then cast it back to a `StoreContextMut`. This is naturally unsafe due
-    /// to the raw pointer usage, but it's also unsafe because `T` here needs to
-    /// line up with the `T` used to define the trait object itself.
-    ///
-    /// This should generally be achieved with various trait bounds throughout
-    /// Wasmtime that might give access to the `Caller<'_, T>` type.
-    /// Unfortunately there's not a ton of debug asserts we can add here, so we
-    /// rely on testing to largely help show that this is correctly used.
-    pub(crate) unsafe fn from_raw(
-        store: *mut dyn wasmtime_runtime::Store,
-    ) -> StoreContextMut<'a, T> {
-        StoreContextMut(&mut *(store as *mut StoreInner<T>))
-    }
-}
-
-/// A trait used to get shared access to a [`Store`] in Wasmtime.
-///
-/// This trait is used as a bound on the first argument of many methods within
-/// Wasmtime. This trait is implemented for types like [`Store`],
-/// [`Caller`](crate::Caller), and [`StoreContext`] itself. Implementors of this
-/// trait provide access to a [`StoreContext`] via some means, allowing the
-/// method in question to get access to the store's internal information.
-///
-/// Note that this is only used in contexts where the store's information is
-/// read, but not written. For example methods that return type information will
-/// use this trait as a bound. More commonly, though, mutation is required and
-/// [`AsContextMut`] is needed.
-pub trait AsContext {
-    /// The host information associated with the [`Store`], aka the `T` in
-    /// [`Store<T>`].
-    type Data;
-
-    /// Returns the store context that this type provides access to.
-    fn as_context(&self) -> StoreContext<'_, Self::Data>;
-}
-
-/// A trait used to get exclusive mutable access to a [`Store`] in Wasmtime.
-///
-/// This trait is used as a bound on the first argument of many methods within
-/// Wasmtime. This trait is implemented for types like [`Store`],
-/// [`Caller`](crate::Caller), and [`StoreContextMut`] itself. Implementors of
-/// this trait provide access to a [`StoreContextMut`] via some means, allowing
-/// the method in question to get access to the store's internal information.
-///
-/// This is notably used for methods that may require some mutation of the
-/// [`Store`] itself. For example calling a wasm function can mutate linear
-/// memory or globals. Creation of a [`Func`](crate::Func) will update internal
-/// data structures. This ends up being quite a common bound in Wasmtime, but
-/// typically you can simply pass `&mut store` or `&mut caller` to satisfy it.
-///
-/// # Calling multiple methods that take `&mut impl AsContextMut`
-///
-/// As of Rust 1.53.0, [generic methods that take a generic `&mut T` do not get
-/// "automatic reborrowing"][reborrowing] and therefore you cannot call multiple
-/// generic methods with the same `&mut T` without manually inserting
-/// reborrows. This affects the many `wasmtime` API methods that take `&mut impl
-/// AsContextMut`.
-///
-/// For example, this fails to compile because the context is moved into the
-/// first call:
-///
-/// ```compile_fail
-/// use wasmtime::{AsContextMut, Instance};
-///
-/// fn foo(cx: &mut impl AsContextMut, instance: Instance) {
-///     // `cx` is not reborrowed, but moved into this call.
-///     let my_export = instance.get_export(cx, "my_export");
-///
-///     // Therefore, this use of `cx` is a use-after-move and prohibited by the
-///     // borrow checker.
-///     let other_export = instance.get_export(cx, "other_export");
-/// #   drop((my_export, other_export));
-/// }
-/// ```
-///
-/// To fix this, manually insert reborrows like `&mut *cx` that would otherwise
-/// normally be inserted automatically by the Rust compiler for non-generic
-/// methods:
-///
-/// ```
-/// use wasmtime::{AsContextMut, Instance};
-///
-/// fn foo(cx: &mut impl AsContextMut, instance: Instance) {
-///     let my_export = instance.get_export(&mut *cx, "my_export");
-///
-///     // This works now, since `cx` was reborrowed above, rather than moved!
-///     let other_export = instance.get_export(&mut *cx, "other_export");
-/// #   drop((my_export, other_export));
-/// }
-/// ```
-///
-/// [reborrowing]: https://github.com/rust-lang/rust/issues/85161
-pub trait AsContextMut: AsContext {
-    /// Returns the store context that this type provides access to.
-    fn as_context_mut(&mut self) -> StoreContextMut<'_, Self::Data>;
-}
-
-impl<T> AsContext for Store<T> {
-    type Data = T;
-
-    #[inline]
-    fn as_context(&self) -> StoreContext<'_, T> {
-        StoreContext(&self.inner)
-    }
-}
-
-impl<T> AsContextMut for Store<T> {
-    #[inline]
-    fn as_context_mut(&mut self) -> StoreContextMut<'_, T> {
-        StoreContextMut(&mut self.inner)
-    }
-}
-
-impl<T> AsContext for StoreContext<'_, T> {
-    type Data = T;
-
-    #[inline]
-    fn as_context(&self) -> StoreContext<'_, T> {
-        StoreContext(&*self.0)
-    }
-}
-
-impl<T> AsContext for StoreContextMut<'_, T> {
-    type Data = T;
-
-    #[inline]
-    fn as_context(&self) -> StoreContext<'_, T> {
-        StoreContext(&*self.0)
-    }
-}
-
-impl<T> AsContextMut for StoreContextMut<'_, T> {
-    #[inline]
-    fn as_context_mut(&mut self) -> StoreContextMut<'_, T> {
-        StoreContextMut(&mut *self.0)
-    }
-}
-
-impl<'a, T> From<StoreContextMut<'a, T>> for StoreContext<'a, T> {
-    #[inline]
-    fn from(store: StoreContextMut<'a, T>) -> StoreContext<'a, T> {
-        StoreContext(store.0)
-    }
-}
-
-// Implementations for internal consumers, but these aren't public types so
-// they're not publicly accessible for crate consumers.
-impl<T> AsContext for &'_ StoreInner<T> {
-    type Data = T;
-
-    #[inline]
-    fn as_context(&self) -> StoreContext<'_, T> {
-        StoreContext(self)
-    }
-}
-
-impl<T> AsContext for &'_ mut StoreInner<T> {
-    type Data = T;
-
-    #[inline]
-    fn as_context(&self) -> StoreContext<'_, T> {
-        StoreContext(self)
-    }
-}
-
-impl<T> AsContextMut for &'_ mut StoreInner<T> {
-    #[inline]
-    fn as_context_mut(&mut self) -> StoreContextMut<'_, T> {
-        StoreContextMut(&mut **self)
-    }
-}
-
-// forward AsContext for &T
-impl<T: AsContext> AsContext for &'_ T {
-    type Data = T::Data;
-
-    #[inline]
-    fn as_context(&self) -> StoreContext<'_, T::Data> {
-        T::as_context(*self)
-    }
-}
-
-// forward AsContext for &mut T
-impl<T: AsContext> AsContext for &'_ mut T {
-    type Data = T::Data;
-
-    #[inline]
-    fn as_context(&self) -> StoreContext<'_, T::Data> {
-        T::as_context(*self)
-    }
-}
-
-// forward AsContextMut for &mut T
-impl<T: AsContextMut> AsContextMut for &'_ mut T {
-    #[inline]
-    fn as_context_mut(&mut self) -> StoreContextMut<'_, T::Data> {
-        T::as_context_mut(*self)
-    }
-}
-
-//
-impl<'a, T: AsContext> From<&'a T> for StoreContext<'a, T::Data> {
-    fn from(t: &'a T) -> StoreContext<'a, T::Data> {
-        t.as_context()
-    }
-}
-
-impl<'a, T: AsContext> From<&'a mut T> for StoreContext<'a, T::Data> {
-    fn from(t: &'a mut T) -> StoreContext<'a, T::Data> {
-        T::as_context(t)
-    }
-}
-
-impl<'a, T: AsContextMut> From<&'a mut T> for StoreContextMut<'a, T::Data> {
-    fn from(t: &'a mut T) -> StoreContextMut<'a, T::Data> {
-        t.as_context_mut()
-    }
-}

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

@@ -1,289 +0,0 @@
-use crate::store::StoreOpaque;
-use crate::{StoreContext, StoreContextMut};
-use std::fmt;
-use std::marker;
-use std::num::NonZeroU64;
-use std::ops::{Index, IndexMut};
-use std::sync::atomic::{AtomicU64, Ordering::Relaxed};
-
-// This is defined here, in a private submodule, so we can explicitly reexport
-// it only as `pub(crate)`. This avoids a ton of
-// crate-private-type-in-public-interface errors that aren't really too
-// interesting to deal with.
-#[derive(Copy, Clone)]
-pub struct InstanceId(pub(super) usize);
-
-impl InstanceId {
-    pub fn from_index(idx: usize) -> InstanceId {
-        InstanceId(idx)
-    }
-}
-
-pub struct StoreData {
-    id: StoreId,
-    funcs: Vec<crate::func::FuncData>,
-    tables: Vec<wasmtime_runtime::ExportTable>,
-    globals: Vec<wasmtime_runtime::ExportGlobal>,
-    instances: Vec<crate::instance::InstanceData>,
-    memories: Vec<wasmtime_runtime::ExportMemory>,
-    #[cfg(feature = "component-model")]
-    pub(crate) components: crate::component::ComponentStoreData,
-}
-
-pub trait StoredData: Sized {
-    fn list(data: &StoreData) -> &Vec<Self>;
-    fn list_mut(data: &mut StoreData) -> &mut Vec<Self>;
-}
-
-macro_rules! impl_store_data {
-    ($($field:ident => $t:ty,)*) => ($(
-        impl StoredData for $t {
-            #[inline]
-            fn list(data: &StoreData) -> &Vec<Self> { &data.$field }
-            #[inline]
-            fn list_mut(data: &mut StoreData) -> &mut Vec<Self> { &mut data.$field }
-        }
-    )*)
-}
-
-impl_store_data! {
-    funcs => crate::func::FuncData,
-    tables => wasmtime_runtime::ExportTable,
-    globals => wasmtime_runtime::ExportGlobal,
-    instances => crate::instance::InstanceData,
-    memories => wasmtime_runtime::ExportMemory,
-}
-
-impl StoreData {
-    pub fn new() -> StoreData {
-        StoreData {
-            id: StoreId::allocate(),
-            funcs: Vec::new(),
-            tables: Vec::new(),
-            globals: Vec::new(),
-            instances: Vec::new(),
-            memories: Vec::new(),
-            #[cfg(feature = "component-model")]
-            components: Default::default(),
-        }
-    }
-
-    pub fn id(&self) -> StoreId {
-        self.id
-    }
-
-    pub fn insert<T>(&mut self, data: T) -> Stored<T>
-    where
-        T: StoredData,
-    {
-        let list = T::list_mut(self);
-        let index = list.len();
-        list.push(data);
-        Stored::new(self.id, index)
-    }
-
-    pub fn next_id<T>(&self) -> Stored<T>
-    where
-        T: StoredData,
-    {
-        Stored::new(self.id, T::list(self).len())
-    }
-
-    pub fn contains<T>(&self, id: Stored<T>) -> bool
-    where
-        T: StoredData,
-    {
-        if id.store_id != self.id {
-            return false;
-        }
-        // This should be true as an invariant of our API, but double-check with
-        // debug assertions enabled.
-        debug_assert!(id.index() < T::list(self).len());
-        true
-    }
-
-    pub fn iter<T>(&self) -> impl ExactSizeIterator<Item = Stored<T>>
-    where
-        T: StoredData,
-    {
-        let id = self.id;
-        (0..T::list(self).len()).map(move |i| Stored::new(id, i))
-    }
-
-    pub(crate) fn reserve_funcs(&mut self, count: usize) {
-        self.funcs.reserve(count);
-    }
-}
-
-impl<T> Index<Stored<T>> for StoreData
-where
-    T: StoredData,
-{
-    type Output = T;
-
-    #[inline]
-    fn index(&self, index: Stored<T>) -> &Self::Output {
-        index.assert_belongs_to(self.id);
-        // Note that if this is ever a performance bottleneck it should be safe
-        // to use unchecked indexing here because presence of a `Stored<T>` is
-        // proof of an item having been inserted into a store and lists in
-        // stores are never shrunk. After the store check above the actual index
-        // should always be valid.
-        &T::list(self)[index.index()]
-    }
-}
-
-impl<T> IndexMut<Stored<T>> for StoreData
-where
-    T: StoredData,
-{
-    #[inline]
-    fn index_mut(&mut self, index: Stored<T>) -> &mut Self::Output {
-        index.assert_belongs_to(self.id);
-        // Note that this could be unchecked indexing, see the note in `Index`
-        // above.
-        &mut T::list_mut(self)[index.index()]
-    }
-}
-
-// forward StoreContext => StoreData
-impl<I, T> Index<I> for StoreContext<'_, T>
-where
-    StoreData: Index<I>,
-{
-    type Output = <StoreData as Index<I>>::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        self.0.store_data.index(index)
-    }
-}
-
-// forward StoreContextMut => StoreData
-impl<I, T> Index<I> for StoreContextMut<'_, T>
-where
-    StoreData: Index<I>,
-{
-    type Output = <StoreData as Index<I>>::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        self.0.store_data.index(index)
-    }
-}
-
-// forward StoreOpaque => StoreData
-impl<I> Index<I> for StoreOpaque
-where
-    StoreData: Index<I>,
-{
-    type Output = <StoreData as Index<I>>::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        self.store_data().index(index)
-    }
-}
-impl<I> IndexMut<I> for StoreOpaque
-where
-    StoreData: IndexMut<I>,
-{
-    #[inline]
-    fn index_mut(&mut self, index: I) -> &mut Self::Output {
-        self.store_data_mut().index_mut(index)
-    }
-}
-
-/// A unique identifier to get attached to a store.
-///
-/// This identifier is embedded into the `Stored<T>` structure and is used to
-/// identify the original store that items come from. For example a `Memory` is
-/// owned by a `Store` and will embed a `StoreId` internally to say which store
-/// it came from. Comparisons with this value are how panics are generated for
-/// mismatching the item that a store belongs to.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct StoreId(NonZeroU64);
-
-impl StoreId {
-    /// Allocates a new unique identifier for a store that has never before been
-    /// used in this process.
-    fn allocate() -> StoreId {
-        static NEXT_ID: AtomicU64 = AtomicU64::new(0);
-
-        // Only allow 2^63 stores at which point we start panicking to prevent
-        // overflow.
-        //
-        // If a store is created once per microsecond then this will last the
-        // current process for 584,540 years before overflowing.
-        //
-        // Also note the usage of `Relaxed` ordering here which should be ok
-        // since we're only looking for atomicity on this counter and this
-        // otherwise isn't used to synchronize memory stored anywhere else.
-        let id = NEXT_ID.fetch_add(1, Relaxed);
-        if id & (1 << 63) != 0 {
-            NEXT_ID.store(1 << 63, Relaxed);
-            panic!("store id allocator overflow");
-        }
-
-        StoreId(NonZeroU64::new(id + 1).unwrap())
-    }
-
-    #[inline]
-    pub fn assert_belongs_to(&self, store: StoreId) {
-        if *self == store {
-            return;
-        }
-        store_id_mismatch();
-    }
-}
-
-#[repr(C)] // used by reference in the C API
-pub struct Stored<T> {
-    store_id: StoreId,
-    index: usize,
-    _marker: marker::PhantomData<fn() -> T>,
-}
-
-impl<T> Stored<T> {
-    fn new(store_id: StoreId, index: usize) -> Stored<T> {
-        Stored {
-            store_id,
-            index,
-            _marker: marker::PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn assert_belongs_to(&self, store: StoreId) {
-        self.store_id.assert_belongs_to(store)
-    }
-
-    fn index(&self) -> usize {
-        self.index
-    }
-}
-
-#[cold]
-fn store_id_mismatch() {
-    panic!("object used with the wrong store");
-}
-
-impl<T> PartialEq for Stored<T> {
-    fn eq(&self, other: &Stored<T>) -> bool {
-        self.store_id == other.store_id && self.index == other.index
-    }
-}
-
-impl<T> Copy for Stored<T> {}
-
-impl<T> Clone for Stored<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T> fmt::Debug for Stored<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "store={}, index={}", self.store_id.0, self.index())
-    }
-}

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

@@ -1,85 +0,0 @@
-use crate::module::ModuleRegistry;
-use std::{ptr::NonNull, sync::Arc};
-use wasmtime_runtime::{SendSyncPtr, VMFuncRef, VMNativeCallHostFuncContext};
-
-/// An arena of `VMFuncRef`s.
-///
-/// Allows a store to pin and own funcrefs so that it can patch in trampolines
-/// for `VMFuncRef`s that are missing a `wasm_call` trampoline and
-/// need Wasm to supply it.
-#[derive(Default)]
-pub struct FuncRefs {
-    /// A bump allocation arena where we allocate `VMFuncRef`s such
-    /// that they are pinned and owned.
-    bump: SendSyncBump,
-
-    /// Pointers into `self.bump` for entries that need `wasm_call` field filled
-    /// in.
-    with_holes: Vec<SendSyncPtr<VMFuncRef>>,
-
-    /// Pinned `VMFuncRef`s that had their `wasm_call` field
-    /// pre-patched when constructing an `InstancePre`, and which we need to
-    /// keep alive for our owning store's lifetime.
-    instance_pre_func_refs: Vec<Arc<[VMFuncRef]>>,
-}
-
-use send_sync_bump::SendSyncBump;
-mod send_sync_bump {
-    #[derive(Default)]
-    pub struct SendSyncBump(bumpalo::Bump);
-
-    impl SendSyncBump {
-        pub fn alloc<T>(&mut self, val: T) -> &mut T {
-            self.0.alloc(val)
-        }
-    }
-
-    // Safety: We require `&mut self` on the only public method, which means it
-    // is safe to send `&SendSyncBump` references across threads because they
-    // can't actually do anything with it.
-    unsafe impl Sync for SendSyncBump {}
-}
-
-impl FuncRefs {
-    /// Push the given `VMFuncRef` into this arena, returning a
-    /// pinned pointer to it.
-    ///
-    /// # Safety
-    ///
-    /// You may only access the return value on the same thread as this
-    /// `FuncRefs` and only while the store holding this `FuncRefs` exists.
-    pub unsafe fn push(&mut self, func_ref: VMFuncRef) -> NonNull<VMFuncRef> {
-        debug_assert!(func_ref.wasm_call.is_none());
-        // Debug assert that the vmctx is a `VMNativeCallHostFuncContext` as
-        // that is the only kind that can have holes.
-        let _ = unsafe { VMNativeCallHostFuncContext::from_opaque(func_ref.vmctx) };
-
-        let func_ref = self.bump.alloc(func_ref);
-        let unpatched = SendSyncPtr::from(func_ref);
-        let ret = unpatched.as_non_null();
-        self.with_holes.push(unpatched);
-        ret
-    }
-
-    /// Patch any `VMFuncRef::wasm_call`s that need filling in.
-    pub fn fill(&mut self, modules: &ModuleRegistry) {
-        self.with_holes.retain_mut(|f| {
-            unsafe {
-                let func_ref = f.as_mut();
-                debug_assert!(func_ref.wasm_call.is_none());
-
-                // Debug assert that the vmctx is a `VMNativeCallHostFuncContext` as
-                // that is the only kind that can have holes.
-                let _ = VMNativeCallHostFuncContext::from_opaque(func_ref.vmctx);
-
-                func_ref.wasm_call = modules.wasm_to_native_trampoline(func_ref.type_index);
-                func_ref.wasm_call.is_none()
-            }
-        });
-    }
-
-    /// Push pre-patched `VMFuncRef`s from an `InstancePre`.
-    pub fn push_instance_pre_func_refs(&mut self, func_refs: Arc<[VMFuncRef]>) {
-        self.instance_pre_func_refs.push(func_refs);
-    }
-}