wasmtime 21.0.1 → 22.0.0

data/ext/cargo-vendor/wasmtime-22.0.0/src/runtime/vm.rs

@@ -0,0 +1,277 @@
+//! Runtime library support for Wasmtime.
+
+#![deny(missing_docs)]
+#![warn(clippy::cast_sign_loss)]
+
+use alloc::sync::Arc;
+use anyhow::{Error, Result};
+use core::fmt;
+use core::ptr::NonNull;
+use core::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+use wasmtime_environ::{
+    DefinedFuncIndex, DefinedMemoryIndex, HostPtr, ModuleInternedTypeIndex, VMOffsets,
+    VMSharedTypeIndex,
+};
+
+mod arch;
+mod async_yield;
+#[cfg(feature = "component-model")]
+pub mod component;
+mod const_expr;
+mod export;
+mod gc;
+mod imports;
+mod instance;
+mod memory;
+mod mmap;
+mod mmap_vec;
+mod send_sync_ptr;
+mod store_box;
+mod sys;
+mod table;
+mod traphandlers;
+mod vmcontext;
+
+mod threads;
+pub use self::threads::*;
+
+#[cfg(feature = "debug-builtins")]
+pub mod debug_builtins;
+pub mod libcalls;
+pub mod mpk;
+
+#[cfg(feature = "debug-builtins")]
+pub use wasmtime_jit_debug::gdb_jit_int::GdbJitImageRegistration;
+
+pub use crate::runtime::vm::arch::{get_stack_pointer, V128Abi};
+pub use crate::runtime::vm::async_yield::*;
+pub use crate::runtime::vm::export::*;
+pub use crate::runtime::vm::gc::*;
+pub use crate::runtime::vm::imports::Imports;
+pub use crate::runtime::vm::instance::{
+    GcHeapAllocationIndex, Instance, InstanceAllocationRequest, InstanceAllocator,
+    InstanceAllocatorImpl, InstanceHandle, MemoryAllocationIndex, OnDemandInstanceAllocator,
+    StorePtr, TableAllocationIndex,
+};
+#[cfg(feature = "pooling-allocator")]
+pub use crate::runtime::vm::instance::{
+    InstanceLimits, PoolConcurrencyLimitError, PoolingInstanceAllocator,
+    PoolingInstanceAllocatorConfig,
+};
+pub use crate::runtime::vm::memory::{Memory, RuntimeLinearMemory, RuntimeMemoryCreator};
+pub use crate::runtime::vm::mmap::Mmap;
+pub use crate::runtime::vm::mmap_vec::MmapVec;
+pub use crate::runtime::vm::mpk::MpkEnabled;
+pub use crate::runtime::vm::store_box::*;
+pub use crate::runtime::vm::sys::unwind::UnwindRegistration;
+pub use crate::runtime::vm::table::{Table, TableElement};
+pub use crate::runtime::vm::traphandlers::*;
+pub use crate::runtime::vm::vmcontext::{
+    VMArrayCallFunction, VMArrayCallHostFuncContext, VMContext, VMFuncRef, VMFunctionBody,
+    VMFunctionImport, VMGlobalDefinition, VMGlobalImport, VMMemoryDefinition, VMMemoryImport,
+    VMOpaqueContext, VMRuntimeLimits, VMTableImport, VMWasmCallFunction, ValRaw,
+};
+pub use send_sync_ptr::SendSyncPtr;
+
+mod module_id;
+pub use module_id::{CompiledModuleId, CompiledModuleIdAllocator};
+
+mod cow;
+pub use crate::runtime::vm::cow::{MemoryImage, MemoryImageSlot, ModuleMemoryImages};
+
+/// Dynamic runtime functionality needed by this crate throughout the execution
+/// of a wasm instance.
+///
+/// This trait is used to store a raw pointer trait object within each
+/// `VMContext`. This raw pointer trait object points back to the
+/// `wasmtime::Store` internally but is type-erased so this `wasmtime-runtime`
+/// crate doesn't need the entire `wasmtime` crate to build.
+///
+/// Note that this is an extra-unsafe trait because no heed is paid to the
+/// lifetime of this store or the Send/Sync-ness of this store. All of that must
+/// be respected by embedders (e.g. the `wasmtime::Store` structure). The theory
+/// is that `wasmtime::Store` handles all this correctly.
+pub unsafe trait Store {
+    /// Returns the raw pointer in memory where this store's shared
+    /// `VMRuntimeLimits` structure is located.
+    ///
+    /// Used to configure `VMContext` initialization and store the right pointer
+    /// in the `VMContext`.
+    fn vmruntime_limits(&self) -> *mut VMRuntimeLimits;
+
+    /// Returns a pointer to the global epoch counter.
+    ///
+    /// Used to configure the `VMContext` on initialization.
+    fn epoch_ptr(&self) -> *const AtomicU64;
+
+    /// Get this store's GC heap.
+    fn gc_store(&mut self) -> &mut GcStore {
+        self.maybe_gc_store()
+            .expect("attempt to access the GC store before it has been allocated")
+    }
+
+    /// Get this store's GC heap, if it has been allocated.
+    fn maybe_gc_store(&mut self) -> Option<&mut GcStore>;
+
+    /// Callback invoked to allow the store's resource limiter to reject a
+    /// memory grow operation.
+    fn memory_growing(
+        &mut self,
+        current: usize,
+        desired: usize,
+        maximum: Option<usize>,
+    ) -> Result<bool, Error>;
+
+    /// Callback invoked to notify the store's resource limiter that a memory
+    /// grow operation has failed.
+    ///
+    /// Note that this is not invoked if `memory_growing` returns an error.
+    fn memory_grow_failed(&mut self, error: Error) -> Result<()>;
+
+    /// Callback invoked to allow the store's resource limiter to reject a
+    /// table grow operation.
+    fn table_growing(
+        &mut self,
+        current: u32,
+        desired: u32,
+        maximum: Option<u32>,
+    ) -> Result<bool, Error>;
+
+    /// Callback invoked to notify the store's resource limiter that a table
+    /// grow operation has failed.
+    ///
+    /// Note that this is not invoked if `table_growing` returns an error.
+    fn table_grow_failed(&mut self, error: Error) -> Result<()>;
+
+    /// Callback invoked whenever fuel runs out by a wasm instance. If an error
+    /// is returned that's raised as a trap. Otherwise wasm execution will
+    /// continue as normal.
+    fn out_of_gas(&mut self) -> Result<(), Error>;
+
+    /// Callback invoked whenever an instance observes a new epoch
+    /// number. Cannot fail; cooperative epoch-based yielding is
+    /// completely semantically transparent. Returns the new deadline.
+    fn new_epoch(&mut self) -> Result<u64, Error>;
+
+    /// Callback invoked whenever an instance needs to trigger a GC.
+    ///
+    /// Optionally given a GC reference that is rooted for the collection, and
+    /// then whose updated GC reference is returned.
+    ///
+    /// Cooperative, async-yielding (if configured) is completely transparent.
+    ///
+    /// If the async GC was cancelled, returns an error. This should be raised
+    /// as a trap to clean up Wasm execution.
+    fn gc(&mut self, root: Option<VMGcRef>) -> Result<Option<VMGcRef>>;
+
+    /// Metadata required for resources for the component model.
+    #[cfg(feature = "component-model")]
+    fn component_calls(&mut self) -> &mut component::CallContexts;
+}
+
+/// Functionality required by this crate for a particular module. This
+/// is chiefly needed for lazy initialization of various bits of
+/// instance state.
+///
+/// When an instance is created, it holds an `Arc<dyn ModuleRuntimeInfo>`
+/// so that it can get to signatures, metadata on functions, memory and
+/// funcref-table images, etc. All of these things are ordinarily known
+/// by the higher-level layers of Wasmtime. Specifically, the main
+/// implementation of this trait is provided by
+/// `wasmtime::module::ModuleInner`.  Since the runtime crate sits at
+/// the bottom of the dependence DAG though, we don't know or care about
+/// that; we just need some implementor of this trait for each
+/// allocation request.
+pub trait ModuleRuntimeInfo: Send + Sync + 'static {
+    /// The underlying Module.
+    fn module(&self) -> &Arc<wasmtime_environ::Module>;
+
+    /// Translate a module-level interned type index into an engine-level
+    /// interned type index.
+    fn engine_type_index(&self, module_index: ModuleInternedTypeIndex) -> VMSharedTypeIndex;
+
+    /// Returns the address, in memory, that the function `index` resides at.
+    fn function(&self, index: DefinedFuncIndex) -> NonNull<VMWasmCallFunction>;
+
+    /// Returns the address, in memory, of the trampoline that allows the given
+    /// defined Wasm function to be called by the array calling convention.
+    ///
+    /// Returns `None` for Wasm functions which do not escape, and therefore are
+    /// not callable from outside the Wasm module itself.
+    fn array_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<VMArrayCallFunction>;
+
+    /// Return the address, in memory, of the trampoline that allows Wasm to
+    /// call a array function of the given signature.
+    fn wasm_to_array_trampoline(
+        &self,
+        signature: VMSharedTypeIndex,
+    ) -> Option<NonNull<VMWasmCallFunction>>;
+
+    /// Returns the `MemoryImage` structure used for copy-on-write
+    /// initialization of the memory, if it's applicable.
+    fn memory_image(&self, memory: DefinedMemoryIndex)
+        -> anyhow::Result<Option<&Arc<MemoryImage>>>;
+
+    /// A unique ID for this particular module. This can be used to
+    /// allow for fastpaths to optimize a "re-instantiate the same
+    /// module again" case.
+    fn unique_id(&self) -> Option<CompiledModuleId>;
+
+    /// A slice pointing to all data that is referenced by this instance.
+    fn wasm_data(&self) -> &[u8];
+
+    /// Returns an array, indexed by `ModuleInternedTypeIndex` of all
+    /// `VMSharedSignatureIndex` entries corresponding to the `SignatureIndex`.
+    fn type_ids(&self) -> &[VMSharedTypeIndex];
+
+    /// Offset information for the current host.
+    fn offsets(&self) -> &VMOffsets<HostPtr>;
+}
+
+/// Returns the host OS page size, in bytes.
+pub fn page_size() -> usize {
+    static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
+
+    return match PAGE_SIZE.load(Ordering::Relaxed) {
+        0 => {
+            let size = sys::vm::get_page_size();
+            assert!(size != 0);
+            PAGE_SIZE.store(size, Ordering::Relaxed);
+            size
+        }
+        n => n,
+    };
+}
+
+/// Result of `Memory::atomic_wait32` and `Memory::atomic_wait64`
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum WaitResult {
+    /// Indicates that a `wait` completed by being awoken by a different thread.
+    /// This means the thread went to sleep and didn't time out.
+    Ok = 0,
+    /// Indicates that `wait` did not complete and instead returned due to the
+    /// value in memory not matching the expected value.
+    Mismatch = 1,
+    /// Indicates that `wait` completed with a timeout, meaning that the
+    /// original value matched as expected but nothing ever called `notify`.
+    TimedOut = 2,
+}
+
+/// Description about a fault that occurred in WebAssembly.
+#[derive(Debug)]
+pub struct WasmFault {
+    /// The size of memory, in bytes, at the time of the fault.
+    pub memory_size: usize,
+    /// The WebAssembly address at which the fault occurred.
+    pub wasm_address: u64,
+}
+
+impl fmt::Display for WasmFault {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "memory fault at wasm address 0x{:x} in linear memory of size 0x{:x}",
+            self.wasm_address, self.memory_size,
+        )
+    }
+}

data/ext/cargo-vendor/wasmtime-22.0.0/src/runtime.rs

@@ -0,0 +1,113 @@
+#[macro_use]
+pub(crate) mod func;
+
+pub(crate) mod code;
+pub(crate) mod code_memory;
+pub(crate) mod debug;
+pub(crate) mod externals;
+pub(crate) mod gc;
+pub(crate) mod instance;
+pub(crate) mod instantiate;
+pub(crate) mod limits;
+pub(crate) mod linker;
+pub(crate) mod memory;
+pub(crate) mod module;
+pub(crate) mod resources;
+pub(crate) mod store;
+pub(crate) mod trampoline;
+pub(crate) mod trap;
+pub(crate) mod type_registry;
+pub(crate) mod types;
+pub(crate) mod uninhabited;
+pub(crate) mod v128;
+pub(crate) mod values;
+pub(crate) mod vm;
+
+#[cfg(feature = "component-model")]
+pub mod component;
+
+cfg_if::cfg_if! {
+    if #[cfg(miri)] {
+        // no extensions on miri
+    } else if #[cfg(unix)] {
+        pub mod unix;
+    } else if #[cfg(windows)] {
+        pub mod windows;
+    } else {
+        // ... unknown os!
+    }
+}
+
+pub use code_memory::CodeMemory;
+pub use externals::*;
+pub use func::*;
+pub use gc::*;
+pub use instance::{Instance, InstancePre};
+pub use instantiate::CompiledModule;
+pub use limits::*;
+pub use linker::*;
+pub use memory::*;
+pub use module::{Module, ModuleExport};
+pub use resources::*;
+#[cfg(feature = "async")]
+pub use store::CallHookHandler;
+pub use store::{
+    AsContext, AsContextMut, CallHook, Store, StoreContext, StoreContextMut, UpdateDeadline,
+};
+pub use trap::*;
+pub use types::*;
+pub use v128::V128;
+pub use values::*;
+
+pub(crate) use uninhabited::*;
+
+#[cfg(feature = "pooling-allocator")]
+pub use vm::PoolConcurrencyLimitError;
+
+#[cfg(feature = "profiling")]
+mod profiling;
+#[cfg(feature = "profiling")]
+pub use profiling::GuestProfiler;
+
+#[cfg(feature = "async")]
+pub(crate) mod stack;
+#[cfg(feature = "async")]
+pub use stack::*;
+
+#[cfg(feature = "coredump")]
+mod coredump;
+#[cfg(feature = "coredump")]
+pub use coredump::*;
+
+fn _assertions_runtime() {
+    use crate::_assert_send_and_sync;
+
+    #[cfg(feature = "async")]
+    fn _assert_send<T: Send>(_t: T) {}
+
+    _assert_send_and_sync::<Caller<'_, ()>>();
+    _assert_send_and_sync::<ExternRef>();
+    _assert_send_and_sync::<(Func, TypedFunc<(), ()>, Global, Table, Memory)>();
+    _assert_send_and_sync::<Instance>();
+    _assert_send_and_sync::<InstancePre<()>>();
+    _assert_send_and_sync::<InstancePre<*mut u8>>();
+    _assert_send_and_sync::<Linker<()>>();
+    _assert_send_and_sync::<Linker<*mut u8>>();
+    _assert_send_and_sync::<Module>();
+    _assert_send_and_sync::<Store<()>>();
+    _assert_send_and_sync::<StoreContext<'_, ()>>();
+    _assert_send_and_sync::<StoreContextMut<'_, ()>>();
+
+    #[cfg(feature = "async")]
+    fn _call_async(s: &mut Store<()>, f: Func) {
+        _assert_send(f.call_async(&mut *s, &[], &mut []))
+    }
+    #[cfg(feature = "async")]
+    fn _typed_call_async(s: &mut Store<()>, f: TypedFunc<(), ()>) {
+        _assert_send(f.call_async(&mut *s, ()))
+    }
+    #[cfg(feature = "async")]
+    fn _instantiate_async(s: &mut Store<()>, m: &Module) {
+        _assert_send(Instance::new_async(s, m, &[]))
+    }
+}

data/ext/cargo-vendor/wasmtime-asm-macros-22.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"d961f99d9e6eba0fa93b5430072ef1a81e856757c5b7cd86dfb310085f6cdf6b","src/lib.rs":"52cfa6e1ce00e0fd54d9c6a3e9e5e6c067953710871db971755db9586e796396"},"package":"d697d99c341d4a9ffb72f3af7a02124d233eeb59aee010f36d88e97cca553d5e"}

data/ext/cargo-vendor/wasmtime-asm-macros-22.0.0/Cargo.toml

@@ -0,0 +1,22 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "wasmtime-asm-macros"
+version = "22.0.0"
+authors = ["The Wasmtime Project Developers"]
+description = "Macros for defining asm functions in Wasmtime"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.cfg-if]
+version = "1.0"

data/ext/cargo-vendor/wasmtime-cache-22.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"d75ce558345b0543ebda4b8284cc00a1e1eef89976e0d242b31b49fee195475c","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"084a263430a3b2291e08a0d3a6df04f8803410f542e1ccadcedc0f8117449929","src/config.rs":"84808c8cd0549042bcc42222cbff424467b5ff259ff6063209877c3cf0b7f4dc","src/config/tests.rs":"32a819e3d9ec8b3926c3636215df4d6df4c2dd9c42851084dcb1c9f35db48bbf","src/lib.rs":"23d2bf2b7ed6663c60d3271ef472b63ecdc5350923b502fd556bc58f7239d990","src/tests.rs":"fe729fc056ea66355be4abd0d955949d6e0c10d260dcba43ff0a13b197d3b208","src/worker.rs":"bfd3ed702b27a2c1618afd991a0cbdfd55e8d9bb30a8ffe1bc6d8154c651f23d","src/worker/tests.rs":"888cc64f923304393c88e60e2c1c8cf559282937f7ad1b9036c65bf6577138be","src/worker/tests/system_time_stub.rs":"4fed428563563d59606a1451cd6de14bcb06d55902bb8c1a1dfae28a481ec262","tests/cache_write_default_config.rs":"e0538177c69da417d3855d96aa60f0da1e4ff8048b926727abe0b8c4d36f3785"},"package":"916610f9ae9a6c22deb25bba2e6247ba9f00b093d30620875203b91328a1adfa"}

data/ext/cargo-vendor/wasmtime-cache-22.0.0/Cargo.toml

@@ -0,0 +1,89 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "wasmtime-cache"
+version = "22.0.0"
+authors = ["The Wasmtime Project Developers"]
+description = "Support for automatic module caching with Wasmtime"
+documentation = "https://docs.rs/wasmtime-cache/"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.anyhow]
+version = "1.0.22"
+features = ["std"]
+default-features = false
+
+[dependencies.base64]
+version = "0.21.0"
+
+[dependencies.directories-next]
+version = "2.0"
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.postcard]
+version = "1.0.8"
+features = ["alloc"]
+default-features = false
+
+[dependencies.serde]
+version = "1.0.188"
+features = ["alloc"]
+default-features = false
+
+[dependencies.serde_derive]
+version = "1.0.188"
+
+[dependencies.sha2]
+version = "0.10.2"
+
+[dependencies.toml]
+version = "0.8.10"
+
+[dependencies.zstd]
+version = "0.13.0"
+default-features = false
+
+[dev-dependencies.filetime]
+version = "0.2.7"
+
+[dev-dependencies.once_cell]
+version = "1.12.0"
+default-features = false
+
+[dev-dependencies.pretty_env_logger]
+version = "0.5.0"
+
+[dev-dependencies.tempfile]
+version = "3"
+
+[target."cfg(not(target_os = \"windows\"))".dependencies.rustix]
+version = "0.38.31"
+features = ["process"]
+
+[target."cfg(target_os = \"windows\")".dependencies.windows-sys]
+version = "0.52.0"
+features = ["Win32_System_Threading"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"