Remove cross-type bitcast constant folding rules

These rules fire without knowing the target type, so they also fire on
same-type bitcasts (e.g. float→float), polluting e-classes with
wrong-type values (IntToExpr in a FloatExpr context). This caused type
mismatch errors in the difftests (matrix_ops, vector_extract_insert).
Same-type elimination via SameTypeBitcast is retained.

Author: LegNeato

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

@@ -495,25 +495,6 @@ 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 {
@@ -1134,24 +1115,6 @@ pub fn create_spirv_egraph() -> Result<EGraph, EgglogOptError> {
         "uconvert-fold" = |v: i64, sw: i64, dw: i64| -> i64 { 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

@@ -492,18 +492,10 @@
 (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))))))
+; Cross-type bitcast constant folding is intentionally omitted.
+; Without target type info in the egraph, these rules fire for same-type
+; bitcasts too, polluting e-classes with wrong-type values (e.g., putting
+; IntToExpr in a FloatExpr context). Use SameTypeBitcast for elimination.
 
 ; =============================================================================
 ; SConvert/UConvert Constant Folding