wasmtime 37.0.2 → 38.0.4

data/ext/cargo-vendor/wasmtime-38.0.4/Cargo.toml.orig

@@ -0,0 +1,410 @@
+[package]
+name = "wasmtime"
+version.workspace = true
+authors.workspace = true
+description = "High-level API to expose the Wasmtime runtime"
+documentation = "https://docs.rs/wasmtime"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+readme = "README.md"
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+
+[dependencies]
+wasmtime-environ = { workspace = true }
+wasmtime-jit-debug = { workspace = true, optional = true }
+wasmtime-jit-icache-coherence = { workspace = true, optional = true }
+wasmtime-cache = { workspace = true, optional = true }
+wasmtime-fiber = { workspace = true, optional = true }
+wasmtime-cranelift = { workspace = true, optional = true, features = ['pulley'] }
+wasmtime-unwinder = { workspace = true, optional = true }
+wasmtime-winch = { workspace = true, optional = true }
+wasmtime-component-macro = { workspace = true, optional = true }
+wasmtime-component-util = { workspace = true, optional = true }
+wasmtime-slab = { workspace = true, optional = true }
+wasmtime-versioned-export-macros = { workspace = true }
+wasmtime-wmemcheck = { workspace = true, optional = true }
+wasmtime-math = { workspace = true }
+pulley-interpreter = { workspace = true }
+target-lexicon = { workspace = true }
+wasmparser = { workspace = true }
+wasm-encoder = { workspace = true, optional = true }
+wasm-wave = { workspace = true, optional = true }
+anyhow = { workspace = true }
+libc = { workspace = true }
+cfg-if = { workspace = true }
+log = { workspace = true }
+wat = { workspace = true, optional = true }
+serde = { workspace = true }
+serde_derive = { workspace = true }
+serde_json = { workspace = true, optional = true }
+postcard = { workspace = true }
+indexmap = { workspace = true }
+once_cell = { version = "1.12.0", optional = true }
+rayon = { version = "1.0", optional = true }
+object = { workspace = true, features = ['unaligned'] }
+async-trait = { workspace = true, optional = true }
+encoding_rs = { version = "0.8.31", optional = true }
+bumpalo = "3.11.0"
+fxprof-processed-profile = { version = "0.8.1", optional = true }
+gimli = { workspace = true, optional = true }
+addr2line = { workspace = true, optional = true }
+semver = { workspace = true, optional = true }
+smallvec = { workspace = true, optional = true }
+hashbrown = { workspace = true, features = ["default-hasher"] }
+bitflags = { workspace = true }
+futures = { workspace = true, features = ["alloc"], optional = true }
+bytes = { workspace = true, optional = true }
+
+[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
+workspace = true
+optional = true
+features = [
+  "Win32_Foundation",
+  "Win32_System_Kernel",
+  "Win32_System_Memory",
+  "Win32_System_Diagnostics_Debug",
+  "Win32_System_SystemInformation",
+  "Win32_Storage_FileSystem",
+  "Win32_Security",
+]
+
+# Allow-list the platforms that `ittapi` builds on since it's got C code that
+# doesn't compile by default on all platforms just yet. Also note that this is
+# only enabled for `x86_64` targets as well.
+[target.'cfg(all(target_arch = "x86_64", target_os = "linux"))'.dependencies]
+ittapi = { workspace = true, optional = true }
+[target.'cfg(all(target_arch = "x86_64", target_os = "macos"))'.dependencies]
+ittapi = { workspace = true, optional = true }
+[target.'cfg(all(target_arch = "x86_64", target_os = "windows"))'.dependencies]
+ittapi = { workspace = true, optional = true }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+memfd = { workspace = true, optional = true }
+
+[target.'cfg(target_vendor = "apple")'.dependencies]
+mach2 = { workspace = true, optional = true }
+
+[target.'cfg(unix)'.dependencies]
+rustix = { workspace = true, optional = true, features = ["mm", "param"] }
+
+[dev-dependencies]
+env_logger = { workspace = true }
+proptest = { workspace = true }
+rand = { workspace = true }
+tempfile = { workspace = true }
+libtest-mimic = { workspace = true }
+cranelift-native = { workspace = true }
+wasmtime-test-util = { workspace = true }
+tokio = { workspace = true, features = ["macros", "sync", "rt-multi-thread"] }
+
+[build-dependencies]
+cc = { workspace = true, optional = true }
+wasmtime-versioned-export-macros = { workspace = true, optional = true }
+
+[[test]]
+name = "host_segfault"
+harness = false
+
+[[test]]
+name = "engine_across_forks"
+harness = false
+
+[[test]]
+name = "pooling_alloc_near_oom"
+harness = false
+
+# =============================================================================
+#
+# Features for the Wasmtime crate.
+#
+# This section contains the compile-time features of the `wasmtime` crate. These
+# features can be used to add more functionality and APIs exposed from the
+# crate's API. Most of them are enabled by default. Disabling features can be
+# done to cut down on binary size by disabling features that are not required
+# for a particular embedding.
+[features]
+default = [
+  'async',
+  'cache',
+  'gc',
+  'gc-drc',
+  'gc-null',
+  'wat',
+  'profiling',
+  'parallel-compilation',
+  'cranelift',
+  'pooling-allocator',
+  'demangle',
+  'addr2line',
+  'coredump',
+  'debug-builtins',
+  'runtime',
+  'component-model',
+  'threads',
+  'stack-switching',
+  'std',
+]
+
+# An on-by-default feature enabling runtime compilation of WebAssembly modules
+# with the Cranelift compiler. Cranelift is the default compilation backend of
+# Wasmtime. If disabled then WebAssembly modules can only be created from
+# precompiled WebAssembly modules.
+cranelift = ["dep:wasmtime-cranelift", "std", "wasmtime-unwinder/cranelift"]
+
+# Enables support for Winch, the WebAssembly baseline compiler. The Winch compiler
+# strategy in `Config` will be available. It is currently in active development
+# and shouldn't be used in production applications.
+winch = ["dep:wasmtime-winch", "std"]
+
+# Enables support for Pulley, the WebAssembly interpreter. When paired with the
+# `cranelift` feature, the compiler backends for the `pulley32` and `pulley64`
+# targets will be available. When paired with the `runtime` feature, the Pulley
+# interpreter will be built into the runtime and you can interpret WebAssembly
+# modules that have been compiled to Pulley bytecode.
+pulley = [
+  # Note that this is intentionally empty. This feature is dynamically activated
+  # in `build.rs` as well when the host platform does not have Cranelift support
+  # for example. That means that dependencies for pulley need to be already
+  # activated anyway.
+]
+
+# Enables support for incremental compilation cache to be enabled in `Config`.
+incremental-cache = ["wasmtime-cranelift?/incremental-cache", "std"]
+
+# Enables support for profiling guest modules.
+profiling = [
+  "dep:fxprof-processed-profile",
+  "dep:ittapi",
+  "dep:rustix",
+  "rustix/thread",
+  "dep:serde_json",
+  "std",
+  "wasmtime-jit-debug/perf_jitdump",
+]
+
+# Enables parallel compilation of WebAssembly code.
+parallel-compilation = ["dep:rayon", "std"]
+
+# Enables support for automatic cache configuration to be enabled in `Config`.
+cache = ["dep:wasmtime-cache", "std"]
+
+# Enables support for "async stores" as well as defining host functions as
+# `async fn` and calling functions asynchronously.
+async = [
+  "dep:wasmtime-fiber",
+  "wasmtime-component-macro?/async",
+  "runtime",
+]
+
+# Enables support for the pooling instance allocation strategy
+pooling-allocator = [
+  "runtime",
+  "std",                 # not ported to no_std yet
+]
+
+# Enables support for all architectures in Cranelift, allowing
+# cross-compilation using the `wasmtime` crate's API, notably the
+# `Engine::precompile_module` function.
+all-arch = ["wasmtime-cranelift?/all-arch", "wasmtime-winch?/all-arch", "pulley"]
+
+# Enables in-progress support for the component model. Note that this feature is
+# in-progress, buggy, and incomplete. This is primarily here for internal
+# testing purposes.
+component-model = [
+  "wasmtime-environ/component-model",
+  "wasmtime-cranelift?/component-model",
+  "wasmtime-winch?/component-model",
+  "dep:wasmtime-component-macro",
+  "dep:wasmtime-component-util",
+  "dep:encoding_rs",
+  "dep:semver",
+]
+
+wmemcheck = [
+  "dep:wasmtime-wmemcheck",
+  "wasmtime-cranelift?/wmemcheck",
+  "wasmtime-winch?/wmemcheck",
+  "wasmtime-environ/wmemcheck",
+  "std",
+]
+
+# Enables detailed internal compiler logging via WASMTIME_LOG
+trace-log = ["wasmtime-cranelift?/trace-log"]
+
+# Enables support for demangling WebAssembly function names at runtime in
+# errors such as backtraces.
+demangle = ["wasmtime-environ/demangle", "std"]
+
+# Enable support for generating core dumps on traps.
+coredump = ["dep:wasm-encoder", "runtime", "std"]
+
+# Export some symbols from the final binary to assist in debugging
+# Cranelift-generated code with native debuggers like GDB and LLDB.
+debug-builtins = [
+  "wasmtime-jit-debug/gdb_jit_int",
+]
+
+# Enable support for executing compiled Wasm modules.
+runtime = [
+  "dep:cc",
+  "dep:smallvec",
+  "dep:mach2",
+  "dep:memfd",
+  "dep:wasmtime-slab",
+  "dep:wasmtime-versioned-export-macros",
+  "dep:windows-sys",
+  "pulley-interpreter/interp",
+  "dep:wasmtime-unwinder",
+  "dep:async-trait",
+]
+
+# Enable support for garbage collection-related things.
+#
+# This Cargo feature is required to compile or run Wasm that uses any of the
+# following Wasm proposals:
+#
+# * Reference types: https://github.com/WebAssembly/reference-types/
+# * Typed function references: https://github.com/WebAssembly/function-references/
+# * Garbage collection: https://github.com/WebAssembly/gc
+#
+# When a compiler Cargo feature (`cranelift` or `winch`) is enabled, this
+# feature gates the ability to compile Wasm that uses those proposals.
+#
+# When the `runtime` Cargo feature is enabled, this feature gates the ability to
+# load and run Wasm that uses those proposals.
+#
+# You can additionally configure which GC implementations are enabled via the
+# `gc-drc` and `gc-null` features.
+gc = [
+  "wasmtime-environ/gc",
+  "wasmtime-cranelift?/gc",
+  "wasmtime-winch?/gc",
+]
+
+# Enable the deferred reference counting garbage collector.
+gc-drc = [
+  "gc",
+  "wasmtime-environ/gc-drc",
+  "wasmtime-cranelift?/gc-drc",
+  "wasmtime-winch?/gc-drc",
+]
+
+# Enable the null garbage collector.
+gc-null = [
+  "gc",
+  "wasmtime-environ/gc-null",
+  "wasmtime-cranelift?/gc-null",
+  "wasmtime-winch?/gc-null",
+]
+
+# Enable runtime support for the WebAssembly threads proposal.
+threads = [
+  "wasmtime-cranelift?/threads",
+  "wasmtime-winch?/threads",
+  "std",
+]
+
+stack-switching = [
+  "runtime",
+  "std",
+  "wasmtime-environ/stack-switching",
+  "wasmtime-cranelift?/stack-switching",
+  "wasmtime-winch?/stack-switching",
+]
+
+# Controls whether backtraces will attempt to parse DWARF information in
+# WebAssembly modules and components to provide filenames and line numbers in
+# stack traces.
+addr2line = ["dep:addr2line", "dep:gimli", "std"]
+
+# Enables support for the Rust standard library, enabling APIs that require
+# types and traits from Rust's `std` such as `Path` and `Error`.
+#
+# Many features of the Wasmtime crate implicitly require this `std` feature.
+# This will be automatically enabled if necessary.
+std = [
+  'postcard/use-std',
+  'wasmtime-environ/std',
+  'object/std',
+  'once_cell',
+  'wasmtime-fiber?/std',
+  'pulley-interpreter/std',
+  'wasmtime-math/std',
+  'addr2line?/std',
+  "dep:rustix",
+  "wasmtime-jit-icache-coherence",
+  "wasmtime-jit-debug?/std",
+]
+
+# Enables support for the `Store::call_hook` API which enables injecting custom
+# logic around all entries/exits from WebAssembly. This has a slight performance
+# cost for all host functions.
+call-hook = []
+
+# Enables support for "memory protection keys" which can be used in conjunction
+# with the pooling allocator on x64 to compact linear memory allocations.
+memory-protection-keys = ["pooling-allocator"]
+
+# Enables a re-export of wasmparser, so that an embedder of Wasmtime can use
+# exactly the version of the parser library that Wasmtime does. Sometimes this
+# is necessary, e.g. to guarantee that there will not be any mismatches in
+# which modules are accepted due to Wasm feature configuration or support
+# levels.
+#
+# Note that when this feature is enabled, the version of wasmparser that is
+# re-exported is *not subject to semver*: we reserve the right to make patch
+# releases of Wasmtime that bump the version of wasmparser used, and hence the
+# version re-exported, in semver-incompatible ways. This is the tradeoff that
+# the embedder needs to opt into: in order to stay exactly in sync with an
+# internal detail of Wasmtime, the cost is visibility into potential internal
+# version changes. This is why the re-export is guarded by a feature flag which
+# is off by default.
+reexport-wasmparser = []
+
+# Enables instances of the traits defined in the wasm-wave crate, which
+# provides a human-readable text format for component values.
+wave = ["dep:wasm-wave", 'component-model']
+
+# For platforms that Wasmtime does not have support for Wasmtime will disable
+# the use of virtual memory by default, for example allocating linear memories
+# with `malloc` instead. This feature can be used, for these platforms, to
+# instead use a C API defined in `wasmtime-platform.h` instead.
+#
+# For some more information see
+# https://docs.wasmtime.dev/stability-platform-support.html#support-for-no_std
+#
+# This feature is not necessary for supported platforms like Unix and Windows as
+# virtual memory is always enabled there.
+custom-virtual-memory = []
+
+# Same as `custom-virtual-memory` above, but for custom signal-handling APIs.
+custom-native-signals = []
+
+# Off-by-default support to profile the Pulley interpreter. This has a
+# performance hit, even when not profiling, so it's disabled by default at
+# compile time.
+profile-pulley = ['pulley', 'profiling', 'pulley-interpreter/profile']
+
+# Enables support for the Component Model Async ABI, along with `future`,
+# `stream`, and `error-context` types.
+component-model-async = [
+  "async",
+  "component-model",
+  "std",
+  "wasmtime-component-macro?/component-model-async",
+  "dep:futures",
+  "futures/std",
+]
+
+# Enables support for `stream` interop with the `bytes` crate.
+component-model-async-bytes = [
+  "component-model-async",
+  "dep:bytes",
+]

data/ext/cargo-vendor/wasmtime-38.0.4/build.rs

@@ -0,0 +1,100 @@
+use std::str;
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    // NB: duplicating a workaround in the wasmtime-fiber build script.
+    custom_cfg("asan", cfg_is("sanitize", "address"));
+
+    let unix = cfg("unix");
+    let windows = cfg("windows");
+    let miri = cfg("miri");
+
+    // A boolean indicating whether there's a `sys` module for this platform.
+    // This is true for `unix` or `windows`, but both of those require the `std`
+    // feature to also be active so check that too.
+    let supported_os = (unix || windows) && cfg!(feature = "std");
+
+    // Determine if the current host architecture is supported by Cranelift
+    // meaning that we might be executing native code.
+    let has_host_compiler_backend = match std::env::var("CARGO_CFG_TARGET_ARCH").unwrap().as_str() {
+        "x86_64" | "riscv64" | "s390x" | "aarch64" => true,
+        _ => false,
+    };
+
+    let has_native_signals = !miri
+        && (supported_os || cfg!(feature = "custom-native-signals"))
+        && has_host_compiler_backend;
+    let has_virtual_memory = supported_os || cfg!(feature = "custom-virtual-memory");
+
+    custom_cfg("has_native_signals", has_native_signals);
+    custom_cfg("has_virtual_memory", has_virtual_memory);
+    custom_cfg("has_host_compiler_backend", has_host_compiler_backend);
+
+    // If this OS isn't supported and no debug-builtins or if Cranelift doesn't support
+    // the host or there's no need to build these helpers.
+    #[cfg(feature = "runtime")]
+    if has_host_compiler_backend && (supported_os || cfg!(feature = "debug-builtins")) {
+        build_c_helpers();
+    }
+
+    // Figure out what to do about Pulley.
+    //
+    // If the target platform does not have any Cranelift support then Pulley
+    // will be used by default. That means that the pulley feature is "enabled"
+    // here and the default target is pulley. Note that by enabling the feature
+    // here it doesn't actually enable the Cargo feature, it just passes a cfg
+    // to rustc. That means that conditional dependencies enabled in
+    // `Cargo.toml` (or other features) by `pulley` aren't activated, which is
+    // why the `pulley` feature of this crate depends on nothing else.
+    let default_target_pulley = !has_host_compiler_backend || miri;
+    custom_cfg("default_target_pulley", default_target_pulley);
+    if default_target_pulley {
+        println!("cargo:rustc-cfg=feature=\"pulley\"");
+    }
+}
+
+fn cfg(key: &str) -> bool {
+    std::env::var(&format!("CARGO_CFG_{}", key.to_uppercase())).is_ok()
+}
+
+fn cfg_is(key: &str, val: &str) -> bool {
+    std::env::var(&format!("CARGO_CFG_{}", key.to_uppercase()))
+        .ok()
+        .as_deref()
+        == Some(val)
+}
+
+fn custom_cfg(key: &str, enabled: bool) {
+    println!("cargo:rustc-check-cfg=cfg({key})");
+    if enabled {
+        println!("cargo:rustc-cfg={key}");
+    }
+}
+
+#[cfg(feature = "runtime")]
+fn build_c_helpers() {
+    use wasmtime_versioned_export_macros::versioned_suffix;
+
+    let mut build = cc::Build::new();
+    build.warnings(true);
+    let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+    let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    build.define(&format!("CFG_TARGET_OS_{os}"), None);
+    build.define(&format!("CFG_TARGET_ARCH_{arch}"), None);
+    build.define("VERSIONED_SUFFIX", Some(versioned_suffix!()));
+    if std::env::var("CARGO_FEATURE_DEBUG_BUILTINS").is_ok() {
+        build.define("FEATURE_DEBUG_BUILTINS", None);
+    } else if cfg("windows") {
+        // If debug builtins are disabled and this target is for Windows then
+        // there's no need to build the C helpers file.
+        //
+        // TODO: should skip this on Unix targets as well but needs a solution
+        // for `wasmtime_using_libunwind`.
+        return;
+    }
+
+    println!("cargo:rerun-if-changed=src/runtime/vm/helpers.c");
+    build.file("src/runtime/vm/helpers.c");
+    build.compile("wasmtime-helpers");
+}