wasmtime 16.0.0 → 17.0.0

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

@@ -0,0 +1,248 @@
+;; 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))))
+
+;; iconst_[su] support $I128, but do so by extending, so restricting to
+;; 64-bit or smaller keeps it from just remaking essentially the same thing.
+(rule (simplify (uextend (fits_in_64 wide) (iconst_u narrow k)))
+      (subsume (iconst_u wide k)))
+(rule (simplify (sextend (fits_in_64 wide) (iconst_s narrow k)))
+      (subsume (iconst_s wide k)))
+
+(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_swap_args 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_u _ (u64_nonzero _)) x y))
+      x)
+(rule (simplify
+       (select ty (iconst_u _ 0) x y))
+      y)
+
+;; Replace subtraction by a "negative" constant with addition.
+;; Notably, this gives `x - (-1) == x + 1`, so other patterns don't have to
+;; match the subtract-negative-one version too.
+;; TODO: it would be nice to do this for `x + (-1) == x - 1` as well, but
+;; that needs work in lowering first to avoid regressing addressing modes.
+
+(rule (simplify (isub ty x (iconst_s ty k)))
+      (if-let $true (u64_lt (i64_as_u64 (i64_neg k)) (i64_as_u64 k)))
+      (iadd ty x (iconst ty (imm64_masked ty (i64_as_u64 (i64_neg k))))))
+
+;; 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)
+
+;; Reassociate nested shifts of constants to put constants together for cprop.
+;;
+;; ((A shift b) shift C) ==> ((A shift C) shift b)
+(rule (simplify (ishl ty (ishl ty a@(iconst _ _) b) c@(iconst _ _)))
+      (ishl ty (ishl ty a c) b))
+(rule (simplify (ushr ty (ushr ty a@(iconst _ _) b) c@(iconst _ _)))
+      (ushr ty (ushr ty a c) b))
+(rule (simplify (sshr ty (sshr ty a@(iconst _ _) b) c@(iconst _ _)))
+      (sshr ty (sshr ty a c) b))
+
+;; When we operations that are both commutative and associative, reassociate
+;; constants together for cprop:
+;;
+;; ((a op B) op (c op D)) ==> ((a op c) op (B op D))
+;;
+;; Where `op` is one of: `iadd`, `imul`, `band`, `bor`, or `bxor`.
+(rule (simplify (iadd ty
+                      (iadd ty a b@(iconst _ _))
+                      (iadd ty c d@(iconst _ _))))
+      (iadd ty (iadd ty a c) (iadd ty b d)))
+(rule (simplify (imul ty
+                      (imul ty a b@(iconst _ _))
+                      (imul ty c d@(iconst _ _))))
+      (imul ty (imul ty a c) (imul ty b d)))
+(rule (simplify (band ty
+                      (band ty a b@(iconst _ _))
+                      (band ty c d@(iconst _ _))))
+      (band ty (band ty a c) (band ty b d)))
+(rule (simplify (bor ty
+                      (bor ty a b@(iconst _ _))
+                      (bor ty c d@(iconst _ _))))
+      (bor ty (bor ty a c) (bor ty b d)))
+(rule (simplify (bxor ty
+                      (bxor ty a b@(iconst _ _))
+                      (bxor ty c d@(iconst _ _))))
+      (bxor ty (bxor ty a c) (bxor ty b d)))

data/ext/cargo-vendor/cranelift-codegen-0.104.0/src/opts/extends.isle

@@ -0,0 +1,116 @@
+;; Chained `uextend` and `sextend`.
+(rule (simplify (uextend ty (uextend _intermediate_ty x)))
+      (uextend ty x))
+(rule (simplify (sextend ty (sextend _intermediate_ty x)))
+      (sextend ty x))
+
+;; Once something has be `uextend`ed, further `sextend`ing is the same as `uextend`
+(rule (simplify (sextend ty (uextend _intermediate_ty x)))
+      (uextend ty x))
+
+;; `icmp` is zero or one, so sign-extending is the same as zero-extending
+(rule (simplify (sextend ty x@(icmp _ _ _ _)))
+      (uextend ty x))
+
+;; Masking out any of the top bits of the result of `uextend` is a no-op. (This
+;; is like a cheap version of known-bits analysis.)
+(rule (simplify (band wide x @ (uextend _ (value_type narrow)) (iconst_u _ mask)))
+      ; Check that `narrow_mask` has a subset of the bits that `mask` does.
+      (if-let $true (let ((narrow_mask u64 (ty_mask narrow))) (u64_eq narrow_mask (u64_and mask narrow_mask))))
+      x)
+
+;; Masking out the sign-extended bits of an `sextend` turns it into a `uextend`.
+(rule (simplify (band wide (sextend _ x @ (value_type narrow)) (iconst_u _ mask)))
+      (if-let $true (u64_eq mask (ty_mask narrow)))
+      (uextend wide x))
+
+;; 32-bit integers zero-extended to 64-bit integers are never negative
+(rule (simplify
+       (slt ty
+             (uextend $I64 x @ (value_type $I32))
+             (iconst_u _ 0)))
+      (iconst_u ty 0))
+(rule (simplify
+       (sge ty
+             (uextend $I64 x @ (value_type $I32))
+             (iconst_u _ 0)))
+      (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)))
+      (eq ty x (iconst_s ty 0)))
+(rule (simplify (ne _ (sextend _ x@(value_type ty)) (iconst_s _ 0)))
+      (ne ty x (iconst_s ty 0)))
+(rule (simplify (icmp _ cc (sextend _ x@(value_type ty)) (iconst_s _ 0)))
+      (if (signed_cond_code cc))
+      (icmp ty cc x (iconst_s ty 0)))
+
+;; A reduction-of-an-extend back to the same original type is the same as not
+;; actually doing the extend in the first place.
+(rule (simplify (ireduce ty (sextend _ x @ (value_type ty)))) (subsume x))
+(rule (simplify (ireduce ty (uextend _ x @ (value_type ty)))) (subsume x))
+
+;; A reduction-of-an-extend that's not just to the original type is either:
+;; a reduction of the original if the final type is smaller, or
+(rule (simplify (ireduce (ty_int ty_final) (sextend _ inner@(value_type ty_initial))))
+      (if-let $true (u64_lt (ty_bits_u64 ty_final) (ty_bits_u64 ty_initial)))
+      (ireduce ty_final inner))
+(rule (simplify (ireduce (ty_int ty_final) (uextend _ inner@(value_type ty_initial))))
+      (if-let $true (u64_lt (ty_bits_u64 ty_final) (ty_bits_u64 ty_initial)))
+      (ireduce ty_final inner))
+;; an extension of the original if the final type is larger.
+(rule (simplify (ireduce (ty_int ty_final) (sextend _ inner@(value_type ty_initial))))
+      (if-let $true (u64_lt (ty_bits_u64 ty_initial) (ty_bits_u64 ty_final)))
+      (sextend ty_final inner))
+(rule (simplify (ireduce (ty_int ty_final) (uextend _ inner@(value_type ty_initial))))
+      (if-let $true (u64_lt (ty_bits_u64 ty_initial) (ty_bits_u64 ty_final)))
+      (uextend ty_final inner))
+
+;; `band`, `bor`, and `bxor` can't affect any bits that aren't set in the one of
+;; the inputs, so they can be pushed down inside `uextend`s
+(rule (simplify (band bigty (uextend _ x@(value_type smallty)) (uextend _ y@(value_type smallty))))
+      (uextend bigty (band smallty x y)))
+(rule (simplify (bor bigty (uextend _ x@(value_type smallty)) (uextend _ y@(value_type smallty))))
+      (uextend bigty (bor smallty x y)))
+(rule (simplify (bxor bigty (uextend _ x@(value_type smallty)) (uextend _ y@(value_type smallty))))
+      (uextend bigty (bxor smallty x y)))
+
+;; 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))
+      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))
+      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.
+(decl pure multi reducible_modular_op (Value) Value)
+(rule (reducible_modular_op x@(ineg _ _)) x)
+(rule (reducible_modular_op x@(bnot _ _)) x)
+(rule (reducible_modular_op x@(iadd _ _ _)) x)
+(rule (reducible_modular_op x@(isub _ _ _)) x)
+(rule (reducible_modular_op x@(imul _ _ _)) x)
+(rule (reducible_modular_op x@(bor  _ _ _)) x)
+(rule (reducible_modular_op x@(bxor _ _ _)) x)
+(rule (reducible_modular_op x@(band _ _ _)) x)
+
+;; Replace `(small)(x OP y)` with `(small)x OP (small)y` in cases where that's
+;; legal and it reduces the total number of instructions since the reductions
+;; to the arguments simplify further.
+(rule (simplify (ireduce smallty val@(unary_op _ op x)))
+      (if-let _ (reducible_modular_op val))
+      (if-let _ (will_simplify_with_ireduce x))
+      (unary_op smallty op (ireduce smallty x)))
+(rule (simplify (ireduce smallty val@(binary_op _ op x y)))
+      (if-let _ (reducible_modular_op val))
+      (if-let _ (will_simplify_with_ireduce x))
+      (if-let _ (will_simplify_with_ireduce y))
+      (binary_op smallty op (ireduce smallty x) (ireduce smallty y)))

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

@@ -0,0 +1,197 @@
+;; `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  (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))
+
+;; Optimize icmp-of-icmp.
+(rule (simplify (ne ty
+                      (uextend_maybe _ inner @ (icmp ty _ _ _))
+                      (iconst_u _ 0)))
+      (subsume inner))
+
+(rule (simplify (eq ty
+                      (uextend_maybe _ (icmp ty cc x y))
+                      (iconst_u _ 0)))
+      (subsume (icmp ty (intcc_complement 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_u _ 1)))
+      cmp)
+(rule (simplify
+       (band (ty_int _)
+             extend @ (uextend _ (icmp _ _ _ _))
+             (iconst_u _ 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_u _ 0)))
+      (subsume (iconst_u bty 0)))
+
+;; ule(x, 0) == eq(x, 0)
+(rule (simplify (ule (fits_in_64 (ty_int bty)) x zero @ (iconst_u _ 0)))
+      (eq bty x zero))
+
+;; ugt(x, 0) == ne(x, 0).
+(rule (simplify (ugt (fits_in_64 (ty_int bty)) x zero @ (iconst_u _ 0)))
+      (ne bty x zero))
+
+;; uge(x, 0) == true.
+(rule (simplify (uge (fits_in_64 (ty_int bty)) x zero @ (iconst_u _ 0)))
+      (subsume (iconst_u bty 1)))
+
+;; ult(x, UMAX) == ne(x, UMAX).
+(rule (simplify (ult (fits_in_64 (ty_int bty)) x umax @ (iconst_u cty 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_u cty y)))
+       (if-let $true (u64_eq y (ty_umax cty)))
+       (subsume (iconst_u bty 1)))
+
+;; ugt(x, UMAX) == false.
+(rule (simplify (ugt (fits_in_64 (ty_int bty)) x umax @ (iconst_u cty y)))
+       (if-let $true (u64_eq y (ty_umax cty)))
+       (subsume (iconst_u bty 0)))
+
+;; uge(x, UMAX) == eq(x, UMAX).
+(rule (simplify (uge (fits_in_64 (ty_int bty)) x umax @ (iconst_u cty 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_u cty y)))
+       (if-let $true (u64_eq y (ty_smin cty)))
+       (subsume (iconst_u bty 0)))
+
+;; sle(x, SMIN) == eq(x, SMIN).
+(rule (simplify (sle (fits_in_64 (ty_int bty)) x smin @ (iconst_u cty 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_u cty 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_u cty y)))
+       (if-let $true (u64_eq y (ty_smin cty)))
+       (subsume (iconst_u bty 1)))
+
+;; slt(x, SMAX) == ne(x, SMAX).
+(rule (simplify (slt (fits_in_64 (ty_int bty)) x smax @ (iconst_u cty 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_u cty y)))
+       (if-let $true (u64_eq y (ty_smax cty)))
+       (subsume (iconst_u bty 1)))
+
+;; sgt(x, SMAX) == false.
+(rule (simplify (sgt (fits_in_64 (ty_int bty)) x smax @ (iconst_u cty y)))
+       (if-let $true (u64_eq y (ty_smax cty)))
+       (subsume (iconst_u bty 0)))
+
+;; sge(x, SMAX) == eq(x, SMAX).
+(rule (simplify (sge (fits_in_64 (ty_int bty)) x smax @ (iconst_u cty 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))
+
+;; Prefer comparing against zero
+;; uge(x, 1) == ne(x, 0)
+(rule (simplify (uge ty x (iconst_u cty 1)))
+      (ne ty x (iconst_u cty 0)))
+;; ult(x, 1) == eq(x, 0)
+(rule (simplify (ult ty x (iconst_u cty 1)))
+      (eq ty x (iconst_u cty 0)))
+;; sge(x, 1) == sgt(x, 0)
+(rule (simplify (sge ty x (iconst_s cty 1)))
+      (sgt ty x (iconst_s cty 0)))
+;; slt(x, 1) == sle(x, 0)
+(rule (simplify (slt ty x (iconst_s cty 1)))
+      (sle ty x (iconst_s cty 0)))
+;; sgt(x, -1) == sge(x, 0)
+(rule (simplify (sgt ty x (iconst_s cty -1)))
+      (sge ty x (iconst_s cty 0)))
+;; sle(x, -1) == slt(x, 0)
+(rule (simplify (sle ty x (iconst_s cty -1)))
+      (slt ty x (iconst_s cty 0)))
+
+(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_u ty 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_u ty 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.104.0/src/opts/selects.isle

@@ -0,0 +1,77 @@
+;; `select`/`bitselect`-related rewrites
+
+;; remove select when both choices are the same
+(rule (simplify (select    ty _ x x)) x)
+(rule (simplify (bitselect ty _ x x)) x)
+
+;; Push zeroes to the right -- this makes the select `truthy`, as used elsewhere
+;; if icmp { 0 } else { nonzero } => if !icmp { nonzero } else { 0 }
+(rule (simplify (select sty (icmp cty cc x y)
+                        zero@(iconst_u _ 0)
+                        nonzero@(iconst_u _ (u64_nonzero _))))
+    (select sty (icmp cty (intcc_complement cc) x y) nonzero zero))
+
+;; if icmp(x, y) { 1 } else { 0 } => uextend(icmp(x, y))
+(rule (simplify (select ty cmp@(icmp _ cc x y)
+                        (iconst_u _ 1)
+                        (iconst_u _ 0)))
+    (uextend_maybe ty cmp))
+;; if icmp(x, y) { -1 } else { 0 } => uextend(icmp(x, y))
+(rule (simplify (select ty cmp@(icmp _ cc x y)
+                        (iconst_s _ -1)
+                        (iconst_s _ 0)))
+    (bmask ty cmp))
+
+;; Transform select-of-icmp into {u,s}{min,max} instructions where possible.
+(rule (simplify (select ty (sgt _ x y) x y)) (smax ty x y))
+(rule (simplify (select ty (sge _ x y) x y)) (smax ty x y))
+(rule (simplify (select ty (ugt _ x y) x y)) (umax ty x y))
+(rule (simplify (select ty (uge _ x y) x y)) (umax ty x y))
+(rule (simplify (select ty (slt _ x y) x y)) (smin ty x y))
+(rule (simplify (select ty (sle _ x y) x y)) (smin ty x y))
+(rule (simplify (select ty (ult _ x y) x y)) (umin ty x y))
+(rule (simplify (select ty (ule _ x y) x y)) (umin ty x y))
+
+;; These are the same rules as above, but when the operands for select are swapped
+(rule (simplify (select ty (slt _ x y) y x)) (smax ty x y))
+(rule (simplify (select ty (sle _ x y) y x)) (smax ty x y))
+(rule (simplify (select ty (ult _ x y) y x)) (umax ty x y))
+(rule (simplify (select ty (ule _ x y) y x)) (umax ty x y))
+(rule (simplify (select ty (sgt _ x y) y x)) (smin ty x y))
+(rule (simplify (select ty (sge _ x y) y x)) (smin ty x y))
+(rule (simplify (select ty (ugt _ x y) y x)) (umin ty x y))
+(rule (simplify (select ty (uge _ x y) y x)) (umin ty x y))
+
+;; Transform bitselect-of-icmp into {u,s}{min,max} instructions where possible.
+(rule (simplify (bitselect ty @ (multi_lane _ _) (sgt _ x y) x y)) (smax ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (sge _ x y) x y)) (smax ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (ugt _ x y) x y)) (umax ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (uge _ x y) x y)) (umax ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (slt _ x y) x y)) (smin ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (sle _ x y) x y)) (smin ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (ult _ x y) x y)) (umin ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (ule _ x y) x y)) (umin ty x y))
+
+;; These are the same rules as above, but when the operands for select are swapped
+(rule (simplify (bitselect ty @ (multi_lane _ _) (slt _ x y) y x)) (smax ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (sle _ x y) y x)) (smax ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (ult _ x y) y x)) (umax ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (ule _ x y) y x)) (umax ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (sgt _ x y) y x)) (smin ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (sge _ x y) y x)) (smin ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (ugt _ x y) y x)) (umin ty x y))
+(rule (simplify (bitselect ty @ (multi_lane _ _) (uge _ x y) y x)) (umin ty x y))
+
+;; (c & x) | (~c & y) -> (bitselect c x y)
+;; These are all the same rule, just with different permutations of the operands
+;;
+;; We currently only match vectors since scalar floats and i128's are not supported
+;; in some backends.
+(rule (simplify (bor (ty_vec128 ty) (band ty c x) (band ty (bnot ty c) y))) (bitselect ty c x y))
+(rule (simplify (bor (ty_vec128 ty) (band ty c x) (band ty y (bnot ty c) ))) (bitselect ty c x y))
+(rule (simplify (bor (ty_vec128 ty) (band ty x c) (band ty (bnot ty c) y))) (bitselect ty c x y))
+(rule (simplify (bor (ty_vec128 ty) (band ty x c) (band ty y (bnot ty c) ))) (bitselect ty c x y))
+(rule (simplify (bor (ty_vec128 ty) (band ty (bnot ty c) y) (band ty c x))) (bitselect ty c x y))
+(rule (simplify (bor (ty_vec128 ty) (band ty (bnot ty c) y) (band ty x c))) (bitselect ty c x y))
+(rule (simplify (bor (ty_vec128 ty) (band ty y (bnot ty c)) (band ty c x))) (bitselect ty c x y))
+(rule (simplify (bor (ty_vec128 ty) (band ty y (bnot ty c)) (band ty x c))) (bitselect ty c x y))