[InstSimplify] fold uno/ord comparison if fpclass is always NaN

Author: AlexMaclean

llvm/include/llvm/Analysis/ValueTracking.h

@@ -276,6 +276,8 @@ struct KnownFPClass {
     return (KnownFPClasses & Mask) == fcNone;
   }
 
+  bool isKnownAlways(FPClassTest Mask) const { return isKnownNever(~Mask); }
+
   bool isUnknown() const {
     return KnownFPClasses == fcAllFlags && !SignBit;
   }
@@ -285,6 +287,9 @@ struct KnownFPClass {
     return isKnownNever(fcNan);
   }
 
+  /// Return true if it's known this must always be a nan.
+  bool isKnownAlwaysNaN() const { return isKnownAlways(fcNan); }
+
   /// Return true if it's known this can never be an infinity.
   bool isKnownNeverInfinity() const {
     return isKnownNever(fcInf);

llvm/lib/Analysis/InstructionSimplify.cpp

@@ -4117,9 +4117,14 @@ static Value *simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
   // This catches the 2 variable input case, constants are handled below as a
   // class-like compare.
   if (Pred == FCmpInst::FCMP_ORD || Pred == FCmpInst::FCMP_UNO) {
-    if (FMF.noNaNs() || (isKnownNeverNaN(RHS, /*Depth=*/0, Q) &&
-                         isKnownNeverNaN(LHS, /*Depth=*/0, Q)))
+    KnownFPClass RHSClass = computeKnownFPClass(RHS, fcAllFlags, 0, Q);
+    KnownFPClass LHSClass = computeKnownFPClass(LHS, fcAllFlags, 0, Q);
+    if (FMF.noNaNs() ||
+        (RHSClass.isKnownNeverNaN() && LHSClass.isKnownNeverNaN()))
       return ConstantInt::get(RetTy, Pred == FCmpInst::FCMP_ORD);
+
+    if (RHSClass.isKnownAlwaysNaN() || LHSClass.isKnownAlwaysNaN())
+      return ConstantInt::get(RetTy, Pred == CmpInst::FCMP_UNO);
   }
 
   const APFloat *C = nullptr;

llvm/test/Transforms/InstSimplify/floating-point-compare.ll

@@ -678,8 +678,7 @@ define i1 @assume_nan_x2_uno(float %x, float %y) {
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[UNO_X]])
 ; CHECK-NEXT:    [[UNO_Y:%.*]] = fcmp uno float [[Y:%.*]], 0.000000e+00
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[UNO_Y]])
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno float [[X]], [[Y]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 true
 ;
   %uno.x = fcmp uno float %x, 0.0
   call void @llvm.assume(i1 %uno.x)
@@ -695,8 +694,7 @@ define i1 @assume_nan_x2_ord(float %x, float %y) {
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[UNO_X]])
 ; CHECK-NEXT:    [[UNO_Y:%.*]] = fcmp uno float [[Y:%.*]], 0.000000e+00
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[UNO_Y]])
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ord float [[X]], [[Y]]
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    ret i1 false
 ;
   %uno.x = fcmp uno float %x, 0.0
   call void @llvm.assume(i1 %uno.x)