Remove VPSplatRecipe, replace with VPInstruction::Splat

Author: lukel97

llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h

@@ -265,8 +265,8 @@ class VPBuilder {
         FPBinOp ? FPBinOp->getFastMathFlags() : FastMathFlags()));
   }
 
-  VPSplatRecipe *createSplat(VPValue *Val) {
-    return tryInsertInstruction(new VPSplatRecipe(Val));
+  VPInstruction *createSplat(VPValue *Val) {
+    return tryInsertInstruction(new VPInstruction(VPInstruction::Splat, {Val}));
   }
 
   VPStepVectorRecipe *createStepVector(Type *Ty) {

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -880,6 +880,8 @@ class VPInstruction : public VPRecipeWithIRFlags,
     // Extracts the first active lane of a vector, where the first operand is
     // the predicate, and the second operand is the vector to extract.
     ExtractFirstActive,
+    // Splats a scalar value across all lanes.
+    Splat,
   };
 
 private:
@@ -1236,39 +1238,6 @@ class VPScalarCastRecipe : public VPSingleDefRecipe {
   }
 };
 
-/// A for splatting a scalar value to a vector.
-class VPSplatRecipe : public VPSingleDefRecipe {
-public:
-  VPSplatRecipe(VPValue *Op) : VPSingleDefRecipe(VPDef::VPSplatSC, {Op}) {}
-
-  ~VPSplatRecipe() override = default;
-
-  VPSplatRecipe *clone() override { return new VPSplatRecipe(getOperand(0)); }
-
-  VP_CLASSOF_IMPL(VPDef::VPSplatSC)
-
-  void execute(VPTransformState &State) override;
-
-  /// Return the cost of this VPSplatRecipe.
-  InstructionCost computeCost(ElementCount VF,
-                              VPCostContext &Ctx) const override {
-    // TODO: Compute accurate cost after retiring the legacy cost model.
-    return 0;
-  }
-
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  void print(raw_ostream &O, const Twine &Indent,
-             VPSlotTracker &SlotTracker) const override;
-#endif
-
-  /// Returns true if the recipe only uses the first lane of operand \p Op.
-  bool onlyFirstLaneUsed(const VPValue *Op) const override {
-    assert(is_contained(operands(), Op) &&
-           "Op must be an operand of the recipe");
-    return true;
-  }
-};
-
 /// A recipe for generating a step vector.
 class VPStepVectorRecipe : public VPSingleDefRecipe {
   /// Scalar return type of the intrinsic.

llvm/lib/Transforms/Vectorize/VPlanAnalysis.cpp

@@ -96,6 +96,8 @@ Type *VPTypeAnalysis::inferScalarTypeForRecipe(const VPInstruction *R) {
   case VPInstruction::BranchOnCond:
   case VPInstruction::BranchOnCount:
     return Type::getVoidTy(Ctx);
+  case VPInstruction::Splat:
+    return inferScalarType(R->getOperand(0));
   default:
     break;
   }

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -73,7 +73,6 @@ bool VPRecipeBase::mayWriteToMemory() const {
   case VPBranchOnMaskSC:
   case VPScalarIVStepsSC:
   case VPPredInstPHISC:
-  case VPSplatSC:
   case VPStepVectorSC:
     return false;
   case VPBlendSC:
@@ -122,7 +121,6 @@ bool VPRecipeBase::mayReadFromMemory() const {
   case VPScalarIVStepsSC:
   case VPWidenStoreEVLSC:
   case VPWidenStoreSC:
-  case VPSplatSC:
   case VPStepVectorSC:
     return false;
   case VPBlendSC:
@@ -154,7 +152,6 @@ bool VPRecipeBase::mayHaveSideEffects() const {
   case VPPredInstPHISC:
   case VPScalarCastSC:
   case VPReverseVectorPointerSC:
-  case VPSplatSC:
   case VPStepVectorSC:
     return false;
   case VPInstructionSC:
@@ -715,6 +712,10 @@ Value *VPInstruction::generate(VPTransformState &State) {
         Builder.getInt64Ty(), Mask, true, "first.active.lane");
     return Builder.CreateExtractElement(Vec, Ctz, "early.exit.value");
   }
+  case VPInstruction::Splat:
+    return State.Builder.CreateVectorSplat(State.VF,
+                                           State.get(getOperand(0), true));
+
   default:
     llvm_unreachable("Unsupported opcode for instruction");
   }
@@ -826,6 +827,7 @@ bool VPInstruction::opcodeMayReadOrWriteFromMemory() const {
   case VPInstruction::LogicalAnd:
   case VPInstruction::Not:
   case VPInstruction::PtrAdd:
+  case VPInstruction::Splat:
     return false;
   default:
     return true;
@@ -853,6 +855,7 @@ bool VPInstruction::onlyFirstLaneUsed(const VPValue *Op) const {
   case VPInstruction::BranchOnCount:
   case VPInstruction::BranchOnCond:
   case VPInstruction::ResumePhi:
+  case VPInstruction::Splat:
     return true;
   };
   llvm_unreachable("switch should return");
@@ -944,6 +947,9 @@ void VPInstruction::print(raw_ostream &O, const Twine &Indent,
   case VPInstruction::ExtractFirstActive:
     O << "extract-first-active";
     break;
+  case VPInstruction::Splat:
+    O << "splat";
+    break;
   default:
     O << Instruction::getOpcodeName(getOpcode());
   }
@@ -2319,22 +2325,6 @@ void VPScalarCastRecipe ::print(raw_ostream &O, const Twine &Indent,
 }
 #endif
 
-void VPSplatRecipe::execute(VPTransformState &State) {
-  Value *Splat =
-      State.Builder.CreateVectorSplat(State.VF, State.get(getOperand(0), true));
-  State.set(this, Splat);
-}
-
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-void VPSplatRecipe::print(raw_ostream &O, const Twine &Indent,
-                          VPSlotTracker &SlotTracker) const {
-  O << Indent;
-  printAsOperand(O, SlotTracker);
-  O << " = SPLAT ";
-  printOperands(O, SlotTracker);
-}
-#endif
-
 void VPStepVectorRecipe::execute(VPTransformState &State) {
   VectorType *Ty = VectorType::get(ScalarTy, State.VF);
   State.set(this, State.Builder.CreateStepVector(Ty));

llvm/lib/Transforms/Vectorize/VPlanValue.h

@@ -354,7 +354,6 @@ class VPDef {
     VPWidenSelectSC,
     VPBlendSC,
     VPHistogramSC,
-    VPSplatSC,
     VPStepVectorSC,
     // START: Phi-like recipes. Need to be kept together.
     VPWidenPHISC,