egraphs: Const propagate bitwise float operations (#8625)

* egraphs: Const propagate bitwise float operations

* egraphs: Move float bitwise operations to prelude.isle

Author: afonso360

cranelift/codegen/src/isle_prelude.rs

@@ -953,5 +953,29 @@ macro_rules! isle_common_prelude_methods {
                 None
             }
         }
+
+        fn f32_neg(&mut self, n: Ieee32) -> Ieee32 {
+            n.neg()
+        }
+
+        fn f32_abs(&mut self, n: Ieee32) -> Ieee32 {
+            n.abs()
+        }
+
+        fn f32_copysign(&mut self, a: Ieee32, b: Ieee32) -> Ieee32 {
+            a.copysign(b)
+        }
+
+        fn f64_neg(&mut self, n: Ieee64) -> Ieee64 {
+            n.neg()
+        }
+
+        fn f64_abs(&mut self, n: Ieee64) -> Ieee64 {
+            n.abs()
+        }
+
+        fn f64_copysign(&mut self, a: Ieee64, b: Ieee64) -> Ieee64 {
+            a.copysign(b)
+        }
     };
 }

cranelift/codegen/src/opts/cprop.isle

@@ -279,3 +279,19 @@
 (extern constructor u64_bswap32 u64_bswap32)
 (decl pure u64_bswap64 (u64) u64)
 (extern constructor u64_bswap64 u64_bswap64)
+
+;; Constant fold bitwise float operations (fneg/fabs/fcopysign)
+(rule (simplify (fneg $F32 (f32const $F32 n)))
+      (subsume (f32const $F32 (f32_neg n))))
+(rule (simplify (fneg $F64 (f64const $F64 n)))
+      (subsume (f64const $F64 (f64_neg n))))
+
+(rule (simplify (fabs $F32 (f32const $F32 n)))
+      (subsume (f32const $F32 (f32_abs n))))
+(rule (simplify (fabs $F64 (f64const $F64 n)))
+      (subsume (f64const $F64 (f64_abs n))))
+
+(rule (simplify (fcopysign $F32 (f32const $F32 n) (f32const $F32 m)))
+      (subsume (f32const $F32 (f32_copysign n m))))
+(rule (simplify (fcopysign $F64 (f64const $F64 n) (f64const $F64 m)))
+      (subsume (f64const $F64 (f64_copysign n m))))

cranelift/codegen/src/prelude.isle

@@ -234,6 +234,21 @@
 (decl u16_replicated_u8 (u8) u64)
 (extern extractor u16_replicated_u8 u16_replicated_u8)
 
+;; Floating point operations
+
+(decl pure f32_neg (Ieee32) Ieee32)
+(extern constructor f32_neg f32_neg)
+(decl pure f32_abs (Ieee32) Ieee32)
+(extern constructor f32_abs f32_abs)
+(decl pure f32_copysign (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_copysign f32_copysign)
+(decl pure f64_neg (Ieee64) Ieee64)
+(extern constructor f64_neg f64_neg)
+(decl pure f64_abs (Ieee64) Ieee64)
+(extern constructor f64_abs f64_abs)
+(decl pure f64_copysign (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_copysign f64_copysign)
+
 ;;;; `cranelift_codegen::ir::Type` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (extern const $I8 Type)

cranelift/filetests/filetests/egraph/cprop.clif

@@ -312,3 +312,65 @@ block0:
 
 ; check: v2 = iconst.i64 0xf0de_bc9a_7856_3412
 ; nextln: return v2
+
+function %f32_fneg() -> f32 {
+block0:
+    v1 = f32const 0.0
+    v2 = fneg v1
+    return v2
+}
+
+; check: v3 = f32const -0.0
+; check: return v3  ; v3 = -0.0
+
+function %f32_fabs() -> f32 {
+block0:
+    v1 = f32const -0.0
+    v2 = fabs v1
+    return v2
+}
+
+; check: v3 = f32const 0.0
+; check: return v3  ; v3 = 0.0
+
+function %f32_fabs() -> f32 {
+block0:
+    v1 = f32const -0.0
+    v2 = f32const NaN
+    v3 = fcopysign v2, v1
+    return v3
+}
+
+; check: v4 = f32const -NaN
+; check: return v4  ; v4 = -NaN
+
+function %f64_fneg() -> f64 {
+block0:
+    v1 = f64const 0.0
+    v2 = fneg v1
+    return v2
+}
+
+; check: v3 = f64const -0.0
+; check: return v3  ; v3 = -0.0
+
+function %f64_fabs() -> f64 {
+block0:
+    v1 = f64const -0.0
+    v2 = fabs v1
+    return v2
+}
+
+; check: v3 = f64const 0.0
+; check: return v3  ; v3 = 0.0
+
+function %f64_fabs() -> f64 {
+block0:
+    v1 = f64const -0.0
+    v2 = f64const NaN
+    v3 = fcopysign v2, v1
+    return v3
+}
+
+; check: v4 = f64const -NaN
+; check: return v4  ; v4 = -NaN