Fold arith.cmpf when at least one operand is known to be NaN.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

 }
 
 OpFoldResult arith::CmpFOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "cmpf takes two operands");
 
   auto lhs = operands.front().dyn_cast_or_null<FloatAttr>();
   auto rhs = operands.back().dyn_cast_or_null<FloatAttr>();
 
+  // If one operand is NaN, making them both NaN does not change the result.
+  if (lhs && lhs.getValue().isNaN())
+    rhs = lhs;
+  if (rhs && rhs.getValue().isNaN())
+    lhs = rhs;
+
   if (!lhs || !rhs)
     return {};
 
   auto val = applyCmpPredicate(getPredicate(), lhs.getValue(), rhs.getValue());
   return BoolAttr::get(getContext(), val);
 }
 
 //===----------------------------------------------------------------------===//

mlir/test/Dialect/Arithmetic/canonicalize.mlir

func @constant_MinMax(%arg0 : f32) -> f32 {
   // CHECK:  %[[min:.+]] = arith.minf %arg0, %[[const]] : f32
   // CHECK:  %[[res:.+]] = arith.maxf %[[min]], %[[const]] : f32
   // CHECK:   return %[[res]]
   %const = arith.constant 0.0 : f32
   %min = arith.minf %const, %arg0 : f32
   %res = arith.maxf %const, %min : f32
   return %res : f32
 }
+
+// -----
+// CHECK-LABEL: @cmpf_nan(
+func @cmpf_nan(%arg0 : f32) -> (i1, i1, i1, i1) {
+//   CHECK-DAG:   %[[T:.*]] = arith.constant true
+//   CHECK-DAG:   %[[F:.*]] = arith.constant false
+//       CHECK:   return %[[F]], %[[F]], %[[T]], %[[T]]
+  %nan = arith.constant 0x7fffffff : f32
+  %0 = arith.cmpf olt, %nan, %arg0 : f32
+  %1 = arith.cmpf olt, %arg0, %nan : f32
+  %2 = arith.cmpf ugt, %nan, %arg0 : f32
+  %3 = arith.cmpf ugt, %arg0, %nan : f32
+  return %0, %1, %2, %3 : i1, i1, i1, i1
+}