wasmtime 37.0.2 → 38.0.4

data/ext/cargo-vendor/cranelift-assembler-x64-meta-0.125.4/Cargo.lock

@@ -0,0 +1,16 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "cranelift-assembler-x64-meta"
+version = "0.125.4"
+dependencies = [
+ "cranelift-srcgen",
+]
+
+[[package]]
+name = "cranelift-srcgen"
+version = "0.125.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "718efe674f3df645462677e22a3128e890d88ba55821bb091083d257707be76c"

data/ext/cargo-vendor/cranelift-assembler-x64-meta-0.125.4/Cargo.toml

@@ -0,0 +1,73 @@
+# 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 = "2024"
+rust-version = "1.88.0"
+name = "cranelift-assembler-x64-meta"
+version = "0.125.4"
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Generate a Cranelift-specific assembler for x64 instructions"
+readme = "README.md"
+license = "Apache-2.0 WITH LLVM-exception"
+resolver = "2"
+
+[lib]
+name = "cranelift_assembler_x64_meta"
+path = "src/lib.rs"
+
+[[bin]]
+name = "cranelift-assembler-x64-meta"
+path = "src/main.rs"
+
+[dependencies.cranelift-srcgen]
+version = "0.125.4"
+
+[lints.clippy]
+allow_attributes_without_reason = "warn"
+clone_on_copy = "warn"
+from_over_into = "warn"
+manual_strip = "warn"
+map_clone = "warn"
+multiple_bound_locations = "warn"
+redundant_field_names = "warn"
+uninlined_format_args = "warn"
+unnecessary_cast = "warn"
+unnecessary_fallible_conversions = "warn"
+unnecessary_mut_passed = "warn"
+unnecessary_to_owned = "warn"
+useless_conversion = "warn"
+
+[lints.clippy.all]
+level = "allow"
+priority = -1
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused-macro-rules = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+priority = 0
+check-cfg = [
+    "cfg(pulley_tail_calls)",
+    "cfg(pulley_assume_llvm_makes_tail_calls)",
+    "cfg(pulley_disable_interp_simd)",
+]

data/ext/cargo-vendor/cranelift-assembler-x64-meta-0.125.4/Cargo.toml.orig

@@ -0,0 +1,13 @@
+[package]
+name = "cranelift-assembler-x64-meta"
+description = "Generate a Cranelift-specific assembler for x64 instructions"
+version = "0.125.4"
+license = "Apache-2.0 WITH LLVM-exception"
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+cranelift-srcgen = { workspace = true }
+
+[lints]
+workspace = true

data/ext/cargo-vendor/cranelift-assembler-x64-meta-0.125.4/src/generate/inst.rs

@@ -0,0 +1,322 @@
+use super::{Formatter, fmtln, generate_derive, generate_derive_arbitrary_bounds};
+use crate::dsl;
+
+impl dsl::Inst {
+    /// `struct <inst> { <op>: Reg, <op>: Reg, ... }`
+    pub fn generate_struct(&self, f: &mut Formatter) {
+        let struct_name = self.struct_name_with_generic();
+        let where_clause = if self.requires_generic() {
+            "where R: Registers"
+        } else {
+            ""
+        };
+
+        fmtln!(f, "/// `{self}`");
+        generate_derive(f);
+        if self.requires_generic() {
+            generate_derive_arbitrary_bounds(f);
+        }
+        f.add_block(&format!("pub struct {struct_name} {where_clause}"), |f| {
+            for k in &self.format.operands {
+                let loc = k.location;
+                let ty = k.generate_type();
+                fmtln!(f, "pub {loc}: {ty},");
+            }
+
+            if self.has_trap {
+                fmtln!(f, "pub trap: TrapCode,");
+            }
+        });
+    }
+
+    fn requires_generic(&self) -> bool {
+        self.format.uses_register()
+    }
+
+    /// `<struct_name><R>`
+    pub(crate) fn struct_name_with_generic(&self) -> String {
+        let struct_name = self.name();
+        if self.requires_generic() {
+            format!("{struct_name}<R>")
+        } else {
+            struct_name
+        }
+    }
+
+    /// `impl...`
+    fn generate_impl_block_start(&self) -> &str {
+        if self.requires_generic() {
+            "impl<R: Registers>"
+        } else {
+            "impl"
+        }
+    }
+
+    /// `impl <inst> { ... }`
+    pub fn generate_struct_impl(&self, f: &mut Formatter) {
+        let impl_block = self.generate_impl_block_start();
+        let struct_name = self.struct_name_with_generic();
+        f.add_block(&format!("{impl_block} {struct_name}"), |f| {
+            self.generate_new_function(f);
+            f.empty_line();
+            self.generate_mnemonic_function(f);
+            f.empty_line();
+            self.generate_encode_function(f);
+            f.empty_line();
+            self.generate_visit_function(f);
+            f.empty_line();
+            self.generate_is_available_function(f);
+            f.empty_line();
+            self.generate_features_function(f);
+            f.empty_line();
+            self.generate_num_registers_function(f);
+        });
+    }
+
+    // `fn new(<params>) -> Self { ... }`
+    pub fn generate_new_function(&self, f: &mut Formatter) {
+        let params = comma_join(
+            self.format
+                .operands
+                .iter()
+                .map(|o| format!("{}: impl Into<{}>", o.location, o.generate_type()))
+                .chain(if self.has_trap {
+                    Some("trap: impl Into<TrapCode>".to_string())
+                } else {
+                    None
+                }),
+        );
+        fmtln!(f, "#[must_use]");
+        f.add_block(&format!("pub fn new({params}) -> Self"), |f| {
+            f.add_block("Self", |f| {
+                for o in &self.format.operands {
+                    let loc = o.location;
+                    fmtln!(f, "{loc}: {loc}.into(),");
+                }
+                if self.has_trap {
+                    fmtln!(f, "trap: trap.into(),");
+                }
+            });
+        });
+    }
+
+    /// `fn mnemonic(&self) -> &'static str { ... }`
+    pub fn generate_mnemonic_function(&self, f: &mut Formatter) {
+        use dsl::Customization::*;
+
+        fmtln!(f, "#[must_use]");
+        fmtln!(f, "#[inline]");
+        f.add_block(
+            &format!("pub fn mnemonic(&self) -> std::borrow::Cow<'static, str>"),
+            |f| {
+                if self.custom.contains(Mnemonic) {
+                    fmtln!(f, "crate::custom::mnemonic::{}(self)", self.name());
+                } else {
+                    fmtln!(f, "std::borrow::Cow::Borrowed(\"{}\")", self.mnemonic);
+                }
+            },
+        );
+    }
+
+    /// `fn encode(&self, ...) { ... }`
+    fn generate_encode_function(&self, f: &mut Formatter) {
+        use dsl::Customization::*;
+
+        f.add_block(
+            &format!("pub fn encode(&self, buf: &mut impl CodeSink)"),
+            |f| {
+                if self.custom.contains(Encode) {
+                    fmtln!(f, "crate::custom::encode::{}(self, buf);", self.name());
+                } else {
+                    self.generate_possible_trap(f);
+                    match &self.encoding {
+                        dsl::Encoding::Rex(rex) => self.format.generate_rex_encoding(f, rex),
+                        dsl::Encoding::Vex(vex) => self.format.generate_vex_encoding(f, vex),
+                        dsl::Encoding::Evex(evex) => self.format.generate_evex_encoding(f, evex),
+                    }
+                }
+            },
+        );
+    }
+
+    // `buf.add_trap(...)`
+    fn generate_possible_trap(&self, f: &mut Formatter) {
+        if self.has_trap {
+            f.comment("Emit trap.");
+            fmtln!(f, "buf.add_trap(self.trap);");
+        } else if let Some(op) = self.format.uses_memory() {
+            use dsl::OperandKind::*;
+            f.comment("Emit trap.");
+            match op.kind() {
+                Mem(_) => {
+                    f.add_block(
+                        &format!("if let Some(trap_code) = self.{op}.trap_code()"),
+                        |f| {
+                            fmtln!(f, "buf.add_trap(trap_code);");
+                        },
+                    );
+                }
+                RegMem(_) => {
+                    let ty = op.reg_class().unwrap();
+                    f.add_block(&format!("if let {ty}Mem::Mem({op}) = &self.{op}"), |f| {
+                        f.add_block(&format!("if let Some(trap_code) = {op}.trap_code()"), |f| {
+                            fmtln!(f, "buf.add_trap(trap_code);");
+                        });
+                    });
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    /// `fn visit(&self, ...) { ... }`
+    fn generate_visit_function(&self, f: &mut Formatter) {
+        use dsl::{Customization::*, OperandKind::*};
+        let extra_generic_bound = if self.requires_generic() {
+            ""
+        } else {
+            "<R: Registers>"
+        };
+        let visitor = if self.format.operands.is_empty() && !self.custom.contains(Visit) {
+            "_"
+        } else {
+            "visitor"
+        };
+        f.add_block(&format!("pub fn visit{extra_generic_bound}(&mut self, {visitor}: &mut impl RegisterVisitor<R>)"), |f| {
+            if self.custom.contains(Visit) {
+                fmtln!(f, "crate::custom::visit::{}(self, visitor)", self.name());
+                return;
+            }
+            for o in &self.format.operands {
+                let mutability = o.mutability.generate_snake_case();
+                let reg = o.location.reg_class();
+                match o.location.kind() {
+                    Imm(_) => {
+                        // Immediates do not need register allocation.
+                        //
+                        // If an instruction happens to only have immediates
+                        // then generate a dummy use of the `visitor` variable
+                        // to suppress unused variables warnings.
+                        fmtln!(f, "let _ = visitor;");
+                    }
+                    FixedReg(loc) => {
+                        let reg_lower = reg.unwrap().to_string().to_lowercase();
+                        fmtln!(f, "let enc = self.{loc}.expected_enc();");
+                        fmtln!(f, "visitor.fixed_{mutability}_{reg_lower}(&mut self.{loc}.0, enc);");
+                    }
+                    Reg(loc) => {
+                        let reg_lower = reg.unwrap().to_string().to_lowercase();
+                        fmtln!(f, "visitor.{mutability}_{reg_lower}(self.{loc}.as_mut());");
+                    }
+                    RegMem(loc) => {
+                        let reg = reg.unwrap();
+                        let reg_lower = reg.to_string().to_lowercase();
+                        fmtln!(f, "visitor.{mutability}_{reg_lower}_mem(&mut self.{loc});");
+                    }
+                    Mem(loc) => {
+                        // Note that this is always "read" because from a
+                        // regalloc perspective when using an amode it means
+                        // that the while a write is happening that's to
+                        // memory, not registers.
+                        fmtln!(f, "visitor.read_amode(&mut self.{loc});");
+                    }
+
+                }
+            }
+        });
+    }
+
+    /// `fn is_available(&self, ...) -> bool { ... }`
+    fn generate_is_available_function(&self, f: &mut Formatter) {
+        fmtln!(f, "#[must_use]");
+        f.add_block(
+            "pub fn is_available(&self, features: &impl AvailableFeatures) -> bool",
+            |f| {
+                let expr = self.features.generate_boolean_expr("features");
+                fmtln!(f, "{expr}");
+            },
+        );
+    }
+
+    /// `fn features(&self) -> Features { ... }`
+    fn generate_features_function(&self, f: &mut Formatter) {
+        fmtln!(f, "#[must_use]");
+        f.add_block("pub fn features(&self) -> &'static Features", |f| {
+            self.features.generate_constructor_expr(f);
+        });
+    }
+
+    /// `fn num_registers_available(&self) -> usize { ... }`
+    fn generate_num_registers_function(&self, f: &mut Formatter) {
+        fmtln!(f, "#[must_use]");
+        f.add_block("pub fn num_registers_available(&self) -> usize", |f| {
+            use dsl::Encoding::*;
+            let n = match self.encoding {
+                Rex(_) | Vex(_) => 16,
+                Evex(_) => 32,
+            };
+            fmtln!(f, "{n}")
+        });
+    }
+
+    /// `impl Display for <inst> { ... }`
+    pub fn generate_display_impl(&self, f: &mut Formatter) {
+        use crate::dsl::Customization::*;
+        let impl_block = self.generate_impl_block_start();
+        let struct_name = self.struct_name_with_generic();
+        f.add_block(
+            &format!("{impl_block} std::fmt::Display for {struct_name}"),
+            |f| {
+                f.add_block(
+                    "fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result",
+                    |f| {
+                        if self.custom.contains(Display) {
+                            fmtln!(f, "crate::custom::display::{}(f, self)", self.name());
+                            return;
+                        }
+
+                        fmtln!(f, "let name = self.mnemonic();");
+                        if self.format.operands.is_empty() {
+                            fmtln!(f, "f.write_str(&name)");
+                            return;
+                        }
+                        for op in self.format.operands.iter() {
+                            let location = op.location;
+                            let to_string = location.generate_to_string(op.extension);
+                            fmtln!(f, "let {location} = {to_string};");
+                        }
+                        let ordered_ops = self.format.generate_att_style_operands();
+                        let mut implicit_ops = self.format.generate_implicit_operands();
+                        if self.has_trap {
+                            fmtln!(f, "let trap = self.trap;");
+                            if implicit_ops.is_empty() {
+                                implicit_ops.push_str(" ;; {trap}");
+                            } else {
+                                implicit_ops.push_str(", {trap}");
+                            }
+                        }
+                        fmtln!(f, "write!(f, \"{{name}} {ordered_ops}{implicit_ops}\")");
+                    },
+                );
+            },
+        );
+    }
+
+    /// `impl From<struct> for Inst { ... }`
+    pub fn generate_from_impl(&self, f: &mut Formatter) {
+        let struct_name_r = self.struct_name_with_generic();
+        let variant_name = self.name();
+        f.add_block(
+            &format!("impl<R: Registers> From<{struct_name_r}> for Inst<R>"),
+            |f| {
+                f.add_block(&format!("fn from(inst: {struct_name_r}) -> Self"), |f| {
+                    fmtln!(f, "Self::{variant_name}(inst)");
+                });
+            },
+        );
+    }
+}
+
+fn comma_join<S: Into<String>>(items: impl Iterator<Item = S>) -> String {
+    items.map(Into::into).collect::<Vec<_>>().join(", ")
+}

data/ext/cargo-vendor/cranelift-assembler-x64-meta-0.125.4/src/generate.rs

@@ -0,0 +1,110 @@
+//! Contains the code-generation logic to emit for the DSL-defined instructions.
+
+mod features;
+mod format;
+mod inst;
+mod operand;
+
+use crate::dsl;
+use cranelift_srcgen::{Formatter, fmtln};
+
+/// Generate the Rust assembler code; e.g., `enum Inst { ... }`.
+pub fn rust_assembler(f: &mut Formatter, insts: &[dsl::Inst]) {
+    // Generate "all instructions" enum.
+    generate_inst_enum(f, insts);
+    generate_inst_impls(f, insts);
+    generate_inst_display_impl(f, insts);
+
+    // Generate per-instruction structs.
+    f.empty_line();
+    for inst in insts {
+        inst.generate_struct(f);
+        inst.generate_struct_impl(f);
+        inst.generate_display_impl(f);
+        inst.generate_from_impl(f);
+        f.empty_line();
+    }
+
+    // Generate the `Feature` trait.
+    dsl::Feature::generate_macro(f);
+}
+
+/// `enum Inst { ... }`
+fn generate_inst_enum(f: &mut Formatter, insts: &[dsl::Inst]) {
+    fmtln!(f, "#[doc(hidden)]");
+    generate_derive(f);
+    generate_derive_arbitrary_bounds(f);
+    f.add_block("pub enum Inst<R: Registers>", |f| {
+        for inst in insts {
+            let variant_name = inst.name();
+            let struct_name = inst.struct_name_with_generic();
+            fmtln!(f, "{variant_name}({struct_name}),");
+        }
+    });
+}
+
+/// Helper for emitting `match self { ... }` blocks over all instructions. For each instruction in
+/// `insts`, this generate a separate match arm containing `invoke`.
+fn match_variants(f: &mut Formatter, insts: &[dsl::Inst], invoke: &str) {
+    f.add_block("match self", |f| {
+        for inst in insts.iter().map(|i| i.name()) {
+            fmtln!(f, "Self::{inst}(i) => i.{invoke},");
+        }
+    });
+}
+
+/// `impl std::fmt::Display for Inst { ... }`
+fn generate_inst_display_impl(f: &mut Formatter, insts: &[dsl::Inst]) {
+    f.add_block("impl<R: Registers> std::fmt::Display for Inst<R>", |f| {
+        f.add_block(
+            "fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result",
+            |f| {
+                match_variants(f, insts, "fmt(f)");
+            },
+        );
+    });
+}
+
+fn generate_inst_impls(f: &mut Formatter, insts: &[dsl::Inst]) {
+    f.add_block("impl<R: Registers> Inst<R>", |f| {
+        f.add_block("pub fn encode(&self, b: &mut impl CodeSink)", |f| {
+            match_variants(f, insts, "encode(b)");
+        });
+        f.add_block(
+            "pub fn visit(&mut self, v: &mut impl RegisterVisitor<R>)",
+            |f| {
+                match_variants(f, insts, "visit(v)");
+            },
+        );
+        f.add_block(
+            "pub fn is_available(&self, f: &impl AvailableFeatures) -> bool",
+            |f| {
+                match_variants(f, insts, "is_available(f)");
+            },
+        );
+        f.add_block("pub fn features(&self) -> &'static Features", |f| {
+            match_variants(f, insts, "features()");
+        });
+        f.add_block("pub fn num_registers_available(&self) -> usize", |f| {
+            match_variants(f, insts, "num_registers_available()");
+        });
+    });
+}
+
+/// `#[derive(...)]`
+fn generate_derive(f: &mut Formatter) {
+    fmtln!(f, "#[derive(Copy, Clone, Debug)]");
+    fmtln!(
+        f,
+        "#[cfg_attr(any(test, feature = \"fuzz\"), derive(arbitrary::Arbitrary))]"
+    );
+}
+
+/// Adds a custom bound to the `Arbitrary` implementation which ensures that
+/// the associated registers are all `Arbitrary` as well.
+fn generate_derive_arbitrary_bounds(f: &mut Formatter) {
+    fmtln!(
+        f,
+        "#[cfg_attr(any(test, feature = \"fuzz\"), arbitrary(bound = \"R: crate::fuzz::RegistersArbitrary\"))]"
+    );
+}

data/ext/cargo-vendor/cranelift-bforest-0.125.4/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"7c7643d232f93154a6d6a1d175fcfac6b2d040a19a37382fcad8a6150b570b02","Cargo.lock":"ac2dded8dd07ba2944fce06ab8b5b3fbbbcf8aed58dcd8af482a57179ff67977","Cargo.toml":"5fa183cc284cabf50b7518d01b85287f749fe9d1442622e1c90824ced61828f3","Cargo.toml.orig":"01827ba63c4437aa53350f70cf182ebf0863e433305e4ee02eebe1bb768e3cf9","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"af367c67340fa7f6fb9a35b0aa637dcf303957f7ae7427a5f4f6356801c8bb04","src/lib.rs":"f813243589cbf47418dc966a863bb8efeee9f9c7a03b44c04890faf3b50ca065","src/map.rs":"9fb84ff108682532738c855a4c98f81b2314c03fc572a52ef76caa4a2b76aa95","src/node.rs":"abefa0f3a0e1db8628dd2caf3aa85b875f7e961f71854e16944019352c66b1c6","src/path.rs":"ef4ace5a8ce54e40c502623c6ef5c6847d5224e9b3c2a7267da807296d8c2d92","src/pool.rs":"5907efaadd76261727f07c06e16644d8742d497f53f2e2c4cc8bf3eeca99ffd1","src/set.rs":"1e2ffc1fd08f703b2f378e04efef5315e7fe8b78e40e71c65facfaa7938abed7"},"package":"0206887a11a43f507fee320a218dc365980bfc42ec2696792079a9f8c9369e90"}

data/ext/cargo-vendor/cranelift-bforest-0.125.4/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "4c22e15bade0a8590d8272f5be85426cb134601b"
+  },
+  "path_in_vcs": "cranelift/bforest"
+}

data/ext/cargo-vendor/cranelift-bforest-0.125.4/Cargo.lock

@@ -0,0 +1,25 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "cranelift-bforest"
+version = "0.125.4"
+dependencies = [
+ "cranelift-entity",
+]
+
+[[package]]
+name = "cranelift-bitset"
+version = "0.125.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac0790c83cfdab95709c5d0105fd888221e3af9049a7d7ec376ec901ab4e4dba"
+
+[[package]]
+name = "cranelift-entity"
+version = "0.125.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "981b56af777f9a34ea6dcce93255125776d391410c2a68b75bed5941b714fa15"
+dependencies = [
+ "cranelift-bitset",
+]

data/ext/cargo-vendor/cranelift-bforest-0.125.4/Cargo.toml

@@ -0,0 +1,79 @@
+# 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 = "2024"
+rust-version = "1.88.0"
+name = "cranelift-bforest"
+version = "0.125.4"
+authors = ["The Cranelift Project Developers"]
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "A forest of B+-trees"
+documentation = "https://docs.rs/cranelift-bforest"
+readme = "README.md"
+keywords = [
+    "btree",
+    "forest",
+    "set",
+    "map",
+]
+categories = ["no-std"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+resolver = "2"
+
+[lib]
+name = "cranelift_bforest"
+path = "src/lib.rs"
+
+[dependencies.cranelift-entity]
+version = "0.125.4"
+
+[lints.clippy]
+allow_attributes_without_reason = "warn"
+clone_on_copy = "warn"
+from_over_into = "warn"
+manual_strip = "warn"
+map_clone = "warn"
+multiple_bound_locations = "warn"
+redundant_field_names = "warn"
+uninlined_format_args = "warn"
+unnecessary_cast = "warn"
+unnecessary_fallible_conversions = "warn"
+unnecessary_mut_passed = "warn"
+unnecessary_to_owned = "warn"
+useless_conversion = "warn"
+
+[lints.clippy.all]
+level = "allow"
+priority = -1
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused-macro-rules = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+priority = 0
+check-cfg = [
+    "cfg(pulley_tail_calls)",
+    "cfg(pulley_assume_llvm_makes_tail_calls)",
+    "cfg(pulley_disable_interp_simd)",
+]

data/ext/cargo-vendor/cranelift-bforest-0.125.4/Cargo.toml.orig

@@ -0,0 +1,19 @@
+[package]
+authors = ["The Cranelift Project Developers"]
+name = "cranelift-bforest"
+version = "0.125.4"
+description = "A forest of B+-trees"
+license = "Apache-2.0 WITH LLVM-exception"
+documentation = "https://docs.rs/cranelift-bforest"
+repository = "https://github.com/bytecodealliance/wasmtime"
+categories = ["no-std"]
+readme = "README.md"
+keywords = ["btree", "forest", "set", "map"]
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+cranelift-entity = { workspace = true }

data/ext/cargo-vendor/cranelift-bitset-0.125.4/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"4140da41193f28bb17470d6a3e761dd7fb7b0bbd4833972cf2929896cbd4e6db","Cargo.lock":"7a2c61ab8815c31eb31023ae986fa0ed32a1f2aaad4f34d9470796976a19b8b9","Cargo.toml":"00fb0bbfee4c922d86237db13be0e65a944ce7d8e5dbdb6218f13b8176b3c766","Cargo.toml.orig":"6359ab4cf72d786adfc295cae9f15b640adf702345be4572739bbdd0560412e8","src/compound.rs":"9674b6659bf42fcd7d7cc1a11c582ddeed5e3a8157eb5b065ba9396a7abee522","src/lib.rs":"f8df4142218c08cda5e38bb5087a8e2869e694acdec228a4a163d1eb1156d6b1","src/scalar.rs":"cb85685c57691c39932d6327a98ecc1d8743efab444ef262d19bf7d892b4253d","tests/bitset.rs":"a6328a130b8a6c6b1b5f9415e706b89a16a04fcc91f739b386371fe66b540b5d"},"package":"ac0790c83cfdab95709c5d0105fd888221e3af9049a7d7ec376ec901ab4e4dba"}

data/ext/cargo-vendor/cranelift-bitset-0.125.4/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "4c22e15bade0a8590d8272f5be85426cb134601b"
+  },
+  "path_in_vcs": "cranelift/bitset"
+}