Transforms/Vectorize/LoopVectorize.cpp

406                       LoopVectorizationCostModel *CM)
410         VectorLoopValueMap(UnrollFactor, VecWidth), Legal(LVL), Cost(CM) {}
787                     LoopVectorizationCostModel *CM)
789                             UnrollFactor, LVL, CM) {}
1190   /// The sets depend on CM decision for Load/Store instructions
2367          "CM decision should be taken at this point");
6313              "CM decision should be taken at this point");
6447                                  LoopVectorizationCostModel &CM) {
6449   std::tie(std::ignore, WidestType) = CM.getSmallestAndWidestTypes();
6464       VF = determineVPlanVF(TTI->getRegisterBitWidth(true /* Vector*/), CM);
6495   Optional<unsigned> MaybeMaxVF = CM.computeMaxVF();
6500   if (CM.blockNeedsPredication(OrigLoop->getHeader()) &&
6506     CM.InterleaveInfo.reset();
6514     CM.selectUserVectorizationFactor(UserVF);
6525     CM.collectUniformsAndScalars(VF);
6530       CM.collectInstsToScalarize(VF);
6539   return CM.selectVectorizationFactor(MaxVF);
6747     if (!CM.blockNeedsPredication(BB))
6785         CM.getWideningDecision(I, VF);
6787            "CM decision should be taken at this point.");
6790     if (CM.isScalarAfterVectorization(I, VF) ||
6791         CM.isProfitableToScalarize(I, VF))
6830         [=](unsigned VF) -> bool { return CM.isOptimizableIVTruncate(K, VF); };
6868       [&](unsigned VF) { return CM.isScalarWithPredication(I, VF); }, Range);
6930     if (!isa<PHINode>(I) && (CM.isScalarAfterVectorization(I, VF) ||
6931                              CM.isProfitableToScalarize(I, VF)))
6940       unsigned CallCost = CM.getVectorCallCost(CI, VF, NeedToScalarize);
6942           ID && CM.getVectorIntrinsicCost(CI, VF) <= CallCost;
6946       assert(CM.getWideningDecision(I, VF) ==
6981       [&](unsigned VF) { return CM.isUniformAfterVectorization(I, VF); },
6985       [&](unsigned VF) { return CM.isScalarWithPredication(I, VF); }, Range);
7063       return CM.isScalarWithPredication(Instr, VF) ||
7064              CM.isScalarAfterVectorization(Instr, VF) ||
7065              CM.isProfitableToScalarize(Instr, VF);
7104   if (CM.foldTailByMasking()) {
7146   VPRecipeBuilder RecipeBuilder(OrigLoop, TLI, Legal, CM, Builder);
7167               CM.getWideningDecision(IG->getInsertPos(), VF) ==
7268   if (CM.foldTailByMasking()) {
7563   LoopVectorizationCostModel CM(SEL, L, PSE, LI, LVL, *TTI, TLI, DB, AC, ORE, F,
7566   // TODO: CM is not used at this point inside the planner. Turn CM into an
7568   LoopVectorizationPlanner LVP(L, LI, TLI, TTI, LVL, CM, IAI);
7586                          &CM);
7722   LoopVectorizationCostModel CM(SEL, L, PSE, LI, &LVL, *TTI, TLI, DB, AC, ORE,
7724   CM.collectValuesToIgnore();
7727   LoopVectorizationPlanner LVP(L, LI, TLI, TTI, &LVL, CM, IAI);
7742     IC = CM.selectInterleaveCount(VF.Width, VF.Cost);
7845                                &CM);
7857                            &LVL, &CM);