wasmtime 37.0.2 → 38.0.4

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

@@ -1,333 +0,0 @@
-;; rewrites for integer and floating-point arithmetic
-;; eg: `iadd`, `isub`, `ineg`, `imul`, `fadd`, `fsub`, `fmul`
-
-;; For commutative instructions, we depend on cprop.isle pushing immediates to
-;; the right, and thus only simplify patterns like `x+0`, not `0+x`.
-
-;; x+0 == x.
-(rule (simplify (iadd ty
-                      x
-                      (iconst_u ty 0)))
-      (subsume x))
-;; x-0 == x.
-(rule (simplify (isub ty
-                      x
-                      (iconst_u ty 0)))
-      (subsume x))
-;; 0-x == (ineg x).
-(rule (simplify (isub ty
-                      (iconst_u ty 0)
-                      x))
-      (ineg ty x))
-
-;; x + -y == -y + x == -(y - x) == x - y
-(rule (simplify (iadd ty x (ineg ty y)))
-      (isub ty x y))
-(rule (simplify (iadd ty (ineg ty y) x))
-      (isub ty x y))
-(rule (simplify (ineg ty (isub ty y x)))
-      (isub ty x y))
-;; x - -y == x + y
-(rule (simplify (isub ty x (ineg ty y)))
-      (iadd ty x y))
-
-;; 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 (ty_int ty) x x)) (subsume (iconst_u ty 0)))
-
-;; x*1 == x.
-(rule (simplify (imul ty
-                      x
-                      (iconst_u ty 1)))
-      (subsume x))
-
-;; x*0 == 0.
-(rule (simplify (imul ty
-                      _
-                      zero @ (iconst_u ty 0)))
-      (subsume zero))
-
-;; x*-1 == ineg(x).
-(rule (simplify (imul ty x (iconst_s ty -1)))
-      (ineg ty x))
-
-;; (!x) + 1 == ineg(x)
-(rule (simplify (iadd ty (bnot ty x) (iconst_u ty 1)))
-      (ineg ty x))
-
-;; !(x - 1) == !(x + (-1)) == ineg(x)
-(rule (simplify (bnot ty (isub ty x (iconst_s ty 1))))
-      (ineg ty x))
-(rule (simplify (bnot ty (iadd ty x (iconst_s ty -1))))
-      (ineg ty x))
-
-;; x / 1 == x.
-(rule (simplify_skeleton (sdiv x (iconst_s ty 1))) x)
-(rule (simplify_skeleton (udiv x (iconst_u ty 1))) x)
-
-;; Unsigned `x / d == x >> ilog2(d)` when d is a power of two.
-(rule (simplify_skeleton (udiv x (iconst_u ty (u64_extract_power_of_two d))))
-      (ushr ty x (iconst_u ty (u64_ilog2 d))))
-
-;; Signed `x / d` when d is a power of two is a bit more involved...
-(rule (simplify_skeleton (sdiv x (iconst_u ty (u64_extract_power_of_two d))))
-      (if-let true (u64_gt d 1))
-      (let ((k u32 (u64_trailing_zeros d))
-            (t1 Value (sshr ty x (iconst_u ty (u32_sub k 1))))
-            (t2 Value (ushr ty t1 (iconst_u ty (u32_sub (ty_bits ty) k))))
-            (t3 Value (iadd ty x t2))
-            (t4 Value (sshr ty t3 (iconst_s ty k))))
-        t4))
-
-;; And signed `x / d` when d is a negative power of two is the same, but with a
-;; negation.
-(rule (simplify_skeleton (sdiv x (iconst_s ty d)))
-      (if-let true (i64_is_negative_power_of_two d))
-      (if-let true (i64_ne d -1))
-      (let ((k u32 (i64_trailing_zeros d))
-            (t1 Value (sshr ty x (iconst_u ty (u32_sub k 1))))
-            (t2 Value (ushr ty t1 (iconst_u ty (u32_sub (ty_bits ty) k))))
-            (t3 Value (iadd ty x t2))
-            (t4 Value (sshr ty t3 (iconst_s ty k)))
-            (t5 Value (ineg ty t4)))
-        t5))
-
-;; General cases for `udiv` with constant divisors.
-(rule (simplify_skeleton (udiv x (iconst_u $I32 (u64_extract_non_zero (u32_from_u64 d)))))
-      (if-let false (u32_is_power_of_two d))
-      (apply_div_const_magic_u32 (Opcode.Udiv) x d))
-(rule (simplify_skeleton (udiv x (iconst_u $I64 (u64_extract_non_zero d))))
-      (if-let false (u64_is_power_of_two d))
-      (apply_div_const_magic_u64 (Opcode.Udiv) x d))
-
-;; General cases for `sdiv` with constant divisors.
-(rule (simplify_skeleton (sdiv x (iconst_s $I32 (i64_extract_non_zero (i32_from_i64 d)))))
-      (if-let false (i64_is_any_sign_power_of_two d))
-      (apply_div_const_magic_s32 (Opcode.Sdiv) x d))
-(rule (simplify_skeleton (sdiv x (iconst_s $I64 (i64_extract_non_zero d))))
-      (if-let false (i64_is_any_sign_power_of_two d))
-      (apply_div_const_magic_s64 (Opcode.Sdiv) x d))
-
-;; x % 1 == 0
-(rule (simplify_skeleton (urem x (iconst_u ty 1))) (iconst_u ty 0))
-(rule (simplify_skeleton (srem x (iconst_u ty 1))) (iconst_u ty 0))
-(rule (simplify_skeleton (srem x (iconst_s ty -1))) (iconst_u ty 0))
-
-;; Unsigned `x % d == x & ((1 << ilog2(d)) - 1)` when `d` is a power of two.
-(rule (simplify_skeleton (urem x (iconst_u ty (u64_extract_power_of_two d))))
-      (if-let true (u64_gt d 1))
-      (let ((mask Value (iconst_u ty (u64_sub (u64_shl 1 (u64_ilog2 d)) 1))))
-        (band ty x mask)))
-
-;; Signed `x % d` when `d` is a (possibly negative) power of two is a little
-;; more complicated.
-(rule (simplify_skeleton (srem x d_val @ (iconst_s ty d)))
-      ;; Interestingly, this same sequence works for both positive and negative
-      ;; powers of two.
-      (if-let true (i64_is_any_sign_power_of_two d))
-      (if-let true (i64_ne d 1))
-      (if-let true (i64_ne d -1))
-      (let ((k u32 (i64_trailing_zeros d))
-            (t1 Value (sshr ty x (iconst_u ty (u32_sub k 1))))
-            (t2 Value (ushr ty t1 (iconst_u ty (u32_sub (ty_bits ty) k))))
-            (t3 Value (iadd ty x t2))
-            (t4 Value (band ty t3 (iconst_s ty (i64_wrapping_neg (i64_shl 1 k)))))
-            (t5 Value (isub ty x t4)))
-        t5))
-
-;; General cases for `urem` with constant divisors.
-(rule (simplify_skeleton (urem x (iconst_u $I32 (u64_extract_non_zero (u32_from_u64 d)))))
-      (if-let false (u32_is_power_of_two d))
-      (apply_div_const_magic_u32 (Opcode.Urem) x d))
-(rule (simplify_skeleton (urem x (iconst_u $I64 (u64_extract_non_zero d))))
-      (if-let false (u64_is_power_of_two d))
-      (apply_div_const_magic_u64 (Opcode.Urem) x d))
-
-;; General cases for `srem` with constant divisors.
-(rule (simplify_skeleton (srem x (iconst_s $I32 (i64_extract_non_zero (i32_from_i64 d)))))
-      (if-let false (i64_is_any_sign_power_of_two d))
-      (apply_div_const_magic_s32 (Opcode.Srem) x d))
-(rule (simplify_skeleton (srem x (iconst_s $I64 (i64_extract_non_zero d))))
-      (if-let false (i64_is_any_sign_power_of_two d))
-      (apply_div_const_magic_s64 (Opcode.Srem) x d))
-
-;; x*2 == x+x.
-(rule (simplify (imul ty x (iconst_u _ 2)))
-      (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))
-
-;; (a op (b op (c op d))) ==> ((a op b) op (c op d))
-;;
-;; and
-;;
-;; (((a op b) op c) op d) ==> ((a op b) op (c op d))
-;;
-;; where `op` is an associative operation: `iadd`, `imul`, `band`, or `bxor`.
-;;
-;; This increases instruction-level parallelism and shrinks live ranges. It also
-;; canonicalizes into the shallow-and-wide form for reassociating constants
-;; together for cprop.
-;;
-;; NB: We subsume to avoid exponential e-node blow up due to reassociating very
-;; large chains of operations.
-;;
-;; TODO: We should add `bor` rules for this as well. Unfortunately, they
-;; conflict with our `bswap` recognizing rules when we `subsume`.
-
-(rule (simplify (iadd ty a (iadd ty b (iadd ty c d))))
-      (subsume (iadd ty (iadd ty a b) (iadd ty c d))))
-(rule (simplify (iadd ty (iadd ty (iadd ty a b) c) d))
-      (subsume (iadd ty (iadd ty a b) (iadd ty c d))))
-
-(rule (simplify (imul ty a (imul ty b (imul ty c d))))
-      (subsume (imul ty (imul ty a b) (imul ty c d))))
-(rule (simplify (imul ty (imul ty (imul ty a b) c) d))
-      (subsume (imul ty (imul ty a b) (imul ty c d))))
-
-(rule (simplify (band ty a (band ty b (band ty c d))))
-      (subsume (band ty (band ty a b) (band ty c d))))
-(rule (simplify (band ty (band ty (band ty a b) c) d))
-      (subsume (band ty (band ty a b) (band ty c d))))
-
-(rule (simplify (bxor ty a (bxor ty b (bxor ty c d))))
-      (subsume (bxor ty (bxor ty a b) (bxor ty c d))))
-(rule (simplify (bxor ty (bxor ty (bxor ty a b) c) d))
-      (subsume (bxor ty (bxor ty a b) (bxor ty c d))))
-
-
-;; Similar rules but for associating combinations of + and -
-
-;; a -(b-(c-d)) = (a-b) + (c-d)
-(rule (simplify (isub ty a (isub ty b (isub ty c d))))
-      (subsume (iadd ty (isub ty a b) (isub ty c d))))
-
-;; a -(b-(c+d)) = (a-b) + (c+d)
-(rule (simplify (isub ty a (isub ty b (iadd ty c d))))
-      (subsume (iadd ty (isub ty a b) (iadd ty c d))))
-
-;; a -(b+(c-d)) = (a-b) - (c-d)
-(rule (simplify (isub ty a (iadd ty b (isub ty c d))))
-      (subsume (isub ty (isub ty a b) (isub ty c d))))
-
-;; a -(b+(c+d)) = (a-b) - (c+d)
-(rule (simplify (isub ty a (iadd ty b (iadd ty c d))))
-      (subsume (isub ty (isub ty a b) (iadd ty c d))))
-
-;; a +(b-(c-d)) = (a+b) - (c-d)
-(rule (simplify (iadd ty a (isub ty b (isub ty c d))))
-      (subsume (isub ty (iadd ty a b) (isub ty c d))))
-
-;; a +(b-(c+d)) = (a+b) - (c+d)
-(rule (simplify (iadd ty a (isub ty b (iadd ty c d))))
-      (subsume (isub ty (iadd ty a b) (iadd ty c d))))
-
-;; a +(b+(c-d)) = (a+b) + (c-d)
-(rule (simplify (iadd ty a (iadd ty b (isub ty c d))))
-      (subsume (iadd ty (iadd ty a b) (isub ty c d))))
-
-;; and nested the other way
-
-;; ((a-b)-c)-d = (a-b) - (c+d)
-(rule (simplify (isub ty (isub ty (isub ty a b) c) d))
-      (subsume (isub ty (isub ty a b) (iadd ty c d))))
-
-;; ((a-b)-c)+d = (a-b) - (c-d)
-(rule (simplify (iadd ty (isub ty (isub ty a b) c) d))
-      (subsume (isub ty (isub ty a b) (isub ty c d))))
-
-;; ((a-b)+c)-d = (a-b) + (c-d)
-(rule (simplify (isub ty (iadd ty (isub ty a b) c) d))
-      (subsume (iadd ty (isub ty a b) (isub ty c d))))
-
-;; ((a-b)+c)+d = (a-b) + (c+d)
-(rule (simplify (iadd ty (iadd ty (isub ty a b) c) d))
-      (subsume (iadd ty (isub ty a b) (iadd ty c d))))
-
-;; ((a+b)-c)-d = (a+b) - (c+d)
-(rule (simplify (isub ty (isub ty (iadd ty a b) c) d))
-      (subsume (isub ty (iadd ty a b) (iadd ty c d))))
-
-;; ((a+b)-c)+d = (a+b) - (c-d)
-(rule (simplify (iadd ty (isub ty (iadd ty a b) c) d))
-      (subsume (isub ty (iadd ty a b) (isub ty c d))))
-
-;; ((a+b)+c)-d = (a+b) + (c-d)
-(rule (simplify (isub ty (iadd ty (iadd ty a b) c) d))
-      (subsume (iadd ty (iadd ty a b) (isub ty c d))))
-
-;; Detect people open-coding `mulhi`: (x as big * y as big) >> bits
-;; LLVM doesn't have an intrinsic for it, so you'll see it in code like
-;; <https://github.com/rust-lang/rust/blob/767453eb7ca188e991ac5568c17b984dd4893e77/library/core/src/num/mod.rs#L174-L180>
-(rule (simplify (sshr ty (imul ty (sextend _ x@(value_type half_ty))
-                                  (sextend _ y@(value_type half_ty)))
-                         (iconst_u _ k)))
-      (if-let true (ty_equal half_ty (ty_half_width ty)))
-      (if-let true (u64_eq k (ty_bits_u64 half_ty)))
-      (sextend ty (smulhi half_ty x y)))
-(rule (simplify (ushr ty (imul ty (uextend _ x@(value_type half_ty))
-                                  (uextend _ y@(value_type half_ty)))
-                         (iconst_u _ k)))
-      (if-let true (ty_equal half_ty (ty_half_width ty)))
-      (if-let true (u64_eq k (ty_bits_u64 half_ty)))
-      (uextend ty (umulhi half_ty x y)))
-
-;; Cranelift's `fcvt_from_{u,s}int` instructions are polymorphic over the input
-;; type so remove any unnecessary `uextend` or `sextend` to give backends
-;; the chance to convert from the smallest integral type to the float. This
-;; can help lowerings on x64 for example which has a less efficient u64-to-float
-;; conversion than other bit widths.
-(rule (simplify (fcvt_from_uint ty (uextend _ val)))
-      (fcvt_from_uint ty val))
-(rule (simplify (fcvt_from_sint ty (sextend _ val)))
-      (fcvt_from_sint ty val))
-
-
-;; or(x, C) + (-C)  -->  and(x, ~C)
-(rule
-  (simplify (iadd ty
-              (bor ty x (iconst_s ty n))
-              (iconst_s ty m)))
-  (if-let m (i64_checked_neg n))
-  (band ty x (iconst ty (imm64_masked ty (i64_cast_unsigned (i64_not n))))))
-
-;; (x + y) - (x | y) --> x & y
-(rule (simplify (isub ty (iadd ty x y) (bor ty x y))) (band ty x y))
-
-;; x * (1 << y) == x << y
-(rule (simplify (imul ty x (ishl ty (iconst_s ty 1) y))) (ishl ty x y))

data/ext/cargo-vendor/cranelift-codegen-0.124.2/src/opts/bitops.isle

@@ -1,204 +0,0 @@
-;; Rewrites for `band`, `bnot`, `bor`, `bxor`
-
-;; x | 0 == x | x == x.
-(rule (simplify (bor ty
-                     x
-                     (iconst_u ty 0)))
-      (subsume x))
-(rule (simplify (bor ty x x))
-      (subsume x))
-
-;; x ^ 0 == x.
-(rule (simplify (bxor ty
-                     x
-                     (iconst_u ty 0)))
-      (subsume x))
-
-;; x ^ x == 0.
-(rule (simplify (bxor (ty_int ty) x x))
-      (subsume (iconst_u ty 0)))
-
-;; x ^ not(x) == not(x) ^ x == x | not(x) == not(x) | x == -1.
-;; This identity also holds for non-integer types, vectors, and wider types.
-(rule (simplify (bxor (ty_int ty) x (bnot ty x))) (subsume (iconst_s ty -1)))
-(rule (simplify (bxor (ty_int ty) (bnot ty x) x)) (subsume (iconst_s ty -1)))
-(rule (simplify (bor (ty_int ty) x (bnot ty x))) (subsume (iconst_s ty -1)))
-(rule (simplify (bor (ty_int ty) (bnot ty x) x)) (subsume (iconst_s ty -1)))
-
-;; x & x == x & -1 == x.
-(rule (simplify (band ty x x)) (subsume x))
-(rule (simplify (band ty x (iconst_s ty -1)))
-      (subsume x))
-
-;; x & 0 == x & not(x) == not(x) & x == 0.
-(rule (simplify (band ty _ zero @ (iconst_u ty 0))) (subsume zero))
-(rule (simplify (band (ty_int ty) x (bnot ty x))) (subsume (iconst_u ty 0)))
-(rule (simplify (band (ty_int ty) (bnot ty x) x)) (subsume (iconst_u ty 0)))
-
-;; (x & y) ^ (x ^ y) == x | y
-(rule (simplify (bxor ty (band ty X Y) (bxor ty X Y))) (bor ty X Y))
-
-;; not(not(x)) == x.
-(rule (simplify (bnot ty (bnot ty x))) (subsume x))
-
-;; DeMorgan's rule (two versions):
-;; bnot(bor(x, y)) == band(bnot(x), bnot(y))
-(rule (simplify (bnot ty (bor ty x y)))
-      (band ty (bnot ty x) (bnot ty y)))
-;; bnot(band(x, y)) == bor(bnot(x), bnot(y))
-(rule (simplify (bnot ty (band t x y)))
-      (bor ty (bnot ty x) (bnot ty y)))
-
-;; `or(and(x, y), not(y)) == or(x, not(y))`
-(rule (simplify (bor ty
-                     (band ty x y)
-                     z @ (bnot ty y)))
-      (bor ty x z))
-;; Duplicate the rule but swap the `bor` operands because `bor` is
-;; commutative. We could, of course, add a `simplify` rule to do the commutative
-;; swap for all `bor`s but this will bloat the e-graph with many e-nodes. It is
-;; cheaper to have additional rules, rather than additional e-nodes, because we
-;; amortize their cost via ISLE's smart codegen.
-(rule (simplify (bor ty
-                     z @ (bnot ty y)
-                     (band ty x y)))
-      (bor ty x z))
-
-;; `or(and(x, y), not(y)) == or(x, not(y))` specialized for constants, since
-;; otherwise we may not know that `z == not(y)` since we don't generally expand
-;; constants in the e-graph.
-;;
-;; (No need to duplicate for commutative `bor` for this constant version because
-;; we move constants to the right.)
-(rule (simplify (bor ty
-                     (band ty x (iconst_u ty y))
-                     z @ (iconst_u ty zk)))
-      (if-let true (u64_eq (u64_and (ty_mask ty) zk)
-                            (u64_and (ty_mask ty) (u64_not y))))
-      (bor ty x z))
-
-;; (x ^ -1) can be replaced with the `bnot` instruction
-(rule (simplify (bxor ty x (iconst_s ty -1)))
-  (bnot ty x))
-
-;; sshr((x | -x), N) == bmask(x) where N = ty_bits(ty) - 1.
-;;
-;; (x | -x) sets the sign bit to 1 if x is nonzero, and 0 if x is zero. sshr propagates
-;; the sign bit to the rest of the value.
-(rule (simplify (sshr ty (bor ty x (ineg ty x)) (iconst_u ty shift_amt)))
-      (if-let true (u64_eq shift_amt (ty_shift_mask ty)))
-      (bmask ty x))
-
-(rule (simplify (sshr ty (bor ty (ineg ty x) x) (iconst_u ty shift_amt)))
-      (if-let true (u64_eq shift_amt (ty_shift_mask ty)))
-      (bmask ty x))
-
-;; Since icmp is always 0 or 1, bmask is just a negation.
-;; TODO: Explore whether this makes sense for things needing extension too.
-(rule (simplify (bmask $I8 cmp@(icmp $I8 _ _ _)))
-      (ineg $I8 cmp))
-
-;; Matches any expressions that preserve "truthiness".
-;; i.e. If the input is zero it remains zero, and if it is nonzero it can have
-;; a different value as long as it is still nonzero.
-(decl pure multi truthy (Value) Value)
-(rule (truthy (sextend _ x)) x)
-(rule (truthy (uextend _ x)) x)
-(rule (truthy (bmask _ x)) x)
-(rule (truthy (ineg _ x)) x)
-(rule (truthy (bswap _ x)) x)
-(rule (truthy (bitrev _ x)) x)
-(rule (truthy (popcnt _ x)) x)
-(rule (truthy (rotl _ x _)) x)
-(rule (truthy (rotr _ x _)) x)
-(rule (truthy (select _ x (iconst_u _ (u64_when_non_zero)) (iconst_u _ 0))) x)
-;; (ne ty (iconst 0) v) is also canonicalized into this form via another rule
-(rule (truthy (ne _ x (iconst_u _ 0))) x)
-
-;; All of these expressions don't care about their input as long as it is truthy.
-;; so we can remove expressions that preserve that property from the input.
-(rule (simplify (bmask ty v)) (if-let x (truthy v)) (bmask ty x))
-(rule (simplify (select ty v t f)) (if-let c (truthy v)) (select ty c t f))
-;; (ne ty (iconst 0) v) is also canonicalized into this form via another rule
-(rule (simplify (ne cty v (iconst_u _ 0)))
-      (if-let c (truthy v))
-      (if-let (value_type (ty_int_ref_scalar_64 ty)) c)
-      (ne cty c (iconst_u ty 0)))
-
-
-
-;; (sextend (bmask x)) can be replaced with (bmask x) since bmask
-;; supports any size of output type, regardless of input.
-;; Same with `ireduce`
-(rule (simplify (sextend ty (bmask _ x))) (bmask ty x))
-(rule (simplify (ireduce ty (bmask _ x))) (bmask ty x))
-
-;; (bswap (bswap x)) == x
-(rule (simplify (bswap ty (bswap ty x))) (subsume x))
-
-;; (bitrev (bitrev x)) == x
-(rule (simplify (bitrev ty (bitrev ty x))) (subsume x))
-
-;; WebAssembly doesn't have a native byte-swapping instruction at this time so
-;; languages which have a byte-swapping operation will compile it down to bit
-;; shifting and twiddling. This attempts to pattern match what LLVM currently
-;; generates today for the Rust code `a.swap_bytes()`. This might be a bit
-;; brittle over time and/or with other possible LLVM backend optimizations, but
-;; it's at least one way to generate a byte swap.
-;;
-;; Technically this could be permuted quite a few ways and currently there's no
-;; easy way to match all of them, so only one is matched here.
-(rule (simplify (bor ty @ $I32
-    (bor ty
-      (ishl ty x (iconst_u ty 24))
-      (ishl ty
-        (band ty x (iconst_u ty 0xff00))
-        (iconst_u ty 8)))
-    (bor ty
-      (band ty
-        (ushr ty x (iconst_u ty 8))
-        (iconst_u ty 0xff00))
-      (ushr ty x (iconst_u ty 24)))))
-  (bswap ty x))
-
-(rule (simplify (bor ty @ $I64
-    (bor ty
-      (bor ty
-        (ishl ty x (iconst_u ty 56))
-        (ishl ty
-          (band ty x (iconst_u ty 0xff00))
-          (iconst_u ty 40)))
-      (bor ty
-        (ishl ty
-          (band ty x (iconst_u ty 0xff_0000))
-          (iconst_u ty 24))
-        (ishl ty
-          (band ty x (iconst_u ty 0xff00_0000))
-          (iconst_u ty 8))))
-    (bor ty
-      (bor ty
-        (band ty
-          (ushr ty x (iconst_u ty 8))
-          (iconst_u ty 0xff00_0000))
-        (band ty
-          (ushr ty x (iconst_u ty 24))
-          (iconst_u ty 0xff_0000)))
-      (bor ty
-        (band ty
-          (ushr ty x (iconst_u ty 40))
-          (iconst_u ty 0xff00))
-        (ushr ty x (iconst_u ty 56))))))
-  (bswap ty x))
-
-(rule (simplify (bxor ty (bor ty x y) (band ty x y))) (bxor ty x y))
-
-
-(rule (simplify (bor ty (bor ty x y) x)) (bor ty x y))
-(rule (simplify (bor ty (bor ty x y) y)) (bor ty x y))
-(rule (simplify (bor ty x (bor ty x y))) (bor ty x y))
-(rule (simplify (bor ty y (bor ty x y))) (bor ty x y))
-
-(rule (simplify (band ty (band ty x y) x)) (band ty x y))
-(rule (simplify (band ty (band ty x y) y)) (band ty x y))
-(rule (simplify (band ty x (band ty x y))) (band ty x y))
-(rule (simplify (band ty y (band ty x y))) (band ty x y))