wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/cranelift-codegen-0.102.1/src/opts/arithmetic.isle

@@ -1,128 +0,0 @@
-;; rewrites for integer and floating-point arithmetic
-;; eg: `iadd`, `isub`, `ineg`, `imul`, `fadd`, `fsub`, `fmul`
-
-;; x+0 == 0+x == x.
-(rule (simplify (iadd ty
-                      x
-                      (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-(rule (simplify (iadd ty
-                      (iconst ty (u64_from_imm64 0))
-                      x))
-      (subsume x))
-;; x-0 == x.
-(rule (simplify (isub ty
-                      x
-                      (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-;; 0-x == (ineg x).
-(rule (simplify (isub ty
-                      (iconst ty (u64_from_imm64 0))
-                      x))
-      (ineg ty x))
-
-;; ineg(ineg(x)) == x.
-(rule (simplify (ineg ty (ineg ty x))) (subsume x))
-
-;; ineg(x) * ineg(y) == x*y.
-(rule (simplify (imul ty (ineg ty x) (ineg ty y)))
-      (subsume (imul ty x y)))
-
-;; iabs(ineg(x)) == iabs(x).
-(rule (simplify (iabs ty (ineg ty x)))
-      (iabs ty x))
-
-;; iabs(iabs(x)) == iabs(x).
-(rule (simplify (iabs ty inner @ (iabs ty x)))
-      (subsume inner))
-
-;; x-x == 0.
-(rule (simplify (isub (fits_in_64 (ty_int ty)) x x)) (subsume (iconst ty (imm64 0))))
-
-;; x*1 == 1*x == x.
-(rule (simplify (imul ty
-                      x
-                      (iconst ty (u64_from_imm64 1))))
-      (subsume x))
-(rule (simplify (imul ty
-                      (iconst ty (u64_from_imm64 1))
-                      x))
-      (subsume x))
-
-;; x*0 == 0*x == 0.
-(rule (simplify (imul ty
-                      _
-                      zero @ (iconst ty (u64_from_imm64 0))))
-      (subsume zero))
-(rule (simplify (imul ty
-                      zero @ (iconst ty (u64_from_imm64 0))
-                      _))
-      (subsume zero))
-
-;; x*-1 == -1*x == ineg(x).
-(rule (simplify (imul ty x (iconst ty c)))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-(rule (simplify (imul ty (iconst ty c) x))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-
-;; (!x) + 1 == 1 + (!x) == !(x) - (-1) == ineg(x)
-(rule (simplify (iadd ty (bnot ty x) (iconst ty (u64_from_imm64 1))))
-      (ineg ty x))
-(rule (simplify (iadd ty (iconst ty (u64_from_imm64 1)) (bnot ty x)))
-      (ineg ty x))
-(rule (simplify (isub ty (bnot ty x) (iconst ty c)))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-
-;; !(x - 1) == !(x + (-1)) == !((-1) + x) == ineg(x)
-(rule (simplify (bnot ty (isub ty x (iconst ty (u64_from_imm64 1)))))
-      (ineg ty x))
-(rule (simplify (bnot ty (iadd ty x (iconst ty c))))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-(rule (simplify (bnot ty (iadd ty (iconst ty c) x)))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-
-;; x/1 == x.
-(rule (simplify (sdiv ty
-                      x
-                      (iconst ty (u64_from_imm64 1))))
-      (subsume x))
-(rule (simplify (udiv ty
-                      x
-                      (iconst ty (u64_from_imm64 1))))
-      (subsume x))
-
-;; TODO: strength reduction: div to shifts
-;; TODO: div/rem by constants -> magic multiplications
-
-;; x*2 == 2*x == x+x.
-(rule (simplify (imul ty x (iconst _ (simm32 2))))
-      (iadd ty x x))
-(rule (simplify (imul ty (iconst _ (simm32 2)) x))
-      (iadd ty x x))
-
-;; x*c == x<<log2(c) when c is a power of two.
-;; Note that the type of `iconst` must be the same as the type of `imul`,
-;; so these rules can only fire in situations where it's safe to construct an
-;; `iconst` of that type.
-(rule (simplify (imul ty x (iconst _ (imm64_power_of_two c))))
-      (ishl ty x (iconst ty (imm64 c))))
-(rule (simplify (imul ty (iconst _ (imm64_power_of_two c)) x))
-      (ishl ty x (iconst ty (imm64 c))))
-
-;; fneg(fneg(x)) == x.
-(rule (simplify (fneg ty (fneg ty x))) (subsume x))
-
-;; If both of the multiplied arguments to an `fma` are negated then remove
-;; both of them since they cancel out.
-(rule (simplify (fma ty (fneg ty x) (fneg ty y) z))
-      (fma ty x y z))
-
-;; If both of the multiplied arguments to an `fmul` are negated then remove
-;; both of them since they cancel out.
-(rule (simplify (fmul ty (fneg ty x) (fneg ty y)))
-      (fmul ty x y))

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

@@ -1,210 +0,0 @@
-;; 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_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 _ (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)
-
-;; 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))

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

@@ -1,177 +0,0 @@
-;; `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_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 _ (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.102.1/src/opts/selects.isle

@@ -1,59 +0,0 @@
-;; `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)
-
-;; 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))