[LV] Added special representation of the loop into VPlan

[nikolaypanchenko]

Summary

The commit adds a special object to represent loop-like region in a
VPlan. Currently it simply replaces region that was previously built to
hold Header -> Latch and provides special functionality to query IV.

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

std::optional<VPlanPtr> LoopVectorizationPlanner::tryToBuildVPlanWithVPRecipes(
   // Build initial VPlan: Scan the body of the loop in a topological order to
   // visit each basic block after having visited its predecessor basic blocks.
   // ---------------------------------------------------------------------------
 
   // Create initial VPlan skeleton, starting with a block for the pre-header,
   // followed by a region for the vector loop, followed by the middle block. The
   // skeleton vector loop region contains a header and latch block.
   VPBasicBlock *Preheader = new VPBasicBlock("vector.ph");
-  auto Plan = std::make_unique<VPlan>(Preheader);
 
   VPBasicBlock *HeaderVPBB = new VPBasicBlock("vector.body");
   VPBasicBlock *LatchVPBB = new VPBasicBlock("vector.latch");
   VPBlockUtils::insertBlockAfter(LatchVPBB, HeaderVPBB);
-  auto *TopRegion = new VPRegionBlock(HeaderVPBB, LatchVPBB, "vector loop");
-  VPBlockUtils::insertBlockAfter(TopRegion, Preheader);
+  auto *Loop = new VPCountableLoop(HeaderVPBB, LatchVPBB, "vector countable loop");
+  VPBlockUtils::insertBlockAfter(Loop, Preheader);
   VPBasicBlock *MiddleVPBB = new VPBasicBlock("middle.block");
-  VPBlockUtils::insertBlockAfter(MiddleVPBB, TopRegion);
+  VPBlockUtils::insertBlockAfter(MiddleVPBB, Loop);
+  auto *TopRegion = new VPRegionBlock(Preheader, MiddleVPBB, "vector loop");
+  auto Plan = std::make_unique<VPlan>(TopRegion);
 
   // Don't use getDecisionAndClampRange here, because we don't know the UF
   // so this function is better to be conservative, rather than to split
   // it up into different VPlans.
   bool IVUpdateMayOverflow = false;
   for (ElementCount VF : Range)
     IVUpdateMayOverflow |= !isIndvarOverflowCheckKnownFalse(&CM, VF);
 
std::optional<VPlanPtr> LoopVectorizationPlanner::tryToBuildVPlanWithVPRecipes(
 
   if (CM.requiresScalarEpilogue(Range)) {
     // No edge from the middle block to the unique exit block has been inserted
     // and there is nothing to fix from vector loop; phis should have incoming
     // from scalar loop only.
   } else
     addUsersInExitBlock(HeaderVPBB, MiddleVPBB, OrigLoop, *Plan);
 
-  assert(isa<VPRegionBlock>(Plan->getVectorLoopRegion()) &&
+  if (std::optional<Loop::LoopBounds> Bounds =
+          OrigLoop->getBounds(*PSE.getSE()))
+    Loop->setUpperBound(Plan->getVPValue(&Bounds->getFinalIVValue()));
+  assert(isa<VPLoopBase>(Plan->getVectorLoopRegion()) &&
          !Plan->getVectorLoopRegion()->getEntryBasicBlock()->empty() &&
-         "entry block must be set to a VPRegionBlock having a non-empty entry "
+         "entry block must be set to a VPLoopBase having a non-empty entry "
          "VPBasicBlock");
   RecipeBuilder.fixHeaderPhis();
 
   // ---------------------------------------------------------------------------
   // Transform initial VPlan: Apply previously taken decisions, in order, to
   // bring the VPlan to its final state.
   // ---------------------------------------------------------------------------
 
   VPlanTransforms::removeRedundantCanonicalIVs(*Plan);
   VPlanTransforms::removeRedundantInductionCasts(*Plan);
 
   // Adjust the recipes for any inloop reductions.
-  adjustRecipesForReductions(cast<VPBasicBlock>(TopRegion->getExiting()), Plan,
+  adjustRecipesForReductions(cast<VPBasicBlock>(Loop->getExiting()), Plan,
                              RecipeBuilder, Range.Start);
 
   // Sink users of fixed-order recurrence past the recipe defining the previous
   // value and introduce FirstOrderRecurrenceSplice VPInstructions.
   if (!VPlanTransforms::adjustFixedOrderRecurrences(*Plan, Builder))
     return std::nullopt;
 
   // Interleave memory: for each Interleave Group we marked earlier as relevant

llvm/lib/Transforms/Vectorize/VPlan.h

protected:
   VPBlockBase(const unsigned char SC, const std::string &N)
       : SubclassID(SC), Name(N) {}
 
 public:
   /// An enumeration for keeping track of the concrete subclass of VPBlockBase
   /// that are actually instantiated. Values of this enumeration are kept in the
   /// SubclassID field of the VPBlockBase objects. They are used for concrete
   /// type identification.
-  using VPBlockTy = enum { VPBasicBlockSC, VPRegionBlockSC };
+  using VPBlockTy = enum { VPBasicBlockSC, VPRegionBlockSC, VPCountableLoopSC };
 
   using VPBlocksTy = SmallVectorImpl<VPBlockBase *>;
 
   virtual ~VPBlockBase() = default;
 
   const std::string &getName() const { return Name; }
 
   void setName(const Twine &newName) { Name = newName.str(); }
public:
   inline bool empty() const { return Recipes.empty(); }
   inline const VPRecipeBase &front() const { return Recipes.front(); }
   inline VPRecipeBase &front() { return Recipes.front(); }
   inline const VPRecipeBase &back() const { return Recipes.back(); }
   inline VPRecipeBase &back() { return Recipes.back(); }
 
   /// Returns a reference to the list of recipes.
   RecipeListTy &getRecipeList() { return Recipes; }
+  const RecipeListTy &getRecipeList() const { return Recipes; }
 
   /// Returns a pointer to a member of the recipe list.
   static RecipeListTy VPBasicBlock::*getSublistAccess(VPRecipeBase *) {
     return &VPBasicBlock::Recipes;
   }
 
   /// Method to support type inquiry through isa, cast, and dyn_cast.
   static inline bool classof(const VPBlockBase *V) {
class VPRegionBlock : public VPBlockBase {
   VPBlockBase *Exiting;
 
   /// An indicator whether this region is to generate multiple replicated
   /// instances of output IR corresponding to its VPBlockBases.
   bool IsReplicator;
 
 public:
   VPRegionBlock(VPBlockBase *Entry, VPBlockBase *Exiting,
+                const std::string &Name = "", bool IsReplicator = false);
+
+  VPRegionBlock(unsigned RegionOpcode, VPBlockBase *Entry, VPBlockBase *Exiting,
+                const std::string &Name = "");
+
+  VPRegionBlock(unsigned RegionOpcode = VPRegionBlockSC,
                 const std::string &Name = "", bool IsReplicator = false)
-      : VPBlockBase(VPRegionBlockSC, Name), Entry(Entry), Exiting(Exiting),
-        IsReplicator(IsReplicator) {
-    assert(Entry->getPredecessors().empty() && "Entry block has predecessors.");
-    assert(Exiting->getSuccessors().empty() && "Exit block has successors.");
-    Entry->setParent(this);
-    Exiting->setParent(this);
-  }
-  VPRegionBlock(const std::string &Name = "", bool IsReplicator = false)
-      : VPBlockBase(VPRegionBlockSC, Name), Entry(nullptr), Exiting(nullptr),
-        IsReplicator(IsReplicator) {}
+      : VPBlockBase(RegionOpcode, Name), Entry(nullptr), Exiting(nullptr),
+        IsReplicator(IsReplicator){}
 
   ~VPRegionBlock() override {
     if (Entry) {
       VPValue DummyValue;
       Entry->dropAllReferences(&DummyValue);
       deleteCFG(Entry);
     }
   }
 
   /// Method to support type inquiry through isa, cast, and dyn_cast.
   static inline bool classof(const VPBlockBase *V) {
-    return V->getVPBlockID() == VPBlockBase::VPRegionBlockSC;
+    return V->getVPBlockID() == VPBlockBase::VPRegionBlockSC ||
+           V->getVPBlockID() == VPCountableLoopSC;
   }
 
   const VPBlockBase *getEntry() const { return Entry; }
   VPBlockBase *getEntry() { return Entry; }
 
   /// Set \p EntryBlock as the entry VPBlockBase of this VPRegionBlock. \p
   /// EntryBlock must have no predecessors.
   void setEntry(VPBlockBase *EntryBlock) {
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   /// Note that the numbering is applied to the whole VPlan, so printing
   /// individual regions is consistent with the whole VPlan printing.
   void print(raw_ostream &O, const Twine &Indent,
              VPSlotTracker &SlotTracker) const override;
   using VPBlockBase::print; // Get the print(raw_stream &O) version.
 #endif
 };
 
+/// A base class for all loop-like regions
+class VPLoopBase : public VPRegionBlock {
+public:
+  explicit VPLoopBase(unsigned LoopOpcode, VPBlockBase *Header,
+                      VPBlockBase *Exiting, const std::string &Name = "")
+      : VPRegionBlock(LoopOpcode, Header, Exiting, Name) {}
+
+  explicit VPLoopBase(unsigned LoopOpcode, const std::string &Name = "")
+      : VPRegionBlock(LoopOpcode, Name, false) {}
+
+  /// Method to return header VPBB
+  VPBlockBase *getHeader() { return getEntry(); }
+
+  /// Method to return header VPBB
+  const VPBlockBase *getHeader() const { return getEntry(); }
+
+  /// Method to support type inquiry through isa, cast, and dyn_cast.
+  static inline bool classof(const VPBlockBase *V) {
+    return V->getVPBlockID() == VPBlockBase::VPCountableLoopSC;
+  }
+};
+
+/// Countable loop representation in VPlan.
+class VPCountableLoop final : public VPLoopBase {
+  VPValue *LowerBound;
+  VPValue *UpperBound;
+
+public:
+  explicit VPCountableLoop(VPBlockBase *Header, VPBlockBase *Exiting,
+                           VPValue *LB, VPValue *UB,
+                           const std::string &Name = "");
+
+  /// TODO: These constructors should be moved to private and only allowed to
+  /// be called by VPlan builder which may not convert lower and upper bounds
+  /// before countable loop is created.
+  explicit VPCountableLoop(VPBasicBlock *Header, VPBasicBlock *Exiting,
+                           const std::string &Name = "")
+      : VPCountableLoop(Header, Exiting, /*LowerBound=*/nullptr,
+                        /*UpperBound=*/nullptr, Name) {}
+
+  explicit VPCountableLoop(const std::string &Name = "")
+      : VPLoopBase(VPCountableLoopSC, Name) {}
+
+  /// Method to get IV of the loop
+  VPValue *getCanonicalIV();
+
+  /// Method to get IV of the loop
+  const VPValue *getCanonicalIV() const;
+
+  /// Return lower bound of the countable loop
+  VPValue *getLowerBound() { return LowerBound; }
+
+  /// Return lower bound of the countable loop
+  const VPValue *getLowerBound() const { return LowerBound; }
+
+  /// Return upper bound of the countable loop
+  VPValue *getUpperBound() { return UpperBound; }
+
+  /// Return upper bound of the countable loop
+  const VPValue *getUpperBound() const { return UpperBound; }
+
+  /// Set lower bound of the loop
+  void setLowerBound(VPValue *LB) { LowerBound = LB; }
+
+  /// Set upper bound of the loop
+  void setUpperBound(VPValue *UB) { UpperBound = UB; }
+
+  /// Method to support type inquiry through isa, cast, and dyn_cast.
+  static inline bool classof(const VPBlockBase *V) {
+    return V->getVPBlockID() == VPBlockBase::VPCountableLoopSC;
+  }
+
+  /// The method which generates the output IR instructions that correspond to
+  /// this VPCountableLoop, thereby "executing" the VPlan.
+  void execute(VPTransformState *State) override;
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  /// Print this VPLoopRegion to \p O (recursively), prefixing all lines with
+  /// \p Indent. \p SlotTracker is used to print unnamed VPValue's using
+  /// consequtive numbers.
+  ///
+  /// Note that the numbering is applied to the whole VPlan, so printing
+  /// individual regions is consistent with the whole VPlan printing.
+  void print(raw_ostream &O, const Twine &Indent,
+             VPSlotTracker &SlotTracker) const override;
+  using VPBlockBase::print; // Get the print(raw_stream &O) version.
+#endif
+};
+
 /// VPlan models a candidate for vectorization, encoding various decisions take
 /// to produce efficient output IR, including which branches, basic-blocks and
 /// output IR instructions to generate, and their cost. VPlan holds a
 /// Hierarchical-CFG of VPBasicBlocks and VPRegionBlocks rooted at an Entry
 /// VPBlock.
 class VPlan {
   friend class VPlanPrinter;
   friend class VPSlotTracker;
#endif
   iterator_range<mapped_iterator<Use *, std::function<VPValue *(Value *)>>>
   mapToVPValues(User::op_range Operands) {
     std::function<VPValue *(Value *)> Fn = [this](Value *Op) {
       return getVPValueOrAddLiveIn(Op);
     };
     return map_range(Operands, Fn);
   }
 
-  /// Returns the VPRegionBlock of the vector loop.
-  VPRegionBlock *getVectorLoopRegion() {
-    return cast<VPRegionBlock>(getEntry()->getSingleSuccessor());
-  }
-  const VPRegionBlock *getVectorLoopRegion() const {
-    return cast<VPRegionBlock>(getEntry()->getSingleSuccessor());
+  /// Returns the VPLoopBase of the VPlan
+  /// TODO: These function should be moved to vputils or removed completely as
+  /// VPlan may contain multiple loops
+  VPLoopBase *getVectorLoopRegion() {
+    return const_cast<VPLoopBase *>(
+        const_cast<const VPlan *>(this)->getVectorLoopRegion());
+  }
+
+  /// Returns the VPLoopBase of the VPlan
+  /// TODO: These function should be moved to vputils or removed completely as
+  /// VPlan may contain multiple loops
+  const VPLoopBase *getVectorLoopRegion() const {
+    assert(isa<VPRegionBlock>(Entry) &&
+           "Entry of the VPlan must be a type of VPRegionBlock");
+    // Ad-hoc approach that expects
+    // VPRegionBlock {
+    //   preheader:
+    //     ...
+    //   VPLoopBase {
+    //     ...
+    //   }
+    // }
+    VPBlockBase *Loop =
+        cast<VPRegionBlock>(Entry)->getEntry()->getSingleSuccessor();
+    assert(isa<VPLoopBase>(Loop) &&
+           "VPLoopBase is expected as a successor of the preheader");
+    return cast<VPLoopBase>(Loop);
   }
 
   /// Returns the canonical induction recipe of the vector loop.
+  /// TODO: These function should be moved to vputils or removed completely as
+  /// VPlan may contain multiple VPLoops
   VPCanonicalIVPHIRecipe *getCanonicalIV() {
-    VPBasicBlock *EntryVPBB = getVectorLoopRegion()->getEntryBasicBlock();
-    if (EntryVPBB->empty()) {
-      // VPlan native path.
-      EntryVPBB = cast<VPBasicBlock>(EntryVPBB->getSingleSuccessor());
-    }
-    return cast<VPCanonicalIVPHIRecipe>(&*EntryVPBB->begin());
+    VPLoopBase *Loop = getVectorLoopRegion();
+    VPValue *IV = cast<VPCountableLoop>(Loop)->getCanonicalIV();
+    return cast<VPCanonicalIVPHIRecipe>(IV->getDefiningRecipe());
   }
 
   /// Find and return the VPActiveLaneMaskPHIRecipe from the header - there
   /// be only one at most. If there isn't one, then return nullptr.
   VPActiveLaneMaskPHIRecipe *getActiveLaneMaskPhi();
 
   void addLiveOut(PHINode *PN, VPValue *V);
 

llvm/lib/Transforms/Vectorize/VPlan.cpp

for (VPBlockBase *Block : vp_depth_first_shallow(Entry))
     // DummyValue.
     Block->dropAllReferences(NewValue);
 }
 
 void VPRegionBlock::execute(VPTransformState *State) {
   ReversePostOrderTraversal<VPBlockShallowTraversalWrapper<VPBlockBase *>>
       RPOT(Entry);
 
-  if (!isReplicator()) {
-    // Create and register the new vector loop.
-    Loop *PrevLoop = State->CurrentVectorLoop;
-    State->CurrentVectorLoop = State->LI->AllocateLoop();
-    BasicBlock *VectorPH = State->CFG.VPBB2IRBB[getPreheaderVPBB()];
-    Loop *ParentLoop = State->LI->getLoopFor(VectorPH);
-
-    // Insert the new loop into the loop nest and register the new basic blocks
-    // before calling any utilities such as SCEV that require valid LoopInfo.
-    if (ParentLoop)
-      ParentLoop->addChildLoop(State->CurrentVectorLoop);
-    else
-      State->LI->addTopLevelLoop(State->CurrentVectorLoop);
-
-    // Visit the VPBlocks connected to "this", starting from it.
-    for (VPBlockBase *Block : RPOT) {
-      LLVM_DEBUG(dbgs() << "LV: VPBlock in RPO " << Block->getName() << '\n');
-      Block->execute(State);
-    }
-
-    State->CurrentVectorLoop = PrevLoop;
+  if (!isReplicator() && !getParent()) {
+    getPlan()->getVectorLoopRegion()->execute(State);
     return;
   }
 
   assert(!State->Instance && "Replicating a Region with non-null instance.");
 
   // Enter replicating mode.
   State->Instance = VPIteration(0, 0);
 
void VPlan::execute(VPTransformState *State) {
 
   // Initialize CFG state.
   State->CFG.PrevVPBB = nullptr;
   State->CFG.ExitBB = State->CFG.PrevBB->getSingleSuccessor();
   BasicBlock *VectorPreHeader = State->CFG.PrevBB;
   State->Builder.SetInsertPoint(VectorPreHeader->getTerminator());
 
   // Generate code in the loop pre-header and body.
-  for (VPBlockBase *Block : vp_depth_first_shallow(Entry))
+  for (VPBlockBase *Block :
+       vp_depth_first_shallow(cast<VPRegionBlock>(Entry)->getEntry()))
     Block->execute(State);
 
   VPBasicBlock *LatchVPBB = getVectorLoopRegion()->getExitingBasicBlock();
   BasicBlock *VectorLatchBB = State->CFG.VPBB2IRBB[LatchVPBB];
 
   // Fix the latch value of canonical, reduction and first-order recurrences
   // phis in the vector loop.
   VPBasicBlock *Header = getVectorLoopRegion()->getEntryBasicBlock();
VPValue *vputils::getOrCreateVPValueForSCEVExpr(VPlan &Plan, const SCEV *Expr,
   if (auto *E = dyn_cast<SCEVUnknown>(Expr))
     return Plan.getVPValueOrAddLiveIn(E->getValue());
 
   VPBasicBlock *Preheader = Plan.getEntry()->getEntryBasicBlock();
   VPExpandSCEVRecipe *Step = new VPExpandSCEVRecipe(Expr, SE);
   Preheader->appendRecipe(Step);
   return Step;
 }
+
+VPValue *VPCountableLoop::getCanonicalIV() {
+  return const_cast<VPValue *>(
+      const_cast<const VPCountableLoop *>(this)->getCanonicalIV());
+}
+
+const VPValue *VPCountableLoop::getCanonicalIV() const {
+  for (const VPRecipeBase &R :
+       getHeader()->getEntryBasicBlock()->getRecipeList())
+    if (auto *VPIV = dyn_cast<VPCanonicalIVPHIRecipe>(&R))
+      return VPIV;
+  return nullptr;
+}
+
+void VPCountableLoop::execute(VPTransformState *State) {
+  ReversePostOrderTraversal<VPBlockShallowTraversalWrapper<VPBlockBase *>> RPOT(
+      getHeader());
+  // Create and register the new vector loop.
+  Loop *PrevLoop = State->CurrentVectorLoop;
+  State->CurrentVectorLoop = State->LI->AllocateLoop();
+  BasicBlock *VectorPH =
+      State->CFG.VPBB2IRBB[cast<VPBasicBlock>(getSinglePredecessor())];
+  Loop *ParentLoop = State->LI->getLoopFor(VectorPH);
+
+  // Insert the new loop into the loop nest and register the new basic blocks
+  // before calling any utilities such as SCEV that require valid LoopInfo.
+  if (ParentLoop)
+    ParentLoop->addChildLoop(State->CurrentVectorLoop);
+  else
+    State->LI->addTopLevelLoop(State->CurrentVectorLoop);
+
+  // Visit the VPBlocks connected to "this", starting from it.
+  for (VPBlockBase *Block : RPOT) {
+    LLVM_DEBUG(dbgs() << "LV: VPBlock in RPO " << Block->getName() << '\n');
+    Block->execute(State);
+  }
+
+  State->CurrentVectorLoop = PrevLoop;
+}
+
+VPRegionBlock::VPRegionBlock(VPBlockBase *Entry, VPBlockBase *Exiting,
+                             const std::string &Name, bool IsReplicator)
+    : VPBlockBase(VPRegionBlockSC, Name), Entry(Entry), Exiting(Exiting),
+      IsReplicator(IsReplicator) {
+  assert(Entry->getPredecessors().empty() && "Entry block has predecessors.");
+  assert(Exiting->getSuccessors().empty() && "Exit block has successors.");
+  Entry->setParent(this);
+  Exiting->setParent(this);
+  ReversePostOrderTraversal<VPBlockShallowTraversalWrapper<VPBlockBase *>> RPOT(
+      Entry);
+  for (VPBlockBase *VPBB : RPOT)
+    VPBB->setParent(this);
+}
+
+VPRegionBlock::VPRegionBlock(unsigned RegionOpcode, VPBlockBase *Entry,
+                             VPBlockBase *Exiting, const std::string &Name)
+    : VPBlockBase(RegionOpcode, Name), Entry(Entry), Exiting(Exiting),
+      IsReplicator(false) {
+  assert(Entry->getPredecessors().empty() && "Entry block has predecessors.");
+  // Single exiting block may not exist for loops with multple exits
+  assert((!Exiting || Exiting->getSuccessors().empty()) &&
+         "Exit block has successors.");
+  Entry->setParent(this);
+  if (Exiting)
+    Exiting->setParent(this);
+  ReversePostOrderTraversal<VPBlockShallowTraversalWrapper<VPBlockBase *>> RPOT(
+      Entry);
+  for (VPBlockBase *VPBB : RPOT)
+    VPBB->setParent(this);
+}
+
+VPCountableLoop::VPCountableLoop(VPBlockBase *Header, VPBlockBase *Exiting,
+                                 VPValue *LB, VPValue *UB,
+                                 const std::string &Name)
+    : VPLoopBase(VPCountableLoopSC, Header, Exiting, Name), LowerBound(LB),
+      UpperBound(UB) {
+  ReversePostOrderTraversal<VPBlockShallowTraversalWrapper<VPBlockBase *>> RPOT(
+      Header);
+  for (VPBlockBase *VPBB : RPOT)
+    VPBB->setParent(this);
+}
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+void VPCountableLoop::print(raw_ostream &O, const Twine &Indent,
+                            VPSlotTracker &SlotTracker) const {
+  O << Indent << getName();
+  if (const VPValue *IV = getCanonicalIV()) {
+    O << ' ';
+    IV->printAsOperand(O, SlotTracker);
+    O << " = ";
+    if (const VPValue *LB = getLowerBound())
+      O << *LB;
+    else
+      O << '0';
+    if (const VPValue *UB = getUpperBound())
+      O << ", " << *UB;
+    else
+      O << ", inf";
+  }
+  O << " {\n";
+  auto NewIndent = Indent + "  ";
+  for (auto *BlockBase : vp_depth_first_shallow(getHeader())) {
+    O << '\n';
+    BlockBase->print(O, NewIndent, SlotTracker);
+  }
+  O << Indent << "}\n";
+
+  printSuccessors(O, Indent);
+}
+#endif

llvm/lib/Transforms/Vectorize/VPlanHCFGBuilder.h

private:
 
   // Dominator analysis for VPlan plain CFG to be used in the
   // construction of the H-CFG. This analysis is no longer valid once regions
   // are introduced.
   VPDominatorTree VPDomTree;
 
   /// Build plain CFG for TheLoop. Return the pre-header VPBasicBlock connected
   /// to a new VPRegionBlock (TopRegion) enclosing the plain CFG.
-  VPBasicBlock *buildPlainCFG();
+  VPBlockBase *buildPlainCFG();
 
 public:
   VPlanHCFGBuilder(Loop *Lp, LoopInfo *LI, VPlan &P)
       : TheLoop(Lp), LI(LI), Plan(P) {}
 
   /// Build H-CFG for TheLoop and update Plan accordingly.
   void buildHierarchicalCFG();
 };
 } // namespace llvm
 
 #endif // LLVM_TRANSFORMS_VECTORIZE_VPLAN_VPLANHCFGBUILDER_H

llvm/lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp

#endif
   void createVPInstructionsForVPBB(VPBasicBlock *VPBB, BasicBlock *BB);
 
 public:
   PlainCFGBuilder(Loop *Lp, LoopInfo *LI, VPlan &P)
       : TheLoop(Lp), LI(LI), Plan(P) {}
 
   /// Build plain CFG for TheLoop. Return the pre-header VPBasicBlock connected
   /// to a new VPRegionBlock (TopRegion) enclosing the plain CFG.
-  VPBasicBlock *buildPlainCFG();
+  VPBlockBase *buildPlainCFG();
 };
 } // anonymous namespace
 
 // Set predecessors of \p VPBB in the same order as they are in \p BB. \p VPBB
 // must have no predecessors.
 void PlainCFGBuilder::setVPBBPredsFromBB(VPBasicBlock *VPBB, BasicBlock *BB) {
   SmallVector<VPBlockBase *, 8> VPBBPreds;
   // Collect VPBB predecessors.
if (BlockIt != BB2VPBB.end())
     return BlockIt->second;
 
   // Get or create a region for the loop containing BB.
   Loop *CurrentLoop = LI->getLoopFor(BB);
   VPRegionBlock *ParentR = nullptr;
   if (CurrentLoop) {
     auto Iter = Loop2Region.insert({CurrentLoop, nullptr});
     if (Iter.second)
-      Iter.first->second = new VPRegionBlock(
-          CurrentLoop->getHeader()->getName().str(), false /*isReplicator*/);
+      Iter.first->second =
+          new VPCountableLoop(CurrentLoop->getHeader()->getName().str());
     ParentR = Iter.first->second;
   }
 
   // Create new VPBB.
   LLVM_DEBUG(dbgs() << "Creating VPBasicBlock for " << BB->getName() << "\n");
   VPBasicBlock *VPBB = new VPBasicBlock(BB->getName());
   BB2VPBB[BB] = VPBB;
   VPBB->setParent(ParentR);
if (auto *Phi = dyn_cast<PHINode>(Inst)) {
           VPIRBuilder.createNaryOp(Inst->getOpcode(), VPOperands, Inst));
     }
 
     IRDef2VPValue[Inst] = NewVPV;
   }
 }
 
 // Main interface to build the plain CFG.
-VPBasicBlock *PlainCFGBuilder::buildPlainCFG() {
+VPBlockBase *PlainCFGBuilder::buildPlainCFG() {
   // 1. Scan the body of the loop in a topological order to visit each basic
   // block after having visited its predecessor basic blocks. Create a VPBB for
   // each BB and link it to its successor and predecessor VPBBs. Note that
   // predecessors must be set in the same order as they are in the incomming IR.
   // Otherwise, there might be problems with existing phi nodes and algorithm
   // based on predecessors traversal.
 
   // Loop PH needs to be explicitly visited since it's not taken into account by
while (!LoopWorkList.empty()) {
     Region->setEntry(HeaderVPBB);
     VPBlockUtils::connectBlocks(PreheaderVPBB, Region);
 
     // Disconnect exit block from exiting (=latch) block, set exiting block and
     // connect region to exit block.
     VPBasicBlock *ExitVPBB = getOrCreateVPBB(L->getExitBlock());
     VPBlockUtils::disconnectBlocks(ExitingVPBB, ExitVPBB);
     Region->setExiting(ExitingVPBB);
+    // TODO: Set lower and upper bound for the loop
     VPBlockUtils::connectBlocks(Region, ExitVPBB);
 
     // Queue sub-loops for processing.
     LoopWorkList.append(L->begin(), L->end());
   }
   // 4. The whole CFG has been built at this point so all the input Values must
   // have a VPlan couterpart. Fix VPlan phi nodes by adding their corresponding
   // VPlan operands.
   fixPhiNodes();
 
-  return ThePreheaderVPBB;
+  return new VPRegionBlock(ThePreheaderVPBB, LoopExitVPBB);
 }
 
-VPBasicBlock *VPlanHCFGBuilder::buildPlainCFG() {
+VPBlockBase *VPlanHCFGBuilder::buildPlainCFG() {
   PlainCFGBuilder PCFGBuilder(TheLoop, LI, Plan);
   return PCFGBuilder.buildPlainCFG();
 }
 
 // Public interface to build a H-CFG.
 void VPlanHCFGBuilder::buildHierarchicalCFG() {
   // Build Top Region enclosing the plain CFG and set it as VPlan entry.
-  VPBasicBlock *EntryVPBB = buildPlainCFG();
+  VPBlockBase *EntryVPBB = buildPlainCFG();
   Plan.setEntry(EntryVPBB);
   LLVM_DEBUG(Plan.setName("HCFGBuilder: Plain CFG\n"); dbgs() << Plan);
 
-  VPRegionBlock *TopRegion = Plan.getVectorLoopRegion();
+  VPRegionBlock *TopRegion = cast<VPRegionBlock>(Plan.getEntry());
   Verifier.verifyHierarchicalCFG(TopRegion);
 
   // Compute plain CFG dom tree for VPLInfo.
   VPDomTree.recalculate(Plan);
   LLVM_DEBUG(dbgs() << "Dominator Tree after building the plain CFG.\n";
              VPDomTree.print(dbgs()));
 }

llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp

 //===-- VPlanTransforms.cpp - Utility VPlan to VPlan transforms -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements a set of utility VPlan to VPlan transformations.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "VPlanTransforms.h"
+#include "VPlan.h"
 #include "VPlanDominatorTree.h"
 #include "VPRecipeBuilder.h"
 #include "VPlanCFG.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/IVDescriptors.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/Intrinsics.h"

 
 bool VPlanTransforms::adjustFixedOrderRecurrences(VPlan &Plan,
                                                   VPBuilder &Builder) {
   VPDominatorTree VPDT;
   VPDT.recalculate(Plan);
 
   SmallVector<VPFirstOrderRecurrencePHIRecipe *> RecurrencePhis;
   for (VPRecipeBase &R :
-       Plan.getVectorLoopRegion()->getEntry()->getEntryBasicBlock()->phis())
+       Plan.getVectorLoopRegion()->getEntryBasicBlock()->phis())
     if (auto *FOR = dyn_cast<VPFirstOrderRecurrencePHIRecipe>(&R))
       RecurrencePhis.push_back(FOR);
 
   for (VPFirstOrderRecurrencePHIRecipe *FOR : RecurrencePhis) {
     SmallPtrSet<VPFirstOrderRecurrencePHIRecipe *, 4> SeenPhis;
     VPRecipeBase *Previous = FOR->getBackedgeValue()->getDefiningRecipe();
     // Fixed-order recurrences do not contain cycles, so this loop is guaranteed
     // to terminate.

llvm/lib/Transforms/Vectorize/VPlanVerifier.cpp

 /// not specific for VPBasicBlocks or VPRegionBlocks.
 static void verifyBlocksInRegion(const VPRegionBlock *Region) {
   for (const VPBlockBase *VPB : vp_depth_first_shallow(Region->getEntry())) {
     // Check block's parent.
     assert(VPB->getParent() == Region && "VPBlockBase has wrong parent");
 
     auto *VPBB = dyn_cast<VPBasicBlock>(VPB);
     // Check block's condition bit.
-    if (VPB->getNumSuccessors() > 1 || (VPBB && VPBB->isExiting()))
+    if (VPB->getNumSuccessors() == 0 && !Region->getParent())
+      assert(!VPBB->getTerminator() &&
+             "Unexpected branch recipe in VPlan's exiting basic block");
+    else if (VPB->getNumSuccessors() > 1 || (VPBB && VPBB->isExiting()))
       assert(VPBB && VPBB->getTerminator() &&
              "Block has multiple successors but doesn't "
              "have a proper branch recipe!");
     else
       assert((!VPBB || !VPBB->getTerminator()) && "Unexpected branch recipe!");
 
     // Check block's successors.
     const auto &Successors = VPB->getSuccessors();

llvm/test/Transforms/LoopVectorize/AArch64/sve-tail-folding-forced.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; REQUIRES: asserts
 ; RUN: opt -S -passes=loop-vectorize -debug-only=loop-vectorize < %s 2>%t | FileCheck %s
 ; RUN: cat %t | FileCheck %s --check-prefix=VPLANS
 
 ; These tests ensure that tail-folding is enabled when the predicate.enable
 ; loop attribute is set to true.
 
 target triple = "aarch64-unknown-linux-gnu"
 
 ; VPLANS-LABEL: Checking a loop in 'simple_memset'
 ; VPLANS:      VPlan 'Initial VPlan for VF={vscale x 1,vscale x 2,vscale x 4},UF>=1' {
-; VPLANS-NEXT: Live-in vp<[[TC:%[0-9]+]]> = original trip-count
+; VPLANS-NEXT: Live-in vp<%1> = original trip-count
 ; VPLANS-EMPTY:
-; VPLANS-NEXT: vector.ph:
-; VPLANS-NEXT:   EMIT vp<[[VF:%[0-9]+]]> = VF * Part +  ir<0>
-; VPLANS-NEXT:   EMIT vp<[[NEWTC:%[0-9]+]]> = TC > VF ? TC - VF : 0 vp<[[TC]]>
-; VPLANS-NEXT:   EMIT vp<[[LANEMASK_ENTRY:%[0-9]+]]> = active lane mask vp<[[VF]]> vp<[[TC]]>
-; VPLANS-NEXT: Successor(s): vector loop
+; VPLANS-NEXT: <x1> vector loop: {
+; VPLANS-NEXT:   vector.ph:
+; VPLANS-NEXT:     EMIT vp<%2> = VF * Part +  ir<0>
+; VPLANS-NEXT:     EMIT vp<%3> = TC > VF ? TC - VF : 0 vp<%1>
+; VPLANS-NEXT:     EMIT vp<%4> = active lane mask vp<%2> vp<%1>
+; VPLANS-NEXT:   Successor(s): vector countable loop
+; VPLANS-EMPTY:
+; VPLANS-NEXT:   vector countable loop vp<%5> = 0, ir<%n> {
 ; VPLANS-EMPTY:
-; VPLANS-NEXT: <x1> vector loop: {
-; VPLANS-NEXT:   vector.body:
-; VPLANS-NEXT:     EMIT vp<[[INDV:%[0-9]+]]> = CANONICAL-INDUCTION
-; VPLANS-NEXT:     ACTIVE-LANE-MASK-PHI vp<[[LANEMASK_PHI:%[0-9]+]]> = phi vp<[[LANEMASK_ENTRY]]>, vp<[[LANEMASK_LOOP:%[0-9]+]]>
-; VPLANS-NEXT:     vp<[[STEP:%[0-9]+]]>    = SCALAR-STEPS vp<[[INDV]]>, ir<1>
-; VPLANS-NEXT:     CLONE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEP]]>
-; VPLANS-NEXT:     WIDEN store ir<%gep>, ir<%val>, vp<[[LANEMASK_PHI]]>
-; VPLANS-NEXT:     EMIT vp<[[INC:%[0-9]+]]> = VF * Part +  vp<[[INDV]]>
-; VPLANS-NEXT:     EMIT vp<[[LANEMASK_LOOP]]> = active lane mask vp<[[INC]]> vp<[[NEWTC]]>
-; VPLANS-NEXT:     EMIT vp<[[INDV_UPDATE:%[0-9]+]]> = VF * UF +  vp<[[INDV]]>
-; VPLANS-NEXT:     EMIT vp<[[NOT:%[0-9]+]]> = not vp<[[LANEMASK_LOOP]]>
-; VPLANS-NEXT:     EMIT branch-on-cond vp<[[NOT]]>
-; VPLANS-NEXT:   No successors
+; VPLANS-NEXT:     vector.body:
+; VPLANS-NEXT:       EMIT vp<%5> = CANONICAL-INDUCTION
+; VPLANS-NEXT:       ACTIVE-LANE-MASK-PHI vp<%6> = phi vp<%4>, vp<%10>
+; VPLANS-NEXT:       vp<%7>      = SCALAR-STEPS vp<%5>, ir<1>
+; VPLANS-NEXT:       CLONE ir<%gep> = getelementptr ir<%ptr>, vp<%7>
+; VPLANS-NEXT:       WIDEN store ir<%gep>, ir<%val>, vp<%6>
+; VPLANS-NEXT:       EMIT vp<%9> = VF * Part +  vp<%5>
+; VPLANS-NEXT:       EMIT vp<%10> = active lane mask vp<%9> vp<%3>
+; VPLANS-NEXT:       EMIT vp<%11> = VF * UF +  vp<%5>
+; VPLANS-NEXT:       EMIT vp<%12> = not vp<%10>
+; VPLANS-NEXT:       EMIT branch-on-cond vp<%12>
+; VPLANS-NEXT:     No successors
+; VPLANS-NEXT:   }
+; VPLANS-NEXT:   Successor(s): middle.block
+; VPLANS-EMPTY:
+; VPLANS-NEXT:   middle.block:
+; VPLANS-NEXT:   No successors
+; VPLANS-NEXT: }
+; VPLANS-NEXT: No successors
 ; VPLANS-NEXT: }
 
 define void @simple_memset(i32 %val, ptr %ptr, i64 %n) #0 {
 ; CHECK-LABEL: @simple_memset(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[N:%.*]], i64 1)
 ; CHECK-NEXT:    br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]]
 ; CHECK:       vector.ph:

llvm/test/Transforms/LoopVectorize/AArch64/sve-widen-gep.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; REQUIRES: asserts
 ; RUN: opt -passes=loop-vectorize -S -mtriple=aarch64 -mattr=+sve -debug-only=loop-vectorize \
 ; RUN:   -prefer-predicate-over-epilogue=scalar-epilogue < %s 2>&1 | FileCheck %s
 
 target triple = "aarch64-unknown-linux-gnu"
 
 ; CHECK-LABEL:  LV: Checking a loop in 'pointer_induction_used_as_vector'
 ; CHECK-NOT:    LV: Found {{.*}} scalar instruction:   %ptr.iv.2.next = getelementptr inbounds i8, ptr %ptr.iv.2, i64 1
 ;
 ; CHECK:        VPlan 'Initial VPlan for VF={vscale x 2},UF>=1' {
-; CHECK-NEXT:   Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<%N> {
 ; CHECK-EMPTY:
-; CHECK-NEXT:   <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     EMIT ir<%ptr.iv.1> = WIDEN-POINTER-INDUCTION ir<%start.1>, 8
-; CHECK-NEXT:     EMIT ir<%ptr.iv.2> = WIDEN-POINTER-INDUCTION ir<%start.2>, 1
-; CHECK-NEXT:     WIDEN-GEP Var[Inv] ir<%ptr.iv.2.next> = getelementptr ir<%ptr.iv.2>, ir<1>
-; CHECK-NEXT:     WIDEN store ir<%ptr.iv.1>, ir<%ptr.iv.2.next>
-; CHECK-NEXT:     WIDEN ir<%lv> = load ir<%ptr.iv.2>
-; CHECK-NEXT:     WIDEN ir<%add> = add ir<%lv>, ir<1>
-; CHECK-NEXT:     WIDEN store ir<%ptr.iv.2>, ir<%add>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT:   }
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       EMIT ir<%ptr.iv.1> = WIDEN-POINTER-INDUCTION ir<%start.1>, 8
+; CHECK-NEXT:       EMIT ir<%ptr.iv.2> = WIDEN-POINTER-INDUCTION ir<%start.2>, 1
+; CHECK-NEXT:       WIDEN-GEP Var[Inv] ir<%ptr.iv.2.next> = getelementptr ir<%ptr.iv.2>, ir<1>
+; CHECK-NEXT:       WIDEN store ir<%ptr.iv.1>, ir<%ptr.iv.2.next>
+; CHECK-NEXT:       WIDEN ir<%lv> = load ir<%ptr.iv.2>
+; CHECK-NEXT:       WIDEN ir<%add> = add ir<%lv>, ir<1>
+; CHECK-NEXT:       WIDEN store ir<%ptr.iv.2>, ir<%add>
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 
 ; In the test below the pointer phi %ptr.iv.2 is used as
 ;  1. As a uniform address for the load, and
 ;  2. Non-uniform use by the getelementptr which is stored. This requires the
 ;     vector value.
 define void @pointer_induction_used_as_vector(ptr noalias %start.1, ptr noalias %start.2, i64 %N) {
 ; CHECK-LABEL: @pointer_induction_used_as_vector(
 ; CHECK-NEXT:  entry:

llvm/test/Transforms/LoopVectorize/AArch64/synthesize-mask-for-call.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -force-vector-interleave=1 -debug-only=loop-vectorize -S < %s 2>&1 | FileCheck %s
 
 target triple = "aarch64-unknown-linux-gnu"
 
 ;; Given the choice between a masked and unmasked variant for the same VF (4)
 ;; where no mask is required, make sure we choose the unmasked variant.
 
 ; CHECK-LABEL: LV: Checking a loop in 'test_v4_v4m'
 ; CHECK: VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%load> = load ir<%gep>
-; CHECK-NEXT:     REPLICATE ir<%call> = call @foo(ir<%load>)
-; CHECK-NEXT:     CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN store ir<%arrayidx>, ir<%call>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%b>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%load> = load ir<%gep>
+; CHECK-NEXT:       REPLICATE ir<%call> = call @foo(ir<%load>)
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<%2>
+; CHECK-NEXT:       WIDEN store ir<%arrayidx>, ir<%call>
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 
-; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: VPlan 'Initial VPlan for VF={4},UF>=1' {
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[STEPS]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%load> = load ir<%gep>
-; CHECK-NEXT:     WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed4_nomask)
-; CHECK-NEXT:     CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN store ir<%arrayidx>, ir<%call>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%b>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%load> = load ir<%gep>
+; CHECK-NEXT:       WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed4_nomask)
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<%2>
+; CHECK-NEXT:       WIDEN store ir<%arrayidx>, ir<%call>
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 
 ;; If we have a masked variant at one VF and an unmasked variant at a different
 ;; VF, ensure we create appropriate recipes (including a synthesized all-true
 ;; mask for the masked variant)
 
 ; CHECK-LABEL: LV: Checking a loop in 'test_v2_v4m'
 ; CHECK: VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%load> = load ir<%gep>
-; CHECK-NEXT:     WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed2_nomask)
-; CHECK-NEXT:     CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN store ir<%arrayidx>, ir<%call>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXST:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%b>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%load> = load ir<%gep>
+; CHECK-NEXT:       WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed2_nomask)
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<%2>
+; CHECK-NEXT:       WIDEN store ir<%arrayidx>, ir<%call>
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
-
-; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: VPlan 'Initial VPlan for VF={4},UF>=1' {
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%load> = load ir<%gep>
-; CHECK-NEXT:     WIDEN-CALL ir<%call> = call @foo(ir<%load>, ir<true>) (using library function: foo_vector_fixed4_mask)
-; CHECK-NEXT:     CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN store ir<%arrayidx>, ir<%call>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%b>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%load> = load ir<%gep>
+; CHECK-NEXT:       WIDEN-CALL ir<%call> = call @foo(ir<%load>, ir<true>) (using library function: foo_vector_fixed4_mask)
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<%2>
+; CHECK-NEXT:       WIDEN store ir<%arrayidx>, ir<%call>
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 
 ;; If we have two variants at different VFs, neither of which are masked, we
 ;; still expect to see a different vplan per VF.
 
 ; CHECK-LABEL: LV: Checking a loop in 'test_v2_v4'
 ; CHECK: VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%load> = load ir<%gep>
-; CHECK-NEXT:     WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed2_nomask)
-; CHECK-NEXT:     CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN store ir<%arrayidx>, ir<%call>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%b>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%load> = load ir<%gep>
+; CHECK-NEXT:       WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed2_nomask)
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<%2>
+; CHECK-NEXT:       WIDEN store ir<%arrayidx>, ir<%call>
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
-
-; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: VPlan 'Initial VPlan for VF={4},UF>=1' {
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep> = getelementptr ir<%b>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%load> = load ir<%gep>
-; CHECK-NEXT:     WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed4_nomask)
-; CHECK-NEXT:     CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN store ir<%arrayidx>, ir<%call>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%b>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%load> = load ir<%gep>
+; CHECK-NEXT:       WIDEN-CALL ir<%call> = call @foo(ir<%load>) (using library function: foo_vector_fixed4_nomask)
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<%2>
+; CHECK-NEXT:       WIDEN store ir<%arrayidx>, ir<%call>
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 
 define void @test_v4_v4m(ptr noalias %a, ptr readonly %b) #3 {
 ; CHECK-LABEL: @test_v4_v4m(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]]
 ; CHECK:       vector.ph:
 ; CHECK-NEXT:    br label [[VECTOR_BODY:%.*]]
 ; CHECK:       vector.body:

llvm/test/Transforms/LoopVectorize/AArch64/widen-call-with-intrinsic-or-libfunc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -force-vector-interleave=1 -vectorizer-maximize-bandwidth -mtriple=arm64-apple-ios -debug -S %s 2>&1 | FileCheck %s
 
 target triple = "arm64-apple-ios"
 
 ; CHECK-LABEL: LV: Checking a loop in 'test'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep.src> = getelementptr ir<%src>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%l> = load ir<%gep.src>
-; CHECK-NEXT:     WIDEN ir<%conv> = fpext ir<%l>
-; CHECK-NEXT:     WIDEN-CALL ir<%s> = call @llvm.sin.f64(ir<%conv>) (using library function: __simd_sin_v2f64)
-; CHECK-NEXT:     REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<%s>, ir<%gep.dst>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep.src> = getelementptr ir<%src>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%l> = load ir<%gep.src>
+; CHECK-NEXT:       WIDEN ir<%conv> = fpext ir<%l>
+; CHECK-NEXT:       WIDEN-CALL ir<%s> = call @llvm.sin.f64(ir<%conv>) (using library function: __simd_sin_v2f64)
+; CHECK-NEXT:       REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<%2>
+; CHECK-NEXT:       REPLICATE store ir<%s>, ir<%gep.dst>
+; CHECK-NEXT:       EMIT vp<%9> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%9> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 
-; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: VPlan 'Initial VPlan for VF={4},UF>=1' {
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep.src> = getelementptr ir<%src>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%l> = load ir<%gep.src>
-; CHECK-NEXT:     WIDEN ir<%conv> = fpext ir<%l>
-; CHECK-NEXT:     WIDEN-CALL ir<%s> = call @llvm.sin.f64(ir<%conv>) (using vector intrinsic)
-; CHECK-NEXT:     REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<%s>, ir<%gep.dst>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep.src> = getelementptr ir<%src>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%l> = load ir<%gep.src>
+; CHECK-NEXT:       WIDEN ir<%conv> = fpext ir<%l>
+; CHECK-NEXT:       WIDEN-CALL ir<%s> = call @llvm.sin.f64(ir<%conv>) (using vector intrinsic)
+; CHECK-NEXT:       REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<%2>
+; CHECK-NEXT:       REPLICATE store ir<%s>, ir<%gep.dst>
+; CHECK-NEXT:       EMIT vp<%9> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%9> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 ;
 define void @test(ptr noalias %src, ptr noalias %dst) {
 ; CHECK-LABEL: @test(
 ; CHECK:       vector.body:
 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]
 ; CHECK-NEXT:    [[TMP0:%.*]] = add i64 [[INDEX]], 0
 ; CHECK-NEXT:    [[TMP1:%.*]] = add i64 [[INDEX]], 1

llvm/test/Transforms/LoopVectorize/RISCV/riscv-vector-reverse.ll

 ; CHECK-NEXT:  LV: Using user VF vscale x 4.
 ; CHECK-NEXT:  LV: Scalarizing: %i.0 = add nsw i32 %i.0.in8, -1
 ; CHECK-NEXT:  LV: Scalarizing: %idxprom = zext i32 %i.0 to i64
 ; CHECK-NEXT:  LV: Scalarizing: %arrayidx = getelementptr inbounds i32, ptr %B, i64 %idxprom
 ; CHECK-NEXT:  LV: Scalarizing: %arrayidx3 = getelementptr inbounds i32, ptr %A, i64 %idxprom
 ; CHECK-NEXT:  LV: Scalarizing: %cmp = icmp ugt i64 %indvars.iv, 1
 ; CHECK-NEXT:  LV: Scalarizing: %indvars.iv.next = add nsw i64 %indvars.iv, -1
 ; CHECK-NEXT:  VPlan 'Initial VPlan for VF={vscale x 4},UF>=1' {
-; CHECK-NEXT:  Live-in vp<[[VTC:%.+]]> = vector-trip-count
-; CHECK:       vector.ph:
-; CHECK-NEXT:  Successor(s): vector loop
-; CHECK:       <x1> vector loop: {
-; CHECK-NEXT:    vector.body:
-; CHECK-NEXT:    EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:    vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<%n> + vp<[[CAN_IV]]> * ir<-1>
-; CHECK-NEXT:    vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<-1>
-; CHECK-NEXT:    CLONE ir<%i.0> = add vp<[[STEPS]]>, ir<-1>
-; CHECK-NEXT:    CLONE ir<%idxprom> = zext ir<%i.0>
-; CHECK-NEXT:    CLONE ir<%arrayidx> = getelementptr ir<%B>, ir<%idxprom>
-; CHECK-NEXT:    WIDEN ir<%1> = load ir<%arrayidx>
-; CHECK-NEXT:    WIDEN ir<%add9> = add ir<%1>, ir<1>
-; CHECK-NEXT:    CLONE ir<%arrayidx3> = getelementptr ir<%A>, ir<%idxprom>
-; CHECK-NEXT:    WIDEN store ir<%arrayidx3>, ir<%add9>
-; CHECK-NEXT:    EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:    EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:    No successors
-; CHECK-NEXT:  }
-; CHECK-NEXT:  Successor(s): middle.block
-; CHECK:       middle.block:
+; CHECK-NEXT:  Live-in vp<%0> = vector-trip-count
+; CHECK-EMPTY:
+; CHECK-NEXT:  <x1> vector loop: {
+; CHECK-NEXT:    vector.ph:
+; CHECK-NEXT:    Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:    vector countable loop vp<%1> = 0, ir<1> {
+; CHECK-EMPTY:
+; CHECK-NEXT:      vector.body:
+; CHECK-NEXT:        EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:        vp<%2>      = DERIVED-IV ir<%n> + vp<%1> * ir<-1>
+; CHECK-NEXT:        vp<%3>      = SCALAR-STEPS vp<%2>, ir<-1>
+; CHECK-NEXT:        CLONE ir<%i.0> = add vp<%3>, ir<-1>
+; CHECK-NEXT:        CLONE ir<%idxprom> = zext ir<%i.0>
+; CHECK-NEXT:        CLONE ir<%arrayidx> = getelementptr ir<%B>, ir<%idxprom>
+; CHECK-NEXT:        WIDEN ir<%1> = load ir<%arrayidx>
+; CHECK-NEXT:        WIDEN ir<%add9> = add ir<%1>, ir<1>
+; CHECK-NEXT:        CLONE ir<%arrayidx3> = getelementptr ir<%A>, ir<%idxprom>
+; CHECK-NEXT:        WIDEN store ir<%arrayidx3>, ir<%add9>
+; CHECK-NEXT:        EMIT vp<%10> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:        EMIT branch-on-count  vp<%10> vp<%0>
+; CHECK-NEXT:      No successors
+; CHECK-NEXT:    }
+; CHECK-NEXT:    Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:    middle.block:
+; CHECK-NEXT:    No successors
+; CHECK-NEXT:  }
 ; CHECK-NEXT:  No successors
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  LV: Found an estimated cost of 1 for VF vscale x 4 For instruction: %indvars.iv = phi i64 [ %0, %for.body.preheader ], [ %indvars.iv.next, %for.body ]
 ; CHECK-NEXT:  LV: Found an estimated cost of 1 for VF vscale x 4 For instruction: %i.0.in8 = phi i32 [ %n, %for.body.preheader ], [ %i.0, %for.body ]
 ; CHECK-NEXT:  LV: Found an estimated cost of 1 for VF vscale x 4 For instruction: %i.0 = add nsw i32 %i.0.in8, -1
 ; CHECK-NEXT:  LV: Found an estimated cost of 1 for VF vscale x 4 For instruction: %idxprom = zext i32 %i.0 to i64
 ; CHECK-NEXT:  LV: Found an estimated cost of 0 for VF vscale x 4 For instruction: %arrayidx = getelementptr inbounds i32, ptr %B, i64 %idxprom
 ; CHECK-NEXT:  LV: Found an estimated cost of 8 for VF vscale x 4 For instruction: %1 = load i32, ptr %arrayidx, align 4

 ; CHECK-NEXT:  LV: Using user VF vscale x 4.
 ; CHECK-NEXT:  LV: Scalarizing: %i.0 = add nsw i32 %i.0.in8, -1
 ; CHECK-NEXT:  LV: Scalarizing: %idxprom = zext i32 %i.0 to i64
 ; CHECK-NEXT:  LV: Scalarizing: %arrayidx = getelementptr inbounds float, ptr %B, i64 %idxprom
 ; CHECK-NEXT:  LV: Scalarizing: %arrayidx3 = getelementptr inbounds float, ptr %A, i64 %idxprom
 ; CHECK-NEXT:  LV: Scalarizing: %cmp = icmp ugt i64 %indvars.iv, 1
 ; CHECK-NEXT:  LV: Scalarizing: %indvars.iv.next = add nsw i64 %indvars.iv, -1
 ; CHECK-NEXT:  VPlan 'Initial VPlan for VF={vscale x 4},UF>=1' {
-; CHECK-NEXT:  Live-in vp<[[VTC:%.+]]> = vector-trip-count
-; CHECK:       vector.ph:
-; CHECK-NEXT:  Successor(s): vector loop
-; CHECK:       <x1> vector loop: {
-; CHECK-NEXT:    vector.body:
-; CHECK-NEXT:    EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:    vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<%n> + vp<[[CAN_IV]]> * ir<-1>
-; CHECK-NEXT:    vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<-1>
-; CHECK-NEXT:    CLONE ir<%i.0> = add vp<[[STEPS]]>, ir<-1>
-; CHECK-NEXT:    CLONE ir<%idxprom> = zext ir<%i.0>
-; CHECK-NEXT:    CLONE ir<%arrayidx> = getelementptr ir<%B>, ir<%idxprom>
-; CHECK-NEXT:    WIDEN ir<%1> = load ir<%arrayidx>
-; CHECK-NEXT:    WIDEN ir<%conv1> = fadd ir<%1>, ir<1.000000e+00>
-; CHECK-NEXT:    CLONE ir<%arrayidx3> = getelementptr ir<%A>, ir<%idxprom>
-; CHECK-NEXT:    WIDEN store ir<%arrayidx3>, ir<%conv1>
-; CHECK-NEXT:    EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:    EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:    No successors
-; CHECK-NEXT:  }
-; CHECK-NEXT:  Successor(s): middle.block
-; CHECK:       middle.block:
+; CHECK-NEXT:  Live-in vp<%0> = vector-trip-count
+; CHECK-EMPTY:
+; CHECK-NEXT:  <x1> vector loop: {
+; CHECK-NEXT:    vector.ph:
+; CHECK-NEXT:    Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:    vector countable loop vp<%1> = 0, ir<1> {
+; CHECK-EMPTY:
+; CHECK-NEXT:      vector.body:
+; CHECK-NEXT:        EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:        vp<%2>      = DERIVED-IV ir<%n> + vp<%1> * ir<-1>
+; CHECK-NEXT:        vp<%3>      = SCALAR-STEPS vp<%2>, ir<-1>
+; CHECK-NEXT:        CLONE ir<%i.0> = add vp<%3>, ir<-1>
+; CHECK-NEXT:        CLONE ir<%idxprom> = zext ir<%i.0>
+; CHECK-NEXT:        CLONE ir<%arrayidx> = getelementptr ir<%B>, ir<%idxprom>
+; CHECK-NEXT:        WIDEN ir<%1> = load ir<%arrayidx>
+; CHECK-NEXT:        WIDEN ir<%conv1> = fadd ir<%1>, ir<1.000000e+00>
+; CHECK-NEXT:        CLONE ir<%arrayidx3> = getelementptr ir<%A>, ir<%idxprom>
+; CHECK-NEXT:        WIDEN store ir<%arrayidx3>, ir<%conv1>
+; CHECK-NEXT:        EMIT vp<%10> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:        EMIT branch-on-count  vp<%10> vp<%0>
+; CHECK-NEXT:      No successors
+; CHECK-NEXT:    }
+; CHECK-NEXT:    Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:    middle.block:
+; CHECK-NEXT:    No successors
+; CHECK-NEXT:  }
 ; CHECK-NEXT:  No successors
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  LV: Found an estimated cost of 1 for VF vscale x 4 For instruction: %indvars.iv = phi i64 [ %0, %for.body.preheader ], [ %indvars.iv.next, %for.body ]
 ; CHECK-NEXT:  LV: Found an estimated cost of 1 for VF vscale x 4 For instruction: %i.0.in8 = phi i32 [ %n, %for.body.preheader ], [ %i.0, %for.body ]
 ; CHECK-NEXT:  LV: Found an estimated cost of 1 for VF vscale x 4 For instruction: %i.0 = add nsw i32 %i.0.in8, -1
 ; CHECK-NEXT:  LV: Found an estimated cost of 1 for VF vscale x 4 For instruction: %idxprom = zext i32 %i.0 to i64
 ; CHECK-NEXT:  LV: Found an estimated cost of 0 for VF vscale x 4 For instruction: %arrayidx = getelementptr inbounds float, ptr %B, i64 %idxprom
 ; CHECK-NEXT:  LV: Found an estimated cost of 8 for VF vscale x 4 For instruction: %1 = load float, ptr %arrayidx, align 4

llvm/test/Transforms/LoopVectorize/first-order-recurrence-chains-vplan.ll

 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -debug-only=loop-vectorize -disable-output -S %s 2>&1 | FileCheck %s
 
 define void @test_chained_first_order_recurrences_1(ptr %ptr) {
 ; CHECK-LABEL: 'test_chained_first_order_recurrences_1'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1000> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%for.1> = phi ir<22>, ir<%for.1.next>
-; CHECK-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%for.2> = phi ir<33>, vp<[[FOR1_SPLICE:%.+]]>
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep.ptr> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%for.1.next> = load ir<%gep.ptr>
-; CHECK-NEXT:     EMIT vp<[[FOR1_SPLICE]]> = first-order splice ir<%for.1> ir<%for.1.next>
-; CHECK-NEXT:     EMIT vp<[[FOR2_SPLICE:%.+]]> = first-order splice ir<%for.2> vp<[[FOR1_SPLICE]]>
-; CHECK-NEXT:     WIDEN ir<%add> = add vp<[[FOR1_SPLICE]]>, vp<[[FOR2_SPLICE]]>
-; CHECK-NEXT:     WIDEN store ir<%gep.ptr>, ir<%add>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%for.1> = phi ir<22>, ir<%for.1.next>
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%for.2> = phi ir<33>, vp<%7>
+; CHECK-NEXT:       vp<%4>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep.ptr> = getelementptr ir<%ptr>, vp<%4>
+; CHECK-NEXT:       WIDEN ir<%for.1.next> = load ir<%gep.ptr>
+; CHECK-NEXT:       EMIT vp<%7> = first-order splice ir<%for.1> ir<%for.1.next>
+; CHECK-NEXT:       EMIT vp<%8> = first-order splice ir<%for.2> vp<%7>
+; CHECK-NEXT:       WIDEN ir<%add> = add vp<%7>, vp<%8>
+; CHECK-NEXT:       WIDEN store ir<%gep.ptr>, ir<%add>
+; CHECK-NEXT:       EMIT vp<%10> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%10> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %for.1 = phi i16 [ 22, %entry ], [ %for.1.next, %loop ]
   %for.2 = phi i16 [ 33, %entry ], [ %for.1, %loop ]
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
   %iv.next = add nuw nsw i64 %iv, 1
   %gep.ptr = getelementptr inbounds i16, ptr %ptr, i64 %iv
   %for.1.next = load i16, ptr %gep.ptr, align 2
   %add = add i16 %for.1, %for.2
   store i16 %add, ptr %gep.ptr
   %exitcond.not = icmp eq i64 %iv.next, 1000
   br i1 %exitcond.not, label %exit, label %loop
 
 exit:
   ret void
 }
 
 define void @test_chained_first_order_recurrences_3(ptr %ptr) {
 ; CHECK-LABEL: 'test_chained_first_order_recurrences_3'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1000> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%for.1> = phi ir<22>, ir<%for.1.next>
-; CHECK-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%for.2> = phi ir<33>, vp<[[FOR1_SPLICE:%.+]]>
-; CHECK-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%for.3> = phi ir<33>, vp<[[FOR2_SPLICE:%.+]]>
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep.ptr> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%for.1.next> = load ir<%gep.ptr>
-; CHECK-NEXT:     EMIT vp<[[FOR1_SPLICE]]> = first-order splice ir<%for.1> ir<%for.1.next>
-; CHECK-NEXT:     EMIT vp<[[FOR2_SPLICE]]> = first-order splice ir<%for.2> vp<[[FOR1_SPLICE]]>
-; CHECK-NEXT:     EMIT vp<[[FOR3_SPLICE:%.+]]> = first-order splice ir<%for.3> vp<[[FOR2_SPLICE]]>
-; CHECK-NEXT:     WIDEN ir<%add.1> = add vp<[[FOR1_SPLICE]]>, vp<[[FOR2_SPLICE]]>
-; CHECK-NEXT:     WIDEN ir<%add.2> = add ir<%add.1>, vp<[[FOR3_SPLICE]]>
-; CHECK-NEXT:     WIDEN store ir<%gep.ptr>, ir<%add.2>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%for.1> = phi ir<22>, ir<%for.1.next>
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%for.2> = phi ir<33>, vp<%8>
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%for.3> = phi ir<33>, vp<%9>
+; CHECK-NEXT:       vp<%5>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep.ptr> = getelementptr ir<%ptr>, vp<%5>
+; CHECK-NEXT:       WIDEN ir<%for.1.next> = load ir<%gep.ptr>
+; CHECK-NEXT:       EMIT vp<%8> = first-order splice ir<%for.1> ir<%for.1.next>
+; CHECK-NEXT:       EMIT vp<%9> = first-order splice ir<%for.2> vp<%8>
+; CHECK-NEXT:       EMIT vp<%10> = first-order splice ir<%for.3> vp<%9>
+; CHECK-NEXT:       WIDEN ir<%add.1> = add vp<%8>, vp<%9>
+; CHECK-NEXT:       WIDEN ir<%add.2> = add ir<%add.1>, vp<%10>
+; CHECK-NEXT:       WIDEN store ir<%gep.ptr>, ir<%add.2>
+; CHECK-NEXT:       EMIT vp<%13> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%13> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
-
-; CHECK-NOT: vector.body:
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %for.1 = phi i16 [ 22, %entry ], [ %for.1.next, %loop ]
   %for.2 = phi i16 [ 33, %entry ], [ %for.1, %loop ]
   %for.3 = phi i16 [ 33, %entry ], [ %for.2, %loop ]

llvm/test/Transforms/LoopVectorize/first-order-recurrence-sink-replicate-region.ll

 ; REQUIRES: asserts
 ; RUN: opt < %s -passes=loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -force-widen-divrem-via-safe-divisor=0 -disable-output -debug-only=loop-vectorize 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 
 ; Test cases for PR50009, which require sinking a replicate-region due to a
 ; first-order recurrence.
 
 define void @sink_replicate_region_1(i32 %x, ptr %ptr, ptr noalias %dst) optsize {
 ; CHECK-LABEL: sink_replicate_region_1
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, ir<20001> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%0> = phi ir<0>, ir<%conv>
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   vp<[[STEPS:%.]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT: Successor(s): pred.load
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%0> = phi ir<0>, ir<%conv>
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       vp<%5>      = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:       EMIT vp<%6> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:     Successor(s): pred.load
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.load: {
-; CHECK-NEXT:   pred.load.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
+; CHECK-NEXT:     <xVFxUF> pred.load: {
+; CHECK-NEXT:       pred.load.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.load.if, pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.if:
-; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv> = load ir<%gep> (S->V)
-; CHECK-NEXT:   Successor(s): pred.load.continue
+; CHECK-NEXT:       pred.load.if:
+; CHECK-NEXT:         REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<%5>
+; CHECK-NEXT:         REPLICATE ir<%lv> = load ir<%gep> (S->V)
+; CHECK-NEXT:       Successor(s): pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED1:%.+]]> = ir<%lv>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.0
+; CHECK-NEXT:       pred.load.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%9> = ir<%lv>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.0:
-; CHECK-NEXT:   WIDEN ir<%conv> = sext vp<[[PRED1]]>
-; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%0> ir<%conv>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     loop.0:
+; CHECK-NEXT:       WIDEN ir<%conv> = sext vp<%9>
+; CHECK-NEXT:       EMIT vp<%11> = first-order splice ir<%0> ir<%conv>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x>
-; CHECK-NEXT:     REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%add> = add ir<%conv>, ir<%rem>
-; CHECK-NEXT:     REPLICATE store ir<%add>, ir<%gep.dst>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%rem> = srem vp<%11>, ir<%x>
+; CHECK-NEXT:         REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<%5>
+; CHECK-NEXT:         REPLICATE ir<%add> = add ir<%conv>, ir<%rem>
+; CHECK-NEXT:         REPLICATE store ir<%add>, ir<%gep.dst>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%rem>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.2
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%16> = ir<%rem>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.2
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.2:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     loop.2:
+; CHECK-NEXT:       EMIT vp<%17> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%17> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %0 = phi i32 [ 0, %entry ], [ %conv, %loop ]
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
   %rem = srem i32 %0, %x

 
 exit:
   ret void
 }
 
 define void @sink_replicate_region_2(i32 %x, i8 %y, ptr %ptr) optsize {
 ; CHECK-LABEL: sink_replicate_region_2
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, ir<20001> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:   WIDEN ir<%recur.next> = sext ir<%y>
-; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%recur> ir<%recur.next>
-; CHECK-NEXT:   Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%5> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:       WIDEN ir<%recur.next> = sext ir<%y>
+; CHECK-NEXT:       EMIT vp<%7> = first-order splice ir<%recur> ir<%recur.next>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:  pred.store.entry:
-; CHECK-NEXT:    BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:  Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%5>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:  pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x>
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%add> = add ir<%rem>, ir<%recur.next>
-; CHECK-NEXT:     REPLICATE store ir<%add>, ir<%gep>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%rem> = srem vp<%7>, ir<%x>
+; CHECK-NEXT:         vp<%9>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<%9>
+; CHECK-NEXT:         REPLICATE ir<%add> = add ir<%rem>, ir<%recur.next>
+; CHECK-NEXT:         REPLICATE store ir<%add>, ir<%gep>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%rem>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.1
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%13> = ir<%rem>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.1
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.1:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     loop.1:
+; CHECK-NEXT:       EMIT vp<%14> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%14> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %recur = phi i32 [ 0, %entry ], [ %recur.next, %loop ]
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
   %rem = srem i32 %recur, %x
   %recur.next = sext i8 %y to i32
   %add = add i32 %rem, %recur.next
   %gep = getelementptr i32, ptr %ptr, i32 %iv
   store i32 %add, ptr %gep
   %iv.next = add nsw i32 %iv, 1
   %ec = icmp eq i32 %iv.next, 20001
   br i1 %ec, label %exit, label %loop
 
 exit:
   ret void
 }
 
 define i32 @sink_replicate_region_3_reduction(i32 %x, i8 %y, ptr %ptr) optsize {
 ; CHECK-LABEL: sink_replicate_region_3_reduction
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, ir<20001> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
-; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%and.red> = phi ir<1234>, ir<%and.red.next>
-; CHECK-NEXT:   EMIT vp<[[WIDEN_CAN:%.+]]> = WIDEN-CANONICAL-INDUCTION vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule vp<[[WIDEN_CAN]]> vp<[[BTC]]>
-; CHECK-NEXT:   WIDEN ir<%recur.next> = sext ir<%y>
-; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%recur> ir<%recur.next>
-; CHECK-NEXT: Successor(s): pred.srem
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
+; CHECK-NEXT:       WIDEN-REDUCTION-PHI ir<%and.red> = phi ir<1234>, ir<%and.red.next>
+; CHECK-NEXT:       EMIT vp<%5> = WIDEN-CANONICAL-INDUCTION vp<%2>
+; CHECK-NEXT:       EMIT vp<%6> = icmp ule vp<%5> vp<%1>
+; CHECK-NEXT:       WIDEN ir<%recur.next> = sext ir<%y>
+; CHECK-NEXT:       EMIT vp<%8> = first-order splice ir<%recur> ir<%recur.next>
+; CHECK-NEXT:     Successor(s): pred.srem
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.srem: {
-; CHECK-NEXT:   pred.srem.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.srem.if, pred.srem.continue
+; CHECK-NEXT:     <xVFxUF> pred.srem: {
+; CHECK-NEXT:       pred.srem.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.srem.if, pred.srem.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.srem.if:
-; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x> (S->V)
-; CHECK-NEXT:   Successor(s): pred.srem.continue
+; CHECK-NEXT:       pred.srem.if:
+; CHECK-NEXT:         REPLICATE ir<%rem> = srem vp<%8>, ir<%x> (S->V)
+; CHECK-NEXT:       Successor(s): pred.srem.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.srem.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%rem>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.0
+; CHECK-NEXT:       pred.srem.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%10> = ir<%rem>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.0:
-; CHECK-NEXT:   WIDEN ir<%add> = add vp<[[PRED]]>, ir<%recur.next>
-; CHECK-NEXT:   WIDEN ir<%and.red.next> = and ir<%and.red>, ir<%add>
-; CHECK-NEXT:   EMIT vp<[[SEL:%.+]]> = select vp<[[MASK]]> ir<%and.red.next> ir<%and.red>
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     loop.0:
+; CHECK-NEXT:       WIDEN ir<%add> = add vp<%10>, ir<%recur.next>
+; CHECK-NEXT:       WIDEN ir<%and.red.next> = and ir<%and.red>, ir<%add>
+; CHECK-NEXT:       EMIT vp<%13> = select vp<%6> ir<%and.red.next> ir<%and.red>
+; CHECK-NEXT:       EMIT vp<%14> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%14> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: No successors
 ; CHECK-EMPTY:
 ; CHECK-NEXT: Live-out i32 %res = ir<%and.red.next>
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
exit:
   ret i32 %res
 }
 
 ; To sink the replicate region containing %rem, we need to split the block
 ; containing %conv at the end, because %conv is the last recipe in the block.
 define void @sink_replicate_region_4_requires_split_at_end_of_block(i32 %x, ptr %ptr, ptr noalias %dst) optsize {
 ; CHECK-LABEL: sink_replicate_region_4_requires_split_at_end_of_block
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, ir<20001> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%0> = phi ir<0>, ir<%conv>
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:   REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT: Successor(s): pred.load
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%0> = phi ir<0>, ir<%conv>
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       vp<%5>      = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:       EMIT vp<%6> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:       REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<%5>
+; CHECK-NEXT:     Successor(s): pred.load
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.load: {
-; CHECK-NEXT:   pred.load.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
+; CHECK-NEXT:     <xVFxUF> pred.load: {
+; CHECK-NEXT:       pred.load.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.load.if, pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.if:
-; CHECK-NEXT:     REPLICATE ir<%lv> = load ir<%gep> (S->V)
-; CHECK-NEXT:   Successor(s): pred.load.continue
+; CHECK-NEXT:       pred.load.if:
+; CHECK-NEXT:         REPLICATE ir<%lv> = load ir<%gep> (S->V)
+; CHECK-NEXT:       Successor(s): pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%lv>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.0
+; CHECK-NEXT:       pred.load.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%9> = ir<%lv>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.0:
-; CHECK-NEXT:   WIDEN ir<%conv> = sext vp<[[PRED]]>
-; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%0> ir<%conv>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     loop.0:
+; CHECK-NEXT:       WIDEN ir<%conv> = sext vp<%9>
+; CHECK-NEXT:       EMIT vp<%11> = first-order splice ir<%0> ir<%conv>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK:      <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK:        pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x>
-; CHECK-NEXT:     REPLICATE ir<%lv.2> = load ir<%gep>
-; CHECK-NEXT:     REPLICATE ir<%conv.lv.2> = sext ir<%lv.2>
-; CHECK-NEXT:     REPLICATE ir<%add.1> = add ir<%conv>, ir<%rem>
-; CHECK-NEXT:     REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%add> = add ir<%add.1>, ir<%conv.lv.2>
-; CHECK-NEXT:     REPLICATE store ir<%add>, ir<%gep.dst>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%rem> = srem vp<%11>, ir<%x>
+; CHECK-NEXT:         REPLICATE ir<%lv.2> = load ir<%gep>
+; CHECK-NEXT:         REPLICATE ir<%conv.lv.2> = sext ir<%lv.2>
+; CHECK-NEXT:         REPLICATE ir<%add.1> = add ir<%conv>, ir<%rem>
+; CHECK-NEXT:         REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<%5>
+; CHECK-NEXT:         REPLICATE ir<%add> = add ir<%add.1>, ir<%conv.lv.2>
+; CHECK-NEXT:         REPLICATE store ir<%add>, ir<%gep.dst>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK:        pred.store.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED1:%.+]]> = ir<%rem>
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%lv.2>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT:   Successor(s): loop.3
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%19> = ir<%rem>
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%20> = ir<%lv.2>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.3
 ; CHECK-EMPTY:
-; CHECK:      loop.3:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     loop.3:
+; CHECK-NEXT:       EMIT vp<%21> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%21> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %0 = phi i32 [ 0, %entry ], [ %conv, %loop ]
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
   %gep = getelementptr i8, ptr %ptr, i32 %iv

 exit:
   ret void
 }
 
 ; Test case that requires sinking a recipe in a replicate region after another replicate region.
 define void @sink_replicate_region_after_replicate_region(ptr %ptr, ptr noalias %dst.2, i32 %x, i8 %y) optsize {
 ; CHECK-LABEL: sink_replicate_region_after_replicate_region
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, WIDEN ir<%recur.next> = sext ir<%y> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:   WIDEN ir<%recur.next> = sext ir<%y>
-; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%recur> ir<%recur.next>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%recur> = phi ir<0>, ir<%recur.next>
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%5> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:       WIDEN ir<%recur.next> = sext ir<%y>
+; CHECK-NEXT:       EMIT vp<%7> = first-order splice ir<%recur> ir<%recur.next>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%5>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%rem> = srem vp<[[SPLICE]]>, ir<%x>
-; CHECK-NEXT:     REPLICATE ir<%rem.div> = sdiv ir<20>, ir<%rem>
-; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<%rem.div>, ir<%gep>
-; CHECK-NEXT:     REPLICATE ir<%gep.2> = getelementptr ir<%dst.2>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<%rem.div>, ir<%gep.2>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         vp<%8>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%rem> = srem vp<%7>, ir<%x>
+; CHECK-NEXT:         REPLICATE ir<%rem.div> = sdiv ir<20>, ir<%rem>
+; CHECK-NEXT:         REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<%8>
+; CHECK-NEXT:         REPLICATE store ir<%rem.div>, ir<%gep>
+; CHECK-NEXT:         REPLICATE ir<%gep.2> = getelementptr ir<%dst.2>, vp<%8>
+; CHECK-NEXT:         REPLICATE store ir<%rem.div>, ir<%gep.2>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%rem>
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%rem.div>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.3
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%15> = ir<%rem>
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%16> = ir<%rem.div>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.3
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.3:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     loop.3:
+; CHECK-NEXT:       EMIT vp<%17> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%17> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:                                             ; preds = %loop, %entry
   %recur = phi i32 [ 0, %entry ], [ %recur.next, %loop ]
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
   %rem = srem i32 %recur, %x

 
 exit:                                             ; preds = %loop
   ret void
 }
 
 define void @need_new_block_after_sinking_pr56146(i32 %x, ptr %src, ptr noalias %dst) {
 ; CHECK-LABEL: need_new_block_after_sinking_pr56146
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, ir<3> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%.pn> = phi ir<0>, ir<[[L:%.+]]>
-; CHECK-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<2> + vp<[[CAN_IV]]> * ir<1>
-; CHECK-NEXT:     EMIT vp<[[WIDE_IV:%.+]]> = WIDEN-CANONICAL-INDUCTION vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT vp<[[CMP:%.+]]> = icmp ule vp<[[WIDE_IV]]> vp<[[BTC]]>
-; CHECK-NEXT:     CLONE ir<[[L]]> = load ir<%src>
-; CHECK-NEXT:     EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%.pn> ir<[[L]]>
-; CHECK-NEXT:  Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%.pn> = phi ir<0>, ir<%l>
+; CHECK-NEXT:       vp<%4>      = DERIVED-IV ir<2> + vp<%2> * ir<1>
+; CHECK-NEXT:       EMIT vp<%5> = WIDEN-CANONICAL-INDUCTION vp<%2>
+; CHECK-NEXT:       EMIT vp<%6> = icmp ule vp<%5> vp<%1>
+; CHECK-NEXT:       CLONE ir<%l> = load ir<%src>
+; CHECK-NEXT:       EMIT vp<%8> = first-order splice ir<%.pn> ir<%l>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT:   <xVFxUF> pred.store: {
-; CHECK-NEXT:     pred.store.entry:
-; CHECK-NEXT:       BRANCH-ON-MASK vp<[[CMP]]>
-; CHECK-NEXT:     Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:     pred.store.if:
-; CHECK-NEXT:       REPLICATE ir<%val> = sdiv vp<[[SPLICE]]>, ir<%x>
-; CHECK-NEXT:       vp<[[SCALAR_STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<1>
-; CHECK-NEXT:       REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[SCALAR_STEPS]]>
-; CHECK-NEXT:       REPLICATE store ir<%val>, ir<%gep.dst>
-; CHECK-NEXT:     Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%val> = sdiv vp<%8>, ir<%x>
+; CHECK-NEXT:         vp<%10>        = SCALAR-STEPS vp<%4>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<%10>
+; CHECK-NEXT:         REPLICATE store ir<%val>, ir<%gep.dst>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:     pred.store.continue:
-; CHECK-NEXT:       PHI-PREDICATED-INSTRUCTION vp<[[P_VAL:%.+]]> = ir<%val>
-; CHECK-NEXT:     No successors
-; CHECK-NEXT:   }
-; CHECK-NEXT:   Successor(s): loop.1
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%13> = ir<%val>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.1
 ; CHECK-EMPTY:
-; CHECK-NEXT:   loop.1:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     loop.1:
+; CHECK-NEXT:       EMIT vp<%14> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%14> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i64 [ 2, %entry ], [ %iv.next, %loop ]
   %.pn = phi i32 [ 0, %entry ], [ %l, %loop ]
   %val = sdiv i32 %.pn, %x

llvm/test/Transforms/LoopVectorize/icmp-uniforms.ll

 for.end:
   %tmp4 = phi i32 [ %tmp3, %for.body ]
   ret i32 %tmp4
 }
 
 ; Check for crash exposed by D76992.
 ; CHECK-LABEL: 'test'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, ir<14> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[COND:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:   WIDEN ir<%cond0> = icmp ult ir<%iv>, ir<13>
-; CHECK-NEXT:   WIDEN-SELECT ir<%s> = select ir<%cond0>, ir<10>, ir<20>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%4> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:       WIDEN ir<%cond0> = icmp ult ir<%iv>, ir<13>
+; CHECK-NEXT:       WIDEN-SELECT ir<%s> = select ir<%cond0>, ir<10>, ir<20>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT:  <xVFxUF> pred.store: {
-; CHECK-NEXT:    pred.store.entry:
-; CHECK-NEXT:      BRANCH-ON-MASK vp<[[COND]]>
-; CHECK-NEXT:    Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%4>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:    pred.store.if:
-; CHECK-NEXT:      vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:      REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:      REPLICATE store ir<%s>, ir<%gep>
-; CHECK-NEXT:    Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         vp<%7>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<%7>
+; CHECK-NEXT:         REPLICATE store ir<%s>, ir<%gep>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:    pred.store.continue:
-; CHECK-NEXT:    No successors
-; CHECK-NEXT:  }
-; CHECK-NEXT:  Successor(s): loop.0
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.0:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successor
+; CHECK-NEXT:     loop.0:
+; CHECK-NEXT:       EMIT vp<%10> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%10> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 define void @test(ptr %ptr) {
 entry:
   br label %loop
 
 loop:                       ; preds = %loop, %entry
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
   %cond0 = icmp ult i64 %iv, 13

llvm/test/Transforms/LoopVectorize/interleave-and-scalarize-only.ll

 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -debug -disable-output %s 2>&1 | FileCheck --check-prefix=DBG %s
 ; RUN: opt -passes=loop-vectorize -force-vector-width=1 -force-vector-interleave=2 -S %s | FileCheck %s
 
 ; DBG-LABEL: 'test_scalarize_call'
 ; DBG:      VPlan 'Initial VPlan for VF={1},UF>=1' {
-; DBG-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; DBG-NEXT: Live-in vp<%0> = vector-trip-count
 ; DBG-EMPTY:
-; DBG-NEXT: vector.ph:
-; DBG-NEXT: Successor(s): vector loop
+; DBG-NEXT: <x1> vector loop: {
+; DBG-NEXT:   vector.ph:
+; DBG-NEXT:   Successor(s): vector countable loop
+; DBG-EMPTY:
+; DBG-NEXT:   vector countable loop vp<%1> = 0, ir<1000> {
 ; DBG-EMPTY:
-; DBG-NEXT: <x1> vector loop: {
-; DBG-NEXT:   vector.body:
-; DBG-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; DBG-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<%start> + vp<[[CAN_IV]]> * ir<1>
-; DBG-NEXT:     vp<[[IV_STEPS:%.]]>    = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<1>
-; DBG-NEXT:     CLONE ir<%min> = call @llvm.smin.i32(vp<[[IV_STEPS]]>, ir<65535>)
-; DBG-NEXT:     CLONE ir<%arrayidx> = getelementptr ir<%dst>, vp<[[IV_STEPS]]>
-; DBG-NEXT:     CLONE store ir<%min>, ir<%arrayidx>
-; DBG-NEXT:     EMIT vp<[[INC:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; DBG-NEXT:     EMIT branch-on-count  vp<[[INC]]> vp<[[VEC_TC]]>
-; DBG-NEXT:   No successors
+; DBG-NEXT:     vector.body:
+; DBG-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; DBG-NEXT:       vp<%2>      = DERIVED-IV ir<%start> + vp<%1> * ir<1>
+; DBG-NEXT:       vp<%3>      = SCALAR-STEPS vp<%2>, ir<1>
+; DBG-NEXT:       CLONE ir<%min> = call @llvm.smin.i32(vp<%3>, ir<65535>)
+; DBG-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%dst>, vp<%3>
+; DBG-NEXT:       CLONE store ir<%min>, ir<%arrayidx>
+; DBG-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; DBG-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; DBG-NEXT:     No successors
+; DBG-NEXT:   }
+; DBG-NEXT:   Successor(s): middle.block
+; DBG-EMPTY:
+; DBG-NEXT:   middle.block:
+; DBG-NEXT:   No successors
+; DBG-NEXT: }
+; DBG-NEXT: No successors
 ; DBG-NEXT: }
 ;
 define void @test_scalarize_call(i32 %start, ptr %dst) {
 ; CHECK-LABEL: @test_scalarize_call(
 ; CHECK:       vector.body:
 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i32 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]
 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = add i32 %start, [[INDEX]]
 ; CHECK-NEXT:    [[INDUCTION:%.*]] = add i32 [[OFFSET_IDX]], 0

 exit:
   ret void
 }
 
 declare i32 @llvm.smin.i32(i32, i32)
 
 
 ; DBG-LABEL: 'test_scalarize_with_branch_cond'
-
-; DBG:       Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; DBG: VPlan 'Initial VPlan for VF={1},UF>=1' {
+; DBG-NEXT: Live-in vp<%0> = vector-trip-count
 ; DBG-EMPTY:
-; DBG-NEXT: vector.ph:
-; DBG-NEXT: Successor(s): vector loop
+; DBG-NEXT: <x1> vector loop: {
+; DBG-NEXT:   vector.ph:
+; DBG-NEXT:   Successor(s): vector countable loop
+; DBG-EMPTY:
+; DBG-NEXT:   vector countable loop vp<%1> = 0, ir<1000> {
 ; DBG-EMPTY:
-; DBG-NEXT: <x1> vector loop: {
-; DBG-NEXT:   vector.body:
-; DBG-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; DBG-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<false> + vp<[[CAN_IV]]> * ir<true>
-; DBG-NEXT:     vp<[[STEPS1:%.+]]>    = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<true>
-; DBG-NEXT:   Successor(s): pred.store
+; DBG-NEXT:     vector.body:
+; DBG-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; DBG-NEXT:       vp<%2>      = DERIVED-IV ir<false> + vp<%1> * ir<true>
+; DBG-NEXT:       vp<%3>      = SCALAR-STEPS vp<%2>, ir<true>
+; DBG-NEXT:     Successor(s): pred.store
 ; DBG-EMPTY:
-; DBG-NEXT:   <xVFxUF> pred.store: {
-; DBG-NEXT:     pred.store.entry:
-; DBG-NEXT:       BRANCH-ON-MASK vp<[[STEPS1]]>
-; DBG-NEXT:     Successor(s): pred.store.if, pred.store.continue
+; DBG-NEXT:     <xVFxUF> pred.store: {
+; DBG-NEXT:       pred.store.entry:
+; DBG-NEXT:         BRANCH-ON-MASK vp<%3>
+; DBG-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; DBG-EMPTY:
-; DBG-NEXT:     pred.store.if:
-; DBG-NEXT:       vp<[[STEPS2:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; DBG-NEXT:       CLONE ir<%gep.src> = getelementptr ir<%src>, vp<[[STEPS2]]>
-; DBG-NEXT:       CLONE ir<%l> = load ir<%gep.src>
-; DBG-NEXT:       CLONE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[STEPS2]]>
-; DBG-NEXT:       CLONE store ir<%l>, ir<%gep.dst>
-; DBG-NEXT:     Successor(s): pred.store.continue
+; DBG-NEXT:       pred.store.if:
+; DBG-NEXT:         vp<%4>        = SCALAR-STEPS vp<%1>, ir<1>
+; DBG-NEXT:         CLONE ir<%gep.src> = getelementptr ir<%src>, vp<%4>
+; DBG-NEXT:         CLONE ir<%l> = load ir<%gep.src>
+; DBG-NEXT:         CLONE ir<%gep.dst> = getelementptr ir<%dst>, vp<%4>
+; DBG-NEXT:         CLONE store ir<%l>, ir<%gep.dst>
+; DBG-NEXT:       Successor(s): pred.store.continue
 ; DBG-EMPTY:
-; DBG-NEXT:     pred.store.continue:
-; DBG-NEXT:       PHI-PREDICATED-INSTRUCTION vp<{{.+}}> = ir<%l>
-; DBG-NEXT:     No successors
-; DBG-NEXT:   }
-; DBG-NEXT:   Successor(s): cond.false.1
+; DBG-NEXT:       pred.store.continue:
+; DBG-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%9> = ir<%l>
+; DBG-NEXT:       No successors
+; DBG-NEXT:     }
+; DBG-NEXT:     Successor(s): cond.false.1
 ; DBG-EMPTY:
-; DBG-NEXT:   cond.false.1:
-; DBG-NEXT:     EMIT vp<[[CAN_IV_INC:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; DBG-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_INC]]> vp<[[VEC_TC]]>
-; DBG-NEXT:   No successors
-; DBG-NEXT: }
-; DBG-NEXT: Successor(s): middle.block
+; DBG-NEXT:     cond.false.1:
+; DBG-NEXT:       EMIT vp<%10> = VF * UF +(nuw)  vp<%1>
+; DBG-NEXT:       EMIT branch-on-count  vp<%10> vp<%0>
+; DBG-NEXT:     No successors
+; DBG-NEXT:   }
+; DBG-NEXT:   Successor(s): middle.block
 ; DBG-EMPTY:
-; DBG-NEXT: middle.block:
-; DBG-NEXT: No successors
+; DBG-NEXT:   middle.block:
+; DBG-NEXT:   No successors
 ; DBG-NEXT: }
+; DBG-NEXT: No successors
+; DBG-NEXT: }
+
 
 define void @test_scalarize_with_branch_cond(ptr %src, ptr %dst) {
 ; CHECK-LABEL: @test_scalarize_with_branch_cond(
 ; CHECK:       vector.body:
 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %pred.store.continue5 ]
 ; CHECK-NEXT:    [[TMP0:%.*]] = trunc i64 [[INDEX]] to i1
 ; CHECK-NEXT:    [[OFFSET_IDX:%.*]] = sub i1 false, [[TMP0]]
 ; CHECK-NEXT:    [[INDUCTION:%.*]] = add i1 [[OFFSET_IDX]], false
exit:
   ret void
 }
 
 ; Make sure the widened induction gets replaced by scalar-steps for plans
 ; including the scalar VF, if it is used in first-order recurrences.
 
 ; DBG-LABEL: 'first_order_recurrence_using_induction'
 ; DBG:      VPlan 'Initial VPlan for VF={1},UF>=1' {
-; DBG-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; DBG-NEXT: Live-in vp<%0> = vector-trip-count
 ; DBG-EMPTY:
-; DBG-NEXT: vector.ph:
-; DBG-NEXT: Successor(s): vector loop
+; DBG-NEXT: <x1> vector loop: {
+; DBG-NEXT:   vector.ph:
+; DBG-NEXT:   Successor(s): vector countable loop
+; DBG-EMPTY:
+; DBG-NEXT:   vector countable loop vp<%1> = 0, inf {
 ; DBG-EMPTY:
-; DBG-NEXT: <x1> vector loop: {
-; DBG-NEXT:   vector.body:
-; DBG-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; DBG-NEXT:     FIRST-ORDER-RECURRENCE-PHI ir<%for> = phi ir<0>, vp<[[SCALAR_STEPS:.+]]>
-; DBG-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<0> + vp<[[CAN_IV]]> * ir<1> (truncated to i32)
-; DBG-NEXT:     vp<[[SCALAR_STEPS]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<1>
-; DBG-NEXT:     EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%for> vp<[[SCALAR_STEPS]]>
-; DBG-NEXT:     CLONE store vp<[[SPLICE]]>, ir<%dst>
-; DBG-NEXT:     EMIT vp<[[IV_INC:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; DBG-NEXT:     EMIT branch-on-count  vp<[[IV_INC]]> vp<[[VTC]]>
-; DBG-NEXT:   No successors
-; DBG-NEXT: }
-; DBG-NEXT: Successor(s): middle.block
+; DBG-NEXT:     vector.body:
+; DBG-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; DBG-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%for> = phi ir<0>, vp<%4>
+; DBG-NEXT:       vp<%3>      = DERIVED-IV ir<0> + vp<%1> * ir<1> (truncated to i32)
+; DBG-NEXT:       vp<%4>      = SCALAR-STEPS vp<%3>, ir<1>
+; DBG-NEXT:       EMIT vp<%5> = first-order splice ir<%for> vp<%4>
+; DBG-NEXT:       CLONE store vp<%5>, ir<%dst>
+; DBG-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; DBG-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; DBG-NEXT:     No successors
+; DBG-NEXT:   }
+; DBG-NEXT:   Successor(s): middle.block
 ; DBG-EMPTY:
-; DBG-NEXT: middle.block:
-; DBG-NEXT: No successors
+; DBG-NEXT:   middle.block:
+; DBG-NEXT:   No successors
 ; DBG-NEXT: }
+; DBG-NEXT: No successors
+; DBG-NEXT: }
 
 define void @first_order_recurrence_using_induction(i32 %n, ptr %dst) {
 ; CHECK-LABEL: @first_order_recurrence_using_induction(
 ; CHECK:       vector.body:
 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]
 ; CHECK-NEXT:    [[VECTOR_RECUR:%.*]] = phi i32 [ 0, %vector.ph ], [ [[INDUCTION1:%.*]], %vector.body ]
 ; CHECK-NEXT:    [[TMP3:%.*]] = trunc i64 [[INDEX]] to i32
 ; CHECK-NEXT:    [[INDUCTION:%.*]] = add i32 [[TMP3]], 0

llvm/test/Transforms/LoopVectorize/vplan-dot-printing.ll

 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -debug-only=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -vplan-print-in-dot-format -disable-output %s 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 ; Verify that -vplan-print-in-dot-format option works.
 
 define void @print_call_and_memory(i64 %n, ptr noalias %y, ptr noalias %x) nounwind uwtable {
-; CHECK:      digraph VPlan {
-; CHECK-NEXT:  graph [labelloc=t, fontsize=30; label="Vectorization Plan\nInitial VPlan for VF=\{4\},UF\>=1"]
-; CHECK-NEXT:  node [shape=rect, fontname=Courier, fontsize=30]
-; CHECK-NEXT:  edge [fontname=Courier, fontsize=30]
-; CHECK-NEXT:  compound=true
-; CHECK-NEXT:  N0 [label =
-; CHECK-NEXT:    "vector.ph:\l" +
-; CHECK-NEXT:    "Successor(s): vector loop\l"
-; CHECK-NEXT:  ]
-; CHECK-NEXT:  N0 -> N1 [ label="" lhead=cluster_N2]
-; CHECK-NEXT:  subgraph cluster_N2 {
-; CHECK-NEXT:    fontname=Courier
-; CHECK-NEXT:    label="\<x1\> vector loop"
-; CHECK-NEXT:    N1 [label =
-; CHECK-NEXT:    "vector.body:\l" +
-; CHECK-NEXT:    "  EMIT vp\<[[CAN_IV:%.+]]\> = CANONICAL-INDUCTION\l" +
-; CHECK-NEXT:    "  vp\<[[STEPS:%.+]]\> = SCALAR-STEPS vp\<[[CAN_IV]]\>, ir\<1\>\l" +
-; CHECK-NEXT:    "  CLONE ir\<%arrayidx\> = getelementptr ir\<%y\>, vp\<[[STEPS]]\>\l" +
-; CHECK-NEXT:    "  WIDEN ir\<%lv\> = load ir\<%arrayidx\>\l" +
-; CHECK-NEXT:    "  WIDEN-CALL ir\<%call\> = call @llvm.sqrt.f32(ir\<%lv\>) (using vector intrinsic)\l" +
-; CHECK-NEXT:    "  CLONE ir\<%arrayidx2\> = getelementptr ir\<%x\>, vp\<[[STEPS]]\>\l" +
-; CHECK-NEXT:    "  WIDEN store ir\<%arrayidx2\>, ir\<%call\>\l" +
-; CHECK-NEXT:    "  EMIT vp\<[[CAN_IV_NEXT:%.+]]\> = VF * UF +(nuw) vp\<[[CAN_IV]]\>\l" +
-; CHECK-NEXT:    "  EMIT branch-on-count vp\<[[CAN_IV_NEXT]]\> vp\<{{.+}}\>\l" +
-; CHECK-NEXT:    "No successors\l"
-; CHECK-NEXT:  ]
-;
+; CHECK: digraph VPlan {
+; CHECK-NEXT: graph [labelloc=t, fontsize=30; label="Vectorization Plan\nInitial VPlan for VF=\{4\},UF\>=1"]
+; CHECK-NEXT: node [shape=rect, fontname=Courier, fontsize=30]
+; CHECK-NEXT: edge [fontname=Courier, fontsize=30]
+; CHECK-NEXT: compound=true
+; CHECK-NEXT:   subgraph cluster_N0 {
+; CHECK-NEXT:     fontname=Courier
+; CHECK-NEXT:     label="\<x1\> vector loop"
+; CHECK-NEXT:     N1 [label =
+; CHECK-NEXT:       "vector.ph:\l" +
+; CHECK-NEXT:       "Successor(s): vector countable loop\l"
+; CHECK-NEXT:     ]
+; CHECK-NEXT:     N1 -> N2 [ label="" lhead=cluster_N3]
+; CHECK-NEXT:     subgraph cluster_N3 {
+; CHECK-NEXT:       fontname=Courier
+; CHECK-NEXT:       label="\<x1\> vector countable loop"
+; CHECK-NEXT:       N2 [label =
+; CHECK-NEXT:         "vector.body:\l" +
+; CHECK-NEXT:         "  EMIT vp\<%1\> = CANONICAL-INDUCTION\l" +
+; CHECK-NEXT:         "  vp\<%2\>  = SCALAR-STEPS vp\<%1\>, ir\<1\>\l" +
+; CHECK-NEXT:         "  CLONE ir\<%arrayidx\> = getelementptr ir\<%y\>, vp\<%2\>\l" +
+; CHECK-NEXT:         "  WIDEN ir\<%lv\> = load ir\<%arrayidx\>\l" +
+; CHECK-NEXT:         "  WIDEN-CALL ir\<%call\> = call @llvm.sqrt.f32(ir\<%lv\>) (using vector intrinsic)\l" +
+; CHECK-NEXT:         "  CLONE ir\<%arrayidx2\> = getelementptr ir\<%x\>, vp\<%2\>\l" +
+; CHECK-NEXT:         "  WIDEN store ir\<%arrayidx2\>, ir\<%call\>\l" +
+; CHECK-NEXT:         "  EMIT vp\<%7\> = VF * UF +(nuw)  vp\<%1\>\l" +
+; CHECK-NEXT:         "  EMIT branch-on-count  vp\<%7\> vp\<%0\>\l" +
+; CHECK-NEXT:         "No successors\l"
+; CHECK-NEXT:       ]
+; CHECK-NEXT:     }
+; CHECK-NEXT:     N2 -> N4 [ label="" ltail=cluster_N3]
+; CHECK-NEXT:     N4 [label =
+; CHECK-NEXT:       "middle.block:\l" +
+; CHECK-NEXT:       "No successors\l"
+; CHECK-NEXT:     ]
+; CHECK-NEXT:   }
+; CHECK-NEXT: }
 entry:
   %cmp6 = icmp sgt i64 %n, 0
   br i1 %cmp6, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.body
   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv
   %lv = load float, ptr %arrayidx, align 4

llvm/test/Transforms/LoopVectorize/vplan-iv-transforms.ll

 ; REQUIRES: asserts
 ; RUN: opt -passes=loop-vectorize -force-vector-interleave=1 -force-vector-width=8 -S -debug %s 2>&1 | FileCheck %s
 
 define void @iv_no_binary_op_in_descriptor(i1 %c, ptr %dst) {
 ; CHECK-LABEL: LV: Checking a loop in 'iv_no_binary_op_in_descriptor'
 ; CHECK:      VPlan 'Initial VPlan for VF={8},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     WIDEN-INDUCTION %iv = phi 0, %iv.next.p, ir<1>
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep> = getelementptr ir<%dst>, vp<[[STEPS:%.+]]>
-; CHECK-NEXT:     WIDEN store ir<%gep>, ir<%iv>
-; CHECK-NEXT:     EMIT vp<[[CAN_INC:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_INC]]> vp<[[VEC_TC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next.p, ir<1>
+; CHECK-NEXT:       vp<%3>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%dst>, vp<%3>
+; CHECK-NEXT:       WIDEN store ir<%gep>, ir<%iv>
+; CHECK-NEXT:       EMIT vp<%5> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%5> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop.header
 
 loop.header:
   %iv = phi i64 [ 0, %entry ], [ %iv.next.p, %loop.latch ]
   %gep = getelementptr inbounds i64, ptr %dst, i64 %iv
   store i64 %iv, ptr %gep, align 8

llvm/test/Transforms/LoopVectorize/vplan-printing-outer-loop.ll

 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -enable-vplan-native-path -debug -disable-output %s 2>&1 | FileCheck %s
 
 @arr2 = external global [8 x i64], align 16
 @arr = external global [8 x [8 x i64]], align 16
 
 define void @foo(i64 %n) {
 ; CHECK:      VPlan 'HCFGBuilder: Plain CFG
-; CHECK-NEXT: {
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): outer.header
+; CHECK-NEXT:  for UF>=1' {
+; CHECK-NEXT: <x1> : {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): outer.header
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> outer.header: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     WIDEN-PHI ir<%outer.iv> = phi ir<0>, ir<%outer.iv.next>
-; CHECK-NEXT:     EMIT ir<%gep.1> = getelementptr ir<@arr2> ir<0> ir<%outer.iv>
-; CHECK-NEXT:     EMIT store ir<%outer.iv> ir<%gep.1>
-; CHECK-NEXT:     EMIT ir<%add> = add ir<%outer.iv> ir<%n>
-; CHECK-NEXT:   Successor(s): inner
+; CHECK-NEXT:   outer.header {
+; CHECK-EMPTY:
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       WIDEN-PHI ir<%outer.iv> = phi ir<0>, ir<%outer.iv.next>
+; CHECK-NEXT:       EMIT ir<%gep.1> = getelementptr ir<@arr2> ir<0> ir<%outer.iv>
+; CHECK-NEXT:       EMIT store ir<%outer.iv> ir<%gep.1>
+; CHECK-NEXT:       EMIT ir<%add> = add ir<%outer.iv> ir<%n>
+; CHECK-NEXT:     Successor(s): inner
 ; CHECK-EMPTY:
-; CHECK-NEXT:   <x1> inner: {
-; CHECK-NEXT:     inner:
-; CHECK-NEXT:       WIDEN-PHI ir<%inner.iv> = phi ir<0>, ir<%inner.iv.next>
-; CHECK-NEXT:       EMIT ir<%gep.2> = getelementptr ir<@arr> ir<0> ir<%inner.iv> ir<%outer.iv>
-; CHECK-NEXT:       EMIT store ir<%add> ir<%gep.2>
-; CHECK-NEXT:       EMIT ir<%inner.iv.next> = add ir<%inner.iv> ir<1>
-; CHECK-NEXT:       EMIT ir<%inner.ec> = icmp ir<%inner.iv.next> ir<8>
-; CHECK-NEXT:       EMIT branch-on-cond ir<%inner.ec>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT:  }
-; CHECK-NEXT:  Successor(s): outer.latch
+; CHECK-NEXT:     inner {
+; CHECK-EMPTY:
+; CHECK-NEXT:       inner:
+; CHECK-NEXT:         WIDEN-PHI ir<%inner.iv> = phi ir<0>, ir<%inner.iv.next>
+; CHECK-NEXT:         EMIT ir<%gep.2> = getelementptr ir<@arr> ir<0> ir<%inner.iv> ir<%outer.iv>
+; CHECK-NEXT:         EMIT store ir<%add> ir<%gep.2>
+; CHECK-NEXT:         EMIT ir<%inner.iv.next> = add ir<%inner.iv> ir<1>
+; CHECK-NEXT:         EMIT ir<%inner.ec> = icmp ir<%inner.iv.next> ir<8>
+; CHECK-NEXT:         EMIT branch-on-cond ir<%inner.ec>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): outer.latch
 ; CHECK-EMPTY:
-; CHECK-NEXT:   outer.latch:
-; CHECK-NEXT:     EMIT ir<%outer.iv.next> = add ir<%outer.iv> ir<1>
-; CHECK-NEXT:     EMIT ir<%outer.ec> = icmp ir<%outer.iv.next> ir<8>
-; CHECK-NEXT:     EMIT branch-on-cond ir<%outer.ec>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT:  }
-; CHECK-NEXT: Successor(s): exit
+; CHECK-NEXT:     outer.latch:
+; CHECK-NEXT:       EMIT ir<%outer.iv.next> = add ir<%outer.iv> ir<1>
+; CHECK-NEXT:       EMIT ir<%outer.ec> = icmp ir<%outer.iv.next> ir<8>
+; CHECK-NEXT:       EMIT branch-on-cond ir<%outer.ec>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): exit
 ; CHECK-EMPTY:
-; CHECK-NEXT: exit:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   exit:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 entry:
   br label %outer.header
 
 outer.header:
   %outer.iv = phi i64 [ 0, %entry ], [ %outer.iv.next, %outer.latch ]
   %gep.1 = getelementptr inbounds [8 x i64], ptr @arr2, i64 0, i64 %outer.iv
   store i64 %outer.iv, ptr %gep.1, align 4
   %add = add nsw i64 %outer.iv, %n

llvm/test/Transforms/LoopVectorize/vplan-printing.ll

 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -debug-only=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -prefer-inloop-reductions -enable-interleaved-mem-accesses=true -enable-masked-interleaved-mem-accesses -force-widen-divrem-via-safe-divisor=0 -disable-output %s 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 ; Tests for printing VPlans.
 
 define void @print_call_and_memory(i64 %n, ptr noalias %y, ptr noalias %x) nounwind uwtable {
 ; CHECK-LABEL: Checking a loop in 'print_call_and_memory'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<%n> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr ir<%y>, vp<[[STEPS]]>
-; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
-; CHECK-NEXT:   WIDEN-CALL ir<%call> = call @llvm.sqrt.f32(ir<%lv>)
-; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr ir<%x>, vp<[[STEPS]]>
-; CHECK-NEXT:   WIDEN store ir<%arrayidx2>, ir<%call>
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%y>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%lv> = load ir<%arrayidx>
+; CHECK-NEXT:       WIDEN-CALL ir<%call> = call @llvm.sqrt.f32(ir<%lv>) (using vector intrinsic)
+; CHECK-NEXT:       CLONE ir<%arrayidx2> = getelementptr ir<%x>, vp<%2>
+; CHECK-NEXT:       WIDEN store ir<%arrayidx2>, ir<%call>
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   %cmp6 = icmp sgt i64 %n, 0
   br i1 %cmp6, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.body
   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv
   %lv = load float, ptr %arrayidx, align 4
   %call = tail call float @llvm.sqrt.f32(float %lv) nounwind readnone
   %arrayidx2 = getelementptr inbounds float, ptr %x, i64 %iv
   store float %call, ptr %arrayidx2, align 4
   %iv.next = add i64 %iv, 1
   %exitcond = icmp eq i64 %iv.next, %n
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body, %entry
   ret void
 }
 
 define void @print_widen_gep_and_select(i64 %n, ptr noalias %y, ptr noalias %x, ptr %z) nounwind uwtable {
 ; CHECK-LABEL: Checking a loop in 'print_widen_gep_and_select'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<%n> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi %iv.next, 0, ir<1>
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   WIDEN-GEP Inv[Var] ir<%arrayidx> = getelementptr ir<%y>, ir<%iv>
-; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
-; CHECK-NEXT:   WIDEN ir<%cmp> = icmp eq ir<%arrayidx>, ir<%z>
-; CHECK-NEXT:   WIDEN-SELECT ir<%sel> = select ir<%cmp>, ir<1.000000e+01>, ir<2.000000e+01>
-; CHECK-NEXT:   WIDEN ir<%add> = fadd ir<%lv>, ir<%sel>
-; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr ir<%x>, vp<[[STEPS]]>
-; CHECK-NEXT:   WIDEN store ir<%arrayidx2>, ir<%add>
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi %iv.next, 0, ir<1>
+; CHECK-NEXT:       vp<%3>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       WIDEN-GEP Inv[Var] ir<%arrayidx> = getelementptr ir<%y>, ir<%iv>
+; CHECK-NEXT:       WIDEN ir<%lv> = load ir<%arrayidx>
+; CHECK-NEXT:       WIDEN ir<%cmp> = icmp eq ir<%arrayidx>, ir<%z>
+; CHECK-NEXT:       WIDEN-SELECT ir<%sel> = select ir<%cmp>, ir<1.000000e+01>, ir<2.000000e+01>
+; CHECK-NEXT:       WIDEN ir<%add> = fadd ir<%lv>, ir<%sel>
+; CHECK-NEXT:       CLONE ir<%arrayidx2> = getelementptr ir<%x>, vp<%3>
+; CHECK-NEXT:       WIDEN store ir<%arrayidx2>, ir<%add>
+; CHECK-NEXT:       EMIT vp<%10> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%10> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   %cmp6 = icmp sgt i64 %n, 0
   br i1 %cmp6, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.body
   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv

 
 for.end:                                          ; preds = %for.body, %entry
   ret void
 }
 
 define float @print_reduction(i64 %n, ptr noalias %y) {
 ; CHECK-LABEL: Checking a loop in 'print_reduction'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<%n> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%red> = phi ir<0.000000e+00>, ir<%red.next>
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr ir<%y>, vp<[[STEPS]]>
-; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
-; CHECK-NEXT:   REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>)
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-REDUCTION-PHI ir<%red> = phi ir<0.000000e+00>, ir<%red.next>
+; CHECK-NEXT:       vp<%3>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%y>, vp<%3>
+; CHECK-NEXT:       WIDEN ir<%lv> = load ir<%arrayidx>
+; CHECK-NEXT:       REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>)
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: No successors
 ; CHECK-EMPTY:
 ; CHECK-NEXT: Live-out float %red.next.lcssa = ir<%red.next>
 ; CHECK-NEXT: }
 ;
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.body
   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
   %red = phi float [ %red.next, %for.body ], [ 0.0, %entry ]
   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv
   %lv = load float, ptr %arrayidx, align 4
   %red.next = fadd fast float %lv, %red
   %iv.next = add i64 %iv, 1
   %exitcond = icmp eq i64 %iv.next, %n
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body, %entry
   ret float %red.next
 }
 
 define void @print_reduction_with_invariant_store(i64 %n, ptr noalias %y, ptr noalias %dst) {
 ; CHECK-LABEL: Checking a loop in 'print_reduction_with_invariant_store'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<%n> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%red> = phi ir<0.000000e+00>, ir<%red.next>
-; CHECK-NEXT:   vp<[[IV:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr ir<%y>, vp<[[IV]]>
-; CHECK-NEXT:   WIDEN ir<%lv> = load ir<%arrayidx>
-; CHECK-NEXT:   REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>) (with final reduction value stored in invariant address sank outside of loop)
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-REDUCTION-PHI ir<%red> = phi ir<0.000000e+00>, ir<%red.next>
+; CHECK-NEXT:       vp<%3>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%y>, vp<%3>
+; CHECK-NEXT:       WIDEN ir<%lv> = load ir<%arrayidx>
+; CHECK-NEXT:       REDUCE ir<%red.next> = ir<%red> + fast reduce.fadd (ir<%lv>) (with final reduction value stored in invariant address sank outside of loop)
+; CHECK-NEXT:       EMIT vp<%7> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%7> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %entry, %for.body
   %iv = phi i64 [ %iv.next, %for.body ], [ 0, %entry ]
   %red = phi float [ %red.next, %for.body ], [ 0.0, %entry ]
   %arrayidx = getelementptr inbounds float, ptr %y, i64 %iv
   %lv = load float, ptr %arrayidx, align 4
   %red.next = fadd fast float %lv, %red
   store float %red.next, ptr %dst, align 4
   %iv.next = add i64 %iv, 1
   %exitcond = icmp eq i64 %iv.next, %n
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body, %entry
   ret void
 }
 
 define void @print_replicate_predicated_phi(i64 %n, ptr %x) {
 ; CHECK-LABEL: Checking a loop in 'print_replicate_predicated_phi'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<%n> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %i = phi 0, %i.next, ir<1>
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   WIDEN ir<%cmp> = icmp ult ir<%i>, ir<5>
-; CHECK-NEXT: Successor(s): pred.udiv
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %i = phi 0, %i.next, ir<1>
+; CHECK-NEXT:       vp<%3>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       WIDEN ir<%cmp> = icmp ult ir<%i>, ir<5>
+; CHECK-NEXT:     Successor(s): pred.udiv
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.udiv: {
-; CHECK-NEXT:   pred.udiv.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK ir<%cmp>
-; CHECK-NEXT:   Successor(s): pred.udiv.if, pred.udiv.continue
+; CHECK-NEXT:     <xVFxUF> pred.udiv: {
+; CHECK-NEXT:       pred.udiv.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK ir<%cmp>
+; CHECK-NEXT:       Successor(s): pred.udiv.if, pred.udiv.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.udiv.if:
-; CHECK-NEXT:     REPLICATE ir<%tmp4> = udiv ir<%n>, vp<[[STEPS]]> (S->V)
-; CHECK-NEXT:   Successor(s): pred.udiv.continue
+; CHECK-NEXT:       pred.udiv.if:
+; CHECK-NEXT:         REPLICATE ir<%tmp4> = udiv ir<%n>, vp<%3> (S->V)
+; CHECK-NEXT:       Successor(s): pred.udiv.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.udiv.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%tmp4>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): if.then.0
+; CHECK-NEXT:       pred.udiv.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%6> = ir<%tmp4>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): if.then.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: if.then.0:
-; CHECK-NEXT:   EMIT vp<[[NOT:%.+]]> = not ir<%cmp>
-; CHECK-NEXT:   BLEND %d = ir<0>/vp<[[NOT]]> vp<[[PRED]]>/ir<%cmp>
-; CHECK-NEXT:   CLONE ir<%idx> = getelementptr ir<%x>, vp<[[STEPS]]>
-; CHECK-NEXT:   WIDEN store ir<%idx>, ir<%d>
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     if.then.0:
+; CHECK-NEXT:       EMIT vp<%7> = not ir<%cmp>
+; CHECK-NEXT:       BLEND %d = ir<0>/vp<%7> vp<%6>/ir<%cmp>
+; CHECK-NEXT:       CLONE ir<%idx> = getelementptr ir<%x>, vp<%3>
+; CHECK-NEXT:       WIDEN store ir<%idx>, ir<%d>
+; CHECK-NEXT:       EMIT vp<%10> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%10> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.inc, %entry
   %i = phi i64 [ 0, %entry ], [ %i.next, %for.inc ]
   %cmp = icmp ult i64 %i, 5
   br i1 %cmp, label %if.then, label %for.inc

 }
 
 @AB = common global [1024 x i32] zeroinitializer, align 4
 @CD = common global [1024 x i32] zeroinitializer, align 4
 
 define void @print_interleave_groups(i32 %C, i32 %D) {
 ; CHECK-LABEL: Checking a loop in 'print_interleave_groups'
 ; CHECK:       VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1024> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:  vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<0> + vp<[[CAN_IV]]> * ir<4>
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<4>
-; CHECK-NEXT:   CLONE ir<%gep.AB.0> = getelementptr ir<@AB>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:   INTERLEAVE-GROUP with factor 4 at %AB.0, ir<%gep.AB.0>
-; CHECK-NEXT:     ir<%AB.0> = load from index 0
-; CHECK-NEXT:     ir<%AB.1> = load from index 1
-; CHECK-NEXT:     ir<%AB.3> = load from index 3
-; CHECK-NEXT:   CLONE ir<%iv.plus.3> = add vp<[[STEPS]]>, ir<3>
-; CHECK-NEXT:   WIDEN ir<%add> = add ir<%AB.0>, ir<%AB.1>
-; CHECK-NEXT:   CLONE ir<%gep.CD.3> = getelementptr ir<@CD>, ir<0>, ir<%iv.plus.3>
-; CHECK-NEXT:   INTERLEAVE-GROUP with factor 4 at <badref>, ir<%gep.CD.3>
-; CHECK-NEXT:     store ir<%add> to index 0
-; CHECK-NEXT:     store ir<1> to index 1
-; CHECK-NEXT:     store ir<2> to index 2
-; CHECK-NEXT:     store ir<%AB.3> to index 3
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = DERIVED-IV ir<0> + vp<%1> * ir<4>
+; CHECK-NEXT:       vp<%3>      = SCALAR-STEPS vp<%2>, ir<4>
+; CHECK-NEXT:       CLONE ir<%gep.AB.0> = getelementptr ir<@AB>, ir<0>, vp<%3>
+; CHECK-NEXT:       INTERLEAVE-GROUP with factor 4 at %AB.0, ir<%gep.AB.0>
+; CHECK-NEXT:         ir<%AB.0> = load from index 0
+; CHECK-NEXT:         ir<%AB.1> = load from index 1
+; CHECK-NEXT:         ir<%AB.3> = load from index 3
+; CHECK-NEXT:       CLONE ir<%iv.plus.3> = add vp<%3>, ir<3>
+; CHECK-NEXT:       WIDEN ir<%add> = add ir<%AB.0>, ir<%AB.1>
+; CHECK-NEXT:       CLONE ir<%gep.CD.3> = getelementptr ir<@CD>, ir<0>, ir<%iv.plus.3>
+; CHECK-NEXT:       INTERLEAVE-GROUP with factor 4 at <badref>, ir<%gep.CD.3>
+; CHECK-NEXT:         store ir<%add> to index 0
+; CHECK-NEXT:         store ir<1> to index 1
+; CHECK-NEXT:         store ir<2> to index 2
+; CHECK-NEXT:         store ir<%AB.3> to index 3
+; CHECK-NEXT:       EMIT vp<%11> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%11> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %for.body
 
 for.body:
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
   %gep.AB.0= getelementptr inbounds [1024 x i32], ptr @AB, i64 0, i64 %iv
   %AB.0 = load i32, ptr %gep.AB.0, align 4

 
 for.end:
   ret void
 }
 
 define float @print_fmuladd_strict(ptr %a, ptr %b, i64 %n) {
 ; CHECK-LABEL: Checking a loop in 'print_fmuladd_strict'
 ; CHECK:      VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<%n> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-REDUCTION-PHI ir<%sum.07> = phi ir<0.000000e+00>, ir<%muladd>
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<[[STEPS]]>
-; CHECK-NEXT:   WIDEN ir<%l.a> = load ir<%arrayidx>
-; CHECK-NEXT:   CLONE ir<%arrayidx2> = getelementptr ir<%b>, vp<[[STEPS]]>
-; CHECK-NEXT:   WIDEN ir<%l.b> = load ir<%arrayidx2>
-; CHECK-NEXT:   EMIT vp<[[FMUL:%.+]]> = fmul nnan ninf nsz ir<%l.a> ir<%l.b>
-; CHECK-NEXT:   REDUCE ir<[[MULADD:%.+]]> = ir<%sum.07> + nnan ninf nsz reduce.fadd (vp<[[FMUL]]>)
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-REDUCTION-PHI ir<%sum.07> = phi ir<0.000000e+00>, ir<%muladd>
+; CHECK-NEXT:       vp<%3>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%arrayidx> = getelementptr ir<%a>, vp<%3>
+; CHECK-NEXT:       WIDEN ir<%l.a> = load ir<%arrayidx>
+; CHECK-NEXT:       CLONE ir<%arrayidx2> = getelementptr ir<%b>, vp<%3>
+; CHECK-NEXT:       WIDEN ir<%l.b> = load ir<%arrayidx2>
+; CHECK-NEXT:       EMIT vp<%8> = fmul nnan ninf nsz ir<%l.a> ir<%l.b>
+; CHECK-NEXT:       REDUCE ir<%muladd> = ir<%sum.07> + nnan ninf nsz reduce.fadd (vp<%8>)
+; CHECK-NEXT:       EMIT vp<%10> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%10> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: No successors
 ; CHECK-EMPTY:
 ; CHECK-NEXT: Live-out float %muladd.lcssa = ir<%muladd>
-; CHECK-NEXT:}
+; CHECK-NEXT: }
+;
 
 entry:
   br label %for.body
 
 for.body:
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
   %sum.07 = phi float [ 0.000000e+00, %entry ], [ %muladd, %for.body ]
   %arrayidx = getelementptr inbounds float, ptr %a, i64 %iv
   %l.a = load float, ptr %arrayidx, align 4
   %arrayidx2 = getelementptr inbounds float, ptr %b, i64 %iv
   %l.b = load float, ptr %arrayidx2, align 4
   %muladd = tail call nnan ninf nsz float @llvm.fmuladd.f32(float %l.a, float %l.b, float %sum.07)
   %iv.next = add nuw nsw i64 %iv, 1
   %exitcond.not = icmp eq i64 %iv.next, %n
   br i1 %exitcond.not, label %for.end, label %for.body
 
 for.end:
   ret float %muladd
 }
 
 define void @debug_loc_vpinstruction(ptr nocapture %asd, ptr nocapture %bsd) !dbg !5 {
 ; CHECK-LABEL: Checking a loop in 'debug_loc_vpinstruction'
 ; CHECK:    VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<128> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:  vector.body:
-; CHECK-NEXT:    EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:    vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:    CLONE ir<%isd> = getelementptr ir<%asd>, vp<[[STEPS]]>
-; CHECK-NEXT:    WIDEN ir<%lsd> = load ir<%isd>
-; CHECK-NEXT:    WIDEN ir<%psd> = add ir<%lsd>, ir<23>
-; CHECK-NEXT:    WIDEN ir<%cmp1> = icmp slt ir<%lsd>, ir<100>
-; CHECK-NEXT:    WIDEN ir<%cmp2> = icmp sge ir<%lsd>, ir<200>
-; CHECK-NEXT:    EMIT vp<[[NOT1:%.+]]> = not ir<%cmp1>, !dbg /tmp/s.c:5:3
-; CHECK-NEXT:    EMIT vp<[[SEL1:%.+]]> = select vp<[[NOT1]]> ir<%cmp2> ir<false>, !dbg /tmp/s.c:5:21
-; CHECK-NEXT:    EMIT vp<[[OR1:%.+]]> = or vp<[[SEL1]]> ir<%cmp1>
-; CHECK-NEXT:  Successor(s): pred.sdiv
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%isd> = getelementptr ir<%asd>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%lsd> = load ir<%isd>
+; CHECK-NEXT:       WIDEN ir<%psd> = add ir<%lsd>, ir<23>
+; CHECK-NEXT:       WIDEN ir<%cmp1> = icmp slt ir<%lsd>, ir<100>
+; CHECK-NEXT:       WIDEN ir<%cmp2> = icmp sge ir<%lsd>, ir<200>
+; CHECK-NEXT:       EMIT vp<%8> = not ir<%cmp1>, !dbg /tmp/s.c:5:3
+; CHECK-NEXT:       EMIT vp<%9> = select vp<%8> ir<%cmp2> ir<false>, !dbg /tmp/s.c:5:21
+; CHECK-NEXT:       EMIT vp<%10> = or vp<%9> ir<%cmp1>
+; CHECK-NEXT:     Successor(s): pred.sdiv
 ; CHECK-EMPTY:
-; CHECK-NEXT:  <xVFxUF> pred.sdiv: {
-; CHECK-NEXT:    pred.sdiv.entry:
-; CHECK-NEXT:      BRANCH-ON-MASK vp<[[OR1]]>
-; CHECK-NEXT:    Successor(s): pred.sdiv.if, pred.sdiv.continue
+; CHECK-NEXT:     <xVFxUF> pred.sdiv: {
+; CHECK-NEXT:       pred.sdiv.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%10>
+; CHECK-NEXT:       Successor(s): pred.sdiv.if, pred.sdiv.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:    pred.sdiv.if:
-; CHECK-NEXT:      REPLICATE ir<%sd1> = sdiv ir<%psd>, ir<%lsd> (S->V)
-; CHECK-NEXT:    Successor(s): pred.sdiv.continue
+; CHECK-NEXT:       pred.sdiv.if:
+; CHECK-NEXT:         REPLICATE ir<%sd1> = sdiv ir<%psd>, ir<%lsd> (S->V)
+; CHECK-NEXT:       Successor(s): pred.sdiv.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:    pred.sdiv.continue:
-; CHECK-NEXT:      PHI-PREDICATED-INSTRUCTION vp<[[PHI:%.+]]> = ir<%sd1>
-; CHECK-NEXT:    No successors
-; CHECK-NEXT:  }
-; CHECK-NEXT:  Successor(s): if.then.0
+; CHECK-NEXT:       pred.sdiv.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%12> = ir<%sd1>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): if.then.0
 ; CHECK-EMPTY:
-; CHECK-NEXT:  if.then.0:
-; CHECK-NEXT:    EMIT vp<[[NOT2:%.+]]> = not ir<%cmp2>
-; CHECK-NEXT:    EMIT vp<[[SEL2:%.+]]> = select vp<[[NOT1]]> vp<[[NOT2]]> ir<false>
-; CHECK-NEXT:    BLEND %ysd.0 = vp<[[PHI]]>/vp<[[OR1]]> ir<%psd>/vp<[[SEL2]]>
-; CHECK-NEXT:    WIDEN store ir<%isd>, ir<%ysd.0>
-; CHECK-NEXT:    EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:    EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT:  No successors
-; CHECK-NEXT:}
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     if.then.0:
+; CHECK-NEXT:       EMIT vp<%13> = not ir<%cmp2>, !dbg /tmp/s.c:5:21
+; CHECK-NEXT:       EMIT vp<%14> = select vp<%8> vp<%13> ir<false>, !dbg /tmp/s.c:5:21
+; CHECK-NEXT:       BLEND %ysd.0 = vp<%12>/vp<%10> ir<%psd>/vp<%14>
+; CHECK-NEXT:       WIDEN store ir<%isd>, ir<%ysd.0>
+; CHECK-NEXT:       EMIT vp<%16> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%16> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
-; CHECK-NEXT:}
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %if.end ]
   %isd = getelementptr inbounds i32, ptr %asd, i64 %iv
   %lsd = load i32, ptr %isd, align 4

 }
 
 declare float @llvm.sqrt.f32(float) nounwind readnone
 declare float @llvm.fmuladd.f32(float, float, float)
 
 define void @print_expand_scev(i64 %y, ptr %ptr) {
 ; CHECK-LABEL: Checking a loop in 'print_expand_scev'
 ; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VTC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT:   EMIT vp<[[EXP_SCEV:%.+]]> = EXPAND SCEV (1 + (%y /u 492802768830814060))<nuw><nsw>
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:     EMIT vp<%1> = EXPAND SCEV (1 + (%y /u 492802768830814060))<nuw><nsw>
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     WIDEN-INDUCTION\l" +
-; CHECK-NEXT:     "  %iv = phi %iv.next, 0\l" +
-; CHECK-NEXT:     "  ir<%v2>, vp<[[EXP_SCEV]]>
-; CHECK-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<0> + vp<[[CAN_IV]]> * vp<[[EXP_SCEV]]>
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, vp<[[EXP_SCEV]]>
-; CHECK-NEXT:     WIDEN ir<%v3> = add ir<%v2>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<%v3>, ir<%gep>
-; CHECK-NEXT:     EMIT vp<[[CAN_INC:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_INC]]> vp<[[VTC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION\l" +
+; CHECK-NEXT:       "  %iv = phi %iv.next, 0\l" +
+; CHECK-NEXT:       "  ir<%v2>, vp<%1>
+; CHECK-NEXT:       vp<%4>      = DERIVED-IV ir<0> + vp<%2> * vp<%1>
+; CHECK-NEXT:       vp<%5>      = SCALAR-STEPS vp<%4>, vp<%1>
+; CHECK-NEXT:       WIDEN ir<%v3> = add ir<%v2>, ir<1>
+; CHECK-NEXT:       REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<%5>
+; CHECK-NEXT:       REPLICATE store ir<%v3>, ir<%gep>
+; CHECK-NEXT:       EMIT vp<%9> = VF * UF +(nuw)  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%9> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   %div = udiv i64 %y, 492802768830814060
   %inc = add i64 %div, 1
   br label %loop
 
 loop:                                             ; preds = %loop, %entry
   %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
   %v2 = trunc i64 %iv to i8
   %v3 = add i8 %v2, 1
   %gep = getelementptr inbounds i8, ptr %ptr, i64 %iv
   store i8 %v3, ptr %gep
 
   %cmp15 = icmp slt i8 %v3, 10000
   %iv.next = add i64 %iv, %inc
   br i1 %cmp15, label %loop, label %loop.exit
 
 loop.exit:
   ret void
 }
 
 define i32 @print_exit_value(ptr %ptr, i32 %off) {
 ; CHECK-LABEL: Checking a loop in 'print_exit_value'
 ; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<1000> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:     vp<[[STEPS:%.+]]>    = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     CLONE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:     WIDEN ir<%add> = add ir<%iv>, ir<%off>
-; CHECK-NEXT:     WIDEN store ir<%gep>, ir<0>
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       vp<%3>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%ptr>, vp<%3>
+; CHECK-NEXT:       WIDEN ir<%add> = add ir<%iv>, ir<%off>
+; CHECK-NEXT:       WIDEN store ir<%gep>, ir<0>
+; CHECK-NEXT:       EMIT vp<%6> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%6> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: No successors
 ; CHECK-EMPTY:
 ; CHECK-NEXT: Live-out i32 %lcssa = ir<%add>
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:

llvm/test/Transforms/LoopVectorize/vplan-sink-scalars-and-merge-vf1.ll

 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -force-vector-interleave=2 -force-vector-width=1 -debug -disable-output %s 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 ; Make sure recipes with side-effects are not sunk.
 define void @sink_with_sideeffects(i1 %c, ptr %ptr) {
 ; CHECK-LABEL: sink_with_sideeffects
 ; CHECK:      VPlan 'Initial VPlan for VF={1},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<0> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   CLONE ir<%tmp2> = getelementptr ir<%ptr>, vp<[[STEPS]]>
-; CHECK-NEXT:   CLONE ir<%tmp3> = load ir<%tmp2>
-; CHECK-NEXT:   CLONE store ir<0>, ir<%tmp2>
-; CHECK-NEXT: Successor(s): pred.store
-
-; CHECK:      <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK ir<%c>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
-
-; CHECK:      pred.store.if:
-; CHECK-NEXT:   CLONE ir<%tmp4> = zext ir<%tmp3>
-; CHECK-NEXT:   CLONE ir<%tmp5> = trunc ir<%tmp4>
-; CHECK-NEXT:   CLONE store ir<%tmp5>, ir<%tmp2>
-; CHECK-NEXT:   Successor(s): pred.store.continue
-
-; CHECK:      pred.store.continue:
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-
-; CHECK:      if.then.0:
-; CHECK-NEXT:  EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:  EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT: No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%tmp2> = getelementptr ir<%ptr>, vp<%2>
+; CHECK-NEXT:       CLONE ir<%tmp3> = load ir<%tmp2>
+; CHECK-NEXT:       CLONE store ir<0>, ir<%tmp2>
+; CHECK-NEXT:     Successor(s): pred.store
+; CHECK-EMPTY:
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK ir<%c>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         CLONE ir<%tmp4> = zext ir<%tmp3>
+; CHECK-NEXT:         CLONE ir<%tmp5> = trunc ir<%tmp4>
+; CHECK-NEXT:         CLONE store ir<%tmp5>, ir<%tmp2>
+; CHECK-NEXT:       Successor(s): pred.store.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): if.then.0
+; CHECK-EMPTY:
+; CHECK-NEXT:     if.then.0:
+; CHECK-NEXT:       EMIT vp<%9> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%9> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %for.body
 
 for.body:
   %tmp0 = phi i64 [ %tmp6, %for.inc ], [ 0, %entry ]
   %tmp1 = phi i64 [ %tmp7, %for.inc ], [ 0, %entry ]
   %tmp2 = getelementptr i8, ptr %ptr, i64 %tmp0

llvm/test/Transforms/LoopVectorize/vplan-sink-scalars-and-merge.ll

 ; REQUIRES: asserts
 
 ; RUN: opt -passes=loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -debug -disable-output %s 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 @a = common global [2048 x i32] zeroinitializer, align 16
 @b = common global [2048 x i32] zeroinitializer, align 16
 @c = common global [2048 x i32] zeroinitializer, align 16
 
 
 ; CHECK-LABEL: LV: Checking a loop in 'sink1'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT: Successor(s): pred.store
-
-; CHECK:      <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
-
-; CHECK:      pred.store.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.b> = load ir<%gep.b>
-; CHECK-NEXT:     REPLICATE ir<%add> = add ir<%lv.b>, ir<10>
-; CHECK-NEXT:     REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, vp<[[STEPS]]
-; CHECK-NEXT:     REPLICATE ir<%mul> = mul ir<2>, ir<%add>
-; CHECK-NEXT:     REPLICATE store ir<%mul>, ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.store.continue
-
-; CHECK:      pred.store.continue:
-; CHECK-NEXT:   PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%lv.b>
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%4> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:     Successor(s): pred.store
+; CHECK-EMPTY:
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%4>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         vp<%5>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<%5>
+; CHECK-NEXT:         REPLICATE ir<%lv.b> = load ir<%gep.b>
+; CHECK-NEXT:         REPLICATE ir<%add> = add ir<%lv.b>, ir<10>
+; CHECK-NEXT:         REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, vp<%5>
+; CHECK-NEXT:         REPLICATE ir<%mul> = mul ir<2>, ir<%add>
+; CHECK-NEXT:         REPLICATE store ir<%mul>, ir<%gep.a>
+; CHECK-NEXT:       Successor(s): pred.store.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%12> = ir<%lv.b>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.1
+; CHECK-EMPTY:
+; CHECK-NEXT:     loop.1:
+; CHECK-NEXT:       EMIT vp<%13> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%13> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
 ; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
-
-; CHECK:      loop.1:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 define void @sink1(i32 %k) {
 entry:
   br label %loop
 
 loop:
loop:
   %realexit = or i1 %large, %exitcond
   br i1 %realexit, label %exit, label %loop
 
 exit:
   ret void
 }
 
 ; CHECK-LABEL: LV: Checking a loop in 'sink2'
-; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK: VPlan 'Initial VPlan for VF={2},UF>=1' {
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT: Successor(s): pred.load
-
-; CHECK:      <xVFxUF> pred.load: {
-; CHECK-NEXT:   pred.load.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
-
-; CHECK:      pred.load.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.b> = load ir<%gep.b>
-; CHECK-NEXT:   Successor(s): pred.load.continue
-
-; CHECK:      pred.load.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%lv.b>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-
-; CHECK:      loop.0:
-; CHECK-NEXT:   WIDEN ir<%mul> = mul ir<%iv>, ir<2>
-; CHECK-NEXT: Successor(s): pred.store
-
-; CHECK:      <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
-
-; CHECK:       pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
-; CHECK-NEXT:     REPLICATE ir<%add> = add vp<[[PRED]]>, ir<10>
-; CHECK-NEXT:     REPLICATE store ir<%add>, ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.store.continue
-
-; CHECK:      pred.store.continue:
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%4> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:     Successor(s): pred.load
+; CHECK-EMPTY:
+; CHECK-NEXT:     <xVFxUF> pred.load: {
+; CHECK-NEXT:       pred.load.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%4>
+; CHECK-NEXT:       Successor(s): pred.load.if, pred.load.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.load.if:
+; CHECK-NEXT:         vp<%5>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<%5>
+; CHECK-NEXT:         REPLICATE ir<%lv.b> = load ir<%gep.b>
+; CHECK-NEXT:       Successor(s): pred.load.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.load.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%8> = ir<%lv.b>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.0
+; CHECK-EMPTY:
+; CHECK-NEXT:     loop.0:
+; CHECK-NEXT:       WIDEN ir<%mul> = mul ir<%iv>, ir<2>
+; CHECK-NEXT:     Successor(s): pred.store
+; CHECK-EMPTY:
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%4>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
+; CHECK-NEXT:         REPLICATE ir<%add> = add vp<%8>, ir<10>
+; CHECK-NEXT:         REPLICATE store ir<%add>, ir<%gep.a>
+; CHECK-NEXT:       Successor(s): pred.store.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.1
+; CHECK-EMPTY:
+; CHECK-NEXT:     loop.1:
+; CHECK-NEXT:       EMIT vp<%13> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%13> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
 ; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
-
-; CHECK:       loop.1:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 define void @sink2(i32 %k) {
 entry:
   br label %loop
 
 loop:
loop:
   br i1 %realexit, label %exit, label %loop
 
 exit:
   ret void
 }
 
 ; CHECK-LABEL: LV: Checking a loop in 'sink3'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT: Successor(s): pred.load
-
-; CHECK:      <xVFxUF> pred.load: {
-; CHECK-NEXT:   pred.load.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
-
-; CHECK:       pred.load.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.b> = load ir<%gep.b> (S->V)
-; CHECK-NEXT:   Successor(s): pred.load.continue
-
-; CHECK:       pred.load.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%lv.b>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-
-; CHECK:      loop.0:
-; CHECK-NEXT:   WIDEN ir<%add> = add vp<[[PRED]]>, ir<10>
-; CHECK-NEXT:   WIDEN ir<%mul> = mul ir<%iv>, ir<%add>
-; CHECK-NEXT: Successor(s): pred.store
-
-; CHECK:      <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
-
-; CHECK:      pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
-; CHECK-NEXT:     REPLICATE store ir<%add>, ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.store.continue
-
-; CHECK:      pred.store.continue:
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%4> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:     Successor(s): pred.load
+; CHECK-EMPTY:
+; CHECK-NEXT:     <xVFxUF> pred.load: {
+; CHECK-NEXT:       pred.load.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%4>
+; CHECK-NEXT:       Successor(s): pred.load.if, pred.load.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.load.if:
+; CHECK-NEXT:         vp<%5>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<%5>
+; CHECK-NEXT:         REPLICATE ir<%lv.b> = load ir<%gep.b> (S->V)
+; CHECK-NEXT:       Successor(s): pred.load.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.load.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%8> = ir<%lv.b>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.0
+; CHECK-EMPTY:
+; CHECK-NEXT:     loop.0:
+; CHECK-NEXT:       WIDEN ir<%add> = add vp<%8>, ir<10>
+; CHECK-NEXT:       WIDEN ir<%mul> = mul ir<%iv>, ir<%add>
+; CHECK-NEXT:     Successor(s): pred.store
+; CHECK-EMPTY:
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%4>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
+; CHECK-NEXT:         REPLICATE store ir<%add>, ir<%gep.a>
+; CHECK-NEXT:       Successor(s): pred.store.continue
+; CHECK-EMPTY:
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.1
+; CHECK-EMPTY:
+; CHECK-NEXT:     loop.1:
+; CHECK-NEXT:       EMIT vp<%13> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%13> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
 ; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
-
-; CHECK:      loop.1:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 define void @sink3(i32 %k) {
 entry:
   br label %loop
 
 loop:

 exit:
   ret void
 }
 
 ; Make sure we do not sink uniform instructions.
 define void @uniform_gep(i64 %k, ptr noalias %A, ptr noalias %B) {
 ; CHECK-LABEL: LV: Checking a loop in 'uniform_gep'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, ir<32> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 21, %iv.next, ir<1>
-; CHECK-NEXT:   vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<21> + vp<[[CAN_IV]]> * ir<1>
-; CHECK-NEXT:   EMIT vp<[[WIDE_CAN_IV:%.+]]> = WIDEN-CANONICAL-INDUCTION vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule vp<[[WIDE_CAN_IV]]> vp<[[BTC]]>
-; CHECK-NEXT:   CLONE ir<%gep.A.uniform> = getelementptr ir<%A>, ir<0>
-; CHECK-NEXT:   CLONE ir<%lv> = load ir<%gep.A.uniform>
-; CHECK-NEXT:   WIDEN ir<%cmp> = icmp ult ir<%iv>, ir<%k>
-; CHECK-NEXT:   EMIT vp<[[NOT2:%.+]]> = not ir<%cmp>
-; CHECK-NEXT:   EMIT vp<[[MASK2:%.+]]> = select vp<[[MASK]]> vp<[[NOT2]]> ir<false>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 21, %iv.next, ir<1>
+; CHECK-NEXT:       vp<%4>      = DERIVED-IV ir<21> + vp<%2> * ir<1>
+; CHECK-NEXT:       EMIT vp<%5> = WIDEN-CANONICAL-INDUCTION vp<%2>
+; CHECK-NEXT:       EMIT vp<%6> = icmp ule vp<%5> vp<%1>
+; CHECK-NEXT:       CLONE ir<%gep.A.uniform> = getelementptr ir<%A>, ir<0>
+; CHECK-NEXT:       CLONE ir<%lv> = load ir<%gep.A.uniform>
+; CHECK-NEXT:       WIDEN ir<%cmp> = icmp ult ir<%iv>, ir<%k>
+; CHECK-NEXT:       EMIT vp<%10> = not ir<%cmp>
+; CHECK-NEXT:       EMIT vp<%11> = select vp<%6> vp<%10> ir<false>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK2]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%11>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep.B> = getelementptr ir<%B>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<%lv>, ir<%gep.B>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         vp<%12>        = SCALAR-STEPS vp<%4>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.B> = getelementptr ir<%B>, vp<%12>
+; CHECK-NEXT:         REPLICATE store ir<%lv>, ir<%gep.B>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.then.0
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.then.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.then.0:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     loop.then.0:
+; CHECK-NEXT:       EMIT vp<%15> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%15> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i64 [ 21, %entry ], [ %iv.next, %loop.latch ]

 exit:
   ret void
 }
 
 ; Loop with predicated load.
 define void @pred_cfg1(i32 %k, i32 %j) {
 ; CHECK-LABEL: LV: Checking a loop in 'pred_cfg1'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK1:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:   WIDEN ir<%c.1> = icmp ult ir<%iv>, ir<%j>
-; CHECK-NEXT:   WIDEN ir<%mul> = mul ir<%iv>, ir<10>
-; CHECK-NEXT:   EMIT vp<[[MASK2:%.+]]> = select vp<[[MASK1]]> ir<%c.1> ir<false>
-; CHECK-NEXT: Successor(s): pred.load
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%4> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:       WIDEN ir<%c.1> = icmp ult ir<%iv>, ir<%j>
+; CHECK-NEXT:       WIDEN ir<%mul> = mul ir<%iv>, ir<10>
+; CHECK-NEXT:       EMIT vp<%7> = select vp<%4> ir<%c.1> ir<false>
+; CHECK-NEXT:     Successor(s): pred.load
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.load: {
-; CHECK-NEXT:   pred.load.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK2]]>
-; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
+; CHECK-NEXT:     <xVFxUF> pred.load: {
+; CHECK-NEXT:       pred.load.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%7>
+; CHECK-NEXT:       Successor(s): pred.load.if, pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.b> = load ir<%gep.b> (S->V)
-; CHECK-NEXT:   Successor(s): pred.load.continue
+; CHECK-NEXT:       pred.load.if:
+; CHECK-NEXT:         vp<%8>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<%8>
+; CHECK-NEXT:         REPLICATE ir<%lv.b> = load ir<%gep.b> (S->V)
+; CHECK-NEXT:       Successor(s): pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%lv.b>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): then.0.0
+; CHECK-NEXT:       pred.load.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%11> = ir<%lv.b>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): then.0.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: then.0.0:
-; CHECK-NEXT:   EMIT vp<[[NOT:%.+]]> = not ir<%c.1>
-; CHECK-NEXT:   EMIT vp<[[MASK3:%.+]]> = select vp<[[MASK1]]> vp<[[NOT]]> ir<false>
-; CHECK-NEXT:   BLEND %p = ir<0>/vp<[[MASK3]]> vp<[[PRED]]>/vp<[[MASK2]]>
-; CHECK-NEXT:   EMIT vp<[[OR:%.+]]> = or vp<[[MASK2]]> vp<[[MASK3]]>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     then.0.0:
+; CHECK-NEXT:       EMIT vp<%12> = not ir<%c.1>
+; CHECK-NEXT:       EMIT vp<%13> = select vp<%4> vp<%12> ir<false>
+; CHECK-NEXT:       BLEND %p = ir<0>/vp<%13> vp<%11>/vp<%7>
+; CHECK-NEXT:       EMIT vp<%15> = or vp<%7> vp<%13>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[OR]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%15>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
-; CHECK-NEXT:     REPLICATE store ir<%p>, ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
+; CHECK-NEXT:         REPLICATE store ir<%p>, ir<%gep.a>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): next.0.1
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): next.0.1
 ; CHECK-EMPTY:
-; CHECK-NEXT: next.0.1:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     next.0.1:
+; CHECK-NEXT:       EMIT vp<%18> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%18> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %next.0 ]
exit:
   ret void
 }
 
 ; Loop with predicated load and store in separate blocks, store depends on
 ; loaded value.
 define void @pred_cfg2(i32 %k, i32 %j) {
 ; CHECK-LABEL: LV: Checking a loop in 'pred_cfg2'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK1:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:   WIDEN ir<%mul> = mul ir<%iv>, ir<10>
-; CHECK-NEXT:   WIDEN ir<%c.0> = icmp ult ir<%iv>, ir<%j>
-; CHECK-NEXT:   WIDEN ir<%c.1> = icmp ugt ir<%iv>, ir<%j>
-; CHECK-NEXT:   EMIT vp<[[MASK2:%.+]]> = select vp<[[MASK1]]> ir<%c.0> ir<false>
-; CHECK-NEXT: Successor(s): pred.load
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%4> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:       WIDEN ir<%mul> = mul ir<%iv>, ir<10>
+; CHECK-NEXT:       WIDEN ir<%c.0> = icmp ult ir<%iv>, ir<%j>
+; CHECK-NEXT:       WIDEN ir<%c.1> = icmp ugt ir<%iv>, ir<%j>
+; CHECK-NEXT:       EMIT vp<%8> = select vp<%4> ir<%c.0> ir<false>
+; CHECK-NEXT:     Successor(s): pred.load
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.load: {
-; CHECK-NEXT:   pred.load.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK2]]>
-; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
+; CHECK-NEXT:     <xVFxUF> pred.load: {
+; CHECK-NEXT:       pred.load.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%8>
+; CHECK-NEXT:       Successor(s): pred.load.if, pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.b> = load ir<%gep.b> (S->V)
-; CHECK-NEXT:   Successor(s): pred.load.continue
+; CHECK-NEXT:       pred.load.if:
+; CHECK-NEXT:         vp<%9>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<%9>
+; CHECK-NEXT:         REPLICATE ir<%lv.b> = load ir<%gep.b> (S->V)
+; CHECK-NEXT:       Successor(s): pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%lv.b>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): then.0.0
+; CHECK-NEXT:       pred.load.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%12> = ir<%lv.b>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): then.0.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: then.0.0:
-; CHECK-NEXT:   EMIT vp<[[NOT:%.+]]> = not ir<%c.0>
-; CHECK-NEXT:   EMIT vp<[[MASK3:%.+]]> = select vp<[[MASK1]]> vp<[[NOT]]> ir<false>
-; CHECK-NEXT:   BLEND %p = ir<0>/vp<[[MASK3]]> vp<[[PRED]]>/vp<[[MASK2]]>
-; CHECK-NEXT:   EMIT vp<[[OR:%.+]]> = or vp<[[MASK2]]> vp<[[MASK3]]>
-; CHECK-NEXT:   EMIT vp<[[MASK4:%.+]]> = select vp<[[OR]]> ir<%c.1> ir<false>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     then.0.0:
+; CHECK-NEXT:       EMIT vp<%13> = not ir<%c.0>
+; CHECK-NEXT:       EMIT vp<%14> = select vp<%4> vp<%13> ir<false>
+; CHECK-NEXT:       BLEND %p = ir<0>/vp<%14> vp<%12>/vp<%8>
+; CHECK-NEXT:       EMIT vp<%16> = or vp<%8> vp<%14>
+; CHECK-NEXT:       EMIT vp<%17> = select vp<%16> ir<%c.1> ir<false>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK4]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%17>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
-; CHECK-NEXT:     REPLICATE store ir<%p>, ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
+; CHECK-NEXT:         REPLICATE store ir<%p>, ir<%gep.a>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): then.1.1
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): then.1.1
 ; CHECK-EMPTY:
-; CHECK-NEXT: then.1.1:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     then.1.1:
+; CHECK-NEXT:       EMIT vp<%20> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%20> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %next.1 ]
exit:
   ret void
 }
 
 ; Loop with predicated load and store in separate blocks, store does not depend
 ; on loaded value.
 define void @pred_cfg3(i32 %k, i32 %j) {
 ; CHECK-LABEL: LV: Checking a loop in 'pred_cfg3'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK1:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:   WIDEN ir<%mul> = mul ir<%iv>, ir<10>
-; CHECK-NEXT:   WIDEN ir<%c.0> = icmp ult ir<%iv>, ir<%j>
-; CHECK-NEXT:   EMIT vp<[[MASK2:%.+]]> = select vp<[[MASK1:%.+]]> ir<%c.0> ir<false>
-; CHECK-NEXT: Successor(s): pred.load
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%4> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:       WIDEN ir<%mul> = mul ir<%iv>, ir<10>
+; CHECK-NEXT:       WIDEN ir<%c.0> = icmp ult ir<%iv>, ir<%j>
+; CHECK-NEXT:       EMIT vp<%7> = select vp<%4> ir<%c.0> ir<false>
+; CHECK-NEXT:     Successor(s): pred.load
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.load: {
-; CHECK-NEXT:   pred.load.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK2]]>
-; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
+; CHECK-NEXT:     <xVFxUF> pred.load: {
+; CHECK-NEXT:       pred.load.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%7>
+; CHECK-NEXT:       Successor(s): pred.load.if, pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.b> = load ir<%gep.b>
-; CHECK-NEXT:   Successor(s): pred.load.continue
+; CHECK-NEXT:       pred.load.if:
+; CHECK-NEXT:         vp<%8>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<%8>
+; CHECK-NEXT:         REPLICATE ir<%lv.b> = load ir<%gep.b> (S->V)
+; CHECK-NEXT:       Successor(s): pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%lv.b>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): then.0.0
+; CHECK-NEXT:       pred.load.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%11> = ir<%lv.b>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): then.0.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: then.0.0:
-; CHECK-NEXT:   EMIT vp<[[NOT:%.+]]> = not ir<%c.0>
-; CHECK-NEXT:   EMIT vp<[[MASK3:%.+]]> = select vp<[[MASK1]]> vp<[[NOT]]> ir<false>
-; CHECK-NEXT:   BLEND %p = ir<0>/vp<[[MASK3]]> vp<[[PRED]]>/vp<[[MASK2]]>
-; CHECK-NEXT:   EMIT vp<[[MASK4:%.+]]> = or vp<[[MASK2]]> vp<[[MASK3]]>
-; CHECK-NEXT:   EMIT vp<[[MASK5:%.+]]> = select vp<[[MASK4]]> ir<%c.0> ir<false>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     then.0.0:
+; CHECK-NEXT:       EMIT vp<%12> = not ir<%c.0>
+; CHECK-NEXT:       EMIT vp<%13> = select vp<%4> vp<%12> ir<false>
+; CHECK-NEXT:       BLEND %p = ir<0>/vp<%13> vp<%11>/vp<%7>
+; CHECK-NEXT:       EMIT vp<%15> = or vp<%7> vp<%13>
+; CHECK-NEXT:       EMIT vp<%16> = select vp<%15> ir<%c.0> ir<false>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK5]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%16>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
-; CHECK-NEXT:     REPLICATE store ir<0>, ir<%gep.a>
-; CHECK-NEXT:     REPLICATE ir<%gep.c> = getelementptr ir<@c>, ir<0>, ir<%mul>
-; CHECK-NEXT:     REPLICATE store ir<%p>, ir<%gep.c>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, ir<%mul>
+; CHECK-NEXT:         REPLICATE store ir<0>, ir<%gep.a>
+; CHECK-NEXT:         REPLICATE ir<%gep.c> = getelementptr ir<@c>, ir<0>, ir<%mul>
+; CHECK-NEXT:         REPLICATE store ir<%p>, ir<%gep.c>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): then.1.2
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): then.1.2
 ; CHECK-EMPTY:
-; CHECK-NEXT: then.1.2:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     then.1.2:
+; CHECK-NEXT:       EMIT vp<%21> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%21> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %next.1 ]

 
 exit:
   ret void
 }
 
 define void @merge_3_replicate_region(i32 %k, i32 %j) {
 ; CHECK-LABEL: LV: Checking a loop in 'merge_3_replicate_region'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       vp<%4>      = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:       EMIT vp<%5> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%5>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.a> = load ir<%gep.a>
-; CHECK-NEXT:     REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.b> = load ir<%gep.b>
-; CHECK-NEXT:     REPLICATE ir<%gep.c> = getelementptr ir<@c>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<%lv.a>, ir<%gep.c>
-; CHECK-NEXT:     REPLICATE store ir<%lv.b>, ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, vp<%4>
+; CHECK-NEXT:         REPLICATE ir<%lv.a> = load ir<%gep.a> (S->V)
+; CHECK-NEXT:         REPLICATE ir<%gep.b> = getelementptr ir<@b>, ir<0>, vp<%4>
+; CHECK-NEXT:         REPLICATE ir<%lv.b> = load ir<%gep.b> (S->V)
+; CHECK-NEXT:         REPLICATE ir<%gep.c> = getelementptr ir<@c>, ir<0>, vp<%4>
+; CHECK-NEXT:         REPLICATE store ir<%lv.a>, ir<%gep.c>
+; CHECK-NEXT:         REPLICATE store ir<%lv.b>, ir<%gep.a>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED1:%.+]]> = ir<%lv.a>
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%lv.b>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.3
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%13> = ir<%lv.a>
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%14> = ir<%lv.b>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.3
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.3:
-; CHECK-NEXT:   WIDEN ir<%c.0> = icmp ult ir<%iv>, ir<%j>
-; CHECK-NEXT:   WIDEN ir<%mul> = mul vp<[[PRED1]]>, vp<[[PRED2]]>
-; CHECK-NEXT:   EMIT vp<[[MASK2:%.+]]> = select vp<[[MASK]]> ir<%c.0> ir<false>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     loop.3:
+; CHECK-NEXT:       WIDEN ir<%c.0> = icmp ult ir<%iv>, ir<%j>
+; CHECK-NEXT:       WIDEN ir<%mul> = mul vp<%13>, vp<%14>
+; CHECK-NEXT:       EMIT vp<%17> = select vp<%5> ir<%c.0> ir<false>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK2]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%17>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%gep.c.1> = getelementptr ir<@c>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<%mul>, ir<%gep.c.1>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%gep.c.1> = getelementptr ir<@c>, ir<0>, vp<%4>
+; CHECK-NEXT:         REPLICATE store ir<%mul>, ir<%gep.c.1>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): then.0.4
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): then.0.4
 ; CHECK-EMPTY:
-; CHECK-NEXT: then.0.4:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     then.0.4:
+; CHECK-NEXT:       EMIT vp<%20> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%20> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %latch ]

 exit:
   ret void
 }
 
 
 define void @update_2_uses_in_same_recipe_in_merged_block(i32 %k) {
 ; CHECK-LABEL: LV: Checking a loop in 'update_2_uses_in_same_recipe_in_merged_block'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       EMIT vp<%4> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%4>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:     REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE ir<%lv.a> = load ir<%gep.a>
-; CHECK-NEXT:     REPLICATE ir<%div> = sdiv ir<%lv.a>, ir<%lv.a>
-; CHECK-NEXT:     REPLICATE store ir<%div>, ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         vp<%5>        = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:         REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, vp<%5>
+; CHECK-NEXT:         REPLICATE ir<%lv.a> = load ir<%gep.a>
+; CHECK-NEXT:         REPLICATE ir<%div> = sdiv ir<%lv.a>, ir<%lv.a>
+; CHECK-NEXT:         REPLICATE store ir<%div>, ir<%gep.a>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED1:%.+]]> = ir<%lv.a>
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%div>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.2
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%10> = ir<%lv.a>
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%11> = ir<%div>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.2
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.2:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     loop.2:
+; CHECK-NEXT:       EMIT vp<%12> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%12> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]

 
 exit:
   ret void
 }
 
 define void @recipe_in_merge_candidate_used_by_first_order_recurrence(i32 %k) {
 ; CHECK-LABEL: LV: Checking a loop in 'recipe_in_merge_candidate_used_by_first_order_recurrence'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
-; CHECK-NEXT:   FIRST-ORDER-RECURRENCE-PHI ir<%for> = phi ir<0>, vp<[[PRED:%.+]]>
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:   REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, vp<[[STEPS]]>
-; CHECK-NEXT: Successor(s): pred.load
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
+; CHECK-NEXT:       FIRST-ORDER-RECURRENCE-PHI ir<%for> = phi ir<0>, vp<%9>
+; CHECK-NEXT:       vp<%5>      = SCALAR-STEPS vp<%2>, ir<1>
+; CHECK-NEXT:       EMIT vp<%6> = icmp ule ir<%iv> vp<%1>
+; CHECK-NEXT:       REPLICATE ir<%gep.a> = getelementptr ir<@a>, ir<0>, vp<%5>
+; CHECK-NEXT:     Successor(s): pred.load
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.load: {
-; CHECK-NEXT:   pred.load.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.load.if, pred.load.continue
+; CHECK-NEXT:     <xVFxUF> pred.load: {
+; CHECK-NEXT:       pred.load.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.load.if, pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.if:
-; CHECK-NEXT:     REPLICATE ir<%lv.a> = load ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.load.continue
+; CHECK-NEXT:       pred.load.if:
+; CHECK-NEXT:         REPLICATE ir<%lv.a> = load ir<%gep.a> (S->V)
+; CHECK-NEXT:       Successor(s): pred.load.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.load.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED]]> = ir<%lv.a>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.0
+; CHECK-NEXT:       pred.load.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%9> = ir<%lv.a>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.0:
-; CHECK-NEXT:   EMIT vp<[[SPLICE:%.+]]> = first-order splice ir<%for> vp<[[PRED]]>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     loop.0:
+; CHECK-NEXT:       EMIT vp<%10> = first-order splice ir<%for> vp<%9>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%div> = sdiv vp<[[SPLICE]]>, vp<[[PRED]]>
-; CHECK-NEXT:     REPLICATE store ir<%div>, ir<%gep.a>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%div> = sdiv vp<%10>, vp<%9>
+; CHECK-NEXT:         REPLICATE store ir<%div>, ir<%gep.a>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED2:%.+]]> = ir<%div>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.2
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%13> = ir<%div>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.2
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.2:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     loop.2:
+; CHECK-NEXT:       EMIT vp<%14> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%14> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]

 
 exit:
   ret void
 }
 
 define void @update_multiple_users(ptr noalias %src, ptr noalias %dst, i1 %c) {
 ; CHECK-LABEL: LV: Checking a loop in 'update_multiple_users'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, ir<999> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK ir<%c>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK ir<%c>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%l1> = load ir<%src>
-; CHECK-NEXT:     REPLICATE ir<%l2> = trunc ir<%l1>
-; CHECK-NEXT:     REPLICATE ir<%cmp> = icmp ir<%l1>, ir<0>
-; CHECK-NEXT:     REPLICATE ir<%sel> = select ir<%cmp>, ir<5>, ir<%l2>
-; CHECK-NEXT:     REPLICATE store ir<%sel>, ir<%dst>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%l1> = load ir<%src>
+; CHECK-NEXT:         REPLICATE ir<%l2> = trunc ir<%l1>
+; CHECK-NEXT:         REPLICATE ir<%cmp> = icmp ir<%l1>, ir<0>
+; CHECK-NEXT:         REPLICATE ir<%sel> = select ir<%cmp>, ir<5>, ir<%l2>
+; CHECK-NEXT:         REPLICATE store ir<%sel>, ir<%dst>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:     PHI-PREDICATED-INSTRUCTION vp<[[PRED:%.+]]> = ir<%l1>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): loop.then.1
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%7> = ir<%l1>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.then.1
 ; CHECK-EMPTY:
-; CHECK-NEXT: loop.then.1:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     loop.then.1:
+; CHECK-NEXT:       EMIT vp<%8> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%8> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop.header
 
 loop.header:
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]

 
 exit:
   ret void
 }
 
 define void @sinking_requires_duplication(ptr %addr) {
 ; CHECK-LABEL: LV: Checking a loop in 'sinking_requires_duplication'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT: vector.body:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:   vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
-; CHECK-NEXT:   CLONE ir<%gep> = getelementptr ir<%addr>, vp<[[STEPS]]>
-; CHECK-NEXT:   WIDEN ir<%0> = load ir<%gep>
-; CHECK-NEXT:   WIDEN ir<%pred> = fcmp oeq ir<%0>, ir<0.000000e+00>
-; CHECK-NEXT:   EMIT vp<[[MASK:%.+]]> = not ir<%pred>
-; CHECK-NEXT: Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%2>      = SCALAR-STEPS vp<%1>, ir<1>
+; CHECK-NEXT:       CLONE ir<%gep> = getelementptr ir<%addr>, vp<%2>
+; CHECK-NEXT:       WIDEN ir<%0> = load ir<%gep>
+; CHECK-NEXT:       WIDEN ir<%pred> = fcmp oeq ir<%0>, ir<0.000000e+00>
+; CHECK-NEXT:       EMIT vp<%6> = not ir<%pred>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT: <xVFxUF> pred.store: {
-; CHECK-NEXT:   pred.store.entry:
-; CHECK-NEXT:     BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:   Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.if:
-; CHECK-NEXT:     REPLICATE ir<%gep> = getelementptr ir<%addr>, vp<[[STEPS]]>
-; CHECK-NEXT:     REPLICATE store ir<1.000000e+01>, ir<%gep>
-; CHECK-NEXT:   Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%gep> = getelementptr ir<%addr>, vp<%2>
+; CHECK-NEXT:         REPLICATE store ir<1.000000e+01>, ir<%gep>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:   pred.store.continue:
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): then.0
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): then.0
 ; CHECK-EMPTY:
-; CHECK-NEXT: then.0:
-; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw) vp<[[CAN_IV]]>
-; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT:     then.0:
+; CHECK-NEXT:       EMIT vp<%9> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%9> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
+; CHECK-NEXT: }
 ; CHECK-NEXT: No successors
 ; CHECK-NEXT: }
 ;
 entry:
   br label %loop.header
 
 loop.header:
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
exit:
   ret void
 }
 
 ; Test case with a dead GEP between the load and store regions. Dead recipes
 ; need to be removed before merging.
 define void @merge_with_dead_gep_between_regions(i32 %n, ptr noalias %src, ptr noalias %dst) optsize {
 ; CHECK-LABEL: LV: Checking a loop in 'merge_with_dead_gep_between_regions'
 ; CHECK:      VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
-; CHECK-NEXT: Live-in vp<[[BTC:%.+]]> = backedge-taken count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%1> = backedge-taken count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%2> = 0, ir<0> {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     vp<[[DERIVED_IV:%.+]]> = DERIVED-IV ir<%n> + vp<[[CAN_IV]]> * ir<-1>
-; CHECK-NEXT:     EMIT vp<[[WIDE_IV:%.+]]> = WIDEN-CANONICAL-INDUCTION vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT vp<[[MASK:%.+]]> = icmp ule vp<[[WIDE_IV]]> vp<[[BTC]]>
-; CHECK-NEXT:   Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%2> = CANONICAL-INDUCTION
+; CHECK-NEXT:       vp<%3>      = DERIVED-IV ir<%n> + vp<%2> * ir<-1>
+; CHECK-NEXT:       EMIT vp<%4> = WIDEN-CANONICAL-INDUCTION vp<%2>
+; CHECK-NEXT:       EMIT vp<%5> = icmp ule vp<%4> vp<%1>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT:   <xVFxUF> pred.store: {
-; CHECK-NEXT:     pred.store.entry:
-; CHECK-NEXT:       BRANCH-ON-MASK vp<[[MASK]]>
-; CHECK-NEXT:     Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%5>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:     pred.store.if:
-; CHECK-NEXT:       vp<[[SCALAR_STEPS:%.+]]>    = SCALAR-STEPS vp<[[DERIVED_IV]]>, ir<-1>
-; CHECK-NEXT:       REPLICATE ir<%gep.src> = getelementptr ir<%src>, vp<[[SCALAR_STEPS]]>
-; CHECK-NEXT:       REPLICATE ir<%l> = load ir<%gep.src>
-; CHECK-NEXT:       REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<[[SCALAR_STEPS]]>
-; CHECK-NEXT:       REPLICATE store ir<%l>, ir<%gep.dst>
-; CHECK-NEXT:     Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         vp<%6>        = SCALAR-STEPS vp<%3>, ir<-1>
+; CHECK-NEXT:         REPLICATE ir<%gep.src> = getelementptr ir<%src>, vp<%6>
+; CHECK-NEXT:         REPLICATE ir<%l> = load ir<%gep.src>
+; CHECK-NEXT:         REPLICATE ir<%gep.dst> = getelementptr ir<%dst>, vp<%6>
+; CHECK-NEXT:         REPLICATE store ir<%l>, ir<%gep.dst>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:     pred.store.continue:
-; CHECK-NEXT:       PHI-PREDICATED-INSTRUCTION vp<[[P_LOAD:%.+]]> = ir<%l>
-; CHECK-NEXT:     No successors
-; CHECK-NEXT:   }
-; CHECK-NEXT:   Successor(s): loop.1
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:         PHI-PREDICATED-INSTRUCTION vp<%11> = ir<%l>
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): loop.1
 ; CHECK-EMPTY:
-; CHECK-NEXT:   loop.1:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     loop.1:
+; CHECK-NEXT:       EMIT vp<%12> = VF * UF +  vp<%2>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%12> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop
 
 loop:
   %iv = phi i32[ %n, %entry ], [ %iv.next, %loop ]
   %iv.next = add nsw i32 %iv, -1
   %gep.src = getelementptr inbounds i32, ptr %src, i32 %iv
   %l = load i32, ptr %gep.src, align 16
   %dead_gep = getelementptr inbounds i32, ptr %dst, i64 1
   %gep.dst = getelementptr inbounds i32, ptr %dst, i32 %iv
   store i32 %l, ptr %gep.dst, align 16
   %ec = icmp eq i32 %iv.next, 0
   br i1 %ec, label %exit, label %loop
 
 exit:
   ret void
 }
 
 define void @ptr_induction_remove_dead_recipe(ptr %start, ptr %end) {
 ; CHECK-LABEL: LV: Checking a loop in 'ptr_induction_remove_dead_recipe'
 ; CHECK:       VPlan 'Initial VPlan for VF={2},UF>=1' {
-; CHECK-NEXT: Live-in vp<[[VEC_TC:%.+]]> = vector-trip-count
+; CHECK-NEXT: Live-in vp<%0> = vector-trip-count
 ; CHECK-EMPTY:
-; CHECK-NEXT: vector.ph:
-; CHECK-NEXT: Successor(s): vector loop
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT:   vector.ph:
+; CHECK-NEXT:   Successor(s): vector countable loop
+; CHECK-EMPTY:
+; CHECK-NEXT:   vector countable loop vp<%1> = 0, inf {
 ; CHECK-EMPTY:
-; CHECK-NEXT: <x1> vector loop: {
-; CHECK-NEXT:   vector.body:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
-; CHECK-NEXT:     EMIT ir<%ptr.iv> = WIDEN-POINTER-INDUCTION ir<%start>, -1
-; CHECK-NEXT:     CLONE ir<%ptr.iv.next> = getelementptr ir<%ptr.iv>, ir<-1>
-; CHECK-NEXT:     WIDEN ir<%l> = load ir<%ptr.iv.next>
-; CHECK-NEXT:     WIDEN ir<%c.1> = icmp eq ir<%l>, ir<0>
-; CHECK-NEXT:     EMIT vp<[[NEG:%.+]]> = not ir<%c.1>
-; CHECK-NEXT:   Successor(s): pred.store
+; CHECK-NEXT:     vector.body:
+; CHECK-NEXT:       EMIT vp<%1> = CANONICAL-INDUCTION
+; CHECK-NEXT:       EMIT ir<%ptr.iv> = WIDEN-POINTER-INDUCTION ir<%start>, -1
+; CHECK-NEXT:       CLONE ir<%ptr.iv.next> = getelementptr ir<%ptr.iv>, ir<-1>
+; CHECK-NEXT:       WIDEN ir<%l> = load ir<%ptr.iv.next>
+; CHECK-NEXT:       WIDEN ir<%c.1> = icmp eq ir<%l>, ir<0>
+; CHECK-NEXT:       EMIT vp<%6> = not ir<%c.1>
+; CHECK-NEXT:     Successor(s): pred.store
 ; CHECK-EMPTY:
-; CHECK-NEXT:   <xVFxUF> pred.store: {
-; CHECK-NEXT:     pred.store.entry:
-; CHECK-NEXT:       BRANCH-ON-MASK vp<[[NEG]]>
-; CHECK-NEXT:     Successor(s): pred.store.if, pred.store.continue
+; CHECK-NEXT:     <xVFxUF> pred.store: {
+; CHECK-NEXT:       pred.store.entry:
+; CHECK-NEXT:         BRANCH-ON-MASK vp<%6>
+; CHECK-NEXT:       Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:     pred.store.if:
-; CHECK-NEXT:       REPLICATE ir<%ptr.iv.next> = getelementptr ir<%ptr.iv>, ir<-1>
-; CHECK-NEXT:       REPLICATE store ir<95>, ir<%ptr.iv.next>
-; CHECK-NEXT:     Successor(s): pred.store.continue
+; CHECK-NEXT:       pred.store.if:
+; CHECK-NEXT:         REPLICATE ir<%ptr.iv.next> = getelementptr ir<%ptr.iv>, ir<-1>
+; CHECK-NEXT:         REPLICATE store ir<95>, ir<%ptr.iv.next>
+; CHECK-NEXT:       Successor(s): pred.store.continue
 ; CHECK-EMPTY:
-; CHECK-NEXT:     pred.store.continue:
-; CHECK-NEXT:     No successors
-; CHECK-NEXT:   }
-; CHECK-NEXT:   Successor(s): if.then.0
+; CHECK-NEXT:       pred.store.continue:
+; CHECK-NEXT:       No successors
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Successor(s): if.then.0
 ; CHECK-EMPTY:
-; CHECK-NEXT:   if.then.0:
-; CHECK-NEXT:     EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF +(nuw)  vp<[[CAN_IV]]>
-; CHECK-NEXT:     EMIT branch-on-count  vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
-; CHECK-NEXT:   No successors
-; CHECK-NEXT: }
-; CHECK-NEXT: Successor(s): middle.block
+; CHECK-NEXT:     if.then.0:
+; CHECK-NEXT:       EMIT vp<%9> = VF * UF +(nuw)  vp<%1>
+; CHECK-NEXT:       EMIT branch-on-count  vp<%9> vp<%0>
+; CHECK-NEXT:     No successors
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Successor(s): middle.block
 ; CHECK-EMPTY:
-; CHECK-NEXT: middle.block:
-; CHECK-NEXT: No successors
+; CHECK-NEXT:   middle.block:
+; CHECK-NEXT:   No successors
 ; CHECK-NEXT: }
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
 ;
 entry:
   br label %loop.header
 
 loop.header:
   %ptr.iv = phi ptr [ %start, %entry ], [ %ptr.iv.next, %loop.latch ]
   %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 -1
   %l = load i8, ptr %ptr.iv.next, align 1

llvm/unittests/Transforms/Vectorize/VPlanHCFGTest.cpp

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   std::string FullDump;
   raw_string_ostream OS(FullDump);
   Plan->printDOT(OS);
   const char *ExpectedStr = R"(digraph VPlan {
 graph [labelloc=t, fontsize=30; label="Vectorization Plan\n for UF\>=1"]
 node [shape=rect, fontname=Courier, fontsize=30]
 edge [fontname=Courier, fontsize=30]
 compound=true
-  N0 [label =
+  subgraph cluster_N0 {
+    fontname=Courier
+    label="\<x1\> "
+    N1 [label =
       "vector.ph:\l" +
       "Successor(s): for.body\l"
     ]
-  N0 -> N1 [ label="" lhead=cluster_N2]
-  subgraph cluster_N2 {
+    N1 -> N2 [ label="" lhead=cluster_N3]
+    subgraph cluster_N3 {
       fontname=Courier
       label="\<x1\> for.body"
-    N1 [label =
+      N2 [label =
         "vector.body:\l" +
         "  WIDEN-PHI ir\<%indvars.iv\> = phi ir\<0\>, ir\<%indvars.iv.next\>\l" +
         "  EMIT ir\<%arr.idx\> = getelementptr ir\<%A\> ir\<%indvars.iv\>\l" +
         "  EMIT ir\<%l1\> = load ir\<%arr.idx\>\l" +
         "  EMIT ir\<%res\> = add ir\<%l1\> ir\<10\>\l" +
         "  EMIT store ir\<%res\> ir\<%arr.idx\>\l" +
         "  EMIT ir\<%indvars.iv.next\> = add ir\<%indvars.iv\> ir\<1\>\l" +
         "  EMIT ir\<%exitcond\> = icmp ir\<%indvars.iv.next\> ir\<%N\>\l" +
         "  EMIT branch-on-cond ir\<%exitcond\>\l" +
         "No successors\l"
       ]
     }
-  N1 -> N3 [ label="" ltail=cluster_N2]
-  N3 [label =
+    N2 -> N4 [ label="" ltail=cluster_N3]
+    N4 [label =
       "for.end:\l" +
       "No successors\l"
     ]
   }
+}
 )";
   EXPECT_EQ(ExpectedStr, FullDump);
 #endif
   TargetLibraryInfoImpl TLII(Triple(M.getTargetTriple()));
   TargetLibraryInfo TLI(TLII);
   SmallPtrSet<Instruction *, 1> DeadInstructions;
   VPlanTransforms::VPInstructionsToVPRecipes(
       Plan, [](PHINode *P) { return nullptr; }, DeadInstructions, *SE, TLI);

llvm/unittests/Transforms/Vectorize/VPlanTestBase.h

protected:
   }
 
   /// Build the VPlan plain CFG for the loop starting from \p LoopHeader.
   VPlanPtr buildPlainCFG(BasicBlock *LoopHeader) {
     doAnalysis(*LoopHeader->getParent());
 
     auto Plan = std::make_unique<VPlan>();
     VPlanHCFGBuilder HCFGBuilder(LI->getLoopFor(LoopHeader), LI.get(), *Plan);
-    VPBasicBlock *EntryVPBB = HCFGBuilder.buildPlainCFG();
+    VPBlockBase *EntryVPBB = HCFGBuilder.buildPlainCFG();
     Plan->setEntry(EntryVPBB);
     return Plan;
   }
 };
 
 } // namespace llvm
 
 #endif // LLVM_UNITTESTS_TRANSFORMS_VECTORIZE_VPLANTESTBASE_H