Bitcast constant folding across int/float types

Add cross-type bitcast constant folding that reinterprets bit patterns:
- Integer → float: Bitcast(IntToExpr(Const N)) → FloatToExpr(FConst f)
  with 32-bit width guard via ResultWidth, and unconditional for Const64
- Float → integer: Bitcast(FloatToExpr(FConst f)) → IntToExpr(Const n)

Four new primitives handle the bit reinterpretation:
- bitcast-i32-to-f: lower 32 bits as f32, promoted to f64
- bitcast-i64-to-f: all 64 bits as f64
- bitcast-f-to-i32: f64 demoted to f32, bits as i64
- bitcast-f-to-i64: f64 bits as i64

This matches the C++ BitCastScalarOrVector folding rule.

Author: LegNeato

rust/spirv-tools-opt/src/egglog_opt/mod.rs

@@ -487,6 +487,26 @@ fn float_neg_bits(a: i64) -> i64 {
     }
 }
 
+/// Bitcast 32-bit integer constant to f64 (reinterpret lower 32 bits as f32, promote to f64).
+fn bitcast_int_to_float32(v: i64) -> f64 {
+    f32::from_bits(v as u32) as f64
+}
+
+/// Bitcast 64-bit integer constant to f64 (reinterpret bits as f64).
+fn bitcast_int_to_float64(v: i64) -> f64 {
+    f64::from_bits(v as u64)
+}
+
+/// Bitcast f64 constant to 32-bit integer (demote to f32, get u32 bits).
+fn bitcast_float_to_int32(v: f64) -> i64 {
+    (v as f32).to_bits() as i64
+}
+
+/// Bitcast f64 constant to 64-bit integer (get u64 bits).
+fn bitcast_float_to_int64(v: f64) -> i64 {
+    v.to_bits() as i64
+}
+
 /// SConvert constant fold: sign-extend or truncate to target width.
 fn sconvert_fold(v: i64, dst_width: i64) -> i64 {
     let dw = dst_width as u32;
@@ -908,6 +928,20 @@ pub fn create_spirv_egraph() -> Result<EGraph, EgglogOptError> {
         uconvert_fold(v, sw, dw)
     });
 
+    // Bitcast constant folding primitives (cross int/float reinterpretation)
+    add_primitive!(&mut egraph, "bitcast-i32-to-f" = |v: i64| -> F {
+        F::from(OrderedFloat(bitcast_int_to_float32(v)))
+    });
+    add_primitive!(&mut egraph, "bitcast-i64-to-f" = |v: i64| -> F {
+        F::from(OrderedFloat(bitcast_int_to_float64(v)))
+    });
+    add_primitive!(&mut egraph, "bitcast-f-to-i32" = |v: F| -> i64 {
+        bitcast_float_to_int32(v.0.0)
+    });
+    add_primitive!(&mut egraph, "bitcast-f-to-i64" = |v: F| -> i64 {
+        bitcast_float_to_int64(v.0.0)
+    });
+
     // Now load the base SPIR-V language and rules (which use the primitives above)
     egraph
         .parse_and_run_program(None, SPIRV_EGGLOG_PROGRAM)

rust/spirv-tools-opt/src/rules/primitives.egg

@@ -486,13 +486,25 @@
 ; =============================================================================
 ; BitCast Constant Folding
 ; =============================================================================
-; Bitcast of a constant preserves the bit pattern (identity).
-
+; Same-sort bitcast preserves the bit pattern (identity).
 (rule ((= e (Bitcast (IntToExpr (Const a)))))
       ((union e (IntToExpr (Const a)))))
 (rule ((= e (BitCast (IntToExpr (Const a)))))
       ((union e (IntToExpr (Const a)))))
 
+; Cross-type bitcast: reinterpret integer bits as float (32-bit)
+(rule ((= e (Bitcast (IntToExpr (Const a))))
+       (= 32 (ResultWidth (Const a))))
+      ((union e (FloatToExpr (FConst (bitcast-i32-to-f a))))))
+
+; Cross-type bitcast: reinterpret integer bits as float (64-bit)
+(rule ((= e (Bitcast (IntToExpr (Const64 a)))))
+      ((union e (FloatToExpr (FConst (bitcast-i64-to-f a))))))
+
+; Cross-type bitcast: reinterpret float bits as integer (32-bit)
+(rule ((= e (Bitcast (FloatToExpr (FConst a)))))
+      ((union e (IntToExpr (Const (bitcast-f-to-i32 a))))))
+
 ; =============================================================================
 ; SConvert/UConvert Constant Folding
 ; =============================================================================