[SLP][NFC] Remove comparator argument of `tryToVectorizeSequence()`

[vporpo]

Summary

As far as I can tell there is no good reason why we are defining the comparator
before calling tryToVectorizeSequence() but running sort() inside
tryToVectorizeSequence().
So this patch simplifies the code by moving the call to sort() closer to its
comparator.

[ABataev]

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

14144

Would be good to add the assert that the array is properly sorted, but I don't know how to do it without comparator here.

[ABataev]

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

14144

The general idea behind passing it as an argument was ensure that the incomming array is properly sorted, so we operate on potentially vectorizable lists instead of trying incompatible ones. So, it just allows do not forget about comparator for the new operations (e.g. math intrinsics calls).

[vporpo]

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

14144

Makes sense. I think we can use a common comparator function, let me see if it works.

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

if (!findBuildAggregate(IEI, TTI, BuildVectorOpds, BuildVectorInsts) ||
        isFixedVectorShuffle(BuildVectorOpds, Mask)))
     return false;
 
   LLVM_DEBUG(dbgs() << "SLP: array mappable to vector: " << *IEI << "\n");
   return tryToVectorizeList(BuildVectorInsts, R);
 }
 
 template <typename T>
-static bool
-tryToVectorizeSequence(SmallVectorImpl<T *> &Incoming,
-                       function_ref<unsigned(T *)> Limit,
-                       function_ref<bool(T *, T *)> Comparator,
-                       function_ref<bool(T *, T *)> AreCompatible,
-                       function_ref<bool(ArrayRef<T *>, bool)> TryToVectorizeHelper,
-                       bool LimitForRegisterSize) {
+static bool tryToVectorizeSequence(
+    SmallVectorImpl<T *> &Incoming, function_ref<unsigned(T *)> Limit,
   bool Changed = false;
-  // Sort by type, parent, operands.
-  stable_sort(Incoming, Comparator);
 
   // Try to vectorize elements base on their type.
   SmallVector<T *> Candidates;
   for (auto *IncIt = Incoming.begin(), *E = Incoming.end(); IncIt != E;) {
     // Look for the next elements with the same type, parent and operand
     // kinds.
     auto *SameTypeIt = IncIt;
     while (SameTypeIt != E && AreCompatible(*SameTypeIt, *IncIt))
auto AreCompatibleCompares = [&](Value *V1, Value *V2) {
                               [&R](Instruction *I) { return R.isDeleted(I); });
     };
     auto Limit = [&R](Value *V) {
       unsigned EltSize = R.getVectorElementSize(V);
       return std::max(2U, R.getMaxVecRegSize() / EltSize);
     };
 
     SmallVector<Value *> Vals(PostponedCmps.begin(), PostponedCmps.end());
+    stable_sort(Vals, CompareSorter);
+
     OpsChanged |= tryToVectorizeSequence<Value>(
-        Vals, Limit, CompareSorter, AreCompatibleCompares,
+        Vals, Limit, AreCompatibleCompares,
         [this, &R](ArrayRef<Value *> Candidates, bool LimitForRegisterSize) {
           // Exclude possible reductions from other blocks.
           bool ArePossiblyReducedInOtherBlock =
               any_of(Candidates, [](Value *V) {
                 return any_of(V->users(), [V](User *U) {
                   return isa<SelectInst>(U) &&
                          cast<SelectInst>(U)->getParent() !=
                              cast<Instruction>(V)->getParent();
for (Value *V : Incoming) {
             Nodes.push_back(PHI1);
             continue;
           }
           Opcodes.emplace_back(V);
         }
       }
     }
 
+    stable_sort(Incoming, PHICompare);
+
     HaveVectorizedPhiNodes = tryToVectorizeSequence<Value>(
-        Incoming, Limit, PHICompare, AreCompatiblePHIs,
+        Incoming, Limit, AreCompatiblePHIs,
         [this, &R](ArrayRef<Value *> Candidates, bool LimitForRegisterSize) {
           return tryToVectorizeList(Candidates, R, LimitForRegisterSize);
         },
         /*LimitForRegisterSize=*/true);
     Changed |= HaveVectorizedPhiNodes;
     VisitedInstrs.insert(Incoming.begin(), Incoming.end());
   } while (HaveVectorizedPhiNodes);
 
if (Pair.second.size() < 2)
       continue;
 
     LLVM_DEBUG(dbgs() << "SLP: Analyzing a store chain of length "
                       << Pair.second.size() << ".\n");
 
     if (!isValidElementType(Pair.second.front()->getValueOperand()->getType()))
       continue;
 
+    stable_sort(Pair.second, StoreSorter);
+
     Changed |= tryToVectorizeSequence<StoreInst>(
-        Pair.second, Limit, StoreSorter, AreCompatibleStores,
+        Pair.second, Limit, AreCompatibleStores,
         [this, &R](ArrayRef<StoreInst *> Candidates, bool) {
           return vectorizeStores(Candidates, R);
         },
         /*LimitForRegisterSize=*/false);
   }
   return Changed;
 }