ValueTracking: Report fast math flags for fcmp/select

[arsenm]

ping

[spatel]

Is the root problem that we don't have FMF on any FP select? We discussed that in:
https://bugs.llvm.org/show_bug.cgi?id=38086

If that's correct, I think we should make that change instead of making matchSelectPattern more complicated.

We're going to have to fix this anyway to solve cases that aren't min/max like:
https://bugs.llvm.org/show_bug.cgi?id=39535

[RKSimon]

include/llvm/IR/Operator.h

237

const FastMathFlags &OtherFlags ?

[spatel]

In D51701#1414272, @spatel wrote:

Is the root problem that we don't have FMF on any FP select? We discussed that in:
https://bugs.llvm.org/show_bug.cgi?id=38086

If that's correct, I think we should make that change instead of making matchSelectPattern more complicated.

rL361401 - enabled FMF for select-of-FP, so I'm not sure where we stand on this patch. I'm also proposing to canonicalize to minnum/maxnum intrinsics from fcmp+select in D62414, so that might remove some of the motivation for this patch.

[arsenm]

Since select should have FMF now anyway, I don't think this is needed anymore

[spatel]

In D51701#1677262, @arsenm wrote:

Since select should have FMF now anyway, I don't think this is needed anymore

Note: for IR coming from clang, we have to do more in most cases:
D67564

include/llvm/Analysis/ValueTracking.h

 #define LLVM_ANALYSIS_VALUETRACKING_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/Operator.h"
 #include <cassert>
 #include <cstdint>
 
 namespace llvm {
 
 class AddOperator;
 class APInt;
 class AssumptionCache;
SPNB_RETURNS_ANY            /// Given one NaN input, can return either (or
                                 /// it has been determined that no operands can
                                 /// be NaN).
   };
 
   struct SelectPatternResult {
     SelectPatternFlavor Flavor;
     SelectPatternNaNBehavior NaNBehavior; /// Only applicable if Flavor is
                                           /// SPF_FMINNUM or SPF_FMAXNUM.
+    FastMathFlags FMF; /// Any inferred flags from the pattern.
     bool Ordered;               /// When implementing this min/max pattern as
                                 /// fcmp; select, does the fcmp have to be
                                 /// ordered?
 
     /// Return true if \p SPF is a min or a max pattern.
     static bool isMinOrMax(SelectPatternFlavor SPF) {
       return SPF != SPF_UNKNOWN && SPF != SPF_ABS && SPF != SPF_NABS;
     }

include/llvm/IR/Operator.h

public:
   void setApproxFunc(bool B = true) {
     Flags = (Flags & ~ApproxFunc) | B * ApproxFunc;
   }
   void setFast(bool B = true) { B ? set() : clear(); }
 
   void operator&=(const FastMathFlags &OtherFlags) {
     Flags &= OtherFlags.Flags;
   }
+
+  bool operator==(const FastMathFlags OtherFlags) const {
+    return Flags == OtherFlags.Flags;
+  }
 };
 
 /// Utility class for floating point operations which can have
 /// information about relaxed accuracy requirements attached to them.
 class FPMathOperator : public Operator {
 private:
   friend class Instruction;
 

lib/Analysis/ValueTracking.cpp

 
 /// Match clamp pattern for float types without care about NaNs or signed zeros.
 /// Given non-min/max outer cmp/select from the clamp pattern this
 /// function recognizes if it can be substitued by a "canonical" min/max
 /// pattern.
 static SelectPatternResult matchFastFloatClamp(CmpInst::Predicate Pred,
                                                Value *CmpLHS, Value *CmpRHS,
                                                Value *TrueVal, Value *FalseVal,
-                                               Value *&LHS, Value *&RHS) {
+                                               Value *&LHS, Value *&RHS,
+                                               FastMathFlags FMF) {
   // Try to match
   //   X < C1 ? C1 : Min(X, C2) --> Max(C1, Min(X, C2))
   //   X > C1 ? C1 : Max(X, C2) --> Min(C1, Max(X, C2))
   // and return description of the outer Max/Min.
 
   // First, check if select has inverse order:
   if (CmpRHS == FalseVal) {
     std::swap(TrueVal, FalseVal);
     Pred = CmpInst::getInversePredicate(Pred);
   }
 
   // Assume success now. If there's no match, callers should not use these anyway.
   LHS = TrueVal;
   RHS = FalseVal;
 
   const APFloat *FC1;
   if (CmpRHS != TrueVal || !match(CmpRHS, m_APFloat(FC1)) || !FC1->isFinite())
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FMF, false};
 
   const APFloat *FC2;
   switch (Pred) {
   case CmpInst::FCMP_OLT:
   case CmpInst::FCMP_OLE:
   case CmpInst::FCMP_ULT:
   case CmpInst::FCMP_ULE:
     if (match(FalseVal,
               m_CombineOr(m_OrdFMin(m_Specific(CmpLHS), m_APFloat(FC2)),
                           m_UnordFMin(m_Specific(CmpLHS), m_APFloat(FC2)))) &&
         FC1->compare(*FC2) == APFloat::cmpResult::cmpLessThan)
-      return {SPF_FMAXNUM, SPNB_RETURNS_ANY, false};
+      return {SPF_FMAXNUM, SPNB_RETURNS_ANY, FMF, false};
     break;
   case CmpInst::FCMP_OGT:
   case CmpInst::FCMP_OGE:
   case CmpInst::FCMP_UGT:
   case CmpInst::FCMP_UGE:
     if (match(FalseVal,
               m_CombineOr(m_OrdFMax(m_Specific(CmpLHS), m_APFloat(FC2)),
                           m_UnordFMax(m_Specific(CmpLHS), m_APFloat(FC2)))) &&
         FC1->compare(*FC2) == APFloat::cmpResult::cmpGreaterThan)
-      return {SPF_FMINNUM, SPNB_RETURNS_ANY, false};
+      return {SPF_FMINNUM, SPNB_RETURNS_ANY, FMF, false};
     break;
   default:
     break;
   }
 
-  return {SPF_UNKNOWN, SPNB_NA, false};
+  return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 }
 
 /// Recognize variations of:
 ///   CLAMP(v,l,h) ==> ((v) < (l) ? (l) : ((v) > (h) ? (h) : (v)))
 static SelectPatternResult matchClamp(CmpInst::Predicate Pred,
                                       Value *CmpLHS, Value *CmpRHS,
                                       Value *TrueVal, Value *FalseVal) {
   // Swap the select operands and predicate to match the patterns below.
   if (CmpRHS != TrueVal) {
     Pred = ICmpInst::getSwappedPredicate(Pred);
     std::swap(TrueVal, FalseVal);
   }
   const APInt *C1;
   if (CmpRHS == TrueVal && match(CmpRHS, m_APInt(C1))) {
     const APInt *C2;
     // (X <s C1) ? C1 : SMIN(X, C2) ==> SMAX(SMIN(X, C2), C1)
     if (match(FalseVal, m_SMin(m_Specific(CmpLHS), m_APInt(C2))) &&
         C1->slt(*C2) && Pred == CmpInst::ICMP_SLT)
-      return {SPF_SMAX, SPNB_NA, false};
+      return {SPF_SMAX, SPNB_NA, FastMathFlags(), false};
 
     // (X >s C1) ? C1 : SMAX(X, C2) ==> SMIN(SMAX(X, C2), C1)
     if (match(FalseVal, m_SMax(m_Specific(CmpLHS), m_APInt(C2))) &&
         C1->sgt(*C2) && Pred == CmpInst::ICMP_SGT)
-      return {SPF_SMIN, SPNB_NA, false};
+      return {SPF_SMIN, SPNB_NA, FastMathFlags(), false};
 
     // (X <u C1) ? C1 : UMIN(X, C2) ==> UMAX(UMIN(X, C2), C1)
     if (match(FalseVal, m_UMin(m_Specific(CmpLHS), m_APInt(C2))) &&
         C1->ult(*C2) && Pred == CmpInst::ICMP_ULT)
-      return {SPF_UMAX, SPNB_NA, false};
+      return {SPF_UMAX, SPNB_NA, FastMathFlags(), false};
 
     // (X >u C1) ? C1 : UMAX(X, C2) ==> UMIN(UMAX(X, C2), C1)
     if (match(FalseVal, m_UMax(m_Specific(CmpLHS), m_APInt(C2))) &&
         C1->ugt(*C2) && Pred == CmpInst::ICMP_UGT)
-      return {SPF_UMIN, SPNB_NA, false};
+      return {SPF_UMIN, SPNB_NA, FastMathFlags(), false};
   }
-  return {SPF_UNKNOWN, SPNB_NA, false};
+  return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 }
 
 /// Recognize variations of:
 ///   a < c ? min(a,b) : min(b,c) ==> min(min(a,b),min(b,c))
 static SelectPatternResult matchMinMaxOfMinMax(CmpInst::Predicate Pred,
                                                Value *CmpLHS, Value *CmpRHS,
                                                Value *TVal, Value *FVal,
                                                unsigned Depth) {
   // TODO: Allow FP min/max with nnan/nsz.
   assert(CmpInst::isIntPredicate(Pred) && "Expected integer comparison");
 
   Value *A, *B;
   SelectPatternResult L = matchSelectPattern(TVal, A, B, nullptr, Depth + 1);
   if (!SelectPatternResult::isMinOrMax(L.Flavor))
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
   Value *C, *D;
   SelectPatternResult R = matchSelectPattern(FVal, C, D, nullptr, Depth + 1);
   if (L.Flavor != R.Flavor)
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
   // We have something like: x Pred y ? min(a, b) : min(c, d).
   // Try to match the compare to the min/max operations of the select operands.
   // First, make sure we have the right compare predicate.
   switch (L.Flavor) {
   case SPF_SMIN:
     if (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE) {
       Pred = ICmpInst::getSwappedPredicate(Pred);
       std::swap(CmpLHS, CmpRHS);
     }
     if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE)
       break;
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
   case SPF_SMAX:
     if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE) {
       Pred = ICmpInst::getSwappedPredicate(Pred);
       std::swap(CmpLHS, CmpRHS);
     }
     if (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE)
       break;
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
   case SPF_UMIN:
     if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) {
       Pred = ICmpInst::getSwappedPredicate(Pred);
       std::swap(CmpLHS, CmpRHS);
     }
     if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE)
       break;
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
   case SPF_UMAX:
     if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) {
       Pred = ICmpInst::getSwappedPredicate(Pred);
       std::swap(CmpLHS, CmpRHS);
     }
     if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE)
       break;
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
   default:
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
   }
 
   // If there is a common operand in the already matched min/max and the other
   // min/max operands match the compare operands (either directly or inverted),
   // then this is min/max of the same flavor.
 
   // a pred c ? m(a, b) : m(c, b) --> m(m(a, b), m(c, b))
   // ~c pred ~a ? m(a, b) : m(c, b) --> m(m(a, b), m(c, b))
   if (D == B) {
     if ((CmpLHS == A && CmpRHS == C) || (match(C, m_Not(m_Specific(CmpLHS))) &&
                                          match(A, m_Not(m_Specific(CmpRHS)))))
-      return {L.Flavor, SPNB_NA, false};
+      return {L.Flavor, SPNB_NA, FastMathFlags(), false};
   }
   // a pred d ? m(a, b) : m(b, d) --> m(m(a, b), m(b, d))
   // ~d pred ~a ? m(a, b) : m(b, d) --> m(m(a, b), m(b, d))
   if (C == B) {
     if ((CmpLHS == A && CmpRHS == D) || (match(D, m_Not(m_Specific(CmpLHS))) &&
                                          match(A, m_Not(m_Specific(CmpRHS)))))
-      return {L.Flavor, SPNB_NA, false};
+      return {L.Flavor, SPNB_NA, FastMathFlags(), false};
   }
   // b pred c ? m(a, b) : m(c, a) --> m(m(a, b), m(c, a))
   // ~c pred ~b ? m(a, b) : m(c, a) --> m(m(a, b), m(c, a))
   if (D == A) {
     if ((CmpLHS == B && CmpRHS == C) || (match(C, m_Not(m_Specific(CmpLHS))) &&
                                          match(B, m_Not(m_Specific(CmpRHS)))))
-      return {L.Flavor, SPNB_NA, false};
+      return {L.Flavor, SPNB_NA, FastMathFlags(), false};
   }
   // b pred d ? m(a, b) : m(a, d) --> m(m(a, b), m(a, d))
   // ~d pred ~b ? m(a, b) : m(a, d) --> m(m(a, b), m(a, d))
   if (C == A) {
     if ((CmpLHS == B && CmpRHS == D) || (match(D, m_Not(m_Specific(CmpLHS))) &&
                                          match(B, m_Not(m_Specific(CmpRHS)))))
-      return {L.Flavor, SPNB_NA, false};
+      return {L.Flavor, SPNB_NA, FastMathFlags(), false};
   }
 
-  return {SPF_UNKNOWN, SPNB_NA, false};
+  return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 }
 
 /// Match non-obvious integer minimum and maximum sequences.
 static SelectPatternResult matchMinMax(CmpInst::Predicate Pred,
                                        Value *CmpLHS, Value *CmpRHS,
                                        Value *TrueVal, Value *FalseVal,
                                        Value *&LHS, Value *&RHS,
                                        unsigned Depth) {
   // Assume success. If there's no match, callers should not use these anyway.
   LHS = TrueVal;
   RHS = FalseVal;
 
   SelectPatternResult SPR = matchClamp(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal);
   if (SPR.Flavor != SelectPatternFlavor::SPF_UNKNOWN)
     return SPR;
 
   SPR = matchMinMaxOfMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, Depth);
   if (SPR.Flavor != SelectPatternFlavor::SPF_UNKNOWN)
     return SPR;
 
   if (Pred != CmpInst::ICMP_SGT && Pred != CmpInst::ICMP_SLT)
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
   // Z = X -nsw Y
   // (X >s Y) ? 0 : Z ==> (Z >s 0) ? 0 : Z ==> SMIN(Z, 0)
   // (X <s Y) ? 0 : Z ==> (Z <s 0) ? 0 : Z ==> SMAX(Z, 0)
   if (match(TrueVal, m_Zero()) &&
       match(FalseVal, m_NSWSub(m_Specific(CmpLHS), m_Specific(CmpRHS))))
-    return {Pred == CmpInst::ICMP_SGT ? SPF_SMIN : SPF_SMAX, SPNB_NA, false};
+    return {Pred == CmpInst::ICMP_SGT ? SPF_SMIN : SPF_SMAX, SPNB_NA,
+            FastMathFlags(), false};
 
   // Z = X -nsw Y
   // (X >s Y) ? Z : 0 ==> (Z >s 0) ? Z : 0 ==> SMAX(Z, 0)
   // (X <s Y) ? Z : 0 ==> (Z <s 0) ? Z : 0 ==> SMIN(Z, 0)
   if (match(FalseVal, m_Zero()) &&
       match(TrueVal, m_NSWSub(m_Specific(CmpLHS), m_Specific(CmpRHS))))
-    return {Pred == CmpInst::ICMP_SGT ? SPF_SMAX : SPF_SMIN, SPNB_NA, false};
+    return {Pred == CmpInst::ICMP_SGT ? SPF_SMAX : SPF_SMIN, SPNB_NA,
+            FastMathFlags(), false};
 
   const APInt *C1;
   if (!match(CmpRHS, m_APInt(C1)))
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
   // An unsigned min/max can be written with a signed compare.
   const APInt *C2;
   if ((CmpLHS == TrueVal && match(FalseVal, m_APInt(C2))) ||
       (CmpLHS == FalseVal && match(TrueVal, m_APInt(C2)))) {
     // Is the sign bit set?
     // (X <s 0) ? X : MAXVAL ==> (X >u MAXVAL) ? X : MAXVAL ==> UMAX
     // (X <s 0) ? MAXVAL : X ==> (X >u MAXVAL) ? MAXVAL : X ==> UMIN
     if (Pred == CmpInst::ICMP_SLT && C1->isNullValue() &&
         C2->isMaxSignedValue())
-      return {CmpLHS == TrueVal ? SPF_UMAX : SPF_UMIN, SPNB_NA, false};
+      return {CmpLHS == TrueVal ? SPF_UMAX : SPF_UMIN, SPNB_NA,
+              FastMathFlags(), false};
 
     // Is the sign bit clear?
     // (X >s -1) ? MINVAL : X ==> (X <u MINVAL) ? MINVAL : X ==> UMAX
     // (X >s -1) ? X : MINVAL ==> (X <u MINVAL) ? X : MINVAL ==> UMIN
     if (Pred == CmpInst::ICMP_SGT && C1->isAllOnesValue() &&
         C2->isMinSignedValue())
-      return {CmpLHS == FalseVal ? SPF_UMAX : SPF_UMIN, SPNB_NA, false};
+      return {CmpLHS == FalseVal ? SPF_UMAX : SPF_UMIN, SPNB_NA,
+              FastMathFlags(), false};
   }
 
   // Look through 'not' ops to find disguised signed min/max.
   // (X >s C) ? ~X : ~C ==> (~X <s ~C) ? ~X : ~C ==> SMIN(~X, ~C)
   // (X <s C) ? ~X : ~C ==> (~X >s ~C) ? ~X : ~C ==> SMAX(~X, ~C)
   if (match(TrueVal, m_Not(m_Specific(CmpLHS))) &&
       match(FalseVal, m_APInt(C2)) && ~(*C1) == *C2)
-    return {Pred == CmpInst::ICMP_SGT ? SPF_SMIN : SPF_SMAX, SPNB_NA, false};
+    return {Pred == CmpInst::ICMP_SGT ? SPF_SMIN : SPF_SMAX, SPNB_NA,
+            FastMathFlags(), false};
 
   // (X >s C) ? ~C : ~X ==> (~X <s ~C) ? ~C : ~X ==> SMAX(~C, ~X)
   // (X <s C) ? ~C : ~X ==> (~X >s ~C) ? ~C : ~X ==> SMIN(~C, ~X)
   if (match(FalseVal, m_Not(m_Specific(CmpLHS))) &&
       match(TrueVal, m_APInt(C2)) && ~(*C1) == *C2)
-    return {Pred == CmpInst::ICMP_SGT ? SPF_SMAX : SPF_SMIN, SPNB_NA, false};
+    return {Pred == CmpInst::ICMP_SGT ? SPF_SMAX : SPF_SMIN, SPNB_NA,
+            FastMathFlags(), false};
 
-  return {SPF_UNKNOWN, SPNB_NA, false};
+  return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 }
 
 bool llvm::isKnownNegation(const Value *X, const Value *Y, bool NeedNSW) {
   assert(X && Y && "Invalid operand");
 
   // X = sub (0, Y) || X = sub nsw (0, Y)
   if ((!NeedNSW && match(X, m_Sub(m_ZeroInt(), m_Specific(Y)))) ||
       (NeedNSW && match(X, m_NSWSub(m_ZeroInt(), m_Specific(Y)))))
static SelectPatternResult matchSelectPattern(CmpInst::Predicate Pred,
   // operands is known to not be zero or if we don't care about signed zero.
   switch (Pred) {
   default: break;
   // FIXME: Include OGT/OLT/UGT/ULT.
   case CmpInst::FCMP_OGE: case CmpInst::FCMP_OLE:
   case CmpInst::FCMP_UGE: case CmpInst::FCMP_ULE:
     if (!FMF.noSignedZeros() && !isKnownNonZero(CmpLHS) &&
         !isKnownNonZero(CmpRHS))
-      return {SPF_UNKNOWN, SPNB_NA, false};
+      return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
   }
 
   SelectPatternNaNBehavior NaNBehavior = SPNB_NA;
   bool Ordered = false;
 
   // When given one NaN and one non-NaN input:
   //   - maxnum/minnum (C99 fmaxf()/fminf()) return the non-NaN input.
   //   - A simple C99 (a < b ? a : b) construction will return 'b' (as the
if (LHSSafe && RHSSafe) {
       Ordered = true;
       if (LHSSafe)
         // LHS is non-NaN, so if RHS is NaN then NaN will be returned.
         NaNBehavior = SPNB_RETURNS_NAN;
       else if (RHSSafe)
         NaNBehavior = SPNB_RETURNS_OTHER;
       else
         // Completely unsafe.
-        return {SPF_UNKNOWN, SPNB_NA, false};
+        return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
     } else {
       Ordered = false;
       // An unordered comparison will return true when given a NaN, so it
       // returns the LHS.
       if (LHSSafe)
         // LHS is non-NaN, so if RHS is NaN then non-NaN will be returned.
         NaNBehavior = SPNB_RETURNS_OTHER;
       else if (RHSSafe)
         NaNBehavior = SPNB_RETURNS_NAN;
       else
         // Completely unsafe.
-        return {SPF_UNKNOWN, SPNB_NA, false};
+        return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
     }
   }
 
   if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
     std::swap(CmpLHS, CmpRHS);
     Pred = CmpInst::getSwappedPredicate(Pred);
     if (NaNBehavior == SPNB_RETURNS_NAN)
       NaNBehavior = SPNB_RETURNS_OTHER;
     else if (NaNBehavior == SPNB_RETURNS_OTHER)
       NaNBehavior = SPNB_RETURNS_NAN;
     Ordered = !Ordered;
   }
 
   // ([if]cmp X, Y) ? X : Y
   if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
     switch (Pred) {
-    default: return {SPF_UNKNOWN, SPNB_NA, false}; // Equality.
+    default: return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false}; // Equality.
     case ICmpInst::ICMP_UGT:
-    case ICmpInst::ICMP_UGE: return {SPF_UMAX, SPNB_NA, false};
+    case ICmpInst::ICMP_UGE: return {SPF_UMAX, SPNB_NA, FastMathFlags(), false};
     case ICmpInst::ICMP_SGT:
-    case ICmpInst::ICMP_SGE: return {SPF_SMAX, SPNB_NA, false};
+    case ICmpInst::ICMP_SGE: return {SPF_SMAX, SPNB_NA, FastMathFlags(), false};
     case ICmpInst::ICMP_ULT:
-    case ICmpInst::ICMP_ULE: return {SPF_UMIN, SPNB_NA, false};
+    case ICmpInst::ICMP_ULE: return {SPF_UMIN, SPNB_NA, FastMathFlags(), false};
     case ICmpInst::ICMP_SLT:
-    case ICmpInst::ICMP_SLE: return {SPF_SMIN, SPNB_NA, false};
+    case ICmpInst::ICMP_SLE: return {SPF_SMIN, SPNB_NA, FastMathFlags(), false};
     case FCmpInst::FCMP_UGT:
     case FCmpInst::FCMP_UGE:
     case FCmpInst::FCMP_OGT:
-    case FCmpInst::FCMP_OGE: return {SPF_FMAXNUM, NaNBehavior, Ordered};
+    case FCmpInst::FCMP_OGE: return {SPF_FMAXNUM, NaNBehavior, FMF, Ordered};
     case FCmpInst::FCMP_ULT:
     case FCmpInst::FCMP_ULE:
     case FCmpInst::FCMP_OLT:
-    case FCmpInst::FCMP_OLE: return {SPF_FMINNUM, NaNBehavior, Ordered};
+    case FCmpInst::FCMP_OLE: return {SPF_FMINNUM, NaNBehavior, FMF, Ordered};
     }
   }
 
   if (isKnownNegation(TrueVal, FalseVal)) {
     // Sign-extending LHS does not change its sign, so TrueVal/FalseVal can
     // match against either LHS or sext(LHS).
     auto MaybeSExtCmpLHS =
         m_CombineOr(m_Specific(CmpLHS), m_SExt(m_Specific(CmpLHS)));
     auto ZeroOrAllOnes = m_CombineOr(m_ZeroInt(), m_AllOnes());
     auto ZeroOrOne = m_CombineOr(m_ZeroInt(), m_One());
     if (match(TrueVal, MaybeSExtCmpLHS)) {
       // Set the return values. If the compare uses the negated value (-X >s 0),
       // swap the return values because the negated value is always 'RHS'.
       LHS = TrueVal;
       RHS = FalseVal;
       if (match(CmpLHS, m_Neg(m_Specific(FalseVal))))
         std::swap(LHS, RHS);
 
       // (X >s 0) ? X : -X or (X >s -1) ? X : -X --> ABS(X)
       // (-X >s 0) ? -X : X or (-X >s -1) ? -X : X --> ABS(X)
       if (Pred == ICmpInst::ICMP_SGT && match(CmpRHS, ZeroOrAllOnes))
-        return {SPF_ABS, SPNB_NA, false};
+        return {SPF_ABS, SPNB_NA, FastMathFlags(), false};
 
       // (X <s 0) ? X : -X or (X <s 1) ? X : -X --> NABS(X)
       // (-X <s 0) ? -X : X or (-X <s 1) ? -X : X --> NABS(X)
       if (Pred == ICmpInst::ICMP_SLT && match(CmpRHS, ZeroOrOne))
-        return {SPF_NABS, SPNB_NA, false};
+        return {SPF_NABS, SPNB_NA, FastMathFlags(), false};
     }
     else if (match(FalseVal, MaybeSExtCmpLHS)) {
       // Set the return values. If the compare uses the negated value (-X >s 0),
       // swap the return values because the negated value is always 'RHS'.
       LHS = FalseVal;
       RHS = TrueVal;
       if (match(CmpLHS, m_Neg(m_Specific(TrueVal))))
         std::swap(LHS, RHS);
 
       // (X >s 0) ? -X : X or (X >s -1) ? -X : X --> NABS(X)
       // (-X >s 0) ? X : -X or (-X >s -1) ? X : -X --> NABS(X)
       if (Pred == ICmpInst::ICMP_SGT && match(CmpRHS, ZeroOrAllOnes))
-        return {SPF_NABS, SPNB_NA, false};
+        return {SPF_NABS, SPNB_NA, FastMathFlags(), false};
 
       // (X <s 0) ? -X : X or (X <s 1) ? -X : X --> ABS(X)
       // (-X <s 0) ? X : -X or (-X <s 1) ? X : -X --> ABS(X)
       if (Pred == ICmpInst::ICMP_SLT && match(CmpRHS, ZeroOrOne))
-        return {SPF_ABS, SPNB_NA, false};
+        return {SPF_ABS, SPNB_NA, FastMathFlags(), false};
     }
   }
 
   if (CmpInst::isIntPredicate(Pred))
     return matchMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS, Depth);
 
   // According to (IEEE 754-2008 5.3.1), minNum(0.0, -0.0) and similar
   // may return either -0.0 or 0.0, so fcmp/select pair has stricter
   // semantics than minNum. Be conservative in such case.
   if (NaNBehavior != SPNB_RETURNS_ANY ||
       (!FMF.noSignedZeros() && !isKnownNonZero(CmpLHS) &&
        !isKnownNonZero(CmpRHS)))
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
-  return matchFastFloatClamp(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS);
+  return matchFastFloatClamp(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal,
+                             LHS, RHS, FMF);
 }
 
 /// Helps to match a select pattern in case of a type mismatch.
 ///
 /// The function processes the case when type of true and false values of a
 /// select instruction differs from type of the cmp instruction operands because
 /// of a cast instruction. The function checks if it is legal to move the cast
 /// operation after "select". If yes, it returns the new second value of
static Value *lookThroughCast(CmpInst *CmpI, Value *V1, Value *V2,
 
   return CastedTo;
 }
 
 SelectPatternResult llvm::matchSelectPattern(Value *V, Value *&LHS, Value *&RHS,
                                              Instruction::CastOps *CastOp,
                                              unsigned Depth) {
   if (Depth >= MaxDepth)
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
   SelectInst *SI = dyn_cast<SelectInst>(V);
-  if (!SI) return {SPF_UNKNOWN, SPNB_NA, false};
+  if (!SI) return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
   CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
-  if (!CmpI) return {SPF_UNKNOWN, SPNB_NA, false};
+  if (!CmpI) return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
   CmpInst::Predicate Pred = CmpI->getPredicate();
   Value *CmpLHS = CmpI->getOperand(0);
   Value *CmpRHS = CmpI->getOperand(1);
   Value *TrueVal = SI->getTrueValue();
   Value *FalseVal = SI->getFalseValue();
   FastMathFlags FMF;
   if (isa<FPMathOperator>(CmpI))
     FMF = CmpI->getFastMathFlags();
 
   // Bail out early.
   if (CmpI->isEquality())
-    return {SPF_UNKNOWN, SPNB_NA, false};
+    return {SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false};
 
   // Deal with type mismatches.
   if (CastOp && CmpLHS->getType() != TrueVal->getType()) {
     if (Value *C = lookThroughCast(CmpI, TrueVal, FalseVal, CastOp)) {
       // If this is a potential fmin/fmax with a cast to integer, then ignore
       // -0.0 because there is no corresponding integer value.
       if (*CastOp == Instruction::FPToSI || *CastOp == Instruction::FPToUI)
         FMF.setNoSignedZeros();

unittests/Analysis/ValueTrackingTest.cpp

protected:
 
   void expectPattern(const SelectPatternResult &P) {
     Value *LHS, *RHS;
     Instruction::CastOps CastOp;
     SelectPatternResult R = matchSelectPattern(A, LHS, RHS, &CastOp);
     EXPECT_EQ(P.Flavor, R.Flavor);
     EXPECT_EQ(P.NaNBehavior, R.NaNBehavior);
     EXPECT_EQ(P.Ordered, R.Ordered);
+    EXPECT_EQ(P.FMF, R.FMF);
   }
 
   LLVMContext Context;
   std::unique_ptr<Module> M;
   Instruction *A, *B;
 };
 
 }
 
 TEST_F(MatchSelectPatternTest, SimpleFMin) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ult float %a, 5.0\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
       "}\n");
-  expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, false});
+  expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, FastMathFlags(), false});
+}
+
+TEST_F(MatchSelectPatternTest, SimpleFMin_WithFMF) {
+  parseAssembly(
+      "define float @test(float %a) {\n"
+      "  %1 = fcmp nsz ult float %a, 5.0\n"
+      "  %A = select i1 %1, float %a, float 5.0\n"
+      "  ret float %A\n"
+      "}\n");
+  FastMathFlags FMF;
+  FMF.setNoSignedZeros();
+
+  expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, FMF, false});
 }
 
 TEST_F(MatchSelectPatternTest, SimpleFMax) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float %a, 5.0\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
       "}\n");
-  expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, true});
+  expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, FastMathFlags(), true});
 }
 
 TEST_F(MatchSelectPatternTest, SwappedFMax) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float 5.0, %a\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
       "}\n");
-  expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, false});
+  expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, FastMathFlags(), false});
 }
 
 TEST_F(MatchSelectPatternTest, SwappedFMax2) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float %a, 5.0\n"
       "  %A = select i1 %1, float 5.0, float %a\n"
       "  ret float %A\n"
       "}\n");
-  expectPattern({SPF_FMAXNUM, SPNB_RETURNS_NAN, false});
+  expectPattern({SPF_FMAXNUM, SPNB_RETURNS_NAN, FastMathFlags(), false});
 }
 
 TEST_F(MatchSelectPatternTest, SwappedFMax3) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ult float %a, 5.0\n"
       "  %A = select i1 %1, float 5.0, float %a\n"
       "  ret float %A\n"
       "}\n");
-  expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, true});
+  expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, FastMathFlags(), true});
 }
 
 TEST_F(MatchSelectPatternTest, FastFMin) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp nnan olt float %a, 5.0\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
       "}\n");
-  expectPattern({SPF_FMINNUM, SPNB_RETURNS_ANY, false});
+  FastMathFlags FMF;
+  FMF.setNoNaNs();
+  expectPattern({SPF_FMINNUM, SPNB_RETURNS_ANY, FMF, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMinConstantZero) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ole float %a, 0.0\n"
       "  %A = select i1 %1, float %a, float 0.0\n"
       "  ret float %A\n"
       "}\n");
   // This shouldn't be matched, as %a could be -0.0.
-  expectPattern({SPF_UNKNOWN, SPNB_NA, false});
+  expectPattern({SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false});
 }
 
 TEST_F(MatchSelectPatternTest, FMinConstantZeroNsz) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp nsz ole float %a, 0.0\n"
       "  %A = select i1 %1, float %a, float 0.0\n"
       "  ret float %A\n"
       "}\n");
+
+  FastMathFlags FMF;
+  FMF.setNoSignedZeros();
+
   // But this should be, because we've ignored signed zeroes.
-  expectPattern({SPF_FMINNUM, SPNB_RETURNS_OTHER, true});
+  expectPattern({SPF_FMINNUM, SPNB_RETURNS_OTHER, FMF, true});
 }
 
 TEST_F(MatchSelectPatternTest, DoubleCastU) {
   parseAssembly(
       "define i32 @test(i8 %a, i8 %b) {\n"
       "  %1 = icmp ult i8 %a, %b\n"
       "  %2 = zext i8 %a to i32\n"
       "  %3 = zext i8 %b to i32\n"
       "  %A = select i1 %1, i32 %2, i32 %3\n"
       "  ret i32 %A\n"
       "}\n");
   // We should be able to look through the situation where we cast both operands
   // to the select.
-  expectPattern({SPF_UMIN, SPNB_NA, false});
+  expectPattern({SPF_UMIN, SPNB_NA, FastMathFlags(), false});
 }
 
 TEST_F(MatchSelectPatternTest, DoubleCastS) {
   parseAssembly(
       "define i32 @test(i8 %a, i8 %b) {\n"
       "  %1 = icmp slt i8 %a, %b\n"
       "  %2 = sext i8 %a to i32\n"
       "  %3 = sext i8 %b to i32\n"
       "  %A = select i1 %1, i32 %2, i32 %3\n"
       "  ret i32 %A\n"
       "}\n");
   // We should be able to look through the situation where we cast both operands
   // to the select.
-  expectPattern({SPF_SMIN, SPNB_NA, false});
+  expectPattern({SPF_SMIN, SPNB_NA, FastMathFlags(), false});
 }
 
 TEST_F(MatchSelectPatternTest, DoubleCastBad) {
   parseAssembly(
       "define i32 @test(i8 %a, i8 %b) {\n"
       "  %1 = icmp ult i8 %a, %b\n"
       "  %2 = zext i8 %a to i32\n"
       "  %3 = sext i8 %b to i32\n"
       "  %A = select i1 %1, i32 %2, i32 %3\n"
       "  ret i32 %A\n"
       "}\n");
   // The cast types here aren't the same, so we cannot match an UMIN.
-  expectPattern({SPF_UNKNOWN, SPNB_NA, false});
+  expectPattern({SPF_UNKNOWN, SPNB_NA, FastMathFlags(), false});
 }
 
 TEST(ValueTracking, GuaranteedToTransferExecutionToSuccessor) {
   StringRef Assembly =
       "declare void @nounwind_readonly(i32*) nounwind readonly "
       "declare void @nounwind_argmemonly(i32*) nounwind argmemonly "
       "declare void @throws_but_readonly(i32*) readonly "
       "declare void @throws_but_argmemonly(i32*) argmemonly "