[VPlan] Use VPPhiAccessors for VPIRPhi.

Author: fhahn

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -1730,7 +1730,8 @@ class VPVectorPointerRecipe : public VPRecipeWithIRFlags,
 ///  * VPWidenPointerInductionRecipe: Generate vector and scalar values for a
 ///    pointer induction. Produces either a vector PHI per-part or scalar values
 ///    per-lane based on the canonical induction.
-class VPHeaderPHIRecipe : public VPSingleDefRecipe {
+class VPHeaderPHIRecipe : public VPSingleDefRecipe,
+                          public VPPhiAccessors<VPHeaderPHIRecipe> {
 protected:
   VPHeaderPHIRecipe(unsigned char VPDefID, Instruction *UnderlyingInstr,
                     VPValue *Start = nullptr, DebugLoc DL = {})
@@ -2616,7 +2617,8 @@ class VPBranchOnMaskRecipe : public VPRecipeBase {
 /// order to merge values that are set under such a branch and feed their uses.
 /// The phi nodes can be scalar or vector depending on the users of the value.
 /// This recipe works in concert with VPBranchOnMaskRecipe.
-class VPPredInstPHIRecipe : public VPSingleDefRecipe {
+class VPPredInstPHIRecipe : public VPSingleDefRecipe,
+                            public VPPhiAccessors<VPPredInstPHIRecipe> {
 public:
   /// Construct a VPPredInstPHIRecipe given \p PredInst whose value needs a phi
   /// nodes after merging back from a Branch-on-Mask.

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -1745,6 +1745,12 @@ void VPWidenCastRecipe::print(raw_ostream &O, const Twine &Indent,
 }
 #endif
 
+template <>
+const VPBasicBlock *
+VPPhiAccessors<VPHeaderPHIRecipe>::getIncomingBlock(unsigned Idx) const {
+  return getIncomingBlockForRecipe(getAsRecipe(), Idx);
+}
+
 InstructionCost VPHeaderPHIRecipe::computeCost(ElementCount VF,
                                                VPCostContext &Ctx) const {
   return Ctx.TTI.getCFInstrCost(Instruction::PHI, Ctx.CostKind);
@@ -2537,6 +2543,14 @@ InstructionCost VPBranchOnMaskRecipe::computeCost(ElementCount VF,
   // now.
   return 0;
 }
+template <>
+const VPBasicBlock *
+VPPhiAccessors<VPPredInstPHIRecipe>::getIncomingBlock(unsigned Idx) const {
+  assert(Idx == 0 && "Only one incoming block available");
+  // VPPredInstPHIRecipe only has a single incoming value, which corresponds to
+  // the second predecessor.
+  return getIncomingBlockForRecipe(getAsRecipe(), 1);
+}
 
 void VPPredInstPHIRecipe::execute(VPTransformState &State) {
   State.setDebugLocFrom(getDebugLoc());

llvm/lib/Transforms/Vectorize/VPlanVerifier.cpp

@@ -175,8 +175,7 @@ bool VPlanVerifier::verifyVPBasicBlock(const VPBasicBlock *VPBB) {
   if (!verifyPhiRecipes(VPBB))
     return false;
 
-  // Verify that defs in VPBB dominate all their uses. The current
-  // implementation is still incomplete.
+  // Verify that defs in VPBB dominate all their uses.
   DenseMap<const VPRecipeBase *, unsigned> RecipeNumbering;
   unsigned Cnt = 0;
   for (const VPRecipeBase &R : *VPBB)
@@ -203,25 +202,42 @@ bool VPlanVerifier::verifyVPBasicBlock(const VPBasicBlock *VPBB) {
 
       for (const VPUser *U : V->users()) {
         auto *UI = cast<VPRecipeBase>(U);
-        // TODO: check dominance of incoming values for phis properly.
-        if (!UI || isa<VPHeaderPHIRecipe, VPWidenPHIRecipe, VPPredInstPHIRecipe,
-                       VPIRPhi>(UI))
-          continue;
-
-        // If the user is in the same block, check it comes after R in the
-        // block.
-        if (UI->getParent() == VPBB) {
-          if (RecipeNumbering[UI] < RecipeNumbering[&R]) {
-            errs() << "Use before def!\n";
-            return false;
-          }
-          continue;
-        }
-
-        if (!VPDT.dominates(VPBB, UI->getParent())) {
-          errs() << "Use before def!\n";
+        const VPBlockBase *UserVPBB = UI->getParent();
+        bool Ok =
+            TypeSwitch<VPRecipeBase *, bool>(
+                const_cast<VPRecipeBase *>(cast<VPRecipeBase>(U)))
+                .Case<VPWidenPHIRecipe, VPHeaderPHIRecipe, VPPredInstPHIRecipe,
+                      VPIRPhi>([&](auto *R) {
+                  for (const auto &[IncVPV, IncVPBB] :
+                       R->incoming_values_and_blocks()) {
+                    if (IncVPV != V)
+                      continue;
+                    if (IncVPBB != VPBB && !VPDT.dominates(VPBB, IncVPBB)) {
+                      errs() << "Use before def!\n";
+                      return false;
+                    }
+                  }
+                  return true;
+                })
+                .Default([&](const VPUser *U) {
+                  // If the user is in the same block, check it comes after R in
+                  // the block.
+                  if (UserVPBB == VPBB) {
+                    if (RecipeNumbering[UI] < RecipeNumbering[&R]) {
+                      errs() << "Use before def!\n";
+                      return false;
+                    }
+                    return true;
+                  }
+
+                  if (!VPDT.dominates(VPBB, UserVPBB)) {
+                    errs() << "Use before def!\n";
+                    return false;
+                  }
+                  return true;
+                });
+        if (!Ok)
           return false;
-        }
       }
     }
     if (const auto *EVL = dyn_cast<VPInstruction>(&R)) {