[LV] Compute ranges for plans up front (NFC).

[fhahn]

Summary

This patch introduces a new helper to compute the ranges of VFs with
matching decisions for all instructions up front. This will be used in a
follow-up patch to get rid of the VF range clamping during recipe
creation, enabling us to move to more granular VPlan construction.

The current version just adds the new helper and adds assertions to
ensure it gives the same result as the current clamping, in order to
catch any potential gaps.

This extra work is only needed temporarily and it appears to be
compile-time neutral:
http://llvm-compile-time-tracker.com/compare.php?from=7c7f4676cd421b1d64145eebfed11e5a3d8935d7&to=80d7088723fcfcd4ac80235bdbd57b70156b997f&stat=instructions

Note that this means the logic to apply the decisions is becoming a bit
more spread out initially. But in future patches, we can do the
decisions exclusively up-front (e.g. by creating a map which contains
whether to widen, scalarize or clone for each instruction in the loop).
This would allow us to untangle recipe creation from the cost-model
specifics as follow-up.

[fhahn]

ping :)

[Ayal]

Thanks @fhahn for moving this forward!
Have mostly minor nits.

llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h

208

This cleanup is independent?

300

vector factor >> vectorization factor (x2)

303

computeRanges >> computeVFRanges

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

1602

Ideally these bool CM.should*(inst, VF) methods would be const, but that seems to require various other methods to be const as well?

1639

will be should be >> should be scalarized

8475

Note that folding the above VF-agnostic early-exit into the lambda below may cause some overhead - no need to scan the entire range to realize it will not be clamped. But as your measurements confirm this is insignificant.

8511

Should one-liner 'willWiden()' lambda's be folded inline into getDecisionAndClampRange() as in IsPredicated above?

8528–8529

How about 'ShouldScalarize' >> 'willWiden' returning !CM.shouldScalarize(), to be more consistent with the above?

8718

// Split the [Start, End) Range at Idx into [Start, VF*2) and [VF*2, End)

by clamping the End of the existing Range and introducing a new range.
Can Range.Start continue to be const?

8747

Better scan basic-blocks in regular DFS order, avoid RPO.

8772

Widened >> Widen

Better first set Widen = CM.*(Instr, VF) and then set Split = (Widen == CM.*(Instr, VF*2)) throughout?

8775

Use Instr or &I consistently?

8783

second VF should be VF * 2
(calls for a test?)

Alternatively check if getWideningDecision's agree, thereby also covering CM_Interleave case?

Outline into Split = !CM.dicisionsAgree(Instr, VF, VF*2) ?

8788

if (!Widen && !Split) { ?

8792

Also need to make sure isScalarWithPredication() are identical?
Originally affects clamping in tryToWidenCall() and handleReplication().

8821

This calls for a Range::operator==, but is needed only temporarily, right?

llvm/lib/Transforms/Vectorize/VPlan.h

72

Is this change needed?
Update above comment given that Start is also adjustable?

llvm/test/Transforms/LoopVectorize/X86/phis-only.ll

7

Worth mentioning the purpose of the test, possibly by renaming the function name?
%0 is dead?

[fhahn]

Address comments, thanks!

[fhahn]

llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h

208

Unfortunately not at the moment. it is still used during the widening checks in tryToWidenCall I think.

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

1602

I pushed a few NFC commits changing the used methods to const . Now shouldWiden.* can be const as well.

8718

Unfortunately it cannot, because Ranges.insert needs to be able to overwrite existing entries I think.

8747

I think we can just iterate over the loop blocks. I removed the DFS/RPO.

8775

Instr is gone.

8783

(calls for a test?)

yes, but unfortunately I could not construct a test case where it only comes down to whether the decisions agree for a memory operation. for example, it is possible to have a case where we switch from interleave-group to widen, but in that case the recipe for the GEP also changes.

8821

yes it's just temporary. I can add Range::operator==, but I think it would become unused, after the next patch goes in.

llvm/lib/Transforms/Vectorize/VPlan.h

72

Unfortunately yes, because Ranges.insert needs to overwrite existing elements.

We should be able to limit modifications once the clamping is gone, but using a vector of const VFRange.

llvm/test/Transforms/LoopVectorize/X86/phis-only.ll

7

Done, I added a comment and adjusted the check lines to check for a plan including all VFs.

[fhahn]

Adjust comment for VFRange.

[fhahn]

I changed focus on transitioning sinking of scalar operands to a VPlan-to-VPlan transform in D100258.

llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h

 /// Legality checks.
 class LoopVectorizationPlanner {
   /// The loop that we evaluate.
   Loop *OrigLoop;
 
   /// Loop Info analysis.
   LoopInfo *LI;
 
-  /// Target Library Info.
-  const TargetLibraryInfo *TLI;
-
   /// Target Transform Info.
   const TargetTransformInfo *TTI;
 
   /// The legality analysis.
   LoopVectorizationLegality *Legal;
 
   /// The profitability analysis.
   LoopVectorizationCostModel &CM;
class LoopVectorizationPlanner {
 
   /// The best number of elements of the vector types used in the
   /// transformed loop. BestVF = None means that vectorization is
   /// disabled.
   Optional<ElementCount> BestVF = None;
   unsigned BestUF = 0;
 
 public:
-  LoopVectorizationPlanner(Loop *L, LoopInfo *LI, const TargetLibraryInfo *TLI,
+  LoopVectorizationPlanner(Loop *L, LoopInfo *LI,
                            const TargetTransformInfo *TTI,
                            LoopVectorizationLegality *Legal,
                            LoopVectorizationCostModel &CM,
                            InterleavedAccessInfo &IAI,
                            PredicatedScalarEvolution &PSE)
-      : OrigLoop(L), LI(LI), TLI(TLI), TTI(TTI), Legal(Legal), CM(CM), IAI(IAI),
+      : OrigLoop(L), LI(LI), TTI(TTI), Legal(Legal), CM(CM), IAI(IAI),
         PSE(PSE) {}
 
   /// Plan how to best vectorize, return the best VF and its cost, or None if
   /// vectorization and interleaving should be avoided up front.
   Optional<VectorizationFactor> plan(ElementCount UserVF, unsigned UserIC);
 
   /// Use the VPlan-native path to plan how to best vectorize, return the best
   /// VF and its cost.
private:
   VPlanPtr buildVPlan(VFRange &Range);
 
   /// Build a VPlan using VPRecipes according to the information gather by
   /// Legal. This method is only used for the legacy inner loop vectorizer.
   VPlanPtr buildVPlanWithVPRecipes(
       VFRange &Range, SmallPtrSetImpl<Instruction *> &DeadInstructions,
       const DenseMap<Instruction *, Instruction *> &SinkAfter);
 
+  /// Compute a list of vectorization factor ranges so that the decisions for
+  /// each instruction matches across all vectorization factors in the range.
+  SmallVector<VFRange, 4>
+  computeVFRanges(ElementCount MinVF, ElementCount MaxVF,
+                  SmallPtrSetImpl<Instruction *> &DeadInstructions);
+
   /// Build VPlans for power-of-2 VF's between \p MinVF and \p MaxVF inclusive,
   /// according to the information gathered by Legal when it checked if it is
   /// legal to vectorize the loop. This method creates VPlans using VPRecipes.
   void buildVPlansWithVPRecipes(ElementCount MinVF, ElementCount MaxVF);
 
   /// Adjust the recipes for any inloop reductions. The chain of instructions
   /// leading from the loop exit instr to the phi need to be converted to
   /// reductions, with one operand being vector and the other being the scalar
   /// reduction chain.
   void adjustRecipesForInLoopReductions(VPlanPtr &Plan,
                                         VPRecipeBuilder &RecipeBuilder);
 };
 
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZATIONPLANNER_H

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

public:
 
   /// Invalidates decisions already taken by the cost model.
   void invalidateCostModelingDecisions() {
     WideningDecisions.clear();
     Uniforms.clear();
     Scalars.clear();
   }
 
+  /// Returns true if \p CI should be widened for \p VF.
+  bool shouldWidenCall(CallInst *CI, ElementCount VF) const {
+    Intrinsic::ID ID = getVectorIntrinsicIDForCall(CI, TLI);
+    if (ID && (ID == Intrinsic::assume || ID == Intrinsic::lifetime_end ||
+               ID == Intrinsic::lifetime_start || ID == Intrinsic::sideeffect ||
+               ID == Intrinsic::pseudoprobe ||
+               ID == Intrinsic::experimental_noalias_scope_decl))
+      return false;
+
+    // The following case may be scalarized depending on the VF.
+    // The flag shows whether we use Intrinsic or a usual Call for vectorized
+    // version of the instruction.
+    // Is it beneficial to perform intrinsic call compared to lib call?
+    bool NeedToScalarize = false;
+    InstructionCost CallCost = getVectorCallCost(CI, VF, NeedToScalarize);
+    InstructionCost IntrinsicCost = ID ? getVectorIntrinsicCost(CI, VF) : 0;
+    bool UseVectorIntrinsic = ID && IntrinsicCost <= CallCost;
+    assert(IntrinsicCost.isValid() && CallCost.isValid() &&
+           "Cannot have invalid costs while widening");
+    return UseVectorIntrinsic || !NeedToScalarize;
+  }
+
+  /// Returns true if memory instruction \p I should be widened for \p VF.
+  bool shouldWidenMemory(Instruction *I, ElementCount VF) const {
+    if (VF.isScalar())
+      return false;
+    LoopVectorizationCostModel::InstWidening Decision =
+        getWideningDecision(I, VF);
+    assert(Decision != LoopVectorizationCostModel::CM_Unknown &&
+           "CM decision should be taken at this point.");
+    if (Decision == LoopVectorizationCostModel::CM_Interleave)
+      return true;
+    if (isScalarAfterVectorization(I, VF) || isProfitableToScalarize(I, VF))
+      return false;
+    return Decision != LoopVectorizationCostModel::CM_Scalarize;
+  }
+
+  /// Returns true if instruction \p I should be scalarized for \p VF.
+  bool shouldScalarize(Instruction *I, ElementCount VF) const {
+    return isScalarAfterVectorization(I, VF) ||
+           isProfitableToScalarize(I, VF) || isScalarWithPredication(I, VF);
+  }
+
+  /// Returns true if the widening decisions for \p I agree for \p VF1 and \p
+  /// VF2.
+  bool decisionsAgree(Instruction *I, ElementCount VF1,
+                      ElementCount VF2) const {
+    assert(VF2.isVector() && "only VF1 should be scalar");
+    // If VF1 is scalar, I should be kept scalar for VF2.
+    if (VF1.isScalar())
+      return isScalarAfterVectorization(I, VF2) ||
+             getWideningDecision(I, VF2) !=
+                 LoopVectorizationCostModel::CM_Scalarize;
+    ;
+    return getWideningDecision(I, VF1) == getWideningDecision(I, VF2);
+  }
+
 private:
   unsigned NumPredStores = 0;
 
   /// \return An upper bound for the vectorization factor, a power-of-2 larger
   /// than zero. One is returned if vectorization should best be avoided due
   /// to cost.
   ElementCount computeFeasibleMaxVF(unsigned ConstTripCount,
                                     ElementCount UserVF);

 }
 
 VPRecipeBase *VPRecipeBuilder::tryToWidenMemory(Instruction *I, VFRange &Range,
                                                 VPlanPtr &Plan) {
   assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
          "Must be called with either a load or store");
 
   auto willWiden = [&](ElementCount VF) -> bool {
-    if (VF.isScalar())
-      return false;
-    LoopVectorizationCostModel::InstWidening Decision =
-        CM.getWideningDecision(I, VF);
-    assert(Decision != LoopVectorizationCostModel::CM_Unknown &&
-           "CM decision should be taken at this point.");
-    if (Decision == LoopVectorizationCostModel::CM_Interleave)
-      return true;
-    if (CM.isScalarAfterVectorization(I, VF) ||
-        CM.isProfitableToScalarize(I, VF))
-      return false;
-    return Decision != LoopVectorizationCostModel::CM_Scalarize;
+    return CM.shouldWidenMemory(I, VF);
   };
 
   if (!LoopVectorizationPlanner::getDecisionAndClampRange(willWiden, Range))
     return nullptr;
 
   VPValue *Mask = nullptr;
   if (Legal->isMaskRequired(I))
     Mask = createBlockInMask(I->getParent(), Plan);

 
 VPWidenCallRecipe *VPRecipeBuilder::tryToWidenCall(CallInst *CI, VFRange &Range,
                                                    VPlan &Plan) const {
 
   bool IsPredicated = LoopVectorizationPlanner::getDecisionAndClampRange(
       [this, CI](ElementCount VF) {
         return CM.isScalarWithPredication(CI, VF);
       },
       Range);
 
   if (IsPredicated)
     return nullptr;
 
-  Intrinsic::ID ID = getVectorIntrinsicIDForCall(CI, TLI);
-  if (ID && (ID == Intrinsic::assume || ID == Intrinsic::lifetime_end ||
-             ID == Intrinsic::lifetime_start || ID == Intrinsic::sideeffect ||
-             ID == Intrinsic::pseudoprobe ||
-             ID == Intrinsic::experimental_noalias_scope_decl))
-    return nullptr;
-
-  auto willWiden = [&](ElementCount VF) -> bool {
-    Intrinsic::ID ID = getVectorIntrinsicIDForCall(CI, TLI);
-    // The following case may be scalarized depending on the VF.
-    // The flag shows whether we use Intrinsic or a usual Call for vectorized
-    // version of the instruction.
-    // Is it beneficial to perform intrinsic call compared to lib call?
-    bool NeedToScalarize = false;
-    InstructionCost CallCost = CM.getVectorCallCost(CI, VF, NeedToScalarize);
-    InstructionCost IntrinsicCost = ID ? CM.getVectorIntrinsicCost(CI, VF) : 0;
-    bool UseVectorIntrinsic = ID && IntrinsicCost <= CallCost;
-    assert(IntrinsicCost.isValid() && CallCost.isValid() &&
-           "Cannot have invalid costs while widening");
-    return UseVectorIntrinsic || !NeedToScalarize;
-  };
-
-  if (!LoopVectorizationPlanner::getDecisionAndClampRange(willWiden, Range))
+  if (!LoopVectorizationPlanner::getDecisionAndClampRange(
+          [this, CI](ElementCount VF) { return CM.shouldWidenCall(CI, VF); },
+          Range))
     return nullptr;
 
   return new VPWidenCallRecipe(*CI, Plan.mapToVPValues(CI->arg_operands()));
 }
 
 bool VPRecipeBuilder::shouldWiden(Instruction *I, VFRange &Range) const {
   assert(!isa<BranchInst>(I) && !isa<PHINode>(I) && !isa<LoadInst>(I) &&
          !isa<StoreInst>(I) && "Instruction should have been handled earlier");
   // Instruction should be widened, unless it is scalar after vectorization,
   // scalarization is profitable or it is predicated.
-  auto WillScalarize = [this, I](ElementCount VF) -> bool {
-    return CM.isScalarAfterVectorization(I, VF) ||
-           CM.isProfitableToScalarize(I, VF) ||
-           CM.isScalarWithPredication(I, VF);
-  };
-  return !LoopVectorizationPlanner::getDecisionAndClampRange(WillScalarize,
-                                                             Range);
+  return LoopVectorizationPlanner::getDecisionAndClampRange(
+      [this, I](ElementCount VF) { return !CM.shouldScalarize(I, VF); }, Range);
 }
 
 VPWidenRecipe *VPRecipeBuilder::tryToWiden(Instruction *I, VPlan &Plan) const {
   auto IsVectorizableOpcode = [](unsigned Opcode) {
     switch (Opcode) {
     case Instruction::Add:
     case Instruction::And:
     case Instruction::AShr:
bool InvariantCond =
         PSE.getSE()->isLoopInvariant(PSE.getSCEV(SI->getOperand(0)), OrigLoop);
     return toVPRecipeResult(new VPWidenSelectRecipe(
         *SI, Plan->mapToVPValues(SI->operands()), InvariantCond));
   }
 
   return toVPRecipeResult(tryToWiden(Instr, *Plan));
 }
 
+SmallVector<VFRange, 4> LoopVectorizationPlanner::computeVFRanges(
+    ElementCount MinVF, ElementCount MaxVF,
+    SmallPtrSetImpl<Instruction *> &DeadInstructions) {
+  SmallVector<VFRange, 4> Ranges;
+  Ranges.emplace_back(MinVF, MaxVF.getWithIncrement(1));
+
+  // Split the [Start, End) Range at Idx into [Start, VF*2) and [VF*2, End)
+  // by clamping the End of the existing Range and introducing a new range.
+  auto SplitRange = [&Ranges](unsigned Idx, ElementCount VF) {
+    auto &Range = Ranges[Idx];
+    VFRange NewR(VF * 2, Range.End);
+    Range.End = VF * 2;
+    if (Idx + 1 == Ranges.size())
+      Ranges.push_back(NewR);
+    else
+      Ranges.insert(&Ranges[Idx + 1], NewR);
+  };
+
+  for (BasicBlock *BB : OrigLoop->blocks()) {
+    for (Instruction &I : BB->instructionsWithoutDebug()) {
+      // Skip irrelevant instructions.
+      if (isa<BranchInst>(&I) || DeadInstructions.count(&I))
+        continue;
+
+      // Inductions are always widened.
+      if (auto *Phi = dyn_cast<PHINode>(&I)) {
+        InductionDescriptor II = Legal->getInductionVars().lookup(Phi);
+        if (II.getKind() == InductionDescriptor::IK_IntInduction ||
+            II.getKind() == InductionDescriptor::IK_FpInduction) {
+          continue;
+        }
+      }
+
+      // Check if the same decision applies for each VF for each of the current
+      // ranges. If the same decision cannot be applied to all VFs in a range,
+      // split the range at the point where the decisions diverge.
+      for (unsigned Idx = 0; Idx != Ranges.size(); ++Idx) {
+        VFRange &Range = Ranges[Idx];
+        for (ElementCount VF = Range.Start;
+             ElementCount::isKnownLT(VF * 2, Range.End); VF *= 2) {
+          bool Split = false;
+          bool Widen = false;
+          if (CM.isOptimizableIVTruncate(&I, VF)) {
+            Widen = true;
+            Split |= !CM.isOptimizableIVTruncate(&I, VF * 2);
+          } else if (auto *CI = dyn_cast<CallInst>(&I)) {
+            Widen |= CM.shouldWidenCall(CI, VF);
+            Split |= Widen != CM.shouldWidenCall(CI, VF * 2);
+          } else if (isa<LoadInst>(&I) || isa<StoreInst>(&I)) {
+            Widen |= CM.shouldWidenMemory(&I, VF);
+            Split |= !CM.decisionsAgree(&I, VF, VF * 2);
+          }
+
+          // If we did not already decided to widen, check if the scalarization
+          // decisions agree.
+          if (!Widen && !Split) {
+            Split |=
+                CM.shouldScalarize(&I, VF) != CM.shouldScalarize(&I, VF * 2);
+            Split |= CM.isUniformAfterVectorization(&I, VF) !=
+                     CM.isUniformAfterVectorization(&I, VF * 2);
+            Split |= CM.isScalarWithPredication(&I, VF) !=
+                     CM.isScalarWithPredication(&I, VF * 2);
+          }
+
+          // Split the current range into (Range.Start, VF * 2), (VF * 2,
+          // Range.End). Continue processing the second (newly added) range.
+          if (Split) {
+            SplitRange(Idx, VF);
+            break;
+          }
+        }
+      }
+    }
+  }
+  return Ranges;
+}
+
 void LoopVectorizationPlanner::buildVPlansWithVPRecipes(ElementCount MinVF,
                                                         ElementCount MaxVF) {
   assert(OrigLoop->isInnermost() && "Inner loop expected.");
 
   // Collect instructions from the original loop that will become trivially dead
   // in the vectorized loop. We don't need to vectorize these instructions. For
   // example, original induction update instructions can become dead because we
   // separately emit induction "steps" when generating code for the new loop.
   // Similarly, we create a new latch condition when setting up the structure
   // of the new loop, so the old one can become dead.
   SmallPtrSet<Instruction *, 4> DeadInstructions;
   collectTriviallyDeadInstructions(DeadInstructions);
 
   // Add assume instructions we need to drop to DeadInstructions, to prevent
   // them from being added to the VPlan.
   // TODO: We only need to drop assumes in blocks that get flattend. If the
   // control flow is preserved, we should keep them.
   auto &ConditionalAssumes = Legal->getConditionalAssumes();
   DeadInstructions.insert(ConditionalAssumes.begin(), ConditionalAssumes.end());
 
   DenseMap<Instruction *, Instruction *> &SinkAfter = Legal->getSinkAfter();
   // Dead instructions do not need sinking. Remove them from SinkAfter.
   for (Instruction *I : DeadInstructions)
     SinkAfter.erase(I);
 
+  auto Ranges = computeVFRanges(MinVF, MaxVF, DeadInstructions);
   auto MaxVFPlusOne = MaxVF.getWithIncrement(1);
+  unsigned I = 0;
   for (ElementCount VF = MinVF; ElementCount::isKnownLT(VF, MaxVFPlusOne);) {
     VFRange SubRange = {VF, MaxVFPlusOne};
     VPlans.push_back(
         buildVPlanWithVPRecipes(SubRange, DeadInstructions, SinkAfter));
     VF = SubRange.End;
+    assert(Ranges[I].Start == SubRange.Start && Ranges[I].End == SubRange.End &&
+           "clamped range should match computed range");
+    I++;
   }
+
+  assert(Ranges.size() == VPlans.size() &&
+         "should have the same number of clamped and computed ranges");
 }
 
 VPlanPtr LoopVectorizationPlanner::buildVPlanWithVPRecipes(
     VFRange &Range, SmallPtrSetImpl<Instruction *> &DeadInstructions,
     const DenseMap<Instruction *, Instruction *> &SinkAfter) {
 
   SmallPtrSet<const InterleaveGroup<Instruction> *, 1> InterleaveGroups;
 
-  VPRecipeBuilder RecipeBuilder(OrigLoop, TLI, Legal, CM, PSE, Builder);
+  VPRecipeBuilder RecipeBuilder(OrigLoop, Legal, CM, PSE, Builder);
 
   // ---------------------------------------------------------------------------
   // Pre-construction: record ingredients whose recipes we'll need to further
   // process after constructing the initial VPlan.
   // ---------------------------------------------------------------------------
 
   // Mark instructions we'll need to sink later and their targets as
   // ingredients whose recipe we'll need to record.
static bool processLoopInVPlanNativePath(
   ScalarEpilogueLowering SEL = getScalarEpilogueLowering(
       F, L, Hints, PSI, BFI, TTI, TLI, AC, LI, PSE.getSE(), DT, *LVL);
 
   LoopVectorizationCostModel CM(SEL, L, PSE, LI, LVL, *TTI, TLI, DB, AC, ORE, F,
                                 &Hints, IAI);
   // Use the planner for outer loop vectorization.
   // TODO: CM is not used at this point inside the planner. Turn CM into an
   // optional argument if we don't need it in the future.
-  LoopVectorizationPlanner LVP(L, LI, TLI, TTI, LVL, CM, IAI, PSE);
+  LoopVectorizationPlanner LVP(L, LI, TTI, LVL, CM, IAI, PSE);
 
   // Get user vectorization factor.
   ElementCount UserVF = Hints.getWidth();
 
   // Plan how to best vectorize, return the best VF and its cost.
   const VectorizationFactor VF = LVP.planInVPlanNativePath(UserVF);
 
   // If we are stress testing VPlan builds, do not attempt to generate vector
#endif /* NDEBUG */
   }
 
   // Use the cost model.
   LoopVectorizationCostModel CM(SEL, L, PSE, LI, &LVL, *TTI, TLI, DB, AC, ORE,
                                 F, &Hints, IAI);
   CM.collectValuesToIgnore();
 
   // Use the planner for vectorization.
-  LoopVectorizationPlanner LVP(L, LI, TLI, TTI, &LVL, CM, IAI, PSE);
+  LoopVectorizationPlanner LVP(L, LI, TTI, &LVL, CM, IAI, PSE);
 
   // Get user vectorization factor and interleave count.
   ElementCount UserVF = Hints.getWidth();
   unsigned UserIC = Hints.getInterleave();
 
   // Plan how to best vectorize, return the best VF and its cost.
   Optional<VectorizationFactor> MaybeVF = LVP.plan(UserVF, UserIC);
 

llvm/lib/Transforms/Vectorize/VPRecipeBuilder.h

 
 using VPRecipeOrVPValueTy = PointerUnion<VPRecipeBase *, VPValue *>;
 
 /// Helper class to create VPRecipies from IR instructions.
 class VPRecipeBuilder {
   /// The loop that we evaluate.
   Loop *OrigLoop;
 
-  /// Target Library Info.
-  const TargetLibraryInfo *TLI;
-
   /// The legality analysis.
   LoopVectorizationLegality *Legal;
 
   /// The profitablity analysis.
   LoopVectorizationCostModel &CM;
 
   PredicatedScalarEvolution &PSE;
 
class VPRecipeBuilder {
   /// if it can. The function should only be called if the cost-model indicates
   /// that widening should be performed.
   VPWidenRecipe *tryToWiden(Instruction *I, VPlan &Plan) const;
 
   /// Return a VPRecipeOrValueTy with VPRecipeBase * being set. This can be used to force the use as VPRecipeBase* for recipe sub-types that also inherit from VPValue.
   VPRecipeOrVPValueTy toVPRecipeResult(VPRecipeBase *R) const { return R; }
 
 public:
-  VPRecipeBuilder(Loop *OrigLoop, const TargetLibraryInfo *TLI,
-                  LoopVectorizationLegality *Legal,
+  VPRecipeBuilder(Loop *OrigLoop, LoopVectorizationLegality *Legal,
                   LoopVectorizationCostModel &CM,
                   PredicatedScalarEvolution &PSE, VPBuilder &Builder)
-      : OrigLoop(OrigLoop), TLI(TLI), Legal(Legal), CM(CM), PSE(PSE),
-        Builder(Builder) {}
+      : OrigLoop(OrigLoop), Legal(Legal), CM(CM), PSE(PSE), Builder(Builder) {}
 
   /// Check if an existing VPValue can be used for \p Instr or a recipe can be
   /// create for \p I withing the given VF \p Range. If an existing VPValue can
   /// be used or if a recipe can be created, return it. Otherwise return a
   /// VPRecipeOrVPValueTy with nullptr.
   VPRecipeOrVPValueTy tryToCreateWidenRecipe(Instruction *Instr, VFRange &Range,
                                              VPlanPtr &Plan);
 

llvm/lib/Transforms/Vectorize/VPlan.h

 class VPlan;
 class VPlanSlp;
 
 /// Returns a calculation for the total number of elements for a given \p VF.
 /// For fixed width vectors this value is a constant, whereas for scalable
 /// vectors it is an expression determined at runtime.
 Value *getRuntimeVF(IRBuilder<> &B, Type *Ty, ElementCount VF);
 
-/// A range of powers-of-2 vectorization factors with fixed start and
-/// adjustable end. The range includes start and excludes end, e.g.,:
-/// [1, 9) = {1, 2, 4, 8}
+/// A range of powers-of-2 vectorization factors with adjustable start and end.
+/// The range includes start and excludes end, e.g.,: [1, 9) = {1, 2, 4, 8}
 struct VFRange {
   // A power of 2.
-  const ElementCount Start;
+  ElementCount Start;
 
   // Need not be a power of 2. If End <= Start range is empty.
   ElementCount End;
 
   bool isEmpty() const {
     return End.getKnownMinValue() <= Start.getKnownMinValue();
   }
 

llvm/test/Transforms/LoopVectorize/X86/phis-only.ll

+; REQUIRES: asserts
+; RUN: opt -loop-vectorize -debug -S %s 2>&1 | FileCheck %s
+
+target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx"
+
+; The function only contains induction PHIs. Make sure there is a single VPlan for all possible VFs.
+define void @phis_only() {
+; CHECK-LABEL: VPlan 'Initial VPlan for VF={1,2,4,8,16},UF>=1' {
+; CHECK-NEXT:  loop:
+; CHECK-NEXT:    WIDEN-INDUCTION %iv = phi %iv.next, 0
+; CHECK-NEXT:    WIDEN-INDUCTION %iv.2 = phi %iv.2.next, 0
+; CHECK-NEXT:  No successors
+; CHECK-NEXT:  }
+;
+entry:
+  br label %loop
+
+loop:
+  %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
+  %iv.2 = phi i64 [ %iv.2.next, %loop ], [ 0, %entry ]
+  %iv.next = add nuw nsw i64 %iv, 1
+  %iv.2.next = add nsw i64 %iv.2, -1
+  %ec = icmp eq i64 %iv.2.next, 0
+  br i1 %ec, label %exit, label %loop
+
+exit:
+  ret void
+}