Respond to review comments

* Document range is to VF
* Move private method above
* Merge classof checks
* Use VPBuilder
* Add assertion method

Author: lukel97

llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h

@@ -177,8 +177,11 @@ class VPBuilder {
                               Type *ResultTy,
                               std::optional<FastMathFlags> FMFs = {},
                               DebugLoc DL = {}, const Twine &Name = "") {
-    return tryInsertInstruction(new VPInstructionWithType(
-        Opcode, Operands, ResultTy, FMFs.value_or(FastMathFlags()), DL, Name));
+    if (FMFs)
+      return tryInsertInstruction(new VPInstructionWithType(
+          Opcode, Operands, ResultTy, *FMFs, DL, Name));
+    return tryInsertInstruction(
+        new VPInstructionWithType(Opcode, Operands, ResultTy, DL, Name));
   }
 
   VPInstruction *createOverflowingOp(unsigned Opcode,

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -898,7 +898,7 @@ class VPInstruction : public VPRecipeWithIRFlags,
     /// Scale the first operand (vector step) by the second operand
     /// (scalar-step).  Casts both operands to the result type if needed.
     WideIVStep,
-    // Creates a step vector starting from 0 with a step of 1.
+    // Creates a step vector starting from 0 to VF with a step of 1.
     StepVector,
 
   };
@@ -1065,15 +1065,20 @@ class VPInstructionWithType : public VPInstruction {
       : VPInstruction(Opcode, Operands, FMFs, DL, Name), ResultTy(ResultTy) {}
 
   static inline bool classof(const VPRecipeBase *R) {
-    if (isa<VPInstruction>(R) &&
-        cast<VPInstruction>(R)->getOpcode() == VPInstruction::StepVector)
-      return true;
     // VPInstructionWithType are VPInstructions with specific opcodes requiring
     // type information.
     if (R->isScalarCast())
       return true;
     auto *VPI = dyn_cast<VPInstruction>(R);
-    return VPI && VPI->getOpcode() == VPInstruction::WideIVStep;
+    if (!VPI)
+      return false;
+    switch (VPI->getOpcode()) {
+    case VPInstruction::WideIVStep:
+    case VPInstruction::StepVector:
+      return true;
+    default:
+      return false;
+    }
   }
 
   static inline bool classof(const VPUser *R) {
@@ -1833,6 +1838,8 @@ class VPWidenInductionRecipe : public VPHeaderPHIRecipe {
 class VPWidenIntOrFpInductionRecipe : public VPWidenInductionRecipe {
   TruncInst *Trunc;
 
+  bool isUnrolled() const { return getNumOperands() == 6; }
+
 public:
   VPWidenIntOrFpInductionRecipe(PHINode *IV, VPValue *Start, VPValue *Step,
                                 VPValue *VF, const InductionDescriptor &IndDesc,
@@ -1913,9 +1920,6 @@ class VPWidenIntOrFpInductionRecipe : public VPWidenInductionRecipe {
   VPValue *getLastUnrolledPartOperand() {
     return isUnrolled() ? getOperand(getNumOperands() - 1) : this;
   }
-
-private:
-  bool isUnrolled() const { return getNumOperands() == 6; }
 };
 
 class VPWidenPointerInductionRecipe : public VPWidenInductionRecipe,

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -1966,7 +1966,8 @@ void VPWidenIntOrFpInductionRecipe::execute(VPTransformState &State) {
 
   Value *SplatStart = Builder.CreateVectorSplat(State.VF, Start);
   assert(cast<VPInstruction>(getStepVector())->getOpcode() ==
-         VPInstruction::StepVector);
+             VPInstruction::StepVector &&
+         "step vector operand must be a StepVector");
   Value *SteppedStart =
       ::getStepVector(SplatStart, Step, State.get(getStepVector()),
                       ID.getInductionOpcode(), State.VF, State.Builder);

llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp

@@ -2419,10 +2419,10 @@ void VPlanTransforms::convertToConcreteRecipes(VPlan &Plan,
           Ty = Trunc->getType();
         if (Ty->isFloatingPointTy())
           Ty = IntegerType::get(Ty->getContext(), Ty->getScalarSizeInBits());
-        VPInstruction *StepVector = new VPInstructionWithType(
-            VPInstruction::StepVector, {}, Ty, R.getDebugLoc());
 
-        Plan.getVectorPreheader()->appendRecipe(StepVector);
+        VPBuilder Builder(Plan.getVectorPreheader());
+        VPInstruction *StepVector = Builder.createNaryOp(
+            VPInstruction::StepVector, {}, Ty, {}, R.getDebugLoc());
         IVR->setStepVector(StepVector);
         continue;
       }