Index: llvm/include/llvm/IR/Instruction.h =================================================================== --- llvm/include/llvm/IR/Instruction.h +++ llvm/include/llvm/IR/Instruction.h @@ -123,6 +123,9 @@ /// Insert an unlinked instruction into a basic block immediately before /// the specified instruction. void insertBefore(Instruction *InsertPos); + void insertBefore(SymbolTableList::iterator InsertPos) { + insertBefore(&*InsertPos); + } /// Insert an unlinked instruction into a basic block immediately after the /// specified instruction. @@ -133,6 +136,11 @@ SymbolTableList::iterator insertInto(BasicBlock *ParentBB, SymbolTableList::iterator It); + void insertBefore(BasicBlock &BB, + SymbolTableList::iterator InsertPos) { + insertInto(&BB, InsertPos); + } + /// Unlink this instruction from its current basic block and insert it into /// the basic block that MovePos lives in, right before MovePos. void moveBefore(Instruction *MovePos); Index: llvm/lib/CodeGen/CodeGenPrepare.cpp =================================================================== --- llvm/lib/CodeGen/CodeGenPrepare.cpp +++ llvm/lib/CodeGen/CodeGenPrepare.cpp @@ -7045,7 +7045,8 @@ // to get the PHI operand. for (SelectInst *SI : llvm::reverse(ASI)) { // The select itself is replaced with a PHI Node. - PHINode *PN = PHINode::Create(SI->getType(), 2, "", &EndBlock->front()); + PHINode *PN = PHINode::Create(SI->getType(), 2, ""); + PN->insertBefore(EndBlock->begin()); PN->takeName(SI); PN->addIncoming(getTrueOrFalseValue(SI, true, INS), TrueBlock); PN->addIncoming(getTrueOrFalseValue(SI, false, INS), FalseBlock); Index: llvm/lib/CodeGen/SelectOptimize.cpp =================================================================== --- llvm/lib/CodeGen/SelectOptimize.cpp +++ llvm/lib/CodeGen/SelectOptimize.cpp @@ -504,7 +504,8 @@ for (auto It = ASI.rbegin(); It != ASI.rend(); ++It) { SelectInst *SI = *It; // The select itself is replaced with a PHI Node. - PHINode *PN = PHINode::Create(SI->getType(), 2, "", &EndBlock->front()); + PHINode *PN = PHINode::Create(SI->getType(), 2, ""); + PN->insertBefore(EndBlock->begin()); PN->takeName(SI); PN->addIncoming(getTrueOrFalseValue(SI, true, INS), TrueBlock); PN->addIncoming(getTrueOrFalseValue(SI, false, INS), FalseBlock); Index: llvm/lib/Target/AMDGPU/SIAnnotateControlFlow.cpp =================================================================== --- llvm/lib/Target/AMDGPU/SIAnnotateControlFlow.cpp +++ llvm/lib/Target/AMDGPU/SIAnnotateControlFlow.cpp @@ -268,7 +268,8 @@ return false; BasicBlock *Target = Term->getSuccessor(1); - PHINode *Broken = PHINode::Create(IntMask, 0, "phi.broken", &Target->front()); + PHINode *Broken = PHINode::Create(IntMask, 0, "phi.broken"); + Broken->insertBefore(Target->begin()); Value *Cond = Term->getCondition(); Term->setCondition(BoolTrue); Index: llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp =================================================================== --- llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp +++ llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp @@ -707,8 +707,8 @@ BasicBlock *LoopPredecessor = L->getLoopPredecessor(); PHINode *NewPHI = PHINode::Create(I8PtrTy, HeaderLoopPredCount, - getInstrName(BaseMemI, PHINodeNameSuffix), - Header->getFirstNonPHI()); + getInstrName(BaseMemI, PHINodeNameSuffix)); + NewPHI->insertBefore(Header->getFirstInsertionPt()); Value *BasePtrStart = SCEVE.expandCodeFor(BasePtrStartSCEV, I8PtrTy, LoopPredecessor->getTerminator()); Index: llvm/lib/Transforms/Coroutines/CoroFrame.cpp =================================================================== --- llvm/lib/Transforms/Coroutines/CoroFrame.cpp +++ llvm/lib/Transforms/Coroutines/CoroFrame.cpp @@ -2043,8 +2043,8 @@ int Index = PN->getBasicBlockIndex(InsertedBB); Value *V = PN->getIncomingValue(Index); PHINode *InputV = PHINode::Create( - V->getType(), 1, V->getName() + Twine(".") + SuccBB->getName(), - &InsertedBB->front()); + V->getType(), 1, V->getName() + Twine(".") + SuccBB->getName()); + InputV->insertBefore(InsertedBB->begin()); InputV->addIncoming(V, PredBB); PN->setIncomingValue(Index, InputV); PN = dyn_cast(PN->getNextNode()); @@ -2190,7 +2190,8 @@ // ehAwareSplitEdge will clone the LandingPad in all the edge blocks. // We replace the original landing pad with a PHINode that will collect the // results from all of them. - ReplPHI = PHINode::Create(LandingPad->getType(), 1, "", LandingPad); + ReplPHI = PHINode::Create(LandingPad->getType(), 1, ""); + ReplPHI->insertBefore(BB.getFirstInsertionPt()); ReplPHI->takeName(LandingPad); LandingPad->replaceAllUsesWith(ReplPHI); // We will erase the original landing pad at the end of this function after Index: llvm/lib/Transforms/Coroutines/CoroSplit.cpp =================================================================== --- llvm/lib/Transforms/Coroutines/CoroSplit.cpp +++ llvm/lib/Transforms/Coroutines/CoroSplit.cpp @@ -447,7 +447,8 @@ Switch->addCase(IndexVal, ResumeBB); cast(SuspendBB->getTerminator())->setSuccessor(0, LandingBB); - auto *PN = PHINode::Create(Builder.getInt8Ty(), 2, "", &LandingBB->front()); + auto *PN = PHINode::Create(Builder.getInt8Ty(), 2, ""); + PN->insertBefore(LandingBB->begin()); S->replaceAllUsesWith(PN); PN->addIncoming(Builder.getInt8(-1), SuspendBB); PN->addIncoming(S, ResumeBB); Index: llvm/lib/Transforms/IPO/PartialInlining.cpp =================================================================== --- llvm/lib/Transforms/IPO/PartialInlining.cpp +++ llvm/lib/Transforms/IPO/PartialInlining.cpp @@ -1041,7 +1041,7 @@ ClonedOI->ReturnBlock = ClonedOI->ReturnBlock->splitBasicBlock( ClonedOI->ReturnBlock->getFirstNonPHI()->getIterator()); BasicBlock::iterator I = PreReturn->begin(); - Instruction *Ins = &ClonedOI->ReturnBlock->front(); + BasicBlock::iterator Ins = ClonedOI->ReturnBlock->begin(); SmallVector DeadPhis; while (I != PreReturn->end()) { PHINode *OldPhi = dyn_cast(I); @@ -1049,9 +1049,10 @@ break; PHINode *RetPhi = - PHINode::Create(OldPhi->getType(), NumPredsFromEntries + 1, "", Ins); + PHINode::Create(OldPhi->getType(), NumPredsFromEntries + 1, ""); + RetPhi->insertBefore(Ins); OldPhi->replaceAllUsesWith(RetPhi); - Ins = ClonedOI->ReturnBlock->getFirstNonPHI(); + Ins = ClonedOI->ReturnBlock->getFirstInsertionPt(); RetPhi->addIncoming(&*I, PreReturn); for (BasicBlock *E : ClonedOI->ReturnBlockPreds) { Index: llvm/lib/Transforms/InstCombine/InstructionCombining.cpp =================================================================== --- llvm/lib/Transforms/InstCombine/InstructionCombining.cpp +++ llvm/lib/Transforms/InstCombine/InstructionCombining.cpp @@ -3572,7 +3572,7 @@ bool Changed = false; if (&FI != MoveBefore) { - FI.moveBefore(MoveBefore); + FI.moveBefore(*MoveBefore->getParent(), MoveBefore->getIterator()); Changed = true; } @@ -3772,7 +3772,7 @@ /// the new position. BasicBlock::iterator InsertPos = DestBlock->getFirstInsertionPt(); - I->moveBefore(&*InsertPos); + I->moveBefore(*DestBlock, InsertPos); ++NumSunkInst; // Also sink all related debug uses from the source basic block. Otherwise we Index: llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp =================================================================== --- llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp +++ llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp @@ -1593,8 +1593,8 @@ // Insert a trivial phi for I (phi [&I, P0], [&I, P1], ...) at // ExitBlock. Replace I with the new phi in UI unless UI is another // phi at ExitBlock. - PHINode *PN = PHINode::Create(I.getType(), pred_size(ExitBlock), "", - &ExitBlock->front()); + PHINode *PN = PHINode::Create(I.getType(), pred_size(ExitBlock), ""); + PN->insertBefore(ExitBlock->begin()); for (BasicBlock *Pred : predecessors(ExitBlock)) { PN->addIncoming(&I, Pred); } Index: llvm/lib/Transforms/Scalar/GVN.cpp =================================================================== --- llvm/lib/Transforms/Scalar/GVN.cpp +++ llvm/lib/Transforms/Scalar/GVN.cpp @@ -2882,9 +2882,9 @@ ++NumGVNPRE; // Create a PHI to make the value available in this block. - PHINode *Phi = - PHINode::Create(CurInst->getType(), predMap.size(), - CurInst->getName() + ".pre-phi", &CurrentBlock->front()); + PHINode *Phi = PHINode::Create(CurInst->getType(), predMap.size(), + CurInst->getName() + ".pre-phi"); + Phi->insertBefore(CurrentBlock->begin()); for (unsigned i = 0, e = predMap.size(); i != e; ++i) { if (Value *V = predMap[i].first) { // If we use an existing value in this phi, we have to patch the original Index: llvm/lib/Transforms/Scalar/GVNSink.cpp =================================================================== --- llvm/lib/Transforms/Scalar/GVNSink.cpp +++ llvm/lib/Transforms/Scalar/GVNSink.cpp @@ -850,8 +850,9 @@ // Create a new PHI in the successor block and populate it. auto *Op = I0->getOperand(O); assert(!Op->getType()->isTokenTy() && "Can't PHI tokens!"); - auto *PN = PHINode::Create(Op->getType(), Insts.size(), - Op->getName() + ".sink", &BBEnd->front()); + auto *PN = + PHINode::Create(Op->getType(), Insts.size(), Op->getName() + ".sink"); + PN->insertBefore(BBEnd->begin()); for (auto *I : Insts) PN->addIncoming(I->getOperand(O), I->getParent()); NewOperands.push_back(PN); Index: llvm/lib/Transforms/Scalar/JumpThreading.cpp =================================================================== --- llvm/lib/Transforms/Scalar/JumpThreading.cpp +++ llvm/lib/Transforms/Scalar/JumpThreading.cpp @@ -1432,8 +1432,8 @@ // Create a PHI node at the start of the block for the PRE'd load value. pred_iterator PB = pred_begin(LoadBB), PE = pred_end(LoadBB); - PHINode *PN = PHINode::Create(LoadI->getType(), std::distance(PB, PE), "", - &LoadBB->front()); + PHINode *PN = PHINode::Create(LoadI->getType(), std::distance(PB, PE), ""); + PN->insertBefore(LoadBB->begin()); PN->takeName(LoadI); PN->setDebugLoc(LoadI->getDebugLoc()); Index: llvm/lib/Transforms/Scalar/LICM.cpp =================================================================== --- llvm/lib/Transforms/Scalar/LICM.cpp +++ llvm/lib/Transforms/Scalar/LICM.cpp @@ -1491,8 +1491,9 @@ if (LI->wouldBeOutOfLoopUseRequiringLCSSA(Op.get(), PN.getParent())) { auto *OInst = cast(Op.get()); PHINode *OpPN = - PHINode::Create(OInst->getType(), PN.getNumIncomingValues(), - OInst->getName() + ".lcssa", &ExitBlock.front()); + PHINode::Create(OInst->getType(), PN.getNumIncomingValues(), + OInst->getName() + ".lcssa"); + OpPN->insertBefore(ExitBlock.begin()); for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) OpPN->addIncoming(OInst, PN.getIncomingBlock(i)); Op = OpPN; @@ -1832,7 +1833,8 @@ // We need to create an LCSSA PHI node for the incoming value and // store that. PHINode *PN = PHINode::Create(I->getType(), PredCache.size(BB), - I->getName() + ".lcssa", &BB->front()); + I->getName() + ".lcssa"); + PN->insertBefore(BB->begin()); for (BasicBlock *Pred : PredCache.get(BB)) PN->addIncoming(I, Pred); return PN; Index: llvm/lib/Transforms/Scalar/LoopFuse.cpp =================================================================== --- llvm/lib/Transforms/Scalar/LoopFuse.cpp +++ llvm/lib/Transforms/Scalar/LoopFuse.cpp @@ -1473,12 +1473,13 @@ for (Instruction *I : HoistInsts) { assert(I->getParent() == FC1.Preheader); - I->moveBefore(FC0.Preheader->getTerminator()); + I->moveBefore(*FC0.Preheader, + FC0.Preheader->getTerminator()->getIterator()); } // insert instructions in reverse order to maintain dominance relationship for (Instruction *I : reverse(SinkInsts)) { assert(I->getParent() == FC1.Preheader); - I->moveBefore(&*FC1.ExitBlock->getFirstInsertionPt()); + I->moveBefore(*FC1.ExitBlock, FC1.ExitBlock->getFirstInsertionPt()); } } @@ -1671,7 +1672,7 @@ // exiting the first and jumping to the header of the second does not break // the SSA property of the phis originally in the first loop. See also the // comment above. - Instruction *L1HeaderIP = &FC1.Header->front(); + BasicBlock::iterator L1HeaderIP = FC1.Header->begin(); for (PHINode *LCPHI : OriginalFC0PHIs) { int L1LatchBBIdx = LCPHI->getBasicBlockIndex(FC1.Latch); assert(L1LatchBBIdx >= 0 && @@ -1679,8 +1680,9 @@ Value *LCV = LCPHI->getIncomingValue(L1LatchBBIdx); - PHINode *L1HeaderPHI = PHINode::Create( - LCV->getType(), 2, LCPHI->getName() + ".afterFC0", L1HeaderIP); + PHINode *L1HeaderPHI = + PHINode::Create(LCV->getType(), 2, LCPHI->getName() + ".afterFC0"); + L1HeaderPHI->insertBefore(L1HeaderIP); L1HeaderPHI->addIncoming(LCV, FC0.Latch); L1HeaderPHI->addIncoming(UndefValue::get(LCV->getType()), FC0.ExitingBlock); @@ -1953,7 +1955,7 @@ // exiting the first and jumping to the header of the second does not break // the SSA property of the phis originally in the first loop. See also the // comment above. - Instruction *L1HeaderIP = &FC1.Header->front(); + BasicBlock::iterator L1HeaderIP = FC1.Header->begin(); for (PHINode *LCPHI : OriginalFC0PHIs) { int L1LatchBBIdx = LCPHI->getBasicBlockIndex(FC1.Latch); assert(L1LatchBBIdx >= 0 && @@ -1961,8 +1963,9 @@ Value *LCV = LCPHI->getIncomingValue(L1LatchBBIdx); - PHINode *L1HeaderPHI = PHINode::Create( - LCV->getType(), 2, LCPHI->getName() + ".afterFC0", L1HeaderIP); + PHINode *L1HeaderPHI = + PHINode::Create(LCV->getType(), 2, LCPHI->getName() + ".afterFC0"); + L1HeaderPHI->insertBefore(L1HeaderIP); L1HeaderPHI->addIncoming(LCV, FC0.Latch); L1HeaderPHI->addIncoming(UndefValue::get(LCV->getType()), FC0.ExitingBlock); Index: llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp =================================================================== --- llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp +++ llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp @@ -2040,7 +2040,8 @@ auto *LbBr = cast(Body->getTerminator()); ICmpInst *LbCond = cast(LbBr->getCondition()); - PHINode *TcPhi = PHINode::Create(CountTy, 2, "tcphi", &Body->front()); + PHINode *TcPhi = PHINode::Create(CountTy, 2, "tcphi"); + TcPhi->insertBefore(Body->begin()); Builder.SetInsertPoint(LbCond); Instruction *TcDec = cast(Builder.CreateSub( @@ -2146,12 +2147,12 @@ ICmpInst *LbCond = cast(LbBr->getCondition()); Type *Ty = TripCnt->getType(); - PHINode *TcPhi = PHINode::Create(Ty, 2, "tcphi", &Body->front()); + PHINode *TcPhi = PHINode::Create(Ty, 2, "tcphi"); + TcPhi->insertBefore(Body->begin()); Builder.SetInsertPoint(LbCond); - Instruction *TcDec = cast( - Builder.CreateSub(TcPhi, ConstantInt::get(Ty, 1), - "tcdec", false, true)); + Instruction *TcDec = cast(Builder.CreateSub( + TcPhi, ConstantInt::get(Ty, 1), "tcdec", false, true)); TcPhi->addIncoming(TripCnt, PreHead); TcPhi->addIncoming(TcDec, Body); Index: llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp =================================================================== --- llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp +++ llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp @@ -434,8 +434,8 @@ Cand.Load->getType(), InitialPtr, "load_initial", /* isVolatile */ false, Cand.Load->getAlign(), PH->getTerminator()); - PHINode *PHI = PHINode::Create(Initial->getType(), 2, "store_forwarded", - &L->getHeader()->front()); + PHINode *PHI = PHINode::Create(Initial->getType(), 2, "store_forwarded"); + PHI->insertBefore(L->getHeader()->begin()); PHI->addIncoming(Initial, PH); Type *LoadType = Initial->getType(); Index: llvm/lib/Transforms/Scalar/MergedLoadStoreMotion.cpp =================================================================== --- llvm/lib/Transforms/Scalar/MergedLoadStoreMotion.cpp +++ llvm/lib/Transforms/Scalar/MergedLoadStoreMotion.cpp @@ -217,8 +217,8 @@ if (Opd1 == Opd2) return nullptr; - auto *NewPN = PHINode::Create(Opd1->getType(), 2, Opd2->getName() + ".sink", - &BB->front()); + auto *NewPN = PHINode::Create(Opd1->getType(), 2, Opd2->getName() + ".sink"); + NewPN->insertBefore(BB->begin()); NewPN->applyMergedLocation(S0->getDebugLoc(), S1->getDebugLoc()); NewPN->addIncoming(Opd1, S0->getParent()); NewPN->addIncoming(Opd2, S1->getParent()); @@ -269,7 +269,7 @@ // Create the new store to be inserted at the join point. StoreInst *SNew = cast(S0->clone()); - SNew->insertBefore(&*InsertPt); + SNew->insertBefore(InsertPt); // New PHI operand? Use it. if (PHINode *NewPN = getPHIOperand(BB, S0, S1)) SNew->setOperand(0, NewPN); Index: llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp =================================================================== --- llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp +++ llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp @@ -366,10 +366,11 @@ bool FullUnswitch) { assert(&ExitBB != &UnswitchedBB && "Must have different loop exit and unswitched blocks!"); - Instruction *InsertPt = &*UnswitchedBB.begin(); + BasicBlock::iterator InsertPt = UnswitchedBB.begin(); for (PHINode &PN : ExitBB.phis()) { auto *NewPN = PHINode::Create(PN.getType(), /*NumReservedValues*/ 2, - PN.getName() + ".split", InsertPt); + PN.getName() + ".split"); + NewPN->insertBefore(InsertPt); // Walk backwards over the old PHI node's inputs to minimize the cost of // removing each one. We have to do this weird loop manually so that we @@ -621,7 +622,7 @@ // If fully unswitching, we can use the existing branch instruction. // Splice it into the old PH to gate reaching the new preheader and re-point // its successors. - OldPH->splice(OldPH->end(), BI.getParent(), BI.getIterator()); + BI.moveBefore(*OldPH, OldPH->end()); BI.setCondition(Cond); if (MSSAU) { // Temporarily clone the terminator, to make MSSA update cheaper by @@ -1244,8 +1245,8 @@ SE->forgetValue(&I); auto *MergePN = - PHINode::Create(I.getType(), /*NumReservedValues*/ 2, ".us-phi", - &*MergeBB->getFirstInsertionPt()); + PHINode::Create(I.getType(), /*NumReservedValues*/ 2, ".us-phi"); + MergePN->insertBefore(MergeBB->getFirstInsertionPt()); I.replaceAllUsesWith(MergePN); MergePN->addIncoming(&I, ExitBB); MergePN->addIncoming(&ClonedI, ClonedExitBB); @@ -2312,7 +2313,7 @@ if (FullUnswitch) { // Splice the terminator from the original loop and rewrite its // successors. - SplitBB->splice(SplitBB->end(), ParentBB, TI.getIterator()); + TI.moveBefore(*SplitBB, SplitBB->end()); // Keep a clone of the terminator for MSSA updates. Instruction *NewTI = TI.clone(); Index: llvm/lib/Transforms/Scalar/TailRecursionElimination.cpp =================================================================== --- llvm/lib/Transforms/Scalar/TailRecursionElimination.cpp +++ llvm/lib/Transforms/Scalar/TailRecursionElimination.cpp @@ -518,10 +518,10 @@ // block, insert a PHI node for each argument of the function. // For now, we initialize each PHI to only have the real arguments // which are passed in. - Instruction *InsertPos = &HeaderBB->front(); + BasicBlock::iterator InsertPos = HeaderBB->begin(); for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { - PHINode *PN = - PHINode::Create(I->getType(), 2, I->getName() + ".tr", InsertPos); + PHINode *PN = PHINode::Create(I->getType(), 2, I->getName() + ".tr"); + PN->insertBefore(InsertPos); I->replaceAllUsesWith(PN); // Everyone use the PHI node now! PN->addIncoming(&*I, NewEntry); ArgumentPHIs.push_back(PN); @@ -534,8 +534,10 @@ Type *RetType = F.getReturnType(); if (!RetType->isVoidTy()) { Type *BoolType = Type::getInt1Ty(F.getContext()); - RetPN = PHINode::Create(RetType, 2, "ret.tr", InsertPos); - RetKnownPN = PHINode::Create(BoolType, 2, "ret.known.tr", InsertPos); + RetPN = PHINode::Create(RetType, 2, "ret.tr"); + RetPN->insertBefore(InsertPos); + RetKnownPN = PHINode::Create(BoolType, 2, "ret.known.tr"); + RetKnownPN->insertBefore(InsertPos); RetPN->addIncoming(PoisonValue::get(RetType), NewEntry); RetKnownPN->addIncoming(ConstantInt::getFalse(BoolType), NewEntry); @@ -555,7 +557,8 @@ // Start by inserting a new PHI node for the accumulator. pred_iterator PB = pred_begin(HeaderBB), PE = pred_end(HeaderBB); AccPN = PHINode::Create(F.getReturnType(), std::distance(PB, PE) + 1, - "accumulator.tr", &HeaderBB->front()); + "accumulator.tr"); + AccPN->insertBefore(HeaderBB->begin()); // Loop over all of the predecessors of the tail recursion block. For the // real entry into the function we seed the PHI with the identity constant for Index: llvm/lib/Transforms/Utils/BasicBlockUtils.cpp =================================================================== --- llvm/lib/Transforms/Utils/BasicBlockUtils.cpp +++ llvm/lib/Transforms/Utils/BasicBlockUtils.cpp @@ -852,9 +852,11 @@ continue; // Otherwise a new PHI is needed. Create one and populate it. - PHINode *NewPN = PHINode::Create( - PN.getType(), Preds.size(), "split", - SplitBB->isLandingPad() ? &SplitBB->front() : SplitBB->getTerminator()); + PHINode *NewPN = PHINode::Create(PN.getType(), Preds.size(), "split"); + BasicBlock::iterator InsertPos = + SplitBB->isLandingPad() ? SplitBB->begin() + : SplitBB->getTerminator()->getIterator(); + NewPN->insertBefore(InsertPos); for (BasicBlock *BB : Preds) NewPN->addIncoming(V, BB); Index: llvm/lib/Transforms/Utils/BreakCriticalEdges.cpp =================================================================== --- llvm/lib/Transforms/Utils/BreakCriticalEdges.cpp +++ llvm/lib/Transforms/Utils/BreakCriticalEdges.cpp @@ -449,8 +449,8 @@ // Create a PHI in the body block, to merge the direct and indirect // predecessors. - PHINode *MergePHI = - PHINode::Create(IndPHI->getType(), 2, "merge", &*MergeInsert); + PHINode *MergePHI = PHINode::Create(IndPHI->getType(), 2, "merge"); + MergePHI->insertBefore(MergeInsert); MergePHI->addIncoming(NewIndPHI, Target); MergePHI->addIncoming(DirPHI, DirectSucc); Index: llvm/lib/Transforms/Utils/CodeExtractor.cpp =================================================================== --- llvm/lib/Transforms/Utils/CodeExtractor.cpp +++ llvm/lib/Transforms/Utils/CodeExtractor.cpp @@ -721,7 +721,8 @@ // Create a new PHI node in the new region, which has an incoming value // from OldPred of PN. PHINode *NewPN = PHINode::Create(PN->getType(), 1 + NumPredsFromRegion, - PN->getName() + ".ce", &NewBB->front()); + PN->getName() + ".ce"); + NewPN->insertBefore(NewBB->begin()); PN->replaceAllUsesWith(NewPN); NewPN->addIncoming(PN, OldPred); @@ -775,9 +776,9 @@ } // Split this PHI. - PHINode *NewPN = - PHINode::Create(PN.getType(), IncomingVals.size(), - PN.getName() + ".ce", NewBB->getFirstNonPHI()); + PHINode *NewPN = PHINode::Create(PN.getType(), IncomingVals.size(), + PN.getName() + ".ce"); + NewPN->insertBefore(NewBB->getFirstInsertionPt()); for (unsigned i : IncomingVals) NewPN->addIncoming(PN.getIncomingValue(i), PN.getIncomingBlock(i)); for (unsigned i : reverse(IncomingVals)) Index: llvm/lib/Transforms/Utils/InlineFunction.cpp =================================================================== --- llvm/lib/Transforms/Utils/InlineFunction.cpp +++ llvm/lib/Transforms/Utils/InlineFunction.cpp @@ -189,20 +189,21 @@ const unsigned PHICapacity = 2; // Create corresponding new PHIs for all the PHIs in the outer landing pad. - Instruction *InsertPoint = &InnerResumeDest->front(); + BasicBlock::iterator InsertPoint = InnerResumeDest->begin(); BasicBlock::iterator I = OuterResumeDest->begin(); for (unsigned i = 0, e = UnwindDestPHIValues.size(); i != e; ++i, ++I) { PHINode *OuterPHI = cast(I); PHINode *InnerPHI = PHINode::Create(OuterPHI->getType(), PHICapacity, - OuterPHI->getName() + ".lpad-body", - InsertPoint); + OuterPHI->getName() + ".lpad-body"); + InnerPHI->insertBefore(InsertPoint); OuterPHI->replaceAllUsesWith(InnerPHI); InnerPHI->addIncoming(OuterPHI, OuterResumeDest); } // Create a PHI for the exception values. - InnerEHValuesPHI = PHINode::Create(CallerLPad->getType(), PHICapacity, - "eh.lpad-body", InsertPoint); + InnerEHValuesPHI = + PHINode::Create(CallerLPad->getType(), PHICapacity, "eh.lpad-body"); + InnerEHValuesPHI->insertBefore(InsertPoint); CallerLPad->replaceAllUsesWith(InnerEHValuesPHI); InnerEHValuesPHI->addIncoming(CallerLPad, OuterResumeDest); @@ -1520,10 +1521,10 @@ if (ByValAlignment) Alignment = std::max(Alignment, *ByValAlignment); - Value *NewAlloca = - new AllocaInst(ByValType, DL.getAllocaAddrSpace(), nullptr, Alignment, - Arg->getName(), &*Caller->begin()->begin()); - IFI.StaticAllocas.push_back(cast(NewAlloca)); + AllocaInst *NewAlloca = new AllocaInst(ByValType, DL.getAllocaAddrSpace(), + nullptr, Alignment, Arg->getName()); + NewAlloca->insertBefore(Caller->begin()->begin()); + IFI.StaticAllocas.push_back(NewAlloca); // Uses of the argument in the function should use our new alloca // instead. @@ -2730,8 +2731,8 @@ // The PHI node should go at the front of the new basic block to merge all // possible incoming values. if (!CB.use_empty()) { - PHI = PHINode::Create(RTy, Returns.size(), CB.getName(), - &AfterCallBB->front()); + PHI = PHINode::Create(RTy, Returns.size(), CB.getName()); + PHI->insertBefore(AfterCallBB->begin()); // Anything that used the result of the function call should now use the // PHI node as their operand. CB.replaceAllUsesWith(PHI); Index: llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp =================================================================== --- llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp +++ llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp @@ -105,8 +105,8 @@ // PrologLatch. When supporting multiple-exiting block loops, we can have // two or more blocks that have the LatchExit as the target in the // original loop. - PHINode *NewPN = PHINode::Create(PN.getType(), 2, PN.getName() + ".unr", - PrologExit->getFirstNonPHI()); + PHINode *NewPN = PHINode::Create(PN.getType(), 2, PN.getName() + ".unr"); + NewPN->insertBefore(PrologExit->getFirstInsertionPt()); // Adding a value to the new PHI node from the original loop preheader. // This is the value that skips all the prolog code. if (L->contains(&PN)) { @@ -269,8 +269,8 @@ for (PHINode &PN : Succ->phis()) { // Add new PHI nodes to the loop exit block and update epilog // PHIs with the new PHI values. - PHINode *NewPN = PHINode::Create(PN.getType(), 2, PN.getName() + ".unr", - NewExit->getFirstNonPHI()); + PHINode *NewPN = PHINode::Create(PN.getType(), 2, PN.getName() + ".unr"); + NewPN->insertBefore(NewExit->getFirstInsertionPt()); // Adding a value to the new PHI node from the unrolling loop preheader. NewPN->addIncoming(PN.getIncomingValueForBlock(NewPreHeader), PreHeader); // Adding a value to the new PHI node from the unrolling loop latch. @@ -363,12 +363,13 @@ BasicBlock *FirstLoopBB = cast(VMap[Header]); BranchInst *LatchBR = cast(NewBB->getTerminator()); IRBuilder<> Builder(LatchBR); - PHINode *NewIdx = PHINode::Create(NewIter->getType(), 2, - suffix + ".iter", - FirstLoopBB->getFirstNonPHI()); + PHINode *NewIdx = + PHINode::Create(NewIter->getType(), 2, suffix + ".iter"); + NewIdx->insertBefore(FirstLoopBB->getFirstInsertionPt()); auto *Zero = ConstantInt::get(NewIdx->getType(), 0); auto *One = ConstantInt::get(NewIdx->getType(), 1); - Value *IdxNext = Builder.CreateAdd(NewIdx, One, NewIdx->getName() + ".next"); + Value *IdxNext = + Builder.CreateAdd(NewIdx, One, NewIdx->getName() + ".next"); Value *IdxCmp = Builder.CreateICmpNE(IdxNext, NewIter, NewIdx->getName() + ".cmp"); Builder.CreateCondBr(IdxCmp, FirstLoopBB, InsertBot); NewIdx->addIncoming(Zero, InsertTop); @@ -912,8 +913,8 @@ IRBuilder<> B2(NewPreHeader->getTerminator()); Value *TestVal = B2.CreateSub(TripCount, ModVal, "unroll_iter"); BranchInst *LatchBR = cast(Latch->getTerminator()); - PHINode *NewIdx = PHINode::Create(TestVal->getType(), 2, "niter", - Header->getFirstNonPHI()); + PHINode *NewIdx = PHINode::Create(TestVal->getType(), 2, "niter"); + NewIdx->insertBefore(Header->getFirstInsertionPt()); B2.SetInsertPoint(LatchBR); auto *Zero = ConstantInt::get(NewIdx->getType(), 0); auto *One = ConstantInt::get(NewIdx->getType(), 1); Index: llvm/lib/Transforms/Utils/LoopVersioning.cpp =================================================================== --- llvm/lib/Transforms/Utils/LoopVersioning.cpp +++ llvm/lib/Transforms/Utils/LoopVersioning.cpp @@ -145,8 +145,8 @@ } // If not create it. if (!PN) { - PN = PHINode::Create(Inst->getType(), 2, Inst->getName() + ".lver", - &PHIBlock->front()); + PN = PHINode::Create(Inst->getType(), 2, Inst->getName() + ".lver"); + PN->insertBefore(PHIBlock->begin()); SmallVector UsersToUpdate; for (User *U : Inst->users()) if (!VersionedLoop->contains(cast(U)->getParent())) Index: llvm/lib/Transforms/Utils/MoveAutoInit.cpp =================================================================== --- llvm/lib/Transforms/Utils/MoveAutoInit.cpp +++ llvm/lib/Transforms/Utils/MoveAutoInit.cpp @@ -204,7 +204,7 @@ // if two instructions are moved from the same BB to the same BB, we insert // the second one in the front, then the first on top of it. for (auto &Job : reverse(JobList)) { - Job.first->moveBefore(&*Job.second->getFirstInsertionPt()); + Job.first->moveBefore(*Job.second, Job.second->getFirstInsertionPt()); MSSAU.moveToPlace(MSSA.getMemoryAccess(Job.first), Job.first->getParent(), MemorySSA::InsertionPlace::Beginning); } Index: llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp =================================================================== --- llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp +++ llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp @@ -981,8 +981,8 @@ // Create a PhiNode using the dereferenced type... and add the phi-node to the // BasicBlock. PN = PHINode::Create(Allocas[AllocaNo]->getAllocatedType(), getNumPreds(BB), - Allocas[AllocaNo]->getName() + "." + Twine(Version++), - &BB->front()); + Allocas[AllocaNo]->getName() + "." + Twine(Version++)); + PN->insertBefore(BB->begin()); ++NumPHIInsert; PhiToAllocaMap[PN] = AllocaNo; return true; Index: llvm/lib/Transforms/Utils/SSAUpdater.cpp =================================================================== --- llvm/lib/Transforms/Utils/SSAUpdater.cpp +++ llvm/lib/Transforms/Utils/SSAUpdater.cpp @@ -156,8 +156,9 @@ } // Ok, we have no way out, insert a new one now. - PHINode *InsertedPHI = PHINode::Create(ProtoType, PredValues.size(), - ProtoName, &BB->front()); + PHINode *InsertedPHI = + PHINode::Create(ProtoType, PredValues.size(), ProtoName); + InsertedPHI->insertBefore(BB->begin()); // Fill in all the predecessors of the PHI. for (const auto &PredValue : PredValues) @@ -295,8 +296,9 @@ /// Reserve space for the operands but do not fill them in yet. static Value *CreateEmptyPHI(BasicBlock *BB, unsigned NumPreds, SSAUpdater *Updater) { - PHINode *PHI = PHINode::Create(Updater->ProtoType, NumPreds, - Updater->ProtoName, &BB->front()); + PHINode *PHI = + PHINode::Create(Updater->ProtoType, NumPreds, Updater->ProtoName); + PHI->insertBefore(BB->begin()); return PHI; } Index: llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp =================================================================== --- llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp +++ llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp @@ -1604,8 +1604,8 @@ // specified loop. BasicBlock *Header = L->getHeader(); pred_iterator HPB = pred_begin(Header), HPE = pred_end(Header); - CanonicalIV = PHINode::Create(Ty, std::distance(HPB, HPE), "indvar", - &Header->front()); + CanonicalIV = PHINode::Create(Ty, std::distance(HPB, HPE), "indvar"); + CanonicalIV->insertBefore(Header->begin()); rememberInstruction(CanonicalIV); SmallSet PredSeen; Index: llvm/lib/Transforms/Utils/SimplifyCFG.cpp =================================================================== --- llvm/lib/Transforms/Utils/SimplifyCFG.cpp +++ llvm/lib/Transforms/Utils/SimplifyCFG.cpp @@ -1951,8 +1951,9 @@ // Create a new PHI in the successor block and populate it. auto *Op = I0->getOperand(O); assert(!Op->getType()->isTokenTy() && "Can't PHI tokens!"); - auto *PN = PHINode::Create(Op->getType(), Insts.size(), - Op->getName() + ".sink", &BBEnd->front()); + auto *PN = + PHINode::Create(Op->getType(), Insts.size(), Op->getName() + ".sink"); + PN->insertBefore(BBEnd->begin()); for (auto *I : Insts) PN->addIncoming(I->getOperand(O), I->getParent()); NewOperands.push_back(PN); @@ -1962,7 +1963,8 @@ // and move it to the start of the successor block. for (unsigned O = 0, E = I0->getNumOperands(); O != E; ++O) I0->getOperandUse(O).set(NewOperands[O]); - I0->moveBefore(&*BBEnd->getFirstInsertionPt()); + + I0->moveBefore(*BBEnd, BBEnd->getFirstInsertionPt()); // Update metadata and IR flags, and merge debug locations. for (auto *I : Insts) @@ -3862,7 +3864,8 @@ (!isa(V) || cast(V)->getParent() != BB)) return V; - PHI = PHINode::Create(V->getType(), 2, "simplifycfg.merge", &Succ->front()); + PHI = PHINode::Create(V->getType(), 2, "simplifycfg.merge"); + PHI->insertBefore(Succ->begin()); PHI->addIncoming(V, BB); for (BasicBlock *PredBB : predecessors(Succ)) if (PredBB != BB) Index: llvm/lib/Transforms/Vectorize/LoopVectorize.cpp =================================================================== --- llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -8041,8 +8041,8 @@ // Generate a resume induction for the vector epilogue and put it in the // vector epilogue preheader Type *IdxTy = Legal->getWidestInductionType(); - PHINode *EPResumeVal = PHINode::Create(IdxTy, 2, "vec.epilog.resume.val", - LoopVectorPreHeader->getFirstNonPHI()); + PHINode *EPResumeVal = PHINode::Create(IdxTy, 2, "vec.epilog.resume.val"); + EPResumeVal->insertBefore(LoopVectorPreHeader->getFirstInsertionPt()); EPResumeVal->addIncoming(EPI.VectorTripCount, VecEpilogueIterationCountCheck); EPResumeVal->addIncoming(ConstantInt::get(IdxTy, 0), EPI.MainLoopIterationCountCheck); @@ -9378,8 +9378,8 @@ // We may need to add the step a number of times, depending on the unroll // factor. The last of those goes into the PHI. - PHINode *VecInd = PHINode::Create(SteppedStart->getType(), 2, "vec.ind", - &*State.CFG.PrevBB->getFirstInsertionPt()); + PHINode *VecInd = PHINode::Create(SteppedStart->getType(), 2, "vec.ind"); + VecInd->insertBefore(State.CFG.PrevBB->getFirstInsertionPt()); VecInd->setDebugLoc(EntryVal->getDebugLoc()); Instruction *LastInduction = VecInd; for (unsigned Part = 0; Part < State.UF; ++Part) { Index: llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp =================================================================== --- llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp +++ llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp @@ -10632,7 +10632,8 @@ Instruction *I = EEIt->second; if (Builder.GetInsertPoint() != Builder.GetInsertBlock()->end() && Builder.GetInsertPoint()->comesBefore(I)) - I->moveBefore(&*Builder.GetInsertPoint()); + I->moveBefore(*Builder.GetInsertPoint()->getParent(), + Builder.GetInsertPoint()); Ex = I; } } Index: llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp =================================================================== --- llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp +++ llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp @@ -1090,8 +1090,8 @@ void VPCanonicalIVPHIRecipe::execute(VPTransformState &State) { Value *Start = getStartValue()->getLiveInIRValue(); - PHINode *EntryPart = PHINode::Create( - Start->getType(), 2, "index", &*State.CFG.PrevBB->getFirstInsertionPt()); + PHINode *EntryPart = PHINode::Create(Start->getType(), 2, "index"); + EntryPart->insertBefore(State.CFG.PrevBB->getFirstInsertionPt()); BasicBlock *VectorPH = State.CFG.getPreheaderBBFor(this); EntryPart->addIncoming(Start, VectorPH); @@ -1216,8 +1216,8 @@ } // Create a phi node for the new recurrence. - PHINode *EntryPart = PHINode::Create( - VecTy, 2, "vector.recur", &*State.CFG.PrevBB->getFirstInsertionPt()); + PHINode *EntryPart = PHINode::Create(VecTy, 2, "vector.recur"); + EntryPart->insertBefore(State.CFG.PrevBB->getFirstInsertionPt()); EntryPart->addIncoming(VectorInit, VectorPH); State.set(this, EntryPart, 0); } @@ -1249,8 +1249,8 @@ "recipe must be in the vector loop header"); unsigned LastPartForNewPhi = isOrdered() ? 1 : State.UF; for (unsigned Part = 0; Part < LastPartForNewPhi; ++Part) { - Value *EntryPart = - PHINode::Create(VecTy, 2, "vec.phi", &*HeaderBB->getFirstInsertionPt()); + Instruction *EntryPart = PHINode::Create(VecTy, 2, "vec.phi"); + EntryPart->insertBefore(HeaderBB->getFirstInsertionPt()); State.set(this, EntryPart, Part); }