wasmtime 17.0.0 → 17.0.1

data/ext/cargo-vendor/{cranelift-codegen-0.104.0 → cranelift-codegen-0.104.1}/src/egraph/cost.rs

@@ -74,7 +74,7 @@ impl Cost {
     const DEPTH_BITS: u8 = 8;
     const DEPTH_MASK: u32 = (1 << Self::DEPTH_BITS) - 1;
     const OP_COST_MASK: u32 = !Self::DEPTH_MASK;
-    const MAX_OP_COST: u32 = (Self::OP_COST_MASK >> Self::DEPTH_BITS) - 1;
+    const MAX_OP_COST: u32 = Self::OP_COST_MASK >> Self::DEPTH_BITS;
 
     pub(crate) fn infinity() -> Cost {
         // 2^32 - 1 is, uh, pretty close to infinite... (we use `Cost`
@@ -86,14 +86,16 @@ impl Cost {
         Cost(0)
     }
 
-    /// Construct a new finite cost from the given parts.
+    /// Construct a new `Cost` from the given parts.
     ///
-    /// The opcode cost is clamped to the maximum value representable.
-    fn new_finite(opcode_cost: u32, depth: u8) -> Cost {
-        let opcode_cost = std::cmp::min(opcode_cost, Self::MAX_OP_COST);
-        let cost = Cost((opcode_cost << Self::DEPTH_BITS) | u32::from(depth));
-        debug_assert_ne!(cost, Cost::infinity());
-        cost
+    /// If the opcode cost is greater than or equal to the maximum representable
+    /// opcode cost, then the resulting `Cost` saturates to infinity.
+    fn new(opcode_cost: u32, depth: u8) -> Cost {
+        if opcode_cost >= Self::MAX_OP_COST {
+            Self::infinity()
+        } else {
+            Cost(opcode_cost << Self::DEPTH_BITS | u32::from(depth))
+        }
     }
 
     fn depth(&self) -> u8 {
@@ -111,7 +113,7 @@ impl Cost {
     /// that satisfies `inst_predicates::is_pure_for_egraph()`.
     pub(crate) fn of_pure_op(op: Opcode, operand_costs: impl IntoIterator<Item = Self>) -> Self {
         let c = pure_op_cost(op) + operand_costs.into_iter().sum();
-        Cost::new_finite(c.op_cost(), c.depth().saturating_add(1))
+        Cost::new(c.op_cost(), c.depth().saturating_add(1))
     }
 }
 
@@ -131,12 +133,9 @@ impl std::ops::Add<Cost> for Cost {
     type Output = Cost;
 
     fn add(self, other: Cost) -> Cost {
-        let op_cost = std::cmp::min(
-            self.op_cost().saturating_add(other.op_cost()),
-            Self::MAX_OP_COST,
-        );
+        let op_cost = self.op_cost().saturating_add(other.op_cost());
         let depth = std::cmp::max(self.depth(), other.depth());
-        Cost::new_finite(op_cost, depth)
+        Cost::new(op_cost, depth)
     }
 }
 
@@ -147,11 +146,11 @@ impl std::ops::Add<Cost> for Cost {
 fn pure_op_cost(op: Opcode) -> Cost {
     match op {
         // Constants.
-        Opcode::Iconst | Opcode::F32const | Opcode::F64const => Cost::new_finite(1, 0),
+        Opcode::Iconst | Opcode::F32const | Opcode::F64const => Cost::new(1, 0),
 
         // Extends/reduces.
         Opcode::Uextend | Opcode::Sextend | Opcode::Ireduce | Opcode::Iconcat | Opcode::Isplit => {
-            Cost::new_finite(2, 0)
+            Cost::new(2, 0)
         }
 
         // "Simple" arithmetic.
@@ -163,9 +162,52 @@ fn pure_op_cost(op: Opcode) -> Cost {
         | Opcode::Bnot
         | Opcode::Ishl
         | Opcode::Ushr
-        | Opcode::Sshr => Cost::new_finite(3, 0),
+        | Opcode::Sshr => Cost::new(3, 0),
 
         // Everything else (pure.)
-        _ => Cost::new_finite(4, 0),
+        _ => Cost::new(4, 0),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn add_cost() {
+        let a = Cost::new(5, 2);
+        let b = Cost::new(37, 3);
+        assert_eq!(a + b, Cost::new(42, 3));
+        assert_eq!(b + a, Cost::new(42, 3));
+    }
+
+    #[test]
+    fn add_infinity() {
+        let a = Cost::new(5, 2);
+        let b = Cost::infinity();
+        assert_eq!(a + b, Cost::infinity());
+        assert_eq!(b + a, Cost::infinity());
+    }
+
+    #[test]
+    fn op_cost_saturates_to_infinity() {
+        let a = Cost::new(Cost::MAX_OP_COST - 10, 2);
+        let b = Cost::new(11, 2);
+        assert_eq!(a + b, Cost::infinity());
+        assert_eq!(b + a, Cost::infinity());
+    }
+
+    #[test]
+    fn depth_saturates_to_max_depth() {
+        let a = Cost::new(10, u8::MAX);
+        let b = Cost::new(10, 1);
+        assert_eq!(
+            Cost::of_pure_op(Opcode::Iconst, [a, b]),
+            Cost::new(21, u8::MAX)
+        );
+        assert_eq!(
+            Cost::of_pure_op(Opcode::Iconst, [b, a]),
+            Cost::new(21, u8::MAX)
+        );
     }
 }

data/ext/cargo-vendor/{cranelift-codegen-0.104.0 → cranelift-codegen-0.104.1}/src/egraph/elaborate.rs

@@ -7,6 +7,7 @@ use super::Stats;
 use crate::dominator_tree::DominatorTree;
 use crate::fx::{FxHashMap, FxHashSet};
 use crate::hash_map::Entry as HashEntry;
+use crate::inst_predicates::is_pure_for_egraph;
 use crate::ir::{Block, Function, Inst, Value, ValueDef};
 use crate::loop_analysis::{Loop, LoopAnalysis};
 use crate::scoped_hash_map::ScopedHashMap;
@@ -216,46 +217,112 @@ impl<'a> Elaborator<'a> {
 
     fn compute_best_values(&mut self) {
         let best = &mut self.value_to_best_value;
-        for (value, def) in self.func.dfg.values_and_defs() {
-            trace!("computing best for value {:?} def {:?}", value, def);
-            match def {
-                ValueDef::Union(x, y) => {
-                    // Pick the best of the two options based on
-                    // min-cost. This works because each element of `best`
-                    // is a `(cost, value)` tuple; `cost` comes first so
-                    // the natural comparison works based on cost, and
-                    // breaks ties based on value number.
-                    trace!(" -> best of {:?} and {:?}", best[x], best[y]);
-                    best[value] = std::cmp::min(best[x], best[y]);
-                    trace!(" -> {:?}", best[value]);
-                }
-                ValueDef::Param(_, _) => {
-                    best[value] = BestEntry(Cost::zero(), value);
-                }
-                // If the Inst is inserted into the layout (which is,
-                // at this point, only the side-effecting skeleton),
-                // then it must be computed and thus we give it zero
-                // cost.
-                ValueDef::Result(inst, _) => {
-                    if let Some(_) = self.func.layout.inst_block(inst) {
-                        best[value] = BestEntry(Cost::zero(), value);
-                    } else {
-                        trace!(" -> value {}: result, computing cost", value);
-                        let inst_data = &self.func.dfg.insts[inst];
-                        // N.B.: at this point we know that the opcode is
-                        // pure, so `pure_op_cost`'s precondition is
-                        // satisfied.
-                        let cost = Cost::of_pure_op(
-                            inst_data.opcode(),
-                            self.func.dfg.inst_values(inst).map(|value| best[value].0),
+
+        // Do a fixpoint loop to compute the best value for each eclass.
+        //
+        // The maximum number of iterations is the length of the longest chain
+        // of `vNN -> vMM` edges in the dataflow graph where `NN < MM`, so this
+        // is *technically* quadratic, but `cranelift-frontend` won't construct
+        // any such edges. NaN canonicalization will introduce some of these
+        // edges, but they are chains of only two or three edges. So in
+        // practice, we *never* do more than a handful of iterations here unless
+        // (a) we parsed the CLIF from text and the text was funkily numbered,
+        // which we don't really care about, or (b) the CLIF producer did
+        // something weird, in which case it is their responsibility to stop
+        // doing that.
+        trace!("Entering fixpoint loop to compute the best values for each eclass");
+        let mut keep_going = true;
+        while keep_going {
+            keep_going = false;
+            trace!(
+                "fixpoint iteration {}",
+                self.stats.elaborate_best_cost_fixpoint_iters
+            );
+            self.stats.elaborate_best_cost_fixpoint_iters += 1;
+
+            for (value, def) in self.func.dfg.values_and_defs() {
+                trace!("computing best for value {:?} def {:?}", value, def);
+                let orig_best_value = best[value];
+
+                match def {
+                    ValueDef::Union(x, y) => {
+                        // Pick the best of the two options based on
+                        // min-cost. This works because each element of `best`
+                        // is a `(cost, value)` tuple; `cost` comes first so
+                        // the natural comparison works based on cost, and
+                        // breaks ties based on value number.
+                        best[value] = std::cmp::min(best[x], best[y]);
+                        trace!(
+                            " -> best of union({:?}, {:?}) = {:?}",
+                            best[x],
+                            best[y],
+                            best[value]
                         );
-                        best[value] = BestEntry(cost, value);
                     }
-                }
-            };
-            debug_assert_ne!(best[value].0, Cost::infinity());
-            debug_assert_ne!(best[value].1, Value::reserved_value());
-            trace!("best for eclass {:?}: {:?}", value, best[value]);
+                    ValueDef::Param(_, _) => {
+                        best[value] = BestEntry(Cost::zero(), value);
+                    }
+                    // If the Inst is inserted into the layout (which is,
+                    // at this point, only the side-effecting skeleton),
+                    // then it must be computed and thus we give it zero
+                    // cost.
+                    ValueDef::Result(inst, _) => {
+                        if let Some(_) = self.func.layout.inst_block(inst) {
+                            best[value] = BestEntry(Cost::zero(), value);
+                        } else {
+                            let inst_data = &self.func.dfg.insts[inst];
+                            // N.B.: at this point we know that the opcode is
+                            // pure, so `pure_op_cost`'s precondition is
+                            // satisfied.
+                            let cost = Cost::of_pure_op(
+                                inst_data.opcode(),
+                                self.func.dfg.inst_values(inst).map(|value| best[value].0),
+                            );
+                            best[value] = BestEntry(cost, value);
+                            trace!(" -> cost of value {} = {:?}", value, cost);
+                        }
+                    }
+                };
+
+                // Keep on iterating the fixpoint loop while we are finding new
+                // best values.
+                keep_going |= orig_best_value != best[value];
+            }
+        }
+
+        if cfg!(any(feature = "trace-log", debug_assertions)) {
+            trace!("finished fixpoint loop to compute best value for each eclass");
+            for value in self.func.dfg.values() {
+                trace!("-> best for eclass {:?}: {:?}", value, best[value]);
+                debug_assert_ne!(best[value].1, Value::reserved_value());
+                // You might additionally be expecting an assert that the best
+                // cost is not infinity, however infinite cost *can* happen in
+                // practice. First, note that our cost function doesn't know
+                // about any shared structure in the dataflow graph, it only
+                // sums operand costs. (And trying to avoid that by deduping a
+                // single operation's operands is a losing game because you can
+                // always just add one indirection and go from `add(x, x)` to
+                // `add(foo(x), bar(x))` to hide the shared structure.) Given
+                // that blindness to sharing, we can make cost grow
+                // exponentially with a linear sequence of operations:
+                //
+                //     v0 = iconst.i32 1    ;; cost = 1
+                //     v1 = iadd v0, v0     ;; cost = 3 + 1 + 1
+                //     v2 = iadd v1, v1     ;; cost = 3 + 5 + 5
+                //     v3 = iadd v2, v2     ;; cost = 3 + 13 + 13
+                //     v4 = iadd v3, v3     ;; cost = 3 + 29 + 29
+                //     v5 = iadd v4, v4     ;; cost = 3 + 61 + 61
+                //     v6 = iadd v5, v5     ;; cost = 3 + 125 + 125
+                //     ;; etc...
+                //
+                // Such a chain can cause cost to saturate to infinity. How do
+                // we choose which e-node is best when there are multiple that
+                // have saturated to infinity? It doesn't matter. As long as
+                // invariant (2) for optimization rules is upheld by our rule
+                // set (see `cranelift/codegen/src/opts/README.md`) it is safe
+                // to choose *any* e-node in the e-class. At worst we will
+                // produce suboptimal code, but never an incorrectness.
+            }
         }
     }
 
@@ -606,7 +673,13 @@ impl<'a> Elaborator<'a> {
                         }
                         inst
                     };
+
                     // Place the inst just before `before`.
+                    debug_assert!(
+                        is_pure_for_egraph(self.func, inst),
+                        "something has gone very wrong if we are elaborating effectful \
+                         instructions, they should have remained in the skeleton"
+                    );
                     self.func.layout.insert_inst(inst, before);
 
                     // Update the inst's arguments.

data/ext/cargo-vendor/{cranelift-codegen-0.104.0 → cranelift-codegen-0.104.1}/src/egraph.rs

@@ -700,4 +700,5 @@ pub(crate) struct Stats {
     pub(crate) elaborate_func: u64,
     pub(crate) elaborate_func_pre_insts: u64,
     pub(crate) elaborate_func_post_insts: u64,
+    pub(crate) elaborate_best_cost_fixpoint_iters: u64,
 }

data/ext/cargo-vendor/cranelift-codegen-0.104.1/src/opts/README.md

@@ -0,0 +1,87 @@
+# Rules for Writing Optimization Rules
+
+For both correctness and compile speed, we must be careful with our rules. A lot
+of it boils down to the fact that, unlike traditional e-graphs, our rules are
+*directional*.
+
+1. Rules should not rewrite to worse code: the right-hand side should be at
+   least as good as the left-hand side or better.
+
+   For example, the rule
+
+       x => (add x 0)
+
+   is disallowed, but swapping its left- and right-hand sides produces a rule
+   that is allowed.
+
+   Any kind of canonicalizing rule that intends to help subsequent rules match
+   and unlock further optimizations (e.g. floating constants to the right side
+   for our constant-propagation rules to match) must produce canonicalized
+   output that is no worse than its noncanonical input.
+
+   We assume this invariant as a heuristic to break ties between two
+   otherwise-equal-cost expressions in various places, making up for some
+   limitations of our explicit cost function.
+
+2. Any rule that removes value-uses in its right-hand side that previously
+   existed in its left-hand side MUST use `subsume`.
+
+   For example, the rule
+
+       (select 1 x y) => x
+
+   MUST use `subsume`.
+
+   This is required for correctness because, once a value-use is removed, some
+   e-nodes in the e-class are more equal than others. There might be uses of `x`
+   in a scope where `y` is not available, and so emitting `(select 1 x y)` in
+   place of `x` in such cases would introduce uses of `y` where it is not
+   defined.
+
+   An exception to this rule is discarding constants, as they can be
+   rematerialized anywhere without introducing correctness issues. For example,
+   the (admittedly silly) rule `(select 1 x (iconst_u _)) => x` would be a good
+   candidate for not using `subsume`, as it does not discard any non-constant
+   values introduced in its LHS.
+
+3. Avoid overly general rewrites like commutativity and associativity. Instead,
+   prefer targeted instances of the rewrite (for example, canonicalizing adds
+   where one operand is a constant such that the constant is always the add's
+   second operand, rather than general commutativity for adds) or even writing
+   the "same" optimization rule multiple times.
+
+   For example, the commutativity in the first rule in the following snippet is
+   bad because it will match even when the first operand is not an add:
+
+       ;; Commute to allow `(foo (add ...) x)`, when we see it, to match.
+       (foo x y) => (foo y x)
+
+       ;; Optimize.
+       (foo x (add ...)) => (bar x)
+
+   Better is to commute only when we know that canonicalizing in this way will
+   all definitely allow the subsequent optimization rule to match:
+
+       ;; Canonicalize all adds to `foo`'s second operand.
+       (foo (add ...) x) => (foo x (add ...))
+
+       ;; Optimize.
+       (foo x (add ...)) => (bar x)
+
+   But even better in this case is to write the "same" optimization multiple
+   times:
+
+       (foo (add ...) x) => (bar x)
+       (foo x (add ...)) => (bar x)
+
+   The cost of rule-matching is amortized by the ISLE compiler, where as the
+   intermediate result of each rewrite allocates new e-nodes and requires
+   storage in the dataflow graph. Therefore, additional rules are cheaper than
+   additional e-nodes.
+
+   Commutativity and associativity in particular can cause huge amounts of
+   e-graph bloat.
+
+   One day we intend to extend ISLE with built-in support for commutativity, so
+   we don't need to author the redundant commutations ourselves:
+   https://github.com/bytecodealliance/wasmtime/issues/6128

data/ext/cargo-vendor/{cranelift-codegen-0.104.0 → cranelift-codegen-0.104.1}/src/opts/cprop.isle

@@ -167,12 +167,10 @@
        (bxor ty (bxor ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
       (bxor ty x (bxor ty k1 k2)))
 
-(rule (simplify
-       (select ty (iconst_u _ (u64_nonzero _)) x y))
-      x)
-(rule (simplify
-       (select ty (iconst_u _ 0) x y))
-      y)
+(rule (simplify (select ty (iconst_u _ (u64_nonzero _)) x _))
+      (subsume x))
+(rule (simplify (select ty (iconst_u _ 0) _ y))
+      (subsume y))
 
 ;; Replace subtraction by a "negative" constant with addition.
 ;; Notably, this gives `x - (-1) == x + 1`, so other patterns don't have to

data/ext/cargo-vendor/{cranelift-codegen-0.104.0 → cranelift-codegen-0.104.1}/src/opts/extends.isle

@@ -29,12 +29,12 @@
        (slt ty
              (uextend $I64 x @ (value_type $I32))
              (iconst_u _ 0)))
-      (iconst_u ty 0))
+      (subsume (iconst_u ty 0)))
 (rule (simplify
        (sge ty
              (uextend $I64 x @ (value_type $I32))
              (iconst_u _ 0)))
-      (iconst_u ty 1))
+      (subsume (iconst_u ty 1)))
 
 ;; Sign-extending can't change whether a number is zero nor how it signed-compares to zero
 (rule (simplify (eq _ (sextend _ x@(value_type ty)) (iconst_s _ 0)))
@@ -77,18 +77,26 @@
 
 ;; Matches values where `ireducing` them will not actually introduce another
 ;; instruction, since other rules will collapse them with the reduction.
-(decl pure multi will_simplify_with_ireduce (Value) Value)
-(rule (will_simplify_with_ireduce x@(uextend _ _)) x)
-(rule (will_simplify_with_ireduce x@(sextend _ _)) x)
-(rule (will_simplify_with_ireduce x@(iconst _ _)) x)
-(rule (will_simplify_with_ireduce x@(unary_op _ _ a))
-      (if-let _ (will_simplify_with_ireduce a))
+(decl pure multi will_simplify_with_ireduce_rec (u8 Value) Value)
+(rule (will_simplify_with_ireduce_rec _ x@(uextend _ _)) x)
+(rule (will_simplify_with_ireduce_rec _ x@(sextend _ _)) x)
+(rule (will_simplify_with_ireduce_rec _ x@(iconst _ _)) x)
+(rule (will_simplify_with_ireduce_rec depth x@(unary_op _ _ a))
+      (if-let _ (u8_lt 0 depth))
+      (if-let _ (reducible_modular_op x))
+      (if-let _ (will_simplify_with_ireduce_rec (u8_sub depth 1) a))
       x)
-(rule (will_simplify_with_ireduce x@(binary_op _ _ a b))
-      (if-let _ (will_simplify_with_ireduce a))
-      (if-let _ (will_simplify_with_ireduce b))
+(rule (will_simplify_with_ireduce_rec depth x@(binary_op _ _ a b))
+      (if-let _ (u8_lt 0 depth))
+      (if-let _ (reducible_modular_op x))
+      (if-let _ (will_simplify_with_ireduce_rec (u8_sub depth 1) a))
+      (if-let _ (will_simplify_with_ireduce_rec (u8_sub depth 1) b))
       x)
 
+(decl pure multi will_simplify_with_ireduce (Value) Value)
+(rule (will_simplify_with_ireduce x)
+      (will_simplify_with_ireduce_rec 2 x))
+
 ;; Matches values where the high bits of the input don't affect lower bits of
 ;; the output, and thus the inputs can be reduced before the operation rather
 ;; than doing the wide operation then reducing afterwards.

data/ext/cargo-vendor/{cranelift-codegen-0.104.0 → cranelift-codegen-0.104.1}/src/opts/icmp.isle

@@ -2,16 +2,16 @@
 
 ;; `x == x` is always true for integers; `x != x` is false. Strict
 ;; inequalities are false, and loose inequalities are true.
-(rule (simplify (eq  (ty_int ty) x x)) (iconst_u ty 1))
-(rule (simplify (ne  (ty_int ty) x x)) (iconst_u ty 0))
-(rule (simplify (ugt (ty_int ty) x x)) (iconst_u ty 0))
-(rule (simplify (uge (ty_int ty) x x)) (iconst_u ty 1))
-(rule (simplify (sgt (ty_int ty) x x)) (iconst_u ty 0))
-(rule (simplify (sge (ty_int ty) x x)) (iconst_u ty 1))
-(rule (simplify (ult (ty_int ty) x x)) (iconst_u ty 0))
-(rule (simplify (ule (ty_int ty) x x)) (iconst_u ty 1))
-(rule (simplify (slt (ty_int ty) x x)) (iconst_u ty 0))
-(rule (simplify (sle (ty_int ty) x x)) (iconst_u ty 1))
+(rule (simplify (eq  (ty_int ty) x x)) (subsume (iconst_u ty 1)))
+(rule (simplify (ne  (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (ugt (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (uge (ty_int ty) x x)) (subsume (iconst_u ty 1)))
+(rule (simplify (sgt (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (sge (ty_int ty) x x)) (subsume (iconst_u ty 1)))
+(rule (simplify (ult (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (ule (ty_int ty) x x)) (subsume (iconst_u ty 1)))
+(rule (simplify (slt (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (sle (ty_int ty) x x)) (subsume (iconst_u ty 1)))
 
 ;; Optimize icmp-of-icmp.
 (rule (simplify (ne ty

data/ext/cargo-vendor/{cranelift-codegen-meta-0.104.0 → cranelift-codegen-meta-0.104.1}/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{"Cargo.toml":"0fe5edc24c7df8b7400fd05b72c265c59691c213aff4640d10300cd3350f0810","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":"7f21c124e58286bf5239bba064c3f1bdd76ba95f27c2f6c82ffff1ec54f46274","src/error.rs":"e9b11b2feb2d867b94c8810fdc5a6c4e0d9131604a0bfa5340ff2639a55100b4","src/gen_inst.rs":"b9c892d569ec028a524a10cb1a05429f485543e7e92470a16ff2d786d8cc38d7","src/gen_settings.rs":"c94c120bc3ebf153906da00e06d94a57e7af45e852a5c16978bbcfa9374de0fb","src/gen_types.rs":"d302614e051e04bb1d4d3172331adfaebd89285e1b06497ff7a58de7510420b2","src/isa/arm64.rs":"2d5d6c1871155fbba7a7032b92bc39eb43e0082a109d530eb32f415723412003","src/isa/mod.rs":"396ec4c885ef0d7c101abdb33724795a01b1182031f05590ee6066594263afd4","src/isa/riscv64.rs":"13e15154acdc736df3823d68ff7473746be40f7bb1a07c1b9da29caccec08186","src/isa/s390x.rs":"54ed76179d0696d6244720666685336b90e318be848dc32217ccc16a28a40490","src/isa/x86.rs":"686a85196dceaf3efdff88c4b7546d5f50406b9d86fb109f354a6b3ce33a2106","src/lib.rs":"dbeb6e2ecebe97a2f1fd227f487309fc6949ce30f1f3cc6f240a79e2614a2dd7","src/shared/entities.rs":"ec671951c8fe6e967517c96be51267e63fc7ee51b4e76aedb9f4552c7e873cb8","src/shared/formats.rs":"dffac49e20af150900210520908d7b80b5e8968730f1476d180639844f67c032","src/shared/immediates.rs":"9db6a6933a78e4810b326024d0ab879f83e989e044f617b0882841c2556f4a78","src/shared/instructions.rs":"83d6d55d16e5ea9ee913387c813e662a6d9320002f1867c6b9518e27491b2ea4","src/shared/mod.rs":"df8a1ab3ccd3d31e44dc06c72de7c5f4ffe115fc81db8035f587431e38395f89","src/shared/settings.rs":"1392d9d93c156b7ef00cf4439c49b2df14d45b05956b67c2622005125ad60f9a","src/shared/types.rs":"bad3d2b305610e3f1000f3a7700c9347c10ddb75040eccebf9f952525a09f4d4","src/srcgen.rs":"a758e8d9302fc8c367792588e298a959bbd7882b8a89e7de264e050e1368912c","src/unique_table.rs":"d804720d23d3db4cc8630fd3975dbde13dcd111137e98513c950ad3618ce1168"},"package":"a3fd3664e38e51649b17dc30cfdd561273fe2f590dcd013fb75d9eabc6272dfb"}
+{"files":{"Cargo.toml":"ff4bae59bd77acb59c61e8300c4832e2217547494204e80bbfe22b1dd3a914da","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":"7f21c124e58286bf5239bba064c3f1bdd76ba95f27c2f6c82ffff1ec54f46274","src/error.rs":"e9b11b2feb2d867b94c8810fdc5a6c4e0d9131604a0bfa5340ff2639a55100b4","src/gen_inst.rs":"b9c892d569ec028a524a10cb1a05429f485543e7e92470a16ff2d786d8cc38d7","src/gen_settings.rs":"c94c120bc3ebf153906da00e06d94a57e7af45e852a5c16978bbcfa9374de0fb","src/gen_types.rs":"d302614e051e04bb1d4d3172331adfaebd89285e1b06497ff7a58de7510420b2","src/isa/arm64.rs":"2d5d6c1871155fbba7a7032b92bc39eb43e0082a109d530eb32f415723412003","src/isa/mod.rs":"396ec4c885ef0d7c101abdb33724795a01b1182031f05590ee6066594263afd4","src/isa/riscv64.rs":"13e15154acdc736df3823d68ff7473746be40f7bb1a07c1b9da29caccec08186","src/isa/s390x.rs":"54ed76179d0696d6244720666685336b90e318be848dc32217ccc16a28a40490","src/isa/x86.rs":"686a85196dceaf3efdff88c4b7546d5f50406b9d86fb109f354a6b3ce33a2106","src/lib.rs":"dbeb6e2ecebe97a2f1fd227f487309fc6949ce30f1f3cc6f240a79e2614a2dd7","src/shared/entities.rs":"ec671951c8fe6e967517c96be51267e63fc7ee51b4e76aedb9f4552c7e873cb8","src/shared/formats.rs":"dffac49e20af150900210520908d7b80b5e8968730f1476d180639844f67c032","src/shared/immediates.rs":"9db6a6933a78e4810b326024d0ab879f83e989e044f617b0882841c2556f4a78","src/shared/instructions.rs":"83d6d55d16e5ea9ee913387c813e662a6d9320002f1867c6b9518e27491b2ea4","src/shared/mod.rs":"df8a1ab3ccd3d31e44dc06c72de7c5f4ffe115fc81db8035f587431e38395f89","src/shared/settings.rs":"1392d9d93c156b7ef00cf4439c49b2df14d45b05956b67c2622005125ad60f9a","src/shared/types.rs":"bad3d2b305610e3f1000f3a7700c9347c10ddb75040eccebf9f952525a09f4d4","src/srcgen.rs":"a758e8d9302fc8c367792588e298a959bbd7882b8a89e7de264e050e1368912c","src/unique_table.rs":"d804720d23d3db4cc8630fd3975dbde13dcd111137e98513c950ad3618ce1168"},"package":"bc7e74aed5c2b91e38d090653506afbd2cd3be1ff70593e2aa6bb82b3c6b77ff"}

data/ext/cargo-vendor/{cranelift-codegen-meta-0.104.0 → cranelift-codegen-meta-0.104.1}/Cargo.toml

@@ -12,7 +12,7 @@
 [package]
 edition = "2021"
 name = "cranelift-codegen-meta"
-version = "0.104.0"
+version = "0.104.1"
 authors = ["The Cranelift Project Developers"]
 description = "Metaprogram for cranelift-codegen code generator library"
 readme = "README.md"
@@ -23,7 +23,7 @@ repository = "https://github.com/bytecodealliance/wasmtime"
 rustdoc-args = ["--document-private-items"]
 
 [dependencies.cranelift-codegen-shared]
-version = "0.104.0"
+version = "0.104.1"
 
 [lints.clippy]
 all = "allow"

data/ext/cargo-vendor/{cranelift-codegen-shared-0.104.0 → cranelift-codegen-shared-0.104.1}/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{"Cargo.toml":"033ca47747826c21ec09eed8b2bdd92fdb60e24a78f6e9c3a428bc968bc2b8f2","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"a410bc2f5dcbde499c0cd299c2620bc8111e3c5b3fccdd9e2d85caf3c24fdab3","src/constant_hash.rs":"4dc1a4e6f31a2f25d41fc7ee4ed2ae94563a090cdc77d7bbd972aa4098bd4f01","src/constants.rs":"401059f8958896c29edfcaacc3f5cb32adcdf28710142c867a5cb37e8eae3f14","src/lib.rs":"317c5fad6b13ad2ef5b4fe5ac45a45e776dda246f293fe9f7f1248096ddfaedd"},"package":"4b031ec5e605828975952622b5a77d49126f20ffe88d33719a0af66b23a0fc36"}
+{"files":{"Cargo.toml":"c82777ece3779e8891583b64ee1765886ba376071c4c87c8e0f0bf7a0a2f1de2","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"a410bc2f5dcbde499c0cd299c2620bc8111e3c5b3fccdd9e2d85caf3c24fdab3","src/constant_hash.rs":"4dc1a4e6f31a2f25d41fc7ee4ed2ae94563a090cdc77d7bbd972aa4098bd4f01","src/constants.rs":"401059f8958896c29edfcaacc3f5cb32adcdf28710142c867a5cb37e8eae3f14","src/lib.rs":"317c5fad6b13ad2ef5b4fe5ac45a45e776dda246f293fe9f7f1248096ddfaedd"},"package":"9ff2dd24cce0775566da85770cb48aa58fef901cf2bff30275b42e7dbe62cbd5"}

data/ext/cargo-vendor/{cranelift-codegen-shared-0.104.0 → cranelift-codegen-shared-0.104.1}/Cargo.toml

@@ -12,7 +12,7 @@
 [package]
 edition = "2021"
 name = "cranelift-codegen-shared"
-version = "0.104.0"
+version = "0.104.1"
 authors = ["The Cranelift Project Developers"]
 description = "For code shared between cranelift-codegen-meta and cranelift-codegen"
 readme = "README.md"

data/ext/cargo-vendor/{cranelift-control-0.104.0 → cranelift-control-0.104.1}/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{"Cargo.toml":"51a99db3d84e1869caa9f45da6e53936ff252ab3ceb5bc648587865f1ee1b258","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"9266e3c8ff78a0f5948eb24292a2b51ec272d9417816ffe23de0b1ea4589acb4","src/chaos.rs":"2249bbd902abb610258e8a0545e4ce3d526ea4f29f04aa4724195cd2d7ee28a3","src/lib.rs":"4da5d01c3d43954437288a96f8842f11f01431d99fbf4a7210e9bb71b56393dc","src/zero_sized.rs":"4f970663f3502a2644162033aaf6a7b65336e3e1a9b064737f5cace89636e556"},"package":"fada054d017cf2ed8f7ed2336e0517fc1b19e6825be1790de9eb00c94788362b"}
+{"files":{"Cargo.toml":"9b45da325b547228256f016c14d15538cb9cf5f41ab90b21c1f105dea311dbc4","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"9266e3c8ff78a0f5948eb24292a2b51ec272d9417816ffe23de0b1ea4589acb4","src/chaos.rs":"2249bbd902abb610258e8a0545e4ce3d526ea4f29f04aa4724195cd2d7ee28a3","src/lib.rs":"4da5d01c3d43954437288a96f8842f11f01431d99fbf4a7210e9bb71b56393dc","src/zero_sized.rs":"4f970663f3502a2644162033aaf6a7b65336e3e1a9b064737f5cace89636e556"},"package":"e8bcf4d5c73bbca309edf3af2839b5218e5c74cfbf22b0ac492af8a1d11120d9"}

data/ext/cargo-vendor/{cranelift-control-0.104.0 → cranelift-control-0.104.1}/Cargo.toml

@@ -12,7 +12,7 @@
 [package]
 edition = "2021"
 name = "cranelift-control"
-version = "0.104.0"
+version = "0.104.1"
 authors = ["The Cranelift Project Developers"]
 description = "White-box fuzz testing framework"
 readme = "README.md"

data/ext/cargo-vendor/{cranelift-entity-0.104.0 → cranelift-entity-0.104.1}/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{"Cargo.toml":"f830c513fc7088b1cadd6970bf322bf2bedaaa5e4c5264a195e5ff1327d377ac","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"96ceffbfd88fb06e3b41aa4d3087cffbbf8441d04eba7ab09662a72ab600a321","src/boxed_slice.rs":"69d539b72460c0aba1d30e0b72efb0c29d61558574d751c784794e14abf41352","src/iter.rs":"61fefdc49cafad4cacba5f5a7ad2396a23160642c688a7f0b0734277391847cd","src/keys.rs":"b8c2fba26dee15bf3d1880bb2b41e8d66fe1428d242ee6d9fd30ee94bbd0407d","src/lib.rs":"91726acf10704f47a75a1de7656374972d3c9a76f127afcbafde03bfc5ea642e","src/list.rs":"dce6c14f30cdbbf4d97ff3b15ec9fcd6bc59c43c3eebdfd6cebc1259765a2cd6","src/map.rs":"d5e004471acf75d71cebaac0e65a45fe052781507f4a616120d264a8056a5d92","src/packed_option.rs":"5835517c24397e79db5075201950d43956f9f8c7e6ac0df738b1372d5c3e725a","src/primary.rs":"6032b4fd3b75f9909aba307549cdca591fa47abcbd4682480e4f0f09580b2be2","src/set.rs":"895202c96ca318e8b7bd43bfdb37ce5b845880aec1a3fecc6033aedc294a3c8d","src/sparse.rs":"a3aafc3e57ba958618ec88a5d1d25d698330e1b4b2c2d33c2c0638ea06a673f7","src/unsigned.rs":"cb50cc8387466857a46dca6f0368c8be80a5c01036876fe6b10c477880202878"},"package":"177b6f94ae8de6348eb45bf977c79ab9e3c40fc3ac8cb7ed8109560ea39bee7d"}
+{"files":{"Cargo.toml":"6588706a4ffca58c7ba58aea1539bc63e1ad2e3f4cdf91ee1f1e4cf03b9d2407","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"96ceffbfd88fb06e3b41aa4d3087cffbbf8441d04eba7ab09662a72ab600a321","src/boxed_slice.rs":"69d539b72460c0aba1d30e0b72efb0c29d61558574d751c784794e14abf41352","src/iter.rs":"61fefdc49cafad4cacba5f5a7ad2396a23160642c688a7f0b0734277391847cd","src/keys.rs":"b8c2fba26dee15bf3d1880bb2b41e8d66fe1428d242ee6d9fd30ee94bbd0407d","src/lib.rs":"91726acf10704f47a75a1de7656374972d3c9a76f127afcbafde03bfc5ea642e","src/list.rs":"dce6c14f30cdbbf4d97ff3b15ec9fcd6bc59c43c3eebdfd6cebc1259765a2cd6","src/map.rs":"d5e004471acf75d71cebaac0e65a45fe052781507f4a616120d264a8056a5d92","src/packed_option.rs":"5835517c24397e79db5075201950d43956f9f8c7e6ac0df738b1372d5c3e725a","src/primary.rs":"6032b4fd3b75f9909aba307549cdca591fa47abcbd4682480e4f0f09580b2be2","src/set.rs":"895202c96ca318e8b7bd43bfdb37ce5b845880aec1a3fecc6033aedc294a3c8d","src/sparse.rs":"a3aafc3e57ba958618ec88a5d1d25d698330e1b4b2c2d33c2c0638ea06a673f7","src/unsigned.rs":"cb50cc8387466857a46dca6f0368c8be80a5c01036876fe6b10c477880202878"},"package":"286754159b1a685475d6a0b4710832f950d6f4846a817002e2c23ff001321a65"}

data/ext/cargo-vendor/{cranelift-entity-0.104.0 → cranelift-entity-0.104.1}/Cargo.toml

@@ -12,7 +12,7 @@
 [package]
 edition = "2021"
 name = "cranelift-entity"
-version = "0.104.0"
+version = "0.104.1"
 authors = ["The Cranelift Project Developers"]
 description = "Data structures using entity references as mapping keys"
 documentation = "https://docs.rs/cranelift-entity"

data/ext/cargo-vendor/{cranelift-frontend-0.104.0 → cranelift-frontend-0.104.1}/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{"Cargo.toml":"a80457bc622996b1a9c5551664182071242e73adc21d63503c92be4c3b840a2b","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"dea43e8044284df50f8b8772e9b48ba8b109b45c74111ff73619775d57ad8d67","src/frontend.rs":"712cbce058ca2aea229debf0600c6b0eee0d02d3102bf49a52db96f67e3a0d03","src/lib.rs":"1fcaf7c33f40aff0aa778bd1b54049478ec26517c342140f40538528940a5a1d","src/ssa.rs":"9d1a47cb6d6328f31997f0ee09b0326067e4507284f363e5d09074e2c306f303","src/switch.rs":"ca77eeb97db8c43566c5cfc1cc5e7a0c394fc72e306b985117e47d6d6f5bb5cc","src/variable.rs":"ad628b3c6de9a8c008dc31f869bf9d853f2dd3b590dc4e2e3c6da70ba6bf7adf"},"package":"ebebd23a69a23e3ddea78e98ff3a2de222e88c8e045d81ef4a72f042e0d79dbd"}
+{"files":{"Cargo.toml":"0f105cbfc75eb5c6569f4a3bc6ca2187e7adce3ac6c11a34f8ce4a522126509b","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"dea43e8044284df50f8b8772e9b48ba8b109b45c74111ff73619775d57ad8d67","src/frontend.rs":"712cbce058ca2aea229debf0600c6b0eee0d02d3102bf49a52db96f67e3a0d03","src/lib.rs":"1fcaf7c33f40aff0aa778bd1b54049478ec26517c342140f40538528940a5a1d","src/ssa.rs":"9d1a47cb6d6328f31997f0ee09b0326067e4507284f363e5d09074e2c306f303","src/switch.rs":"ca77eeb97db8c43566c5cfc1cc5e7a0c394fc72e306b985117e47d6d6f5bb5cc","src/variable.rs":"ad628b3c6de9a8c008dc31f869bf9d853f2dd3b590dc4e2e3c6da70ba6bf7adf"},"package":"67150a1fef9857caba710f8c0c8223d640f02c0e5d1ebbfc75ed62912599cb6b"}

data/ext/cargo-vendor/{cranelift-frontend-0.104.0 → cranelift-frontend-0.104.1}/Cargo.toml

@@ -12,7 +12,7 @@
 [package]
 edition = "2021"
 name = "cranelift-frontend"
-version = "0.104.0"
+version = "0.104.1"
 authors = ["The Cranelift Project Developers"]
 description = "Cranelift IR builder helper"
 documentation = "https://docs.rs/cranelift-frontend"
@@ -22,7 +22,7 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 
 [dependencies.cranelift-codegen]
-version = "0.104.0"
+version = "0.104.1"
 features = [
     "std",
     "unwind",