[VPlanRecipeBase] Add insertBefore helper.

[dcaballe]

Thanks for the patch! LGTM.
I think it's ok to kept these utilities in the VPRecipeBase class for now. Eventually, if we add too many, we may want to move them to a VPInstructionUtils, same as what we are doing for VPBlockBase.

lib/Transforms/Vectorize/VPlan.h

560

instruction -> recipe?

[fhahn]

Added Cmake changes to add VPlanTest.cpp, so we do not depend on any other patches. Also change instruction->recipe in comment.

lib/Transforms/Vectorize/VPlan.h

public:
   virtual void execute(struct VPTransformState &State) = 0;
 
   /// Each recipe prints itself.
   virtual void print(raw_ostream &O, const Twine &Indent) const = 0;
 
   /// Unlink this recipe from its current VPBasicBlock and insert it into
   /// the VPBasicBlock that MovePos lives in, right after MovePos.
   void moveAfter(VPRecipeBase *MovePos);
+
+  /// Insert an unlinked instruction into a basic block immediately before
+  /// the specified instruction.
+  void insertBefore(VPRecipeBase *InsertPos);
 };
 
 /// This is a concrete Recipe that models a single VPlan-level instruction.
 /// While as any Recipe it may generate a sequence of IR instructions when
 /// executed, these instructions would always form a single-def expression as
 /// the VPInstruction is also a single def-use vertex.
 class VPInstruction : public VPUser, public VPRecipeBase {
 public:

lib/Transforms/Vectorize/VPlan.cpp

 }
 
 void VPRecipeBase::moveAfter(VPRecipeBase *InsertPos) {
   InsertPos->getParent()->getRecipeList().splice(
       std::next(InsertPos->getIterator()), getParent()->getRecipeList(),
       getIterator());
 }
 
+void VPRecipeBase::insertBefore(VPRecipeBase *InsertPos) {
+  InsertPos->getParent()->getRecipeList().insert(InsertPos->getIterator(),
+                                                 this);
+}
+
 void VPInstruction::generateInstruction(VPTransformState &State,
                                         unsigned Part) {
   IRBuilder<> &Builder = State.Builder;
 
   if (Instruction::isBinaryOp(getOpcode())) {
     Value *A = State.get(getOperand(0), Part);
     Value *B = State.get(getOperand(1), Part);
     Value *V = Builder.CreateBinOp((Instruction::BinaryOps)getOpcode(), A, B);

unittests/Transforms/Vectorize/VPlanTest.cpp

TEST(VPInstructionTest, moveAfter) {
   VPBB2.appendRecipe(I5);
 
   I3->moveAfter(I4);
 
   CHECK_ITERATOR(VPBB1, I2, I1);
   CHECK_ITERATOR(VPBB2, I4, I3, I5);
 }
 
+TEST(VPInstructionTest, insertBefore) {
+  VPInstruction *I1 = new VPInstruction(0, {});
+  VPInstruction *I2 = new VPInstruction(1, {});
+  VPInstruction *I3 = new VPInstruction(2, {});
+
+  VPBasicBlock VPBB1;
+  VPBB1.appendRecipe(I1);
+
+  I2->insertBefore(I1);
+  CHECK_ITERATOR(VPBB1, I2, I1);
+
+  I3->insertBefore(I2);
+  CHECK_ITERATOR(VPBB1, I3, I2, I1);
+}
+
 TEST(VPInstructionTest, sinkInstructions) {
   // Create some dummy instructions, we need those for the SinkAfter mapping.
   LLVMContext Context;
   Value *V = new Argument(Type::getInt32Ty(Context));
   Instruction *I1 = BinaryOperator::Create(Instruction::Add, V, V);
   Instruction *I2 = BinaryOperator::Create(Instruction::Add, I1, V);
   Instruction *I3 = BinaryOperator::Create(Instruction::Add, I2, V);
   Instruction *I4 = BinaryOperator::Create(Instruction::Add, I3, V);