[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

40

nit: better placed in order, before VPBB1?

41

?

113

nit: better place VPBB0 in order, before R1BB1?

114

nit: better place right after creating R1?

llvm/unittests/Transforms/Vectorize/VPlanTest.cpp

441

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;
+  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 {
   MapVector<PHINode *, VPLiveOut *> LiveOuts;
 
   /// Mapping from SCEVs to the VPValues representing their expansions.
   /// NOTE: This mapping is temporary and will be removed once all users have
   /// been modeled in VPlan directly.
   DenseMap<const SCEV *, VPValue *> SCEVToExpansion;
 
 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

if (auto *Expanded = Plan.getSCEVExpansion(Expr))
     return Expanded;
   VPValue *Expanded = nullptr;
   if (auto *E = dyn_cast<SCEVConstant>(Expr))
     Expanded = Plan.getVPValueOrAddLiveIn(E->getValue());
   else if (auto *E = dyn_cast<SCEVUnknown>(Expr))
     Expanded = Plan.getVPValueOrAddLiveIn(E->getValue());
   else {
 
-    VPBasicBlock *Preheader = Plan.getEntry()->getEntryBasicBlock();
+    VPBasicBlock *Preheader = Plan.getEntry();
     Expanded = new VPExpandSCEVRecipe(Expr, SE);
     Preheader->appendRecipe(Expanded->getDefiningRecipe());
   }
   Plan.addSCEVExpansion(Expr, Expanded);
   return Expanded;
 }

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 *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(VPBB1, VPBB2);
   VPBlockUtils::connectBlocks(VPBB1, VPBB3);
   VPBlockUtils::connectBlocks(VPBB2, VPBB4);
   VPBlockUtils::connectBlocks(VPBB3, VPBB4);
 
+  VPBasicBlock *VPBB0 = new VPBasicBlock("VPBB0");
+  VPBlockUtils::connectBlocks(VPBB0, VPBB0);
   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
     //  }
TEST(VPDominatorTreeTest, DominanceRegionsTest) {
     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);
 
+    VPBasicBlock *VPBB0 = new VPBasicBlock("VPBB0");
+    VPBlockUtils::connectBlocks(VPBB0, R1);
     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
     //  }
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);
+    VPBasicBlock *VPBB0 = new VPBasicBlock("VPBB0");
+    VPBlockUtils::connectBlocks(VPBB0, R1);
+    Plan.setEntry(VPBB0);
   }
 
   {
     // 2 nested regions.
     //  VPBB1
     //    |
     //  R1 {
     //         R1BB1