wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/cranelift-codegen-meta-0.97.1/src/shared/settings.rs

@@ -0,0 +1,348 @@
+use crate::cdsl::settings::{SettingGroup, SettingGroupBuilder};
+
+pub(crate) fn define() -> SettingGroup {
+    let mut settings = SettingGroupBuilder::new("shared");
+
+    settings.add_bool(
+        "regalloc_checker",
+        "Enable the symbolic checker for register allocation.",
+        r#"
+            This performs a verification that the register allocator preserves
+            equivalent dataflow with respect to the original (pre-regalloc)
+            program. This analysis is somewhat expensive. However, if it succeeds,
+            it provides independent evidence (by a carefully-reviewed, from-first-principles
+            analysis) that no regalloc bugs were triggered for the particular compilations
+            performed. This is a valuable assurance to have as regalloc bugs can be
+            very dangerous and difficult to debug.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "regalloc_verbose_logs",
+        "Enable verbose debug logs for regalloc2.",
+        r#"
+            This adds extra logging for regalloc2 output, that is quite valuable to understand
+            decisions taken by the register allocator as well as debugging it. It is disabled by
+            default, as it can cause many log calls which can slow down compilation by a large
+            amount.
+        "#,
+        false,
+    );
+
+    settings.add_enum(
+        "opt_level",
+        "Optimization level for generated code.",
+        r#"
+            Supported levels:
+
+            - `none`: Minimise compile time by disabling most optimizations.
+            - `speed`: Generate the fastest possible code
+            - `speed_and_size`: like "speed", but also perform transformations aimed at reducing code size.
+        "#,
+        vec!["none", "speed", "speed_and_size"],
+    );
+
+    settings.add_bool(
+        "enable_alias_analysis",
+        "Do redundant-load optimizations with alias analysis.",
+        r#"
+            This enables the use of a simple alias analysis to optimize away redundant loads.
+            Only effective when `opt_level` is `speed` or `speed_and_size`.
+        "#,
+        true,
+    );
+
+    settings.add_bool(
+        "enable_verifier",
+        "Run the Cranelift IR verifier at strategic times during compilation.",
+        r#"
+            This makes compilation slower but catches many bugs. The verifier is always enabled by
+            default, which is useful during development.
+        "#,
+        true,
+    );
+
+    // Note that Cranelift doesn't currently need an is_pie flag, because PIE is
+    // just PIC where symbols can't be pre-empted, which can be expressed with the
+    // `colocated` flag on external functions and global values.
+    settings.add_bool(
+        "is_pic",
+        "Enable Position-Independent Code generation.",
+        "",
+        false,
+    );
+
+    settings.add_bool(
+        "use_colocated_libcalls",
+        "Use colocated libcalls.",
+        r#"
+            Generate code that assumes that libcalls can be declared "colocated",
+            meaning they will be defined along with the current function, such that
+            they can use more efficient addressing.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "enable_float",
+        "Enable the use of floating-point instructions.",
+        r#"
+            Disabling use of floating-point instructions is not yet implemented.
+        "#,
+        true,
+    );
+
+    settings.add_bool(
+        "enable_nan_canonicalization",
+        "Enable NaN canonicalization.",
+        r#"
+            This replaces NaNs with a single canonical value, for users requiring
+            entirely deterministic WebAssembly computation. This is not required
+            by the WebAssembly spec, so it is not enabled by default.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "enable_pinned_reg",
+        "Enable the use of the pinned register.",
+        r#"
+            This register is excluded from register allocation, and is completely under the control of
+            the end-user. It is possible to read it via the get_pinned_reg instruction, and to set it
+            with the set_pinned_reg instruction.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "enable_simd",
+        "Enable the use of SIMD instructions.",
+        "",
+        false,
+    );
+
+    settings.add_bool(
+        "enable_atomics",
+        "Enable the use of atomic instructions",
+        "",
+        true,
+    );
+
+    settings.add_bool(
+        "enable_safepoints",
+        "Enable safepoint instruction insertions.",
+        r#"
+            This will allow the emit_stack_maps() function to insert the safepoint
+            instruction on top of calls and interrupt traps in order to display the
+            live reference values at that point in the program.
+        "#,
+        false,
+    );
+
+    settings.add_enum(
+        "tls_model",
+        "Defines the model used to perform TLS accesses.",
+        "",
+        vec!["none", "elf_gd", "macho", "coff"],
+    );
+
+    settings.add_enum(
+        "libcall_call_conv",
+        "Defines the calling convention to use for LibCalls call expansion.",
+        r#"
+            This may be different from the ISA default calling convention.
+
+            The default value is to use the same calling convention as the ISA
+            default calling convention.
+
+            This list should be kept in sync with the list of calling
+            conventions available in isa/call_conv.rs.
+        "#,
+        vec![
+            "isa_default",
+            "fast",
+            "cold",
+            "system_v",
+            "windows_fastcall",
+            "apple_aarch64",
+            "probestack",
+        ],
+    );
+
+    settings.add_bool(
+        "enable_llvm_abi_extensions",
+        "Enable various ABI extensions defined by LLVM's behavior.",
+        r#"
+            In some cases, LLVM's implementation of an ABI (calling convention)
+            goes beyond a standard and supports additional argument types or
+            behavior. This option instructs Cranelift codegen to follow LLVM's
+            behavior where applicable.
+
+            Currently, this applies only to Windows Fastcall on x86-64, and
+            allows an `i128` argument to be spread across two 64-bit integer
+            registers. The Fastcall implementation otherwise does not support
+            `i128` arguments, and will panic if they are present and this
+            option is not set.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "unwind_info",
+        "Generate unwind information.",
+        r#"
+            This increases metadata size and compile time, but allows for the
+            debugger to trace frames, is needed for GC tracing that relies on
+            libunwind (such as in Wasmtime), and is unconditionally needed on
+            certain platforms (such as Windows) that must always be able to unwind.
+          "#,
+        true,
+    );
+
+    settings.add_bool(
+        "preserve_frame_pointers",
+        "Preserve frame pointers",
+        r#"
+            Preserving frame pointers -- even inside leaf functions -- makes it
+            easy to capture the stack of a running program, without requiring any
+            side tables or metadata (like `.eh_frame` sections). Many sampling
+            profilers and similar tools walk frame pointers to capture stacks.
+            Enabling this option will play nice with those tools.
+        "#,
+        false,
+    );
+
+    settings.add_bool(
+        "machine_code_cfg_info",
+        "Generate CFG metadata for machine code.",
+        r#"
+            This increases metadata size and compile time, but allows for the
+            embedder to more easily post-process or analyze the generated
+            machine code. It provides code offsets for the start of each
+            basic block in the generated machine code, and a list of CFG
+            edges (with blocks identified by start offsets) between them.
+            This is useful for, e.g., machine-code analyses that verify certain
+            properties of the generated code.
+        "#,
+        false,
+    );
+
+    // Stack probing options.
+
+    settings.add_bool(
+        "enable_probestack",
+        "Enable the use of stack probes for supported calling conventions.",
+        "",
+        false,
+    );
+
+    settings.add_bool(
+        "probestack_func_adjusts_sp",
+        "Enable if the stack probe adjusts the stack pointer.",
+        "",
+        false,
+    );
+
+    settings.add_num(
+        "probestack_size_log2",
+        "The log2 of the size of the stack guard region.",
+        r#"
+            Stack frames larger than this size will have stack overflow checked
+            by calling the probestack function.
+
+            The default is 12, which translates to a size of 4096.
+        "#,
+        12,
+    );
+
+    settings.add_enum(
+        "probestack_strategy",
+        "Controls what kinds of stack probes are emitted.",
+        r#"
+            Supported strategies:
+
+            - `outline`: Always emits stack probes as calls to a probe stack function.
+            - `inline`: Always emits inline stack probes.
+        "#,
+        vec!["outline", "inline"],
+    );
+
+    // Jump table options.
+
+    settings.add_bool(
+        "enable_jump_tables",
+        "Enable the use of jump tables in generated machine code.",
+        "",
+        true,
+    );
+
+    // Spectre options.
+
+    settings.add_bool(
+        "enable_heap_access_spectre_mitigation",
+        "Enable Spectre mitigation on heap bounds checks.",
+        r#"
+            This is a no-op for any heap that needs no bounds checks; e.g.,
+            if the limit is static and the guard region is large enough that
+            the index cannot reach past it.
+
+            This option is enabled by default because it is highly
+            recommended for secure sandboxing. The embedder should consider
+            the security implications carefully before disabling this option.
+        "#,
+        true,
+    );
+
+    settings.add_bool(
+        "enable_table_access_spectre_mitigation",
+        "Enable Spectre mitigation on table bounds checks.",
+        r#"
+            This option uses a conditional move to ensure that when a table
+            access index is bounds-checked and a conditional branch is used
+            for the out-of-bounds case, a misspeculation of that conditional
+            branch (falsely predicted in-bounds) will select an in-bounds
+            index to load on the speculative path.
+
+            This option is enabled by default because it is highly
+            recommended for secure sandboxing. The embedder should consider
+            the security implications carefully before disabling this option.
+        "#,
+        true,
+    );
+
+    settings.add_bool(
+        "enable_incremental_compilation_cache_checks",
+        "Enable additional checks for debugging the incremental compilation cache.",
+        r#"
+            Enables additional checks that are useful during development of the incremental
+            compilation cache. This should be mostly useful for Cranelift hackers, as well as for
+            helping to debug false incremental cache positives for embedders.
+
+            This option is disabled by default and requires enabling the "incremental-cache" Cargo
+            feature in cranelift-codegen.
+        "#,
+        false,
+    );
+
+    settings.add_num(
+        "bb_padding_log2_minus_one",
+        "The log2 of the size to insert dummy padding between basic blocks",
+        r#"
+            This is a debugging option for stressing various cases during code
+            generation without requiring large functions. This will insert
+            0-byte padding between basic blocks of the specified size.
+
+            The amount of padding inserted two raised to the power of this value
+            minus one. If this value is 0 then no padding is inserted.
+
+            The default for this option is 0 to insert no padding as it's only
+            intended for testing and development.
+        "#,
+        0,
+    );
+
+    // When adding new settings please check if they can also be added
+    // in cranelift/fuzzgen/src/lib.rs for fuzzing.
+    settings.build()
+}

data/ext/cargo-vendor/cranelift-codegen-shared-0.97.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"c3fb5e3dda7d9f3d5b6ce06e3c2be49fd55f6e7c8021b234e11442202d828a88","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"a410bc2f5dcbde499c0cd299c2620bc8111e3c5b3fccdd9e2d85caf3c24fdab3","src/constant_hash.rs":"4dc1a4e6f31a2f25d41fc7ee4ed2ae94563a090cdc77d7bbd972aa4098bd4f01","src/constants.rs":"401059f8958896c29edfcaacc3f5cb32adcdf28710142c867a5cb37e8eae3f14","src/lib.rs":"2459e84571ddc885542d132a9d660d2148ddd34c2aa6ab656613823949d08387"},"package":"0114095ec7d2fbd658ed100bd007006360bc2530f57c6eee3d3838869140dbf9"}

data/ext/cargo-vendor/cranelift-codegen-shared-0.97.1/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 = "cranelift-codegen-shared"
+version = "0.97.1"
+authors = ["The Cranelift Project Developers"]
+description = "For code shared between cranelift-codegen-meta and cranelift-codegen"
+readme = "README.md"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies]

data/ext/cargo-vendor/cranelift-control-0.97.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"6f7003763e5e6ae9f879e0246545213920c63163d88a8d321e0f8655fbed555f","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"9266e3c8ff78a0f5948eb24292a2b51ec272d9417816ffe23de0b1ea4589acb4","src/chaos.rs":"2249bbd902abb610258e8a0545e4ce3d526ea4f29f04aa4724195cd2d7ee28a3","src/lib.rs":"4da5d01c3d43954437288a96f8842f11f01431d99fbf4a7210e9bb71b56393dc","src/zero_sized.rs":"4f970663f3502a2644162033aaf6a7b65336e3e1a9b064737f5cace89636e556"},"package":"1d56031683a55a949977e756d21826eb17a1f346143a1badc0e120a15615cd38"}

data/ext/cargo-vendor/cranelift-control-0.97.1/Cargo.toml

@@ -0,0 +1,30 @@
+# 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 = "cranelift-control"
+version = "0.97.1"
+authors = ["The Cranelift Project Developers"]
+description = "White-box fuzz testing framework"
+readme = "README.md"
+keywords = [
+    "fuzz",
+    "test",
+]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.arbitrary]
+version = "1.3.0"
+
+[features]
+chaos = []

data/ext/cargo-vendor/cranelift-control-0.97.1/src/chaos.rs

@@ -0,0 +1,125 @@
+use arbitrary::{Arbitrary, Unstructured};
+
+/// The control plane of chaos mode.
+/// Please see the [crate-level documentation](crate).
+#[derive(Debug, Clone, Default)]
+pub struct ControlPlane {
+    data: Vec<u8>,
+    fuel: Option<u8>,
+    /// This is used as a little optimization to avoid additional heap
+    /// allocations when using `Unstructured` internally. See the source of
+    /// [`ControlPlane::shuffle`] for an example.
+    tmp: Vec<u8>,
+}
+
+impl Arbitrary<'_> for ControlPlane {
+    fn arbitrary<'a>(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        Ok(Self::new(u.arbitrary()?))
+    }
+}
+
+impl ControlPlane {
+    fn new(data: Vec<u8>) -> Self {
+        Self {
+            data,
+            fuel: None,
+            tmp: Vec::new(),
+        }
+    }
+
+    /// Set the [fuel limit](crate#fuel-limit). Zero is interpreted as the
+    /// fuel limit being deactivated, consistent with the cranelift setting
+    /// `control_plane_fuel`.
+    pub fn set_fuel(&mut self, fuel: u8) {
+        self.fuel = (fuel != 0).then_some(fuel)
+    }
+
+    /// Tries to consume fuel, returning `true` if successful (or if
+    /// fuel-limiting is disabled).
+    fn consume_fuel(&mut self) -> bool {
+        match self.fuel {
+            None => true,               // fuel deactivated
+            Some(f) if f == 0 => false, // no more fuel
+            Some(ref mut f) => {
+                *f -= 1;
+                true
+            }
+        }
+    }
+
+    /// Returns a pseudo-random boolean if the control plane was constructed
+    /// with `arbitrary`.
+    ///
+    /// The default value `false` will always be returned if the
+    /// pseudo-random data is exhausted or the control plane was constructed
+    /// with `default`.
+    pub fn get_decision(&mut self) -> bool {
+        self.consume_fuel() && self.data.pop().unwrap_or_default() & 1 == 1
+    }
+
+    /// Returns an arbitrary value if the control plane was constructed with
+    /// `arbitrary`.
+    ///
+    /// The default value will always be returned if the pseudo-random data is
+    /// exhausted or the control plane was constructed with `default`.
+    pub fn get_arbitrary<T: for<'a> Arbitrary<'a> + Default>(&mut self) -> T {
+        if !self.consume_fuel() || self.data.is_empty() {
+            return T::default();
+        }
+        let mut u = Unstructured::new(&self.data);
+        let res = u.arbitrary().unwrap_or_default();
+
+        // take remaining bytes
+        let rest = u.take_rest();
+        self.tmp.resize(rest.len(), 0); // allocates once per control plane
+        self.tmp.copy_from_slice(rest);
+        std::mem::swap(&mut self.data, &mut self.tmp);
+
+        res
+    }
+
+    /// Shuffles the items in the slice into a pseudo-random permutation if
+    /// the control plane was constructed with `arbitrary`.
+    ///
+    /// The default operation, to leave the slice unchanged, will always be
+    /// performed if the pseudo-random data is exhausted or the control
+    /// plane was constructed with `default`.
+    pub fn shuffle<T>(&mut self, slice: &mut [T]) {
+        if !self.consume_fuel() || self.data.is_empty() {
+            return;
+        }
+        let mut u = Unstructured::new(&self.data);
+
+        // adapted from:
+        // https://docs.rs/arbitrary/1.3.0/arbitrary/struct.Unstructured.html#examples-1
+        let mut to_permute = &mut slice[..];
+
+        while to_permute.len() > 1 {
+            if let Ok(idx) = u.choose_index(to_permute.len()) {
+                to_permute.swap(0, idx);
+                to_permute = &mut to_permute[1..];
+            } else {
+                break;
+            }
+        }
+
+        // take remaining bytes
+        let rest = u.take_rest();
+        self.tmp.resize(rest.len(), 0); // allocates once per control plane
+        self.tmp.copy_from_slice(rest);
+        std::mem::swap(&mut self.data, &mut self.tmp);
+    }
+
+    /// Returns a new iterator over the same items as the input iterator in
+    /// a pseudo-random order if the control plane was constructed with
+    /// `arbitrary`.
+    ///
+    /// The default value, an iterator with an unchanged order, will always
+    /// be returned if the pseudo-random data is exhausted or the control
+    /// plane was constructed with `default`.
+    pub fn shuffled<T>(&mut self, iter: impl Iterator<Item = T>) -> impl Iterator<Item = T> {
+        let mut slice: Vec<_> = iter.collect();
+        self.shuffle(&mut slice);
+        slice.into_iter()
+    }
+}

data/ext/cargo-vendor/cranelift-control-0.97.1/src/lib.rs

@@ -0,0 +1,45 @@
+//! # Cranelift Control
+//!
+//! This is the home of the control plane of chaos mode, a compilation feature
+//! intended to be turned on for certain fuzz targets. When the feature is
+//! turned off, as is normally the case, [ControlPlane] will be a zero-sized
+//! type and optimized away.
+//!
+//! While the feature is turned on, the struct [ControlPlane]
+//! provides functionality to tap into pseudo-randomness at specific locations
+//! in the code. It may be used for targeted fuzzing of compiler internals,
+//! e.g. manipulate heuristic optimizations, clobber undefined register bits
+//! etc.
+//!
+//! There are two ways to acquire a [ControlPlane]:
+//! - [arbitrary] for the real deal
+//! - [default] for an "empty" control plane which always returns default
+//!   values
+//!
+//! ## Fuel Limit
+//!
+//! Controls the number of mutations or optimizations that the compiler will
+//! perform before stopping.
+//!
+//! When a perturbation introduced by chaos mode triggers a bug, it may not be
+//! immediately clear which of the introduced perturbations was the trigger. The
+//! fuel limit can then be used to binary-search for the trigger. It limits the
+//! number of perturbations introduced by the control plane. The fuel limit will
+//! typically be set with a command line argument passed to a fuzz target. For
+//! example:
+//! ```sh
+//! cargo fuzz run --features chaos $TARGET -- --fuel=16
+//! ```
+//!
+//! [arbitrary]: ControlPlane#method.arbitrary
+//! [default]: ControlPlane#method.default
+
+#[cfg(not(feature = "chaos"))]
+mod zero_sized;
+#[cfg(not(feature = "chaos"))]
+pub use zero_sized::*;
+
+#[cfg(feature = "chaos")]
+mod chaos;
+#[cfg(feature = "chaos")]
+pub use chaos::*;

data/ext/cargo-vendor/cranelift-control-0.97.1/src/zero_sized.rs

@@ -0,0 +1,53 @@
+//! Shims for ControlPlane when chaos mode is disabled. Enables
+//! unconditional use of the type and its methods throughout cranelift.
+
+/// A shim for ControlPlane when chaos mode is disabled.
+/// Please see the [crate-level documentation](crate).
+#[derive(Debug, Clone, Default)]
+pub struct ControlPlane {
+    /// prevent direct instantiation (use `default` instead)
+    _private: (),
+}
+
+/// A shim for ControlPlane's `Arbitrary` implementation when chaos mode is
+/// disabled. It doesn't consume any bytes and always returns a default
+/// control plane.
+impl arbitrary::Arbitrary<'_> for ControlPlane {
+    fn arbitrary(_u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
+        Ok(Self::default())
+    }
+}
+
+impl ControlPlane {
+    /// Set the [fuel limit](crate#fuel-limit). This variant is used when
+    /// chaos mode is disabled. It doesn't do anything.
+    pub fn set_fuel(&mut self, _fuel: u8) {}
+
+    /// Returns a pseudo-random boolean. This variant is used when chaos
+    /// mode is disabled. It always returns `false`.
+    #[inline]
+    pub fn get_decision(&mut self) -> bool {
+        false
+    }
+
+    /// Returns an arbitrary value. This variant is used when chaos mode is
+    /// disabled. It always returns the default value.
+    #[inline]
+    pub fn get_arbitrary<T: for<'a> arbitrary::Arbitrary<'a> + Default>(&mut self) -> T {
+        T::default()
+    }
+
+    /// Shuffles the items in the slice into a pseudo-random permutation.
+    /// This variant is used when chaos mode is disabled. It doesn't do
+    /// anything.
+    #[inline]
+    pub fn shuffle<T>(&mut self, _slice: &mut [T]) {}
+
+    /// Returns a new iterator over the same items as the input iterator in
+    /// a pseudo-random order. This variant is used when chaos mode is
+    /// disabled. It always returns the same order.
+    #[inline]
+    pub fn shuffled<T>(&mut self, iter: impl Iterator<Item = T>) -> impl Iterator<Item = T> {
+        iter
+    }
+}

data/ext/cargo-vendor/cranelift-entity-0.97.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"7097ba4b854c435ac0481f7f11936d20016334f694ea73864207a92a3dccdaa7","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"96ceffbfd88fb06e3b41aa4d3087cffbbf8441d04eba7ab09662a72ab600a321","src/boxed_slice.rs":"69d539b72460c0aba1d30e0b72efb0c29d61558574d751c784794e14abf41352","src/iter.rs":"61fefdc49cafad4cacba5f5a7ad2396a23160642c688a7f0b0734277391847cd","src/keys.rs":"b8c2fba26dee15bf3d1880bb2b41e8d66fe1428d242ee6d9fd30ee94bbd0407d","src/lib.rs":"e1bb697e13165cb995767e0632f0886ff1b4702f4960b1841e426cd3ca498abb","src/list.rs":"ca92856079ee5bbeb57dd2223b03ec4361606eb7b0337a96b7dde9ad6c73faaf","src/map.rs":"d5e004471acf75d71cebaac0e65a45fe052781507f4a616120d264a8056a5d92","src/packed_option.rs":"00fd85e014f59b14b3be383c3a85bbd887e878efe24a3344c9376724f86fc499","src/primary.rs":"6de2e2785b6d571664918f28757b32ddc873346cd60e844a182f534ef2dea760","src/set.rs":"895202c96ca318e8b7bd43bfdb37ce5b845880aec1a3fecc6033aedc294a3c8d","src/sparse.rs":"4984fad1d4163f3e345a09ab99f81b6462c88330a93e473479bf2fd1df2c1f52"},"package":"d6565198b5684367371e2b946ceca721eb36965e75e3592fad12fc2e15f65d7b"}

data/ext/cargo-vendor/cranelift-entity-0.97.1/Cargo.toml

@@ -0,0 +1,35 @@
+# 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 = "cranelift-entity"
+version = "0.97.1"
+authors = ["The Cranelift Project Developers"]
+description = "Data structures using entity references as mapping keys"
+documentation = "https://docs.rs/cranelift-entity"
+readme = "README.md"
+keywords = [
+    "entity",
+    "set",
+    "map",
+]
+categories = ["no-std"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.serde]
+version = "1.0.94"
+features = ["derive"]
+optional = true
+
+[features]
+enable-serde = ["serde"]