Add << overload for VPDef and getVFScaleFactor utility function

Author: SamTebbs33

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

@@ -4874,6 +4874,20 @@ void LoopVectorizationCostModel::collectElementTypesForWidening() {
   }
 }
 
+/// Get the VF scaling factor applied to the recipe's output, if the recipe has
+/// one.
+static unsigned getVFScaleFactor(VPRecipeBase *R) {
+  if (isa<VPPartialReductionRecipe, VPReductionPHIRecipe>(R)) {
+    auto *ReductionR = dyn_cast<VPReductionPHIRecipe>(R);
+    auto *PartialReductionR =
+        ReductionR ? nullptr : dyn_cast<VPPartialReductionRecipe>(R);
+    unsigned ScaleFactor = ReductionR ? ReductionR->getVFScaleFactor()
+                                      : PartialReductionR->getVFScaleFactor();
+    return ScaleFactor;
+  }
+  return 1;
+}
+
 /// Estimate the register usage for \p Plan and vectorization factors in \p VFs
 /// by calculating the highest number of values that are live at a single
 /// location as a rough estimate. Returns the register usage for each VF in \p
@@ -5027,22 +5041,13 @@ calculateRegisterUsage(VPlan &Plan, ArrayRef<ElementCount> VFs,
           // even in the scalar case.
           RegUsage[ClassID] += 1;
         } else {
-          // The output from scaled phis and scaled reductions actually have
+          // The output from scaled phis and scaled reductions actually has
           // fewer lanes than the VF.
-          ElementCount VF = VFs[J];
-          if (isa<VPPartialReductionRecipe, VPReductionPHIRecipe>(R)) {
-            auto *ReductionR = dyn_cast<VPReductionPHIRecipe>(R);
-            auto *PartialReductionR =
-                ReductionR ? nullptr : dyn_cast<VPPartialReductionRecipe>(R);
-            unsigned ScaleFactor = ReductionR
-                                       ? ReductionR->getVFScaleFactor()
-                                       : PartialReductionR->getVFScaleFactor();
-            VF = VF.divideCoefficientBy(ScaleFactor);
-          }
+          unsigned ScaleFactor = getVFScaleFactor(R);
+          ElementCount VF = VFs[J].divideCoefficientBy(ScaleFactor);
           LLVM_DEBUG(if (VF != VFs[J]) {
             dbgs() << "LV(REG): Scaled down VF from " << VFs[J] << " to " << VF
-                   << " for ";
-            R->dump();
+                   << " for " << *R << "\n";
           });
 
           for (VPValue *DefV : R->definedValues()) {

llvm/lib/Transforms/Vectorize/VPlan.cpp

@@ -71,6 +71,15 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const VPValue &V) {
   V.print(OS, SlotTracker);
   return OS;
 }
+raw_ostream &llvm::operator<<(raw_ostream &OS, const VPDef &D) {
+  /// If this def has a single value, we can cast it to an instruction and use
+  /// its plan for the slot tracker.
+  if (const VPValue *Val = D.getVPSingleValue())
+    return OS << *Val;
+  VPSlotTracker SlotTracker(nullptr);
+  D.print(OS, "", SlotTracker);
+  return OS;
+}
 #endif
 
 Value *VPLane::getAsRuntimeExpr(IRBuilderBase &Builder,

llvm/lib/Transforms/Vectorize/VPlanSLP.cpp

@@ -516,8 +516,8 @@ VPInstruction *VPlanSlp::buildGraph(ArrayRef<VPValue *> Values) {
   auto *Inst = cast<VPInstruction>(Values[0])->getUnderlyingInstr();
   auto *VPI = new VPInstruction(Opcode, CombinedOperands, Inst->getDebugLoc());
 
-  LLVM_DEBUG(dbgs() << "Create VPInstruction " << *VPI << " "
-                    << *cast<VPInstruction>(Values[0]) << "\n");
+  LLVM_DEBUG(dbgs() << "Create VPInstruction " << cast<VPValue>(*VPI) << " "
+                    << Values[0] << "\n");
   addCombined(Values, VPI);
   return VPI;
 }

llvm/lib/Transforms/Vectorize/VPlanValue.h

@@ -195,6 +195,7 @@ typedef DenseMap<Value *, VPValue *> Value2VPValueTy;
 typedef DenseMap<VPValue *, Value *> VPValue2ValueTy;
 
 raw_ostream &operator<<(raw_ostream &OS, const VPValue &V);
+raw_ostream &operator<<(raw_ostream &OS, const VPDef &D);
 
 /// This class augments VPValue with operands which provide the inverse def-use
 /// edges from VPValue's users to their defs.

llvm/unittests/Transforms/Vectorize/VPlanTest.cpp

@@ -812,7 +812,7 @@ Successor(s): ir-bb<scalar.header>
   {
     std::string I4Dump;
     raw_string_ostream OS(I4Dump);
-    OS << *I4;
+    OS << *cast<VPDef>(I4);
     EXPECT_EQ("EMIT vp<%5> = mul vp<%3>, vp<%2>", I4Dump);
   }
 }