Revert "[SLP] Consider alternatives for cost of select instructions."

This reverts commit 1922570.

This appears to cause a crash in the following example

 a, b, c;
 l() {
   int e = a, f = l, g, h, i, j;
   float *d = c, *k = b;
   for (;;)
     for (; g < f; g++) {
       k[h] = d[i];
       k[h - 1] = d[j];
       h += e << 1;
       i += e;
     }
 }

 clang -cc1 -triple i386-unknown-linux-gnu -emit-obj -target-cpu pentium-m -O1 -vectorize-loops -vectorize-slp reduced.c

 llvm::Type *llvm::Type::getWithNewBitWidth(unsigned int) const: Assertion `isIntOrIntVectorTy() && "Original type expected to be a vector of integers or a scalar integer."' failed.

Author: fhahn

llvm/include/llvm/Analysis/ValueTracking.h

@@ -728,14 +728,6 @@ constexpr unsigned MaxAnalysisRecursionDepth = 6;
   /// minimum/maximum flavor.
   CmpInst::Predicate getInverseMinMaxPred(SelectPatternFlavor SPF);
 
-  /// Check if the values in \p VL are select instructions that can be converted
-  /// to a min or max (vector) intrinsic. Returns the intrinsic ID, if such a
-  /// conversion is possible, together with a bool indicating whether all select
-  /// conditions are only used by the selects. Otherwise return
-  /// Intrinsic::not_intrinsic.
-  std::pair<Intrinsic::ID, bool>
-  canConvertToMinOrMaxIntrinsic(ArrayRef<Value *> VL);
-
   /// Return true if RHS is known to be implied true by LHS.  Return false if
   /// RHS is known to be implied false by LHS.  Otherwise, return None if no
   /// implication can be made.

llvm/lib/Analysis/ValueTracking.cpp

@@ -6128,45 +6128,6 @@ CmpInst::Predicate llvm::getInverseMinMaxPred(SelectPatternFlavor SPF) {
   return getMinMaxPred(getInverseMinMaxFlavor(SPF));
 }
 
-std::pair<Intrinsic::ID, bool>
-llvm::canConvertToMinOrMaxIntrinsic(ArrayRef<Value *> VL) {
-  // Check if VL contains select instructions that can be folded into a min/max
-  // vector intrinsic and return the intrinsic if it is possible.
-  // TODO: Support floating point min/max.
-  bool AllCmpSingleUse = true;
-  SelectPatternResult SelectPattern;
-  SelectPattern.Flavor = SPF_UNKNOWN;
-  if (all_of(VL, [&SelectPattern, &AllCmpSingleUse](Value *I) {
-        Value *LHS, *RHS;
-        auto CurrentPattern = matchSelectPattern(I, LHS, RHS);
-        if (!SelectPatternResult::isMinOrMax(CurrentPattern.Flavor) ||
-            CurrentPattern.Flavor == SPF_FMINNUM ||
-            CurrentPattern.Flavor == SPF_FMAXNUM)
-          return false;
-        if (SelectPattern.Flavor != SPF_UNKNOWN &&
-            SelectPattern.Flavor != CurrentPattern.Flavor)
-          return false;
-        SelectPattern = CurrentPattern;
-        AllCmpSingleUse &=
-            match(I, m_Select(m_OneUse(m_Value()), m_Value(), m_Value()));
-        return true;
-      })) {
-    switch (SelectPattern.Flavor) {
-    case SPF_SMIN:
-      return {Intrinsic::smin, AllCmpSingleUse};
-    case SPF_UMIN:
-      return {Intrinsic::umin, AllCmpSingleUse};
-    case SPF_SMAX:
-      return {Intrinsic::smax, AllCmpSingleUse};
-    case SPF_UMAX:
-      return {Intrinsic::umax, AllCmpSingleUse};
-    default:
-      llvm_unreachable("unexpected select pattern flavor");
-    }
-  }
-  return {Intrinsic::not_intrinsic, false};
-}
-
 /// Return true if "icmp Pred LHS RHS" is always true.
 static bool isTruePredicate(CmpInst::Predicate Pred, const Value *LHS,
                             const Value *RHS, const DataLayout &DL,

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

@@ -3549,21 +3549,6 @@ int BoUpSLP::getEntryCost(TreeEntry *E) {
       int ScalarCost = VecTy->getNumElements() * ScalarEltCost;
       int VecCost = TTI->getCmpSelInstrCost(E->getOpcode(), VecTy, MaskTy,
                                             CostKind, VL0);
-      // Check if it is possible and profitable to use min/max for selects in
-      // VL.
-      //
-      auto IntrinsicAndUse = canConvertToMinOrMaxIntrinsic(VL);
-      if (IntrinsicAndUse.first != Intrinsic::not_intrinsic) {
-        IntrinsicCostAttributes CostAttrs(IntrinsicAndUse.first, VecTy,
-                                          {VecTy, VecTy});
-        int IntrinsicCost = TTI->getIntrinsicInstrCost(CostAttrs, CostKind);
-        // If the selects are the only uses of the compares, they will be dead
-        // and we can adjust the cost by removing their cost.
-        if (IntrinsicAndUse.second)
-          IntrinsicCost -= TTI->getCmpSelInstrCost(Instruction::ICmp, VecTy,
-                                                   MaskTy, CostKind);
-        VecCost = std::min(VecCost, IntrinsicCost);
-      }
       return ReuseShuffleCost + VecCost - ScalarCost;
     }
     case Instruction::FNeg: