[NFC] Rename Function::insertBasicBlockAt() to Function::insert().

[vporpo]

Summary

I think this is a better name because it is what STL uses.

[vporpo]

Fixed a couple more files that were missing from the original patch.

[asbirlea]

lgtm.

clang/lib/CodeGen/CGStmt.cpp

void CodeGenFunction::EmitBlock(llvm::BasicBlock *BB, bool IsFinished) {
   if (IsFinished && BB->use_empty()) {
     delete BB;
     return;
   }
 
   // Place the block after the current block, if possible, or else at
   // the end of the function.
   if (CurBB && CurBB->getParent())
-    CurFn->insertBasicBlockAt(std::next(CurBB->getIterator()), BB);
+    CurFn->insert(std::next(CurBB->getIterator()), BB);
   else
-    CurFn->insertBasicBlockAt(CurFn->end(), BB);
+    CurFn->insert(CurFn->end(), BB);
   Builder.SetInsertPoint(BB);
 }
 
 void CodeGenFunction::EmitBranch(llvm::BasicBlock *Target) {
   // Emit a branch from the current block to the target one if this
   // was a real block.  If this was just a fall-through block after a
   // terminator, don't emit it.
   llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
 
   if (!CurBB || CurBB->getTerminator()) {
     // If there is no insert point or the previous block is already
     // terminated, don't touch it.
   } else {
     // Otherwise, create a fall-through branch.
     Builder.CreateBr(Target);
   }
 
   Builder.ClearInsertionPoint();
 }
 
 void CodeGenFunction::EmitBlockAfterUses(llvm::BasicBlock *block) {
   bool inserted = false;
   for (llvm::User *u : block->users()) {
     if (llvm::Instruction *insn = dyn_cast<llvm::Instruction>(u)) {
-      CurFn->insertBasicBlockAt(std::next(insn->getParent()->getIterator()),
-                                block);
+      CurFn->insert(std::next(insn->getParent()->getIterator()), block);
       inserted = true;
       break;
     }
   }
 
   if (!inserted)
-    CurFn->insertBasicBlockAt(CurFn->end(), block);
+    CurFn->insert(CurFn->end(), block);
 
   Builder.SetInsertPoint(block);
 }
 
 CodeGenFunction::JumpDest
 CodeGenFunction::getJumpDestForLabel(const LabelDecl *D) {
   JumpDest &Dest = LabelMap[D];
   if (Dest.isValid()) return Dest;
void CodeGenFunction::EmitCaseStmtRange(const CaseStmt &S,
   llvm::BasicBlock *RestoreBB = Builder.GetInsertBlock();
 
   // Push this test onto the chain of range checks (which terminates
   // in the default basic block). The switch's default will be changed
   // to the top of this chain after switch emission is complete.
   llvm::BasicBlock *FalseDest = CaseRangeBlock;
   CaseRangeBlock = createBasicBlock("sw.caserange");
 
-  CurFn->insertBasicBlockAt(CurFn->end(), CaseRangeBlock);
+  CurFn->insert(CurFn->end(), CaseRangeBlock);
   Builder.SetInsertPoint(CaseRangeBlock);
 
   // Emit range check.
   llvm::Value *Diff =
     Builder.CreateSub(SwitchInsn->getCondition(), Builder.getInt(LHS));
   llvm::Value *Cond =
     Builder.CreateICmpULE(Diff, Builder.getInt(Range), "inbounds");
 

clang/lib/CodeGen/CodeGenFunction.cpp

llvm::DebugLoc CodeGenFunction::EmitReturnBlock() {
 
   EmitBlock(ReturnBlock.getBlock());
   return llvm::DebugLoc();
 }
 
 static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
   if (!BB) return;
   if (!BB->use_empty()) {
-    CGF.CurFn->insertBasicBlockAt(CGF.CurFn->end(), BB);
+    CGF.CurFn->insert(CGF.CurFn->end(), BB);
     return;
   }
   delete BB;
 }
 
 void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
   assert(BreakContinueStack.empty() &&
          "mismatched push/pop in break/continue stack!");

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/examples/Kaleidoscope/Chapter5/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/examples/Kaleidoscope/Chapter6/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/examples/Kaleidoscope/Chapter7/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/examples/Kaleidoscope/Chapter8/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/examples/Kaleidoscope/Chapter9/toy.cpp

Value *IfExprAST::codegen() {
   if (!ThenV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
   ThenBB = Builder->GetInsertBlock();
 
   // Emit else block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), ElseBB);
+  TheFunction->insert(TheFunction->end(), ElseBB);
   Builder->SetInsertPoint(ElseBB);
 
   Value *ElseV = Else->codegen();
   if (!ElseV)
     return nullptr;
 
   Builder->CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder->GetInsertBlock();
 
   // Emit merge block.
-  TheFunction->insertBasicBlockAt(TheFunction->end(), MergeBB);
+  TheFunction->insert(TheFunction->end(), MergeBB);
   Builder->SetInsertPoint(MergeBB);
   PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 

llvm/include/llvm/IR/Function.h

public:
   /// Steal arguments from another function.
   ///
   /// Drop this function's arguments and splice in the ones from \c Src.
   /// Requires that this has no function body.
   void stealArgumentListFrom(Function &Src);
 
   /// Insert \p BB in the basic block list at \p Position. \Returns an iterator
   /// to the newly inserted BB.
-  Function::iterator insertBasicBlockAt(Function::iterator Position, BasicBlock *BB) {
+  Function::iterator insert(Function::iterator Position, BasicBlock *BB) {
     return BasicBlocks.insert(Position, BB);
   }
 
   /// Transfer all blocks from \p FromF to this function at \p ToIt.
   void splice(Function::iterator ToIt, Function *FromF) {
     splice(ToIt, FromF, FromF->begin(), FromF->end());
   }
 
public:
 
   /// Erases a range of BasicBlocks from \p FromIt to (not including) \p ToIt.
   /// \Returns \p ToIt.
   Function::iterator erase(Function::iterator FromIt, Function::iterator ToIt);
 
   /// Get the underlying elements of the Function... the basic block list is
   /// empty for external functions.
   ///
+  /// This is deliberately private because we have implemented an adequate set
+  /// of functions to modify the list, including Function::splice(),
+  /// Function::erase(), Function::insert() etc.
   const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
         BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }
 
   static BasicBlockListType Function::*getSublistAccess(BasicBlock*) {
     return &Function::BasicBlocks;
   }
 
   const BasicBlock       &getEntryBlock() const   { return front(); }

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::emitCommonDirectiveEntry(
   BasicBlock *EntryBB = Builder.GetInsertBlock();
   Value *CallBool = Builder.CreateIsNotNull(EntryCall);
   auto *ThenBB = BasicBlock::Create(M.getContext(), "omp_region.body");
   auto *UI = new UnreachableInst(Builder.getContext(), ThenBB);
 
   // Emit thenBB and set the Builder's insertion point there for
   // body generation next. Place the block after the current block.
   Function *CurFn = EntryBB->getParent();
-  CurFn->insertBasicBlockAt(std::next(EntryBB->getIterator()), ThenBB);
+  CurFn->insert(std::next(EntryBB->getIterator()), ThenBB);
 
   // Move Entry branch to end of ThenBB, and replace with conditional
   // branch (If-stmt)
   Instruction *EntryBBTI = EntryBB->getTerminator();
   Builder.CreateCondBr(CallBool, ThenBB, ExitBB);
   EntryBBTI->removeFromParent();
   Builder.SetInsertPoint(UI);
   Builder.Insert(EntryBBTI);

llvm/lib/IR/BasicBlock.cpp

BasicBlock::BasicBlock(LLVMContext &C, const Twine &Name, Function *NewParent,
   setName(Name);
 }
 
 void BasicBlock::insertInto(Function *NewParent, BasicBlock *InsertBefore) {
   assert(NewParent && "Expected a parent");
   assert(!Parent && "Already has a parent");
 
   if (InsertBefore)
-    NewParent->insertBasicBlockAt(InsertBefore->getIterator(), this);
+    NewParent->insert(InsertBefore->getIterator(), this);
   else
-    NewParent->insertBasicBlockAt(NewParent->end(), this);
+    NewParent->insert(NewParent->end(), this);
 }
 
 BasicBlock::~BasicBlock() {
   validateInstrOrdering();
 
   // If the address of the block is taken and it is being deleted (e.g. because
   // it is dead), this means that there is either a dangling constant expr
   // hanging off the block, or an undefined use of the block (source code

llvm/lib/IR/Core.cpp

LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C,
   return wrap(llvm::BasicBlock::Create(*unwrap(C), Name));
 }
 
 void LLVMInsertExistingBasicBlockAfterInsertBlock(LLVMBuilderRef Builder,
                                                   LLVMBasicBlockRef BB) {
   BasicBlock *ToInsert = unwrap(BB);
   BasicBlock *CurBB = unwrap(Builder)->GetInsertBlock();
   assert(CurBB && "current insertion point is invalid!");
-  CurBB->getParent()->insertBasicBlockAt(std::next(CurBB->getIterator()),
-                                         ToInsert);
+  CurBB->getParent()->insert(std::next(CurBB->getIterator()), ToInsert);
 }
 
 void LLVMAppendExistingBasicBlock(LLVMValueRef Fn,
                                   LLVMBasicBlockRef BB) {
-  unwrap<Function>(Fn)->insertBasicBlockAt(unwrap<Function>(Fn)->end(),
-                                           unwrap(BB));
+  unwrap<Function>(Fn)->insert(unwrap<Function>(Fn)->end(), unwrap(BB));
 }
 
 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
                                                 LLVMValueRef FnRef,
                                                 const char *Name) {
   return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef)));
 }
 

llvm/lib/Transforms/Utils/BreakCriticalEdges.cpp

NewBB = BasicBlock::Create(TI->getContext(), TIBB->getName() + "." +
                                                      "_crit_edge");
   // Create our unconditional branch.
   BranchInst *NewBI = BranchInst::Create(DestBB, NewBB);
   NewBI->setDebugLoc(TI->getDebugLoc());
 
   // Insert the block into the function... right after the block TI lives in.
   Function &F = *TIBB->getParent();
   Function::iterator FBBI = TIBB->getIterator();
-  F.insertBasicBlockAt(++FBBI, NewBB);
+  F.insert(++FBBI, NewBB);
 
   // Branch to the new block, breaking the edge.
   TI->setSuccessor(SuccNum, NewBB);
 
   // If there are any PHI nodes in DestBB, we need to update them so that they
   // merge incoming values from NewBB instead of from TIBB.
   {
     unsigned BBIdx = 0;

llvm/lib/Transforms/Utils/CloneFunction.cpp

#endif
   SmallVector<const PHINode *, 16> PHIToResolve;
   for (const BasicBlock &BI : *OldFunc) {
     Value *V = VMap.lookup(&BI);
     BasicBlock *NewBB = cast_or_null<BasicBlock>(V);
     if (!NewBB)
       continue; // Dead block.
 
     // Add the new block to the new function.
-    NewFunc->insertBasicBlockAt(NewFunc->end(), NewBB);
+    NewFunc->insert(NewFunc->end(), NewBB);
 
     // Handle PHI nodes specially, as we have to remove references to dead
     // blocks.
     for (const PHINode &PN : BI.phis()) {
       // PHI nodes may have been remapped to non-PHI nodes by the caller or
       // during the cloning process.
       if (isa<PHINode>(VMap[&PN]))
         PHIToResolve.push_back(&PN);

llvm/lib/Transforms/Utils/CodeExtractor.cpp

if (Attr.isStringAttribute()) {
       case Attribute::EndAttrKinds:
       case Attribute::EmptyKey:
       case Attribute::TombstoneKey:
         llvm_unreachable("Not a function attribute");
       }
 
     newFunction->addFnAttr(Attr);
   }
-  newFunction->insertBasicBlockAt(newFunction->end(), newRootNode);
+  newFunction->insert(newFunction->end(), newRootNode);
 
   // Create scalar and aggregate iterators to name all of the arguments we
   // inserted.
   Function::arg_iterator ScalarAI = newFunction->arg_begin();
   Function::arg_iterator AggAI = std::next(ScalarAI, NumScalarParams);
 
   // Rewrite all users of the inputs in the extracted region to use the
   // arguments (or appropriate addressing into struct) instead.
for (BasicBlock *Block : Blocks) {
     // Delete the basic block from the old function, and the list of blocks
     Block->removeFromParent();
 
     // Insert this basic block into the new function
     // Insert the original blocks after the entry block created
     // for the new function. The entry block may be followed
     // by a set of exit blocks at this point, but these exit
     // blocks better be placed at the end of the new function.
-    newFuncIt = newFunction->insertBasicBlockAt(std::next(newFuncIt), Block);
+    newFuncIt = newFunction->insert(std::next(newFuncIt), Block);
   }
 }
 
 void CodeExtractor::calculateNewCallTerminatorWeights(
     BasicBlock *CodeReplacer,
     DenseMap<BasicBlock *, BlockFrequency> &ExitWeights,
     BranchProbabilityInfo *BPI) {
   using Distribution = BlockFrequencyInfoImplBase::Distribution;

llvm/lib/Transforms/Utils/LoopUnroll.cpp

LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
   for (unsigned It = 1; It != ULO.Count; ++It) {
     SmallVector<BasicBlock *, 8> NewBlocks;
     SmallDenseMap<const Loop *, Loop *, 4> NewLoops;
     NewLoops[L] = L;
 
     for (LoopBlocksDFS::RPOIterator BB = BlockBegin; BB != BlockEnd; ++BB) {
       ValueToValueMapTy VMap;
       BasicBlock *New = CloneBasicBlock(*BB, VMap, "." + Twine(It));
-      Header->getParent()->insertBasicBlockAt(BlockInsertPt, New);
+      Header->getParent()->insert(BlockInsertPt, New);
 
       assert((*BB != Header || LI->getLoopFor(*BB) == L) &&
              "Header should not be in a sub-loop");
       // Tell LI about New.
       const Loop *OldLoop = addClonedBlockToLoopInfo(*BB, New, LI, NewLoops);
       if (OldLoop)
         LoopsToSimplify.insert(NewLoops[OldLoop]);
 

llvm/lib/Transforms/Utils/LoopUnrollAndJam.cpp

for (unsigned It = 1; It != Count; ++It) {
     DenseMap<Value *, Value *> PrevItValueMap;
     SmallDenseMap<const Loop *, Loop *, 4> NewLoops;
     NewLoops[L] = L;
     NewLoops[SubLoop] = SubLoop;
 
     for (LoopBlocksDFS::RPOIterator BB = BlockBegin; BB != BlockEnd; ++BB) {
       ValueToValueMapTy VMap;
       BasicBlock *New = CloneBasicBlock(*BB, VMap, "." + Twine(It));
-      Header->getParent()->insertBasicBlockAt(Header->getParent()->end(), New);
+      Header->getParent()->insert(Header->getParent()->end(), New);
 
       // Tell LI about New.
       addClonedBlockToLoopInfo(*BB, New, LI, NewLoops);
 
       if (ForeBlocks.count(*BB)) {
         if (*BB == ForeBlocksFirst[0])
           ForeBlocksFirst.push_back(New);
         if (*BB == ForeBlocksLast[0])

llvm/lib/Transforms/Utils/LowerSwitch.cpp

 /// switch's value == the case's value. If not, then it jumps to the default
 /// branch. At this point in the tree, the value can't be another valid case
 /// value, so the jump to the "default" branch is warranted.
 BasicBlock *NewLeafBlock(CaseRange &Leaf, Value *Val, ConstantInt *LowerBound,
                          ConstantInt *UpperBound, BasicBlock *OrigBlock,
                          BasicBlock *Default) {
   Function *F = OrigBlock->getParent();
   BasicBlock *NewLeaf = BasicBlock::Create(Val->getContext(), "LeafBlock");
-  F->insertBasicBlockAt(++OrigBlock->getIterator(), NewLeaf);
+  F->insert(++OrigBlock->getIterator(), NewLeaf);
 
   // Emit comparison
   ICmpInst *Comp = nullptr;
   if (Leaf.Low == Leaf.High) {
     // Make the seteq instruction...
     Comp =
         new ICmpInst(*NewLeaf, ICmpInst::ICMP_EQ, Val, Leaf.Low, "SwitchLeaf");
   } else {
BasicBlock *SwitchConvert(CaseItr Begin, CaseItr End, ConstantInt *LowerBound,
 
   BasicBlock *LBranch =
       SwitchConvert(LHS.begin(), LHS.end(), LowerBound, NewUpperBound, Val,
                     NewNode, OrigBlock, Default, UnreachableRanges);
   BasicBlock *RBranch =
       SwitchConvert(RHS.begin(), RHS.end(), NewLowerBound, UpperBound, Val,
                     NewNode, OrigBlock, Default, UnreachableRanges);
 
-  F->insertBasicBlockAt(++OrigBlock->getIterator(), NewNode);
+  F->insert(++OrigBlock->getIterator(), NewNode);
   Comp->insertAt(NewNode, NewNode->end());
 
   BranchInst::Create(LBranch, RBranch, Comp, NewNode);
   return NewNode;
 }
 
 /// Transform simple list of \p SI's cases into list of CaseRange's \p Cases.
 /// \post \p Cases wouldn't contain references to \p SI's default BB.

llvm/unittests/IR/FunctionTest.cpp

)");
 
   Function *BarF = M->getFunction("bar");
   BasicBlock *BarBB0 = getBBWithName(BarF, "bar_bb0");
   BasicBlock *BarBB1 = getBBWithName(BarF, "bar_bb1");
   BasicBlock *BarBB2 = getBBWithName(BarF, "bar_bb2");
 
   // Insert foo_bb0 into bar() at the very top.
   FooBB0->removeFromParent();
-  auto It = BarF->insertBasicBlockAt(BarF->begin(), FooBB0);
+  auto It = BarF->insert(BarF->begin(), FooBB0);
   EXPECT_EQ(BarBB0->getPrevNode(), FooBB0);
   EXPECT_EQ(It, FooBB0->getIterator());
 
   // Insert foo_bb0 into bar() at the very end.
   FooBB0->removeFromParent();
-  It = BarF->insertBasicBlockAt(BarF->end(), FooBB0);
+  It = BarF->insert(BarF->end(), FooBB0);
   EXPECT_EQ(FooBB0->getPrevNode(), BarBB2);
   EXPECT_EQ(FooBB0->getNextNode(), nullptr);
   EXPECT_EQ(It, FooBB0->getIterator());
 
   // Insert foo_bb0 into bar() just before bar_bb0.
   FooBB0->removeFromParent();
-  It = BarF->insertBasicBlockAt(BarBB0->getIterator(), FooBB0);
+  It = BarF->insert(BarBB0->getIterator(), FooBB0);
   EXPECT_EQ(FooBB0->getPrevNode(), nullptr);
   EXPECT_EQ(FooBB0->getNextNode(), BarBB0);
   EXPECT_EQ(It, FooBB0->getIterator());
 
   // Insert foo_bb0 into bar() just before bar_bb1.
   FooBB0->removeFromParent();
-  It = BarF->insertBasicBlockAt(BarBB1->getIterator(), FooBB0);
+  It = BarF->insert(BarBB1->getIterator(), FooBB0);
   EXPECT_EQ(FooBB0->getPrevNode(), BarBB0);
   EXPECT_EQ(FooBB0->getNextNode(), BarBB1);
   EXPECT_EQ(It, FooBB0->getIterator());
 
   // Insert foo_bb0 into bar() just before bar_bb2.
   FooBB0->removeFromParent();
-  It = BarF->insertBasicBlockAt(BarBB2->getIterator(), FooBB0);
+  It = BarF->insert(BarBB2->getIterator(), FooBB0);
   EXPECT_EQ(FooBB0->getPrevNode(), BarBB1);
   EXPECT_EQ(FooBB0->getNextNode(), BarBB2);
   EXPECT_EQ(It, FooBB0->getIterator());
 }
 
 TEST(FunctionTest, SpliceOneBB) {
   LLVMContext Ctx;
   std::unique_ptr<Module> M = parseIR(Ctx, R"(