[InstCombine] Canonicalize clamp of float types to minmax in fast mode.
Summary:
This commit allows matchSelectPattern to recognize clamp of float
arguments in the presence of FMF the same way as already done for
integers.
This case is a little different though. With integers, given the
min/max pattern is recognized, DAGBuilder starts selecting MIN/MAX
"automatically". That is not the case for float, because for them only
full FMINNAN/FMINNUM/FMAXNAN/FMAXNUM ISD nodes exist and they do care
about NaNs. On the other hand, some backends (e.g. X86) have only
FMIN/FMAX nodes that do not care about NaNS and the former NAN/NUM
nodes are illegal thus selection is not happening. So I decided to do
such kind of transformation in IR (InstCombiner) instead of
complicating the logic in the backend.
Reviewers: spatel, jmolloy, majnemer, efriedma, craig.topper
Reviewed By: efriedma
Subscribers: hiraditya, javed.absar, n.bozhenov, llvm-commits
Patch by Andrei Elovikov <andrei.elovikov@intel.com>
Differential Revision: https://reviews.llvm.org/D33186
llvm-svn: 310054
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 9ab98ce..3456871 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -3994,6 +3994,62 @@
return false;
}
+/// 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) {
+ // 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};
+
+ 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};
+ 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};
+ break;
+ default:
+ break;
+ }
+
+ return {SPF_UNKNOWN, SPNB_NA, false};
+}
+
/// Match non-obvious integer minimum and maximum sequences.
static SelectPatternResult matchMinMax(CmpInst::Predicate Pred,
Value *CmpLHS, Value *CmpRHS,
@@ -4201,7 +4257,18 @@
}
}
- return matchMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS);
+ if (CmpInst::isIntPredicate(Pred))
+ return matchMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS);
+
+ // 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 matchFastFloatClamp(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS);
}
static Value *lookThroughCast(CmpInst *CmpI, Value *V1, Value *V2,