[SLP] Avoid multiple attempts to vectorize CmpInsts.

[ABataev]

Summary

No need to lookup through and/or try to vectorize operands of the
CmpInst instructions during attempts to find/vectorize min/max
reductions. Compiler implements postanalysis of the CmpInsts so we can
skip extra attempts in tryToVectorizeHorReductionOrInstOperands and save
compile time.

[RKSimon]

LGTM with one (repeated) minor

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

7537–7538

Mention in comment we don't do this for CmpInst

7551

Mention in comment we don't do this for CmpInst

[xbolva00]

http://llvm-compile-time-tracker.com/compare.php?from=85b86c6f43ab50ba70571ed49da7e81f7d52ffd2&to=a78e86e6beb2d62196fa42be9f4a2994823f71f3&stat=size-text

Should not be this change neutral for code size? Or possibly it may produce better codegen?

[ABataev]

In D99950#2675237, @xbolva00 wrote:

http://llvm-compile-time-tracker.com/compare.php?from=85b86c6f43ab50ba70571ed49da7e81f7d52ffd2&to=a78e86e6beb2d62196fa42be9f4a2994823f71f3&stat=size-text

Should not be this change neutral for code size? Or possibly it may produce better codegen?

It should just improve compile time, nothing else

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

static bool tryToVectorizeHorReductionOrInstOperands(
   // found, try to vectorize it. If it is not a horizontal reduction or
   // vectorization is not possible or not effective, and currently analyzed
   // instruction is a binary operation, try to vectorize the operands, using
   // pre-order DFS traversal order. If the operands were not vectorized, repeat
   // the same procedure considering each operand as a possible root of the
   // horizontal reduction.
   // Interrupt the process if the Root instruction itself was vectorized or all
   // sub-trees not higher that RecursionMaxDepth were analyzed/vectorized.
+  // Skip the analysis of CmpInsts.Compiler implements postanalysis of the
+  // CmpInsts so we can skip extra attempts in
+  // tryToVectorizeHorReductionOrInstOperands and save compile time.
   SmallVector<std::pair<Instruction *, unsigned>, 8> Stack(1, {Root, 0});
   SmallPtrSet<Value *, 8> VisitedInstrs;
   bool Res = false;
   while (!Stack.empty()) {
     Instruction *Inst;
     unsigned Level;
     std::tie(Inst, Level) = Stack.pop_back_val();
     Value *B0, *B1;
if (IsBinop || IsSelect) {
           P = nullptr;
           continue;
         }
       }
     }
     // Set P to nullptr to avoid re-analysis of phi node in
     // matchAssociativeReduction function unless this is the root node.
     P = nullptr;
-    if (Vectorize(Inst, R)) {
+    // Do not try to vectorize CmpInst operands, this is done separately.
+    if (!isa<CmpInst>(Inst) && Vectorize(Inst, R)) {
       Res = true;
       continue;
     }
 
     // Try to vectorize operands.
     // Continue analysis for the instruction from the same basic block only to
     // save compile time.
     if (++Level < RecursionMaxDepth)
       for (auto *Op : Inst->operand_values())
         if (VisitedInstrs.insert(Op).second)
           if (auto *I = dyn_cast<Instruction>(Op))
-            if (!isa<PHINode>(I) && !R.isDeleted(I) && I->getParent() == BB)
+            // Do not try to vectorize CmpInst operands,  this is done
+            // separately.
+            if (!isa<PHINode>(I) && !isa<CmpInst>(I) && !R.isDeleted(I) &&
+                I->getParent() == BB)
               Stack.emplace_back(I, Level);
   }
   return Res;
 }
 
 bool SLPVectorizerPass::vectorizeRootInstruction(PHINode *P, Value *V,
                                                  BasicBlock *BB, BoUpSLP &R,
                                                  TargetTransformInfo *TTI) {