wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wasmtime-10.0.1/src/ref.rs

@@ -0,0 +1,109 @@
+#![allow(missing_docs)]
+
+use crate::AsContextMut;
+use std::any::Any;
+use std::ffi::c_void;
+use wasmtime_runtime::VMExternRef;
+
+/// Represents an opaque reference to any data within WebAssembly.
+#[derive(Clone, Debug)]
+#[repr(transparent)]
+pub struct ExternRef {
+    pub(crate) inner: VMExternRef,
+}
+
+impl ExternRef {
+    /// Creates a new instance of `ExternRef` wrapping the given value.
+    pub fn new<T>(value: T) -> ExternRef
+    where
+        T: 'static + Any + Send + Sync,
+    {
+        let inner = VMExternRef::new(value);
+        ExternRef { inner }
+    }
+
+    /// Get the underlying data for this `ExternRef`.
+    pub fn data(&self) -> &dyn Any {
+        &*self.inner
+    }
+
+    /// Get the strong reference count for this `ExternRef`.
+    ///
+    /// Note that this loads the reference count with a `SeqCst` ordering to
+    /// synchronize with other threads.
+    pub fn strong_count(&self) -> usize {
+        self.inner.strong_count()
+    }
+
+    /// Does this `ExternRef` point to the same inner value as `other`?
+    ///
+    /// This is *only* pointer equality, and does *not* run any inner value's
+    /// `Eq` implementation.
+    pub fn ptr_eq(&self, other: &ExternRef) -> bool {
+        VMExternRef::eq(&self.inner, &other.inner)
+    }
+
+    /// Creates a new strongly-owned [`ExternRef`] from the raw value provided.
+    ///
+    /// This is intended to be used in conjunction with [`Func::new_unchecked`],
+    /// [`Func::call_unchecked`], and [`ValRaw`] with its `externref` field.
+    ///
+    /// This function assumes that `raw` is an externref value which is
+    /// currently rooted within the [`Store`].
+    ///
+    /// # Unsafety
+    ///
+    /// This function is particularly `unsafe` because `raw` not only must be a
+    /// valid externref value produced prior by `to_raw` but it must also be
+    /// correctly rooted within the store. When arguments are provided to a
+    /// callback with [`Func::new_unchecked`], for example, or returned via
+    /// [`Func::call_unchecked`], if a GC is performed within the store then
+    /// floating externref values are not rooted and will be GC'd, meaning that
+    /// this function will no longer be safe to call with the values cleaned up.
+    /// This function must be invoked *before* possible GC operations can happen
+    /// (such as calling wasm).
+    ///
+    /// When in doubt try to not use this. Instead use the safe Rust APIs of
+    /// [`TypedFunc`] and friends.
+    ///
+    /// [`Func::call_unchecked`]: crate::Func::call_unchecked
+    /// [`Func::new_unchecked`]: crate::Func::new_unchecked
+    /// [`Store`]: crate::Store
+    /// [`TypedFunc`]: crate::TypedFunc
+    /// [`ValRaw`]: crate::ValRaw
+    pub unsafe fn from_raw(raw: *mut c_void) -> Option<ExternRef> {
+        let raw = raw.cast::<u8>();
+        if raw.is_null() {
+            None
+        } else {
+            Some(ExternRef {
+                inner: VMExternRef::clone_from_raw(raw),
+            })
+        }
+    }
+
+    /// Converts this [`ExternRef`] to a raw value suitable to store within a
+    /// [`ValRaw`].
+    ///
+    /// # Unsafety
+    ///
+    /// Produces a raw value which is only safe to pass into a store if a GC
+    /// doesn't happen between when the value is produce and when it's passed
+    /// into the store.
+    ///
+    /// [`ValRaw`]: crate::ValRaw
+    pub unsafe fn to_raw(&self, mut store: impl AsContextMut) -> *mut c_void {
+        let externref_ptr = self.inner.as_raw();
+        store
+            .as_context_mut()
+            .0
+            .insert_vmexternref_without_gc(self.inner.clone());
+        externref_ptr.cast()
+    }
+}
+
+impl std::fmt::Pointer for ExternRef {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Pointer::fmt(&self.inner, f)
+    }
+}

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

@@ -0,0 +1,243 @@
+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-10.0.1/src/store/func_refs.rs

@@ -0,0 +1,85 @@
+use crate::{instance::PrePatchedFuncRef, 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<[PrePatchedFuncRef]>>,
+}
+
+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<[PrePatchedFuncRef]>) {
+        self.instance_pre_func_refs.push(func_refs);
+    }
+}