[NFC] Rename Instruction::insertAt() to Instruction::insertInto(), to be consistent with BasicBlock::insertInto()

[asbirlea]

Rebase to trigger pre-merge checks?

[vporpo]

Rebase

clang/lib/CodeGen/CGCleanup.cpp

// the cleanup block and then try to clean up after ourselves.
       EHStack.popCleanup();
       assert(EHStack.hasNormalCleanups() == HasEnclosingCleanups);
 
       EmitCleanup(*this, Fn, cleanupFlags, NormalActiveFlag);
 
       // Append the prepared cleanup prologue from above.
       llvm::BasicBlock *NormalExit = Builder.GetInsertBlock();
       for (unsigned I = 0, E = InstsToAppend.size(); I != E; ++I)
-        InstsToAppend[I]->insertAt(NormalExit, NormalExit->end());
+        InstsToAppend[I]->insertInto(NormalExit, NormalExit->end());
 
       // Optimistically hope that any fixups will continue falling through.
       for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups();
            I < E; ++I) {
         BranchFixup &Fixup = EHStack.getBranchFixup(I);
         if (!Fixup.Destination) continue;
         if (!Fixup.OptimisticBranchBlock) {
           createStoreInstBefore(Builder.getInt32(Fixup.DestinationIndex),

llvm/docs/ProgrammersManual.rst

* Insertion into the instruction list of the ``BasicBlock``
   pointer to a ``BasicBlock`` to be appended to.  For example code that looked
   like:
 
   .. code-block:: c++
 
     BasicBlock *pb = ...;
     auto *newInst = new Instruction(...);
 
-    newInst->insertAt(pb, pb->end()); // Appends newInst to pb
+    newInst->insertInto(pb, pb->end()); // Appends newInst to pb
 
   becomes:
 
   .. code-block:: c++
 
     BasicBlock *pb = ...;
     auto *newInst = new Instruction(..., pb);
 

llvm/examples/BrainF/BrainF.cpp

void BrainF::header(LLVMContext& C) {
   ConstantInt *val_mem = ConstantInt::get(C, APInt(32, memtotal));
   BasicBlock* BB = builder->GetInsertBlock();
   Type* IntPtrTy = IntegerType::getInt32Ty(C);
   Type* Int8Ty = IntegerType::getInt8Ty(C);
   Constant* allocsize = ConstantExpr::getSizeOf(Int8Ty);
   allocsize = ConstantExpr::getTruncOrBitCast(allocsize, IntPtrTy);
   ptr_arr = CallInst::CreateMalloc(BB, IntPtrTy, Int8Ty, allocsize, val_mem, 
                                    nullptr, "arr");
-  cast<Instruction>(ptr_arr)->insertAt(BB, BB->end());
+  cast<Instruction>(ptr_arr)->insertInto(BB, BB->end());
 
   //call void @llvm.memset.p0i8.i32(i8 *%arr, i8 0, i32 %d, i1 0)
   {
     Value *memset_params[] = {
       ptr_arr,
       ConstantInt::get(C, APInt(8, 0)),
       val_mem,
       ConstantInt::get(C, APInt(1, 0))
curhead = builder->CreateGEP(
       Int8Ty, ptr_arr, ConstantInt::get(C, APInt(32, memtotal / 2)), headreg);
 
   //Function footer
 
   //brainf.end:
   endbb = BasicBlock::Create(C, label, brainf_func);
 
   //call free(i8 *%arr)
-  CallInst::CreateFree(ptr_arr, endbb)->insertAt(endbb, endbb->end());
+  CallInst::CreateFree(ptr_arr, endbb)->insertInto(endbb, endbb->end());
 
   //ret void
   ReturnInst::Create(C, endbb);
 
   //Error block for array out of bounds
   if (comflag & flag_arraybounds)
   {
     //@aberrormsg = internal constant [%d x i8] c"\00"

llvm/examples/ModuleMaker/ModuleMaker.cpp

int main() {
   Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2);
   Value *Three = ConstantInt::get(Type::getInt32Ty(Context), 3);
 
   // Create the add instruction... does not insert...
   Instruction *Add = BinaryOperator::Create(Instruction::Add, Two, Three,
                                             "addresult");
 
   // explicitly insert it into the basic block...
-  Add->insertAt(BB, BB->end());
+  Add->insertInto(BB, BB->end());
 
   // Create the return instruction and add it to the basic block
-  ReturnInst::Create(Context, Add)->insertAt(BB, BB->end());
+  ReturnInst::Create(Context, Add)->insertInto(BB, BB->end());
 
   // Output the bitcode file to stdout
   WriteBitcodeToFile(*M, outs());
 
   // Delete the module and all of its contents.
   delete M;
   return 0;
 }

llvm/include/llvm/IR/BasicBlock.h

public:
   using iterator = InstListType::iterator;
   using const_iterator = InstListType::const_iterator;
   using reverse_iterator = InstListType::reverse_iterator;
   using const_reverse_iterator = InstListType::const_reverse_iterator;
 
   // These functions and classes need access to the instruction list.
   friend void Instruction::removeFromParent();
   friend iplist<Instruction>::iterator Instruction::eraseFromParent();
-  friend BasicBlock::iterator Instruction::insertAt(BasicBlock *BB,
+  friend BasicBlock::iterator Instruction::insertInto(BasicBlock *BB,
                                                       BasicBlock::iterator It);
   friend class llvm::SymbolTableListTraits<llvm::Instruction>;
   friend class llvm::ilist_node_with_parent<llvm::Instruction, llvm::BasicBlock>;
 
   /// Creates a new BasicBlock.
   ///
   /// If the Parent parameter is specified, the basic block is automatically
   /// inserted at either the end of the function (if InsertBefore is 0), or
   /// before the specified basic block.
iterator_range<const_phi_iterator> phis() const {
     return const_cast<BasicBlock *>(this)->phis();
   }
   iterator_range<phi_iterator> phis();
 
 private:
   /// Return the underlying instruction list container.
   /// This is deliberately private because we have implemented an adequate set
   /// of functions to modify the list, including BasicBlock::splice(),
-  /// BasicBlock::erase(), Instruction::insertAt() etc.
+  /// BasicBlock::erase(), Instruction::insertInto() etc.
   const InstListType &getInstList() const { return InstList; }
   InstListType &getInstList() { return InstList; }
 
   /// Returns a pointer to a member of the instruction list.
   /// This is private on purpose, just like `getInstList()`.
   static InstListType BasicBlock::*getSublistAccess(Instruction *) {
     return &BasicBlock::InstList;
   }

llvm/include/llvm/IR/IRBuilder.h

 class IRBuilderDefaultInserter {
 public:
   virtual ~IRBuilderDefaultInserter();
 
   virtual void InsertHelper(Instruction *I, const Twine &Name,
                             BasicBlock *BB,
                             BasicBlock::iterator InsertPt) const {
     if (BB)
-      I->insertAt(BB, InsertPt);
+      I->insertInto(BB, InsertPt);
     I->setName(Name);
   }
 };
 
 /// Provides an 'InsertHelper' that calls a user-provided callback after
 /// performing the default insertion.
 class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {
   std::function<void(Instruction *)> Callback;

llvm/include/llvm/IR/Instruction.h

public:
   /// Insert an unlinked instruction into a basic block immediately before
   /// the specified instruction.
   void insertBefore(Instruction *InsertPos);
 
   /// Insert an unlinked instruction into a basic block immediately after the
   /// specified instruction.
   void insertAfter(Instruction *InsertPos);
 
-  /// Inserts an unlinked instruction into \p BB at position \p It and returns
-  /// the iterator of the inserted instruction.
+  /// Inserts an unlinked instruction into \p ParentBB at position \p It and
+  /// returns the iterator of the inserted instruction.
   SymbolTableList<Instruction>::iterator
-  insertAt(BasicBlock *BB, SymbolTableList<Instruction>::iterator It);
+  insertInto(BasicBlock *ParentBB, SymbolTableList<Instruction>::iterator It);
 
   /// 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);
 
   /// Unlink this instruction and insert into BB before I.
   ///
   /// \pre I is a valid iterator into BB.

llvm/include/llvm/Transforms/InstCombine/InstCombiner.h

public:
   /// Inserts an instruction \p New before instruction \p Old
   ///
   /// Also adds the new instruction to the worklist and returns \p New so that
   /// it is suitable for use as the return from the visitation patterns.
   Instruction *InsertNewInstBefore(Instruction *New, Instruction &Old) {
     assert(New && !New->getParent() &&
            "New instruction already inserted into a basic block!");
     BasicBlock *BB = Old.getParent();
-    New->insertAt(BB, Old.getIterator()); // Insert inst
+    New->insertInto(BB, Old.getIterator()); // Insert inst
     Worklist.push(New);
     return New;
   }
 
   /// Same as InsertNewInstBefore, but also sets the debug loc.
   Instruction *InsertNewInstWith(Instruction *New, Instruction &Old) {
     New->setDebugLoc(Old.getDebugLoc());
     return InsertNewInstBefore(New, Old);

llvm/lib/AsmParser/LLParser.cpp

if (Lex.getKind() == lltok::LocalVarID) {
         return true;
     }
 
     switch (parseInstruction(Inst, BB, PFS)) {
     default:
       llvm_unreachable("Unknown parseInstruction result!");
     case InstError: return true;
     case InstNormal:
-      Inst->insertAt(BB, BB->end());
+      Inst->insertInto(BB, BB->end());
 
       // With a normal result, we check to see if the instruction is followed by
       // a comma and metadata.
       if (EatIfPresent(lltok::comma))
         if (parseInstructionMetadata(*Inst))
           return true;
       break;
     case InstExtraComma:
-      Inst->insertAt(BB, BB->end());
+      Inst->insertInto(BB, BB->end());
 
       // If the instruction parser ate an extra comma at the end of it, it
       // *must* be followed by metadata.
       if (parseInstructionMetadata(*Inst))
         return true;
       break;
     }
 

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::FUNC_CODE_INST_CAST: {    // CAST: [opval, opty, destty, castopc]
       int Opc = getDecodedCastOpcode(Record[OpNum + 1]);
       if (Opc == -1 || !ResTy)
         return error("Invalid record");
       Instruction *Temp = nullptr;
       if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) {
         if (Temp) {
           InstructionList.push_back(Temp);
           assert(CurBB && "No current BB?");
-          Temp->insertAt(CurBB, CurBB->end());
+          Temp->insertInto(CurBB, CurBB->end());
         }
       } else {
         auto CastOp = (Instruction::CastOps)Opc;
         if (!CastInst::castIsValid(CastOp, Op, ResTy))
           return error("Invalid cast");
         I = CastInst::Create(CastOp, Op, ResTy);
       }
       InstructionList.push_back(I);
case bitc::FUNC_CODE_INST_CMPXCHG_OLD: {
       I = new AtomicCmpXchgInst(Ptr, Cmp, New, Alignment, SuccessOrdering,
                                 FailureOrdering, SSID);
       cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
 
       if (NumRecords < 8) {
         // Before weak cmpxchgs existed, the instruction simply returned the
         // value loaded from memory, so bitcode files from that era will be
         // expecting the first component of a modern cmpxchg.
-        I->insertAt(CurBB, CurBB->end());
+        I->insertInto(CurBB, CurBB->end());
         I = ExtractValueInst::Create(I, 0);
         ResTypeID = CmpTypeID;
       } else {
         cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum + 4]);
         unsigned I1TypeID = getVirtualTypeID(Type::getInt1Ty(Context));
         ResTypeID = getVirtualTypeID(I->getType(), {CmpTypeID, I1TypeID});
       }
 

     if (!CurBB) {
       I->deleteValue();
       return error("Invalid instruction with no BB");
     }
     if (!OperandBundles.empty()) {
       I->deleteValue();
       return error("Operand bundles found with no consumer");
     }
-    I->insertAt(CurBB, CurBB->end());
+    I->insertInto(CurBB, CurBB->end());
 
     // If this was a terminator instruction, move to the next block.
     if (I->isTerminator()) {
       ++CurBBNo;
       CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr;
     }
 
     // Non-void values get registered in the value table for future use.

llvm/lib/CodeGen/WinEHPrepare.cpp

if (auto *CatchRet =
       //     catchret label %NewBlock
       //   NewBlock:
       //     br label %PHIBlock
       // So move the terminators to each others' blocks and swap their
       // successors.
       BranchInst *Goto = cast<BranchInst>(IncomingBlock->getTerminator());
       Goto->removeFromParent();
       CatchRet->removeFromParent();
-      CatchRet->insertAt(IncomingBlock, IncomingBlock->end());
-      Goto->insertAt(NewBlock, NewBlock->end());
+      CatchRet->insertInto(IncomingBlock, IncomingBlock->end());
+      Goto->insertInto(NewBlock, NewBlock->end());
       Goto->setSuccessor(0, PHIBlock);
       CatchRet->setSuccessor(NewBlock);
       // Update the color mapping for the newly split edge.
       // Grab a reference to the ColorVector to be inserted before getting the
       // reference to the vector we are copying because inserting the new
       // element in BlockColors might cause the map to be reallocated.
       ColorVector &ColorsForNewBlock = BlockColors[NewBlock];
       ColorVector &ColorsForPHIBlock = BlockColors[PHIBlock];

llvm/lib/IR/Instruction.cpp

 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
                          Instruction *InsertBefore)
   : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
 
   // If requested, insert this instruction into a basic block...
   if (InsertBefore) {
     BasicBlock *BB = InsertBefore->getParent();
     assert(BB && "Instruction to insert before is not in a basic block!");
-    insertAt(BB, InsertBefore->getIterator());
+    insertInto(BB, InsertBefore->getIterator());
   }
 }
 
 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
                          BasicBlock *InsertAtEnd)
   : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
 
   // append this instruction into the basic block
   assert(InsertAtEnd && "Basic block to append to may not be NULL!");
-  insertAt(InsertAtEnd, InsertAtEnd->end());
+  insertInto(InsertAtEnd, InsertAtEnd->end());
 }
 
 Instruction::~Instruction() {
   assert(!Parent && "Instruction still linked in the program!");
 
   // Replace any extant metadata uses of this instruction with undef to
   // preserve debug info accuracy. Some alternatives include:
   // - Treat Instruction like any other Value, and point its extant metadata

 
 iplist<Instruction>::iterator Instruction::eraseFromParent() {
   return getParent()->getInstList().erase(getIterator());
 }
 
 /// Insert an unlinked instruction into a basic block immediately before the
 /// specified instruction.
 void Instruction::insertBefore(Instruction *InsertPos) {
-  insertAt(InsertPos->getParent(), InsertPos->getIterator());
+  insertInto(InsertPos->getParent(), InsertPos->getIterator());
 }
 
 /// Insert an unlinked instruction into a basic block immediately after the
 /// specified instruction.
 void Instruction::insertAfter(Instruction *InsertPos) {
-  insertAt(InsertPos->getParent(), std::next(InsertPos->getIterator()));
+  insertInto(InsertPos->getParent(), std::next(InsertPos->getIterator()));
 }
 
-BasicBlock::iterator Instruction::insertAt(BasicBlock *BB,
+BasicBlock::iterator Instruction::insertInto(BasicBlock *ParentBB,
                                              BasicBlock::iterator It) {
   assert(getParent() == nullptr && "Expected detached instruction");
-  assert((It == BB->end() || It->getParent() == BB) && "It not in BB");
-  return BB->getInstList().insert(It, this);
+  assert((It == ParentBB->end() || It->getParent() == ParentBB) &&
+         "It not in ParentBB");
+  return ParentBB->getInstList().insert(It, this);
 }
 
 /// Unlink this instruction from its current basic block and insert it into the
 /// basic block that MovePos lives in, right before MovePos.
 void Instruction::moveBefore(Instruction *MovePos) {
   moveBefore(*MovePos->getParent(), MovePos->getIterator());
 }
 

llvm/lib/IR/Instructions.cpp

if (InsertBefore) {
     Result = MCall;
     if (Result->getType() != AllocPtrType)
       // Create a cast instruction to convert to the right type...
       Result = new BitCastInst(MCall, AllocPtrType, Name, InsertBefore);
   } else {
     MCall = CallInst::Create(MallocFunc, AllocSize, OpB, "malloccall");
     Result = MCall;
     if (Result->getType() != AllocPtrType) {
-      MCall->insertAt(InsertAtEnd, InsertAtEnd->end());
+      MCall->insertInto(InsertAtEnd, InsertAtEnd->end());
       // Create a cast instruction to convert to the right type...
       Result = new BitCastInst(MCall, AllocPtrType, Name);
     }
   }
   MCall->setTailCall();
   if (Function *F = dyn_cast<Function>(MallocFunc.getCallee())) {
     MCall->setCallingConv(F->getCallingConv());
     if (!F->returnDoesNotAlias())
UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S,
                                      Instruction *InsertBefore) {
   return new UnaryOperator(Op, S, S->getType(), Name, InsertBefore);
 }
 
 UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S,
                                      const Twine &Name,
                                      BasicBlock *InsertAtEnd) {
   UnaryOperator *Res = Create(Op, S, Name);
-  Res->insertAt(InsertAtEnd, InsertAtEnd->end());
+  Res->insertInto(InsertAtEnd, InsertAtEnd->end());
   return Res;
 }
 
 void UnaryOperator::AssertOK() {
   Value *LHS = getOperand(0);
   (void)LHS; // Silence warnings.
 #ifndef NDEBUG
   switch (getOpcode()) {
assert(S1->getType() == S2->getType() &&
          "Cannot create binary operator with two operands of differing type!");
   return new BinaryOperator(Op, S1, S2, S1->getType(), Name, InsertBefore);
 }
 
 BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2,
                                        const Twine &Name,
                                        BasicBlock *InsertAtEnd) {
   BinaryOperator *Res = Create(Op, S1, S2, Name);
-  Res->insertAt(InsertAtEnd, InsertAtEnd->end());
+  Res->insertInto(InsertAtEnd, InsertAtEnd->end());
   return Res;
 }
 
 BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name,
                                           Instruction *InsertBefore) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
   return new BinaryOperator(Instruction::Sub,
                             zero, Op,

llvm/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

void Simplifier::Context::link(Instruction *I, BasicBlock *B,
   if (I->getParent())
     return;
 
   for (Value *Op : I->operands()) {
     if (Instruction *OpI = dyn_cast<Instruction>(Op))
       link(OpI, B, At);
   }
 
-  I->insertAt(B, At);
+  I->insertInto(B, At);
 }
 
 Value *Simplifier::Context::materialize(BasicBlock *B,
       BasicBlock::iterator At) {
   if (Instruction *RootI = dyn_cast<Instruction>(Root))
     link(RootI, B, At);
   return Root;
 }

llvm/lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

for (; AI != AE && PI != PE; ++AI, ++PI) {
     Type *ParamType = *PI;
 
     if (ArgType == ParamType) {
       Args.push_back(&*AI);
     } else {
       if (CastInst::isBitOrNoopPointerCastable(ArgType, ParamType, DL)) {
         Instruction *PtrCast =
             CastInst::CreateBitOrPointerCast(AI, ParamType, "cast");
-        PtrCast->insertAt(BB, BB->end());
+        PtrCast->insertInto(BB, BB->end());
         Args.push_back(PtrCast);
       } else if (ArgType->isStructTy() || ParamType->isStructTy()) {
         LLVM_DEBUG(dbgs() << "createWrapper: struct param type in bitcast: "
                           << F->getName() << "\n");
         WrapperNeeded = false;
       } else {
         LLVM_DEBUG(dbgs() << "createWrapper: arg type mismatch calling: "
                           << F->getName() << "\n");
if (RtnType->isVoidTy()) {
       LLVM_DEBUG(dbgs() << "Creating dummy return: " << *RtnType << "\n");
       ReturnInst::Create(M->getContext(), UndefValue::get(RtnType), BB);
     } else if (RtnType == ExpectedRtnType) {
       ReturnInst::Create(M->getContext(), Call, BB);
     } else if (CastInst::isBitOrNoopPointerCastable(ExpectedRtnType, RtnType,
                                                     DL)) {
       Instruction *Cast =
           CastInst::CreateBitOrPointerCast(Call, RtnType, "cast");
-      Cast->insertAt(BB, BB->end());
+      Cast->insertInto(BB, BB->end());
       ReturnInst::Create(M->getContext(), Cast, BB);
     } else if (RtnType->isStructTy() || ExpectedRtnType->isStructTy()) {
       LLVM_DEBUG(dbgs() << "createWrapper: struct return type in bitcast: "
                         << F->getName() << "\n");
       WrapperNeeded = false;
     } else {
       LLVM_DEBUG(dbgs() << "createWrapper: return type mismatch calling: "
                         << F->getName() << "\n");

llvm/lib/Transforms/IPO/IROutliner.cpp

for (BasicBlock *DescendBB : Descendants) {
       // overall function.
       StoreInst *SI = cast<StoreInst>(I);
 
       Value *ValueOperand = SI->getValueOperand();
 
       StoreInst *NewI = cast<StoreInst>(I->clone());
       NewI->setDebugLoc(DebugLoc());
       BasicBlock *OutputBB = VBBIt->second;
-      NewI->insertAt(OutputBB, OutputBB->end());
+      NewI->insertInto(OutputBB, OutputBB->end());
       LLVM_DEBUG(dbgs() << "Move store for instruction " << *I << " to "
                         << *OutputBB << "\n");
 
       // If this is storing a PHINode, we must make sure it is included in the
       // overall function.
       if (!isa<PHINode>(ValueOperand) ||
           Region.Candidate->getGVN(ValueOperand).has_value()) {
         if (FirstFunction)

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

public:
   /// Inserts an instruction \p New before instruction \p Old
   ///
   /// Also adds the new instruction to the worklist and returns \p New so that
   /// it is suitable for use as the return from the visitation patterns.
   Instruction *InsertNewInstBefore(Instruction *New, Instruction &Old) {
     assert(New && !New->getParent() &&
            "New instruction already inserted into a basic block!");
     BasicBlock *BB = Old.getParent();
-    New->insertAt(BB, Old.getIterator()); // Insert inst
+    New->insertInto(BB, Old.getIterator()); // Insert inst
     Worklist.add(New);
     return New;
   }
 
   /// Same as InsertNewInstBefore, but also sets the debug loc.
   Instruction *InsertNewInstWith(Instruction *New, Instruction &Old) {
     New->setDebugLoc(Old.getDebugLoc());
     return InsertNewInstBefore(New, Old);

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

if (!isa<BitCastInst>(SrcOp) && GEP.accumulateConstantOffset(DL, Offset) &&
     if (!Offset) {
       // If the bitcast is of an allocation, and the allocation will be
       // converted to match the type of the cast, don't touch this.
       if (isa<AllocaInst>(SrcOp)) {
         // See if the bitcast simplifies, if so, don't nuke this GEP yet.
         if (Instruction *I = visitBitCast(*BCI)) {
           if (I != BCI) {
             I->takeName(BCI);
-            I->insertAt(BCI->getParent(), BCI->getIterator());
+            I->insertInto(BCI->getParent(), BCI->getIterator());
             replaceInstUsesWith(*BCI, I);
           }
           return &GEP;
         }
       }
 
       if (SrcType->getPointerAddressSpace() != GEP.getAddressSpace())
         return new AddrSpaceCastInst(SrcOp, GEP.getType());
if (DI == -1) {
 
       for (auto &I : PN->operands())
         NewPN->addIncoming(cast<GEPOperator>(I)->getOperand(DI),
                            PN->getIncomingBlock(I));
 
       NewGEP->setOperand(DI, NewPN);
     }
 
-    NewGEP->insertAt(GEP.getParent(), GEP.getParent()->getFirstInsertionPt());
+    NewGEP->insertInto(GEP.getParent(), GEP.getParent()->getFirstInsertionPt());
     return replaceOperand(GEP, 0, NewGEP);
   }
 
   if (auto *Src = dyn_cast<GEPOperator>(PtrOp))
     if (Instruction *I = visitGEPOfGEP(GEP, Src))
       return I;
 
   // Skip if GEP source element type is scalable. The type alloc size is unknown
if (Instruction *Result = visit(*I)) {
         if (isa<PHINode>(Result) != isa<PHINode>(I)) {
           // We need to fix up the insertion point.
           if (isa<PHINode>(I)) // PHI -> Non-PHI
             InsertPos = InstParent->getFirstInsertionPt();
           else // Non-PHI -> PHI
             InsertPos = InstParent->getFirstNonPHI()->getIterator();
         }
 
-        Result->insertAt(InstParent, InsertPos);
+        Result->insertInto(InstParent, InsertPos);
 
         // Push the new instruction and any users onto the worklist.
         Worklist.pushUsersToWorkList(*Result);
         Worklist.push(Result);
 
         eraseInstFromFunction(*I);
       } else {
         LLVM_DEBUG(dbgs() << "IC: Mod = " << OrigI << '\n'

llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp

assert(VMap.find(NewEntryBlock) != VMap.end() &&
          "NewEntryBlock must have been copied");
   OldBR->dropAllReferences();
   OldBR->eraseFromParent();
   // The true predicate is a placeholder. It will be replaced later in
   // fixupBranchesAndSelects().
   BranchInst *NewBR = BranchInst::Create(NewEntryBlock,
                                          cast<BasicBlock>(VMap[NewEntryBlock]),
                                          ConstantInt::getTrue(F.getContext()));
-  NewBR->insertAt(PreEntryBlock, PreEntryBlock->end());
+  NewBR->insertInto(PreEntryBlock, PreEntryBlock->end());
   assert(NewEntryBlock->getSinglePredecessor() == EntryBlock &&
          "NewEntryBlock's only pred must be EntryBlock");
   return NewBR;
 }
 
 // A helper for transformScopes. Create the combined branch condition and
 // constant-fold the branches/selects in the hot path.
 void CHR::fixupBranchesAndSelects(CHRScope *Scope,

llvm/lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp

for (uint64_t SizeId : SizeIds) {
     BasicBlock *CaseBB = BasicBlock::Create(
         Ctx, Twine("MemOP.Case.") + Twine(SizeId), &Func, DefaultBB);
     MemOp NewMO = MO.clone();
     // Fix the argument.
     auto *SizeType = dyn_cast<IntegerType>(NewMO.getLength()->getType());
     assert(SizeType && "Expected integer type size argument.");
     ConstantInt *CaseSizeId = ConstantInt::get(SizeType, SizeId);
     NewMO.setLength(CaseSizeId);
-    NewMO.I->insertAt(CaseBB, CaseBB->end());
+    NewMO.I->insertInto(CaseBB, CaseBB->end());
     IRBuilder<> IRBCase(CaseBB);
     IRBCase.CreateBr(MergeBB);
     SI->addCase(CaseSizeId, CaseBB);
     if (!MemOpTy->isVoidTy())
       PHI->addIncoming(NewMO.I, CaseBB);
     if (DT) {
       Updates.push_back({DominatorTree::Insert, CaseBB, MergeBB});
       Updates.push_back({DominatorTree::Insert, BB, CaseBB});

llvm/lib/Transforms/Scalar/JumpThreading.cpp

JumpThreadingPass::cloneInstructions(BasicBlock::iterator BI,
   cloneNoAliasScopes(NoAliasScopes, ClonedScopes, "thread", Context);
 
   // Clone the non-phi instructions of the source basic block into NewBB,
   // keeping track of the mapping and using it to remap operands in the cloned
   // instructions.
   for (; BI != BE; ++BI) {
     Instruction *New = BI->clone();
     New->setName(BI->getName());
-    New->insertAt(NewBB, NewBB->end());
+    New->insertInto(NewBB, NewBB->end());
     ValueMapping[&*BI] = New;
     adaptNoAliasScopes(New, ClonedScopes, Context);
 
     // Remap operands to patch up intra-block references.
     for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
       if (Instruction *Inst = dyn_cast<Instruction>(New->getOperand(i))) {
         DenseMap<Instruction *, Value *>::iterator I = ValueMapping.find(Inst);
         if (I != ValueMapping.end())
if (Value *IV = simplifyInstruction(
         New = nullptr;
       }
     } else {
       ValueMapping[&*BI] = New;
     }
     if (New) {
       // Otherwise, insert the new instruction into the block.
       New->setName(BI->getName());
-      New->insertAt(PredBB, OldPredBranch->getIterator());
+      New->insertInto(PredBB, OldPredBranch->getIterator());
       // Update Dominance from simplified New instruction operands.
       for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
         if (BasicBlock *SuccBB = dyn_cast<BasicBlock>(New->getOperand(i)))
           Updates.push_back({DominatorTree::Insert, PredBB, SuccBB});
     }
   }
 
   // Check to see if the targets of the branch had PHI nodes. If so, we need to
void JumpThreadingPass::unfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB,
   //  |-----
   //  v
   // BB
   BranchInst *PredTerm = cast<BranchInst>(Pred->getTerminator());
   BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "select.unfold",
                                          BB->getParent(), BB);
   // Move the unconditional branch to NewBB.
   PredTerm->removeFromParent();
-  PredTerm->insertAt(NewBB, NewBB->end());
+  PredTerm->insertInto(NewBB, NewBB->end());
   // Create a conditional branch and update PHI nodes.
   auto *BI = BranchInst::Create(NewBB, BB, SI->getCondition(), Pred);
   BI->applyMergedLocation(PredTerm->getDebugLoc(), SI->getDebugLoc());
   SIUse->setIncomingValue(Idx, SI->getFalseValue());
   SIUse->addIncoming(SI->getTrueValue(), NewBB);
 
   // The select is now dead.
   SI->eraseFromParent();

llvm/lib/Transforms/Scalar/LICM.cpp

if (!BlockColors.empty()) {
         OpBundles.emplace_back("funclet", EHPad);
     }
 
     New = CallInst::Create(CI, OpBundles);
   } else {
     New = I.clone();
   }
 
-  New->insertAt(&ExitBlock, ExitBlock.getFirstInsertionPt());
+  New->insertInto(&ExitBlock, ExitBlock.getFirstInsertionPt());
   if (!I.getName().empty())
     New->setName(I.getName() + ".le");
 
   if (MSSAU.getMemorySSA()->getMemoryAccess(&I)) {
     // Create a new MemoryAccess and let MemorySSA set its defining access.
     MemoryAccess *NewMemAcc = MSSAU.createMemoryAccessInBB(
         New, nullptr, New->getParent(), MemorySSA::Beginning);
     if (NewMemAcc) {

llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp

for (BasicBlock *ExitingBlock : ExitingBlocks) {
     if (Cond->getNextNonDebugInstruction() != TermBr) {
       if (Cond->hasOneUse()) {
         Cond->moveBefore(TermBr);
       } else {
         // Clone the terminating condition and insert into the loopend.
         ICmpInst *OldCond = Cond;
         Cond = cast<ICmpInst>(Cond->clone());
         Cond->setName(L->getHeader()->getName() + ".termcond");
-        Cond->insertAt(ExitingBlock, TermBr->getIterator());
+        Cond->insertInto(ExitingBlock, TermBr->getIterator());
 
         // Clone the IVUse, as the old use still exists!
         CondUse = &IU.AddUser(Cond, CondUse->getOperandValToReplace());
         TermBr->replaceUsesOfWith(OldCond, Cond);
       }
     }
 
     // If we get to here, we know that we can transform the setcc instruction to

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

 static void buildPartialInvariantUnswitchConditionalBranch(
     BasicBlock &BB, ArrayRef<Value *> ToDuplicate, bool Direction,
     BasicBlock &UnswitchedSucc, BasicBlock &NormalSucc, Loop &L,
     MemorySSAUpdater *MSSAU) {
   ValueToValueMapTy VMap;
   for (auto *Val : reverse(ToDuplicate)) {
     Instruction *Inst = cast<Instruction>(Val);
     Instruction *NewInst = Inst->clone();
-    NewInst->insertAt(&BB, BB.end());
+    NewInst->insertInto(&BB, BB.end());
     RemapInstruction(NewInst, VMap,
                      RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
     VMap[Val] = NewInst;
 
     if (!MSSAU)
       continue;
 
     MemorySSA *MSSA = MSSAU->getMemorySSA();
if (FullUnswitch) {
     // 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.setCondition(Cond);
     if (MSSAU) {
       // Temporarily clone the terminator, to make MSSA update cheaper by
       // separating "insert edge" updates from "remove edge" ones.
-      BI.clone()->insertAt(ParentBB, ParentBB->end());
+      BI.clone()->insertInto(ParentBB, ParentBB->end());
     } else {
       // Create a new unconditional branch that will continue the loop as a new
       // terminator.
       BranchInst::Create(ContinueBB, ParentBB);
     }
     BI.setSuccessor(LoopExitSuccIdx, UnswitchedBB);
     BI.setSuccessor(1 - LoopExitSuccIdx, NewPH);
   } else {
static void unswitchNontrivialInvariants(
   SplitBB->getTerminator()->eraseFromParent();
   if (FullUnswitch) {
     // Splice the terminator from the original loop and rewrite its
     // successors.
     SplitBB->splice(SplitBB->end(), ParentBB, TI.getIterator());
 
     // Keep a clone of the terminator for MSSA updates.
     Instruction *NewTI = TI.clone();
-    NewTI->insertAt(ParentBB, ParentBB->end());
+    NewTI->insertInto(ParentBB, ParentBB->end());
 
     // First wire up the moved terminator to the preheaders.
     if (BI) {
       BasicBlock *ClonedPH = ClonedPHs.begin()->second;
       BI->setSuccessor(ClonedSucc, ClonedPH);
       BI->setSuccessor(1 - ClonedSucc, LoopPH);
       Value *Cond = skipTrivialSelect(BI->getCondition());
       if (InsertFreeze) {

llvm/lib/Transforms/Scalar/SimplifyCFGPass.cpp

Instruction *CanonicalTerm;
     CanonicalBB = BasicBlock::Create(
         F.getContext(), Twine("common.") + Term->getOpcodeName(), &F, BBs[0]);
     // We'll also need a PHI node per each operand of the terminator.
     NewOps.resize(Term->getNumOperands());
     for (auto I : zip(Term->operands(), NewOps)) {
       std::get<1>(I) = PHINode::Create(std::get<0>(I)->getType(),
                                        /*NumReservedValues=*/BBs.size(),
                                        CanonicalBB->getName() + ".op");
-      std::get<1>(I)->insertAt(CanonicalBB, CanonicalBB->end());
+      std::get<1>(I)->insertInto(CanonicalBB, CanonicalBB->end());
     }
     // Make it so that this canonical block actually has the right
     // terminator.
     CanonicalTerm = Term->clone();
-    CanonicalTerm->insertAt(CanonicalBB, CanonicalBB->end());
+    CanonicalTerm->insertInto(CanonicalBB, CanonicalBB->end());
     // If the canonical terminator has operands, rewrite it to take PHI's.
     for (auto I : zip(NewOps, CanonicalTerm->operands()))
       std::get<1>(I) = std::get<0>(I);
   }
 
   // Now, go through each block (with the current terminator type)
   // we've recorded, and rewrite it to branch to the new common block.
   const DILocation *CommonDebugLoc = nullptr;

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

 
 // Generate a bitcast (no type change) to replace the uses of TLS Candidate.
 Instruction *TLSVariableHoistPass::genBitCastInst(Function &Fn,
                                                   GlobalVariable *GV) {
   BasicBlock *PosBB = &Fn.getEntryBlock();
   BasicBlock::iterator Iter = findInsertPos(Fn, GV, PosBB);
   Type *Ty = GV->getType();
   auto *CastInst = new BitCastInst(GV, Ty, "tls_bitcast");
-  CastInst->insertAt(PosBB, Iter);
+  CastInst->insertInto(PosBB, Iter);
   return CastInst;
 }
 
 bool TLSVariableHoistPass::tryReplaceTLSCandidate(Function &Fn,
                                                   GlobalVariable *GV) {
 
   tlshoist::TLSCandidate &Cand = TLSCandMap[GV];
 

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

assert(I->getParent() == nullptr &&
          "ReplaceInstWithInst: Instruction already inserted into basic block!");
 
   // Copy debug location to newly added instruction, if it wasn't already set
   // by the caller.
   if (!I->getDebugLoc())
     I->setDebugLoc(BI->getDebugLoc());
 
   // Insert the new instruction into the basic block...
-  BasicBlock::iterator New = I->insertAt(BB, BI);
+  BasicBlock::iterator New = I->insertInto(BB, BI);
 
   // Replace all uses of the old instruction, and delete it.
   ReplaceInstWithValue(BI, I);
 
   // Move BI back to point to the newly inserted instruction
   BI = New;
 }
 
if (!NewBB2Preds.empty()) {
 
     // Update the PHI nodes in OrigBB with the values coming from NewBB2.
     UpdatePHINodes(OrigBB, NewBB2, NewBB2Preds, BI2, HasLoopExit);
   }
 
   LandingPadInst *LPad = OrigBB->getLandingPadInst();
   Instruction *Clone1 = LPad->clone();
   Clone1->setName(Twine("lpad") + Suffix1);
-  Clone1->insertAt(NewBB1, NewBB1->getFirstInsertionPt());
+  Clone1->insertInto(NewBB1, NewBB1->getFirstInsertionPt());
 
   if (NewBB2) {
     Instruction *Clone2 = LPad->clone();
     Clone2->setName(Twine("lpad") + Suffix2);
-    Clone2->insertAt(NewBB2, NewBB2->getFirstInsertionPt());
+    Clone2->insertInto(NewBB2, NewBB2->getFirstInsertionPt());
 
     // Create a PHI node for the two cloned landingpad instructions only
     // if the original landingpad instruction has some uses.
     if (!LPad->use_empty()) {
       assert(!LPad->getType()->isTokenTy() &&
              "Split cannot be applied if LPad is token type. Otherwise an "
              "invalid PHINode of token type would be created.");
       PHINode *PN = PHINode::Create(LPad->getType(), 2, "lpad.phi", LPad);

 }
 
 ReturnInst *llvm::FoldReturnIntoUncondBranch(ReturnInst *RI, BasicBlock *BB,
                                              BasicBlock *Pred,
                                              DomTreeUpdater *DTU) {
   Instruction *UncondBranch = Pred->getTerminator();
   // Clone the return and add it to the end of the predecessor.
   Instruction *NewRet = RI->clone();
-  NewRet->insertAt(Pred, Pred->end());
+  NewRet->insertInto(Pred, Pred->end());
 
   // If the return instruction returns a value, and if the value was a
   // PHI node in "BB", propagate the right value into the return.
   for (Use &Op : NewRet->operands()) {
     Value *V = Op;
     Instruction *NewBC = nullptr;
     if (BitCastInst *BCI = dyn_cast<BitCastInst>(V)) {
       // Return value might be bitcasted. Clone and insert it before the
       // return instruction.
       V = BCI->getOperand(0);
       NewBC = BCI->clone();
-      NewBC->insertAt(Pred, NewRet->getIterator());
+      NewBC->insertInto(Pred, NewRet->getIterator());
       Op = NewBC;
     }
 
     Instruction *NewEV = nullptr;
     if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(V)) {
       V = EVI->getOperand(0);
       NewEV = EVI->clone();
       if (NewBC) {
         NewBC->setOperand(0, NewEV);
-        NewEV->insertAt(Pred, NewBC->getIterator());
+        NewEV->insertInto(Pred, NewBC->getIterator());
       } else {
-        NewEV->insertAt(Pred, NewRet->getIterator());
+        NewEV->insertInto(Pred, NewRet->getIterator());
         Op = NewEV;
       }
     }
 
     if (PHINode *PN = dyn_cast<PHINode>(V)) {
       if (PN->getParent() == BB) {
         if (NewEV) {
           NewEV->setOperand(0, PN->getIncomingValueForBlock(Pred));

llvm/lib/Transforms/Utils/CloneFunction.cpp

BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap,
   // Loop over all instructions, and copy them over.
   for (const Instruction &I : *BB) {
     if (DIFinder && TheModule)
       DIFinder->processInstruction(*TheModule, I);
 
     Instruction *NewInst = I.clone();
     if (I.hasName())
       NewInst->setName(I.getName() + NameSuffix);
-    NewInst->insertAt(NewBB, NewBB->end());
+    NewInst->insertInto(NewBB, NewBB->end());
     VMap[&I] = NewInst; // Add instruction map to value.
 
     if (isa<CallInst>(I) && !I.isDebugOrPseudoInst()) {
       hasCalls = true;
       hasMemProfMetadata |= I.hasMetadata(LLVMContext::MD_memprof);
     }
     if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
       if (!AI->isStaticAlloca()) {
if (!isa<PHINode>(NewInst) && !isa<DbgVariableIntrinsic>(NewInst)) {
           continue;
         }
       }
     }
 
     if (II->hasName())
       NewInst->setName(II->getName() + NameSuffix);
     VMap[&*II] = NewInst; // Add instruction map to value.
-    NewInst->insertAt(NewBB, NewBB->end());
+    NewInst->insertInto(NewBB, NewBB->end());
     if (isa<CallInst>(II) && !II->isDebugOrPseudoInst()) {
       hasCalls = true;
       hasMemProfMetadata |= II->hasMetadata(LLVMContext::MD_memprof);
     }
 
     if (CodeInfo) {
       CodeInfo->OrigVMap[&*II] = NewInst;
       if (auto *CB = dyn_cast<CallBase>(&*II))
if (Cond) { // Constant fold to uncond branch!
       TerminatorDone = true;
     }
   }
 
   if (!TerminatorDone) {
     Instruction *NewInst = OldTI->clone();
     if (OldTI->hasName())
       NewInst->setName(OldTI->getName() + NameSuffix);
-    NewInst->insertAt(NewBB, NewBB->end());
+    NewInst->insertInto(NewBB, NewBB->end());
     VMap[OldTI] = NewInst; // Add instruction map to value.
 
     if (CodeInfo) {
       CodeInfo->OrigVMap[OldTI] = NewInst;
       if (auto *CB = dyn_cast<CallBase>(OldTI))
         if (CB->hasOperandBundles())
           CodeInfo->OperandBundleCallSites.push_back(NewInst);
     }

llvm/lib/Transforms/Utils/CodeExtractor.cpp

if (AggregateArgs && !StructValues.empty()) {
     // Store aggregated inputs in the struct.
     for (unsigned i = 0, e = StructValues.size(); i != e; ++i) {
       if (inputs.contains(StructValues[i])) {
         Value *Idx[2];
         Idx[0] = Constant::getNullValue(Type::getInt32Ty(Context));
         Idx[1] = ConstantInt::get(Type::getInt32Ty(Context), i);
         GetElementPtrInst *GEP = GetElementPtrInst::Create(
             StructArgTy, Struct, Idx, "gep_" + StructValues[i]->getName());
-        GEP->insertAt(codeReplacer, codeReplacer->end());
+        GEP->insertInto(codeReplacer, codeReplacer->end());
         new StoreInst(StructValues[i], GEP, codeReplacer);
         NumAggregatedInputs++;
       }
     }
   }
 
   // Emit the call to the function
   call = CallInst::Create(newFunction, params,
                           NumExitBlocks > 1 ? "targetBlock" : "");
   // Add debug location to the new call, if the original function has debug
   // info. In that case, the terminator of the entry block of the extracted
   // function contains the first debug location of the extracted function,
   // set in extractCodeRegion.
   if (codeReplacer->getParent()->getSubprogram()) {
     if (auto DL = newFunction->getEntryBlock().getTerminator()->getDebugLoc())
       call->setDebugLoc(DL);
   }
-  call->insertAt(codeReplacer, codeReplacer->end());
+  call->insertInto(codeReplacer, codeReplacer->end());
 
   // Set swifterror parameter attributes.
   for (unsigned SwiftErrArgNo : SwiftErrorArgs) {
     call->addParamAttr(SwiftErrArgNo, Attribute::SwiftError);
     newFunction->addParamAttr(SwiftErrArgNo, Attribute::SwiftError);
   }
 
   // Reload the outputs passed in by reference, use the struct if output is in
   // the aggregate or reload from the scalar argument.
   for (unsigned i = 0, e = outputs.size(), scalarIdx = 0,
                 aggIdx = NumAggregatedInputs;
        i != e; ++i) {
     Value *Output = nullptr;
     if (AggregateArgs && StructValues.contains(outputs[i])) {
       Value *Idx[2];
       Idx[0] = Constant::getNullValue(Type::getInt32Ty(Context));
       Idx[1] = ConstantInt::get(Type::getInt32Ty(Context), aggIdx);
       GetElementPtrInst *GEP = GetElementPtrInst::Create(
           StructArgTy, Struct, Idx, "gep_reload_" + outputs[i]->getName());
-      GEP->insertAt(codeReplacer, codeReplacer->end());
+      GEP->insertInto(codeReplacer, codeReplacer->end());
       Output = GEP;
       ++aggIdx;
     } else {
       Output = ReloadOutputs[scalarIdx];
       ++scalarIdx;
     }
     LoadInst *load = new LoadInst(outputs[i]->getType(), Output,
                                   outputs[i]->getName() + ".reload",
any_of(Blocks, [&BranchI](const BasicBlock *BB) {
       return any_of(*BB, [&BranchI](const Instruction &I) {
         if (!I.getDebugLoc())
           return false;
         BranchI->setDebugLoc(I.getDebugLoc());
         return true;
       });
     });
   }
-  BranchI->insertAt(newFuncRoot, newFuncRoot->end());
+  BranchI->insertInto(newFuncRoot, newFuncRoot->end());
 
   ValueSet SinkingCands, HoistingCands;
   BasicBlock *CommonExit = nullptr;
   findAllocas(CEAC, SinkingCands, HoistingCands, CommonExit);
   assert(HoistingCands.empty() || CommonExit);
 
   // Find inputs to, outputs from the code region.
   findInputsOutputs(inputs, outputs, SinkingCands);

llvm/lib/Transforms/Utils/LibCallsShrinkWrap.cpp

void LibCallsShrinkWrap::shrinkWrapCI(CallInst *CI, Value *Cond) {
   Instruction *NewInst =
       SplitBlockAndInsertIfThen(Cond, CI, false, BranchWeights, DT);
   BasicBlock *CallBB = NewInst->getParent();
   CallBB->setName("cdce.call");
   BasicBlock *SuccBB = CallBB->getSingleSuccessor();
   assert(SuccBB && "The split block should have a single successor");
   SuccBB->setName("cdce.end");
   CI->removeFromParent();
-  CI->insertAt(CallBB, CallBB->getFirstInsertionPt());
+  CI->insertInto(CallBB, CallBB->getFirstInsertionPt());
   LLVM_DEBUG(dbgs() << "== Basic Block After ==");
   LLVM_DEBUG(dbgs() << *CallBB->getSinglePredecessor() << *CallBB
                     << *CallBB->getSingleSuccessor() << "\n");
 }
 
 // Perform the transformation to a single candidate.
 bool LibCallsShrinkWrap::perform(CallInst *CI) {
   LibFunc Func;

llvm/lib/Transforms/Utils/LowerSwitch.cpp

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->insert(++OrigBlock->getIterator(), NewNode);
-  Comp->insertAt(NewNode, NewNode->end());
+  Comp->insertInto(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.
 /// \returns Number of \p SI's cases that do not reference \p SI's default BB.

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

for (Instruction &BonusInst : *BB) {
     // For an analogous reason, we must also drop all the metadata whose
     // semantics we don't understand. We *can* preserve !annotation, because
     // it is tied to the instruction itself, not the value or position.
     // Similarly strip attributes on call parameters that may cause UB in
     // location the call is moved to.
     NewBonusInst->dropUndefImplyingAttrsAndUnknownMetadata(
         LLVMContext::MD_annotation);
 
-    NewBonusInst->insertAt(PredBlock, PTI->getIterator());
+    NewBonusInst->insertInto(PredBlock, PTI->getIterator());
     NewBonusInst->takeName(&BonusInst);
     BonusInst.setName(NewBonusInst->getName() + ".old");
 
     // Update (liveout) uses of bonus instructions,
     // now that the bonus instruction has been cloned into predecessor.
     // Note that we expect to be in a block-closed SSA form for this to work!
     for (Use &U : make_early_inc_range(BonusInst.uses())) {
       auto *UI = cast<Instruction>(U.getUser());
for (PHINode &PN : Succ->phis()) {
       if (passingValueIsAlwaysUndefined(BB1V, &PN) ||
           passingValueIsAlwaysUndefined(BB2V, &PN))
         return Changed;
     }
   }
 
   // Okay, it is safe to hoist the terminator.
   Instruction *NT = I1->clone();
-  NT->insertAt(BIParent, BI->getIterator());
+  NT->insertInto(BIParent, BI->getIterator());
   if (!NT->getType()->isVoidTy()) {
     I1->replaceAllUsesWith(NT);
     I2->replaceAllUsesWith(NT);
     NT->takeName(I1);
   }
   Changed = true;
   ++NumHoistCommonInstrs;
 
InvokeInst *MergedInvoke = [&Invokes, HasNormalDest]() {
     Function *Func = II0BB->getParent();
     LLVMContext &Ctx = II0->getContext();
 
     BasicBlock *MergedInvokeBB = BasicBlock::Create(
         Ctx, II0BB->getName() + ".invoke", Func, InsertBeforeBlock);
 
     auto *MergedInvoke = cast<InvokeInst>(II0->clone());
     // NOTE: all invokes have the same attributes, so no handling needed.
-    MergedInvoke->insertAt(MergedInvokeBB, MergedInvokeBB->end());
+    MergedInvoke->insertInto(MergedInvokeBB, MergedInvokeBB->end());
 
     if (!HasNormalDest) {
       // This set does not have a normal destination,
       // so just form a new block with unreachable terminator.
       BasicBlock *MergedNormalDest = BasicBlock::Create(
           Ctx, II0BB->getName() + ".cont", Func, InsertBeforeBlock);
       new UnreachableInst(Ctx, MergedNormalDest);
       MergedInvoke->setNormalDest(MergedNormalDest);
for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) {
           N = nullptr;
         }
       } else {
         if (!BBI->use_empty())
           TranslateMap[&*BBI] = N;
       }
       if (N) {
         // Insert the new instruction into its new home.
-        N->insertAt(EdgeBB, InsertPt);
+        N->insertInto(EdgeBB, InsertPt);
 
         // Register the new instruction with the assumption cache if necessary.
         if (auto *Assume = dyn_cast<AssumeInst>(N))
           if (AC)
             AC->registerAssumption(Assume);
       }
     }
 

llvm/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp

bool unifyReturnBlocks(Function &F) {
 
   PHINode *PN = nullptr;
   if (F.getReturnType()->isVoidTy()) {
     ReturnInst::Create(F.getContext(), nullptr, NewRetBlock);
   } else {
     // If the function doesn't return void... add a PHI node to the block...
     PN = PHINode::Create(F.getReturnType(), ReturningBlocks.size(),
                          "UnifiedRetVal");
-    PN->insertAt(NewRetBlock, NewRetBlock->end());
+    PN->insertInto(NewRetBlock, NewRetBlock->end());
     ReturnInst::Create(F.getContext(), PN, NewRetBlock);
   }
 
   // Loop over all of the blocks, replacing the return instruction with an
   // unconditional branch.
   for (BasicBlock *BB : ReturningBlocks) {
     // Add an incoming element to the PHI node for every return instruction that
     // is merging into this new block...

llvm/unittests/Analysis/AssumeBundleQueriesTest.cpp

static void RunRandTest(uint64_t Seed, int Size, int MinCount, int MaxCount,
   FunctionType *FuncType =
       FunctionType::get(Type::getVoidTy(C), TypeArgs, false);
 
   Function *F =
       Function::Create(FuncType, GlobalValue::ExternalLinkage, "test", &*Mod);
   BasicBlock *BB = BasicBlock::Create(C);
   BB->insertInto(F);
   Instruction *Ret = ReturnInst::Create(C);
-  Ret->insertAt(BB, BB->begin());
+  Ret->insertInto(BB, BB->begin());
   Function *FnAssume = Intrinsic::getDeclaration(Mod.get(), Intrinsic::assume);
 
   std::vector<Argument *> ShuffledArgs;
   BitVector HasArg;
   for (auto &Arg : F->args()) {
     ShuffledArgs.push_back(&Arg);
     HasArg.push_back(false);
   }

llvm/unittests/Analysis/MemorySSATest.cpp

TEST_F(MemorySSATest, SinkLoad) {
 
   // Mimic sinking of a load:
   // - clone load
   // - insert in "exit" block
   // - insert in mssa
   // - remove from original block
 
   LoadInst *LoadInstClone = cast<LoadInst>(LoadInst1->clone());
-  LoadInstClone->insertAt(Merge, Merge->begin());
+  LoadInstClone->insertInto(Merge, Merge->begin());
   MemoryAccess * NewLoadAccess =
       Updater.createMemoryAccessInBB(LoadInstClone, nullptr,
                                      LoadInstClone->getParent(),
                                      MemorySSA::Beginning);
   Updater.insertUse(cast<MemoryUse>(NewLoadAccess));
   MSSA.verifyMemorySSA();
   Updater.removeMemoryAccess(MSSA.getMemoryAccess(LoadInst1));
   MSSA.verifyMemorySSA();

llvm/unittests/Analysis/ValueTrackingTest.cpp

TEST_F(ComputeKnownBitsTest, ComputeKnownBitsUnknownVScale) {
 
   KnownBits Known = computeKnownBits(CI, M.getDataLayout(), /* Depth */ 0);
   // There is no parent function so we cannot look up the vscale_range
   // attribute to determine the number of bits.
   EXPECT_EQ(Known.One.getZExtValue(), 0u);
   EXPECT_EQ(Known.Zero.getZExtValue(), 0u);
 
   BasicBlock *BB = BasicBlock::Create(Context);
-  CI->insertAt(BB, BB->end());
+  CI->insertInto(BB, BB->end());
   Known = computeKnownBits(CI, M.getDataLayout(), /* Depth */ 0);
   // There is no parent function so we cannot look up the vscale_range
   // attribute to determine the number of bits.
   EXPECT_EQ(Known.One.getZExtValue(), 0u);
   EXPECT_EQ(Known.Zero.getZExtValue(), 0u);
 
   CI->removeFromParent();
   delete CI;

llvm/unittests/IR/InstructionsTest.cpp

std::unique_ptr<Module> M = parseIR(Ctx, R"(
     }
 )");
   Function *F = &*M->begin();
   Argument *ArgA = F->getArg(0);
   Argument *ArgB = F->getArg(1);
   BasicBlock *BB = &*F->begin();
   Instruction *Ret = &*BB->begin();
   Instruction *I = BinaryOperator::CreateAdd(ArgA, ArgB);
-  auto It = I->insertAt(BB, BB->begin());
+  auto It = I->insertInto(BB, BB->begin());
   EXPECT_EQ(&*It, I);
   EXPECT_EQ(I->getNextNode(), Ret);
 }
 
 TEST(InstructionsTest, InsertAtEnd) {
   LLVMContext Ctx;
   std::unique_ptr<Module> M = parseIR(Ctx, R"(
     define void @f(i32 %a, i32 %b) {
      entry:
        ret void
     }
 )");
   Function *F = &*M->begin();
   Argument *ArgA = F->getArg(0);
   Argument *ArgB = F->getArg(1);
   BasicBlock *BB = &*F->begin();
   Instruction *Ret = &*BB->begin();
   Instruction *I = BinaryOperator::CreateAdd(ArgA, ArgB);
-  auto It = I->insertAt(BB, BB->end());
+  auto It = I->insertInto(BB, BB->end());
   EXPECT_EQ(&*It, I);
   EXPECT_EQ(Ret->getNextNode(), I);
 }
 
 } // end anonymous namespace
 } // end namespace llvm