[VPlan] Turn Plan entry node into VPBasicBlock (NFCI).

[fhahn]

Summary

The entry to the plan is guaranteed to be a VPBasicBlock. Make sure this
is the case by adjusting the type.

[Ayal]

Looks good to me, with minor nits.
Worth explaining that Entry is the preheader of the vector loop.

llvm/unittests/Transforms/Vectorize/VPDomTreeTest.cpp

42

nit: better placed in order, before VPBB1?

43

?

115

nit: better place VPBB0 in order, before R1BB1?

116

nit: better place right after creating R1?

llvm/unittests/Transforms/Vectorize/VPlanTest.cpp

443

ditto

[fhahn]

In D149005#4303649, @Ayal wrote:

Looks good to me, with minor nits.
Worth explaining that Entry is the preheader of the vector loop.

Rebase so this can be applied on current main and addressed the comments, thanks! I updated the comment for VPlan::Entry and plan to land this shortly.

[fhahn]

In D149005#4303649, @Ayal wrote:

Looks good to me, with minor nits.
Worth explaining that Entry is the preheader of the vector loop.

llvm/lib/Transforms/Vectorize/VPlan.h

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   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.
+/// VPBasicBlock.
 class VPlan {
   friend class VPlanPrinter;
   friend class VPSlotTracker;
 
-  /// Hold the single entry to the Hierarchical CFG of the VPlan.
-  VPBlockBase *Entry;
+  /// Hold the single entry to the Hierarchical CFG of the VPlan, i.e. the
+  /// preheader of the vector loop.
+  VPBasicBlock *Entry;
 
   /// Holds the VFs applicable to this VPlan.
   SmallSetVector<ElementCount, 2> VFs;
 
   /// Holds the UFs applicable to this VPlan. If empty, the VPlan is valid for
   /// any UF.
   SmallSetVector<unsigned, 2> UFs;
 
class VPlan {
   /// Indicates whether it is safe use the Value2VPValue mapping or if the
   /// mapping cannot be used any longer, because it is stale.
   bool Value2VPValueEnabled = true;
 
   /// Values used outside the plan.
   MapVector<PHINode *, VPLiveOut *> LiveOuts;
 
 public:
-  VPlan(VPBlockBase *Entry = nullptr) : Entry(Entry) {
+  VPlan(VPBasicBlock *Entry = nullptr) : Entry(Entry) {
     if (Entry)
       Entry->setPlan(this);
   }
 
   ~VPlan();
 
   /// Prepare the plan for execution, setting up the required live-in values.
   void prepareToExecute(Value *TripCount, Value *VectorTripCount,
                         Value *CanonicalIVStartValue, VPTransformState &State,
                         bool IsEpilogueVectorization);
 
   /// Generate the IR code for this VPlan.
   void execute(VPTransformState *State);
 
-  VPBlockBase *getEntry() { return Entry; }
-  const VPBlockBase *getEntry() const { return Entry; }
+  VPBasicBlock *getEntry() { return Entry; }
+  const VPBasicBlock *getEntry() const { return Entry; }
 
-  VPBlockBase *setEntry(VPBlockBase *Block) {
+  VPBasicBlock *setEntry(VPBasicBlock *Block) {
     Entry = Block;
     Block->setPlan(this);
     return Entry;
   }
 
   /// The trip count of the original loop.
   VPValue *getOrCreateTripCount() {
     if (!TripCount)

llvm/lib/Transforms/Vectorize/VPlan.cpp

 
 VPValue *vputils::getOrCreateVPValueForSCEVExpr(VPlan &Plan, const SCEV *Expr,
                                                 ScalarEvolution &SE) {
   if (auto *E = dyn_cast<SCEVConstant>(Expr))
     return Plan.getVPValueOrAddLiveIn(E->getValue());
   if (auto *E = dyn_cast<SCEVUnknown>(Expr))
     return Plan.getVPValueOrAddLiveIn(E->getValue());
 
-  VPBasicBlock *Preheader = Plan.getEntry()->getEntryBasicBlock();
+  VPBasicBlock *Preheader = Plan.getEntry();
   VPExpandSCEVRecipe *Step = new VPExpandSCEVRecipe(Expr, SE);
   Preheader->appendRecipe(Step);
   return Step;
 }

llvm/unittests/Transforms/Vectorize/VPDomTreeTest.cpp

 #include "../lib/Transforms/Vectorize/VPlan.h"
 #include "../lib/Transforms/Vectorize/VPlanDominatorTree.h"
 #include "gtest/gtest.h"
 
 namespace llvm {
 namespace {
 
 TEST(VPDominatorTreeTest, DominanceNoRegionsTest) {
+  //   VPBB0
+  //    |
   //   R1 {
   //     VPBB1
   //     /   \
     // VPBB2  VPBB3
   //    \    /
   //    VPBB4
   //  }
+  VPBasicBlock *VPBB0 = new VPBasicBlock("VPBB0");
   VPBasicBlock *VPBB1 = new VPBasicBlock("VPBB1");
   VPBasicBlock *VPBB2 = new VPBasicBlock("VPBB2");
   VPBasicBlock *VPBB3 = new VPBasicBlock("VPBB3");
   VPBasicBlock *VPBB4 = new VPBasicBlock("VPBB4");
   VPRegionBlock *R1 = new VPRegionBlock(VPBB1, VPBB4);
   VPBB2->setParent(R1);
   VPBB3->setParent(R1);
 
+  VPBlockUtils::connectBlocks(VPBB0, R1);
   VPBlockUtils::connectBlocks(VPBB1, VPBB2);
   VPBlockUtils::connectBlocks(VPBB1, VPBB3);
   VPBlockUtils::connectBlocks(VPBB2, VPBB4);
   VPBlockUtils::connectBlocks(VPBB3, VPBB4);
 
   VPlan Plan;
-  Plan.setEntry(R1);
+  Plan.setEntry(VPBB0);
   VPDominatorTree VPDT;
   VPDT.recalculate(Plan);
 
   EXPECT_TRUE(VPDT.dominates(VPBB1, VPBB4));
   EXPECT_FALSE(VPDT.dominates(VPBB4, VPBB1));
 
   EXPECT_TRUE(VPDT.dominates(VPBB1, VPBB2));
   EXPECT_FALSE(VPDT.dominates(VPBB2, VPBB1));
for (VPBlockBase *C : ExpectedChildren)
     ExpectedNodes.push_back(VPDT.getNode(C));
 
   EXPECT_EQ(Children, ExpectedNodes);
 }
 
 TEST(VPDominatorTreeTest, DominanceRegionsTest) {
   {
     // 2 consecutive regions.
+    // VPBB0
+    //  |
     // R1 {
     //     \
     //     R1BB1     _
     //    /     \   / \
     //  R1BB2   R1BB3  |
     //    \      /  \_/
     //     R1BB4
     //  }
     //   |
     // R2 {
     //   \
     //    R2BB1
     //      |
     //    R2BB2
     // }
     //
+    VPBasicBlock *VPBB0 = new VPBasicBlock("VPBB0");
     VPBasicBlock *R1BB1 = new VPBasicBlock();
     VPBasicBlock *R1BB2 = new VPBasicBlock();
     VPBasicBlock *R1BB3 = new VPBasicBlock();
     VPBasicBlock *R1BB4 = new VPBasicBlock();
     VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB4, "R1");
     R1BB2->setParent(R1);
     R1BB3->setParent(R1);
+    VPBlockUtils::connectBlocks(VPBB0, R1);
     VPBlockUtils::connectBlocks(R1BB1, R1BB2);
     VPBlockUtils::connectBlocks(R1BB1, R1BB3);
     VPBlockUtils::connectBlocks(R1BB2, R1BB4);
     VPBlockUtils::connectBlocks(R1BB3, R1BB4);
     // Cycle.
     VPBlockUtils::connectBlocks(R1BB3, R1BB3);
 
     VPBasicBlock *R2BB1 = new VPBasicBlock();
     VPBasicBlock *R2BB2 = new VPBasicBlock();
     VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R2BB2, "R2");
     VPBlockUtils::connectBlocks(R2BB1, R2BB2);
     VPBlockUtils::connectBlocks(R1, R2);
 
     VPlan Plan;
-    Plan.setEntry(R1);
+    Plan.setEntry(VPBB0);
     VPDominatorTree VPDT;
     VPDT.recalculate(Plan);
 
     checkDomChildren(VPDT, R1, {R1BB1});
     checkDomChildren(VPDT, R1BB1, {R1BB2, R1BB4, R1BB3});
     checkDomChildren(VPDT, R1BB2, {});
     checkDomChildren(VPDT, R1BB3, {});
     checkDomChildren(VPDT, R1BB4, {R2});

llvm/unittests/Transforms/Vectorize/VPlanTest.cpp

TEST(VPBasicBlockTest, getPlan) {
 
     EXPECT_EQ(&Plan, VPBB1->getPlan());
     EXPECT_EQ(&Plan, VPBB2->getPlan());
     EXPECT_EQ(&Plan, VPBB3->getPlan());
     EXPECT_EQ(&Plan, VPBB4->getPlan());
   }
 
   {
-    // Region block is entry into VPlan.
-    VPBasicBlock *R1BB1 = new VPBasicBlock();
-    VPBasicBlock *R1BB2 = new VPBasicBlock();
-    VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB2, "R1");
-    VPBlockUtils::connectBlocks(R1BB1, R1BB2);
-
-    VPlan Plan;
-    Plan.setEntry(R1);
-    EXPECT_EQ(&Plan, R1->getPlan());
-    EXPECT_EQ(&Plan, R1BB1->getPlan());
-    EXPECT_EQ(&Plan, R1BB2->getPlan());
-  }
-
-  {
     // VPBasicBlock is the entry into the VPlan, followed by a region.
     VPBasicBlock *R1BB1 = new VPBasicBlock();
     VPBasicBlock *R1BB2 = new VPBasicBlock();
     VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB2, "R1");
     VPBlockUtils::connectBlocks(R1BB1, R1BB2);
 
     VPBasicBlock *VPBB1 = new VPBasicBlock();
     VPBlockUtils::connectBlocks(VPBB1, R1);
TEST(VPBasicBlockTest, TraversingIteratorTest) {
 
     // Use Plan to properly clean up created blocks.
     VPlan Plan;
     Plan.setEntry(VPBB1);
   }
 
   {
     // 2 consecutive regions.
+    // VPBB0
+    //  |
     // R1 {
     //     \
     //     R1BB1
     //    /     \   |--|
     //  R1BB2   R1BB3 -|
     //    \      /
     //     R1BB4
     //  }
     //   |
     // R2 {
     //   \
     //    R2BB1
     //      |
     //    R2BB2
     //
+    VPBasicBlock *VPBB0 = new VPBasicBlock("VPBB0");
     VPBasicBlock *R1BB1 = new VPBasicBlock();
     VPBasicBlock *R1BB2 = new VPBasicBlock();
     VPBasicBlock *R1BB3 = new VPBasicBlock();
     VPBasicBlock *R1BB4 = new VPBasicBlock();
     VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB4, "R1");
     R1BB2->setParent(R1);
     R1BB3->setParent(R1);
+    VPBlockUtils::connectBlocks(VPBB0, R1);
     VPBlockUtils::connectBlocks(R1BB1, R1BB2);
     VPBlockUtils::connectBlocks(R1BB1, R1BB3);
     VPBlockUtils::connectBlocks(R1BB2, R1BB4);
     VPBlockUtils::connectBlocks(R1BB3, R1BB4);
     // Cycle.
     VPBlockUtils::connectBlocks(R1BB3, R1BB3);
 
     VPBasicBlock *R2BB1 = new VPBasicBlock();
TEST(VPBasicBlockTest, TraversingIteratorTest) {
     EXPECT_EQ(R1BB4, FromIterator[3]);
     EXPECT_EQ(R1BB2, FromIterator[4]);
     EXPECT_EQ(R1BB3, FromIterator[5]);
     EXPECT_EQ(R1BB1, FromIterator[6]);
     EXPECT_EQ(R1, FromIterator[7]);
 
     // Use Plan to properly clean up created blocks.
     VPlan Plan;
-    Plan.setEntry(R1);
+    Plan.setEntry(VPBB0);
   }
 
   {
     // 2 nested regions.
     //  VPBB1
     //    |
     //  R1 {
     //         R1BB1
     //       /        \