wasmtime 15.0.1 → 16.0.0

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

@@ -0,0 +1,73 @@
+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 and zero filled.
+    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-16.0.0/src/v128.rs

@@ -0,0 +1,122 @@
+#![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;
+use wasmtime_runtime::V128Abi;
+
+/// 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(V128Abi);
+
+union Reinterpret {
+    abi: V128Abi,
+    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 = V128Abi;
+
+    #[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-16.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"a8c1a97d3cfc3c461e4a3899fcdd4aead96915a09a5f7b065377db2b2cb7a877","src/lib.rs":"1cb36602e92d2984e218fd6c6455308018afd155754fb3801a12c06613a757ce"},"package":"660ba9143e15a2acd921820df221b73aee256bd3ca2d208d73d8adc9587ccbb9"}

data/ext/cargo-vendor/wasmtime-asm-macros-16.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 = "16.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-16.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"b81fadadbfbbd9fbc351ff8c14eef718485f82378c750db8e2a74b4f4750cfde","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"084a263430a3b2291e08a0d3a6df04f8803410f542e1ccadcedc0f8117449929","src/config.rs":"17d84541dfc27bdc7ac9c1d1b3abc5dd32f7ebe16fa401983e7095a293dd422c","src/config/tests.rs":"68489ca054ee6dbe272c5c03d4d743292658cc1fe5f5a537af7c314d982238e6","src/lib.rs":"8797e8cad90bb611497703c693263cece93141b23ce125d7f3331f581984f6eb","src/tests.rs":"f2e96fca0bf4007514b406c1a9c43aef3157506076348c2ca8150dfa23ad6717","src/worker.rs":"c49322c54801848eb88301fbb7a02d5933e2b7fce8cfd5170afacea8eef046cf","src/worker/tests.rs":"e8dd49eb98a685ce8301b6e4abde022cb6951197091b5b0879ecdb025abecc91","src/worker/tests/system_time_stub.rs":"4fed428563563d59606a1451cd6de14bcb06d55902bb8c1a1dfae28a481ec262","tests/cache_write_default_config.rs":"e0538177c69da417d3855d96aa60f0da1e4ff8048b926727abe0b8c4d36f3785"},"package":"a3ce373743892002f9391c6741ef0cb0335b55ec899d874f311222b7e36f4594"}

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

@@ -0,0 +1,81 @@
+# 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 = "16.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"
+
+[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"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

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

@@ -0,0 +1,235 @@
+use base64::Engine;
+use log::{debug, trace, warn};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::{fs, io};
+
+#[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).is_ok() {
+            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()?;
+
+        match fs_write_atomic(&mod_cache_path, "mod", &compressed_data) {
+            Ok(_) => Some(()),
+            Err(err) => {
+                warn!(
+                    "Failed to write file with rename, target path: {}, err: {}",
+                    mod_cache_path.display(),
+                    err
+                );
+                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]) -> io::Result<()> {
+    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
+}
+
+#[cfg(test)]
+mod tests;