wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/wasmtime-15.0.1/src/stack.rs

@@ -1,73 +0,0 @@
-use std::{ops::Range, sync::Arc};
-
-use anyhow::Error;
-use wasmtime_fiber::{RuntimeFiberStack, RuntimeFiberStackCreator};
-
-/// A stack creator. Can be used to provide a stack creator to wasmtime
-/// which supplies stacks for async support.
-///
-/// # Safety
-///
-/// This trait is unsafe, as memory safety depends on a proper implementation
-/// of memory management. Stacks created by the StackCreator should always be
-/// treated as owned by an wasmtime instance, and any modification of them
-/// outside of wasmtime invoked routines is unsafe and may lead to corruption.
-///
-/// Note that this is a relatively new and experimental feature and it is
-/// recommended to be familiar with wasmtime runtime code to use it.
-pub unsafe trait StackCreator: Send + Sync {
-    /// Create a new `StackMemory` object with the specified size.
-    ///
-    /// The `size` parameter is the expected size of the stack without any guard pages.
-    ///
-    /// Note there should be at least one guard page of protected memory at the bottom
-    /// of the stack to catch potential stack overflow scenarios. Additionally, stacks should be
-    /// page aligned.
-    fn new_stack(&self, size: usize) -> Result<Box<dyn StackMemory>, Error>;
-}
-
-#[derive(Clone)]
-pub(crate) struct StackCreatorProxy(pub Arc<dyn StackCreator>);
-
-unsafe impl RuntimeFiberStackCreator for StackCreatorProxy {
-    fn new_stack(&self, size: usize) -> Result<Box<dyn RuntimeFiberStack>, Error> {
-        let stack = self.0.new_stack(size)?;
-        Ok(Box::new(FiberStackProxy(stack)) as Box<dyn RuntimeFiberStack>)
-    }
-}
-
-/// A stack memory. This trait provides an interface for raw memory buffers
-/// which are used by wasmtime inside of stacks which wasmtime executes
-/// WebAssembly in for async support. By implementing this trait together
-/// with StackCreator, one can supply wasmtime with custom allocated host
-/// managed stacks.
-///
-/// # Safety
-///
-/// The memory should be page aligned and a multiple of page size.
-/// To prevent possible silent overflows, the memory should be protected by a
-/// guard page. Additionally the safety concerns explained in ['Memory'], for
-/// accessing the memory apply here as well.
-///
-/// Note that this is a relatively new and experimental feature and it is
-/// recommended to be familiar with wasmtime runtime code to use it.
-pub unsafe trait StackMemory: Send + Sync {
-    /// The top of the allocated stack.
-    ///
-    /// This address should be page aligned.
-    fn top(&self) -> *mut u8;
-    /// The range of where this stack resides in memory, excluding guard pages.
-    fn range(&self) -> Range<usize>;
-}
-
-pub(crate) struct FiberStackProxy(pub Box<dyn StackMemory>);
-
-unsafe impl RuntimeFiberStack for FiberStackProxy {
-    fn top(&self) -> *mut u8 {
-        self.0.top()
-    }
-
-    fn range(&self) -> Range<usize> {
-        self.0.range()
-    }
-}

data/ext/cargo-vendor/wasmtime-15.0.1/src/v128.rs

@@ -1,151 +0,0 @@
-#![cfg_attr(
-    not(any(target_arch = "x86_64", target_arch = "aarch64")),
-    allow(unused_imports)
-)]
-
-use crate::store::StoreOpaque;
-use crate::{ValRaw, ValType, WasmTy};
-use std::cmp::Ordering;
-use std::fmt;
-
-/// Representation of a 128-bit vector type, `v128`, for WebAssembly.
-///
-/// This type corresponds to the `v128` type in WebAssembly and can be used with
-/// the [`TypedFunc`] API for example. This is additionally
-/// the payload of [`Val::V128`](crate::Val).
-///
-/// # Platform specifics
-///
-/// This type can currently only be used on x86_64 and AArch64 with the
-/// [`TypedFunc`] API. Rust does not have stable support on other platforms for
-/// this type so invoking functions with `v128` parameters requires the
-/// [`Func::call`](crate::Func::call) API (or perhaps
-/// [`Func::call_unchecked`](crate::Func::call_unchecked).
-///
-/// [`TypedFunc`]: crate::TypedFunc
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct V128(Abi);
-
-// NB: this is why this type is only suitable with `TypedFunc` on some platforms
-// and no other. See the documentation for each platform for why each ABI is
-// chosen.
-cfg_if::cfg_if! {
-    if #[cfg(target_arch = "x86_64")] {
-        // x86 vectors are represented with XMM registers which are represented
-        // with the `__m128i` type. This type is considered a vector type for
-        // ABI purposes which is implemented by Cranelift.
-        type Abi = std::arch::x86_64::__m128i;
-    } else if #[cfg(target_arch = "aarch64")] {
-        // AArch64 uses vector registered which here is used with a vector type.
-        // Note that the specific type shouldn't matter too much but the choice
-        // of using a vector is the significant part.
-        type Abi = std::arch::aarch64::uint8x16_t;
-    } else if #[cfg(target_arch = "riscv64")] {
-        // RISC-V currently always passes all vector arguments indirectly in the
-        // ABI. Currently Rust has no stable means of representing this meaning
-        // that a 128-bit representation is chosen here but it can't be passed
-        // directly to WebAssembly, for example, and must instead be passed
-        // through an array-call trampoline.
-        type Abi = u128;
-    } else if #[cfg(target_arch = "s390x")] {
-        // Currently Rust has no stable means of representing vector registers
-        // so like RISC-V at this time this uses a bland 128-bit representation.
-        type Abi = u128;
-    } else {
-        compile_error!("unsupported platform");
-    }
-}
-
-union Reinterpret {
-    abi: Abi,
-    u128: u128,
-}
-
-impl V128 {
-    /// Returns the representation of this `v128` as a 128-bit integer in Rust.
-    pub fn as_u128(&self) -> u128 {
-        unsafe { Reinterpret { abi: self.0 }.u128 }
-    }
-}
-
-/// Primary constructor of a `V128` type.
-impl From<u128> for V128 {
-    fn from(val: u128) -> V128 {
-        unsafe { V128(Reinterpret { u128: val }.abi) }
-    }
-}
-
-impl From<V128> for u128 {
-    fn from(val: V128) -> u128 {
-        val.as_u128()
-    }
-}
-
-impl fmt::Debug for V128 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_u128().fmt(f)
-    }
-}
-
-impl PartialEq for V128 {
-    fn eq(&self, other: &V128) -> bool {
-        self.as_u128() == other.as_u128()
-    }
-}
-
-impl Eq for V128 {}
-
-impl PartialOrd for V128 {
-    fn partial_cmp(&self, other: &V128) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for V128 {
-    fn cmp(&self, other: &V128) -> Ordering {
-        self.as_u128().cmp(&other.as_u128())
-    }
-}
-
-// Note that this trait is conditionally implemented which is intentional. See
-// the documentation above in the `cfg_if!` for why this is conditional.
-#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
-unsafe impl WasmTy for V128 {
-    type Abi = Abi;
-
-    #[inline]
-    fn valtype() -> ValType {
-        ValType::V128
-    }
-
-    #[inline]
-    fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
-        true
-    }
-
-    #[inline]
-    fn is_externref(&self) -> bool {
-        false
-    }
-
-    #[inline]
-    unsafe fn abi_from_raw(raw: *mut ValRaw) -> Self::Abi {
-        V128::from((*raw).get_v128()).0
-    }
-
-    #[inline]
-    unsafe fn abi_into_raw(abi: Self::Abi, raw: *mut ValRaw) {
-        *raw = ValRaw::v128(V128(abi).as_u128());
-    }
-
-    #[inline]
-    fn into_abi(self, _store: &mut StoreOpaque) -> Self::Abi {
-        self.0
-    }
-
-    #[inline]
-    unsafe fn from_abi(abi: Self::Abi, _store: &mut StoreOpaque) -> Self {
-        V128(abi)
-    }
-}

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

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"5b7a22306b469e878f43ede09f71729489ffb1a2e9ff6758bb38194fc4c7b0f1","src/lib.rs":"1cb36602e92d2984e218fd6c6455308018afd155754fb3801a12c06613a757ce"},"package":"beada8bb15df52503de0a4c58de4357bfd2f96d9a44a6e547bad11efdd988b47"}

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

@@ -1,22 +0,0 @@
-# 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 = "15.0.1"
-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-15.0.1/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"0fd287b13ad26d0f8baade137365e505e95a0e57b9ac973b155d3dc86dfca1ba","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"084a263430a3b2291e08a0d3a6df04f8803410f542e1ccadcedc0f8117449929","src/config.rs":"17d84541dfc27bdc7ac9c1d1b3abc5dd32f7ebe16fa401983e7095a293dd422c","src/config/tests.rs":"68489ca054ee6dbe272c5c03d4d743292658cc1fe5f5a537af7c314d982238e6","src/lib.rs":"b7c08b9d82a335d23d2f51cc92ecfef3a472c491c8e7bcc4d40c66acd4f3b663","src/tests.rs":"f2e96fca0bf4007514b406c1a9c43aef3157506076348c2ca8150dfa23ad6717","src/worker.rs":"5a1f6e149b3529d6b1d109755fdb9cff03421934bb90b78bfbe10dc1d68e2b89","src/worker/tests.rs":"e8dd49eb98a685ce8301b6e4abde022cb6951197091b5b0879ecdb025abecc91","src/worker/tests/system_time_stub.rs":"4fed428563563d59606a1451cd6de14bcb06d55902bb8c1a1dfae28a481ec262","tests/cache_write_default_config.rs":"e0538177c69da417d3855d96aa60f0da1e4ff8048b926727abe0b8c4d36f3785"},"package":"aba5bf44d044d25892c03fb3534373936ee204141ff92bac8297787ac7f22318"}

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

@@ -1,72 +0,0 @@
-# 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 = "15.0.1"
-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"
-
-[dependencies.base64]
-version = "0.21.0"
-
-[dependencies.bincode]
-version = "1.1.4"
-
-[dependencies.directories-next]
-version = "2.0"
-
-[dependencies.log]
-version = "0.4.8"
-default-features = false
-
-[dependencies.serde]
-version = "1.0.188"
-
-[dependencies.serde_derive]
-version = "1.0.188"
-
-[dependencies.sha2]
-version = "0.10.2"
-
-[dependencies.toml]
-version = "0.5.5"
-
-[dependencies.zstd]
-version = "0.11.1"
-default-features = false
-
-[dev-dependencies.filetime]
-version = "0.2.7"
-
-[dev-dependencies.once_cell]
-version = "1.12.0"
-
-[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.21"
-features = ["process"]
-
-[target."cfg(target_os = \"windows\")".dependencies.windows-sys]
-version = "0.48.0"
-features = ["Win32_System_Threading"]

data/ext/cargo-vendor/wasmtime-cache-15.0.1/src/lib.rs

@@ -1,238 +0,0 @@
-use base64::Engine;
-use log::{debug, trace, warn};
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-use std::fs;
-use std::hash::Hash;
-use std::hash::Hasher;
-use std::io::Write;
-use std::path::{Path, PathBuf};
-
-#[macro_use] // for tests
-mod config;
-mod worker;
-
-pub use config::{create_new_config, CacheConfig};
-use worker::Worker;
-
-/// Module level cache entry.
-pub struct ModuleCacheEntry<'config>(Option<ModuleCacheEntryInner<'config>>);
-
-struct ModuleCacheEntryInner<'config> {
-    root_path: PathBuf,
-    cache_config: &'config CacheConfig,
-}
-
-struct Sha256Hasher(Sha256);
-
-impl<'config> ModuleCacheEntry<'config> {
-    /// Create the cache entry.
-    pub fn new<'data>(compiler_name: &str, cache_config: &'config CacheConfig) -> Self {
-        if cache_config.enabled() {
-            Self(Some(ModuleCacheEntryInner::new(
-                compiler_name,
-                cache_config,
-            )))
-        } else {
-            Self(None)
-        }
-    }
-
-    #[cfg(test)]
-    fn from_inner(inner: ModuleCacheEntryInner<'config>) -> Self {
-        Self(Some(inner))
-    }
-
-    /// Gets cached data if state matches, otherwise calls `compute`.
-    ///
-    /// Data is automatically serialized/deserialized with `bincode`.
-    pub fn get_data<T, U, E>(&self, state: T, compute: fn(&T) -> Result<U, E>) -> Result<U, E>
-    where
-        T: Hash,
-        U: Serialize + for<'a> Deserialize<'a>,
-    {
-        self.get_data_raw(
-            &state,
-            compute,
-            |_state, data| bincode::serialize(data).ok(),
-            |_state, data| bincode::deserialize(&data).ok(),
-        )
-    }
-
-    /// Gets cached data if state matches, otherwise calls `compute`.
-    ///
-    /// If the cache is disabled or no cached data is found then `compute` is
-    /// called to calculate the data. If the data was found in cache it is
-    /// passed to `deserialize`, which if successful will be the returned value.
-    /// When computed the `serialize` function is used to generate the bytes
-    /// from the returned value.
-    pub fn get_data_raw<T, U, E>(
-        &self,
-        state: &T,
-        // NOTE: These are function pointers instead of closures so that they
-        // don't accidentally close over something not accounted in the cache.
-        compute: fn(&T) -> Result<U, E>,
-        serialize: fn(&T, &U) -> Option<Vec<u8>>,
-        deserialize: fn(&T, Vec<u8>) -> Option<U>,
-    ) -> Result<U, E>
-    where
-        T: Hash,
-    {
-        let inner = match &self.0 {
-            Some(inner) => inner,
-            None => return compute(state),
-        };
-
-        let mut hasher = Sha256Hasher(Sha256::new());
-        state.hash(&mut hasher);
-        let hash: [u8; 32] = hasher.0.finalize().into();
-        // standard encoding uses '/' which can't be used for filename
-        let hash = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(&hash);
-
-        if let Some(cached_val) = inner.get_data(&hash) {
-            if let Some(val) = deserialize(state, cached_val) {
-                let mod_cache_path = inner.root_path.join(&hash);
-                inner.cache_config.on_cache_get_async(&mod_cache_path); // call on success
-                return Ok(val);
-            }
-        }
-        let val_to_cache = compute(state)?;
-        if let Some(bytes) = serialize(state, &val_to_cache) {
-            if inner.update_data(&hash, &bytes).is_some() {
-                let mod_cache_path = inner.root_path.join(&hash);
-                inner.cache_config.on_cache_update_async(&mod_cache_path); // call on success
-            }
-        }
-        Ok(val_to_cache)
-    }
-}
-
-impl<'config> ModuleCacheEntryInner<'config> {
-    fn new<'data>(compiler_name: &str, cache_config: &'config CacheConfig) -> Self {
-        // If debug assertions are enabled then assume that we're some sort of
-        // local build. We don't want local builds to stomp over caches between
-        // builds, so just use a separate cache directory based on the mtime of
-        // our executable, which should roughly correlate with "you changed the
-        // source code so you get a different directory".
-        //
-        // Otherwise if this is a release build we use the `GIT_REV` env var
-        // which is either the git rev if installed from git or the crate
-        // version if installed from crates.io.
-        let compiler_dir = if cfg!(debug_assertions) {
-            fn self_mtime() -> Option<String> {
-                let path = std::env::current_exe().ok()?;
-                let metadata = path.metadata().ok()?;
-                let mtime = metadata.modified().ok()?;
-                Some(match mtime.duration_since(std::time::UNIX_EPOCH) {
-                    Ok(dur) => format!("{}", dur.as_millis()),
-                    Err(err) => format!("m{}", err.duration().as_millis()),
-                })
-            }
-            let self_mtime = self_mtime().unwrap_or("no-mtime".to_string());
-            format!(
-                "{comp_name}-{comp_ver}-{comp_mtime}",
-                comp_name = compiler_name,
-                comp_ver = env!("GIT_REV"),
-                comp_mtime = self_mtime,
-            )
-        } else {
-            format!(
-                "{comp_name}-{comp_ver}",
-                comp_name = compiler_name,
-                comp_ver = env!("GIT_REV"),
-            )
-        };
-        let root_path = cache_config.directory().join("modules").join(compiler_dir);
-
-        Self {
-            root_path,
-            cache_config,
-        }
-    }
-
-    fn get_data(&self, hash: &str) -> Option<Vec<u8>> {
-        let mod_cache_path = self.root_path.join(hash);
-        trace!("get_data() for path: {}", mod_cache_path.display());
-        let compressed_cache_bytes = fs::read(&mod_cache_path).ok()?;
-        let cache_bytes = zstd::decode_all(&compressed_cache_bytes[..])
-            .map_err(|err| warn!("Failed to decompress cached code: {}", err))
-            .ok()?;
-        Some(cache_bytes)
-    }
-
-    fn update_data(&self, hash: &str, serialized_data: &[u8]) -> Option<()> {
-        let mod_cache_path = self.root_path.join(hash);
-        trace!("update_data() for path: {}", mod_cache_path.display());
-        let compressed_data = zstd::encode_all(
-            &serialized_data[..],
-            self.cache_config.baseline_compression_level(),
-        )
-        .map_err(|err| warn!("Failed to compress cached code: {}", err))
-        .ok()?;
-
-        // Optimize syscalls: first, try writing to disk. It should succeed in most cases.
-        // Otherwise, try creating the cache directory and retry writing to the file.
-        if fs_write_atomic(&mod_cache_path, "mod", &compressed_data) {
-            return Some(());
-        }
-
-        debug!(
-            "Attempting to create the cache directory, because \
-             failed to write cached code to disk, path: {}",
-            mod_cache_path.display(),
-        );
-
-        let cache_dir = mod_cache_path.parent().unwrap();
-        fs::create_dir_all(cache_dir)
-            .map_err(|err| {
-                warn!(
-                    "Failed to create cache directory, path: {}, message: {}",
-                    cache_dir.display(),
-                    err
-                )
-            })
-            .ok()?;
-
-        if fs_write_atomic(&mod_cache_path, "mod", &compressed_data) {
-            Some(())
-        } else {
-            None
-        }
-    }
-}
-
-impl Hasher for Sha256Hasher {
-    fn finish(&self) -> u64 {
-        panic!("Sha256Hasher doesn't support finish!");
-    }
-
-    fn write(&mut self, bytes: &[u8]) {
-        self.0.update(bytes);
-    }
-}
-
-// Assumption: path inside cache directory.
-// Then, we don't have to use sound OS-specific exclusive file access.
-// Note: there's no need to remove temporary file here - cleanup task will do it later.
-fn fs_write_atomic(path: &Path, reason: &str, contents: &[u8]) -> bool {
-    let lock_path = path.with_extension(format!("wip-atomic-write-{}", reason));
-    fs::OpenOptions::new()
-        .create_new(true) // atomic file creation (assumption: no one will open it without this flag)
-        .write(true)
-        .open(&lock_path)
-        .and_then(|mut file| file.write_all(contents))
-        // file should go out of scope and be closed at this point
-        .and_then(|()| fs::rename(&lock_path, &path)) // atomic file rename
-        .map_err(|err| {
-            warn!(
-                "Failed to write file with rename, lock path: {}, target path: {}, err: {}",
-                lock_path.display(),
-                path.display(),
-                err
-            )
-        })
-        .is_ok()
-}
-
-#[cfg(test)]
-mod tests;