Fix NaN correctness for ordered float reflexive rules and merge_idx guard

- Disable FOrdEq(x,x), FOrdLe(x,x), FOrdGe(x,x) reflexive rules in
  logical.egg: IEEE 754 says NaN is not ordered with itself, so these
  return false for NaN inputs.  Keep FOrdLt/FOrdGt reflexive rules
  (strict inequality is always false, correct for NaN).
- Add merge_idx < header_idx safety guard in both selection and switch
  construct RVSDG guards: non-standard block ordering could cause
  empty/invalid ranges.
- Update test_boolconst_float_comparison_reflexive to verify FOrdEq(x,x)
  is NOT folded (NaN correctness) and FOrdLt(x,x) IS folded.

Author: LegNeato

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

@@ -632,11 +632,15 @@ pub fn optimize_module_direct(module: &Module) -> Result<Module, EgglogOptError>
             let label_map = &func_block_labels[sel.func_idx];
             let merge_idx = label_map.get(&sel.merge_label).copied();
             let in_loop = if let Some(merge_idx) = merge_idx {
-                // Check all blocks from header to merge (inclusive)
-                (sel.header_block_idx..=merge_idx).any(|idx| {
-                    loop_block_set.contains(&(sel.func_idx, idx))
-                        || continue_block_set.contains(&(sel.func_idx, idx))
-                })
+                // Check all blocks from header to merge (inclusive).
+                if merge_idx < sel.header_block_idx {
+                    true // Non-standard block ordering — skip to be safe
+                } else {
+                    (sel.header_block_idx..=merge_idx).any(|idx| {
+                        loop_block_set.contains(&(sel.func_idx, idx))
+                            || continue_block_set.contains(&(sel.func_idx, idx))
+                    })
+                }
             } else {
                 // Can't resolve merge — skip to be safe
                 true
@@ -754,10 +758,14 @@ pub fn optimize_module_direct(module: &Module) -> Result<Module, EgglogOptError>
             let label_map = &func_block_labels[sw.func_idx];
             let merge_idx = label_map.get(&sw.merge_label).copied();
             let in_loop = if let Some(merge_idx) = merge_idx {
-                (sw.header_block_idx..=merge_idx).any(|idx| {
-                    loop_block_set.contains(&(sw.func_idx, idx))
-                        || continue_block_set.contains(&(sw.func_idx, idx))
-                })
+                if merge_idx < sw.header_block_idx {
+                    true // Non-standard block ordering — skip to be safe
+                } else {
+                    (sw.header_block_idx..=merge_idx).any(|idx| {
+                        loop_block_set.contains(&(sw.func_idx, idx))
+                            || continue_block_set.contains(&(sw.func_idx, idx))
+                    })
+                }
             } else {
                 true
             };

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

@@ -6557,7 +6557,9 @@ fn test_boolconst_logical_tautology() {
 
 #[test]
 fn test_boolconst_float_comparison_reflexive() {
-    // FOrdEq(x, x) should produce BoolConst(1)
+    // FOrdEq(x, x) must NOT fold to BoolConst(1) because x could be NaN.
+    // IEEE 754: NaN is not ordered with itself, so FOrdEq(NaN, NaN) = false.
+    // Only FOrdLt(x,x) and FOrdGt(x,x) are always false (correct for NaN too).
     let mut egraph = create_spirv_egraph().unwrap();
 
     egraph
@@ -6566,16 +6568,29 @@ fn test_boolconst_float_comparison_reflexive() {
             r#"
         (let x (FSym "f"))
         (let root (FOrdEq x x))
-        (let expected (BoolConst 1))
+        (let wrong (BoolConst 1))
+        (let lt_root (FOrdLt x x))
+        (let false_val (BoolConst 0))
     "#,
         )
         .unwrap();
     egraph
         .parse_and_run_program(None, "(run-schedule (repeat 10 (run)))")
         .unwrap();
 
-    let check = egraph.parse_and_run_program(None, "(check (= root expected))");
-    assert!(check.is_ok(), "FOrdEq(x, x) should fold to BoolConst(1)");
+    // FOrdEq(x,x) must NOT be folded (NaN correctness)
+    let check = egraph.parse_and_run_program(None, "(check (= root wrong))");
+    assert!(
+        check.is_err(),
+        "FOrdEq(x, x) must NOT fold to BoolConst(1) — wrong for NaN"
+    );
+
+    // FOrdLt(x,x) IS correctly folded to BoolConst(0)
+    let check2 = egraph.parse_and_run_program(None, "(check (= lt_root false_val))");
+    assert!(
+        check2.is_ok(),
+        "FOrdLt(x, x) should fold to BoolConst(0)"
+    );
 }
 
 #[test]

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

@@ -459,16 +459,24 @@
 ; =============================================================================
 
 ; Floating-point reflexive comparisons
+; DISABLED: Ordered float reflexive comparisons — wrong for NaN.
+; IEEE 754: NaN is NOT ordered with itself, so FOrdLe(NaN,NaN) = false,
+; FOrdEq(NaN,NaN) = false, etc. Only unordered comparisons return true for NaN.
+; The correct rules would be:
+;   FOrdEq(x,x) = LogNot(IsNan(x))
+;   FOrdLt(x,x) = BoolConst(0) (correct: nothing is strictly less than itself)
+;   FOrdGt(x,x) = BoolConst(0) (correct: same)
+; FOrdLt/FOrdGt reflexive rules ARE correct (strict inequality is always false).
 (rule ((= e (FOrdLt a a)))
       ((union e (BoolConst 0))))
 (rule ((= e (FOrdGt a a)))
       ((union e (BoolConst 0))))
-(rule ((= e (FOrdLe a a)))
-      ((union e (BoolConst 1))))
-(rule ((= e (FOrdGe a a)))
-      ((union e (BoolConst 1))))
-(rule ((= e (FOrdEq a a)))
-      ((union e (BoolConst 1))))
+; (rule ((= e (FOrdLe a a)))
+;       ((union e (BoolConst 1))))
+; (rule ((= e (FOrdGe a a)))
+;       ((union e (BoolConst 1))))
+; (rule ((= e (FOrdEq a a)))
+;       ((union e (BoolConst 1))))
 (rule ((= e (FOrdNe a a)))
       ((union e (BoolConst 0))))