[InstSimpify][ValueTracking] Use new FP matchers

[foad]

I split this out from D89038 because of @lebedev.ri's comment:

I would strongly recommend to split this into two separate commits - adding the matchers, and using them.
Because while the matchers themselves LG, i'm not at all confident with users.
When doing latter, please ensure that each separate change has appropriate undef test coverage, and ideally check that alive2 is happy about those transforms.

I haven't looked at adding the extra test coverage yet.

[spatel]

In D90015#2349354, @foad wrote:

I split this out from D89038 because of @lebedev.ri's comment:

I would strongly recommend to split this into two separate commits - adding the matchers, and using them.
Because while the matchers themselves LG, i'm not at all confident with users.
When doing latter, please ensure that each separate change has appropriate undef test coverage, and ideally check that alive2 is happy about those transforms.

I haven't looked at adding the extra test coverage yet.

Sorry, I'm overloaded with reviews, but I agree with @lebedev.ri that it was good to split this up. I'd go even further and split this patch up too and add tests for all known callers of the ValueTracking APIs. We've seen several cases of subtle bugs with partial-undef vectors, so we need more tests and ideally confirm correctness with Alive2.

[lebedev.ri]

In D90015#2350426, @spatel wrote:

In D90015#2349354, @foad wrote:

I split this out from D89038 because of @lebedev.ri's comment:

I would strongly recommend to split this into two separate commits - adding the matchers, and using them.
Because while the matchers themselves LG, i'm not at all confident with users.
When doing latter, please ensure that each separate change has appropriate undef test coverage, and ideally check that alive2 is happy about those transforms.

I haven't looked at adding the extra test coverage yet.

Sorry, I'm overloaded with reviews, but I agree with @lebedev.ri that it was good to split this up. I'd go even further and split this patch up too and add tests for all known callers of the ValueTracking APIs. We've seen several cases of subtle bugs with partial-undef vectors, so we need more tests and ideally confirm correctness with Alive2.

+1

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

llvm/lib/Analysis/InstructionSimplify.cpp

if (!match(Cond, m_FCmp(Pred, m_Specific(T), m_Specific(F))) &&
       !match(Cond, m_FCmp(Pred, m_Specific(F), m_Specific(T))))
     return nullptr;
 
   // This transform is safe if we do not have (do not care about) -0.0 or if
   // at least one operand is known to not be -0.0. Otherwise, the select can
   // change the sign of a zero operand.
   bool HasNoSignedZeros = Q.CxtI && isa<FPMathOperator>(Q.CxtI) &&
                           Q.CxtI->hasNoSignedZeros();
-  const APFloat *C;
-  if (HasNoSignedZeros || (match(T, m_APFloat(C)) && C->isNonZero()) ||
-                          (match(F, m_APFloat(C)) && C->isNonZero())) {
+  if (HasNoSignedZeros || match(T, m_NonZeroFP()) || match(F, m_NonZeroFP())) {
     // (T == F) ? T : F --> F
     // (F == T) ? T : F --> F
     if (Pred == FCmpInst::FCMP_OEQ)
       return F;
 
     // (T != F) ? T : F --> T
     // (F != T) ? T : F --> T
     if (Pred == FCmpInst::FCMP_UNE)

llvm/lib/Analysis/ValueTracking.cpp

bool llvm::isKnownNeverInfinity(const Value *V, const TargetLibraryInfo *TLI,
                                 unsigned Depth) {
   assert(V->getType()->isFPOrFPVectorTy() && "Querying for Inf on non-FP type");
 
   // If we're told that infinities won't happen, assume they won't.
   if (auto *FPMathOp = dyn_cast<FPMathOperator>(V))
     if (FPMathOp->hasNoInfs())
       return true;
 
-  // Handle scalar constants.
-  if (auto *CFP = dyn_cast<ConstantFP>(V))
-    return !CFP->isInfinity();
+  // Handle scalar and fixed width vector constants.
+  if (isa<Constant>(V))
+    return match(V, m_NonInf());
 
   if (Depth == MaxAnalysisRecursionDepth)
     return false;
 
   if (auto *Inst = dyn_cast<Instruction>(V)) {
     switch (Inst->getOpcode()) {
     case Instruction::Select: {
       return isKnownNeverInfinity(Inst->getOperand(1), TLI, Depth + 1) &&
case Instruction::UIToFP: {
       Type *FPTy = Inst->getType()->getScalarType();
       return ilogb(APFloat::getLargest(FPTy->getFltSemantics())) >= IntSize;
     }
     default:
       break;
     }
   }
 
-  // try to handle fixed width vector constants
-  auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
-  if (VFVTy && isa<Constant>(V)) {
-    // For vectors, verify that each element is not infinity.
-    unsigned NumElts = VFVTy->getNumElements();
-    for (unsigned i = 0; i != NumElts; ++i) {
-      Constant *Elt = cast<Constant>(V)->getAggregateElement(i);
-      if (!Elt)
-        return false;
-      if (isa<UndefValue>(Elt))
-        continue;
-      auto *CElt = dyn_cast<ConstantFP>(Elt);
-      if (!CElt || CElt->isInfinity())
-        return false;
-    }
-    // All elements were confirmed non-infinity or undefined.
-    return true;
-  }
-
   // was not able to prove that V never contains infinity
   return false;
 }
 
 bool llvm::isKnownNeverNaN(const Value *V, const TargetLibraryInfo *TLI,
                            unsigned Depth) {
   assert(V->getType()->isFPOrFPVectorTy() && "Querying for NaN on non-FP type");
 
   // If we're told that NaNs won't happen, assume they won't.
   if (auto *FPMathOp = dyn_cast<FPMathOperator>(V))
     if (FPMathOp->hasNoNaNs())
       return true;
 
-  // Handle scalar constants.
-  if (auto *CFP = dyn_cast<ConstantFP>(V))
-    return !CFP->isNaN();
+  // Handle scalar and fixed width vector constants.
+  if (isa<Constant>(V))
+    return match(V, m_NonNaN());
 
   if (Depth == MaxAnalysisRecursionDepth)
     return false;
 
   if (auto *Inst = dyn_cast<Instruction>(V)) {
     switch (Inst->getOpcode()) {
     case Instruction::FAdd:
     case Instruction::FSub:
case Intrinsic::maxnum:
       // If either operand is not NaN, the result is not NaN.
       return isKnownNeverNaN(II->getArgOperand(0), TLI, Depth + 1) ||
              isKnownNeverNaN(II->getArgOperand(1), TLI, Depth + 1);
     default:
       return false;
     }
   }
 
-  // Try to handle fixed width vector constants
-  auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
-  if (VFVTy && isa<Constant>(V)) {
-    // For vectors, verify that each element is not NaN.
-    unsigned NumElts = VFVTy->getNumElements();
-    for (unsigned i = 0; i != NumElts; ++i) {
-      Constant *Elt = cast<Constant>(V)->getAggregateElement(i);
-      if (!Elt)
-        return false;
-      if (isa<UndefValue>(Elt))
-        continue;
-      auto *CElt = dyn_cast<ConstantFP>(Elt);
-      if (!CElt || CElt->isNaN())
-        return false;
-    }
-    // All elements were confirmed not-NaN or undefined.
-    return true;
-  }
-
   // Was not able to prove that V never contains NaN
   return false;
 }
 
 Value *llvm::isBytewiseValue(Value *V, const DataLayout &DL) {
 
   // All byte-wide stores are splatable, even of arbitrary variables.
   if (V->getType()->isIntegerTy(8))
if (CmpRHS == 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())
+  if (CmpRHS != TrueVal || !match(CmpRHS, m_Finite(FC1)))
     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:

llvm/test/Transforms/InstCombine/clamp-to-minmax.ll

 ;
   %cmp2 = fcmp fast olt float %x, 255.0
   %min = select i1 %cmp2, float %x, float 255.0
   %cmp1 = fcmp fast olt float %x, 1.0
   %r = select i1 %cmp1, float 1.0, float %min
   ret float %r
 }
 
+; (X < C1) ? C1 : MIN(X, C2)
+define <2 x float> @clamp_float_fast_ordered_strict_maxmin_vec(<2 x float> %x) {
+; CHECK-LABEL: define {{[^@]+}}@clamp_float_fast_ordered_strict_maxmin_vec(
+; CHECK-NEXT:    [[CMP2:%.*]] = fcmp fast olt <2 x float> [[X:%.*]], <float 2.550000e+02, float 2.550000e+02>
+; CHECK-NEXT:    [[MIN:%.*]] = select <2 x i1> [[CMP2]], <2 x float> [[X]], <2 x float> <float 2.550000e+02, float 2.550000e+02>
+; CHECK-NEXT:    [[TMP1:%.*]] = call fast <2 x float> @llvm.maxnum.v2f32(<2 x float> [[MIN]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
+; CHECK-NEXT:    ret <2 x float> [[TMP1]]
+;
+  %cmp2 = fcmp fast olt <2 x float> %x, <float 255.0, float 255.0>
+  %min = select <2 x i1> %cmp2, <2 x float> %x, <2 x float> <float 255.0, float 255.0>
+  %cmp1 = fcmp fast olt <2 x float> %x, <float 1.0, float 1.0>
+  %r = select <2 x i1> %cmp1, <2 x float> <float 1.0, float 1.0>, <2 x float> %min
+  ret <2 x float> %r
+}
+
 ; (X <= C1) ? C1 : MIN(X, C2)
 define float @clamp_float_fast_ordered_nonstrict_maxmin(float %x) {
 ; CHECK-LABEL: define {{[^@]+}}@clamp_float_fast_ordered_nonstrict_maxmin(
 ; CHECK-NEXT:    [[CMP2:%.*]] = fcmp fast olt float [[X:%.*]], 2.550000e+02
 ; CHECK-NEXT:    [[MIN:%.*]] = select i1 [[CMP2]], float [[X]], float 2.550000e+02
 ; CHECK-NEXT:    [[TMP1:%.*]] = call fast float @llvm.maxnum.f32(float [[MIN]], float 1.000000e+00)
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;

llvm/test/Transforms/InstSimplify/fcmp-select.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ; X == 42.0 ? X : 42.0 --> 42.0
 
 define double @oeq(double %x) {
 ; CHECK-LABEL: @oeq(
 ; CHECK-NEXT:    ret double 4.200000e+01
 ;
   %cmp = fcmp oeq double %x, 42.0
   %cond = select i1 %cmp, double %x, double 42.0
   ret double %cond
 }
 
+; X == <4.0, 2.0, undef> ? X : <4.0, 2.0, undef> --> <4.0, 2.0, undef>
+
+define <3 x double> @oeq_vec(<3 x double> %x) {
+; CHECK-LABEL: @oeq_vec(
+; CHECK-NEXT:    ret <3 x double> <double 4.000000e+00, double 2.000000e+00, double undef>
+;
+  %cmp = fcmp oeq <3 x double> %x, <double 4.0, double 2.0, double undef>
+  %cond = select <3 x i1> %cmp, <3 x double> %x, <3 x double> <double 4.0, double 2.0, double undef>
+  ret <3 x double> %cond
+}
+
 ; X == 42.0 ? 42.0 : X --> X
 
 define float @oeq_swapped(float %x) {
 ; CHECK-LABEL: @oeq_swapped(
 ; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %cmp = fcmp oeq float %x, 42.0
   %cond = select i1 %cmp, float 42.0, float %x