diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp index 1975df3cacbca..f38db39db9cff 100644 --- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -2454,7 +2454,7 @@ static void introduceCheckBlockInVPlan(VPlan &Plan, BasicBlock *CheckIRBB) { assert(PreVectorPH->getNumSuccessors() == 2 && "Expected 2 successors"); assert(PreVectorPH->getSuccessors()[0] == ScalarPH && "Unexpected successor"); - VPIRBasicBlock *CheckVPIRBB = VPIRBasicBlock::fromBasicBlock(CheckIRBB); + VPIRBasicBlock *CheckVPIRBB = Plan.createVPIRBasicBlock(CheckIRBB); VPBlockUtils::insertOnEdge(PreVectorPH, VectorPH, CheckVPIRBB); PreVectorPH = CheckVPIRBB; } @@ -8084,11 +8084,11 @@ EpilogueVectorizerEpilogueLoop::emitMinimumVectorEpilogueIterCountCheck( // A new entry block has been created for the epilogue VPlan. Hook it in, as // otherwise we would try to modify the entry to the main vector loop. - VPIRBasicBlock *NewEntry = VPIRBasicBlock::fromBasicBlock(Insert); + VPIRBasicBlock *NewEntry = Plan.createVPIRBasicBlock(Insert); VPBasicBlock *OldEntry = Plan.getEntry(); VPBlockUtils::reassociateBlocks(OldEntry, NewEntry); Plan.setEntry(NewEntry); - delete OldEntry; + // OldEntry is now dead and will be cleaned up when the plan gets destroyed. introduceCheckBlockInVPlan(Plan, Insert); return Insert; @@ -9289,7 +9289,7 @@ LoopVectorizationPlanner::tryToBuildVPlanWithVPRecipes(VFRange &Range) { VPBB->appendRecipe(Recipe); } - VPBlockUtils::insertBlockAfter(new VPBasicBlock(), VPBB); + VPBlockUtils::insertBlockAfter(Plan->createVPBasicBlock(""), VPBB); VPBB = cast(VPBB->getSingleSuccessor()); } diff --git a/llvm/lib/Transforms/Vectorize/VPlan.cpp b/llvm/lib/Transforms/Vectorize/VPlan.cpp index 9a082921d4f7f..82a42b29c6a7d 100644 --- a/llvm/lib/Transforms/Vectorize/VPlan.cpp +++ b/llvm/lib/Transforms/Vectorize/VPlan.cpp @@ -205,11 +205,6 @@ VPBlockBase *VPBlockBase::getEnclosingBlockWithPredecessors() { return Parent->getEnclosingBlockWithPredecessors(); } -void VPBlockBase::deleteCFG(VPBlockBase *Entry) { - for (VPBlockBase *Block : to_vector(vp_depth_first_shallow(Entry))) - delete Block; -} - VPBasicBlock::iterator VPBasicBlock::getFirstNonPhi() { iterator It = begin(); while (It != end() && It->isPhi()) @@ -474,6 +469,13 @@ void VPIRBasicBlock::execute(VPTransformState *State) { connectToPredecessors(State->CFG); } +VPIRBasicBlock *VPIRBasicBlock::clone() { + auto *NewBlock = getPlan()->createEmptyVPIRBasicBlock(IRBB); + for (VPRecipeBase &R : Recipes) + NewBlock->appendRecipe(R.clone()); + return NewBlock; +} + void VPBasicBlock::execute(VPTransformState *State) { bool Replica = bool(State->Lane); BasicBlock *NewBB = State->CFG.PrevBB; // Reuse it if possible. @@ -513,14 +515,11 @@ void VPBasicBlock::execute(VPTransformState *State) { executeRecipes(State, NewBB); } -void VPBasicBlock::dropAllReferences(VPValue *NewValue) { - for (VPRecipeBase &R : Recipes) { - for (auto *Def : R.definedValues()) - Def->replaceAllUsesWith(NewValue); - - for (unsigned I = 0, E = R.getNumOperands(); I != E; I++) - R.setOperand(I, NewValue); - } +VPBasicBlock *VPBasicBlock::clone() { + auto *NewBlock = getPlan()->createVPBasicBlock(getName()); + for (VPRecipeBase &R : *this) + NewBlock->appendRecipe(R.clone()); + return NewBlock; } void VPBasicBlock::executeRecipes(VPTransformState *State, BasicBlock *BB) { @@ -541,7 +540,7 @@ VPBasicBlock *VPBasicBlock::splitAt(iterator SplitAt) { SmallVector Succs(successors()); // Create new empty block after the block to split. - auto *SplitBlock = new VPBasicBlock(getName() + ".split"); + auto *SplitBlock = getPlan()->createVPBasicBlock(getName() + ".split"); VPBlockUtils::insertBlockAfter(SplitBlock, this); // Finally, move the recipes starting at SplitAt to new block. @@ -701,20 +700,13 @@ static std::pair cloneFrom(VPBlockBase *Entry) { VPRegionBlock *VPRegionBlock::clone() { const auto &[NewEntry, NewExiting] = cloneFrom(getEntry()); - auto *NewRegion = - new VPRegionBlock(NewEntry, NewExiting, getName(), isReplicator()); + auto *NewRegion = getPlan()->createVPRegionBlock(NewEntry, NewExiting, + getName(), isReplicator()); for (VPBlockBase *Block : vp_depth_first_shallow(NewEntry)) Block->setParent(NewRegion); return NewRegion; } -void VPRegionBlock::dropAllReferences(VPValue *NewValue) { - for (VPBlockBase *Block : vp_depth_first_shallow(Entry)) - // Drop all references in VPBasicBlocks and replace all uses with - // DummyValue. - Block->dropAllReferences(NewValue); -} - void VPRegionBlock::execute(VPTransformState *State) { ReversePostOrderTraversal> RPOT(Entry); @@ -822,17 +814,26 @@ void VPRegionBlock::print(raw_ostream &O, const Twine &Indent, #endif VPlan::VPlan(Loop *L) { - setEntry(VPIRBasicBlock::fromBasicBlock(L->getLoopPreheader())); - ScalarHeader = VPIRBasicBlock::fromBasicBlock(L->getHeader()); + setEntry(createVPIRBasicBlock(L->getLoopPreheader())); + ScalarHeader = createVPIRBasicBlock(L->getHeader()); } VPlan::~VPlan() { - if (Entry) { - VPValue DummyValue; - for (VPBlockBase *Block : vp_depth_first_shallow(Entry)) - Block->dropAllReferences(&DummyValue); - - VPBlockBase::deleteCFG(Entry); + VPValue DummyValue; + + for (auto *VPB : CreatedBlocks) { + if (auto *VPBB = dyn_cast(VPB)) { + // Replace all operands of recipes and all VPValues defined in VPBB with + // DummyValue so the block can be deleted. + for (VPRecipeBase &R : *VPBB) { + for (auto *Def : R.definedValues()) + Def->replaceAllUsesWith(&DummyValue); + + for (unsigned I = 0, E = R.getNumOperands(); I != E; I++) + R.setOperand(I, &DummyValue); + } + } + delete VPB; } for (VPValue *VPV : VPLiveInsToFree) delete VPV; @@ -840,14 +841,6 @@ VPlan::~VPlan() { delete BackedgeTakenCount; } -VPIRBasicBlock *VPIRBasicBlock::fromBasicBlock(BasicBlock *IRBB) { - auto *VPIRBB = new VPIRBasicBlock(IRBB); - for (Instruction &I : - make_range(IRBB->begin(), IRBB->getTerminator()->getIterator())) - VPIRBB->appendRecipe(new VPIRInstruction(I)); - return VPIRBB; -} - VPlanPtr VPlan::createInitialVPlan(Type *InductionTy, PredicatedScalarEvolution &PSE, bool RequiresScalarEpilogueCheck, @@ -861,7 +854,7 @@ VPlanPtr VPlan::createInitialVPlan(Type *InductionTy, // an epilogue vector loop, the original entry block here will be replaced by // a new VPIRBasicBlock wrapping the entry to the epilogue vector loop after // generating code for the main vector loop. - VPBasicBlock *VecPreheader = new VPBasicBlock("vector.ph"); + VPBasicBlock *VecPreheader = Plan->createVPBasicBlock("vector.ph"); VPBlockUtils::connectBlocks(Plan->getEntry(), VecPreheader); // Create SCEV and VPValue for the trip count. @@ -878,17 +871,17 @@ VPlanPtr VPlan::createInitialVPlan(Type *InductionTy, // Create VPRegionBlock, with empty header and latch blocks, to be filled // during processing later. - VPBasicBlock *HeaderVPBB = new VPBasicBlock("vector.body"); - VPBasicBlock *LatchVPBB = new VPBasicBlock("vector.latch"); + VPBasicBlock *HeaderVPBB = Plan->createVPBasicBlock("vector.body"); + VPBasicBlock *LatchVPBB = Plan->createVPBasicBlock("vector.latch"); VPBlockUtils::insertBlockAfter(LatchVPBB, HeaderVPBB); - auto *TopRegion = new VPRegionBlock(HeaderVPBB, LatchVPBB, "vector loop", - false /*isReplicator*/); + auto *TopRegion = Plan->createVPRegionBlock( + HeaderVPBB, LatchVPBB, "vector loop", false /*isReplicator*/); VPBlockUtils::insertBlockAfter(TopRegion, VecPreheader); - VPBasicBlock *MiddleVPBB = new VPBasicBlock("middle.block"); + VPBasicBlock *MiddleVPBB = Plan->createVPBasicBlock("middle.block"); VPBlockUtils::insertBlockAfter(MiddleVPBB, TopRegion); - VPBasicBlock *ScalarPH = new VPBasicBlock("scalar.ph"); + VPBasicBlock *ScalarPH = Plan->createVPBasicBlock("scalar.ph"); VPBlockUtils::connectBlocks(ScalarPH, ScalarHeader); if (!RequiresScalarEpilogueCheck) { VPBlockUtils::connectBlocks(MiddleVPBB, ScalarPH); @@ -904,7 +897,7 @@ VPlanPtr VPlan::createInitialVPlan(Type *InductionTy, // we unconditionally branch to the scalar preheader. Do nothing. // 3) Otherwise, construct a runtime check. BasicBlock *IRExitBlock = TheLoop->getUniqueLatchExitBlock(); - auto *VPExitBlock = VPIRBasicBlock::fromBasicBlock(IRExitBlock); + auto *VPExitBlock = Plan->createVPIRBasicBlock(IRExitBlock); // The connection order corresponds to the operands of the conditional branch. VPBlockUtils::insertBlockAfter(VPExitBlock, MiddleVPBB); VPBlockUtils::connectBlocks(MiddleVPBB, ScalarPH); @@ -960,15 +953,14 @@ void VPlan::prepareToExecute(Value *TripCountV, Value *VectorTripCountV, /// have a single predecessor, which is rewired to the new VPIRBasicBlock. All /// successors of VPBB, if any, are rewired to the new VPIRBasicBlock. static void replaceVPBBWithIRVPBB(VPBasicBlock *VPBB, BasicBlock *IRBB) { - VPIRBasicBlock *IRVPBB = VPIRBasicBlock::fromBasicBlock(IRBB); + VPIRBasicBlock *IRVPBB = VPBB->getPlan()->createVPIRBasicBlock(IRBB); for (auto &R : make_early_inc_range(*VPBB)) { assert(!R.isPhi() && "Tried to move phi recipe to end of block"); R.moveBefore(*IRVPBB, IRVPBB->end()); } VPBlockUtils::reassociateBlocks(VPBB, IRVPBB); - - delete VPBB; + // VPBB is now dead and will be cleaned up when the plan gets destroyed. } /// Generate the code inside the preheader and body of the vectorized loop. @@ -1217,6 +1209,7 @@ static void remapOperands(VPBlockBase *Entry, VPBlockBase *NewEntry, } VPlan *VPlan::duplicate() { + unsigned NumBlocksBeforeCloning = CreatedBlocks.size(); // Clone blocks. const auto &[NewEntry, __] = cloneFrom(Entry); @@ -1257,9 +1250,32 @@ VPlan *VPlan::duplicate() { assert(Old2NewVPValues.contains(TripCount) && "TripCount must have been added to Old2NewVPValues"); NewPlan->TripCount = Old2NewVPValues[TripCount]; + + // Transfer all cloned blocks (the second half of all current blocks) from + // current to new VPlan. + unsigned NumBlocksAfterCloning = CreatedBlocks.size(); + for (unsigned I : + seq(NumBlocksBeforeCloning, NumBlocksAfterCloning)) + NewPlan->CreatedBlocks.push_back(this->CreatedBlocks[I]); + CreatedBlocks.truncate(NumBlocksBeforeCloning); + return NewPlan; } +VPIRBasicBlock *VPlan::createEmptyVPIRBasicBlock(BasicBlock *IRBB) { + auto *VPIRBB = new VPIRBasicBlock(IRBB); + CreatedBlocks.push_back(VPIRBB); + return VPIRBB; +} + +VPIRBasicBlock *VPlan::createVPIRBasicBlock(BasicBlock *IRBB) { + auto *VPIRBB = createEmptyVPIRBasicBlock(IRBB); + for (Instruction &I : + make_range(IRBB->begin(), IRBB->getTerminator()->getIterator())) + VPIRBB->appendRecipe(new VPIRInstruction(I)); + return VPIRBB; +} + #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) Twine VPlanPrinter::getUID(const VPBlockBase *Block) { diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h index 404202b7f3130..199e0dd7a6bec 100644 --- a/llvm/lib/Transforms/Vectorize/VPlan.h +++ b/llvm/lib/Transforms/Vectorize/VPlan.h @@ -636,9 +636,6 @@ class VPBlockBase { /// Return the cost of the block. virtual InstructionCost cost(ElementCount VF, VPCostContext &Ctx) = 0; - /// Delete all blocks reachable from a given VPBlockBase, inclusive. - static void deleteCFG(VPBlockBase *Entry); - /// Return true if it is legal to hoist instructions into this block. bool isLegalToHoistInto() { // There are currently no constraints that prevent an instruction to be @@ -646,10 +643,6 @@ class VPBlockBase { return true; } - /// Replace all operands of VPUsers in the block with \p NewValue and also - /// replaces all uses of VPValues defined in the block with NewValue. - virtual void dropAllReferences(VPValue *NewValue) = 0; - #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) void printAsOperand(raw_ostream &OS, bool PrintType = false) const { OS << getName(); @@ -3556,8 +3549,6 @@ class VPBasicBlock : public VPBlockBase { return make_range(begin(), getFirstNonPhi()); } - void dropAllReferences(VPValue *NewValue) override; - /// Split current block at \p SplitAt by inserting a new block between the /// current block and its successors and moving all recipes starting at /// SplitAt to the new block. Returns the new block. @@ -3587,12 +3578,7 @@ class VPBasicBlock : public VPBlockBase { /// Clone the current block and it's recipes, without updating the operands of /// the cloned recipes. - VPBasicBlock *clone() override { - auto *NewBlock = new VPBasicBlock(getName()); - for (VPRecipeBase &R : *this) - NewBlock->appendRecipe(R.clone()); - return NewBlock; - } + VPBasicBlock *clone() override; protected: /// Execute the recipes in the IR basic block \p BB. @@ -3628,20 +3614,11 @@ class VPIRBasicBlock : public VPBasicBlock { return V->getVPBlockID() == VPBlockBase::VPIRBasicBlockSC; } - /// Create a VPIRBasicBlock from \p IRBB containing VPIRInstructions for all - /// instructions in \p IRBB, except its terminator which is managed in VPlan. - static VPIRBasicBlock *fromBasicBlock(BasicBlock *IRBB); - /// The method which generates the output IR instructions that correspond to /// this VPBasicBlock, thereby "executing" the VPlan. void execute(VPTransformState *State) override; - VPIRBasicBlock *clone() override { - auto *NewBlock = new VPIRBasicBlock(IRBB); - for (VPRecipeBase &R : Recipes) - NewBlock->appendRecipe(R.clone()); - return NewBlock; - } + VPIRBasicBlock *clone() override; BasicBlock *getIRBasicBlock() const { return IRBB; } }; @@ -3680,13 +3657,7 @@ class VPRegionBlock : public VPBlockBase { : VPBlockBase(VPRegionBlockSC, Name), Entry(nullptr), Exiting(nullptr), IsReplicator(IsReplicator) {} - ~VPRegionBlock() override { - if (Entry) { - VPValue DummyValue; - Entry->dropAllReferences(&DummyValue); - deleteCFG(Entry); - } - } + ~VPRegionBlock() override {} /// Method to support type inquiry through isa, cast, and dyn_cast. static inline bool classof(const VPBlockBase *V) { @@ -3734,8 +3705,6 @@ class VPRegionBlock : public VPBlockBase { // Return the cost of this region. InstructionCost cost(ElementCount VF, VPCostContext &Ctx) override; - void dropAllReferences(VPValue *NewValue) override; - #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) /// Print this VPRegionBlock to \p O (recursively), prefixing all lines with /// \p Indent. \p SlotTracker is used to print unnamed VPValue's using @@ -3812,6 +3781,10 @@ class VPlan { /// been modeled in VPlan directly. DenseMap SCEVToExpansion; + /// Blocks allocated and owned by the VPlan. They will be deleted once the + /// VPlan is destroyed. + SmallVector CreatedBlocks; + /// Construct a VPlan with \p Entry to the plan and with \p ScalarHeader /// wrapping the original header of the scalar loop. VPlan(VPBasicBlock *Entry, VPIRBasicBlock *ScalarHeader) @@ -3830,8 +3803,8 @@ class VPlan { /// Construct a VPlan with a new VPBasicBlock as entry, a VPIRBasicBlock /// wrapping \p ScalarHeaderBB and a trip count of \p TC. VPlan(BasicBlock *ScalarHeaderBB, VPValue *TC) { - setEntry(new VPBasicBlock("preheader")); - ScalarHeader = VPIRBasicBlock::fromBasicBlock(ScalarHeaderBB); + setEntry(createVPBasicBlock("preheader")); + ScalarHeader = createVPIRBasicBlock(ScalarHeaderBB); TripCount = TC; } @@ -4029,6 +4002,49 @@ class VPlan { /// Clone the current VPlan, update all VPValues of the new VPlan and cloned /// recipes to refer to the clones, and return it. VPlan *duplicate(); + + /// Create a new VPBasicBlock with \p Name and containing \p Recipe if + /// present. The returned block is owned by the VPlan and deleted once the + /// VPlan is destroyed. + VPBasicBlock *createVPBasicBlock(const Twine &Name, + VPRecipeBase *Recipe = nullptr) { + auto *VPB = new VPBasicBlock(Name, Recipe); + CreatedBlocks.push_back(VPB); + return VPB; + } + + /// Create a new VPRegionBlock with \p Entry, \p Exiting and \p Name. If \p + /// IsReplicator is true, the region is a replicate region. The returned block + /// is owned by the VPlan and deleted once the VPlan is destroyed. + VPRegionBlock *createVPRegionBlock(VPBlockBase *Entry, VPBlockBase *Exiting, + const std::string &Name = "", + bool IsReplicator = false) { + auto *VPB = new VPRegionBlock(Entry, Exiting, Name, IsReplicator); + CreatedBlocks.push_back(VPB); + return VPB; + } + + /// Create a new VPRegionBlock with \p Name and entry and exiting blocks set + /// to nullptr. If \p IsReplicator is true, the region is a replicate region. + /// The returned block is owned by the VPlan and deleted once the VPlan is + /// destroyed. + VPRegionBlock *createVPRegionBlock(const std::string &Name = "", + bool IsReplicator = false) { + auto *VPB = new VPRegionBlock(Name, IsReplicator); + CreatedBlocks.push_back(VPB); + return VPB; + } + + /// Create a VPIRBasicBlock wrapping \p IRBB, but do not create + /// VPIRInstructions wrapping the instructions in t\p IRBB. The returned + /// block is owned by the VPlan and deleted once the VPlan is destroyed. + VPIRBasicBlock *createEmptyVPIRBasicBlock(BasicBlock *IRBB); + + /// Create a VPIRBasicBlock from \p IRBB containing VPIRInstructions for all + /// instructions in \p IRBB, except its terminator which is managed by the + /// successors of the block in VPlan. The returned block is owned by the VPlan + /// and deleted once the VPlan is destroyed. + VPIRBasicBlock *createVPIRBasicBlock(BasicBlock *IRBB); }; #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) diff --git a/llvm/lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp b/llvm/lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp index 6e633739fcc3d..76ed578424dfe 100644 --- a/llvm/lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp +++ b/llvm/lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp @@ -182,7 +182,7 @@ VPBasicBlock *PlainCFGBuilder::getOrCreateVPBB(BasicBlock *BB) { // Create new VPBB. StringRef Name = isHeaderBB(BB, TheLoop) ? "vector.body" : BB->getName(); LLVM_DEBUG(dbgs() << "Creating VPBasicBlock for " << Name << "\n"); - VPBasicBlock *VPBB = new VPBasicBlock(Name); + VPBasicBlock *VPBB = Plan.createVPBasicBlock(Name); BB2VPBB[BB] = VPBB; // Get or create a region for the loop containing BB. @@ -204,7 +204,7 @@ VPBasicBlock *PlainCFGBuilder::getOrCreateVPBB(BasicBlock *BB) { if (LoopOfBB == TheLoop) { RegionOfVPBB = Plan.getVectorLoopRegion(); } else { - RegionOfVPBB = new VPRegionBlock(Name.str(), false /*isReplicator*/); + RegionOfVPBB = Plan.createVPRegionBlock(Name.str(), false /*isReplicator*/); RegionOfVPBB->setParent(Loop2Region[LoopOfBB->getParentLoop()]); } RegionOfVPBB->setEntry(VPBB); @@ -357,12 +357,10 @@ void PlainCFGBuilder::buildPlainCFG() { BB2VPBB[TheLoop->getHeader()] = VectorHeaderVPBB; VectorHeaderVPBB->clearSuccessors(); VectorLatchVPBB->clearPredecessors(); - if (TheLoop->getHeader() != TheLoop->getLoopLatch()) { + if (TheLoop->getHeader() != TheLoop->getLoopLatch()) BB2VPBB[TheLoop->getLoopLatch()] = VectorLatchVPBB; - } else { + else TheRegion->setExiting(VectorHeaderVPBB); - delete VectorLatchVPBB; - } // 1. Scan the body of the loop in a topological order to visit each basic // block after having visited its predecessor basic blocks. Create a VPBB for diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp index 0b809c2b34df9..1f5acf996a772 100644 --- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp +++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp @@ -217,7 +217,7 @@ static VPBasicBlock *getPredicatedThenBlock(VPRegionBlock *R) { // is connected to a successor replicate region with the same predicate by a // single, empty VPBasicBlock. static bool mergeReplicateRegionsIntoSuccessors(VPlan &Plan) { - SetVector DeletedRegions; + SmallPtrSet TransformedRegions; // Collect replicate regions followed by an empty block, followed by another // replicate region with matching masks to process front. This is to avoid @@ -248,7 +248,7 @@ static bool mergeReplicateRegionsIntoSuccessors(VPlan &Plan) { // Move recipes from Region1 to its successor region, if both are triangles. for (VPRegionBlock *Region1 : WorkList) { - if (DeletedRegions.contains(Region1)) + if (TransformedRegions.contains(Region1)) continue; auto *MiddleBasicBlock = cast(Region1->getSingleSuccessor()); auto *Region2 = cast(MiddleBasicBlock->getSingleSuccessor()); @@ -294,12 +294,10 @@ static bool mergeReplicateRegionsIntoSuccessors(VPlan &Plan) { VPBlockUtils::connectBlocks(Pred, MiddleBasicBlock); } VPBlockUtils::disconnectBlocks(Region1, MiddleBasicBlock); - DeletedRegions.insert(Region1); + TransformedRegions.insert(Region1); } - for (VPRegionBlock *ToDelete : DeletedRegions) - delete ToDelete; - return !DeletedRegions.empty(); + return !TransformedRegions.empty(); } static VPRegionBlock *createReplicateRegion(VPReplicateRecipe *PredRecipe, @@ -310,7 +308,8 @@ static VPRegionBlock *createReplicateRegion(VPReplicateRecipe *PredRecipe, assert(Instr->getParent() && "Predicated instruction not in any basic block"); auto *BlockInMask = PredRecipe->getMask(); auto *BOMRecipe = new VPBranchOnMaskRecipe(BlockInMask); - auto *Entry = new VPBasicBlock(Twine(RegionName) + ".entry", BOMRecipe); + auto *Entry = + Plan.createVPBasicBlock(Twine(RegionName) + ".entry", BOMRecipe); // Replace predicated replicate recipe with a replicate recipe without a // mask but in the replicate region. @@ -318,7 +317,8 @@ static VPRegionBlock *createReplicateRegion(VPReplicateRecipe *PredRecipe, PredRecipe->getUnderlyingInstr(), make_range(PredRecipe->op_begin(), std::prev(PredRecipe->op_end())), PredRecipe->isUniform()); - auto *Pred = new VPBasicBlock(Twine(RegionName) + ".if", RecipeWithoutMask); + auto *Pred = + Plan.createVPBasicBlock(Twine(RegionName) + ".if", RecipeWithoutMask); VPPredInstPHIRecipe *PHIRecipe = nullptr; if (PredRecipe->getNumUsers() != 0) { @@ -328,8 +328,10 @@ static VPRegionBlock *createReplicateRegion(VPReplicateRecipe *PredRecipe, PHIRecipe->setOperand(0, RecipeWithoutMask); } PredRecipe->eraseFromParent(); - auto *Exiting = new VPBasicBlock(Twine(RegionName) + ".continue", PHIRecipe); - VPRegionBlock *Region = new VPRegionBlock(Entry, Exiting, RegionName, true); + auto *Exiting = + Plan.createVPBasicBlock(Twine(RegionName) + ".continue", PHIRecipe); + VPRegionBlock *Region = + Plan.createVPRegionBlock(Entry, Exiting, RegionName, true); // Note: first set Entry as region entry and then connect successors starting // from it in order, to propagate the "parent" of each VPBasicBlock. @@ -396,7 +398,7 @@ static bool mergeBlocksIntoPredecessors(VPlan &Plan) { VPBlockUtils::disconnectBlocks(VPBB, Succ); VPBlockUtils::connectBlocks(PredVPBB, Succ); } - delete VPBB; + // VPBB is now dead and will be cleaned up when the plan gets destroyed. } return !WorkList.empty(); } @@ -1898,7 +1900,7 @@ void VPlanTransforms::handleUncountableEarlyExit( if (OrigLoop->getUniqueExitBlock()) { VPEarlyExitBlock = cast(MiddleVPBB->getSuccessors()[0]); } else { - VPEarlyExitBlock = VPIRBasicBlock::fromBasicBlock( + VPEarlyExitBlock = Plan.createVPIRBasicBlock( !OrigLoop->contains(TrueSucc) ? TrueSucc : FalseSucc); } @@ -1908,7 +1910,7 @@ void VPlanTransforms::handleUncountableEarlyExit( IsEarlyExitTaken = Builder.createNaryOp(VPInstruction::AnyOf, {EarlyExitTakenCond}); - VPBasicBlock *NewMiddle = new VPBasicBlock("middle.split"); + VPBasicBlock *NewMiddle = Plan.createVPBasicBlock("middle.split"); VPBlockUtils::insertOnEdge(LoopRegion, MiddleVPBB, NewMiddle); VPBlockUtils::connectBlocks(NewMiddle, VPEarlyExitBlock); NewMiddle->swapSuccessors(); diff --git a/llvm/unittests/Transforms/Vectorize/VPDomTreeTest.cpp b/llvm/unittests/Transforms/Vectorize/VPDomTreeTest.cpp index 6aa34a5fa431b..55b68f5866dee 100644 --- a/llvm/unittests/Transforms/Vectorize/VPDomTreeTest.cpp +++ b/llvm/unittests/Transforms/Vectorize/VPDomTreeTest.cpp @@ -29,11 +29,11 @@ TEST_F(VPDominatorTreeTest, DominanceNoRegionsTest) { // } VPlan &Plan = getPlan(); VPBasicBlock *VPBB0 = Plan.getEntry(); - VPBasicBlock *VPBB1 = new VPBasicBlock("VPBB1"); - VPBasicBlock *VPBB2 = new VPBasicBlock("VPBB2"); - VPBasicBlock *VPBB3 = new VPBasicBlock("VPBB3"); - VPBasicBlock *VPBB4 = new VPBasicBlock("VPBB4"); - VPRegionBlock *R1 = new VPRegionBlock(VPBB1, VPBB4); + VPBasicBlock *VPBB1 = Plan.createVPBasicBlock("VPBB1"); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock("VPBB2"); + VPBasicBlock *VPBB3 = Plan.createVPBasicBlock("VPBB3"); + VPBasicBlock *VPBB4 = Plan.createVPBasicBlock("VPBB4"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(VPBB1, VPBB4); VPBB2->setParent(R1); VPBB3->setParent(R1); @@ -96,11 +96,11 @@ TEST_F(VPDominatorTreeTest, DominanceRegionsTest) { // VPlan &Plan = getPlan(); VPBasicBlock *VPBB0 = Plan.getEntry(); - VPBasicBlock *R1BB1 = new VPBasicBlock(); - VPBasicBlock *R1BB2 = new VPBasicBlock(); - VPBasicBlock *R1BB3 = new VPBasicBlock(); - VPBasicBlock *R1BB4 = new VPBasicBlock(); - VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB4, "R1"); + VPBasicBlock *R1BB1 = Plan.createVPBasicBlock(""); + VPBasicBlock *R1BB2 = Plan.createVPBasicBlock(""); + VPBasicBlock *R1BB3 = Plan.createVPBasicBlock(""); + VPBasicBlock *R1BB4 = Plan.createVPBasicBlock(""); + VPRegionBlock *R1 = Plan.createVPRegionBlock(R1BB1, R1BB4, "R1"); R1BB2->setParent(R1); R1BB3->setParent(R1); VPBlockUtils::connectBlocks(VPBB0, R1); @@ -111,9 +111,9 @@ TEST_F(VPDominatorTreeTest, DominanceRegionsTest) { // Cycle. VPBlockUtils::connectBlocks(R1BB3, R1BB3); - VPBasicBlock *R2BB1 = new VPBasicBlock(); - VPBasicBlock *R2BB2 = new VPBasicBlock(); - VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R2BB2, "R2"); + VPBasicBlock *R2BB1 = Plan.createVPBasicBlock(""); + VPBasicBlock *R2BB2 = Plan.createVPBasicBlock(""); + VPRegionBlock *R2 = Plan.createVPRegionBlock(R2BB1, R2BB2, "R2"); VPBlockUtils::connectBlocks(R2BB1, R2BB2); VPBlockUtils::connectBlocks(R1, R2); @@ -170,15 +170,15 @@ TEST_F(VPDominatorTreeTest, DominanceRegionsTest) { // VPBB2 // VPlan &Plan = getPlan(); - VPBasicBlock *R1BB1 = new VPBasicBlock("R1BB1"); - VPBasicBlock *R1BB2 = new VPBasicBlock("R1BB2"); - VPBasicBlock *R1BB3 = new VPBasicBlock("R1BB3"); - VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB3, "R1"); - - VPBasicBlock *R2BB1 = new VPBasicBlock("R2BB1"); - VPBasicBlock *R2BB2 = new VPBasicBlock("R2BB2"); - VPBasicBlock *R2BB3 = new VPBasicBlock("R2BB3"); - VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R2BB3, "R2"); + VPBasicBlock *R1BB1 = Plan.createVPBasicBlock("R1BB1"); + VPBasicBlock *R1BB2 = Plan.createVPBasicBlock("R1BB2"); + VPBasicBlock *R1BB3 = Plan.createVPBasicBlock("R1BB3"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(R1BB1, R1BB3, "R1"); + + VPBasicBlock *R2BB1 = Plan.createVPBasicBlock("R2BB1"); + VPBasicBlock *R2BB2 = Plan.createVPBasicBlock("R2BB2"); + VPBasicBlock *R2BB3 = Plan.createVPBasicBlock("R2BB#"); + VPRegionBlock *R2 = Plan.createVPRegionBlock(R2BB1, R2BB3, "R2"); R2BB2->setParent(R2); VPBlockUtils::connectBlocks(R2BB1, R2BB2); VPBlockUtils::connectBlocks(R2BB2, R2BB1); @@ -193,7 +193,7 @@ TEST_F(VPDominatorTreeTest, DominanceRegionsTest) { VPBasicBlock *VPBB1 = Plan.getEntry(); VPBlockUtils::connectBlocks(VPBB1, R1); - VPBasicBlock *VPBB2 = new VPBasicBlock("VPBB2"); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock("VPBB2"); VPBlockUtils::connectBlocks(R1, VPBB2); VPBlockUtils::connectBlocks(VPBB2, Plan.getScalarHeader()); diff --git a/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp index 2ab55f64a2073..5bcc2b8eb2e22 100644 --- a/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp +++ b/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp @@ -245,9 +245,9 @@ TEST_F(VPBasicBlockTest, getPlan) { { VPlan &Plan = getPlan(); VPBasicBlock *VPBB1 = Plan.getEntry(); - VPBasicBlock *VPBB2 = new VPBasicBlock(); - VPBasicBlock *VPBB3 = new VPBasicBlock(); - VPBasicBlock *VPBB4 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); + VPBasicBlock *VPBB3 = Plan.createVPBasicBlock(""); + VPBasicBlock *VPBB4 = Plan.createVPBasicBlock(""); // VPBB1 // / \ @@ -270,9 +270,9 @@ TEST_F(VPBasicBlockTest, getPlan) { VPlan &Plan = getPlan(); VPBasicBlock *VPBB1 = Plan.getEntry(); // VPBasicBlock is the entry into the VPlan, followed by a region. - VPBasicBlock *R1BB1 = new VPBasicBlock(); - VPBasicBlock *R1BB2 = new VPBasicBlock(); - VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB2, "R1"); + VPBasicBlock *R1BB1 = Plan.createVPBasicBlock(""); + VPBasicBlock *R1BB2 = Plan.createVPBasicBlock(""); + VPRegionBlock *R1 = Plan.createVPRegionBlock(R1BB1, R1BB2, "R1"); VPBlockUtils::connectBlocks(R1BB1, R1BB2); VPBlockUtils::connectBlocks(VPBB1, R1); @@ -287,21 +287,21 @@ TEST_F(VPBasicBlockTest, getPlan) { { VPlan &Plan = getPlan(); - VPBasicBlock *R1BB1 = new VPBasicBlock(); - VPBasicBlock *R1BB2 = new VPBasicBlock(); - VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB2, "R1"); + VPBasicBlock *R1BB1 = Plan.createVPBasicBlock(""); + VPBasicBlock *R1BB2 = Plan.createVPBasicBlock(""); + VPRegionBlock *R1 = Plan.createVPRegionBlock(R1BB1, R1BB2, "R1"); VPBlockUtils::connectBlocks(R1BB1, R1BB2); - VPBasicBlock *R2BB1 = new VPBasicBlock(); - VPBasicBlock *R2BB2 = new VPBasicBlock(); - VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R2BB2, "R2"); + VPBasicBlock *R2BB1 = Plan.createVPBasicBlock(""); + VPBasicBlock *R2BB2 = Plan.createVPBasicBlock(""); + VPRegionBlock *R2 = Plan.createVPRegionBlock(R2BB1, R2BB2, "R2"); VPBlockUtils::connectBlocks(R2BB1, R2BB2); VPBasicBlock *VPBB1 = Plan.getEntry(); VPBlockUtils::connectBlocks(VPBB1, R1); VPBlockUtils::connectBlocks(VPBB1, R2); - VPBasicBlock *VPBB2 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); VPBlockUtils::connectBlocks(R1, VPBB2); VPBlockUtils::connectBlocks(R2, VPBB2); @@ -329,9 +329,9 @@ TEST_F(VPBasicBlockTest, TraversingIteratorTest) { // VPlan &Plan = getPlan(); VPBasicBlock *VPBB1 = Plan.getEntry(); - VPBasicBlock *VPBB2 = new VPBasicBlock(); - VPBasicBlock *VPBB3 = new VPBasicBlock(); - VPBasicBlock *VPBB4 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); + VPBasicBlock *VPBB3 = Plan.createVPBasicBlock(""); + VPBasicBlock *VPBB4 = Plan.createVPBasicBlock(""); VPBlockUtils::connectBlocks(VPBB1, VPBB2); VPBlockUtils::connectBlocks(VPBB1, VPBB3); @@ -368,11 +368,11 @@ TEST_F(VPBasicBlockTest, TraversingIteratorTest) { // VPlan &Plan = getPlan(); VPBasicBlock *VPBB0 = Plan.getEntry(); - VPBasicBlock *R1BB1 = new VPBasicBlock(); - VPBasicBlock *R1BB2 = new VPBasicBlock(); - VPBasicBlock *R1BB3 = new VPBasicBlock(); - VPBasicBlock *R1BB4 = new VPBasicBlock(); - VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB4, "R1"); + VPBasicBlock *R1BB1 = Plan.createVPBasicBlock(""); + VPBasicBlock *R1BB2 = Plan.createVPBasicBlock(""); + VPBasicBlock *R1BB3 = Plan.createVPBasicBlock(""); + VPBasicBlock *R1BB4 = Plan.createVPBasicBlock(""); + VPRegionBlock *R1 = Plan.createVPRegionBlock(R1BB1, R1BB4, "R1"); R1BB2->setParent(R1); R1BB3->setParent(R1); VPBlockUtils::connectBlocks(VPBB0, R1); @@ -383,9 +383,9 @@ TEST_F(VPBasicBlockTest, TraversingIteratorTest) { // Cycle. VPBlockUtils::connectBlocks(R1BB3, R1BB3); - VPBasicBlock *R2BB1 = new VPBasicBlock(); - VPBasicBlock *R2BB2 = new VPBasicBlock(); - VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R2BB2, "R2"); + VPBasicBlock *R2BB1 = Plan.createVPBasicBlock(""); + VPBasicBlock *R2BB2 = Plan.createVPBasicBlock(""); + VPRegionBlock *R2 = Plan.createVPRegionBlock(R2BB1, R2BB2, "R2"); VPBlockUtils::connectBlocks(R2BB1, R2BB2); VPBlockUtils::connectBlocks(R1, R2); @@ -467,15 +467,15 @@ TEST_F(VPBasicBlockTest, TraversingIteratorTest) { // VPBB2 // VPlan &Plan = getPlan(); - VPBasicBlock *R1BB1 = new VPBasicBlock("R1BB1"); - VPBasicBlock *R1BB2 = new VPBasicBlock("R1BB2"); - VPBasicBlock *R1BB3 = new VPBasicBlock("R1BB3"); - VPRegionBlock *R1 = new VPRegionBlock(R1BB1, R1BB3, "R1"); - - VPBasicBlock *R2BB1 = new VPBasicBlock("R2BB1"); - VPBasicBlock *R2BB2 = new VPBasicBlock("R2BB2"); - VPBasicBlock *R2BB3 = new VPBasicBlock("R2BB3"); - VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R2BB3, "R2"); + VPBasicBlock *R1BB1 = Plan.createVPBasicBlock("R1BB1"); + VPBasicBlock *R1BB2 = Plan.createVPBasicBlock("R1BB2"); + VPBasicBlock *R1BB3 = Plan.createVPBasicBlock("R1BB3"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(R1BB1, R1BB3, "R1"); + + VPBasicBlock *R2BB1 = Plan.createVPBasicBlock("R2BB1"); + VPBasicBlock *R2BB2 = Plan.createVPBasicBlock("R2BB2"); + VPBasicBlock *R2BB3 = Plan.createVPBasicBlock("R2BB3"); + VPRegionBlock *R2 = Plan.createVPRegionBlock(R2BB1, R2BB3, "R2"); R2BB2->setParent(R2); VPBlockUtils::connectBlocks(R2BB1, R2BB2); VPBlockUtils::connectBlocks(R2BB2, R2BB1); @@ -490,7 +490,7 @@ TEST_F(VPBasicBlockTest, TraversingIteratorTest) { VPBasicBlock *VPBB1 = Plan.getEntry(); VPBlockUtils::connectBlocks(VPBB1, R1); - VPBasicBlock *VPBB2 = new VPBasicBlock("VPBB2"); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock("VPBB2"); VPBlockUtils::connectBlocks(R1, VPBB2); // Depth-first. @@ -538,12 +538,12 @@ TEST_F(VPBasicBlockTest, TraversingIteratorTest) { // } // VPlan &Plan = getPlan(); - VPBasicBlock *R2BB1 = new VPBasicBlock("R2BB1"); - VPBasicBlock *R2BB2 = new VPBasicBlock("R2BB2"); - VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R2BB2, "R2"); + VPBasicBlock *R2BB1 = Plan.createVPBasicBlock("R2BB1"); + VPBasicBlock *R2BB2 = Plan.createVPBasicBlock("R2BB2"); + VPRegionBlock *R2 = Plan.createVPRegionBlock(R2BB1, R2BB2, "R2"); VPBlockUtils::connectBlocks(R2BB1, R2BB2); - VPRegionBlock *R1 = new VPRegionBlock(R2, R2, "R1"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(R2, R2, "R1"); R2->setParent(R1); VPBasicBlock *VPBB1 = Plan.getEntry(); @@ -592,19 +592,19 @@ TEST_F(VPBasicBlockTest, TraversingIteratorTest) { // VPBB2 // VPlan &Plan = getPlan(); - VPBasicBlock *R3BB1 = new VPBasicBlock("R3BB1"); - VPRegionBlock *R3 = new VPRegionBlock(R3BB1, R3BB1, "R3"); + VPBasicBlock *R3BB1 = Plan.createVPBasicBlock("R3BB1"); + VPRegionBlock *R3 = Plan.createVPRegionBlock(R3BB1, R3BB1, "R3"); - VPBasicBlock *R2BB1 = new VPBasicBlock("R2BB1"); - VPRegionBlock *R2 = new VPRegionBlock(R2BB1, R3, "R2"); + VPBasicBlock *R2BB1 = Plan.createVPBasicBlock("R2BB1"); + VPRegionBlock *R2 = Plan.createVPRegionBlock(R2BB1, R3, "R2"); R3->setParent(R2); VPBlockUtils::connectBlocks(R2BB1, R3); - VPRegionBlock *R1 = new VPRegionBlock(R2, R2, "R1"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(R2, R2, "R1"); R2->setParent(R1); VPBasicBlock *VPBB1 = Plan.getEntry(); - VPBasicBlock *VPBB2 = new VPBasicBlock("VPBB2"); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock("VPBB2"); VPBlockUtils::connectBlocks(VPBB1, R1); VPBlockUtils::connectBlocks(R1, VPBB2); @@ -674,7 +674,7 @@ TEST_F(VPBasicBlockTest, print) { VPInstruction *I2 = new VPInstruction(Instruction::Sub, {I1}); VPInstruction *I3 = new VPInstruction(Instruction::Br, {I1, I2}); - VPBasicBlock *VPBB1 = new VPBasicBlock(); + VPBasicBlock *VPBB1 = Plan.createVPBasicBlock(""); VPBB1->appendRecipe(I1); VPBB1->appendRecipe(I2); VPBB1->appendRecipe(I3); @@ -682,7 +682,7 @@ TEST_F(VPBasicBlockTest, print) { VPInstruction *I4 = new VPInstruction(Instruction::Mul, {I2, I1}); VPInstruction *I5 = new VPInstruction(Instruction::Ret, {I4}); - VPBasicBlock *VPBB2 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); VPBB2->appendRecipe(I4); VPBB2->appendRecipe(I5); VPBB2->setName("bb2"); @@ -783,7 +783,7 @@ TEST_F(VPBasicBlockTest, printPlanWithVFsAndUFs) { VPBB0->appendRecipe(TC); VPInstruction *I1 = new VPInstruction(Instruction::Add, {}); - VPBasicBlock *VPBB1 = new VPBasicBlock(); + VPBasicBlock *VPBB1 = Plan.createVPBasicBlock(""); VPBB1->appendRecipe(I1); VPBB1->setName("bb1"); @@ -1238,7 +1238,7 @@ TEST_F(VPRecipeTest, MayHaveSideEffectsAndMayReadWriteMemory) { TEST_F(VPRecipeTest, dumpRecipeInPlan) { VPlan &Plan = getPlan(); VPBasicBlock *VPBB0 = Plan.getEntry(); - VPBasicBlock *VPBB1 = new VPBasicBlock(); + VPBasicBlock *VPBB1 = Plan.createVPBasicBlock(""); VPBlockUtils::connectBlocks(VPBB1, Plan.getScalarHeader()); VPBlockUtils::connectBlocks(VPBB0, VPBB1); @@ -1307,7 +1307,7 @@ TEST_F(VPRecipeTest, dumpRecipeInPlan) { TEST_F(VPRecipeTest, dumpRecipeUnnamedVPValuesInPlan) { VPlan &Plan = getPlan(); VPBasicBlock *VPBB0 = Plan.getEntry(); - VPBasicBlock *VPBB1 = new VPBasicBlock(); + VPBasicBlock *VPBB1 = Plan.createVPBasicBlock(""); VPBlockUtils::connectBlocks(VPBB1, Plan.getScalarHeader()); VPBlockUtils::connectBlocks(VPBB0, VPBB1); diff --git a/llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp index 174249a7e85e3..f098ba0bce497 100644 --- a/llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp +++ b/llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp @@ -27,8 +27,8 @@ TEST_F(VPVerifierTest, VPInstructionUseBeforeDefSameBB) { VPBB1->appendRecipe(UseI); VPBB1->appendRecipe(DefI); - VPBasicBlock *VPBB2 = new VPBasicBlock(); - VPRegionBlock *R1 = new VPRegionBlock(VPBB2, VPBB2, "R1"); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); + VPRegionBlock *R1 = Plan.createVPRegionBlock(VPBB2, VPBB2, "R1"); VPBlockUtils::connectBlocks(VPBB1, R1); VPBlockUtils::connectBlocks(R1, Plan.getScalarHeader()); @@ -51,14 +51,14 @@ TEST_F(VPVerifierTest, VPInstructionUseBeforeDefDifferentBB) { new VPInstruction(VPInstruction::BranchOnCond, {CanIV}); VPBasicBlock *VPBB1 = Plan.getEntry(); - VPBasicBlock *VPBB2 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); VPBB1->appendRecipe(UseI); VPBB2->appendRecipe(CanIV); VPBB2->appendRecipe(DefI); VPBB2->appendRecipe(BranchOnCond); - VPRegionBlock *R1 = new VPRegionBlock(VPBB2, VPBB2, "R1"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(VPBB2, VPBB2, "R1"); VPBlockUtils::connectBlocks(VPBB1, R1); VPBlockUtils::connectBlocks(R1, Plan.getScalarHeader()); @@ -85,9 +85,9 @@ TEST_F(VPVerifierTest, VPBlendUseBeforeDefDifferentBB) { VPlan &Plan = getPlan(); VPBasicBlock *VPBB1 = Plan.getEntry(); - VPBasicBlock *VPBB2 = new VPBasicBlock(); - VPBasicBlock *VPBB3 = new VPBasicBlock(); - VPBasicBlock *VPBB4 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); + VPBasicBlock *VPBB3 = Plan.createVPBasicBlock(""); + VPBasicBlock *VPBB4 = Plan.createVPBasicBlock(""); VPBB1->appendRecipe(I1); VPBB2->appendRecipe(CanIV); @@ -97,7 +97,7 @@ TEST_F(VPVerifierTest, VPBlendUseBeforeDefDifferentBB) { VPBlockUtils::connectBlocks(VPBB2, VPBB3); VPBlockUtils::connectBlocks(VPBB3, VPBB4); - VPRegionBlock *R1 = new VPRegionBlock(VPBB2, VPBB4, "R1"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(VPBB2, VPBB4, "R1"); VPBlockUtils::connectBlocks(VPBB1, R1); VPBB3->setParent(R1); @@ -125,14 +125,14 @@ TEST_F(VPVerifierTest, DuplicateSuccessorsOutsideRegion) { VPlan &Plan = getPlan(); VPBasicBlock *VPBB1 = Plan.getEntry(); - VPBasicBlock *VPBB2 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); VPBB1->appendRecipe(I1); VPBB1->appendRecipe(BranchOnCond2); VPBB2->appendRecipe(CanIV); VPBB2->appendRecipe(BranchOnCond); - VPRegionBlock *R1 = new VPRegionBlock(VPBB2, VPBB2, "R1"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(VPBB2, VPBB2, "R1"); VPBlockUtils::connectBlocks(VPBB1, R1); VPBlockUtils::connectBlocks(VPBB1, R1); @@ -158,8 +158,8 @@ TEST_F(VPVerifierTest, DuplicateSuccessorsInsideRegion) { VPlan &Plan = getPlan(); VPBasicBlock *VPBB1 = Plan.getEntry(); - VPBasicBlock *VPBB2 = new VPBasicBlock(); - VPBasicBlock *VPBB3 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); + VPBasicBlock *VPBB3 = Plan.createVPBasicBlock(""); VPBB1->appendRecipe(I1); VPBB2->appendRecipe(CanIV); @@ -168,7 +168,7 @@ TEST_F(VPVerifierTest, DuplicateSuccessorsInsideRegion) { VPBlockUtils::connectBlocks(VPBB2, VPBB3); VPBlockUtils::connectBlocks(VPBB2, VPBB3); - VPRegionBlock *R1 = new VPRegionBlock(VPBB2, VPBB3, "R1"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(VPBB2, VPBB3, "R1"); VPBlockUtils::connectBlocks(VPBB1, R1); VPBB3->setParent(R1); @@ -187,7 +187,7 @@ TEST_F(VPVerifierTest, DuplicateSuccessorsInsideRegion) { TEST_F(VPVerifierTest, BlockOutsideRegionWithParent) { VPlan &Plan = getPlan(); VPBasicBlock *VPBB1 = Plan.getEntry(); - VPBasicBlock *VPBB2 = new VPBasicBlock(); + VPBasicBlock *VPBB2 = Plan.createVPBasicBlock(""); VPInstruction *DefI = new VPInstruction(Instruction::Add, {}); VPInstruction *BranchOnCond = @@ -196,7 +196,7 @@ TEST_F(VPVerifierTest, BlockOutsideRegionWithParent) { VPBB1->appendRecipe(DefI); VPBB2->appendRecipe(BranchOnCond); - VPRegionBlock *R1 = new VPRegionBlock(VPBB2, VPBB2, "R1"); + VPRegionBlock *R1 = Plan.createVPRegionBlock(VPBB2, VPBB2, "R1"); VPBlockUtils::connectBlocks(VPBB1, R1); VPBlockUtils::connectBlocks(R1, Plan.getScalarHeader());