reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/ADT/ilist.h

  359     auto I = N.getIterator();
  371     auto Next = std::next(N.getIterator());

include/llvm/Analysis/MemorySSA.h

  179     return this->AllAccessType::getIterator();
  191     return this->DefsOnlyType::getIterator();

include/llvm/CodeGen/MachineInstrBuilder.h

  540         End(getBundleEnd(MI->getIterator())) {}
  563       Begin = MI->getIterator();

include/llvm/CodeGen/MachineInstrBundle.h

  118       InstrI = getBundleStart(MI.getIterator());
  121       InstrI = InstrE = MI.getIterator();

include/llvm/CodeGen/MachineRegisterInfo.h

 1037             getBundleStart(Op->getParent()->getIterator());
 1040         } while (Op && getBundleStart(Op->getParent()->getIterator()) == P);
 1143             getBundleStart(Op->getParent()->getIterator());
 1146         } while (Op && getBundleStart(Op->getParent()->getIterator()) == P);
 1159         return *getBundleStart(Op->getParent()->getIterator());

include/llvm/CodeGen/SlotIndexes.h

  272         return SlotIndex(&*++listEntry()->getIterator(), Slot_Block);
  280       return SlotIndex(&*++listEntry()->getIterator(), getSlot());
  292         return SlotIndex(&*--listEntry()->getIterator(), Slot_Dead);
  300       return SlotIndex(&*--listEntry()->getIterator(), getSlot());
  413       IndexList::iterator I = Index.listEntry()->getIterator();
  552         nextItr = getIndexAfter(MI).listEntry()->getIterator();
  556         prevItr = getIndexBefore(MI).listEntry()->getIterator();
  616         newItr = indexList.insertAfter(startEntry->getIterator(), endEntry);
  620         newItr = indexList.insert(endEntry->getIterator(), startEntry);

include/llvm/IR/BasicBlock.h

  391     return splitBasicBlock(I->getIterator(), BBName);

include/llvm/IR/IRBuilder.h

  141     InsertPt = I->getIterator();

lib/Analysis/LazyValueInfo.cpp

  844   if (BBI->getIterator() == BBI->getParent()->begin())
  846   for (Instruction &I : make_range(std::next(BBI->getIterator().getReverse()),

lib/Analysis/Lint.cpp

  643              std::prev(I.getIterator())->mayHaveSideEffects(),
  675     BasicBlock::iterator BBI = L->getIterator();

lib/Analysis/Loads.cpp

  287   BasicBlock::iterator BBI = ScanFrom->getIterator(),

lib/Analysis/MemoryDependenceAnalysis.cpp

  754           getPointerDependencyFrom(MemLoc, isLoad, ScanPos->getIterator(),
  759                                          ScanPos->getIterator(), QueryParent);
  868         ScanPos = Inst->getIterator();
 1007     ScanPos = ExistingResult->getResult().getInst()->getIterator();
 1586     NewDirtyVal = MemDepResult::getDirty(&*++RemInst->getIterator());

lib/Analysis/MemorySSAUpdater.cpp

 1175   for (Instruction &I : make_range(Start->getIterator(), To->end()))

lib/Analysis/ScalarEvolutionExpander.cpp

   88   BasicBlock::iterator IP = ++I->getIterator();
 1853         while (InsertPt->getIterator() != Builder.GetInsertPoint() &&
 1856           InsertPt = &*std::next(InsertPt->getIterator());

lib/CodeGen/AtomicExpandPass.cpp

  857       BB->splitBasicBlock(CI->getIterator(), "partword.cmpxchg.end");
 1167   BasicBlock *ExitBB = BB->splitBasicBlock(CI->getIterator(), "cmpxchg.end");

lib/CodeGen/BranchFolding.cpp

  459   MachineFunction::iterator MBBI = CurMBB.getIterator();
 1183             auto Next = ++PBB->getIterator();
 1395   MachineFunction::iterator FallThrough = MBB->getIterator();
 1767             MachineBasicBlock *NextBB = &*std::next(MBB->getIterator());
 1782         MachineFunction::iterator SuccPrev = --SuccBB->getIterator();

lib/CodeGen/BranchRelaxation.cpp

  214   MF->insert(++BB.getIterator(), NewBB);
  232   MF->insert(++OrigBB->getIterator(), NewBB);
  235   NewBB->splice(NewBB->end(), OrigBB, MI.getIterator(), OrigBB->end());

lib/CodeGen/CodeGenPrepare.cpp

  603   BasicBlock::iterator BBI = BI->getIterator();
 2302       BasicBlock::iterator It = Inst->getIterator();
 5352             NewBaseInsertPt = std::next(BaseI->getIterator());
 5818         CurInstIterator = std::next(And->getIterator());
 5954   CurInstIterator = std::next(LastSI->getIterator());

lib/CodeGen/DFAPacketizer.cpp

  222     finalizeBundle(*MBB, MIFirst.getIterator(), MI.getInstrIterator());

lib/CodeGen/FinalizeISel.cpp

   65           I = NewMBB->getIterator();

lib/CodeGen/GlobalISel/InstructionSelector.cpp

   78       std::next(MI.getIterator()) == IntoMI.getIterator())
   78       std::next(MI.getIterator()) == IntoMI.getIterator())

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

   46   State.II = MI.getIterator();

lib/CodeGen/IfConversion.cpp

  636   MachineFunction::iterator I = MBB.getIterator();
  705     MachineFunction::iterator I = TrueBBI.BB->getIterator();
 1437   MachineFunction::iterator PI = MBB.getIterator();
 1439   MachineFunction::iterator TI = ToMBB.getIterator();

lib/CodeGen/InterferenceCache.cpp

  159       MF->getBlockNumbered(MBBNum)->getIterator();

lib/CodeGen/IntrinsicLowering.cpp

   44   IRBuilder<> Builder(CI->getParent(), CI->getIterator());

lib/CodeGen/LiveDebugValues.cpp

 1409     MBB->insertAfterBundle(TR.TransferInst->getIterator(), MI);

lib/CodeGen/LiveDebugVariables.cpp

 1353     MachineFunction::iterator MBB = LIS.getMBBFromIndex(Start)->getIterator();
 1381   MachineFunction::iterator MBB = LIS.getMBBFromIndex(loc)->getIterator();

lib/CodeGen/LiveRangeShrink.cpp

  218         MachineBasicBlock::iterator I = std::next(Insert->getIterator());
  222         if (I == MI.getIterator())
  233         MachineBasicBlock::iterator EndIter = std::next(MI.getIterator());
  240         MBB.splice(I, &MBB, MI.getIterator(), EndIter);

lib/CodeGen/MachineBasicBlock.cpp

  525   getParent()->splice(NewAfter->getIterator(), getIterator());
  525   getParent()->splice(NewAfter->getIterator(), getIterator());
  529   getParent()->splice(++NewBefore->getIterator(), getIterator());
  529   getParent()->splice(++NewBefore->getIterator(), getIterator());
  827   MachineFunction::iterator Fallthrough = getIterator();

lib/CodeGen/MachineCopyPropagation.cpp

  169          make_range(AvailCopy->getIterator(), DestCopy.getIterator()))
  169          make_range(AvailCopy->getIterator(), DestCopy.getIterator()))
  306        make_range(PrevCopy->getIterator(), Copy.getIterator()))
  306        make_range(PrevCopy->getIterator(), Copy.getIterator()))
  453          make_range(Copy->getIterator(), std::next(MI.getIterator())))
  453          make_range(Copy->getIterator(), std::next(MI.getIterator())))

lib/CodeGen/MachineFunction.cpp

  294     MBBI = MBB->getIterator();

lib/CodeGen/MachineInstr.cpp

  735   MachineBasicBlock::instr_iterator Pred = getIterator();
  744   MachineBasicBlock::instr_iterator Succ = getIterator();
  753   MachineBasicBlock::instr_iterator Pred = getIterator();
  762   MachineBasicBlock::instr_iterator Succ = getIterator();

lib/CodeGen/MachineLoopInfo.cpp

   57   if (TopMBB->getIterator() != Begin) {
   58     MachineBasicBlock *PriorMBB = &*std::prev(TopMBB->getIterator());
   61       if (TopMBB->getIterator() == Begin)
   63       PriorMBB = &*std::prev(TopMBB->getIterator());
   72   if (BotMBB->getIterator() != std::prev(End)) {
   73     MachineBasicBlock *NextMBB = &*std::next(BotMBB->getIterator());
   76       if (BotMBB == &*std::next(BotMBB->getIterator()))
   78       NextMBB = &*std::next(BotMBB->getIterator());

lib/CodeGen/MachineLoopUtils.cpp

   40     MF.insert(Loop->getIterator(), NewBB);
   42     MF.insert(std::next(Loop->getIterator()), NewBB);

lib/CodeGen/MachineSink.cpp

 1151       MachineBasicBlock::iterator NI = std::next(MI->getIterator());

lib/CodeGen/ModuloSchedule.cpp

  128   MF.insert(BB->getIterator(), KernelBB);
  205     MF.insert(BB->getIterator(), NewBB);
  279     MF.insert(BB->getIterator(), NewBB);
 1309   for (auto I = BB->getFirstNonPHI(); I != FirstMI->getIterator();) {
 1675   MF.insert(std::next(BB->getIterator()), NewBB);

lib/CodeGen/PreISelIntrinsicLowering.cpp

   83     IRBuilder<> Builder(CI->getParent(), CI->getIterator());

lib/CodeGen/ProcessImplicitDefs.cpp

   96   MachineBasicBlock::instr_iterator UserMI = MI->getIterator();

lib/CodeGen/RegisterCoalescer.cpp

 1489         MBB->splice(std::next(NewMI.getIterator()), UseMI->getParent(), UseMI);

lib/CodeGen/RegisterScavenging.cpp

  667   Register SReg = RS.scavengeRegisterBackwards(RC, DefMI.getIterator(),

lib/CodeGen/ScalarizeMaskedMemIntrin.cpp

  207     BasicBlock *CondBlock = IfBlock->splitBasicBlock(InsertPt->getIterator(),
  217         CondBlock->splitBasicBlock(InsertPt->getIterator(), "else");
  339         IfBlock->splitBasicBlock(InsertPt->getIterator(), "cond.store");
  348         CondBlock->splitBasicBlock(InsertPt->getIterator(), "else");
  668     BasicBlock *CondBlock = IfBlock->splitBasicBlock(InsertPt->getIterator(),
  682         CondBlock->splitBasicBlock(InsertPt->getIterator(), "else");
  775         IfBlock->splitBasicBlock(InsertPt->getIterator(), "cond.store");
  788         CondBlock->splitBasicBlock(InsertPt->getIterator(), "else");

lib/CodeGen/ScheduleDAGInstrs.cpp

 1135       MachineBasicBlock::instr_iterator Bundle = MI.getIterator();

lib/CodeGen/SelectionDAG/FastISel.cpp

  243     if (I.getIterator() == LastFlushPoint)
  297     SinkPos = OrderMap.FirstTerminator->getIterator();
  299     SinkPos = FirstUser->getIterator();

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

  752   assert(N->getIterator() != AllNodes.begin() &&
 8569         if (P->getIterator() != SortedPos)
 8578     if (Node.getIterator() == SortedPos) {

lib/CodeGen/SjLjEHPrepare.cpp

  161   IRBuilder<> Builder(SelI->getParent(), std::next(SelI->getIterator()));

lib/CodeGen/SlotIndexes.cpp

  135     MachineBasicBlock::instr_iterator Next = std::next(MI.getIterator());
  196   IndexList::iterator ListB = startIdx.listEntry()->getIterator();
  197   IndexList::iterator ListI = endIdx.listEntry()->getIterator();

lib/CodeGen/SplitKit.cpp

  226       LIS.getMBBFromIndex(LVI->start)->getIterator();
  309       MFI = LIS.getMBBFromIndex(LVI->start)->getIterator();
  326       LIS.getMBBFromIndex(LVI->start)->getIterator();
 1174       MachineFunction::iterator MBB = LIS.getMBBFromIndex(Start)->getIterator();

lib/CodeGen/StackProtector.cpp

  485       BasicBlock *NewBB = BB->splitBasicBlock(RI->getIterator(), "SP_return");

lib/CodeGen/TailDuplicator.cpp

  877     PrevBB = &*std::prev(TailBB->getIterator());

lib/CodeGen/TwoAddressInstructionPass.cpp

  734   MachineFunction::iterator MFI = MBB->getIterator();
  736   assert(MBB->getIterator() == MFI &&

lib/CodeGen/VirtRegMap.cpp

  458         BundleStart = &*std::next(BundledMI->getIterator());

lib/CodeGen/WinEHPrepare.cpp

  967               std::prev(BB->getTerminator()->getIterator());

lib/FuzzMutate/IRMutator.cpp

  188   for (auto I = BB->getFirstInsertionPt(), E = Inst.getIterator(); I != E;

lib/FuzzMutate/RandomIRBuilder.cpp

   53       IP = ++I->getIterator();

lib/IR/AutoUpgrade.cpp

 1650   Builder.SetInsertPoint(CI->getParent(), CI->getIterator());
 3876       IRBuilder<> Builder(CI->getParent(), CI->getIterator());

lib/IR/BasicBlock.cpp

   58     NewParent->getBasicBlockList().insert(InsertBefore->getIterator(), this);
  118   getParent()->getBasicBlockList().remove(getIterator());
  122   return getParent()->getBasicBlockList().erase(getIterator());
  129       MovePos->getIterator(), getParent()->getBasicBlockList(), getIterator());
  129       MovePos->getIterator(), getParent()->getBasicBlockList(), getIterator());
  136       ++MovePos->getIterator(), getParent()->getBasicBlockList(),
  137       getIterator());

lib/IR/Core.cpp

 2642   CurBB->getParent()->getBasicBlockList().insertAfter(CurBB->getIterator(),
 2998   auto I = Instr ? unwrap<Instruction>(Instr)->getIterator() : BB->end();
 3004   unwrap(Builder)->SetInsertPoint(I->getParent(), I->getIterator());

lib/IR/Function.cpp

  223   getParent()->getFunctionList().remove(getIterator());
  227   getParent()->getFunctionList().erase(getIterator());

lib/IR/Globals.cpp

  375     Before->getParent()->getGlobalList().insert(Before->getIterator(), this);
  381   getParent()->getGlobalList().remove(getIterator());
  385   getParent()->getGlobalList().erase(getIterator());
  515   getParent()->getAliasList().remove(getIterator());
  519   getParent()->getAliasList().erase(getIterator());
  548   getParent()->getIFuncList().remove(getIterator());
  552   getParent()->getIFuncList().erase(getIterator());

lib/IR/Instruction.cpp

   31     BB->getInstList().insert(InsertBefore->getIterator(), this);
   64   getParent()->getInstList().remove(getIterator());
   68   return getParent()->getInstList().erase(getIterator());
   74   InsertPos->getParent()->getInstList().insert(InsertPos->getIterator(), this);
   80   InsertPos->getParent()->getInstList().insertAfter(InsertPos->getIterator(),
   87   moveBefore(*MovePos->getParent(), MovePos->getIterator());
   91   moveBefore(*MovePos->getParent(), ++MovePos->getIterator());
   97   BB.getInstList().splice(I, getParent()->getInstList(), getIterator());

lib/IR/Module.cpp

  274   NamedMDList.erase(NMD->getIterator());

lib/MC/MCSection.cpp

   76     IP = MI->second->getIterator();

lib/Target/AArch64/AArch64CleanupLocalDynamicTLSPass.cpp

  126         BuildMI(*I.getParent(), ++I.getIterator(), I.getDebugLoc(),

lib/Target/AArch64/AArch64ExpandPseudoInsts.cpp

  191   MF->insert(++MBB.getIterator(), LoadCmpBB);
  192   MF->insert(++LoadCmpBB->getIterator(), StoreBB);
  193   MF->insert(++StoreBB->getIterator(), DoneBB);
  273   MF->insert(++MBB.getIterator(), LoadCmpBB);
  274   MF->insert(++LoadCmpBB->getIterator(), StoreBB);
  275   MF->insert(++StoreBB->getIterator(), DoneBB);
  360   MF->insert(++MBB.getIterator(), LoopBB);
  361   MF->insert(++LoopBB->getIterator(), DoneBB);

lib/Target/AArch64/AArch64ISelLowering.cpp

 1340   MachineFunction::iterator It = ++MBB->getIterator();

lib/Target/AArch64/AArch64InstrInfo.cpp

 1155                         return MI.getIterator() == From;
 1418   for (auto I = std::next(CmpInstr->getIterator()),

lib/Target/AArch64/AArch64InstructionSelector.cpp

 1555       MIB.setInsertPt(MIB.getMBB(), std::next(I.getIterator()));
 1629     MIB.setInsertPt(MIB.getMBB(), std::next(I.getIterator()));
 1661     BuildMI(MBB, I.getIterator(), I.getDebugLoc(),
 1809       MIB.setInsertPt(MIB.getMBB(), std::next(I.getIterator()));

lib/Target/AArch64/AArch64LoadStoreOptimizer.cpp

  963       for (MachineInstr &MI : make_range(StoreI->getIterator(),
  964                                          LoadI->getIterator())) {
 1037   for (MachineInstr &MI : make_range(StoreI->getIterator(),
 1038                                      BitExtMI->getIterator()))

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  566   IRBuilder<> Builder(FDiv.getParent(), std::next(FDiv.getIterator()), FPMath);

lib/Target/AMDGPU/AMDGPULibCalls.cpp

  651   B.SetInsertPoint(BB, CI->getIterator());
 1299       BasicBlock::iterator BBI = LI->getIterator();
 1324     BasicBlock::iterator BBI = CI->getIterator();

lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp

  717                    MII = UseInstr->getIterator(),
 1741     MachineFunction::iterator ExitIter = Exit->getIterator();
 1851   auto CodeBBStartI = CodeBBStart->getIterator();
 1852   auto CodeBBEndI = CodeBBEnd->getIterator();
 1853   auto MergeIter = MergeBB->getIterator();
 2298     auto MergeIter = MergeBB->getIterator();
 2299     auto CodeBBStartIter = CodeBB->getIterator();
 2300     auto CodeBBEndIter = ++(CodeBB->getIterator());
 2488   auto AfterExitIter = Exit->getIterator();
 2526   auto MBBIter = ++(MBB->getIterator());

lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp

  986   MachineBasicBlock::iterator I = MI.getIterator();

lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

  365   F.getParent()->getFunctionList().insert(F.getIterator(), NewFunc);

lib/Target/AMDGPU/GCNHazardRecognizer.cpp

  206   MachineBasicBlock::instr_iterator MI = std::next(CurrCycleInstr->getIterator());

lib/Target/AMDGPU/GCNIterativeScheduler.cpp

  402     Top = std::next(MI->getIterator());

lib/Target/AMDGPU/GCNSchedStrategy.cpp

  402     if (MI->getIterator() != RegionEnd) {
  424     RegionEnd = MI->getIterator();
  428   RegionBegin = Unsched.front()->getIterator();

lib/Target/AMDGPU/SIISelLowering.cpp

 3104   auto I = MI.getIterator();
 3262   return InsertPt->getIterator();
 3646     BuildMI(*BB, MI.getIterator(), MI.getDebugLoc(),

lib/Target/AMDGPU/SIInsertSkips.cpp

  157   MachineBasicBlock *SkipBB = insertSkipBlock(MBB, MI.getIterator());
  329   MachineBasicBlock::iterator InsPt = std::next(MI.getIterator());

lib/Target/AMDGPU/SIInsertWaitcnts.cpp

 1066       for (auto II = OldWaitcntInstr->getIterator(), NextI = std::next(II);
 1107     for (auto II = OldWaitcntInstr->getIterator(), NextI = std::next(II);
 1152     auto SWaitInst = BuildMI(*MI.getParent(), MI.getIterator(),
 1167         BuildMI(*MI.getParent(), MI.getIterator(), MI.getDebugLoc(),

lib/Target/AMDGPU/SIInstrInfo.cpp

 1548     for (MachineBasicBlock::instr_iterator I = MI.getIterator();
 2231   I = MIB->getIterator();

lib/Target/AMDGPU/SILoadStoreOptimizer.cpp

 1362   BuildMI(*MI.getParent(), MI.getIterator(), MI.getDebugLoc(),
 1374   MachineBasicBlock::iterator MBBI = MI.getIterator();
 1590   MachineBasicBlock::iterator MBBI = MI.getIterator();

lib/Target/AMDGPU/SILowerControlFlow.cpp

  457   for (auto I = Def->getIterator(); I != MI.getIterator(); ++I)
  457   for (auto I = Def->getIterator(); I != MI.getIterator(); ++I)

lib/Target/AMDGPU/SIOptimizeExecMasking.cpp

  330            = std::next(CopyFromExecInst->getIterator()), JE = I->getIterator();
  330            = std::next(CopyFromExecInst->getIterator()), JE = I->getIterator();
  405     auto InsPt = SaveExecInst->getIterator();

lib/Target/AMDGPU/SIOptimizeExecMaskingPreRA.cpp

  272        std::none_of(std::next(Cmp->getIterator()), Andn2->getIterator(),
  272        std::none_of(std::next(Cmp->getIterator()), Andn2->getIterator(),

lib/Target/AMDGPU/SIPeepholeSDWA.cpp

  917   for (auto I = std::next(MI.getIterator()), E = MISucc.getIterator();
  917   for (auto I = std::next(MI.getIterator()), E = MISucc.getIterator();
 1193     auto Copy = BuildMI(*MI.getParent(), MI.getIterator(), MI.getDebugLoc(),

lib/Target/AMDGPU/SIShrinkInstructions.cpp

  492     auto I = std::next(MovT.getIterator()), E = MovT.getParent()->instr_end();
  493     for (auto IY = MovY.getIterator(); I != E && I != IY; ++I) {
  528       BuildMI(*MovT.getParent(), MovX->getIterator(), MovT.getDebugLoc(),
  537     MachineInstr *Next = &*std::next(MovT.getIterator());
  593           Next = NextMI->getIterator();

lib/Target/ARC/ARCOptAddrMode.cpp

  245       Add.getParent()->insertAfter(Add.getIterator(), &Ldst);
  480       MI = std::prev(Res->getIterator());

lib/Target/ARM/ARMBaseInstrInfo.cpp

  304   MachineBasicBlock::iterator MBBI = MI.getIterator();
 1724   MachineBasicBlock::instr_iterator I = Cloned.getIterator();

lib/Target/ARM/ARMConstantIslandPass.cpp

  619   MachineFunction::iterator MBBI = MBB->getIterator();
  899   MachineFunction::iterator MBBI = ++OrigBB->getIterator();
 1028   MachineFunction::const_iterator NextBlock = Water->getIterator();
 1289       NewMBB = &*++UserMBB->getIterator();
 1482     NewMBB = &*++WaterBB->getIterator();
 1493     MachineBasicBlock *WaterBB = &*--NewMBB->getIterator();
 1516   MF->insert(NewMBB->getIterator(), NewIsland);
 1539   BBUtils->adjustBBOffsetsAfter(&*--NewIsland->getIterator());
 1705     std::next(MBB->getIterator())->removeSuccessor(DestBB);
 1709   MachineBasicBlock *NextBB = &*++MBB->getIterator();
 2110   MachineFunction::iterator MBB = JTMI->getParent()->getIterator();
 2224       if (User.MI->getIterator() == User.MI->getParent()->begin())
 2403   MachineFunction::iterator BBi = BB->getIterator();
 2426   MachineFunction::iterator MBBI = ++JTBB->getIterator();

lib/Target/ARM/ARMExpandPseudoInsts.cpp

  914     finalizeBundle(MBB, LO16->getIterator(), MBBI->getIterator());
  914     finalizeBundle(MBB, LO16->getIterator(), MBBI->getIterator());
  949   MF->insert(++MBB.getIterator(), LoadCmpBB);
  950   MF->insert(++LoadCmpBB->getIterator(), StoreBB);
  951   MF->insert(++StoreBB->getIterator(), DoneBB);
 1074   MF->insert(++MBB.getIterator(), LoadCmpBB);
 1075   MF->insert(++LoadCmpBB->getIterator(), StoreBB);
 1076   MF->insert(++StoreBB->getIterator(), DoneBB);

lib/Target/ARM/ARMFrameLowering.cpp

 2326     MF.insert(PrologueMBB.getIterator(), B);

lib/Target/ARM/ARMISelDAGToDAG.cpp

  521   CurDAG->RepositionNode(N.getNode()->getIterator(), M.getNode());
 3137           CurDAG->RepositionNode(N->getIterator(), NewImm.getNode());

lib/Target/ARM/ARMISelLowering.cpp

10015   MachineFunction::iterator It = ++BB->getIterator();
10337   MF->insert(++MBB->getIterator(), ContBB);
10482     MachineFunction::iterator It = ++BB->getIterator();
10615     MachineFunction::iterator BBI = ++BB->getIterator();

lib/Target/ARM/ARMInstructionSelector.cpp

  483       : MBB(*MIB->getParent()), InsertBefore(std::next(MIB->getIterator())),
  692         auto InsertBefore = std::next(MIB->getIterator());
  769   auto InsertBefore = std::next(MIB->getIterator());
  882         auto InsertBefore = std::next(I.getIterator());
  931       auto InsertBefore = std::next(I.getIterator());
 1104       auto InsertBefore = I.getIterator();

lib/Target/ARM/Thumb2ITBlockPass.cpp

  276                    ++LastITMI->getIterator());

lib/Target/AVR/AVRISelLowering.cpp

 1496   for (I = BB->getIterator(); I != F->end() && &(*I) != BB; ++I);

lib/Target/BPF/BPFAbstractMemberAccess.cpp

  871     BB->getInstList().insert(Call->getIterator(), LDInst);
  889   BB->getInstList().insert(Call->getIterator(), LDInst);
  893   BB->getInstList().insert(Call->getIterator(), BCInst);
  898   BB->getInstList().insert(Call->getIterator(), GEP);
  902   BB->getInstList().insert(Call->getIterator(), BCInst2);

lib/Target/BPF/BPFISelLowering.cpp

  653   MachineFunction::iterator I = ++BB->getIterator();

lib/Target/Hexagon/HexagonCommonGEP.cpp

  743       BasicBlock::iterator It = In->getIterator();
 1205     BasicBlock::iterator InsertAt = LastB->getTerminator()->getIterator();

lib/Target/Hexagon/HexagonConstExtenders.cpp

 1586   MachineBasicBlock::iterator At = MI.getIterator();
 1704   MachineBasicBlock::iterator At = MI.getIterator();

lib/Target/Hexagon/HexagonConstPropagation.cpp

 2858     MachineBasicBlock::iterator At = MI.getIterator();
 2952   MachineBasicBlock::iterator At = MI.getIterator();
 3152       auto NI = BuildMI(B, BrI.getIterator(), BrI.getDebugLoc(), JD)

lib/Target/Hexagon/HexagonCopyToCombine.cpp

  578   if (MI == I2.getIterator())

lib/Target/Hexagon/HexagonEarlyIfConv.cpp

  980   MFN->erase(B->getIterator());

lib/Target/Hexagon/HexagonFrameLowering.cpp

  850       MachineBasicBlock::iterator It = I.getIterator();
 2271         MachineBasicBlock::iterator StartIt = SI.getIterator(), NextIt;
 2295         auto EndIt = std::next(EI.getIterator());

lib/Target/Hexagon/HexagonHardwareLoops.cpp

 1338   instr_iterator CmpIt = CmpI->getIterator(), NextIt = std::next(CmpIt);
 1350       BB->splice(++BumpI->getIterator(), BB, CmpI->getIterator());
 1350       BB->splice(++BumpI->getIterator(), BB, CmpI->getIterator());
 1890   MF->insert(Header->getIterator(), NewPH);

lib/Target/Hexagon/HexagonInstrInfo.cpp

  535     I = LastInst->getIterator();
  607           MachineFunction::iterator(NewTBB) == ++MBB.getIterator()) {
 1047       MachineBasicBlock::iterator MBBI = MI.getIterator();
 1517   return MI.getIterator();
 1603   MachineBasicBlock::instr_iterator TI = T->getIterator();

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 1089   BasicBlock::iterator End = EndI ? EndI->getIterator() : ExitB->end();
 1824         Value *NewSel = C.materialize(LoopB, SI->getIterator());
 1855         Value *NewSel = C.materialize(LoopB, SI->getIterator());

lib/Target/Hexagon/HexagonNewValueJump.cpp

  655               for (auto I = std::next(MI.getIterator()); I != jmpPos; ++I) {

lib/Target/Hexagon/HexagonPeephole.cpp

  280               BuildMI(*MBB, MI.getIterator(), MI.getDebugLoc(),

lib/Target/Hexagon/HexagonVExtract.cpp

  128     MachineBasicBlock::iterator At = std::next(DefI->getIterator());

lib/Target/Hexagon/HexagonVLIWPacketizer.cpp

  181   B.splice(InsertPt, &B, MI.getIterator());
 1319   MachineBasicBlock::iterator II = I.getIterator();
 1347   MachineBasicBlock::iterator NextMII = I.getIterator();
 1689   MachineBasicBlock::iterator MII = MI.getIterator();
 1787     MachineBasicBlock::instr_iterator NextMI = std::next(MI->getIterator());

lib/Target/Hexagon/HexagonVectorPrint.cpp

  139         MachineBasicBlock::instr_iterator MII = MI.getIterator();
  170     MachineBasicBlock::instr_iterator MII = I->getIterator();

lib/Target/Hexagon/MCTargetDesc/HexagonAsmBackend.cpp

  716           for (auto K = J.getIterator();

lib/Target/MSP430/MSP430BranchSelector.cpp

   90     Begin = FromBB->getIterator();

lib/Target/MSP430/MSP430ISelLowering.cpp

 1464   MachineFunction::iterator I = ++BB->getIterator();
 1561   MachineFunction::iterator I = ++BB->getIterator();

lib/Target/Mips/Mips16ISelLowering.cpp

  522   MachineFunction::iterator It = ++BB->getIterator();
  585   MachineFunction::iterator It = ++BB->getIterator();
  651   MachineFunction::iterator It = ++BB->getIterator();

lib/Target/Mips/Mips16InstrInfo.cpp

  156   MBB.erase(MI.getIterator());

lib/Target/Mips/MipsBranchExpansion.cpp

  757         MachineBasicBlock::instr_iterator Iit = I->getIterator();

lib/Target/Mips/MipsConstantIslandPass.cpp

  591   MachineFunction::iterator MBBI = MBB->getIterator();
  856   MachineFunction::iterator MBBI = ++OrigBB->getIterator();
  940   MachineFunction::const_iterator NextBlock = ++Water->getIterator();
 1232       NewMBB = &*++UserMBB->getIterator();
 1339     NewMBB = &*++WaterBB->getIterator();
 1356     MachineBasicBlock *WaterBB = &*--NewMBB->getIterator();
 1373   MF->insert(NewMBB->getIterator(), NewIsland);
 1398   adjustBBOffsetsAfter(&*--NewIsland->getIterator());
 1609   MachineBasicBlock *NextBB = &*++MBB->getIterator();

lib/Target/Mips/MipsExpandPseudo.cpp

  118   MachineFunction::iterator It = ++BB.getIterator();
  254   MachineFunction::iterator It = ++BB.getIterator();
  391   MachineFunction::iterator It = ++BB.getIterator();
  580   MachineFunction::iterator It = ++BB.getIterator();

lib/Target/Mips/MipsISelLowering.cpp

 1649   MachineFunction::iterator It = ++BB->getIterator();
 1827   MachineFunction::iterator It = ++BB->getIterator();
 4431   MachineFunction::iterator It = ++BB->getIterator();
 4507   MachineFunction::iterator It = ++BB->getIterator();

lib/Target/NVPTX/NVPTXLowerArgs.cpp

  189     InsertPt = ++cast<Instruction>(Ptr)->getIterator();

lib/Target/PowerPC/PPCExpandISEL.cpp

  346   MachineFunction::iterator It = MBB->getIterator();

lib/Target/PowerPC/PPCISelLowering.cpp

10333   MachineFunction::iterator It = ++BB->getIterator();
10437   MachineFunction::iterator It = ++BB->getIterator();
10620   MachineFunction::iterator I = ++MBB->getIterator();
10884   MachineFunction::iterator It = ++BB->getIterator();

lib/Target/PowerPC/PPCReduceCRLogicals.cpp

  200   MachineFunction::iterator It = ThisMBB->getIterator();

lib/Target/RISCV/RISCVExpandPseudoInsts.cpp

  370   MF->insert(++MBB.getIterator(), LoopMBB);
  371   MF->insert(++LoopMBB->getIterator(), DoneMBB);
  424   MF->insert(++MBB.getIterator(), LoopHeadMBB);
  425   MF->insert(++LoopHeadMBB->getIterator(), LoopIfBodyMBB);
  426   MF->insert(++LoopIfBodyMBB->getIterator(), LoopTailMBB);
  427   MF->insert(++LoopTailMBB->getIterator(), DoneMBB);
  539   MF->insert(++MBB.getIterator(), LoopHeadMBB);
  540   MF->insert(++LoopHeadMBB->getIterator(), LoopTailMBB);
  541   MF->insert(++LoopTailMBB->getIterator(), DoneMBB);
  641   MF->insert(++MBB.getIterator(), NewMBB);

lib/Target/RISCV/RISCVISelLowering.cpp

 1106   MachineFunction::iterator It = ++BB->getIterator();
 1290   MachineFunction::iterator I = ++BB->getIterator();
 1307                   std::next(LastSelectPseudo->getIterator()), HeadMBB->end());
 1327   auto SelectMBBI = MI.getIterator();
 1328   auto SelectEnd = std::next(LastSelectPseudo->getIterator());

lib/Target/RISCV/RISCVInstrInfo.cpp

  407                                                 LuiMI.getIterator(), false, 0);

lib/Target/Sparc/SparcISelLowering.cpp

 3135   MachineFunction::iterator It = ++BB->getIterator();

lib/Target/SystemZ/SystemZISelDAGToDAG.cpp

  613     DAG->RepositionNode(Pos->getIterator(), N.getNode());

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

  251         I = std::next(ScopeTop->getIterator());
  385   auto Iter = std::next(Bottom->getIterator());
  388     Iter = std::next(Bottom->getIterator());
  466   auto Iter = std::next(Bottom->getIterator());
  469     Iter = std::next(Bottom->getIterator());
  482         I = std::next(ScopeTop->getIterator());
  546           if (MI.getIterator() != Header->begin() &&
  547               std::prev(MI.getIterator())->isEHLabel()) {
  548             AfterSet.insert(&*std::prev(MI.getIterator()));
  549             ThrowingCall = &*std::prev(MI.getIterator());
  690       for (auto B = Try->getIterator(), E = std::next(EndTry->getIterator());
  690       for (auto B = Try->getIterator(), E = std::next(EndTry->getIterator());
 1026     auto SplitPos = std::next(Catch->getIterator());
 1034     MF.insert(std::next(EHPad->getIterator()), BrDest);
 1069     MachineBasicBlock *EHPadLayoutPred = &*std::prev(EHPad->getIterator());
 1114       if (RangeBegin->getIterator() != MBB->begin() &&
 1115           std::prev(RangeBegin->getIterator())->isEHLabel())
 1116         RangeBegin = &*std::prev(RangeBegin->getIterator());
 1117       if (std::next(RangeEnd->getIterator()) != MBB->end() &&
 1118           std::next(RangeEnd->getIterator())->isEHLabel())
 1119         RangeEnd = &*std::next(RangeEnd->getIterator());
 1137       MF.insert(std::next(MBB->getIterator()), NestedEHPad);
 1147       MF.insert(std::next(NestedEHPad->getIterator()), NestedCont);
 1154                          std::next(RangeEnd->getIterator()), MBB->end());

lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp

  277           auto InsertPt = std::next(MI.getIterator());

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

  360   MachineFunction::iterator It = ++BB->getIterator();
  366   DoneMBB->splice(DoneMBB->begin(), BB, std::next(MI.getIterator()), BB->end());

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

  198       MBB.erase(std::next(MI.getIterator()), MBB.end());

lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

  863               rematerializeCheapDef(Reg, Op, *Def, MBB, Insert->getIterator(),

lib/Target/X86/X86CmovConversion.cpp

  599   for (auto I = First->getIterator(), E = Last->getIterator(); I != E; I++) {
  599   for (auto I = First->getIterator(), E = Last->getIterator(); I != E; I++) {
  665   MachineFunction::iterator It = ++MBB->getIterator();

lib/Target/X86/X86FixupLEAs.cpp

  182   MachineFunction::iterator MFI = MBB.getIterator();

lib/Target/X86/X86FlagsCopyLowering.cpp

  250   MachineInstr &PrevI = *std::prev(SplitI.getIterator());
  254   assert(!std::prev(PrevI.getIterator())->isTerminator() &&
  264       std::any_of(SplitI.getIterator(), MBB.instr_end(),
  282   NewMBB.splice(NewMBB.end(), &MBB, SplitI.getIterator(), MBB.end());
  409     auto TestPos = CopyDefI.getIterator();
  476       if (HasEFLAGSClobber(HoistMBB->getFirstTerminator()->getIterator(),
  482       TestPos = TestMBB->getFirstTerminator()->getIterator();
  536                           ? std::next(CopyI->getIterator())
  583           auto JmpIt = MI.getIterator();
  819       BuildMI(MBB, MI.getIterator(), MI.getDebugLoc(), TII->get(X86::ADD8ri))
  845   insertTest(MBB, CMovI.getIterator(), CMovI.getDebugLoc(), CondReg);
  868   insertTest(JmpMBB, JmpI.getIterator(), JmpI.getDebugLoc(), CondReg);
  912   auto SetPos = SetBI.getIterator();
 1035   auto MIB = BuildMI(*SetCCI.getParent(), SetCCI.getIterator(),

lib/Target/X86/X86FrameLowering.cpp

  516     MachineBasicBlock::iterator MBBI = std::next(ChkStkStub->getIterator());
  568   MachineFunction::iterator MBBIter = std::next(MBB.getIterator());

lib/Target/X86/X86ISelDAGToDAG.cpp

 1552     DAG.RepositionNode(Pos->getIterator(), N.getNode());

lib/Target/X86/X86ISelLowering.cpp

29180   MachineFunction::iterator I = ++MBB->getIterator();
29359     MachineFunction::iterator MBBIter = ++MBB->getIterator();
29527   MachineFunction::iterator MBBIter = ++MBB->getIterator();
29798   MachineFunction::iterator It = ++ThisMBB->getIterator();
29959   MachineFunction::iterator It = ++ThisMBB->getIterator();
30060   MachineFunction::iterator MBBIter = ++BB->getIterator();
30167   MF->insert(std::next(BB->getIterator()), RestoreMBB);
30474   MachineFunction::iterator I = ++MBB->getIterator();
30663   MachineFunction::iterator I = ++MBB->getIterator();

lib/Target/X86/X86InstrInfo.cpp

  790   MachineBasicBlock::iterator MBBI = MI.getIterator();
 1325   MFI->insert(MI.getIterator(), NewMI); // Insert the new inst

lib/Target/X86/X86SpeculativeLoadHardening.cpp

  922           MBB.insert(MI.getIterator(), NewMI);
 1954   bool EFLAGSLive = isEFLAGSLive(MBB, MI.getIterator(), *TRI);
 2022   auto InsertPt = MI.getIterator();
 2348       UnhardenedReg, MBB, std::next(MI.getIterator()), Loc);
 2384   auto InsertPt = MI.getIterator();
 2431   auto InsertPt = MI.getIterator();
 2633         OldTargetReg, *MI.getParent(), MI.getIterator(), MI.getDebugLoc());

lib/Target/XCore/XCoreISelLowering.cpp

 1535   MachineFunction::iterator It = ++BB->getIterator();

lib/Transforms/Coroutines/CoroSplit.cpp

 1237   auto NextF = std::next(F.getIterator());

lib/Transforms/IPO/ArgumentPromotion.cpp

  235   F->getParent()->getFunctionList().insert(F->getIterator(), NF);

lib/Transforms/IPO/DeadArgumentElimination.cpp

  169   Fn.getParent()->getFunctionList().insert(Fn.getIterator(), NF);
  871   F->getParent()->getFunctionList().insert(F->getIterator(), NF);

lib/Transforms/IPO/GlobalOpt.cpp

  946     GV->getParent()->getGlobalList().insert(GV->getIterator(), InitBool);
 1348       OrigBB->splitBasicBlock(CI->getIterator(), "malloc_cont");
 1636   GV->getParent()->getGlobalList().insert(GV->getIterator(), NewGV);

lib/Transforms/IPO/LowerTypeTests.cpp

  782         BasicBlock *Then = InitialBB->splitBasicBlock(CI->getIterator());

lib/Transforms/IPO/PartialInlining.cpp

 1064       ClonedOI->ReturnBlock->getFirstNonPHI()->getIterator());

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

 2878           Builder.SetInsertPoint(Y->getParent(), ++(Y->getIterator()));

lib/Transforms/InstCombine/InstCombineCalls.cpp

 4184   for (BasicBlock::iterator I = AdjustTramp->getIterator(),

lib/Transforms/InstCombine/InstCombineCompares.cpp

  626       I = &*std::next(I->getIterator());

lib/Transforms/InstCombine/InstCombineInternal.h

  644     BB->getInstList().insert(Old.getIterator(), New); // Insert inst

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

 1470   BBI = SI.getIterator();

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

  610   BasicBlock::iterator BBI = I.getIterator(), BBFront = I.getParent()->begin();

lib/Transforms/InstCombine/InstCombinePHI.cpp

  494   BasicBlock::iterator BBI = L->getIterator(), E = L->getParent()->end();

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  145         InsertPos = ++pos->getIterator();

lib/Transforms/InstCombine/InstructionCombining.cpp

 2202               BCI->getParent()->getInstList().insert(BCI->getIterator(), I);
 3146     for (BasicBlock::iterator Scan = I->getIterator(),
 3331         BasicBlock::iterator InsertPos = I->getIterator();

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

 1785     F.getBasicBlockList().splice(ExitBlock->getIterator(),
 1787                                  NewBlocks[0]->getIterator(), F.end());

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

 1252     BasicBlock *Tail = Head->splitBasicBlock(Pos->getIterator());
 1692       assert(CS->getIterator() != CS->getParent()->end());

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 3361       NextInsn = ++I.getIterator();

lib/Transforms/ObjCARC/DependencyAnalysis.cpp

  225   BasicBlock::iterator StartPos = StartInst->getIterator();

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  297   BasicBlock::iterator I = Store->getIterator();
  473     BasicBlock::iterator BBI = Inst->getIterator();
  484         BBI = Pred->getTerminator()->getIterator();

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

  632   BasicBlock::iterator I = RetainRV->getIterator(),

lib/Transforms/ObjCARC/PtrState.cpp

  276       InsertAfter = std::next(Inst->getIterator());

lib/Transforms/Scalar/CallSiteSplitting.cpp

  213        llvm::make_range(CallSiteBB->begin(), Instr->getIterator())) {
  244   auto II = std::next(CI->getIterator());
  331         TailBB, PredBB, &*std::next(Instr->getIterator()), ValueToValueMaps[i],
  336         &*std::prev(SplitBlock->getTerminator()->getIterator());
  515     auto II = BB.getFirstNonPHIOrDbg()->getIterator();
  516     auto IE = BB.getTerminator()->getIterator();

lib/Transforms/Scalar/DeadStoreElimination.cpp

  141     if (NewIter == DeadInst->getIterator())
  673         MD->getPointerDependencyFrom(Loc, false, InstPt->getIterator(), BB);
 1297                                              DepWrite->getIterator(), &BB,

lib/Transforms/Scalar/GVNSink.cpp

  539     for (auto I = std::next(Inst->getIterator()), E = BB->end();

lib/Transforms/Scalar/IndVarSimplify.cpp

 1855     for (Instruction &I : make_range(Ctx->getIterator().getReverse(),
 2646     InsertPt = ToMove->getIterator();

lib/Transforms/Scalar/InferAddressSpaces.cpp

 1006           BasicBlock::iterator InsertPos = std::next(Inst->getIterator());

lib/Transforms/Scalar/JumpThreading.cpp

 2353       PredBB->getInstList().insert(OldPredBranch->getIterator(), New);

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1341     for (BasicBlock::iterator Iter = LoopEntry->getFirstNonPHI()->getIterator(),
 1466   for (BasicBlock::iterator Iter = LoopEntry->getFirstNonPHI()->getIterator(),

lib/Transforms/Scalar/LoopInterchange.cpp

 1314   ToList.splice(InsertBefore->getIterator(), FromList, FromList.begin(),
 1315                 FromBB->getTerminator()->getIterator());

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 2483         ExitingBlock->getInstList().insert(TermBr->getIterator(), Cond);
 5032       IP = BetterPos->getIterator();
 5034       IP = Tentative->getIterator();
 5361         Value *FullV = Expand(LU, LF, F, BB->getTerminator()->getIterator(),
 5429       Expand(LU, LF, F, LF.UserInst->getIterator(), Rewriter, DeadInsts);

lib/Transforms/Scalar/LoopUnswitch.cpp

 1290   F->getBasicBlockList().splice(NewPreheader->getIterator(),
 1292                                 NewBlocks[0]->getIterator(), F->end());

lib/Transforms/Scalar/MemCpyOptimizer.cpp

  469   for (auto I = --SI->getIterator(), E = P->getIterator(); I != E; --I) {
  469   for (auto I = --SI->getIterator(), E = P->getIterator(); I != E; --I) {
  563         for (auto &I : make_range(++LI->getIterator(), SI->getIterator())) {
  563         for (auto &I : make_range(++LI->getIterator(), SI->getIterator())) {
  612           BBI = M->getIterator();
  632         for (BasicBlock::iterator I = --SI->getIterator(), E = C->getIterator();
  632         for (BasicBlock::iterator I = --SI->getIterator(), E = C->getIterator();
  675       BBI = I->getIterator(); // Don't invalidate iterator.
  699       BBI = M->getIterator();
  713       BBI = I->getIterator(); // Don't invalidate iterator.
  965                                    M->getIterator(), M->getParent());
 1023                                    MemCpy->getIterator(), MemCpy->getParent());
 1120         MemCpyLoc, true, MemSet->getIterator(), MemSet->getParent());
 1200       SrcLoc, true, M->getIterator(), M->getParent());
 1266       CS.getInstruction()->getIterator(), CS.getInstruction()->getParent());
 1313       CS.getInstruction()->getIterator(), MDep->getParent());

lib/Transforms/Scalar/NaryReassociate.cpp

  253           I = NewI->getIterator();

lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp

   85   BB = JoinBB->getIterator();

lib/Transforms/Scalar/PlaceSafepoints.cpp

  409     return &*++I->getIterator();

lib/Transforms/Scalar/Reassociate.cpp

  877         InsertPt = ++InstInput->getIterator();
 1093   BasicBlock::iterator InsertPt = ++BO->getIterator();

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 1903         CallInst::Create(Func, Values, "", &*++Call->getIterator()));
 2803   computeLiveInValues(BB->rbegin(), ++Inst->getIterator().getReverse(),

lib/Transforms/Scalar/Scalarizer.cpp

  351   return Scatterer(Point->getParent(), Point->getIterator(), V);

lib/Transforms/Scalar/TailRecursionElimination.cpp

  481       firstNonDbg(BB->front().getIterator()) == CI &&

lib/Transforms/Utils/BasicBlockUtils.cpp

  255   PredBB->getInstList().splice(PTI->getIterator(), BB->getInstList(),
  256                                BB->begin(), STI->getIterator());
  405   BasicBlock::iterator SplitIt = SplitPt->getIterator();
  786       Pred->getInstList().insert(NewRet->getIterator(), NewBC);
  817   BasicBlock *Tail = Head->splitBasicBlock(SplitBefore->getIterator());
  867   BasicBlock *Tail = Head->splitBasicBlock(SplitBefore->getIterator());

lib/Transforms/Utils/BreakCriticalEdges.cpp

  172   Function::iterator FBBI = TIBB->getIterator();
  434                          End = Target->getFirstNonPHI()->getIterator();

lib/Transforms/Utils/CallPromotionUtils.cpp

  176     InsertBefore = &*std::next(CS.getInstruction()->getIterator());

lib/Transforms/Utils/CloneFunction.cpp

  205            cast<BasicBlock>(VMap[&OldFunc->front()])->getIterator(),
  651   Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB])->getIterator();
  711   for (Function::iterator I = cast<BasicBlock>(VMap[StartingBB])->getIterator(),
  825   F->getBasicBlockList().splice(Before->getIterator(), F->getBasicBlockList(),
  827   F->getBasicBlockList().splice(Before->getIterator(), F->getBasicBlockList(),
  828                                 NewLoop->getHeader()->getIterator(), F->end());

lib/Transforms/Utils/CodeExtractor.cpp

  424       CommonExitBlock->getFirstNonPHI()->getIterator());
  748           Block->splitBasicBlock(RI->getIterator(), Block->getName() + ".ret");
 1249       InsertPt = std::next(OutI->getIterator());

lib/Transforms/Utils/CtorUtils.cpp

   50   GCL->getParent()->getGlobalList().insert(GCL->getIterator(), NGV);

lib/Transforms/Utils/DemoteRegToStack.cpp

   95     InsertPt = ++I.getIterator();
  141   BasicBlock::iterator InsertPt = P->getIterator();

lib/Transforms/Utils/FlattenCFG.cpp

  190       for (BasicBlock::iterator BI = Pred->begin(), BE = PBI->getIterator();
  340   BasicBlock::iterator end1 = Block1->getTerminator()->getIterator();
  342   BasicBlock::iterator end2 = Block2->getTerminator()->getIterator();

lib/Transforms/Utils/InlineFunction.cpp

  168   BasicBlock::iterator SplitPoint = ++CallerLPad->getIterator();
  597   for (Function::iterator I = FirstNewBlock->getIterator(), E = Caller->end();
  614   for (Function::iterator BB = FirstNewBlock->getIterator(), E = Caller->end();
  675   for (Function::iterator BB = FirstNewBlock->getIterator(), E = Caller->end();
  751     for (Function::iterator BB = FirstNewBlock->getIterator(),
 1810            make_range(FirstNewBlock->getIterator(), Caller->end()))
 1855           InsertPoint, FirstNewBlock->getInstList(), AI->getIterator(), I);
 2051     for (Function::iterator BB = FirstNewBlock->getIterator(),
 2215          make_range(FirstNewBlock->getIterator(), Caller->end()))
 2226     OrigBB->getInstList().splice(TheCall->getIterator(),
 2275         OrigBB->splitBasicBlock(CreatedBranchToNormalDest->getIterator(),
 2282     AfterCallBB = OrigBB->splitBasicBlock(TheCall->getIterator(),
 2303   Caller->getBasicBlockList().splice(AfterCallBB->getIterator(),
 2396   OrigBB->getInstList().splice(Br->getIterator(), CalleeEntry->getInstList());

lib/Transforms/Utils/IntegerDivision.cpp

  393     bool IsInsertPoint = Rem->getIterator() == Builder.GetInsertPoint();
  452     bool IsInsertPoint = Div->getIterator() == Builder.GetInsertPoint();

lib/Transforms/Utils/Local.cpp

 1035     Succ->getInstList().splice(Succ->getFirstNonPHI()->getIterator(),
 1884     Instruction *Inst = &*--EndInst->getIterator();
 1929   BasicBlock::iterator BBI = I->getIterator(), BBE = BB->end();
 1981       BB->splitBasicBlock(CI->getIterator(), CI->getName() + ".noexc");
 2627   DomBlock->getInstList().splice(InsertPt->getIterator(), BB->getInstList(),
 2629                                  BB->getTerminator()->getIterator());

lib/Transforms/Utils/LoopRotationUtils.cpp

  612   if (!shouldSpeculateInstrs(Latch->begin(), Jmp->getIterator(), L))

lib/Transforms/Utils/LoopSimplify.cpp

   89   Function::iterator BBI = --NewBB->getIterator();
  103     Function::iterator BBI = SplitPreds[i]->getIterator();
  386   Function::iterator InsertPos = ++BackedgeBlocks.back()->getIterator();

lib/Transforms/Utils/LoopUnrollPeel.cpp

  725     F->getBasicBlockList().splice(InsertTop->getIterator(),
  727                                   NewBlocks[0]->getIterator(), F->end());

lib/Transforms/Utils/LoopUnrollRuntime.cpp

  792   F->getBasicBlockList().splice(InsertBot->getIterator(),
  794                                 NewBlocks[0]->getIterator(),

lib/Transforms/Utils/LowerSwitch.cpp

  213                             IE = SuccBB->getFirstNonPHI()->getIterator();
  321   F->getBasicBlockList().insert(++OrigBlock->getIterator(), NewNode);
  339   F->getBasicBlockList().insert(++OrigBlock->getIterator(), NewLeaf);
  597   F->getBasicBlockList().insert(Default->getIterator(), NewDefault);

lib/Transforms/Utils/SimplifyCFG.cpp

 1294       BIParent->getInstList().splice(BI->getIterator(),
 1296       BIParent->getInstList().splice(BI->getIterator(),
 1303       BIParent->getInstList().splice(BI->getIterator(),
 1377   BIParent->getInstList().insert(BI->getIterator(), NT);
 2111   BB->getInstList().splice(BI->getIterator(), ThenBB->getInstList(),
 2615   BasicBlock::iterator CondIt = ++Cond->getIterator();
 2746       PredBlock->getInstList().insert(PBI->getIterator(), NewBonusInst);
 2756     PredBlock->getInstList().insert(PBI->getIterator(), CondInPred);
 3755         BB->splitBasicBlock(BI->getIterator(), "switch.early.test");
 3824   BasicBlock::iterator I = cast<Instruction>(RI->getValue())->getIterator(),
 3825                        E = RI->getIterator();
 3851     I = IncomingBB->getFirstNonPHI()->getIterator();
 3852     E = IncomingBB->getTerminator()->getIterator();
 3905   BasicBlock::iterator I = LPInst->getIterator(), E = RI->getIterator();
 3905   BasicBlock::iterator I = LPInst->getIterator(), E = RI->getIterator();
 3944   BasicBlock::iterator I = CPInst->getIterator(), E = RI->getIterator();
 3944   BasicBlock::iterator I = CPInst->getIterator(), E = RI->getIterator();
 3976                               IE = DestEHPad->getIterator();
 4022                               IE = BB->getFirstNonPHI()->getIterator();
 4169   while (UI->getIterator() != BB->begin()) {
 4170     BasicBlock::iterator BBI = UI->getIterator();
 5815   BasicBlock::iterator I = BB->getFirstNonPHIOrDbg()->getIterator();

lib/Transforms/Utils/SimplifyLibCalls.cpp

 1175   B.SetInsertPoint(Malloc->getParent(), ++Malloc->getIterator());
 2098     B.SetInsertPoint(ArgInst->getParent(), ++ArgInst->getIterator());

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  531   for (auto BBI = I->getIterator(), E = I->getParent()->end(); BBI != E;
  545   BasicBlock::iterator FirstInstr = C0->getIterator();
  546   BasicBlock::iterator LastInstr = C0->getIterator();
  556       FirstInstr = I.getIterator();
  559       LastInstr = I.getIterator();

lib/Transforms/Vectorize/SLPVectorizer.cpp

 3391     BasicBlock::reverse_iterator InstIt = ++Inst->getIterator().getReverse(),
 3393                                      PrevInst->getIterator().getReverse();
 3612   Builder.SetInsertPoint(BB, ++LastInst->getIterator());
 4302                                std::next(VecI->getIterator()));
 4327                                      std::next(VecI->getIterator()));
 4639       ++ScheduleStart->getIterator().getReverse();
 4641   BasicBlock::iterator DownIter = ScheduleEnd->getIterator();
 4907         BS->BB->getInstList().insert(LastScheduledInst->getIterator(),

lib/Transforms/Vectorize/VPlan.cpp

  279   Parent->getRecipeList().insert(InsertPos->getIterator(), this);
  283   return getParent()->getRecipeList().erase(getIterator());
  288       std::next(InsertPos->getIterator()), getParent()->getRecipeList(),
  289       getIterator());

lib/Transforms/Vectorize/VPlan.h

  717     End = I->getIterator();
  733     if (End != Instr->getIterator())

tools/clang/lib/CodeGen/CGCleanup.cpp

  463       InsertBefore = std::next(Inst->getIterator());

tools/clang/lib/CodeGen/CGExpr.cpp

  131   Block->getInstList().insertAfter(AllocaInsertPt->getIterator(), Store);

tools/clang/lib/CodeGen/CGStmt.cpp

  457   if (BI->getIterator() != BB->begin())
  479     CurFn->getBasicBlockList().insertAfter(CurBB->getIterator(), BB);
  506       CurFn->getBasicBlockList().insertAfter(insn->getParent()->getIterator(),

tools/clang/lib/CodeGen/CodeGenModule.cpp

  253       OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),

tools/llvm-diff/DifferenceEngine.cpp

  635     BasicBlock::iterator I = LTerm->getIterator();
  648     BasicBlock::iterator I = RTerm->getIterator();

tools/llvm-reduce/deltas/ReduceArguments.cpp

   92     Program->getFunctionList().insertAfter(F->getIterator(), ClonedFunc);

tools/llvm-stress/llvm-stress.cpp

  718     BasicBlock::iterator Loc = Instr->getIterator();

tools/opt/Debugify.cpp

  328     auto FuncIt = F.getIterator();
  372     auto FuncIt = F.getIterator();

unittests/ADT/SimpleIListTest.cpp

  174   EXPECT_EQ(C.getIterator(), L.erase(B.getIterator()));
  174   EXPECT_EQ(C.getIterator(), L.erase(B.getIterator()));
  209   L.eraseAndDispose(B->getIterator(), deleteNode());
  226   L.eraseAndDispose(B.getIterator(), doNothing);
  250   EXPECT_EQ(E.getIterator(), L.erase(B.getIterator(), E.getIterator()));
  250   EXPECT_EQ(E.getIterator(), L.erase(B.getIterator(), E.getIterator()));
  250   EXPECT_EQ(E.getIterator(), L.erase(B.getIterator(), E.getIterator()));
  274   EXPECT_EQ(E.getIterator(),
  275             L.eraseAndDispose(B->getIterator(), E.getIterator(), deleteNode()));
  275             L.eraseAndDispose(B->getIterator(), E.getIterator(), deleteNode()));
  299   EXPECT_EQ(E.getIterator(),
  300             L.eraseAndDispose(B.getIterator(), E.getIterator(), doNothing));
  300             L.eraseAndDispose(B.getIterator(), E.getIterator(), doNothing));
  610   Node1Type::self_iterator getIterator1() { return Node1Type::getIterator(); }
  611   Node2Type::self_iterator getIterator2() { return Node2Type::getIterator(); }

unittests/Analysis/LazyCallGraphTest.cpp

 2072   D.getParent()->getFunctionList().insert(D.getIterator(), &E);

unittests/Analysis/MemorySSATest.cpp

  409   SideStore->moveBefore(*EntryStore->getParent(), ++EntryStore->getIterator());
  454   SideStore->moveBefore(*EntryStore->getParent(), EntryStore->getIterator());

unittests/CodeGen/MachineInstrBundleIteratorTest.cpp

   33   auto I = MBI.getIterator();
   98   ASSERT_FALSE(MBI.getIterator() == I);
  100   ASSERT_FALSE(I == MBI.getIterator());
  102   ASSERT_FALSE(MBI.getIterator() == CI);
  104   ASSERT_FALSE(CI == MBI.getIterator());
  122   ASSERT_TRUE(MBI.getIterator() != I);
  124   ASSERT_TRUE(I != MBI.getIterator());
  126   ASSERT_TRUE(MBI.getIterator() != CI);
  128   ASSERT_TRUE(CI != MBI.getIterator());

unittests/IR/IRBuilderTest.cpp

  826   Builder.SetInsertPoint(Call1->getParent(), Call1->getIterator());

unittests/IR/InstructionsTest.cpp

 1031   EXPECT_EQ(Term->getIterator(), skipDebugIntrinsics(BB.begin()));

unittests/MI/LiveIntervalTest.cpp

  126   MBB.splice(ToInstr.getIterator(), &MBB, FromInstr.getIterator());
  126   MBB.splice(ToInstr.getIterator(), &MBB, FromInstr.getIterator());