[InstSimplify] fold and/or of fcmp ord/uno when operand is known nnan

[spatel]

Summary

The 'ord' and 'uno' predicates have a logic operation for NAN built into their definitions:

FCMP_ORD   =  7,  ///< 0 1 1 1    True if ordered (no nans)
FCMP_UNO   =  8,  ///< 1 0 0 0    True if unordered: isnan(X) | isnan(Y)

So we can simplify patterns like this:

(fcmp ord NNAN, X) && (fcmp ord X, Y) --> fcmp ord X, Y
(fcmp uno NNAN, X) || (fcmp uno X, Y) --> fcmp uno X, Y

[spatel]

For motivational reference, this is a continuation of D37427 with a goal of solving patterns as seen in PR27145:
https://bugs.llvm.org/show_bug.cgi?id=27145

[efriedma]

From the perspective of canonicalization, it seems kind of weird to have "%x uno %y" rather than "(%x uno 0) | (%y uno 0)". I mean, the former is probably cheaper to lower, but it leads to a lot of special-case logic to handle the equivalency.

[efriedma]

That said, this transform seems straightforward enough. LGTM.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

static Value *simplifyOrOfICmps(ICmpInst *Op0, ICmpInst *Op1) {
   if (Value *X = simplifyOrOfICmpsWithAdd(Op0, Op1))
     return X;
   if (Value *X = simplifyOrOfICmpsWithAdd(Op1, Op0))
     return X;
 
   return nullptr;
 }
 
-static Value *simplifyAndOrOfICmps(Value *Op0, Value *Op1, bool IsAnd) {
+static Value *simplifyAndOrOfFCmps(FCmpInst *LHS, FCmpInst *RHS, bool IsAnd) {
+  Value *LHS0 = LHS->getOperand(0), *LHS1 = LHS->getOperand(1);
+  Value *RHS0 = RHS->getOperand(0), *RHS1 = RHS->getOperand(1);
+  if (LHS0->getType() != RHS0->getType())
+    return nullptr;
+
+  FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
+  if ((PredL == FCmpInst::FCMP_ORD && PredR == FCmpInst::FCMP_ORD && IsAnd) ||
+      (PredL == FCmpInst::FCMP_UNO && PredR == FCmpInst::FCMP_UNO && !IsAnd)) {
+    // (fcmp ord NNAN, X) & (fcmp ord X, Y) --> fcmp ord X, Y
+    // (fcmp ord NNAN, X) & (fcmp ord Y, X) --> fcmp ord Y, X
+    // (fcmp ord X, NNAN) & (fcmp ord X, Y) --> fcmp ord X, Y
+    // (fcmp ord X, NNAN) & (fcmp ord Y, X) --> fcmp ord Y, X
+    // (fcmp uno NNAN, X) | (fcmp uno X, Y) --> fcmp uno X, Y
+    // (fcmp uno NNAN, X) | (fcmp uno Y, X) --> fcmp uno Y, X
+    // (fcmp uno X, NNAN) | (fcmp uno X, Y) --> fcmp uno X, Y
+    // (fcmp uno X, NNAN) | (fcmp uno Y, X) --> fcmp uno Y, X
+    if ((isKnownNeverNaN(LHS0) && (LHS1 == RHS0 || LHS1 == RHS1)) ||
+        (isKnownNeverNaN(LHS1) && (LHS0 == RHS0 || LHS0 == RHS1)))
+      return RHS;
+
+    // (fcmp ord X, Y) & (fcmp ord NNAN, X) --> fcmp ord X, Y
+    // (fcmp ord Y, X) & (fcmp ord NNAN, X) --> fcmp ord Y, X
+    // (fcmp ord X, Y) & (fcmp ord X, NNAN) --> fcmp ord X, Y
+    // (fcmp ord Y, X) & (fcmp ord X, NNAN) --> fcmp ord Y, X
+    // (fcmp uno X, Y) | (fcmp uno NNAN, X) --> fcmp uno X, Y
+    // (fcmp uno Y, X) | (fcmp uno NNAN, X) --> fcmp uno Y, X
+    // (fcmp uno X, Y) | (fcmp uno X, NNAN) --> fcmp uno X, Y
+    // (fcmp uno Y, X) | (fcmp uno X, NNAN) --> fcmp uno Y, X
+    if ((isKnownNeverNaN(RHS0) && (RHS1 == LHS0 || RHS1 == LHS1)) ||
+        (isKnownNeverNaN(RHS1) && (RHS0 == LHS0 || RHS0 == LHS1)))
+      return LHS;
+  }
+
+  return nullptr;
+}
+
+static Value *simplifyAndOrOfCmps(Value *Op0, Value *Op1, bool IsAnd) {
   // Look through casts of the 'and' operands to find compares.
   auto *Cast0 = dyn_cast<CastInst>(Op0);
   auto *Cast1 = dyn_cast<CastInst>(Op1);
   if (Cast0 && Cast1 && Cast0->getOpcode() == Cast1->getOpcode() &&
       Cast0->getSrcTy() == Cast1->getSrcTy()) {
     Op0 = Cast0->getOperand(0);
     Op1 = Cast1->getOperand(0);
   }
 
-  auto *Cmp0 = dyn_cast<ICmpInst>(Op0);
-  auto *Cmp1 = dyn_cast<ICmpInst>(Op1);
-  if (!Cmp0 || !Cmp1)
-    return nullptr;
+  Value *V = nullptr;
+  auto *ICmp0 = dyn_cast<ICmpInst>(Op0);
+  auto *ICmp1 = dyn_cast<ICmpInst>(Op1);
+  if (ICmp0 && ICmp1)
+    V = IsAnd ? simplifyAndOfICmps(ICmp0, ICmp1) :
+                simplifyOrOfICmps(ICmp0, ICmp1);
+
+  auto *FCmp0 = dyn_cast<FCmpInst>(Op0);
+  auto *FCmp1 = dyn_cast<FCmpInst>(Op1);
+  if (FCmp0 && FCmp1)
+    V = simplifyAndOrOfFCmps(FCmp0, FCmp1, IsAnd);
 
-  Value *V =
-      IsAnd ? simplifyAndOfICmps(Cmp0, Cmp1) : simplifyOrOfICmps(Cmp0, Cmp1);
   if (!V)
     return nullptr;
   if (!Cast0)
     return V;
 
   // If we looked through casts, we can only handle a constant simplification
   // because we are not allowed to create a cast instruction here.
   if (auto *C = dyn_cast<Constant>(V))
if (match(Op0, m_Neg(m_Specific(Op1))) ||
     if (isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
                                Q.DT))
       return Op0;
     if (isKnownToBeAPowerOfTwo(Op1, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
                                Q.DT))
       return Op1;
   }
 
-  if (Value *V = simplifyAndOrOfICmps(Op0, Op1, true))
+  if (Value *V = simplifyAndOrOfCmps(Op0, Op1, true))
     return V;
 
   // Try some generic simplifications for associative operations.
   if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q,
                                           MaxRecurse))
     return V;
 
   // And distributes over Or.  Try some generic simplifications based on this.
static Value *SimplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
   // (~A ^ B) | (B & A) -> (~A ^ B)
   // (B ^ ~A) | (A & B) -> (B ^ ~A)
   // (B ^ ~A) | (B & A) -> (B ^ ~A)
   if (match(Op1, m_And(m_Value(A), m_Value(B))) &&
       (match(Op0, m_c_Xor(m_Specific(A), m_Not(m_Specific(B)))) ||
        match(Op0, m_c_Xor(m_Not(m_Specific(A)), m_Specific(B)))))
     return Op0;
 
-  if (Value *V = simplifyAndOrOfICmps(Op0, Op1, false))
+  if (Value *V = simplifyAndOrOfCmps(Op0, Op1, false))
     return V;
 
   // Try some generic simplifications for associative operations.
   if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, Q,
                                           MaxRecurse))
     return V;
 
   // Or distributes over And.  Try some generic simplifications based on this.

llvm/trunk/test/Transforms/InstSimplify/logic-of-fcmps.ll

 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ; Cycle through commuted variants where one operand of fcmp ord/uno is
 ; known not-a-NAN and the other is repeated in the logically-connected fcmp.
 
 define i1 @ord1(float %x, float %y) {
 ; CHECK-LABEL: @ord1(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord float 0.000000e+00, %x
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord float %x, %y
-; CHECK-NEXT:    [[R:%.*]] = and i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = fcmp ord float 0.0, %x
   %cmp2 = fcmp ord float %x, %y
   %r = and i1 %cmp1, %cmp2
   ret i1 %r
 }
 
 define i1 @ord2(double %x, double %y) {
 ; CHECK-LABEL: @ord2(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double 4.200000e+01, %x
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord double %y, %x
-; CHECK-NEXT:    [[R:%.*]] = and i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = fcmp ord double 42.0, %x
   %cmp2 = fcmp ord double %y, %x
   %r = and i1 %cmp1, %cmp2
   ret i1 %r
 }
 
 define <2 x i1> @ord3(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @ord3(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord <2 x float> %x, zeroinitializer
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord <2 x float> %x, %y
-; CHECK-NEXT:    [[R:%.*]] = and <2 x i1> [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = fcmp ord <2 x float> %x, zeroinitializer
   %cmp2 = fcmp ord <2 x float> %x, %y
   %r = and <2 x i1> %cmp1, %cmp2
   ret <2 x i1> %r
 }
 
 define <2 x i1> @ord4(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @ord4(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord <2 x double> %x, <double 4.200000e+01, double 4.200000e+01>
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord <2 x double> %y, %x
-; CHECK-NEXT:    [[R:%.*]] = and <2 x i1> [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = fcmp ord <2 x double> %x, <double 42.0, double 42.0>
   %cmp2 = fcmp ord <2 x double> %y, %x
   %r = and <2 x i1> %cmp1, %cmp2
   ret <2 x i1> %r
 }
 
 define i1 @ord5(float %x, float %y) {
 ; CHECK-LABEL: @ord5(
-; CHECK-NEXT:    [[NNAN:%.*]] = fdiv nnan float %x, %y
 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord float %x, %y
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord float [[NNAN]], %x
-; CHECK-NEXT:    [[R:%.*]] = and i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %nnan = fdiv nnan float %x, %y
   %cmp1 = fcmp ord float %x, %y
   %cmp2 = fcmp ord float %nnan, %x
   %r = and i1 %cmp1, %cmp2
   ret i1 %r
 }
 
 define i1 @ord6(double %x, double %y) {
 ; CHECK-LABEL: @ord6(
 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %y, %x
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord double 4.200000e+01, %x
-; CHECK-NEXT:    [[R:%.*]] = and i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = fcmp ord double %y, %x
   %cmp2 = fcmp ord double 42.0, %x
   %r = and i1 %cmp1, %cmp2
   ret i1 %r
 }
 
 define <2 x i1> @ord7(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @ord7(
 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord <2 x float> %x, %y
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord <2 x float> %x, zeroinitializer
-; CHECK-NEXT:    [[R:%.*]] = and <2 x i1> [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %cmp1 = fcmp ord <2 x float> %x, %y
   %cmp2 = fcmp ord <2 x float> %x, zeroinitializer
   %r = and <2 x i1> %cmp1, %cmp2
   ret <2 x i1> %r
 }
 
 define <2 x i1> @ord8(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @ord8(
 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord <2 x double> %y, %x
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp ord <2 x double> %x, <double 0.000000e+00, double 4.200000e+01>
-; CHECK-NEXT:    [[R:%.*]] = and <2 x i1> [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %cmp1 = fcmp ord <2 x double> %y, %x
   %cmp2 = fcmp ord <2 x double> %x, <double 0.0, double 42.0>
   %r = and <2 x i1> %cmp1, %cmp2
   ret <2 x i1> %r
 }
 
 define i1 @uno1(float %x, float %y) {
 ; CHECK-LABEL: @uno1(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno float 0.000000e+00, %x
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno float %x, %y
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = fcmp uno float 0.0, %x
   %cmp2 = fcmp uno float %x, %y
   %r = or i1 %cmp1, %cmp2
   ret i1 %r
 }
 
 define i1 @uno2(double %x, double %y) {
 ; CHECK-LABEL: @uno2(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno double 4.200000e+01, %x
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno double %y, %x
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP2]]
 ;
   %cmp1 = fcmp uno double 42.0, %x
   %cmp2 = fcmp uno double %y, %x
   %r = or i1 %cmp1, %cmp2
   ret i1 %r
 }
 
 define <2 x i1> @uno3(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @uno3(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno <2 x float> %x, zeroinitializer
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno <2 x float> %x, %y
-; CHECK-NEXT:    [[R:%.*]] = or <2 x i1> [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = fcmp uno <2 x float> %x, zeroinitializer
   %cmp2 = fcmp uno <2 x float> %x, %y
   %r = or <2 x i1> %cmp1, %cmp2
   ret <2 x i1> %r
 }
 
 define <2 x i1> @uno4(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @uno4(
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno <2 x double> %x, <double 4.200000e+01, double 4.200000e+01>
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno <2 x double> %y, %x
-; CHECK-NEXT:    [[R:%.*]] = or <2 x i1> [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP2]]
 ;
   %cmp1 = fcmp uno <2 x double> %x, <double 42.0, double 42.0>
   %cmp2 = fcmp uno <2 x double> %y, %x
   %r = or <2 x i1> %cmp1, %cmp2
   ret <2 x i1> %r
 }
 
 define i1 @uno5(float %x, float %y) {
 ; CHECK-LABEL: @uno5(
 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno float %x, %y
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno float 0.000000e+00, %x
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = fcmp uno float %x, %y
   %cmp2 = fcmp uno float 0.0, %x
   %r = or i1 %cmp1, %cmp2
   ret i1 %r
 }
 
 define i1 @uno6(double %x, double %y) {
 ; CHECK-LABEL: @uno6(
 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno double %y, %x
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno double 4.200000e+01, %x
-; CHECK-NEXT:    [[R:%.*]] = or i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
+; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %cmp1 = fcmp uno double %y, %x
   %cmp2 = fcmp uno double 42.0, %x
   %r = or i1 %cmp1, %cmp2
   ret i1 %r
 }
 
 define <2 x i1> @uno7(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @uno7(
-; CHECK-NEXT:    [[NNAN:%.*]] = fdiv nnan <2 x float> %x, %y
 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno <2 x float> %x, %y
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno <2 x float> %x, [[NNAN]]
-; CHECK-NEXT:    [[R:%.*]] = or <2 x i1> [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %nnan = fdiv nnan <2 x float> %x, %y
   %cmp1 = fcmp uno <2 x float> %x, %y
   %cmp2 = fcmp uno <2 x float> %x, %nnan
   %r = or <2 x i1> %cmp1, %cmp2
   ret <2 x i1> %r
 }
 
 define <2 x i1> @uno8(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @uno8(
 ; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno <2 x double> %y, %x
-; CHECK-NEXT:    [[CMP2:%.*]] = fcmp uno <2 x double> %x, <double 0x7FF0000000000000, double 4.200000e+01>
-; CHECK-NEXT:    [[R:%.*]] = or <2 x i1> [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret <2 x i1> [[R]]
+; CHECK-NEXT:    ret <2 x i1> [[CMP1]]
 ;
   %cmp1 = fcmp uno <2 x double> %y, %x
   %cmp2 = fcmp uno <2 x double> %x, <double 0x7ff0000000000000, double 42.0>
   %r = or <2 x i1> %cmp1, %cmp2
   ret <2 x i1> %r
 }