wasmtime 11.0.0 → 12.0.1

data/ext/cargo-vendor/cranelift-codegen-0.99.1/src/opts/cprop.isle

@@ -0,0 +1,200 @@
+;; Constant propagation.
+
+(rule (simplify
+       (iadd (fits_in_64 ty)
+             (iconst ty (u64_from_imm64 k1))
+             (iconst ty (u64_from_imm64 k2))))
+      (subsume (iconst ty (imm64_masked ty (u64_add k1 k2)))))
+
+(rule (simplify
+       (isub (fits_in_64 ty)
+             (iconst ty (u64_from_imm64 k1))
+             (iconst ty (u64_from_imm64 k2))))
+      (subsume (iconst ty (imm64_masked ty (u64_sub k1 k2)))))
+
+(rule (simplify
+       (imul (fits_in_64 ty)
+             (iconst ty (u64_from_imm64 k1))
+             (iconst ty (u64_from_imm64 k2))))
+      (subsume (iconst ty (imm64_masked ty (u64_mul k1 k2)))))
+
+(rule (simplify
+       (sdiv (fits_in_64 ty)
+             (iconst ty (u64_from_imm64 k1))
+             (iconst ty (u64_from_imm64 k2))))
+      (if-let d (u64_sdiv k1 k2))
+      (subsume (iconst ty (imm64_masked ty d))))
+
+(rule (simplify
+       (udiv (fits_in_64 ty)
+             (iconst ty (u64_from_imm64 k1))
+             (iconst ty (u64_from_imm64 k2))))
+      (if-let d (u64_udiv k1 k2))
+      (subsume (iconst ty (imm64_masked ty d))))
+
+(rule (simplify
+       (bor (fits_in_64 ty)
+            (iconst ty (u64_from_imm64 k1))
+            (iconst ty (u64_from_imm64 k2))))
+      (subsume (iconst ty (imm64_masked ty (u64_or k1 k2)))))
+
+(rule (simplify
+       (band (fits_in_64 ty)
+            (iconst ty (u64_from_imm64 k1))
+            (iconst ty (u64_from_imm64 k2))))
+      (subsume (iconst ty (imm64_masked ty (u64_and k1 k2)))))
+
+(rule (simplify
+       (bxor (fits_in_64 ty)
+            (iconst ty (u64_from_imm64 k1))
+            (iconst ty (u64_from_imm64 k2))))
+      (subsume (iconst ty (imm64_masked ty (u64_xor k1 k2)))))
+
+(rule (simplify
+       (bnot (fits_in_64 ty)
+            (iconst ty (u64_from_imm64 k))))
+      (subsume (iconst ty (imm64_masked ty (u64_not k)))))
+
+(rule (simplify (ishl (fits_in_64 ty)
+                      (iconst ty k1)
+                      (iconst _ k2)))
+      (subsume (iconst ty (imm64_shl ty k1 k2))))
+
+(rule (simplify (ushr (fits_in_64 ty)
+                      (iconst ty k1)
+                      (iconst _ k2)))
+      (subsume (iconst ty (imm64_ushr ty k1 k2))))
+
+(rule (simplify (sshr (fits_in_64 ty)
+                      (iconst ty k1)
+                      (iconst _ k2)))
+      (subsume (iconst ty (imm64_sshr ty k1 k2))))
+
+(rule (simplify (ireduce narrow (iconst (fits_in_64 _) (u64_from_imm64 imm))))
+      (subsume (iconst narrow (imm64_masked narrow imm))))
+
+(rule (simplify (uextend (fits_in_64 wide) (iconst narrow imm)))
+      (subsume (iconst wide (imm64 (u64_uextend_imm64 narrow imm)))))
+
+(rule (simplify (sextend (fits_in_64 wide) (iconst narrow imm)))
+      (subsume (iconst wide (imm64_masked wide (i64_as_u64 (i64_sextend_imm64 narrow imm))))))
+
+(rule (simplify
+       (icmp result_ty
+            cc
+            (iconst ty k1)
+            (iconst ty k2)))
+      (subsume (iconst result_ty (imm64_icmp ty cc k1 k2))))
+
+
+;; Canonicalize via commutativity: push immediates to the right.
+;;
+;;   (op k x) --> (op x k)
+
+(rule (simplify
+       (iadd ty k @ (iconst ty _) x))
+      (iadd ty x k))
+;; sub is not commutative, but we can flip the args and negate the
+;; whole thing.
+(rule (simplify
+       (isub ty k @ (iconst ty _) x))
+      (ineg ty (isub ty x k)))
+(rule (simplify
+       (imul ty k @ (iconst ty _) x))
+      (imul ty x k))
+
+(rule (simplify
+       (bor ty k @ (iconst ty _) x))
+      (bor ty x k))
+(rule (simplify
+       (band ty k @ (iconst ty _) x))
+      (band ty x k))
+(rule (simplify
+       (bxor ty k @ (iconst ty _) x))
+      (bxor ty x k))
+
+(rule (simplify
+       (icmp ty cc k @ (iconst _ _) x))
+      (icmp ty (intcc_reverse cc) x k))
+
+;; Canonicalize via associativity: reassociate to a right-heavy tree
+;; for constants.
+;;
+;;   (op (op x k) k) --> (op x (op k k))
+
+(rule (simplify
+       (iadd ty (iadd ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
+      (iadd ty x (iadd ty k1 k2)))
+;; sub is not directly associative, but we can flip a sub to an add to
+;; make it work:
+;; - (sub (sub x k1) k2) -> (sub x (add k1 k2))
+;; - (sub (sub k1 x) k2) -> (sub (sub k1 k2) x)
+;; - (sub (add x k1) k2) -> (sub x (sub k2 k1))
+;; - (add (sub x k1) k2) -> (add x (sub k2 k1))
+;; - (add (sub k1 x) k2) -> (sub (add k1 k2) x)
+(rule (simplify (isub ty
+                      (isub ty x (iconst ty (u64_from_imm64 k1)))
+                      (iconst ty (u64_from_imm64 k2))))
+      (isub ty x (iconst ty (imm64_masked ty (u64_add k1 k2)))))
+(rule (simplify (isub ty
+                      (isub ty (iconst ty (u64_from_imm64 k1)) x)
+                      (iconst ty (u64_from_imm64 k2))))
+      (isub ty (iconst ty (imm64_masked ty (u64_sub k1 k2))) x))
+(rule (simplify (isub ty
+                      (iadd ty x (iconst ty (u64_from_imm64 k1)))
+                      (iconst ty (u64_from_imm64 k2))))
+      (isub ty x (iconst ty (imm64_masked ty (u64_sub k2 k1)))))
+(rule (simplify (iadd ty
+                      (isub ty x (iconst ty (u64_from_imm64 k1)))
+                      (iconst ty (u64_from_imm64 k2))))
+      (iadd ty x (iconst ty (imm64_masked ty (u64_sub k2 k1)))))
+(rule (simplify (iadd ty
+                      (isub ty (iconst ty (u64_from_imm64 k1)) x)
+                      (iconst ty (u64_from_imm64 k2))))
+      (isub ty (iconst ty (imm64_masked ty (u64_add k1 k2))) x))
+
+(rule (simplify
+       (imul ty (imul ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
+      (imul ty x (imul ty k1 k2)))
+(rule (simplify
+       (bor ty (bor ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
+      (bor ty x (bor ty k1 k2)))
+(rule (simplify
+       (band ty (band ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
+      (band ty x (band ty k1 k2)))
+(rule (simplify
+       (bxor ty (bxor ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
+      (bxor ty x (bxor ty k1 k2)))
+
+(rule (simplify
+       (select ty (iconst _ (u64_from_imm64 (u64_nonzero _))) x y))
+      x)
+(rule (simplify
+       (select ty (iconst _ (u64_from_imm64 0)) x y))
+      y)
+
+;; TODO: fadd, fsub, fmul, fdiv, fneg, fabs
+
+;; A splat of a constant can become a direct `vconst` with the appropriate bit
+;; pattern.
+(rule (simplify (splat dst (iconst $I8 n)))
+      (vconst dst (splat8 (u64_uextend_imm64 $I8 n))))
+(rule (simplify (splat dst (iconst $I16 n)))
+      (vconst dst (splat16 (u64_uextend_imm64 $I16 n))))
+(rule (simplify (splat dst (iconst $I32 n)))
+      (vconst dst (splat32 (u64_uextend_imm64 $I32 n))))
+(rule (simplify (splat dst (iconst $I64 n)))
+      (vconst dst (splat64 (u64_uextend_imm64 $I64 n))))
+(rule (simplify (splat dst (f32const _ (u32_from_ieee32 n))))
+      (vconst dst (splat32 n)))
+(rule (simplify (splat dst (f64const _ (u64_from_ieee64 n))))
+      (vconst dst (splat64 n)))
+
+(decl splat8 (u64) Constant)
+(rule (splat8 n) (splat16 (u64_or n (u64_shl n 8))))
+(decl splat16 (u64) Constant)
+(rule (splat16 n) (splat32 (u64_or n (u64_shl n 16))))
+(decl splat32 (u64) Constant)
+(rule (splat32 n) (splat64 (u64_or n (u64_shl n 32))))
+(decl splat64 (u64) Constant)
+(extern constructor splat64 splat64)

data/ext/cargo-vendor/cranelift-codegen-0.99.1/src/opts/icmp.isle

@@ -0,0 +1,177 @@
+;; `icmp`-related rewrites
+
+;; `x == x` is always true for integers; `x != x` is false. Strict
+;; inequalities are false, and loose inequalities are true.
+(rule (simplify (eq  (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
+(rule (simplify (ne  (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
+(rule (simplify (ugt (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
+(rule (simplify (uge (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
+(rule (simplify (sgt (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
+(rule (simplify (sge (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
+(rule (simplify (ult (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
+(rule (simplify (ule (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
+(rule (simplify (slt (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
+(rule (simplify (sle (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
+
+;; Optimize icmp-of-icmp.
+(rule (simplify (ne ty
+                      (uextend _ inner @ (icmp ty _ _ _))
+                      (iconst _ (u64_from_imm64 0))))
+      (subsume inner))
+
+(rule (simplify (eq ty
+                      (uextend _ (icmp ty cc x y))
+                      (iconst _ (u64_from_imm64 0))))
+      (subsume (icmp ty (intcc_inverse cc) x y)))
+
+;; Optimize select-of-uextend-of-icmp to select-of-icmp, because
+;; select can take an I8 condition too.
+(rule (simplify
+       (select ty (uextend _ c @ (icmp _ _ _ _)) x y))
+      (select ty c x y))
+(rule (simplify
+       (select ty (uextend _ c @ (icmp _ _ _ _)) x y))
+      (select ty c x y))
+
+;; Masking the result of a comparison with 1 always results in the comparison
+;; itself. Note that comparisons in wasm may sometimes be hidden behind
+;; extensions.
+(rule (simplify
+       (band (ty_int _)
+             cmp @ (icmp _ _ _ _)
+             (iconst _ (u64_from_imm64 1))))
+      cmp)
+(rule (simplify
+       (band (ty_int _)
+             extend @ (uextend _ (icmp _ _ _ _))
+             (iconst _ (u64_from_imm64 1))))
+      extend)
+
+;; Comparisons against largest/smallest signed/unsigned values:
+;; ult(x, 0) == false.
+(rule (simplify (ult (fits_in_64 (ty_int bty)) x zero @ (iconst _ (u64_from_imm64 0))))
+      (subsume (iconst bty (imm64 0))))
+
+;; ule(x, 0) == eq(x, 0)
+(rule (simplify (ule (fits_in_64 (ty_int bty)) x zero @ (iconst _ (u64_from_imm64 0))))
+      (eq bty x zero))
+
+;; ugt(x, 0) == ne(x, 0).
+(rule (simplify (ugt (fits_in_64 (ty_int bty)) x zero @ (iconst _ (u64_from_imm64 0))))
+      (ne bty x zero))
+
+;; uge(x, 0) == true.
+(rule (simplify (uge (fits_in_64 (ty_int bty)) x zero @ (iconst _ (u64_from_imm64 0))))
+      (subsume (iconst bty (imm64 1))))
+
+;; ult(x, UMAX) == ne(x, UMAX).
+(rule (simplify (ult (fits_in_64 (ty_int bty)) x umax @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_umax cty)))
+       (ne bty x umax))
+
+;; ule(x, UMAX) == true.
+(rule (simplify (ule (fits_in_64 (ty_int bty)) x umax @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_umax cty)))
+       (subsume (iconst bty (imm64 1))))
+
+;; ugt(x, UMAX) == false.
+(rule (simplify (ugt (fits_in_64 (ty_int bty)) x umax @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_umax cty)))
+       (subsume (iconst bty (imm64 0))))
+
+;; uge(x, UMAX) == eq(x, UMAX).
+(rule (simplify (uge (fits_in_64 (ty_int bty)) x umax @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_umax cty)))
+       (eq bty x umax))
+
+;; slt(x, SMIN) == false.
+(rule (simplify (slt (fits_in_64 (ty_int bty)) x smin @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_smin cty)))
+       (subsume (iconst bty (imm64 0))))
+
+;; sle(x, SMIN) == eq(x, SMIN).
+(rule (simplify (sle (fits_in_64 (ty_int bty)) x smin @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_smin cty)))
+       (eq bty x smin))
+
+;; sgt(x, SMIN) == ne(x, SMIN).
+(rule (simplify (sgt (fits_in_64 (ty_int bty)) x smin @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_smin cty)))
+       (ne bty x smin))
+
+;; sge(x, SMIN) == true.
+(rule (simplify (sge (fits_in_64 (ty_int bty)) x smin @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_smin cty)))
+       (subsume (iconst bty (imm64 1))))
+
+;; slt(x, SMAX) == ne(x, SMAX).
+(rule (simplify (slt (fits_in_64 (ty_int bty)) x smax @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_smax cty)))
+       (ne bty x smax))
+
+;; sle(x, SMAX) == true.
+(rule (simplify (sle (fits_in_64 (ty_int bty)) x smax @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_smax cty)))
+       (subsume (iconst bty (imm64 1))))
+
+;; sgt(x, SMAX) == false.
+(rule (simplify (sgt (fits_in_64 (ty_int bty)) x smax @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_smax cty)))
+       (subsume (iconst bty (imm64 0))))
+
+;; sge(x, SMAX) == eq(x, SMAX).
+(rule (simplify (sge (fits_in_64 (ty_int bty)) x smax @ (iconst cty (u64_from_imm64 y))))
+       (if-let $true (u64_eq y (ty_smax cty)))
+       (eq bty x smax))
+
+;; `band`/`bor` of 2 comparisons:
+(rule (simplify (band (fits_in_64 ty) (icmp ty cc1 x y) (icmp ty cc2 x y)))
+  (if-let signed (intcc_comparable cc1 cc2))
+  (compose_icmp ty (u64_and (decompose_intcc cc1) (decompose_intcc cc2)) signed x y))
+
+(rule (simplify (bor (fits_in_64 ty) (icmp ty cc1 x y) (icmp ty cc2 x y)))
+  (if-let signed (intcc_comparable cc1 cc2))
+  (compose_icmp ty (u64_or (decompose_intcc cc1) (decompose_intcc cc2)) signed x y))
+
+(decl pure partial intcc_comparable (IntCC IntCC) bool)
+(rule (intcc_comparable x y)
+  (if-let (u64_nonzero class) (u64_and (intcc_class x) (intcc_class y)))
+  (u64_eq 2 class))
+
+(decl pure decompose_intcc (IntCC) u64)
+(rule (decompose_intcc (IntCC.Equal)) 1)
+(rule (decompose_intcc (IntCC.UnsignedLessThan)) 2)
+(rule (decompose_intcc (IntCC.SignedLessThan)) 2)
+(rule (decompose_intcc (IntCC.UnsignedLessThanOrEqual)) 3)
+(rule (decompose_intcc (IntCC.SignedLessThanOrEqual)) 3)
+(rule (decompose_intcc (IntCC.UnsignedGreaterThan)) 4)
+(rule (decompose_intcc (IntCC.SignedGreaterThan)) 4)
+(rule (decompose_intcc (IntCC.UnsignedGreaterThanOrEqual)) 5)
+(rule (decompose_intcc (IntCC.SignedGreaterThanOrEqual)) 5)
+(rule (decompose_intcc (IntCC.NotEqual)) 6)
+
+(decl compose_icmp (Type u64 bool Value Value) Value)
+(rule (compose_icmp ty 0 _ _ _) (subsume (iconst ty (imm64 0))))
+(rule (compose_icmp ty 1 _ x y) (icmp ty (IntCC.Equal) x y))
+(rule (compose_icmp ty 2 $false x y) (icmp ty (IntCC.UnsignedLessThan) x y))
+(rule (compose_icmp ty 2 $true x y) (icmp ty (IntCC.SignedLessThan) x y))
+(rule (compose_icmp ty 3 $false x y) (icmp ty (IntCC.UnsignedLessThanOrEqual) x y))
+(rule (compose_icmp ty 3 $true x y) (icmp ty (IntCC.SignedLessThanOrEqual) x y))
+(rule (compose_icmp ty 4 $false x y) (icmp ty (IntCC.UnsignedGreaterThan) x y))
+(rule (compose_icmp ty 4 $true x y) (icmp ty (IntCC.SignedGreaterThan) x y))
+(rule (compose_icmp ty 5 $false x y) (icmp ty (IntCC.UnsignedGreaterThanOrEqual) x y))
+(rule (compose_icmp ty 5 $true x y) (icmp ty (IntCC.SignedGreaterThanOrEqual) x y))
+(rule (compose_icmp ty 6 _ x y) (icmp ty (IntCC.NotEqual) x y))
+(rule (compose_icmp ty 7 _ _ _) (subsume (iconst ty (imm64 1))))
+
+(decl pure intcc_class (IntCC) u64)
+(rule (intcc_class (IntCC.UnsignedLessThan)) 1)
+(rule (intcc_class (IntCC.UnsignedLessThanOrEqual)) 1)
+(rule (intcc_class (IntCC.UnsignedGreaterThan)) 1)
+(rule (intcc_class (IntCC.UnsignedGreaterThanOrEqual)) 1)
+(rule (intcc_class (IntCC.SignedLessThan)) 2)
+(rule (intcc_class (IntCC.SignedLessThanOrEqual)) 2)
+(rule (intcc_class (IntCC.SignedGreaterThan)) 2)
+(rule (intcc_class (IntCC.SignedGreaterThanOrEqual)) 2)
+(rule (intcc_class (IntCC.Equal)) 3)
+(rule (intcc_class (IntCC.NotEqual)) 3)

data/ext/cargo-vendor/cranelift-codegen-0.99.1/src/value_label.rs

@@ -0,0 +1,32 @@
+use crate::ir::ValueLabel;
+use crate::machinst::Reg;
+use crate::HashMap;
+use alloc::vec::Vec;
+
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Value location range.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct ValueLocRange {
+    /// The ValueLoc containing a ValueLabel during this range.
+    pub loc: LabelValueLoc,
+    /// The start of the range. It is an offset in the generated code.
+    pub start: u32,
+    /// The end of the range. It is an offset in the generated code.
+    pub end: u32,
+}
+
+/// The particular location for a value.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum LabelValueLoc {
+    /// New-backend Reg.
+    Reg(Reg),
+    /// New-backend offset from stack pointer.
+    SPOffset(i64),
+}
+
+/// Resulting map of Value labels and their ranges/locations.
+pub type ValueLabelsRanges = HashMap<ValueLabel, Vec<ValueLocRange>>;

data/ext/cargo-vendor/cranelift-codegen-meta-0.99.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"e57d004bd66cc730200f64e2718c4c09cf9573aeae69b03bf4a7b3993cba8ad7","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"b123f056d0d458396679c5f7f2a16d2762af0258fcda4ac14b6655a95e5a0022","src/cdsl/formats.rs":"3dbbbe2b05ac1df9d88ce8cfafba5a41c485566a6ba9dc6dfcfd71b1b85e85f2","src/cdsl/instructions.rs":"43d84c2cc7b1516d30fc8f60678623e887f2aa7758703ce798dd93345573f6c4","src/cdsl/isa.rs":"fbb5848baea534584ec113fab8d13015b80b125392e86cad0c91e14f746c038c","src/cdsl/mod.rs":"7faf3c1159b05a11aba71bd791dba544423a3e765f5d016f9bb225263edb039d","src/cdsl/operands.rs":"f531120b794e9a79e24a24212ad55a999f02be41af4cea788042ba562c109ecf","src/cdsl/settings.rs":"974e91afbd5e24282b5f0deb3a1349f131a7efb9544e0ca2e4c7c7ef905ba160","src/cdsl/types.rs":"720b8bd81704938fc0e5980f17fce56ff8e46f8bae561138d183c7dc4e1cab31","src/cdsl/typevar.rs":"76b8f16116c7ebabcda41899540f122fdd6aaca080f32b85cc82a5c1c184340f","src/constant_hash.rs":"5c7ae3d6d2f7d436a8ed2c2287e7efbaba3d06f26ec24b61c0ed2eeb9fa3a0a9","src/error.rs":"e9b11b2feb2d867b94c8810fdc5a6c4e0d9131604a0bfa5340ff2639a55100b4","src/gen_inst.rs":"ba47a337b12decb2fe3a5728964b9d05e36133bb1b4c257e8afff24f0080cc75","src/gen_settings.rs":"c94c120bc3ebf153906da00e06d94a57e7af45e852a5c16978bbcfa9374de0fb","src/gen_types.rs":"d302614e051e04bb1d4d3172331adfaebd89285e1b06497ff7a58de7510420b2","src/isa/arm64.rs":"2d5d6c1871155fbba7a7032b92bc39eb43e0082a109d530eb32f415723412003","src/isa/mod.rs":"396ec4c885ef0d7c101abdb33724795a01b1182031f05590ee6066594263afd4","src/isa/riscv64.rs":"83367c2bbb8614c9cb533929bd0eb2243edcf8cd1c7529aeae48acb6757edf77","src/isa/s390x.rs":"54ed76179d0696d6244720666685336b90e318be848dc32217ccc16a28a40490","src/isa/x86.rs":"2ee5446ec06757231a0250fd3f13708064b05b60e92aaba40f12d8854b7d53f3","src/lib.rs":"dbeb6e2ecebe97a2f1fd227f487309fc6949ce30f1f3cc6f240a79e2614a2dd7","src/shared/entities.rs":"ec671951c8fe6e967517c96be51267e63fc7ee51b4e76aedb9f4552c7e873cb8","src/shared/formats.rs":"dffac49e20af150900210520908d7b80b5e8968730f1476d180639844f67c032","src/shared/immediates.rs":"97670f2799df2bc5cc121cc182a7ddcc944a40c001a790af905e79eafcd00fff","src/shared/instructions.rs":"a19ee0d0bcc50bd6870d69ccd3e50203c8be488dadf38674d2197689b3555e86","src/shared/mod.rs":"df8a1ab3ccd3d31e44dc06c72de7c5f4ffe115fc81db8035f587431e38395f89","src/shared/settings.rs":"2c72524613766476a4eba77756dcb4662e837b6b87ba1e3f789ea62a8541eeee","src/shared/types.rs":"bad3d2b305610e3f1000f3a7700c9347c10ddb75040eccebf9f952525a09f4d4","src/srcgen.rs":"a758e8d9302fc8c367792588e298a959bbd7882b8a89e7de264e050e1368912c","src/unique_table.rs":"d804720d23d3db4cc8630fd3975dbde13dcd111137e98513c950ad3618ce1168"},"package":"a3de51da572e65cb712a47b7413c50208cac61a4201560038de929d9a7f4fadf"}

data/ext/cargo-vendor/cranelift-codegen-meta-0.99.1/Cargo.toml

@@ -0,0 +1,26 @@
+# 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-meta"
+version = "0.99.1"
+authors = ["The Cranelift Project Developers"]
+description = "Metaprogram for cranelift-codegen code generator library"
+readme = "README.md"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[package.metadata.docs.rs]
+rustdoc-args = ["--document-private-items"]
+
+[dependencies.cranelift-codegen-shared]
+version = "0.99.1"