A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Constant propagation opts (#11790)
Kirpal Grewal7129b4b9a0bd
diff --git a/cranelift/codegen/src/isle_prelude.rs b/cranelift/codegen/src/isle_prelude.rsindex 0b04f75a5b..6a9a57db40 100644--- a/cranelift/codegen/src/isle_prelude.rs+++ b/cranelift/codegen/src/isle_prelude.rs@@ -27,12 +27,38 @@ macro_rules! isle_common_prelude_methods {self.checked_add_with_type(ty, a, b).is_none()}+ #[inline]+ fn imm64_clz(&mut self, ty: Type, a: Imm64) -> Imm64 {+ let bits = ty.bits();+ assert!(bits <= 64);+ let clz_offset = 64 - bits;+ let a_v: u64 = a.bits().cast_unsigned();+ let lz = a_v.leading_zeros() - clz_offset;+ Imm64::new(i64::from(lz))+ }++ #[inline]+ fn imm64_ctz(&mut self, ty: Type, a: Imm64) -> Imm64 {+ let bits = ty.bits();+ assert!(bits <= 64);+ let a_v: u64 = a.bits().cast_unsigned();+ if a_v == 0 {+ // ctz(0) is defined to be the number of bits in the type.+ Imm64::new(i64::from(bits))+ } else {+ let lz = a_v.trailing_zeros();+ Imm64::new(i64::from(lz))+ }+ }+#[inline]fn imm64_sdiv(&mut self, ty: Type, x: Imm64, y: Imm64) -> Option<Imm64> {// Sign extend `x` and `y`.- let shift = u32::checked_sub(64, ty.bits()).unwrap_or(0);- let x = (x.bits() << shift) >> shift;- let y = (y.bits() << shift) >> shift;+ let type_width = ty.bits();+ assert!(type_width <= 64);+ let x = x.sign_extend_from_width(type_width).bits();+ let y = y.sign_extend_from_width(type_width).bits();+ let shift = 64 - type_width;// NB: We can't rely on `checked_div` to detect `ty::MIN / -1`// (which overflows and should trap) because we are working with@@ -44,9 +70,23 @@ macro_rules! isle_common_prelude_methods {return None;}- let ty_mask = self.ty_mask(ty) as i64;- let result = x.checked_div(y)? & ty_mask;- Some(Imm64::new(result))+ let result = x.checked_div(y)?;+ Some(Imm64::new(result).mask_to_width(type_width))+ }++ #[inline]+ fn imm64_srem(&mut self, ty: Type, x: Imm64, y: Imm64) -> Option<Imm64> {+ // Sign extend `x` and `y`.+ let type_width = ty.bits();+ assert!(type_width <= 64);+ let x = x.sign_extend_from_width(type_width).bits();+ let y = y.sign_extend_from_width(type_width).bits();++ // iN::min % -1 is defined as 0 in wasm so no need+ // to check for it++ let result = x.checked_rem(y)?;+ Some(Imm64::new(result).mask_to_width(type_width))}#[inline]diff --git a/cranelift/codegen/src/opts/arithmetic.isle b/cranelift/codegen/src/opts/arithmetic.isleindex 48578730bc..aba392058d 100644--- a/cranelift/codegen/src/opts/arithmetic.isle+++ b/cranelift/codegen/src/opts/arithmetic.isle@@ -339,5 +339,3 @@;; (x + y) - y --> x(rule (simplify (isub ty (iadd ty x y) x)) y)(rule (simplify (isub ty (iadd ty x y) y)) x)--diff --git a/cranelift/codegen/src/opts/cprop.isle b/cranelift/codegen/src/opts/cprop.isleindex 2e9ea307ec..e6ec5c84db 100644--- a/cranelift/codegen/src/opts/cprop.isle+++ b/cranelift/codegen/src/opts/cprop.isle@@ -1,5 +1,16 @@;; Constant propagation.+(rule (simplify+ (clz (fits_in_64 ty)+ (iconst ty kx)))+ (subsume (iconst ty (imm64_clz ty kx))))+++(rule (simplify+ (ctz (fits_in_64 ty)+ (iconst ty kx)))+ (subsume (iconst ty (imm64_ctz ty kx))))+(rule (simplify(iadd (fits_in_64 ty)(iconst ty (u64_from_imm64 k1))@@ -20,16 +31,28 @@(rule (simplify_skeleton(sdiv (iconst ty k1)- (iconst _ k2)))+ (iconst ty k2)))(if-let d (imm64_sdiv ty k1 k2))(iconst ty d))+(rule (simplify_skeleton+ (srem (iconst ty k1)+ (iconst ty k2)))+ (if-let d (imm64_srem ty k1 k2))+ (iconst ty d))+(rule (simplify_skeleton(udiv (iconst_u ty k1)(iconst_u ty k2)))(if-let d (u64_checked_div k1 k2))(iconst ty (imm64_masked ty d)))+(rule (simplify_skeleton+ (urem (iconst_u ty k1)+ (iconst_u ty k2)))+ (if-let d (u64_checked_rem k1 k2))+ (iconst ty (imm64_masked ty d)))+(rule (simplify(bor (fits_in_64 ty)(iconst ty (u64_from_imm64 k1))diff --git a/cranelift/codegen/src/prelude.isle b/cranelift/codegen/src/prelude.isleindex 20a61cde2e..f6493c7987 100644--- a/cranelift/codegen/src/prelude.isle+++ b/cranelift/codegen/src/prelude.isle@@ -73,6 +73,9 @@(decl pure partial imm64_sdiv (Type Imm64 Imm64) Imm64)(extern constructor imm64_sdiv imm64_sdiv)+(decl pure partial imm64_srem (Type Imm64 Imm64) Imm64)+(extern constructor imm64_srem imm64_srem)+(decl pure imm64_shl (Type Imm64 Imm64) Imm64)(extern constructor imm64_shl imm64_shl)@@ -96,6 +99,12 @@(decl pure imm64_icmp (Type IntCC Imm64 Imm64) Imm64)(extern constructor imm64_icmp imm64_icmp)+(decl pure imm64_clz (Type Imm64) Imm64)+(extern constructor imm64_clz imm64_clz)++(decl pure imm64_ctz (Type Imm64) Imm64)+(extern constructor imm64_ctz imm64_ctz)+;; Each of these extractors tests whether the upper half of the input equals the;; lower half of the input(decl u128_replicated_u64 (u64) u128)diff --git a/cranelift/filetests/filetests/egraph/cprop.clif b/cranelift/filetests/filetests/egraph/cprop.clifindex 87559027a0..fd3d88cb22 100644--- a/cranelift/filetests/filetests/egraph/cprop.clif+++ b/cranelift/filetests/filetests/egraph/cprop.clif@@ -22,6 +22,43 @@ block0:; check: v3 = iconst.i16 -2; nextln: return v3+function %f0() -> i8 {+block0:+ v1 = iconst.i8 51+ v2 = clz.i8 v1+ return v2+}++function %f0() -> i16 {+block0:+ v1 = iconst.i16 51+ v2 = clz.i16 v1+ return v2+}++; check: v3 = iconst.i16 10+; nextln: return v3++function %f0() -> i16 {+block0:+ v1 = iconst.i16 48+ v2 = ctz.i16 v1+ return v2+}++; check: v3 = iconst.i16 4+; nextln: return v3++function %f0() -> i16 {+block0:+ v1 = iconst.i16 0+ v2 = ctz.i16 v1+ return v2+}++; check: v3 = iconst.i16 16+; nextln: return v3+function %ishl() -> i8 {block0:v0 = iconst.i8 1diff --git a/cranelift/filetests/filetests/egraph/skeleton.clif b/cranelift/filetests/filetests/egraph/skeleton.clifindex 81289c74e8..a1c3c79f3a 100644--- a/cranelift/filetests/filetests/egraph/skeleton.clif+++ b/cranelift/filetests/filetests/egraph/skeleton.clif@@ -95,6 +95,21 @@ block0:; return v18 ; v18 = 1; }+function %cprop_urem() -> i32 {+block0:+ v0 = iconst.i32 13+ v1 = iconst.i32 7+ v2 = urem v0, v1+ return v2+}++; function %cprop_urem() -> i32 fast {+; block0:+; v37 = iconst.i32 6+; v2 -> v37+; return v37 ; v37 = 6+; }+function %cprop_sdiv() -> i32 {block0:v0 = iconst.i32 -7@@ -110,6 +125,68 @@ block0:; return v11 ; v11 = -1; }+function %cprop_sdiv_i8_min() -> i8 {+block0:+ v0 = iconst.i8 -128+ v1 = iconst.i8 -1+ v2 = sdiv v0, v1+ return v2+}++;function %cprop_sdiv_i8_min() -> i8 fast {+;block0:+; v0 = iconst.i8 -128+; v1 = iconst.i8 -1+; v2 = sdiv v0, v1 ; v0 = -128, v1 = -1+; return v2+;}++function %cprop_srem_i8_min() -> i8 {+block0:+ v0 = iconst.i8 -128+ v1 = iconst.i8 -1+ v2 = srem v0, v1+ return v2+}++;function %cprop_srem_i8_min() -> i8 fast {+;block0:+; v3 = iconst.i8 0+; v2 -> v3+; return v3 ; v3 = 0+;}++function %cprop_srem_i64_min() -> i64 {+block0:+ v0 = iconst.i64 -9223372036854775808+ v1 = iconst.i64 -1+ v2 = srem v0, v1+ return v2+}++;function %cprop_srem_i64_min() -> i64 fast {+;block0:+; v3 = iconst.i64 0+; v2 -> v3+; return v3 ; v3 = 0+;}++function %cprop_srem() -> i32 {+block0:+ v0 = iconst.i32 -17+ v1 = iconst.i32 7+ v2 = srem v0, v1+ return v2+}++; function %cprop_srem() -> i32 fast {+; block0:+; v28 = iconst.i32 -3+; v2 -> v28+; return v28 ; v28 = -3+; }++function %udiv_by_one(i32) -> i32 {block0(v0: i32):v1 = iconst.i32 1@@ -228,4 +305,3 @@ block0:; v2 = uadd_overflow_trap v0, v1, user42 ; v0 = -1, v1 = 1; return v2; }-diff --git a/cranelift/filetests/filetests/runtests/srem_opts.clif b/cranelift/filetests/filetests/runtests/srem_opts.clifnew file mode 100644index 0000000000..8ba1aa13a9--- /dev/null+++ b/cranelift/filetests/filetests/runtests/srem_opts.clif@@ -0,0 +1,405 @@+test interpret+test run+set opt_level=none+target aarch64+target x86_64+target x86_64 has_avx+target s390x+target riscv64+target riscv64 has_c has_zcb+target pulley32+target pulley32be+target pulley64+target pulley64be++set opt_level=speed+target aarch64+target x86_64+target x86_64 has_avx+target s390x+target riscv64+target riscv64 has_c has_zcb+target pulley32+target pulley32be+target pulley64+target pulley64be+++function %srem_i64(i64, i64) -> i64 {+block0(v0: i64,v1: i64):+ v2 = srem v0, v1+ return v2+}+; run: %srem_i64(0, 1) == 0+; run: %srem_i64(2, 2) == 0+; run: %srem_i64(1, -1) == 0+; run: %srem_i64(3, 2) == 1+; run: %srem_i64(19, 7) == 5+; run: %srem_i64(3, -2) == 1+; run: %srem_i64(-19, 7) == -5+; run: %srem_i64(-57, -5) == -2+; run: %srem_i64(0, 104857600000) == 0+; run: %srem_i64(104857600000, 511) == 398+; run: %srem_i64(0xC0FFEEEE_DECAFFFF, 8) == -1+; run: %srem_i64(0xC0FFEEEE_DECAFFFF, -8) == -1+; run: %srem_i64(0x80000000_00000000, -2) == 0++function %srem_i32(i32, i32) -> i32 {+block0(v0: i32,v1: i32):+ v2 = srem v0, v1+ return v2+}+; run: %srem_i32(0, 1) == 0+; run: %srem_i32(2, 2) == 0+; run: %srem_i32(1, -1) == 0+; run: %srem_i32(3, 2) == 1+; run: %srem_i32(19, 7) == 5+; run: %srem_i32(3, -2) == 1+; run: %srem_i32(-19, 7) == -5+; run: %srem_i32(0, 13) == 0+; run: %srem_i32(1048576, 8192) == 0+; run: %srem_i32(-1024, 255) == -4+; run: %srem_i32(0xC0FFEEEE, 8) == -2+; run: %srem_i32(0xC0FFEEEE, -8) == -2+; run: %srem_i32(0x80000000, -2) == 0++function %srem_i16(i16, i16) -> i16 {+block0(v0: i16,v1: i16):+ v2 = srem v0, v1+ return v2+}+; run: %srem_i16(0, 1) == 0+; run: %srem_i16(2, 2) == 0+; run: %srem_i16(1, -1) == 0+; run: %srem_i16(3, 2) == 1+; run: %srem_i16(19, 7) == 5+; run: %srem_i16(3, -2) == 1+; run: %srem_i16(13, 5) == 3+; run: %srem_i16(0, 42) == 0+; run: %srem_i16(4, -2) == 0+; run: %srem_i16(-19, 7) == -5+; run: %srem_i16(0xC0FF, 8) == -1+; run: %srem_i16(0xC0FF, -8) == -1+; run: %srem_i16(0x8000, -2) == 0++function %srem_i8(i8, i8) -> i8 {+block0(v0: i8,v1: i8):+ v2 = srem v0, v1+ return v2+}+; run: %srem_i8(0, 1) == 0+; run: %srem_i8(2, 2) == 0+; run: %srem_i8(1, -1) == 0+; run: %srem_i8(2, 7) == 2+; run: %srem_i8(3, 2) == 1+; run: %srem_i8(19, 7) == 5+; run: %srem_i8(3, -2) == 1+; run: %srem_i8(-19, 7) == -5+; run: %srem_i8(0xC0, 8) == 0+; run: %srem_i8(0xC0, -8) == 0+; run: %srem_i8(0x80, -2) == 0+++function %srem_imm_i64(i64) -> i64 {+block0(v0: i64):+ v1 = srem_imm v0, 3+ return v1+}+; run: %srem_imm_i64(0) == 0+; run: %srem_imm_i64(1) == 1+; run: %srem_imm_i64(2) == 2+; run: %srem_imm_i64(3) == 0+; run: %srem_imm_i64(19) == 1+; run: %srem_imm_i64(-19) == -1+; run: %srem_imm_i64(-57) == 0+; run: %srem_imm_i64(104857600000) == 1+; run: %srem_imm_i64(0xC0FFEEEE_DECAFFFF) == -1+; run: %srem_imm_i64(0x80000000_00000000) == -2++function %srem_imm_i32(i32) -> i32 {+block0(v0: i32):+ v1 = srem_imm v0, 3+ return v1+}+; run: %srem_imm_i32(0) == 0+; run: %srem_imm_i32(1) == 1+; run: %srem_imm_i32(2) == 2+; run: %srem_imm_i32(3) == 0+; run: %srem_imm_i32(4) == 1+; run: %srem_imm_i32(19) == 1+; run: %srem_imm_i32(-19) == -1+; run: %srem_imm_i32(-42) == 0+; run: %srem_imm_i32(1057) == 1+; run: %srem_imm_i32(0xC0FFEEEE) == -2++function %srem_imm_i16(i16) -> i16 {+block0(v0: i16):+ v1 = srem_imm v0, 3+ return v1+}+; run: %srem_imm_i16(0) == 0+; run: %srem_imm_i16(1) == 1+; run: %srem_imm_i16(2) == 2+; run: %srem_imm_i16(3) == 0+; run: %srem_imm_i16(4) == 1+; run: %srem_imm_i16(19) == 1+; run: %srem_imm_i16(-19) == -1+; run: %srem_imm_i16(0xC0FF) == -1+; run: %srem_imm_i16(0x8000) == -2++function %srem_imm_i8(i8) -> i8 {+block0(v0: i8):+ v1 = srem_imm v0, 3+ return v1+}+; run: %srem_imm_i8(0) == 0+; run: %srem_imm_i8(1) == 1+; run: %srem_imm_i8(2) == 2+; run: %srem_imm_i8(3) == 0+; run: %srem_imm_i8(19) == 1+; run: %srem_imm_i8(-19) == -1+; run: %srem_imm_i8(0xC0) == -1+; run: %srem_imm_i8(0x80) == -2++function %srem_with_bmask(i64, i8) -> i8 {+block0(v0: i64, v1: i8):+ v2 = bmask.i8 v0+ v3 = srem v2, v1+ return v3+}+; run: %srem_with_bmask(4352, -1) == 0+; run: %srem_with_bmask(4352, 1) == 0++; === Constant Propagation Tests (Guaranteed Optimization) ===++; Basic constant folding tests - these should be optimized to constants+function %const_srem_basic_i64() -> i64 {+block0:+ v0 = iconst.i64 17+ v1 = iconst.i64 5+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_basic_i64() == 2++function %const_srem_negative_dividend_i64() -> i64 {+block0:+ v0 = iconst.i64 -17+ v1 = iconst.i64 5+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_negative_dividend_i64() == -2++function %const_srem_negative_divisor_i64() -> i64 {+block0:+ v0 = iconst.i64 17+ v1 = iconst.i64 -5+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_negative_divisor_i64() == 2++function %const_srem_both_negative_i64() -> i64 {+block0:+ v0 = iconst.i64 -17+ v1 = iconst.i64 -5+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_both_negative_i64() == -2++; Power of 2 divisors - these should be optimized to bit operations+function %const_srem_pow2_8_i64() -> i64 {+block0:+ v0 = iconst.i64 100+ v1 = iconst.i64 8+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_pow2_8_i64() == 4++function %const_srem_pow2_16_i64() -> i64 {+block0:+ v0 = iconst.i64 100+ v1 = iconst.i64 16+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_pow2_16_i64() == 4++function %const_srem_pow2_negative_i64() -> i64 {+block0:+ v0 = iconst.i64 -100+ v1 = iconst.i64 8+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_pow2_negative_i64() == -4++; Large constants that test overflow boundaries+function %const_srem_large_i64() -> i64 {+block0:+ v0 = iconst.i64 0x7FFFFFFFFFFFFFFE ; i64::MAX - 1+ v1 = iconst.i64 0x7FFFFFFFFFFFFFFF ; i64::MAX+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_large_i64() == 0x7FFFFFFFFFFFFFFE++; Test with 32-bit constants+function %const_srem_basic_i32() -> i32 {+block0:+ v0 = iconst.i32 2147483647 ; i32::MAX+ v1 = iconst.i32 1000000+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_basic_i32() == 483647++function %const_srem_pow2_i32() -> i32 {+block0:+ v0 = iconst.i32 1000+ v1 = iconst.i32 64+ v2 = srem v0, v1+ return v2+}+; run: %const_srem_pow2_i32() == 40++; Test immediate forms with guaranteed constant optimization+function %const_srem_imm_pow2_i64() -> i64 {+block0:+ v0 = iconst.i64 1000+ v1 = srem_imm v0, 16+ return v1+}+; run: %const_srem_imm_pow2_i64() == 8++function %const_srem_imm_non_pow2_i64() -> i64 {+block0:+ v0 = iconst.i64 1000+ v1 = srem_imm v0, 7+ return v1+}+; run: %const_srem_imm_non_pow2_i64() == 6++function %const_srem_imm_negative_i64() -> i64 {+block0:+ v0 = iconst.i64 -1000+ v1 = srem_imm v0, 7+ return v1+}+; run: %const_srem_imm_negative_i64() == -6++; === Additional Edge Cases ===++; Test zero dividend+function %srem_zero_dividend_i64(i64) -> i64 {+block0(v0: i64):+ v1 = iconst.i64 0+ v2 = srem v1, v0+ return v2+}+; run: %srem_zero_dividend_i64(5) == 0+; run: %srem_zero_dividend_i64(-5) == 0+; run: %srem_zero_dividend_i64(1) == 0+; run: %srem_zero_dividend_i64(-1) == 0++; Test remainder that equals dividend (divisor > dividend)+function %srem_larger_divisor_i64() -> i64 {+block0:+ v0 = iconst.i64 5+ v1 = iconst.i64 10+ v2 = srem v0, v1+ return v2+}+; run: %srem_larger_divisor_i64() == 5++function %srem_larger_divisor_negative_i64() -> i64 {+block0:+ v0 = iconst.i64 -5+ v1 = iconst.i64 10+ v2 = srem v0, v1+ return v2+}+; run: %srem_larger_divisor_negative_i64() == -5++; Test powers of 2 with various patterns+function %srem_pow2_pattern_test_i64() -> i64 {+block0:+ v0 = iconst.i64 -72340172838076674 ;+ v1 = iconst.i64 256+ v2 = srem v0, v1+ return v2+}+; run: %srem_pow2_pattern_test_i64() == -2++function %srem_pow2_pattern_test2_i64() -> i64 {+block0:+ v0 = iconst.i64 -72340172838076673 ;+ v1 = iconst.i64 256+ v2 = srem v0, v1+ return v2+}+; run: %srem_pow2_pattern_test2_i64() == -1++; Test mixed sign edge cases+function %srem_mixed_signs_edge1_i64() -> i64 {+block0:+ v0 = iconst.i64 -1+ v1 = iconst.i64 0x7FFFFFFFFFFFFFFF+ v2 = srem v0, v1+ return v2+}+; run: %srem_mixed_signs_edge1_i64() == -1++function %srem_mixed_signs_edge2_i64() -> i64 {+block0:+ v0 = iconst.i64 0x7FFFFFFFFFFFFFFF+ v1 = iconst.i64 -2+ v2 = srem v0, v1+ return v2+}+; run: %srem_mixed_signs_edge2_i64() == 1+++function %srem_imm_pow2_more_i64(i64) -> i64 {+block0(v0: i64):+ v1 = srem_imm v0, 32+ return v1+}+; run: %srem_imm_pow2_more_i64(100) == 4+; run: %srem_imm_pow2_more_i64(-100) == -4+; run: %srem_imm_pow2_more_i64(31) == 31+; run: %srem_imm_pow2_more_i64(-31) == -31++function %srem_imm_pow2_more_i32(i32) -> i32 {+block0(v0: i32):+ v1 = srem_imm v0, 64+ return v1+}+; run: %srem_imm_pow2_more_i32(100) == 36+; run: %srem_imm_pow2_more_i32(-100) == -36+; run: %srem_imm_pow2_more_i32(63) == 63+; run: %srem_imm_pow2_more_i32(-63) == -63++; Test larger non-power-of-2 immediates+function %srem_imm_large_i64(i64) -> i64 {+block0(v0: i64):+ v1 = srem_imm v0, 1337+ return v1+}+; run: %srem_imm_large_i64(10000) == 641+; run: %srem_imm_large_i64(-10000) == -641+; run: %srem_imm_large_i64(1336) == 1336+; run: %srem_imm_large_i64(-1336) == -1336++function %srem_imm_prime_i64(i64) -> i64 {+block0(v0: i64):+ v1 = srem_imm v0, 97+ return v1+}+; run: %srem_imm_prime_i64(1000) == 30+; run: %srem_imm_prime_i64(-1000) == -30+; run: %srem_imm_prime_i64(96) == 96+; run: %srem_imm_prime_i64(-96) == -96