!fixup address comments, thanks

Author: fhahn

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -936,9 +936,9 @@ class VPInstruction : public VPRecipeWithIRFlags,
     BranchOnCount,
     BranchOnCond,
     Broadcast,
-    /// Creates a struct of fixed-width vectors containing all operands. The
-    /// number of operands
-    /// matches the number of fields in the struct.
+    /// Given operands of (the same) struct type, creates a struct of fixed-
+    /// width vectors each containing a struct field of all operands. The
+    /// number of operands matches the element count of every vector.
     BuildStructVector,
     /// Creates a fixed-width vector containing all operands. The number of
     /// operands matches the vector element count.

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -610,15 +610,12 @@ Value *VPInstruction::generate(VPTransformState &State) {
   }
   case VPInstruction::BuildStructVector: {
     // For struct types, we need to build a new 'wide' struct type, where each
-    // element is widened.
+    // element is widened, i.e. we crate a struct of vectors .
     auto *StructTy =
         cast<StructType>(State.TypeAnalysis.inferScalarType(getOperand(0)));
-    auto NumOfElements = ElementCount::getFixed(getNumOperands());
-    Value *Res = PoisonValue::get(toVectorizedTy(StructTy, NumOfElements));
-    assert(NumOfElements.getKnownMinValue() == StructTy->getNumElements() &&
-           "number of operands must match number of elements in StructTy");
+    Value *Res = PoisonValue::get(toVectorizedTy(StructTy, State.VF));
     for (const auto &[Idx, Op] : enumerate(operands())) {
-      for (unsigned I = 0; I != NumOfElements.getKnownMinValue(); I++) {
+      for (unsigned I = 0; I != StructTy->getNumElements(); I++) {
         Value *ScalarValue = Builder.CreateExtractValue(State.get(Op, true), I);
         Value *VectorValue = Builder.CreateExtractValue(Res, I);
         VectorValue =
@@ -2688,6 +2685,7 @@ void VPReplicateRecipe::execute(VPTransformState &State) {
     }
     State.set(this, State.packScalarIntoVectorizedValue(this, WideValue,
                                                         *State.Lane));
+  }
 }
 
 bool VPReplicateRecipe::shouldPack() const {

llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp

@@ -1148,6 +1148,7 @@ static void simplifyRecipe(VPRecipeBase &R, VPTypeAnalysis &TypeInfo) {
         BuildVector->getOperand(BuildVector->getNumOperands() - 1));
     return;
   }
+
   // Look through ExtractPenultimateElement (BuildVector ....).
   if (match(&R, m_VPInstruction<VPInstruction::ExtractPenultimateElement>(
                     m_BuildVector()))) {

llvm/lib/Transforms/Vectorize/VPlanTransforms.h

@@ -99,9 +99,10 @@ struct VPlanTransforms {
   /// Explicitly unroll \p Plan by \p UF.
   static void unrollByUF(VPlan &Plan, unsigned UF, LLVMContext &Ctx);
 
-  /// Replace replicating VPReplicateRecipes outside replicate regions in \p
-  /// Plan with \p VF single-scalar recipes.
-  /// TODO: Also unroll VPReplicateRegions by VF.
+  /// Replace each VPReplicateRecipe outside on any replicate region in \p Plan
+  /// with \p VF single-scalar recipes.
+  /// TODO: Also replicate VPReplicateRecipes inside replicate regions, thereby
+  /// dissolving the latter.
   static void replicateByVF(VPlan &Plan, ElementCount VF);
 
   /// Optimize \p Plan based on \p BestVF and \p BestUF. This may restrict the

llvm/lib/Transforms/Vectorize/VPlanUnroll.cpp

@@ -511,22 +511,25 @@ void VPlanTransforms::replicateByVF(VPlan &Plan, ElementCount VF) {
       for (unsigned I = 0; I != VF.getKnownMinValue(); ++I)
         LaneDefs.push_back(cloneForLane(Plan, Builder, IdxTy, RepR, VPLane(I)));
 
+      if (RepR->getNumUsers() == 0) {
+        RepR->eraseFromParent();
+        continue;
+      }
+
       /// Users that only demand the first lane can use the definition for lane
       /// 0.
       RepR->replaceUsesWithIf(LaneDefs[0], [RepR](VPUser &U, unsigned) {
         return U.onlyFirstLaneUsed(RepR);
       });
 
-      Type *ResTy = RepR->getUnderlyingInstr()->getType();
       // If needed, create a Build(Struct)Vector recipe to insert the scalar
       // lane values into a vector.
-      if (!ResTy->isVoidTy()) {
-        VPValue *VecRes = Builder.createNaryOp(
-            ResTy->isStructTy() ? VPInstruction::BuildStructVector
-                                : VPInstruction::BuildVector,
-            LaneDefs);
-        RepR->replaceAllUsesWith(VecRes);
-      }
+      Type *ResTy = RepR->getUnderlyingInstr()->getType();
+      VPValue *VecRes = Builder.createNaryOp(
+          ResTy->isStructTy() ? VPInstruction::BuildStructVector
+                              : VPInstruction::BuildVector,
+          LaneDefs);
+      RepR->replaceAllUsesWith(VecRes);
       RepR->eraseFromParent();
     }
   }