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

References

examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h
  103       for (auto &F : M)
examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h
  145     for (auto &F : *M)
examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h
  221     for (auto &F : *M)
examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h
  238     for (auto &F : *M)
include/llvm/ADT/STLExtras.h
  322     while (this->I != End && !Pred(*this->I))
  367     while (!this->Pred(*this->I))
  528   using type = std::tuple<decltype(*declval<Iters>())...>;
  556     return value_type(*std::get<Ns>(iterators)...);
  865     return &*Begin;
include/llvm/ADT/ilist.h
  245     for (const_reference V : L2)
  250     pointer Node = &*IT++;
  362     return &*std::prev(I);
  374     return &*Next;
include/llvm/ADT/ilist_iterator.h
  142   pointer operator->() const { return &operator*(); }
  190   static SimpleType getSimplifiedValue(const iterator &Node) { return &*Node; }
include/llvm/ADT/iterator.h
  271   ReferenceT operator*() const { return *I; }
  323   T &operator*() { return Ptr = &*this->I; }
include/llvm/ADT/simple_ilist.h
  138   reference front() { return *begin(); }
  139   const_reference front() const { return *begin(); }
  140   reference back() { return *rbegin(); }
  141   const_reference back() const { return *rbegin(); }
  175     for (const_reference V : L2)
  198     remove(*I++);
  215     dispose(&*I);
  276     if (comp(*RI, *LI)) {
  276     if (comp(*RI, *LI)) {
  279       RI = std::find_if(RI, RE, [&](reference RV) { return !comp(RV, *LI); });
include/llvm/Analysis/BlockFrequencyInfoImpl.h
 1342   for (const BlockT &BB : *F) {
include/llvm/Analysis/IVUsers.h
  117     for (IVStrideUse &U : IVUses)
include/llvm/Analysis/SparsePropagation.h
  495       for (Instruction &I : *BB)
include/llvm/CodeGen/BasicTTIImpl.h
  480           ImmutableCallSite CS(&*J);
include/llvm/CodeGen/CommandFlags.inc
  373   for (auto &F : M) {
  397       for (auto &B : F)
  398         for (auto &I : B)
include/llvm/CodeGen/MachineFunction.h
  696     for (const MachineBasicBlock &MBB : BasicBlocks)
include/llvm/CodeGen/MachineInstrBundleIterator.h
  178   reference operator*() const { return *MII; }
include/llvm/CodeGen/MachineRegisterInfo.h
 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());
  396           *skipDebugInstructionsForward(BundleStart, BundleEnd);
  417           return SlotIndex(&*I, Index.getSlot());
  573       SlotIndex newIndex(&*newItr, SlotIndex::Slot_Block);
  619         endEntry = getMBBStartIdx(&*nextMBB).listEntry();
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
  397       for (auto &F : SrcM) {
  454     for (auto &GV : SrcM.globals())
  459     for (auto &A : SrcM.aliases())
  500     for (auto &GV : SrcM.globals())
  505     for (auto &A : SrcM.aliases()) {
include/llvm/IR/InstIterator.h
   76   inline reference operator*()  const { return *BI; }
include/llvm/IR/InstVisitor.h
   91       static_cast<SubClass*>(this)->visit(*Start++);
include/llvm/IR/PassManager.h
 1299     for (Function &F : M) {
lib/Analysis/AliasAnalysis.cpp
  721     if (isModOrRefSet(intersectModRef(getModRefInfo(&*I, Loc), Mode)))
lib/Analysis/AliasSetTracker.cpp
  324       FoundSet = &*Cur;
  327       FoundSet->mergeSetIn(*Cur, *this);
  343       FoundSet = &*Cur;
  346       FoundSet->mergeSetIn(*Cur, *this);
  516   for (auto &I : BB)
  527   for (const AliasSet &AS : AST) {
  548       for (auto &Access : *Accesses)
  614     ASVector.push_back(&*I);
  703   for (const AliasSet &AS : *this)
lib/Analysis/AssumptionCache.cpp
  176   for (BasicBlock &B : F)
  177     for (Instruction &II : B)
  285     for (const BasicBlock &B : cast<Function>(*I.first))
  286       for (const Instruction &II : B)
lib/Analysis/BranchProbabilityInfo.cpp
  198   for (auto &I : *BB)
  841   for (const auto &BI : *LastF) {
lib/Analysis/CFG.cpp
  243       if (&*I == B)
lib/Analysis/CFLGraph.h
  637     for (auto &Bb : Fn.getBasicBlockList())
  638       for (auto &Inst : Bb.getInstList())
lib/Analysis/CallGraph.cpp
   34   for (Function &F : M)
   73   for (BasicBlock &BB : *F)
   74     for (Instruction &I : BB) {
lib/Analysis/CallGraphSCCPass.cpp
  286     for (BasicBlock &BB : *F)
  287       for (Instruction &I : BB) {
lib/Analysis/CodeMetrics.cpp
  121   for (const Instruction &I : *BB) {
lib/Analysis/CostModel.cpp
  100   for (BasicBlock &B : *F) {
  101     for (Instruction &Inst : B) {
lib/Analysis/DDG.cpp
  138   for (auto &BB : F.getBasicBlockList())
lib/Analysis/DependenceGraphBuilder.cpp
   42     for (Instruction &I : *BB) {
lib/Analysis/DivergenceAnalysis.cpp
  225     for (auto &I : *UserBlock) {
lib/Analysis/GlobalsModRef.cpp
  288   for (Function &F : M)
  300   for (GlobalVariable &GV : M.globals())
lib/Analysis/GuardUtils.cpp
   29   for (auto &Insn : *DeoptBB) {
lib/Analysis/IVUsers.cpp
  315     (void)AddUsersIfInteresting(&*I);
  326   for (const IVStrideUse &IVUse : IVUses) {
lib/Analysis/InlineCost.cpp
 1575     if (EphValues.count(&*I))
 1587     if (Base::visit(&*I))
 2101       for (User *U : BlockAddress::get(&*BI)->users())
 2105     for (auto &II : *BI) {
 2105     for (auto &II : *BI) {
lib/Analysis/InstructionPrecedenceTracking.cpp
   66   for (auto &I : *BB)
   83   for (const Instruction &Insn : *BB)
lib/Analysis/LazyCallGraph.cpp
  100   for (BasicBlock &BB : *F)
  101     for (Instruction &I : BB) {
  157   for (Function &F : M) {
  178   for (auto &A : M.aliases()) {
  192   for (GlobalVariable &GV : M.globals())
 1777   for (Function &F : M)
 1810   for (Function &F : M)
lib/Analysis/LazyValueInfo.cpp
  710     for (Instruction &I : *BB)
  846   for (Instruction &I : make_range(std::next(BBI->getIterator().getReverse()),
lib/Analysis/LegacyDivergenceAnalysis.cpp
  173     if (!cast<PHINode>(I)->hasConstantOrUndefValue() && DV.insert(&*I).second)
  174       Worklist.push_back(&*I);
  204     for (auto &I : *InfluencedBB) {
  396     auto &BB = *BI;
lib/Analysis/Loads.cpp
  395     Instruction *Inst = &*--ScanFrom;
lib/Analysis/LoopAccessAnalysis.cpp
  710   for (auto &AS : AST) {
  837   for (auto &AS : AST) {
 1816     for (Instruction &I : *BB) {
lib/Analysis/LoopCacheAnalysis.cpp
  519     for (Instruction &I : *BB) {
lib/Analysis/LoopInfo.cpp
  423   for (const Instruction &I : BB) {
  481     for (Instruction &I : *BB)
  561     for (Instruction &I : *BB) {
lib/Analysis/LoopPass.cpp
  108     for (Instruction &I : *BB) {
lib/Analysis/MemoryBuiltins.cpp
  999     Builder.SetInsertPoint(&*PHI.getIncomingBlock(i)->getFirstInsertionPt());
lib/Analysis/MemoryDependenceAnalysis.cpp
  190     Instruction *Inst = &*--ScanIt;
  517     Instruction *Inst = &*--ScanIt;
 1011     RemoveFromReverseMap(ReverseNonLocalPtrDeps, &*ScanPos, CacheKey);
 1586     NewDirtyVal = MemDepResult::getDirty(&*++RemInst->getIterator());
lib/Analysis/MemorySSA.cpp
  534         return &*Defs->rbegin();
 1119     for (MemoryAccess &L : *Accesses) {
 1175           IncomingVal = &*BlockDefs->rbegin();
 1244     for (MemoryAccess &MA : *Pair.second)
 1348   for (MemoryAccess &MA : *Accesses) {
 1521   for (BasicBlock &B : F) {
 1525     for (Instruction &I : B) {
 1556   for (auto &BB : F)
 1930   for (const BasicBlock &BB : F) {
 1943     for (const MemoryAccess &MA : *Accesses) {
 1969   for (BasicBlock &B : F) {
 1978     for (Instruction &I : B) {
 2006       assert(&*ALI == *AAI && "Not the same accesses in the same order");
 2015         assert(&*DLI == *ADI && "Not the same defs in the same order");
 2029   for (BasicBlock &B : F) {
 2035     for (Instruction &I : B) {
 2100   for (const auto &I : *AL)
lib/Analysis/MemorySSAUpdater.cpp
  162         return &*Iter;
  166       for (auto &U : make_range(++MA->getReverseIterator(), End))
  183     CachedPreviousDef.insert({BB, &*Defs->rbegin()});
  184     return &*Defs->rbegin();
  272       MemoryAccess *FirstDef = &*Defs->begin();
  435     MemoryAccess *FirstDef = &*MSSA->getWritableBlockDefs(StartBlock)->begin();
  489         auto *FirstDef = &*Defs->begin();
  569               &*(--DefIt), VMap, MPhiMap, CloneWasSimplified, MSSA);
  589   for (const MemoryAccess &MA : *Acc) {
  828         return &*(--Defs->end());
 1092       for (auto &DefToReplaceUses : *DefsList) {
 1175   for (Instruction &I : make_range(Start->getIterator(), To->end()))
 1184                                     : cast<MemoryUseOrDef>(&*NextIt);
 1197     if (auto *Phi = dyn_cast<MemoryPhi>(&*Defs->begin()))
 1353       for (MemoryAccess &MA : *Acc)
 1363       MemoryAccess *MA = &*AB;
 1384     removeMemoryAccess(&*(BBI++));
lib/Analysis/ModuleSummaryAnalysis.cpp
  271   for (const BasicBlock &BB : F)
  272     for (const Instruction &I : BB) {
  732   for (auto &F : M) {
  756   for (const GlobalVariable &G : M.globals()) {
  764   for (const GlobalAlias &A : M.aliases())
lib/Analysis/MustExecute.cpp
  357   for (Function &F : M) {
  400     for (auto &F : M)
lib/Analysis/OrderedBasicBlock.cpp
   90   if (LastInstFound != BB->end() && I == &*LastInstFound) {
  108   if (LastInstFound != BB->end() && Old == &*LastInstFound)
lib/Analysis/PhiValues.cpp
  152   for (const BasicBlock &BB : F) {
  185   for (const BasicBlock &BB : F)
lib/Analysis/ProfileSummaryInfo.cpp
  153     for (const auto &BB : *F)
  154       for (const auto &I : BB)
  161   for (const auto &BB : *F)
  182     for (const auto &BB : *F)
  183       for (const auto &I : BB)
  190   for (const auto &BB : *F)
  207     for (const auto &BB : *F)
  208       for (const auto &I : BB)
  215   for (const auto &BB : *F)
  381   for (auto &F : M) {
lib/Analysis/ScalarEvolution.cpp
 6117       for (auto &I : *BB) {
12489     for (auto &I : *BB) {
lib/Analysis/ScalarEvolutionExpander.cpp
   64             Ret = CastInst::Create(Op, V, Ty, "", &*IP);
   75     Ret = CastInst::Create(Op, V, Ty, V->getName(), &*IP);
   80   assert(SE.DT.dominates(Ret, &*BIP));
  205           IP->getOperand(1) == RHS && !canGenerateIncompatiblePoison(&*IP))
  206         return &*IP;
  512            SE.DT.dominates(cast<Instruction>(V), &*Builder.GetInsertPoint()));
  537           return &*IP;
  992     Builder.SetInsertPoint(&*NewInsertPt);
 1412                          &*Builder.GetInsertPoint())) {
 1521                       &*NewInsertPt);
 1816   Instruction *InsertPt = &*Builder.GetInsertPoint();
 1846           InsertPt = &*L->getHeader()->getFirstInsertionPt();
 1852           InsertPt = &*L->getHeader()->getFirstInsertionPt();
 1856           InsertPt = &*std::next(InsertPt->getIterator());
 1865     InsertPt = &*InsertPt->getParent()->getFirstInsertionPt();
 2055               IP = &*PN->getParent()->getFirstInsertionPt();
 2074       IRBuilder<> Builder(&*L->getHeader()->getFirstInsertionPt());
lib/Analysis/StackSafetyAnalysis.cpp
  434   for (auto &F : M.functions())
  437   for (auto &A : M.aliases())
  551   for (auto &F : M.functions())
  557   for (auto &A : M.aliases()) {
lib/Analysis/ValueTracking.cpp
  557       if (&*I == CxtI)
  572     if (!isGuaranteedToTransferExecutionToSuccessor(&*I))
 4299     if (!isGuaranteedToTransferExecutionToSuccessor(&*I))
 4312   for (const Instruction &LI : *L->getHeader()) {
 4410     for (auto &I : make_range(Begin, End)) {
lib/Analysis/VectorUtils.cpp
  385     for (auto &I : *BB) {
  817     for (auto &I : *BB) {
lib/AsmParser/LLParser.cpp
  236     UpgradeCallsToIntrinsic(&*FI++); // must be post-increment, as we remove
  242     Function *F = &*FI++;
lib/Bitcode/Reader/BitcodeReader.cpp
  163   for (auto &F : *M) {
 2804         BB = &*BBI;
 2968   for (Function &F : *TheModule) {
 2982   for (GlobalVariable &GV : TheModule->globals())
 5296   for (Function &F : *TheModule) {
lib/Bitcode/Reader/MetadataLoader.cpp
  513     for (auto &GV : TheModule.globals()) {
  533     for (auto &BB : F)
  534       for (auto &I : BB)
lib/Bitcode/Writer/BitcodeWriter.cpp
 1169   for (const GlobalValue &GV : M.globals()) {
 1182   for (const Function &F : M) {
 1261   for (const GlobalVariable &GV : M.globals()) {
 1308   for (const Function &F : M) {
 1345   for (const GlobalAlias &A : M.aliases()) {
 1369   for (const GlobalIFunc &I : M.ifuncs()) {
 1939   for (const NamedMDNode &NMD : M.named_metadata()) {
 2121   for (const Function &F : M)
 2126   for (const GlobalVariable &GV : M.globals())
 2169   for (const BasicBlock &BB : F)
 2170     for (const Instruction &I : BB) {
 3065   for (const Function &F : M) {
 3202       writeInstruction(*I, InstID, Vals);
 3834   for (const Function &F : M) {
 3854   for (const GlobalVariable &G : M.globals())
 3858   for (const GlobalAlias &A : M.aliases()) {
 4268       writeFunction(*F, FunctionToBitcodeIndex);
 4570   for (const GlobalVariable &GV : M.globals()) {
 4584   for (const Function &F : M) {
 4598   for (const GlobalAlias &A : M.aliases()) {
 4612   for (const GlobalIFunc &I : M.ifuncs()) {
lib/Bitcode/Writer/ValueEnumerator.cpp
  112   for (const GlobalVariable &G : M.globals())
  116   for (const GlobalAlias &A : M.aliases())
  119   for (const GlobalIFunc &I : M.ifuncs())
  122   for (const Function &F : M) {
  137   for (const Function &F : M)
  139   for (const GlobalAlias &A : M.aliases())
  141   for (const GlobalIFunc &I : M.ifuncs())
  143   for (const GlobalVariable &G : M.globals())
  147   for (const Function &F : M) {
  153     for (const BasicBlock &BB : F)
  157     for (const BasicBlock &BB : F)
  158       for (const Instruction &I : BB)
  163     for (const BasicBlock &BB : F)
  164       for (const Instruction &I : BB)
  274     const Function &F = *I;
  277     for (const BasicBlock &BB : F)
  281     for (const BasicBlock &BB : F)
  282       for (const Instruction &I : BB)
  286     for (const BasicBlock &BB : F)
  287       for (const Instruction &I : BB)
  293   for (const GlobalVariable &G : M.globals())
  295   for (const Function &F : M)
  297   for (const GlobalAlias &A : M.aliases())
  299   for (const GlobalIFunc &I : M.ifuncs())
  301   for (const GlobalVariable &G : M.globals())
  304   for (const GlobalAlias &A : M.aliases())
  306   for (const GlobalIFunc &I : M.ifuncs())
  308   for (const Function &F : M) {
  327   for (const GlobalVariable &GV : M.globals())
  331   for (const Function & F : M) {
  337   for (const GlobalAlias &GA : M.aliases())
  341   for (const GlobalIFunc &GIF : M.ifuncs())
  348   for (const GlobalVariable &GV : M.globals()) {
  356   for (const GlobalAlias &GA : M.aliases())
  360   for (const GlobalIFunc &GIF : M.ifuncs())
  364   for (const Function &F : M)
  380   for (const GlobalVariable &GV : M.globals()) {
  391   for (const Function &F : M) {
  401     for (const BasicBlock &BB : F)
  402       for (const Instruction &I : BB) {
  557   for (const auto &I : M.named_metadata())
  960   for (const BasicBlock &BB : F) {
  961     for (const Instruction &I : BB)
  981   for (const BasicBlock &BB : F) {
  982     for (const Instruction &I : BB) {
 1023   for (const BasicBlock &BB : *F)
lib/CodeGen/Analysis.cpp
  536       if (&*BBI == I)
  548           !isSafeToSpeculativelyExecute(&*BBI))
  743   for (const MachineBasicBlock &MBB : MF) {
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
  333     for (auto &F: M.getFunctionList()) {
 1052   for (auto &MBB : *MF) {
 1166   for (const auto &BB : F) {
 1271   for (const auto &G : M.globals()) {
 1396   for (const auto &G : M.globals())
 1403   for (const Function &F : M) {
 1501   for (const auto &Alias : M.aliases()) {
 1512   for (const auto &IFunc : M.ifuncs())
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
 1407   for (const auto &MBB : *MF) {
 1426   for (const auto &MBB : *MF) {
 2858   for (const auto &MBB : *MF) {
 2983   for (const GlobalVariable &GV : MMI->getModule()->globals()) {
lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp
  240   for (const auto &MBB : *MF) {
lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
  125   beginFragment(&*MF->begin(), getExceptionSym);
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
  630     getForwardingRegsDefinedByMI(*I, ExplicitFwdRegDefs, ImplicitFwdRegDefs);
  647     if (auto ParamValue = TII->describeLoadedValue(*I)) {
  708   for (const MachineBasicBlock &MBB : MF) {
  709     for (const MachineInstr &MI : MBB.instrs()) {
  947   for (const GlobalVariable &Global : M->globals()) {
 1729   for (const auto &MBB : *MF)
lib/CodeGen/AsmPrinter/EHStreamer.cpp
  243   for (const auto &MBB : *Asm->MF) {
lib/CodeGen/AsmPrinter/WinCFGuard.cpp
   47   for (const Function &F : *M)
lib/CodeGen/AsmPrinter/WinException.cpp
   54   for (const Function &F : *M)
  915       StartLabel = getMCSymbolForMBB(Asm, &*FuncletStart);
 1156     int FuncletState = HandlerStates[&*FuncletStart];
 1161         EndSymbol = getMCSymbolForMBB(Asm, &*FuncletEnd);
lib/CodeGen/BranchFolding.cpp
  200   for (MachineBasicBlock &MBB : MF) {
  230   for (const MachineBasicBlock &BB : MF) {
  523     MachineBasicBlock *NextBB = &*I;
  703       return (MBB != &*MF->begin()) && std::prev(I)->canFallThrough();
 1085   for (MachineBasicBlock &MBB : MF) {
 1125     MachineBasicBlock *IBB = &*I;
 1126     MachineBasicBlock *PredBB = &*std::prev(I);
 1185               FBB = &*Next;
 1214     PredBB = &*std::prev(I); // this may have been changed in TryTailMergeBlocks
 1281     MachineBasicBlock *MBB = &*I++;
 1347   for (MachineInstr &MI : MBB.instrs())
 1359   for (MachineInstr &MI : MBB.instrs())
 1403     auto FallThroughEHScope = EHScopeMembership.find(&*FallThrough);
 1425     } else if (MBB->isSuccessor(&*FallThrough)) {
 1430         Pred->ReplaceUsesOfBlockWith(MBB, &*FallThrough);
 1435         MJTI->ReplaceMBBInJumpTables(MBB, &*FallThrough);
 1443   MachineBasicBlock &PrevBB = *std::prev(MachineFunction::iterator(MBB));
 1767             MachineBasicBlock *NextBB = &*std::next(MBB->getIterator());
 1788         if (SuccBB != MBB && &*SuccPrev != MBB &&
 1816           PrevBB.isSuccessor(&*FallThrough)) {
 1834     MachineBasicBlock *MBB = &*I++;
lib/CodeGen/BranchRelaxation.cpp
  129   for (MachineBasicBlock &MBB : *MF) {
  142   for (auto &MBB : *MF) {
  160   for (MachineBasicBlock &MBB : *MF)
  164   adjustBlockOffsets(*MF->begin());
  197   for (auto &MBB : make_range(MachineFunction::iterator(Start), MF->end())) {
  384     MachineBasicBlock &NextBB = *std::next(MachineFunction::iterator(MBB));
  403     FBB = &(*std::next(MachineFunction::iterator(MBB)));
  484     MachineBasicBlock &MBB = *I;
lib/CodeGen/BreakFalseDeps.cpp
  276   for (MachineBasicBlock &MBB : mf) {
lib/CodeGen/CFGuardLongjmp.cpp
   74   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/CFIInstrInserter.cpp
  137   for (MachineBasicBlock &MBB : MF) {
  151   for (MachineBasicBlock &MBB : MF) {
  250   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/CodeGenPrepare.cpp
  331       Value *CurValue = &*CurInstIterator;
  449     BasicBlock* BB = &*F.begin();
  476       BasicBlock *BB = &*I++;
  509     for (BasicBlock &BB : F) {
  544     for (BasicBlock &BB : F)
  545       for (Instruction &I : BB)
  568   for (auto &Block : llvm::make_range(std::next(F.begin()), F.end()))
  645   for (auto &Block : llvm::make_range(std::next(F.begin()), F.end()))
  941        &*R != RelocatedBase; ++R)
 1115                                       CI->getType(), "", &*InsertPt);
 1207   for (Instruction &Iter : *Cmp->getParent()) {
 1391                           &*InsertPt);
 1571                                                    "", &*InsertPt);
 1574                                                    "", &*InsertPt);
 1583                                        TruncI->getType(), "", &*TruncInsertPt);
 1672                                                    "", &*InsertPt);
 1675                                                    "", &*InsertPt);
 2001     do { ++BI; } while (isa<DbgInfoIntrinsic>(BI) || &*BI == BCI);
 2002     if (&*BI != RetI)
 2007     if (&*BI != RetI)
 2036       do { ++RI; } while (RI != RE && isa<DbgInfoIntrinsic>(&*RI));
 2040       CallInst *CI = dyn_cast<CallInst>(&*RI);
 2305         Point.PrevInst = &*--It;
 2317         Instruction *Position = &*Point.BB->getFirstInsertionPt();
 5012     Value *CurValue = &*CurInstIterator;
 5637       InsertedTrunc = new TruncInst(I, Src->getType(), "", &*InsertPt);
 5817       if (&*CurInstIterator == And)
 5943     SelectInst *I = dyn_cast<SelectInst>(&*It);
 6151                                 SVI->getOperand(2), "", &*InsertPt);
 7093     MadeChange |= optimizeInst(&*CurInstIterator++, ModifiedDT);
 7101     for (auto &I : reverse(BB)) {
 7118   for (BasicBlock &BB : F) {
 7121       Instruction *Insn = &*BI++;
 7143           DVI->insertBefore(&*VI->getParent()->getFirstInsertionPt());
 7189   for (auto &BB : F) {
lib/CodeGen/DeadMachineInstructionElim.cpp
  109   for (MachineBasicBlock &MBB : make_range(MF.rbegin(), MF.rend())) {
lib/CodeGen/DetectDeadLanes.cpp
  534   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/DwarfEHPrepare.cpp
  186   for (BasicBlock &BB : Fn) {
lib/CodeGen/EdgeBundles.cpp
   44   for (const auto &MBB : *MF) {
   80   for (const auto &MBB : *MF) {
lib/CodeGen/ExpandMemCmp.cpp
  825   for (Instruction& I : BB) {
  847     if (runOnBlock(*BBIt, TLI, TTI, TL, DL)) {
lib/CodeGen/FEntryInserter.cpp
   42   auto &FirstMBB = *MF.begin();
lib/CodeGen/FinalizeISel.cpp
   53     MachineBasicBlock *MBB = &*I;
lib/CodeGen/GCRootLowering.cpp
  110       MI->getFunctionInfo(*I); // Instantiate the GC strategy.
  151   for (; !CouldBecomeSafePoint(&*IP); ++IP)
  196   for (BasicBlock &BB : F) 
  275   for (MachineBasicBlock &MBB : MF)
lib/CodeGen/GlobalISel/CSEInfo.cpp
  232   for (auto &MBB : MF) {
lib/CodeGen/GlobalISel/IRTranslator.cpp
  758     NextMBB = &*BBI;
 2278   for (const BasicBlock &BB: F) {
 2335       for (const Instruction &Inst : *BB) {
lib/CodeGen/GlobalISel/InstructionSelect.cpp
  153   for (MachineBasicBlock &MBB : MF) {
  231   for (const auto &MBB : MF) {
lib/CodeGen/GlobalISel/LegalizerInfo.cpp
  740     for (const MachineBasicBlock &MBB : MF)
lib/CodeGen/GlobalMerge.cpp
  581   for (Function &F : M) {
  582     for (BasicBlock &BB : F) {
  610   for (auto &GV : M.globals()) {
lib/CodeGen/IfConversion.cpp
  640   return &*I;
  708     TExit = &*I;
 1427   for (MachineBasicBlock &MBB : MF)
 1444     if (I == E || !I->empty() || !PI->isSuccessor(&*I))
 1449   return PI->isSuccessor(&*I);
 2332   MachineBasicBlock *Last = &*FromMBB.getParent()->rbegin();
lib/CodeGen/ImplicitNullChecks.cpp
  304   for (auto &MBB : MF)
lib/CodeGen/IndirectBrExpandPass.cpp
   93   for (BasicBlock &BB : F)
  117   for (BasicBlock &BB : F) {
lib/CodeGen/InterleavedLoadCombinePass.cpp
 1264     for (BasicBlock &BB : F) {
 1265       for (Instruction &I : BB) {
lib/CodeGen/LexicalScopes.cpp
   72   for (const auto &MBB : *MF) {
  289     for (const auto &MBB : *MF)
lib/CodeGen/LiveDebugValues.cpp
  636   for (const MachineBasicBlock &BB : MF) {
 1308   MachineBasicBlock &First_MBB = *(MF.begin());
 1326   for (auto &MBB : MF) {
 1340   for (auto &MBB : MF)
lib/CodeGen/LiveDebugVariables.cpp
  685     MachineBasicBlock *MBB = &*MFI;
  972   for (MachineBasicBlock &MBB : mf) {
 1354     SlotIndex MBBEnd = LIS.getMBBEndIdx(&*MBB);
 1356     LLVM_DEBUG(dbgs() << ' ' << printMBBReference(*MBB) << '-' << MBBEnd);
 1357     insertDebugValue(&*MBB, Start, Stop, Loc, Spilled, SpillOffset, LIS, TII,
 1366       MBBEnd = LIS.getMBBEndIdx(&*MBB);
 1367       LLVM_DEBUG(dbgs() << ' ' << printMBBReference(*MBB) << '-' << MBBEnd);
 1368       insertDebugValue(&*MBB, Start, Stop, Loc, Spilled, SpillOffset, LIS, TII,
 1383   LLVM_DEBUG(dbgs() << ' ' << printMBBReference(*MBB));
 1384   insertDebugLabel(&*MBB, loc, LIS, TII);
lib/CodeGen/LiveIntervals.cpp
  215   for (const MachineBasicBlock &MBB : *MF) {
  319   for (const MachineBasicBlock &MBB : *MF) {
lib/CodeGen/LiveRangeShrink.cpp
  122   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/LiveVariables.cpp
  669     assert(Visited.count(&*i) != 0 && "unreachable basic block found");
  709   for (const auto &MBB : Fn)
lib/CodeGen/LocalStackSlotAllocation.cpp
  303   for (MachineBasicBlock &BB : Fn) {
lib/CodeGen/LoopTraversal.cpp
   28   MachineBasicBlock *Entry = &*MF.begin();
lib/CodeGen/LowerEmuTLS.cpp
   75   for (const auto &G : M.globals()) {
lib/CodeGen/MIRCanonicalizerPass.cpp
   89   ReversePostOrderTraversal<MachineBasicBlock *> RPOT(&*MF.begin());
  253       if (&*BBI == Def) {
  258       if (&*BBI == UseToBringDefCloserTo) {
  311   for (MachineInstr &MI : MBB->instrs()) {
lib/CodeGen/MIRNamerPass.cpp
   59     ReversePostOrderTraversal<MachineBasicBlock *> RPOT(&*MF.begin());
lib/CodeGen/MIRParser/MIParser.cpp
 2964   for (auto &BB : F) {
 3012   for (const auto &BB : F) {
 3014     for (const auto &I : BB)
lib/CodeGen/MIRParser/MIRParser.cpp
  321   for (const MachineBasicBlock &MBB : MF) {
  376       MF.addCallArgsForwardingRegs(&*CallI, std::move(CSInfo));
  613   for (const MachineBasicBlock &MBB : MF) {
lib/CodeGen/MIRPrinter.cpp
  230   for (const auto &MBB : MF) {
  595       MachineBasicBlock *Next = const_cast<MachineBasicBlock*>(&*NextI);
  688     const MachineInstr &MI = *I;
lib/CodeGen/MachineBasicBlock.cpp
  410   for (const MachineInstr &MI : instrs()) {
  834   if (!isSuccessor(&*Fallthrough))
  848                ? &*Fallthrough
  853   if (!TBB) return &*Fallthrough;
  859     return &*Fallthrough;
  867   return (FBB == nullptr) ? &*Fallthrough : nullptr;
  905       MachineInstr *MI = &*I;
  925       MachineInstr *MI = &*I;
  947       Terminators.push_back(&*I);
  956       NewTerminators.push_back(&*I);
  973       for (MachineInstr &MI : NMBB->instrs()) {
 1000           LV->getVarInfo(Reg).Kills.push_back(&*I);
 1001         LLVM_DEBUG(dbgs() << "Restored terminator kill: " << *I);
 1156   unbundleSingleMI(&*I);
lib/CodeGen/MachineBlockFrequencyInfo.cpp
  137           LayoutOrderMap[&*MBI] = O;
lib/CodeGen/MachineBlockPlacement.cpp
 1172   for (MachineBasicBlock &BB : *F) {
 1656     if (BlockFilter && !BlockFilter->count(&*I))
 1658     if (BlockToChain[&*I] != &PlacedChain) {
 1663       return *BlockToChain[&*I]->begin();
 2563     MachineBasicBlock *BB = &*FI;
 2575       MachineBasicBlock *NextBB = &*NextFI;
 2602   for (MachineBasicBlock &MBB : *F)
 2615     for (MachineBasicBlock &MBB : *F)
 2649     MachineBasicBlock *PrevBB = &*std::prev(MachineFunction::iterator(ChainBB));
 2787         &*std::prev(MachineFunction::iterator(ChainBB));
 2916         if (&(*PrevUnplacedBlockIt) == RemBB) {
 3066     for (MachineBasicBlock &MBB : MF)
 3073       if (!LayoutPred->isSuccessor(&*MBI))
 3142   for (MachineBasicBlock &MBB : F) {
lib/CodeGen/MachineCombiner.cpp
  655   for (auto &MBB : MF)
lib/CodeGen/MachineCopyPropagation.cpp
  168     for (const MachineInstr &MI :
  305   for (MachineInstr &MI :
  452     for (MachineInstr &KMI :
  650   for (MachineBasicBlock &MBB : MF)
lib/CodeGen/MachineFrameInfo.cpp
  197   for (const MachineBasicBlock &MBB : MF) {
lib/CodeGen/MachineFunction.cpp
  305         assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&
  314       MBBNumbering[BlockNo] = &*MBBI;
  346     MachineInstr *Cloned = CloneMachineInstr(&*I);
  514   for (const auto &BB : *this) {
lib/CodeGen/MachineInstr.cpp
  604       if (!I1->isIdenticalTo(*I2, Check))
lib/CodeGen/MachineInstrBundle.cpp
   50     MachineBasicBlock *MBB = &*I;
   54       MachineInstr *MI = &*MII;
  259     MachineBasicBlock &MBB = *I;
lib/CodeGen/MachineLICM.cpp
  763     if (IsLoopInvariantInst(*I) && !HasLoopPHIUse(&*I))
  763     if (IsLoopInvariantInst(*I) && !HasLoopPHIUse(&*I))
  764       Candidates.push_back(&*I);
lib/CodeGen/MachineLoopInfo.cpp
   58     MachineBasicBlock *PriorMBB = &*std::prev(TopMBB->getIterator());
   63       PriorMBB = &*std::prev(TopMBB->getIterator());
   73     MachineBasicBlock *NextMBB = &*std::next(BotMBB->getIterator());
   76       if (BotMBB == &*std::next(BotMBB->getIterator()))
   78       NextMBB = &*std::next(BotMBB->getIterator());
lib/CodeGen/MachineLoopUtils.cpp
   22   return *std::next(BB->instr_begin(), Offset);
lib/CodeGen/MachineOutliner.cpp
  983   MachineBasicBlock *MBB = &*OF.MF->begin();
 1295   for (Function &F : M) {
 1330     for (MachineBasicBlock &MBB : *MF) {
 1356   for (const Function &F : M) {
 1373   for (const Function &F : M) {
lib/CodeGen/MachineScheduler.cpp
  518     Scheduler.startBlock(&*MBB);
  543     getSchedRegions(&*MBB, MBBRegions, Scheduler.doMBBSchedRegionsTopDown());
  552       Scheduler.enterRegion(&*MBB, I, RegionEnd, NumRegionInstrs);
  562       LLVM_DEBUG(dbgs() << MF->getName() << ":" << printMBBReference(*MBB)
  586       Scheduler.fixupKills(*MBB);
lib/CodeGen/MachineSink.cpp
  324     for (auto &MBB: MF)
 1346   for (auto &BB : MF)
lib/CodeGen/MachineSizeOpts.cpp
   54   for (const auto &MBB : *MF)
   71   for (const auto &MBB : *MF)
lib/CodeGen/MachineVerifier.cpp
  405     visitMachineBasicBlockBefore(&*MFI);
  413       if (MBBI->getParent() != &*MFI) {
  414         report("Bad instruction parent pointer", &*MFI);
  415         errs() << "Instruction: " << *MBBI;
  423                &*MBBI);
  427                &*MBBI);
  433         CurBundle = &*MBBI;
  436         report("No bundle header", &*MBBI);
  437       visitMachineInstrBefore(&*MBBI);
  439         const MachineInstr &MI = *MBBI;
  450       visitMachineInstrAfter(&*MBBI);
  459     visitMachineBasicBlockAfter(&*MFI);
  586   for (const auto &MBB : *MF) {
  693       } else if (!MBB->isSuccessor(&*MBBI)) {
  737         if (&*MBBI != TBB)
  746       } else if (!matchPair(MBB->succ_begin(), TBB, &*MBBI)) {
 2141   for (const auto &MBB : *MF) {
 2176   for (const auto &MBB : *MF) {
 2273   for (const MachineBasicBlock &MBB : *MF)
 2280   for (const auto &MBB : *MF) {
 2317     for (const auto &MBB : *MF) {
 2620     assert(LiveInts->isLiveInToMBB(LR, &*MFI));
 2623       if (&*MFI == EndMBB)
 2631       VNI->def == LiveInts->getMBBStartIdx(&*MFI);
 2649         errs() << " live into " << printMBBReference(*MFI) << '@'
 2650                << LiveInts->getMBBStartIdx(&*MFI) << ", not live before "
 2661                << VNI->id << " live into " << printMBBReference(*MFI) << '@'
 2662                << LiveInts->getMBBStartIdx(&*MFI) << '\n';
 2665     if (&*MFI == EndMBB)
lib/CodeGen/ModuloSchedule.cpp
  754         LIS.RemoveMachineInstrFromMaps(*MI);
  806         for (auto &BBJ : make_range(MachineBasicBlock::instr_iterator(MI),
  900       updateInstruction(&*I, false, j, 0, VRMap);
 1658       MachineInstr *MI = &*I++;
lib/CodeGen/OptimizePHIs.cpp
   86     Changed |= OptimizeBB(*I);
lib/CodeGen/PHIElimination.cpp
  160     for (auto &MBB : MF)
  168   for (auto &MBB : MF)
  552   for (const auto &MBB : MF)
lib/CodeGen/PatchableFunction.cpp
   66   auto &FirstMBB = *MF.begin();
lib/CodeGen/PeepholeOptimizer.cpp
 1611   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/PostRAHazardRecognizer.cpp
   78   for (auto &MBB : Fn) {
lib/CodeGen/PostRASchedulerList.cpp
  317   for (auto &MBB : Fn) {
lib/CodeGen/PreISelIntrinsicLowering.cpp
   98   for (Function &F : M) {
lib/CodeGen/ProcessImplicitDefs.cpp
  118     LLVM_DEBUG(dbgs() << "Physreg user: " << *UserMI);
  151         WorkList.insert(&*MBBI);
  156     LLVM_DEBUG(dbgs() << printMBBReference(*MFI) << " has " << WorkList.size()
lib/CodeGen/PrologEpilogInserter.cpp
  372   for (MachineBasicBlock &MBB : MF) {
  520       for (MachineBasicBlock &MBB : MF) {
 1165   for (auto &BB : MF) {
lib/CodeGen/RegAllocFast.cpp
 1314   for (MachineBasicBlock &MBB : MF)
lib/CodeGen/RegAllocPBQP.cpp
  445     for (const auto &MBB : MF) {
lib/CodeGen/RegUsageInfoPropagate.cpp
  115   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/RegisterCoalescer.cpp
 3642     MachineBasicBlock *MBB = &*I;
lib/CodeGen/RegisterScavenging.cpp
  763   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/SafeStackColoring.cpp
  147       for (Instruction &I : *BB) {
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp
  818       BasicBlock *BB = &*I++;
  838     if (CallInst *CI = dyn_cast<CallInst>(&*CurInstIterator++))
lib/CodeGen/ScheduleDAGInstrs.cpp
 1147           toggleKills(MRI, LiveRegs, *I, true);
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
 1402   for (SDNode &Node : DAG.allnodes())
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
  133   for (const BasicBlock &BB : *Fn) {
  134     for (const Instruction &I : BB) {
  230   for (const BasicBlock &BB : *Fn) {
  245         assert(&*BB.begin() == PadInst &&
  250         assert(&*BB.begin() == PadInst && "WinEHPrepare failed to demote PHIs");
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
 4609       SDNode *N = &*NI;
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp
   77   for (SDNode &Node : DAG.allnodes()) {
  205   for (SDNode &Node : DAG.allnodes()) {
  429   for (SDNode &Node : DAG.allnodes()) {
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp
  207     LegalizeOp(SDValue(&*I, 0));
lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp
  720   for (SDNode &Node : DAG->allnodes()) {
lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp
  309   for (SDNode &NI : DAG->allnodes()) {
  327   for (SDNode &NI : DAG->allnodes()) {
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
  685   for (SDNode &Node : allnodes())
 1027   assert(&*AllNodes.begin() == &EntryNode);
 8413   for (auto &N : allnodes()) {
 8435   for (auto &N : allnodes()) {
 8449   for (auto &N : allnodes()) {
 8536     SDNode *N = &*I++;
 8555   for (SDNode &Node : allnodes()) {
 8581       SDNode *S = &*++I;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
 2951       if (const CallInst *Call = dyn_cast<CallInst>(&*PredI)) {
 9446   for (const Instruction &I : FuncInfo->Fn->getEntryBlock()) {
10026   return &*I;
10049     NextMBB = &*BBI;
lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
  820     const SDNode *N = &*I;
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
  357   for (BasicBlock &BB : Fn) {
  482     for (const BasicBlock &BB : Fn) {
  550     for (MachineBasicBlock &MBB : mf) {
  637   for (const auto &MBB : *MF) {
  723     if (!ElidedArgCopyInstrs.count(&*I))
  724       SDB->visit(*I);
 1122       SDNode *Node = &*--ISelPosition;
 1296   for (const BasicBlock &BB : *FuncInfo->Fn) {
 1297     for (const Instruction &I : BB) {
 1453         const Instruction *Inst = &*std::prev(BI);
 1474           while (BeforeInst != &*Begin) {
 1475             BeforeInst = &*std::prev(BasicBlock::const_iterator(BeforeInst));
lib/CodeGen/ShadowStackGCLowering.cpp
  169   for (Function &F : M) {
lib/CodeGen/ShrinkWrap.cpp
  470   ReversePostOrderTraversal<MachineBasicBlock *> RPOT(&*MF.begin());
  487   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/SjLjEHPrepare.cpp
  249         TrueValue, &AI, UndefValue, AI.getName() + ".tmp", &*AfterAllocaInsPt);
  262   for (BasicBlock &BB : F) {
  263     for (Instruction &Inst : BB) {
  359   for (BasicBlock &BB : F)
  432   for (BasicBlock &BB : F) {
  435     for (Instruction &I : BB)
  447   for (BasicBlock &BB : F) {
  450     for (Instruction &I : BB) {
lib/CodeGen/SlotIndexes.cpp
   70   for (MachineBasicBlock &MBB : *mf) {
  136     MachineInstr &NextMI = *Next;
lib/CodeGen/SpillPlacement.cpp
  210   for (auto &I : mf) {
lib/CodeGen/SplitKit.cpp
  229     BI.MBB = &*MFI;
  327   SlotIndex Stop = LIS.getMBBEndIdx(&*MFI);
  335       Stop = LIS.getMBBEndIdx(&*MFI);
 1176       std::tie(BlockStart, BlockEnd) = LIS.getSlotIndexes()->getMBBRange(&*MBB);
 1182         LLVM_DEBUG(dbgs() << ':' << VNI->id << "*" << printMBBReference(*MBB));
 1185           LRC.setLiveOutValue(&*MBB, VNI);
 1195         LLVM_DEBUG(dbgs() << ">" << printMBBReference(*MBB));
 1196         BlockEnd = LIS.getMBBEndIdx(&*MBB);
 1203             LRC.setLiveOutValue(&*MBB, VNI); // Live-out as well.
 1208             LRC.addLiveInBlock(LI, MDT[&*MBB], End);
 1211             LRC.addLiveInBlock(LI, MDT[&*MBB]);
 1212             LRC.setLiveOutValue(&*MBB, nullptr);
lib/CodeGen/StackColoring.cpp
  819   for (const MachineBasicBlock &MBB : *MF) {
  962   for (MachineBasicBlock &BB : *MF)
 1078   for (MachineBasicBlock &BB : *MF)
lib/CodeGen/StackMapLivenessAnalysis.cpp
  125   for (auto &MBB : MF) {
lib/CodeGen/StackProtector.cpp
  224   for (const BasicBlock &BB : F)
  225     for (const Instruction &I : BB)
  275   for (const BasicBlock &BB : *F) {
  276     for (const Instruction &I : BB) {
  412     BasicBlock *BB = &*I++;
lib/CodeGen/StackSlotColoring.cpp
  161     MachineBasicBlock *MBB = &*MBBI;
  374   for (MachineBasicBlock &MBB : MF) {
lib/CodeGen/SwiftErrorValueTracking.cpp
  107   for (const auto &LLVMBB : *Fn)
  108     for (const auto &Inst : LLVMBB) {
  124   MachineBasicBlock *MBB = &*MF->begin();
  267     ImmutableCallSite CS(&*It);
  279         getOrCreateVRegUseAt(&*It, MBB, SwiftErrorAddr);
  285       getOrCreateVRegDefAt(&*It, MBB, SwiftErrorAddr);
  288     } else if (const LoadInst *LI = dyn_cast<const LoadInst>(&*It)) {
  296     } else if (const StoreInst *SI = dyn_cast<const StoreInst>(&*It)) {
  302       getOrCreateVRegDefAt(&*It, MBB, SwiftErrorAddr);
  305     } else if (const ReturnInst *R = dyn_cast<const ReturnInst>(&*It)) {
lib/CodeGen/TailDuplicator.cpp
   97     MachineBasicBlock *MBB = &*I;
  269     MachineBasicBlock *MBB = &*I++;
  877     PrevBB = &*std::prev(TailBB->getIterator());
lib/CodeGen/TwoAddressInstructionPass.cpp
 1696     MBB = &*MBBI;
lib/CodeGen/UnreachableBlockElim.cpp
  119     MachineBasicBlock *BB = &*I;
  152     for (auto &I : DeadBlocks[i]->instrs())
  161     MachineBasicBlock *BB = &*I;
lib/CodeGen/VirtRegMap.cpp
  344   for (MachineBasicBlock &MBB : *MF)
  416       MIs.push_back(&*I);
  458         BundleStart = &*std::next(BundledMI->getIterator());
  504       MachineInstr *MI = &*MII;
lib/CodeGen/WasmEHPrepare.cpp
  207   for (BasicBlock &BB : F) {
  278   IRB.SetInsertPoint(&*BB->getFirstInsertionPt());
  355   for (const auto &BB : *F) {
lib/CodeGen/WinEHPrepare.cpp
  176   for (BasicBlock &BB : *F) {
  433   for (const BasicBlock &BB : *Fn) {
  451   for (const BasicBlock &BB : *Fn) {
  507   for (const BasicBlock &BB : *Fn) {
  682   for (BasicBlock &BB : F) {
  694     BasicBlock *BB = &*FI++;
  701       Instruction *I = &*BI++;
  801       for (Instruction &I : *BB)
  942       for (Instruction &I : *BB) {
  968           auto *CI = cast<CallInst>(&*CallI);
 1009     BasicBlock *BB = &*FI++;
 1022   for (BasicBlock &BB : F) {
 1084                             &*PHIBlock->getFirstInsertionPt());
lib/CodeGen/XRayInstrumentation.cpp
   93   for (auto &MBB : MF) {
  126   for (auto &MBB : MF)
  160     for (const auto &MBB : MF)
  194   auto &FirstMBB = *MBI;
lib/ExecutionEngine/ExecutionEngine.cpp
 1198       for (const auto &GV : M.globals()) {
 1228     for (const auto &GV : M.globals()) {
 1271     for (const auto &GV : M.globals()) {
lib/ExecutionEngine/ExecutionEngineBindings.cpp
  188     for (auto &F : *Mod) {
lib/ExecutionEngine/Interpreter/Execution.cpp
 2164     Instruction &I = *SF.CurInst++;         // Increment before execute
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp
  194   for (auto &F : M.functions()) {
  226   for (auto &A : M.aliases())
  231     for (auto &G : M.globals())
lib/ExecutionEngine/Orc/SpeculateAnalyses.cpp
   36   for (auto &BB : F)
  140   for (auto &Block : F.getBasicBlockList())
lib/ExecutionEngine/Orc/Speculation.cpp
   86     for (auto &Fn : M.getFunctionList()) {
lib/FuzzMutate/IRMutator.cpp
   40   for (Function &F : M)
  109     Insts.push_back(&*I);
  190     if (Pred.matches({}, &*I))
  191       RS.sample(&*I, /*Weight=*/1);
  192     InstsBefore.push_back(&*I);
lib/FuzzMutate/RandomIRBuilder.cpp
   57         cast<PointerType>(Ptr->getType())->getElementType(), Ptr, "L", &*IP);
  125       Ptr = new AllocaInst(V->getType(), 0, "A", &*BB.getFirstInsertionPt());
lib/IR/AsmWriter.cpp
  139   for (const GlobalVariable &G : M->globals()) {
  145   for (const GlobalAlias &A : M->aliases()) {
  150   for (const GlobalIFunc &I : M->ifuncs()) {
  155   for (const Function &F : *M) {
  167     for (const BasicBlock &BB : F) {
  169       for (const Instruction &I : BB) {
  278   for (const Function &F : make_range(M->rbegin(), M->rend())) {
  281     for (const BasicBlock &BB : F)
  285     for (const BasicBlock &BB : F)
  286       for (const Instruction &I : BB)
  290     for (const BasicBlock &BB : F)
  291       for (const Instruction &I : BB)
  296   for (const GlobalVariable &G : M->globals())
  298   for (const Function &F : *M)
  300   for (const GlobalAlias &A : M->aliases())
  302   for (const GlobalIFunc &I : M->ifuncs())
  304   for (const GlobalVariable &G : M->globals())
  307   for (const GlobalAlias &A : M->aliases())
  309   for (const GlobalIFunc &I : M->ifuncs())
  311   for (const Function &F : *M)
  933   for (const GlobalVariable &Var : TheModule->globals()) {
  942   for (const GlobalAlias &A : TheModule->aliases()) {
  947   for (const GlobalIFunc &I : TheModule->ifuncs()) {
  953   for (const NamedMDNode &NMD : TheModule->named_metadata()) {
  958   for (const Function &F : *TheModule) {
  994   for (auto &BB : *TheFunction) {
  998     for (auto &I : BB) {
 1060   for (auto &BB : F) {
 1061     for (auto &I : BB)
 2629   for (const GlobalVariable &GV : M->globals()) {
 2635   for (const GlobalAlias &GA : M->aliases())
 2640   for (const GlobalIFunc &GI : M->ifuncs())
 2647   for (const Function &F : *M)
 2660   for (const NamedMDNode &Node : M->named_metadata())
 3532     for (const BasicBlock &BB : *F)
 3607   for (const Instruction &I : *BB) {
lib/IR/AutoUpgrade.cpp
 4061   for (auto &GV : M.globals()) {
lib/IR/BasicBlock.cpp
  197   for (const Instruction &I : *this)
  204   for (const Instruction &I : *this)
  211   for (const Instruction &I : *this) {
  234   for (Instruction &I : *this)
  298   PHINode *P = empty() ? nullptr : dyn_cast<PHINode>(&*begin());
lib/IR/Core.cpp
 1135   return wrap(&*I);
 1143   return wrap(&*--I);
 1151   return wrap(&*I);
 1159   return wrap(&*--I);
 2091   return wrap(&*I);
 2099   return wrap(&*--I);
 2107   return wrap(&*I);
 2115   return wrap(&*--I);
 2217   return wrap(&*I);
 2225   return wrap(&*--I);
 2233   return wrap(&*I);
 2241   return wrap(&*--I);
 2269   return wrap(&*I);
 2277   return wrap(&*--I);
 2285   return wrap(&*I);
 2293   return wrap(&*--I);
 2517   return wrap(&*I);
 2525   return wrap(&*--I);
 2533   return wrap(&*I);
 2541   return wrap(&*--I);
 2592   for (BasicBlock &BB : *Fn)
 2605   return wrap(&*I);
 2613   return wrap(&*--I);
 2621   return wrap(&*I);
 2629   return wrap(&*--I);
 2700   return wrap(&*I);
 2708   return wrap(&*--I);
 2716   return wrap(&*I);
 2724   return wrap(&*--I);
lib/IR/DebugInfo.cpp
   65   for (auto &F : M.functions()) {
   70     for (const BasicBlock &BB : F)
   71       for (const Instruction &I : BB)
  321   for (BasicBlock &BB : F) {
  323       Instruction &I = *II++; // We may delete the instruction, increment now.
  355     NamedMDNode *NMD = &*NMI;
  367   for (Function &F : M)
  370   for (auto &GV : M.globals()) {
  607     NamedMDNode *NMD = &*NMI;
  615   for (auto &GV : M.globals())
  631   for (auto &F : M) {
  638     for (auto &BB : F) {
  639       for (auto &I : BB) {
  666   for (auto &NMD : M.getNamedMDList()) {
lib/IR/Dominators.cpp
  144   for (; &*I != Def && &*I != User; ++I)
  144   for (; &*I != Def && &*I != User; ++I)
  147   return &*I == Def;
  293   for (; &*I != Def && &*I != UserInst; ++I)
  293   for (; &*I != Def && &*I != UserInst; ++I)
  296   return &*I != UserInst;
lib/IR/Function.cpp
  211   for (const BasicBlock &BB : BasicBlocks)
  362   for (BasicBlock &BB : *this)
lib/IR/IRPrintingPasses.cpp
   36     for(const auto &F : M.functions()) {
lib/IR/LegacyPassManager.cpp
  150   for (Function &F : M) {
  220     F = &*It;
  223   BasicBlock &BB = *F->begin();
 1389   for (BasicBlock &BB : F) {
 1683   for (Function &F : M)
lib/IR/Module.cpp
  440   for (Function &F : *this)
  443   for (GlobalVariable &GV : globals())
  446   for (GlobalAlias &GA : aliases())
  449   for (GlobalIFunc &GIF : ifuncs())
  477   for (Function &F : FunctionList)
lib/IR/PassManager.cpp
   55   for (Function &F : M) {
lib/IR/SafepointIRVerifier.cpp
  129     for (const BasicBlock &BB : F)
  540   for (const BasicBlock &BB : F)
  543       for (const auto &I : BB)
  590     for (const Instruction &I : *BB) {
  654   for (const Instruction &I : *BB) {
lib/IR/SymbolTableListTraitsImpl.h
   57         NewST->reinsertValue(&*I);
   95       ValueSubClass &V = *first;
lib/IR/TypeFinder.cpp
   35   for (const auto &G : M.globals()) {
   42   for (const auto &A : M.aliases()) {
   50   for (const Function &FI : M) {
   60     for (const BasicBlock &BB : FI)
   61       for (const Instruction &I : BB) {
   79   for (const auto &NMD : M.named_metadata())
lib/IR/Verifier.cpp
  336     for (const BasicBlock &BB : F) {
  367     for (const Function &F : M)
  374     for (const GlobalVariable &GV : M.globals())
  377     for (const GlobalAlias &GA : M.aliases())
  380     for (const NamedMDNode &NMD : M.named_metadata())
 2361   for (auto &BB : F)
 2362     for (auto &I : BB) {
 2427   for (auto &I : BB)
 5126   for (const Function &F : M)
 5170     for (Function &F : M)
lib/LTO/LTO.cpp
  681   for (GlobalVariable &GV : M.globals())
  686   for (auto &GA : M.aliases())
lib/LTO/LTOCodeGenerator.cpp
  402   for (auto &GV : TheModule)
  404   for (auto &GV : TheModule.globals())
  406   for (auto &GV : TheModule.aliases())
  452     for (auto &GV : *MergedModule)
  454     for (auto &GV : MergedModule->globals())
  456     for (auto &GV : MergedModule->aliases())
lib/LTO/UpdateCompilerUsed.cpp
   35     for (Function &F : TheModule)
   37     for (GlobalVariable &GV : TheModule.globals())
   39     for (GlobalAlias &GA : TheModule.aliases())
   73     for (const Function &F : TheModule) {
lib/Linker/IRMover.cpp
  744   for (GlobalValue &SGV : SrcM->globals()) {
  760   for (GlobalValue &SGV : *SrcM)
  774   for (GlobalValue &SGV : SrcM->aliases())
 1180   for (const NamedMDNode &NMD : SrcM->named_metadata()) {
lib/Linker/LinkModules.cpp
  487     GlobalAlias &GV = *I++;
  492     GlobalVariable &GV = *I++;
  497     Function &GV = *I++;
  501   for (GlobalVariable &GV : SrcM->globals())
  506   for (Function &SF : *SrcM)
  511   for (GlobalAlias &GA : SrcM->aliases())
  518   for (GlobalVariable &GV : SrcM->globals())
  522   for (Function &SF : *SrcM)
  526   for (GlobalAlias &GA : SrcM->aliases())
lib/MC/MCAssembler.cpp
  675     for (const MCFragment &F : *Sec) {
  715   for (const MCFragment &F : *Sec)
  781     for (MCFragment &Frag : *Sec)
  807     for (MCFragment &Frag : Sec) {
 1100       FirstRelaxedFragment = &*I;
 1127     Layout.getFragmentOffset(&*Section.rbegin());
 1128     computeFragmentSize(Layout, *Section.rbegin());
lib/MC/MCFragment.cpp
   72     const_cast<MCAsmLayout *>(this)->layoutFragment(&*I);
lib/MC/MCMachOStreamer.cpp
  496     for (MCFragment &Frag : Sec) {
lib/MC/MCObjectStreamer.cpp
  141     return &*std::prev(CurInsertionPoint);
lib/MC/WasmObjectWriter.cpp
  592   for (const MCFragment &Frag : DataSection) {
 1514     const MCFragment &EmptyFrag = *IT;
 1519     const MCFragment &AlignFrag = *IT;
 1525     const MCFragment &Frag = *std::next(IT);
lib/ProfileData/InstrProf.cpp
  337   for (Function &F : M) {
lib/ProfileData/SampleProfReader.cpp
  508   for (auto &F : M)
  888   for (auto &F : M)
lib/Target/AArch64/AArch64A53Fix835769.cpp
  122   for (auto &MBB : F) {
  142   MachineBasicBlock *PrevBB = &*std::prev(MBBI);
lib/Target/AArch64/AArch64A57FPLoadBalancing.cpp
  323   for (auto &MBB : F) {
lib/Target/AArch64/AArch64AdvSIMDScalarPass.cpp
  403     if (processMachineBasicBlock(&*I))
lib/Target/AArch64/AArch64BranchTargets.cpp
   78   for (MachineBasicBlock &MBB : MF) {
   86     if (&MBB == &*MF.begin() && (F.hasAddressTaken() || !F.hasLocalLinkage()))
lib/Target/AArch64/AArch64CollectLOH.cpp
  511   for (const MachineBasicBlock &MBB : MF) {
lib/Target/AArch64/AArch64CompressJumpTables.cpp
   78   for (MachineBasicBlock &MBB : *MF) {
  149   for (MachineBasicBlock &MBB : *MF) {
lib/Target/AArch64/AArch64CondBrTuning.cpp
  304   for (MachineBasicBlock &MBB : MF) {
lib/Target/AArch64/AArch64DeadRegisterDefinitionsPass.cpp
  196   for (auto &MBB : MF)
lib/Target/AArch64/AArch64ExpandPseudoInsts.cpp
  729   for (auto &MBB : MF)
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp
  154     for (Instruction &I : *BB) {
lib/Target/AArch64/AArch64FrameLowering.cpp
  188   for (MachineBasicBlock &MBB : MF) {
lib/Target/AArch64/AArch64InstrInfo.cpp
 1421     const MachineInstr &Instr = *I;
 5537     MachineInstr *Call = &*--MBB.instr_end();
lib/Target/AArch64/AArch64LoadStoreOptimizer.cpp
  963       for (MachineInstr &MI : make_range(StoreI->getIterator(),
 1037   for (MachineInstr &MI : make_range(StoreI->getIterator(),
 1831   for (auto &MBB : Fn)
lib/Target/AArch64/AArch64PBQPRegAlloc.cpp
  333   for (const auto &MBB: MF) {
lib/Target/AArch64/AArch64PromoteConstant.cpp
  126     for (auto &MF : M) {
lib/Target/AArch64/AArch64RedundantCopyElimination.cpp
  485   for (MachineBasicBlock &MBB : MF)
lib/Target/AArch64/AArch64SIMDInstrOpt.cpp
  710       for (MachineBasicBlock &MBB : MF) {
lib/Target/AArch64/AArch64SpeculationHardening.cpp
  413   for (MachineBasicBlock &MBB : MF) {
  671     for (auto &MBB : MF)
  689   for (auto &MBB : MF) {
lib/Target/AArch64/AArch64StackTagging.cpp
  342     if (!isa<DbgInfoIntrinsic>(*BI))
  345     if (isNoModRef(AA->getModRefInfo(&*BI, AllocaLoc)))
  504   for (const Instruction &I : *ABB) {
  528   for (auto &BB : *F) {
  530       Instruction *I = &*IT;
  668       tagAlloca(AI, &*IRB.GetInsertPoint(), Ptr, Size);
lib/Target/AArch64/AArch64StackTaggingPreRA.cpp
  190   for (auto &BB : *MF) {
lib/Target/AArch64/AArch64StorePairSuppress.cpp
  144   for (auto &MBB : MF) {
lib/Target/AArch64/AArch64TargetTransformInfo.cpp
  729       for (auto &I : *BB) {
lib/Target/AMDGPU/AMDGPUAlwaysInlinePass.cpp
   93   for (GlobalAlias &A : M.aliases()) {
  119   for (GlobalVariable &GV : M.globals()) {
  132     for (Function &F : M) {
lib/Target/AMDGPU/AMDGPUAnnotateKernelFeatures.cpp
  275   for (BasicBlock &BB : F) {
  276     for (Instruction &I : BB) {
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
  576   for (const MachineBasicBlock &MBB : MF) {
  696   for (const MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
 1039   for (BasicBlock &BB : F) {
 1043       MadeChange |= visit(*I);
lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp
  486     SDNode *N = &*--Position;
 2716       SDNode *Node = &*Position++;
lib/Target/AMDGPU/AMDGPUInline.cpp
  168     if (isa<ReturnInst>(*std::next(I->getIterator()))) {
lib/Target/AMDGPU/AMDGPULibCalls.cpp
 1365     B.SetInsertPoint(&*ItOld);
 1419   B.SetInsertPoint(&*ItNew);
 1755   for (auto &BB : F) {
 1780   for (auto &BB : F) {
lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp
  134   for (Function &F : M) {
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp
   72   BasicBlock &EntryBlock = *F.begin();
   73   IRBuilder<> Builder(&*EntryBlock.begin());
lib/Target/AMDGPU/AMDGPUMCInstLower.cpp
  275       EmitInstruction(&*I);
  399       EmitInstruction(&*I);
lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp
  625   for (auto &MFI : MF) {
  720             if ((&(*MII)) == DefInstr) {
 1421     MachineInstr &Instr = *I;
 1709   for (auto &MFI : MF) {
 1733     return &(*(--(Region->getEntry()->getParent()->end())));
 1877   if (&(*(IfBB->getParent()->begin())) == IfBB) {
 2278   return ((&(*(MBB->getParent()->begin()))) == MBB);
 2557   MachineInstr &Branch = *(Exit->instr_rbegin());
 2673       if ((&(*(InnerEntry->getParent()->begin()))) == InnerEntry) {
 2804   for (auto &MBBI : MF) {
 2858   for (auto &MBBI : MF) {
 2862       MachineInstr &Instr = *I;
lib/Target/AMDGPU/AMDGPUOpenCLEnqueuedBlockLowering.cpp
  109   for (auto &F : M.functions()) {
lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp
  211   for (auto &B : F) {
  213     for (auto &I : B) {
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp
  164   BasicBlock &EntryBB = *F.begin();
  167   for (Instruction &I : EntryBB) {
  650   for (GlobalVariable &GV : Mod->globals()) {
lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp
  169   for (auto &F : M.functions())
  194     for (auto &F : M.functions()) {
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp
  265   for (BasicBlock &BB : F) {
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp
  112     for (const Instruction &I : *BB) {
lib/Target/AMDGPU/GCNDPPCombine.cpp
  565   for (auto &MBB : MF) {
lib/Target/AMDGPU/GCNHazardRecognizer.cpp
  210     CurrCycleInstr = &*MI;
  372     if (IsHazard(&*I))
  378     WaitStates += SIInstrInfo::getNumWaitStates(*I);
  380     if (IsExpired(&*I, WaitStates))
lib/Target/AMDGPU/GCNILPSched.cpp
  252   return &*Best;
  259     auto &C = *I++;
  330                     : AvailQueue) dbgs()
lib/Target/AMDGPU/GCNMinRegStrategy.cpp
  117   using T = decltype(C(*RQ.begin())) ;
  122     T Cur = C(*I);
  129       auto &Cand = *I++;
  211   for (auto &C : RQ) {
  252                     : RQ) dbgs()
lib/Target/AMDGPU/GCNNSAReassign.cpp
  241   for (const MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/GCNRegBankReassign.cpp
  686   for (MachineBasicBlock &MBB : MF) {
  693     for (MachineInstr &MI : MBB.instrs()) {
lib/Target/AMDGPU/R600AsmPrinter.cpp
   51   for (const MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/R600ClauseMergePass.cpp
  191     MachineBasicBlock &MBB = *BB;
lib/Target/AMDGPU/R600ControlFlowFinalizer.cpp
  432           getLiteral(*BI, Literals);
  433           ClauseContent.push_back(&*BI);
  518       MachineBasicBlock &MBB = *MB;
lib/Target/AMDGPU/R600EmitClauseMarkers.cpp
  322       MachineBasicBlock &MBB = *BB;
lib/Target/AMDGPU/R600ExpandSpecialInstrs.cpp
   90     MachineBasicBlock &MBB = *BB;
lib/Target/AMDGPU/R600OptimizeVectorRegisters.cpp
  343     MachineBasicBlock *MB = &*MBB;
lib/Target/AMDGPU/R600Packetizer.cpp
   80       int BISlot = getSlot(*BI);
   84       if (TII->isPredicated(*BI))
   94       if (isTrans || TII->isTransOnly(*BI)) {
  379         if (TII->isSchedulingBoundary(*std::prev(I), &*MBB, Fn))
  396       Packetizer.PacketizeMIs(&*MBB, &*I, RegionEnd);
lib/Target/AMDGPU/SIAddIMGInit.cpp
   71     MachineBasicBlock &MBB = *BI;
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp
  314   Instruction *FirstInsertionPt = &*BB->getFirstInsertionPt();
lib/Target/AMDGPU/SIFixSGPRCopies.cpp
  573             TII->isSchedulingBoundary(*R, MBB, *MBB->getParent()))
  577       if (&*--R != MI)
  578         MBB->splice(*R, MBB, MI);
  599     MachineBasicBlock &MBB = *BI;
lib/Target/AMDGPU/SIFixVGPRCopies.cpp
   54   for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIFixupVectorISel.cpp
  229   for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIFormMemoryClauses.cpp
  325   for (MachineBasicBlock &MBB : MF) {
  328       MachineInstr &MI = *I;
  345         if (!isValidClauseInst(*Next, IsVMEM))
  351         if (!processRegUses(*Next, Defs, Uses, RPT))
  367         Ind->removeSingleMachineInstrFromMaps(*BI);
lib/Target/AMDGPU/SIFrameLowering.cpp
  461   for (MachineBasicBlock &OtherBB : MF) {
lib/Target/AMDGPU/SIISelLowering.cpp
10717     for (auto &MBB : MF) {
lib/Target/AMDGPU/SIInsertSkips.cpp
  115     const MachineBasicBlock &MBB = *MBBI;
  448     MachineBasicBlock &MBB = *BI;
  493           if (NextBB != BE && skipIfDead(MI, *NextBB)) {
  520           BuildMI(*BI, I, MI.getDebugLoc(), TII->get(AMDGPU::S_BRANCH))
lib/Target/AMDGPU/SIInsertWaitcnts.cpp
 1067            &*II != &MI; II = NextI, ++NextI) {
 1071         if (TrackedWaitcntSet.count(&*II)) {
 1072           TrackedWaitcntSet.erase(&*II);
 1108          &*II != &MI; II = NextI, NextI++) {
 1116         if (!TrackedWaitcntSet.count(&*II))
 1132         if (!TrackedWaitcntSet.count(&*II))
 1143                         << "New Instr: " << *II << '\n');
 1377     MachineInstr &Inst = *Iter;
 1545     MachineBasicBlock &MBB = *BI;
lib/Target/AMDGPU/SIInstrInfo.cpp
 2663         return BuildMI(*MBB, MI, MI.getDebugLoc(), get(NewOpc))
 2674         return BuildMI(*MBB, MI, MI.getDebugLoc(), get(NewOpc))
 2684         return BuildMI(*MBB, MI, MI.getDebugLoc(), get(NewOpc))
 2697   return BuildMI(*MBB, MI, MI.getDebugLoc(), get(NewOpc))
 5974     Size += getInstSizeInBytes(*I);
lib/Target/AMDGPU/SILoadStoreOptimizer.cpp
 1688   for (MachineInstr &MI : MBB.instrs()) {
 1850   for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SILowerControlFlow.cpp
  528     MachineBasicBlock &MBB = *BI;
lib/Target/AMDGPU/SILowerI1Copies.cpp
  504   for (MachineBasicBlock &MBB : *MF) {
  552   for (MachineBasicBlock &MBB : *MF) {
  672   for (MachineBasicBlock &MBB : *MF) {
lib/Target/AMDGPU/SILowerSGPRSpills.cpp
  176   for (MachineBasicBlock &MBB : MF) {
  269     for (MachineBasicBlock &MBB : MF) {
  303     for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIMachineFunctionInfo.cpp
  309       for (MachineBasicBlock &BB : MF)
lib/Target/AMDGPU/SIMemoryLegalizer.cpp
 1290   for (auto &MBB : MF) {
lib/Target/AMDGPU/SIModeRegister.cpp
  384   for (MachineBasicBlock &BB : MF)
  390   for (MachineBasicBlock &BB : MF)
  399   for (MachineBasicBlock &BB : MF)
lib/Target/AMDGPU/SIOptimizeExecMasking.cpp
  287   for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIOptimizeExecMaskingPreRA.cpp
  308   for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIPeepholeSDWA.cpp
 1216   for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIPreAllocateWWMRegs.cpp
  121   for (MachineBasicBlock &MBB : MF) {
lib/Target/AMDGPU/SIShrinkInstructions.cpp
  494       if (instReadsReg(&*I, X, Xsub, TRI) ||
  495           instModifiesReg(&*I, Y, Ysub, TRI) ||
  496           instModifiesReg(&*I, T, Tsub, TRI) ||
  497           (MovX && instModifiesReg(&*I, X, Xsub, TRI))) {
  501       if (!instReadsReg(&*I, Y, Ysub, TRI)) {
  502         if (!MovX && instModifiesReg(&*I, X, Xsub, TRI)) {
  516       MovX = &*I;
  537     MachineInstr *Next = &*std::next(MovT.getIterator());
  563     MachineBasicBlock &MBB = *BI;
lib/Target/AMDGPU/SIWholeQuadMode.cpp
  931     processBlock(*BII.first, LiveMaskReg, BII.first == &*MF.begin());
lib/Target/ARC/ARCBranchFinalize.cpp
  153   for (auto &MBB : MF) {
lib/Target/ARC/ARCExpandPseudos.cpp
   80   for (auto &MBB : MF) {
lib/Target/ARC/ARCOptAddrMode.cpp
  496   for (auto &MBB : MF)
lib/Target/ARM/A15SDOptimizer.cpp
  675   for (MachineBasicBlock &MBB : Fn) {
lib/Target/ARM/ARMBaseInstrInfo.cpp
  763     Size += getInstSizeInBytes(*I);
 4040   return &*II;
 4069   return &*II;
 4640         Latency += getInstrLatency(ItinData, *I, PredCost);
lib/Target/ARM/ARMBasicBlockInfo.h
  126     for (MachineBasicBlock &MBB : MF)
lib/Target/ARM/ARMCodeGenPrepare.cpp
  533       InsertZExt(Arg, &*BB.getFirstInsertionPt());
 1022   for (BasicBlock &BB : F) {
 1024     for (auto &I : Insts) {
lib/Target/ARM/ARMConstantIslandPass.cpp
  562   for (MachineBasicBlock &MBB : *MF) {
  624   MachineBasicBlock *NextBB = &*std::next(MBBI);
  678   for (MachineBasicBlock &MBB : *MF) {
  702   for (MachineBasicBlock &MBB : *MF) {
 1289       NewMBB = &*++UserMBB->getIterator();
 1482     NewMBB = &*++WaterBB->getIterator();
 1493     MachineBasicBlock *WaterBB = &*--NewMBB->getIterator();
 1539   BBUtils->adjustBBOffsetsAfter(&*--NewIsland->getIterator());
 1709   MachineBasicBlock *NextBB = &*++MBB->getIterator();
 2413       !TII->analyzeBranch(*OldPrior, TBB, FBB, CondPrior)) {
lib/Target/ARM/ARMExpandPseudoInsts.cpp
 1980   for (MachineBasicBlock &MBB : MF)
lib/Target/ARM/ARMFrameLowering.cpp
 1490   for (auto &MBB : MF) {
 1513   for (auto &MBB : MF) {
lib/Target/ARM/ARMISelDAGToDAG.cpp
  353     SDNode *N = &*I++; // Preincrement iterator to avoid invalidation issues.
lib/Target/ARM/ARMISelLowering.cpp
 9497         CallSiteNumToLPad[*CSI].push_back(&*BB);
lib/Target/ARM/ARMLoadStoreOptimizer.cpp
 2014     MachineBasicBlock &MBB = *MFI;
 2096   for (MachineBasicBlock &MFI : Fn)
lib/Target/ARM/ARMLowOverheadLoops.cpp
  518   for (auto &MBB : *MF) {
lib/Target/ARM/ARMOptimizeBarriersPass.cpp
   62   for (auto &MBB : MF) {
lib/Target/ARM/ARMParallelDSP.cpp
  359   for (auto &I : *BB) {
  516   for (auto &BB : F) {
  521     for (Instruction &I : reverse(BB)) {
  663     return &*++BasicBlock::iterator(cast<Instruction>(V));
  681       Builder.SetInsertPoint(&*++BasicBlock::iterator(Mul));
lib/Target/ARM/ARMTargetTransformInfo.cpp
  974       for (auto &I : *BB) {
 1039     for (auto &I : *BB) {
lib/Target/ARM/MLxExpansionPass.cpp
  384   for (MachineBasicBlock &MBB : Fn)
lib/Target/ARM/MVETailPredication.cpp
  135     for (auto &I : *BB) {
  163     for (auto &I : *BB) {
  294     for (auto &I : *BB) {
  407       for (auto &I : *Exit) {
lib/Target/ARM/MVEVPTBlockPass.cpp
  174     MachineInstr *MI = &*MBIter;
  201       NextPred = getVPTInstrPredicate(*MBIter, PredReg);
  269   for (MachineBasicBlock &MBB : Fn)
lib/Target/ARM/Thumb2ITBlockPass.cpp
  299   for (auto &MBB : Fn )
lib/Target/ARM/Thumb2SizeReduction.cpp
 1060     MachineInstr *MI = &*MII;
 1076       MI = &*I;
lib/Target/AVR/AVRExpandPseudoInsts.cpp
  120   for (Block &MBB : MF) {
lib/Target/AVR/AVRFrameLowering.cpp
  460     for (const MachineBasicBlock &BB : MF) {
  521     for (MachineBasicBlock &MBB : MF) {
lib/Target/AVR/AVRISelLowering.cpp
 1496   for (I = BB->getIterator(); I != F->end() && &(*I) != BB; ++I);
 1650   for (I = MF->begin(); I != MF->end() && &(*I) != MBB; ++I);
lib/Target/AVR/AVRRelaxMemOperations.cpp
   66   for (Block &MBB : MF) {
lib/Target/BPF/BPFAbstractMemberAccess.cpp
  308   for (Function &F : M)
  309     for (auto &BB : F)
  310       for (auto &I : BB) {
  493   for (auto &BB : F)
  494     for (auto &I : BB) {
  913   for (Function &F : M) {
lib/Target/BPF/BPFISelDAGToDAG.cpp
  330     SDNode *Node = &*I++;
lib/Target/BPF/BPFMIChecking.cpp
  157   for (MachineBasicBlock &MBB : *MF) {
lib/Target/BPF/BPFMIPeephole.cpp
  123   for (MachineBasicBlock &MBB : *MF) {
  240   for (MachineBasicBlock &MBB : *MF) {
  361   for (MachineBasicBlock &MBB : *MF) {
lib/Target/BPF/BPFMISimplifyPatchable.cpp
   80   for (MachineBasicBlock &MBB : *MF) {
lib/Target/BPF/BTFDebug.cpp
 1057   for (const GlobalVariable &Global : M->globals()) {
lib/Target/Hexagon/BitTracker.cpp
  969         Targets.insert(&*Next);
 1089       if (Next != MF.end() && B.isSuccessor(&*Next)) {
 1126   for (const MachineBasicBlock &B : MF) {
lib/Target/Hexagon/HexagonAsmPrinter.cpp
  755         HexagonLowerToMC(MCII, &*MII, MCB, *this);
lib/Target/Hexagon/HexagonBitSimplify.cpp
 2809     for (auto &B : MF)
 3325   for (auto &B : MF) {
lib/Target/Hexagon/HexagonBranchRelaxation.cpp
  107   for (auto &B : MF) {
  115     for (auto &MI : B.instrs()) {
  169     if (HII->isNewValueJump(*FirstTerm))
  170       TBB = FirstTerm->getOperand(HII->getCExtOpNum(*FirstTerm)).getMBB();
  172   if (TBB && &MI == &*FirstTerm) {
  175     return !HII->isJumpWithinBranchRange(*FirstTerm, Distance);
  183     if (&MI != &*SecondTerm)
  188     return !HII->isJumpWithinBranchRange(*SecondTerm, Distance);
  197   for (auto &B : MF) {
lib/Target/Hexagon/HexagonCFGOptimizer.cpp
  122     MachineBasicBlock *MBB = &*MBBb;
lib/Target/Hexagon/HexagonCommonGEP.cpp
  751     return B->empty() || (&*B->begin() == B->getTerminator());
 1128     NewInst = GetElementPtrInst::Create(ElTy, Input, A, "cgep", &*At);
 1262       Ins.push_back(&*I);
lib/Target/Hexagon/HexagonConstExtenders.cpp
 1246   for (MachineBasicBlock &MBB : MF) {
lib/Target/Hexagon/HexagonConstPropagation.cpp
  760         Targets.insert(&*Next);
  835       Targets.insert(&*NextI);
  937     for (const MachineBasicBlock &B : MF) {
 1033   for (MachineBasicBlock &B : MF) {
lib/Target/Hexagon/HexagonCopyToCombine.cpp
  484     findPotentialNewifiableTFRs(*BI);
lib/Target/Hexagon/HexagonEarlyIfConv.cpp
  257   MachineBasicBlock *NextB = (NextBI != MFN->end()) ? &*NextBI : nullptr;
lib/Target/Hexagon/HexagonExpandCondsets.cpp
 1267   for (auto &B : MF)
 1312   for (auto &B : MF)
lib/Target/Hexagon/HexagonFixupHwLoops.cpp
  116   for (const MachineBasicBlock &MBB : MF) {
  132   for (MachineBasicBlock &MBB : MF) {
lib/Target/Hexagon/HexagonFrameLowering.cpp
  423   for (auto &I : MF) {
  440   for (auto &I : MF)
  523     for (auto &B : MF)
  527     for (auto &B : MF)
  531     for (auto &B : MF) {
  612   for (auto &MBB : MF)
  872   for (auto &B : MF) {
 1888   for (auto &B : MF) {
 2053   for (auto &B : MF) {
 2195     for (auto &B : MF) {
 2228   for (auto &B : MF) {
 2400   for (auto &B : MF)
 2501   for (const MachineBasicBlock &B : MF) {
lib/Target/Hexagon/HexagonGenExtract.cpp
  238     Instruction *In = &*I;
lib/Target/Hexagon/HexagonGenInsert.cpp
  598     const MachineBasicBlock &B = *A;
lib/Target/Hexagon/HexagonGenMux.cpp
  383   for (auto &I : MF)
lib/Target/Hexagon/HexagonGenPredicate.cpp
  207     MachineBasicBlock &B = *A;
  468   for (MachineBasicBlock &MBB : MF) {
lib/Target/Hexagon/HexagonHardwareLoops.cpp
  429     MachineInstr *Phi = &*I;
 1332     if (&*I == CmpI)
 1340     MachineInstr *In = &*I;
 1630     MachineInstr *Phi = &*I;
 1900       MachineInstr *PN = &*I;
 1948       MachineInstr *PN = &*I;
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
 1212     for (SDNode &N : CurDAG->allnodes())
 2234     SDNode *N = &*I++;
lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp
 1383   for (SDNode &S : DAG.allnodes())
lib/Target/Hexagon/HexagonInstrInfo.cpp
  169         return &*I;
  344       if (TargetInstrInfo::hasLoadFromStackSlot(*MII, Accesses))
  362       if (TargetInstrInfo::hasStoreToStackSlot(*MII, Accesses))
  439   if (!isUnpredicatedTerminator(*I))
  443   MachineInstr *LastInst = &*I;
  447     if (&*I != LastInst && !I->isBundle() && isUnpredicatedTerminator(*I)) {
  447     if (&*I != LastInst && !I->isBundle() && isUnpredicatedTerminator(*I)) {
  449         SecondLastInst = &*I;
 3085     return producesStall(*MII, MI);
 3088     const MachineInstr &J = *MII;
 3260   if (!isUnpredicatedTerminator(*I))
 3264   MachineInstr *LastInst = &*I;
 3269     if (&*I != LastInst && !I->isBundle() && isUnpredicatedTerminator(*I)) {
 3269     if (&*I != LastInst && !I->isBundle() && isUnpredicatedTerminator(*I)) {
 3271         SecondLastInst = &*I;
 4389   MachineBasicBlock &B = *A;
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp
 1075   for (Instruction &In : *LoopB)
 1305   for (Instruction &I : *LoopB) {
 1394     if (isa<PHINode>(I) || !Users.count(&*I))
 1399     if (match(&*I, m_LShr(m_Value(V), m_One()))) {
 1400       replaceAllUsesOfWithIn(&*I, V, LoopB);
 1407       if (!isOperandShifted(&*I, Op))
 1418         IRB.SetInsertPoint(&*I);
 1425         if (Late.count(&*I))
 1469   for (auto &I : *LoopB)
 1475     RecursivelyDeleteTriviallyDeadInstructions(&*I, &TLI);
 1524   IRBuilder<> B(&*At);
 1812   for (Instruction &In : *LoopB) {
 1847     for (Instruction &In : *LoopB) {
 1869   for (Instruction &In : *LoopB) {
 1900     PM = IRBuilder<>(&*At).CreateIntCast(PM, PV.Res->getType(), false);
 1989     for (auto &I : *B)
 2001   for (Instruction &I : *BB)
 2181     for (auto &In : *Header) {
 2333     for (auto &In : *B) {
lib/Target/Hexagon/HexagonNewValueJump.cpp
  474     MachineBasicBlock *MBB = &*MBBb;
lib/Target/Hexagon/HexagonOptimizeSZextends.cpp
  102   for (auto &B : F) {
  103     for (auto &I : B) {
lib/Target/Hexagon/HexagonPeephole.cpp
  125     MachineBasicBlock *MBB = &*MBBb;
lib/Target/Hexagon/HexagonSplitConst32AndConst64.cpp
   72   for (MachineBasicBlock &B : Fn) {
lib/Target/Hexagon/HexagonStoreWidening.cpp
  599   for (auto &B : MFn)
lib/Target/Hexagon/HexagonVExtract.cpp
  109   for (MachineBasicBlock &MBB : MF) {
lib/Target/Hexagon/HexagonVLIWPacketizer.cpp
  231   for (MachineBasicBlock &MB : MF) {
  245   for (auto &MB : MF) {
 1149   for (auto &B : MF) {
 1154       MachineInstr &MI = *I;
 1788     for (auto &I : make_range(HII->expandVGatherPseudo(*MI), NextMI))
lib/Target/Hexagon/HexagonVectorPrint.cpp
  136   for (auto &MBB : Fn)
  144           if (getInstrVecReg(*MII, Reg)) {
  145             VecPrintList.push_back((&*MII));
lib/Target/Hexagon/MCTargetDesc/HexagonAsmBackend.cpp
  710       for (auto &J : Fragments) {
  729               auto &RF = cast<MCRelaxableFragment>(*K);
lib/Target/Hexagon/RDFGraph.cpp
  873   for (MachineBasicBlock &B : MF) {
lib/Target/Hexagon/RDFLiveness.cpp
  699   for (MachineBasicBlock &B : MF) {
  810     for (MachineBasicBlock &B : MF) {
  836   for (auto &B : DFG.getMF()) {
  853   for (auto &B : DFG.getMF())
lib/Target/Hexagon/RDFRegisters.cpp
   77   for (const MachineBasicBlock &B : mf)
lib/Target/Lanai/LanaiAsmPrinter.cpp
  203       emitCallInstruction(&*I);
  207     customEmitInstruction(&*I);
lib/Target/Lanai/LanaiDelaySlotFiller.cpp
   56       Changed |= runOnMachineBasicBlock(*FI);
lib/Target/Lanai/LanaiFrameLowering.cpp
   78         BuildMI(*MBB, MI, DL, LII.get(Lanai::ADD_I_LO), Dst)
lib/Target/Lanai/LanaiMemAluCombiner.cpp
  416     Modified |= combineMemAluInBasicBlock(&*MFI);
lib/Target/MSP430/MSP430BranchSelector.cpp
   96   for (auto &MBB : make_range(Begin, MF->end())) {
  149                           << printMBBReference(*MBB) << "\n");
  157         NewBB->splice(NewBB->end(), &*MBB, std::next(MI), MBB->end());
  170         measureFunction(BlockOffsets, &*MBB);
  184         MachineBasicBlock *NextMBB = &*std::next(MBB);
  196         MI = BuildMI(*MBB, MI, dl, TII->get(MSP430::JCC))
  204       MI = BuildMI(*MBB, MI, dl, TII->get(MSP430::Bi)).addMBB(DestBB);
lib/Target/Mips/MicroMipsSizeReduction.cpp
  417   MachineInstr *MI = &*MII;
  433     ReduceEntryFunArgs Arguments(&(*MII), *Entry, NextMII);
  465   MachineInstr *MI2 = &*NextMII;
  622   MachineInstr *MI2 = &*NextMII;
  680     MachineInstr *MI = &*MII;
  790     Modified |= ReduceMBB(*I);
lib/Target/Mips/Mips16HardFloat.cpp
  382   for (auto &BB: F)
  383     for (auto &I: BB) {
  519       removeUseSoftFloat(*F);
  524     Modified |= fixupFPReturnAndCall(*F, &M, TM);
  525     FPParamVariant V = whichFPParamVariantNeeded(*F);
  528       createFPFnStub(&*F, &M, V, TM);
lib/Target/Mips/MipsAsmPrinter.cpp
  257     if (emitPseudoExpansionLowering(*OutStreamer, &*I))
  266       emitPseudoIndirectBranch(*OutStreamer, &*I);
  282     MCInstLowering.Lower(&*I, TmpInst0);
 1286   for (auto &MBB : MF) {
lib/Target/Mips/MipsBranchExpansion.cpp
  286   for (auto &MBB : *MFp)
  299       MBBInfos[I].Size += TII->getInstSizeInBytes(*MI);
  717     replaceBranch(*MBB, I.Br, DL, &*FallThroughMBB);
  750         std::pair<Iter, bool> Res = getNextMachineInstr(std::next(I), &*FI);
lib/Target/Mips/MipsConstantIslandPass.cpp
  596   MachineBasicBlock *NextBB = &*std::next(MBBI);
  647     computeBlockSize(&*I);
  653   for (MachineBasicBlock &MBB : *MF) {
 1232       NewMBB = &*++UserMBB->getIterator();
 1339     NewMBB = &*++WaterBB->getIterator();
 1356     MachineBasicBlock *WaterBB = &*--NewMBB->getIterator();
 1398   adjustBBOffsetsAfter(&*--NewIsland->getIterator());
 1609   MachineBasicBlock *NextBB = &*++MBB->getIterator();
 1649           LLVM_DEBUG(dbgs() << "constant island constant " << *I << "\n");
 1661             LLVM_DEBUG(dbgs() << "constant island constant " << *I << "\n");
lib/Target/Mips/MipsDelaySlotFiller.cpp
  225         Changed |= runOnMachineBasicBlock(*FI);
  630         if (InMicroMipsMode && TII->getInstSizeInBytes(*std::next(DSI)) == 2 &&
lib/Target/Mips/MipsExpandPseudo.cpp
  689     Modified |= expandMBB(*MFI);
lib/Target/Mips/MipsOs16.cpp
   79       const Instruction &Inst = *I;
  121   for (auto &F : M) {
lib/Target/Mips/MipsSEFrameLowering.cpp
  107   for (auto &MBB : MF) {
lib/Target/Mips/MipsSEISelDAGToDAG.cpp
  159   for (auto &MBB: MF) {
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
  704     const Function *F = &*FI;
  828   for (const GlobalVariable &I : M.globals())
  911     gv_array[i++] = &*I;
lib/Target/NVPTX/NVPTXAssignValidGlobalNames.cpp
   53   for (GlobalVariable &GV : M.globals()) {
   65   for (Function &F : M.functions())
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp
   79     GlobalVariable *GV = &*I++;
  115                 i, remapConstant(&M, &*I, cast<Constant>(Operand), Builder));
lib/Target/NVPTX/NVPTXImageOptimizer.cpp
   61     for (BasicBlock::iterator I = (*BI).begin(), E = (*BI).end();
   61     for (BasicBlock::iterator I = (*BI).begin(), E = (*BI).end();
   63       Instruction &Instr = *I;
lib/Target/NVPTX/NVPTXLowerAlloca.cpp
   69   for (auto &BB : F)
   70     for (auto &I : BB) {
lib/Target/NVPTX/NVPTXLowerArgs.cpp
  197       Ptr->getName(), &*InsertPt);
  199                                               Ptr->getName(), &*InsertPt);
  211     for (auto &B : F) {
  212       for (auto &I : B) {
lib/Target/NVPTX/NVPTXPeephole.cpp
  132   for (auto &MBB : MF) {
lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp
   58   for (MachineBasicBlock &MBB : MF) {
   93       TFI.emitEpilogue(MF, *I);
lib/Target/NVPTX/NVPTXProxyRegErasure.cpp
   69   for (auto &BB : MF) {
  102   for (auto &BB : MF) {
lib/Target/NVPTX/NVPTXReplaceImageHandles.cpp
   61     for (MachineBasicBlock::iterator I = (*BI).begin(), E = (*BI).end();
   61     for (MachineBasicBlock::iterator I = (*BI).begin(), E = (*BI).end();
lib/Target/PowerPC/PPCAsmPrinter.cpp
 1612   for (const Function &F : M) {
lib/Target/PowerPC/PPCBoolRetToInt.cpp
  114       A ? &*A->getParent()->getEntryBlock().begin() : I->getNextNode();
  131     for (auto &BB : F)
  132       for (auto &I : BB)
  201     for (auto &BB : F) {
  202       for (auto &I : BB) {
lib/Target/PowerPC/PPCBranchCoalescing.cpp
  731   for (MachineBasicBlock &MBB : MF) {
lib/Target/PowerPC/PPCBranchSelector.cpp
  122     MachineBasicBlock *MBB = &*MFI;
  155     MachineBasicBlock *MBB = &*MFI;
  299       MachineBasicBlock &MBB = *MFI;
lib/Target/PowerPC/PPCCTRLoops.cpp
  204     MachineBasicBlock *MBB = &*I;
lib/Target/PowerPC/PPCEarlyReturn.cpp
  185         MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCExpandISEL.cpp
  158   for (MachineBasicBlock &MBB : *MF) {
lib/Target/PowerPC/PPCFrameLowering.cpp
  361     const MachineBasicBlock &MBB = *BI;
 1856     for (MachineBasicBlock &MBB : MF) {
lib/Target/PowerPC/PPCISelDAGToDAG.cpp
  398   MachineBasicBlock &EntryBB = *Fn.begin();
  422       BuildMI(*BB, IP, dl, TII.get(PPC::MTVRSAVE)).addReg(InVRSAVE);
 5529     SDNode *N = &*--Position;
 5640     for (SDNode &Node : CurDAG->allnodes()) {
 6221     SDNode *N = &*--Position;
 6377     SDNode *N = &*--Position;
lib/Target/PowerPC/PPCInstrInfo.cpp
 4034           const MachineInstr &CallMI = *(--II);
 4255   for (auto &I : PreHeader.instrs())
lib/Target/PowerPC/PPCLoopPreIncPrep.cpp
  245     for (auto &J : *BB) {
  387   Instruction *InsPoint = &*Header->getFirstInsertionPt();
  432         PtrIP = &*PtrIP->getParent()->getFirstInsertionPt();
lib/Target/PowerPC/PPCMIPeephole.cpp
  276       for (MachineBasicBlock &MBB : *MF) {
  296   for (MachineBasicBlock &MBB : *MF) {
  948         (*BII).getOpcode() == PPC::BCC &&
  949         (*BII).getOperand(1).isReg()) {
  951       Register CndReg = (*BII).getOperand(1).getReg();
 1012     MachineInstr *BI = &*MBB.getFirstInstrTerminator();
 1078   for (MachineBasicBlock &MBB2 : *MF) {
 1111     MachineInstr *BI1   = &*MBB1->getFirstInstrTerminator();
 1114     MachineInstr *BI2   = &*MBB2.getFirstInstrTerminator();
lib/Target/PowerPC/PPCPreEmitPeephole.cpp
   80         if (InstrsToErase.find(&*BBI) != InstrsToErase.end())
  102                             << " from load immediate " << *BBI
  117                        << *AfterBBI << " is a unsetting candidate\n");
  151                        << *AfterBBI << " is a unsetting candidate\n");
  152           InstrsToErase.insert(&*AfterBBI);
  172       for (MachineBasicBlock &MBB : MF) {
  222         MachineInstr *Br = &*I;
lib/Target/PowerPC/PPCQPXLoadSplat.cpp
   65     MachineBasicBlock *MBB = &*MFI;
lib/Target/PowerPC/PPCReduceCRLogicals.cpp
   57   for (auto &MI : Successor->instrs()) {
   90   for (auto &MI : Successor->instrs()) {
  711   for (MachineBasicBlock &MBB : *MF) {
lib/Target/PowerPC/PPCTLSDynamicCall.cpp
  159         MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCTOCRegDeps.cpp
  135         MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCVSXCopy.cpp
  152         MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCVSXFMAMutate.cpp
  364         MachineBasicBlock &B = *I++;
lib/Target/PowerPC/PPCVSXSwapRemoval.cpp
  244   for (MachineBasicBlock &MBB : *MF) {
lib/Target/RISCV/RISCVExpandPseudoInsts.cpp
   80   for (auto &MBB : MF)
lib/Target/RISCV/RISCVISelDAGToDAG.cpp
  208     SDNode *N = &*--Position;
lib/Target/RISCV/RISCVISelLowering.cpp
 1332     if (isSelectPseudo(*SelectMBBI)) {
lib/Target/RISCV/RISCVMergeBaseOffset.cpp
  264   for (MachineBasicBlock &MBB : Fn) {
lib/Target/Sparc/DelaySlotFiller.cpp
   58         Changed |= runOnMachineBasicBlock(*FI);
lib/Target/Sparc/LeonPasses.cpp
   47     MachineBasicBlock &MBB = *MFI;
   82     MachineBasicBlock &MBB = *MFI;
  134     MachineBasicBlock &MBB = *MFI;
lib/Target/Sparc/SparcAsmPrinter.cpp
  268     LowerSparcMachineInstrToMCInst(&*I, TmpInst, *this);
lib/Target/SystemZ/SystemZElimCompare.cpp
  631   for (auto &MBB : F)
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp
 1893     SDNode *N = &*I++;
lib/Target/SystemZ/SystemZPostRewrite.cpp
  267   for (auto &MBB : MF)
lib/Target/SystemZ/SystemZShortenInst.cpp
  375   for (auto &MBB : F)
lib/Target/SystemZ/SystemZTargetTransformInfo.cpp
  247     for (auto &I : *BB) {
lib/Target/WebAssembly/WebAssemblyAddMissingPrototypes.cpp
   67   for (Function &F : M) {
lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp
   98   for (const auto &F : M) {
  135   for (const auto &G : M.globals()) {
lib/Target/WebAssembly/WebAssemblyCFGSort.cpp
  248   for (MachineBasicBlock &MBB : MF) {
  366   for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp
  390   MachineBasicBlock *AfterLoop = &*Iter;
  471   MachineBasicBlock *Cont = &*Iter;
  548             AfterSet.insert(&*std::prev(MI.getIterator()));
  549             ThrowingCall = &*std::prev(MI.getIterator());
  655   for (auto &MBB : MF) {
  681   for (auto &MBB : MF) {
  696         ToDelete.push_back(&*std::prev(B));
  697         ToDelete.push_back(&*E);
  871   for (auto &MBB : reverse(MF)) {
  912   for (auto &MBB : reverse(MF)) {
 1069     MachineBasicBlock *EHPadLayoutPred = &*std::prev(EHPad->getIterator());
 1116         RangeBegin = &*std::prev(RangeBegin->getIterator());
 1119         RangeEnd = &*std::next(RangeEnd->getIterator());
 1173   for (auto &MBB : reverse(MF)) {
 1243   for (MachineBasicBlock &MBB : reverse(MF)) {
 1276   for (auto &MBB : MF)
 1280   for (auto &MBB : MF) {
 1300   for (auto &MBB : reverse(MF)) {
lib/Target/WebAssembly/WebAssemblyCallIndirectFixup.cpp
  110   for (MachineBasicBlock &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp
  227   for (MachineBasicBlock &MBB : MF) {
  384   for (const MachineBasicBlock &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp
  246   for (Function &F : M) {
lib/Target/WebAssembly/WebAssemblyFixIrreducibleControlFlow.cpp
  490   for (auto &MBB : MF) {
  494   if (LLVM_UNLIKELY(processRegion(&*MF.begin(), AllBlocks, MF))) {
lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp
  129   for (auto &MBB : MF) {
  147   for (auto &MBB : MF) {
  187   for (auto &MBB : MF) {
  241   for (auto &MBB : MF) {
  259   for (auto &MBB : MF) {
  371   for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyLowerBrUnless.cpp
   65   for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp
  604   for (BasicBlock &BB : F) {
  605     for (Instruction &I : BB) {
  666     for (Function &F : M) {
  749   for (BasicBlock &BB : F) {
  788   for (BasicBlock &BB : F) {
  790     for (Instruction &I : BB) {
  808   for (BasicBlock &BB : F) {
  809     for (Instruction &I : BB) {
  828   for (BasicBlock &BB : F) {
  892       &*EntryBB.getFirstInsertionPt());
  953   for (BasicBlock &BB : F)
  959     for (Instruction &I : *BB) {
 1053   for (BasicBlock &BB : F) {
lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp
  198   for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyPeephole.cpp
  147   for (auto &MBB : MF)
lib/Target/WebAssembly/WebAssemblyPrepareForLiveIntervals.cpp
   82   MachineBasicBlock &Entry = *MF.begin();
lib/Target/WebAssembly/WebAssemblyRegStackify.cpp
  541   MachineInstr *Clone = &*std::prev(Insert);
  567     DefDIs.move(&*Insert);
  570     DefDIs.clone(&*Insert, NewReg);
  785   for (MachineBasicBlock &MBB : MF) {
  904     for (MachineBasicBlock &MBB : MF)
  911   for (MachineBasicBlock &MBB : MF) {
lib/Target/WebAssembly/WebAssemblySetP2AlignOperands.cpp
   85   for (auto &MBB : MF) {
lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
  186     for (auto &F : M)
  216     for (auto &F : M)
  240     for (auto &F : M) {
  241       for (auto &B : F) {
  242         for (auto &I : B) {
  257     for (auto &F : M)
  265     for (auto &GV : M.globals()) {
lib/Target/X86/X86AvoidStoreForwardingBlocks.cpp
  537   for (auto &MBB : MF)
lib/Target/X86/X86AvoidTrailingCall.cpp
   69   for (MachineBasicBlock &MBB : MF) {
   79     for (MachineBasicBlock &RMBB :
lib/Target/X86/X86CallFrameOptimization.cpp
  168   for (MachineBasicBlock &BB : MF) {
  257   for (auto &MBB : MF)
lib/Target/X86/X86CmovConversion.cpp
  182     for (auto &MBB : MF)
  601       DBGInstructions.push_back(&*I);
lib/Target/X86/X86CondBrFolding.cpp
  393   for (auto &MBB : MF)
  396   for (auto &MBB : MF) {
lib/Target/X86/X86DiscriminateMemOps.cpp
  108   for (auto &MBB : MF) {
  127   for (auto &MBB : MF) {
lib/Target/X86/X86EvexToVex.cpp
  105   for (MachineBasicBlock &MBB : MF) {
lib/Target/X86/X86ExpandPseudo.cpp
  405   for (MachineBasicBlock &MBB : MF)
lib/Target/X86/X86FixupBWInsts.cpp
  164   for (auto &MBB : MF)
lib/Target/X86/X86FixupLEAs.cpp
  210   for (MachineBasicBlock &MBB : MF) {
lib/Target/X86/X86FixupSetCC.cpp
  102   for (auto &MBB : MF) {
lib/Target/X86/X86FlagsCopyLowering.cpp
  250   MachineInstr &PrevI = *std::prev(SplitI.getIterator());
  540         MachineInstr &MI = *MII++;
  585             JmpIs.push_back(&*JmpIt);
  588                    X86::getCondFromBranch(*JmpIt) !=
  700   for (MachineBasicBlock &MBB : MF)
lib/Target/X86/X86FloatingPoint.cpp
  378     for (MachineBasicBlock &BB : MF)
  397   for (MachineBasicBlock &MBB : MF) {
lib/Target/X86/X86FrameLowering.cpp
 2297   assert(&(*MF.begin()) == &PrologueMBB && "Shrink-wrapping not supported yet");
 2588   assert(&(*MF.begin()) == &PrologueMBB && "Shrink-wrapping not supported yet");
 2618     for (auto &MBB : MF) {
 3117   for (auto &MBB : MF) {
lib/Target/X86/X86ISelDAGToDAG.cpp
  792     SDNode *N = &*I++; // Preincrement iterator to avoid invalidation issues.
 1163     SDNode *N = &*--Position;
lib/Target/X86/X86ISelLowering.cpp
30946   for (auto &MBB : *MF) {
lib/Target/X86/X86IndirectBranchTracking.cpp
  121     Changed |= addENDBR(*MBB, MBB->begin());
  124   for (auto &MBB : MF) {
lib/Target/X86/X86InsertPrefetch.cpp
  190   for (auto &MBB : MF) {
  201       if (!IsMemOpCompatibleWithPrefetch(*Current, MemOpOffset))
  204       if (!findPrefetchInfo(Samples, *Current, Prefetches))
lib/Target/X86/X86InstrInfo.cpp
  797   BuildMI(*MFI, MBBI, MI.getDebugLoc(), get(X86::IMPLICIT_DEF), InRegLEA);
  799       BuildMI(*MFI, MBBI, MI.getDebugLoc(), get(TargetOpcode::COPY))
  804       BuildMI(*MFI, MBBI, MI.getDebugLoc(), get(Opcode), OutRegLEA);
  850       BuildMI(*MFI, &*MIB, MI.getDebugLoc(), get(X86::IMPLICIT_DEF), InRegLEA2);
  851       InsMI2 = BuildMI(*MFI, &*MIB, MI.getDebugLoc(), get(TargetOpcode::COPY))
  864       BuildMI(*MFI, MBBI, MI.getDebugLoc(), get(TargetOpcode::COPY))
lib/Target/X86/X86OptimizeLEAs.cpp
  686   for (auto &MBB : MF) {
lib/Target/X86/X86SpeculativeLoadHardening.cpp
  249           *std::next(MachineFunction::iterator(&NewMBB));
  330   for (auto &MBB : MF)
  372   for (MachineBasicBlock &MBB : MF) {
  429   MachineBasicBlock &Entry = *MF.begin();
  517     for (MachineBasicBlock &MBB : MF) {
  570   for (MachineBasicBlock &MBB : MF) {
  603   for (MachineBasicBlock &MBB : MF) {
  713                  : &*std::next(MachineFunction::iterator(&MBB));
  851   for (MachineBasicBlock &MBB : MF)
  855       MachineInstr &MI = *MII++;
  975   for (MachineBasicBlock &MBB : MF) {
  982     MachineInstr &TI = *MII;
 1056   for (MachineBasicBlock &MBB : MF) {
 1653   for (MachineBasicBlock &MBB : MF) {
lib/Target/X86/X86VZeroUpper.cpp
  316   for (MachineBasicBlock &MBB : MF)
lib/Target/X86/X86WinAllocaExpander.cpp
  138   for (MachineBasicBlock &MBB : MF)
lib/Target/X86/X86WinEHState.cpp
  165   for (BasicBlock &BB : F) {
  295     insertStateNumberStore(&*Builder.GetInsertPoint(), ParentBaseState);
  325     insertStateNumberStore(&*Builder.GetInsertPoint(), ParentBaseState);
  367   for (BasicBlock &BB : *F) {
  678     for (Instruction &I : *BB) {
  745     for (Instruction &I : *BB) {
  765     for (Instruction &I : *BB) {
lib/Target/XCore/XCoreFrameToArgsOffsetElim.cpp
   53     MachineBasicBlock &MBB = *MFI;
lib/Target/XCore/XCoreLowerThreadLocal.cpp
  226   for (GlobalVariable &GV : M.globals())
lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
  324   for (BasicBlock &BB : F) {
  334     for (Instruction &I : make_range(BB.rbegin(), BB.rend())) {
  343     for (BasicBlock &BB : F)
lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp
  391   for (auto &BB : F) {
  395     for (auto &I : BB)
lib/Transforms/CFGuard/CFGuard.cpp
  267   for (BasicBlock &BB : F.getBasicBlockList()) {
  268     for (Instruction &I : BB.getInstList()) {
lib/Transforms/Coroutines/CoroElide.cpp
  100   for (Instruction &I : F->getEntryBlock())
  157   for (BasicBlock &B : *F) {
lib/Transforms/Coroutines/CoroFrame.cpp
   51     for (BasicBlock &BB : F)
  695             InsertPt = &*DefBlock->getFirstInsertionPt();
  725       CurrentReload = CreateReload(&*CurrentBlock->getFirstInsertionPt());
  930   for (BasicBlock &BB : F)
  975           &*CurrentBlock->getFirstInsertionPt());
 1306   for (auto &Inst : F.getEntryBlock()) {
lib/Transforms/IPO/AlwaysInliner.cpp
   48   for (Function &F : M)
lib/Transforms/IPO/ArgumentPromotion.cpp
  627   for (Instruction &I : EntryBlock)
  922   for (BasicBlock &BB : *F)
lib/Transforms/IPO/Attributor.cpp
 2224     for (BasicBlock &BB : F)
 2289     for (const Instruction &I : BB)
 4630     for (Function &F : M)
 4933   for (Function &F : M)
 4936   for (Function &F : M) {
lib/Transforms/IPO/BlockExtractor.cpp
  136   for (BasicBlock &BB : F) {
  137     for (Instruction &I : BB) {
  170   for (Function &F : M) {
  188       GroupsOfBlocks[NextGroupIdx].push_back(&*Res);
  227     for (Function &F : M)
lib/Transforms/IPO/CalledValuePropagation.cpp
  377   for (Function &F : M)
lib/Transforms/IPO/ConstantMerge.cpp
  157       GlobalVariable *GV = &*GVI++;
  203       GlobalVariable *GV = &*GVI++;
lib/Transforms/IPO/DeadArgumentElimination.cpp
  139   for (BasicBlock &BB : Fn) {
  140     for (Instruction &I : BB) {
  972           InsertPt = &*NewEdge->getFirstInsertionPt();
 1033     for (BasicBlock &BB : *NF)
 1094     Function &F = *I++;
 1104   for (auto &F : M)
 1112     Function *F = &*I++;
 1118   for (auto &F : M)
lib/Transforms/IPO/ElimAvailExtern.cpp
   36   for (GlobalVariable &GV : M.globals()) {
   52   for (Function &F : M) {
lib/Transforms/IPO/ExtractGV.cpp
   86             deleteStuff == (bool)Named.count(&*I) && !I->isDeclaration();
   94         makeVisible(*I, Delete);
  104       for (Function &F : M) {
  127         bool Delete = deleteStuff == (bool)Named.count(&*CurI);
  128         makeVisible(*CurI, Delete);
  147           delete &*CurI;
lib/Transforms/IPO/ForceFunctionAttrs.cpp
   94   for (Function &F : M.functions())
  113     for (Function &F : M.functions())
lib/Transforms/IPO/FunctionAttrs.cpp
  593       for (BasicBlock &BB : *F)
  639   for (Instruction &I : Entry) {
  863   for (BasicBlock &BB : *F)
  976   for (BasicBlock &BB : *F)
 1368   for (auto &BB : *F)
lib/Transforms/IPO/FunctionImport.cpp
 1000   for (auto &GV : TheModule)
 1002   for (auto &GV : TheModule.globals())
 1004   for (auto &GV : TheModule.aliases())
 1065   for (auto &GV : M.globals())
 1107     for (Function &F : *SrcModule) {
 1129     for (GlobalVariable &GV : SrcModule->globals()) {
 1143     for (GlobalAlias &GA : SrcModule->aliases()) {
lib/Transforms/IPO/GlobalDCE.cpp
   88   for (auto &I : Entry) {
  168   for (GlobalVariable &GV : M.globals()) {
  293   for (Function &F : M)
  296   for (GlobalVariable &GV : M.globals())
  299   for (GlobalAlias &GA : M.aliases())
  321   for (GlobalAlias &GA : M.aliases()) {
  331   for (GlobalIFunc &GIF : M.ifuncs()) {
  356   for (GlobalVariable &GV : M.globals())
  369   for (Function &F : M)
  378   for (GlobalAlias &GA : M.aliases())
  386   for (GlobalIFunc &GIF : M.ifuncs())
lib/Transforms/IPO/GlobalOpt.cpp
 1947     Instruction &FirstI = const_cast<Instruction&>(*GS.AccessingFunction
 2156   for (BasicBlock &BB : *F)
 2217   for (BasicBlock &BB : F) {
 2218     for (Instruction &I : BB) {
 2257     Function *F = &*FI++;
 2264     Function *F = &*FI++;
 2359     GlobalVariable *GV = &*GVI++;
 2762     GlobalAlias *J = &*I++;
 2828   auto *TLI = &GetTLI(*FuncIter);
 2858   for (auto &I : Fn.getEntryBlock()) {
 2924     for (const GlobalVariable &GV : M.globals())
 2928     for (Function &F : M)
 2932     for (GlobalAlias &GA : M.aliases())
lib/Transforms/IPO/GlobalSplit.cpp
  154     GlobalVariable &GV = *I;
lib/Transforms/IPO/HotColdSplitting.cpp
  110   for (Instruction &I : BB)
  334                                 &*Region[0]->begin())
  343                                     &*Region[0]->begin())
  640     Function &F = *It;
lib/Transforms/IPO/IPConstantPropagation.cpp
  178   for (BasicBlock &BB : F)
  297     for (Function &F : M)
lib/Transforms/IPO/InferFunctionAttrs.cpp
   25   for (Function &F : M.functions())
lib/Transforms/IPO/Inliner.cpp
  562     for (BasicBlock &BB : *F)
  563       for (Instruction &I : BB) {
lib/Transforms/IPO/Internalize.cpp
  159     for (Function &F : M)
  161     for (GlobalVariable &GV : M.globals())
  163     for (GlobalAlias &GA : M.aliases())
  181   for (Function &I : M) {
  214   for (auto &GV : M.globals()) {
  224   for (auto &GA : M.aliases()) {
lib/Transforms/IPO/LowerTypeTests.cpp
 1784     for (auto &F : M) {
lib/Transforms/IPO/MergeFunctions.cpp
  398   for (Function &Func : M) {
  534     WorklistBB.push_back(&*BBI);
  557     if (auto *DVI = dyn_cast<DbgValueInst>(&*BI)) {
  566         PDIRelated.insert(&*BI);
  572     } else if (auto *DDI = dyn_cast<DbgDeclareInst>(&*BI)) {
  599                   PDIRelated.insert(&*BI);
  622     } else if (BI->isTerminator() && &*BI == GEntryBlock->getTerminator()) {
  626       PDIRelated.insert(&*BI);
  639     Instruction *I = &*BI;
lib/Transforms/IPO/PartialInlining.cpp
  451   for (auto &BB : *F)
  901     for (BasicBlock &BB : *OutlinedFunc)
 1078     RetPhi->addIncoming(&*I, PreReturn);
 1205   for (BasicBlock &BB : *ClonedFunc)
 1456   for (Function &F : M)
lib/Transforms/IPO/PruneEH.cpp
  108       for (const BasicBlock &BB : *F) {
  116         for (const Instruction &I : BB) {
  194         removeUnwindEdge(&*BB);
  216           new UnreachableInst(BB->getContext(), &*BB);
  241       TokenInst = &*I;
  245     if (auto *Call = dyn_cast<CallBase>(&*I)) {
lib/Transforms/IPO/SampleProfile.cpp
  211     for (const auto &F : CurrentModule) {
  724   for (auto &I : BB->getInstList()) {
  743   for (const auto &BB : F) {
  917     for (auto &BB : F) {
  920       for (auto &I : BB.getInstList()) {
 1087   for (auto &BB : F) {
 1124   for (auto &BI : F) {
 1171   for (const auto &BI : F) {
 1317   for (auto &BI : F) {
 1375   for (auto &BI : F) {
 1420   for (auto &BI : F) {
 1424       for (auto &I : BB->getInstList()) {
 1748   for (auto &F : M)
lib/Transforms/IPO/StripDeadPrototypes.cpp
   33     Function *F = &*I++;
   45     GlobalVariable *GV = &*I++;
lib/Transforms/IPO/StripSymbols.cpp
  212     if (I->hasLocalLinkage() && llvmUsedValues.count(&*I) == 0)
  217   for (Function &I : M) {
  318   for (GlobalVariable &GV : M.globals()) {
lib/Transforms/IPO/SyntheticCountsPropagation.cpp
   75   for (Function &F : M) {
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
  145     Function &F = *I++;
  166     GlobalVariable &GV = *I++;
  253   for (GlobalVariable &GV : M.globals())
  288   for (Function &F : *MergedM)
  298   for (auto &F : M)
  347   for (auto &A : M.aliases()) {
lib/Transforms/IPO/WholeProgramDevirt.cpp
  784   for (GlobalVariable &GV : M.globals()) {
 1541   for (const Function &Fn : FL) {
 1924   for (GlobalVariable &GV : M.globals())
lib/Transforms/InstCombine/InstCombineCalls.cpp
 3876     for (++BI; &*BI != TI; ++BI) {
 4187     Instruction *Inst = &*--I;
 4661         InsertNewInstBefore(NC, *I);
 4664         InsertNewInstBefore(NC, *I);
lib/Transforms/InstCombine/InstCombineCompares.cpp
  621     Builder.SetInsertPoint(&*PHI->getParent()->getFirstInsertionPt());
  626       I = &*std::next(I->getIterator());
  633     Builder.SetInsertPoint(&*Entry.getFirstInsertionPt());
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
  206       while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It))
  206       while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It))
  217       IC.InsertNewInstBefore(GEP, *It);
 1560     for (BasicBlock::iterator I = StoreBB->begin(); &*I != &SI; ++I) {
 1585   InsertNewInstBefore(NewSI, *BBI);
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
  616     if (!isGuaranteedToTransferExecutionToSuccessor(&*BBI))
  624         Worklist.Add(&*BBI);
  628         Worklist.Add(&*BBI);
  633     if (&*BBI == SI)
  635     if (&*BBI == SelectCond)
lib/Transforms/InstCombine/InstCombinePHI.cpp
  267         InsertNewInstBefore(CI, *InsertPos);
  270         InsertNewInstBefore(CI, *InsertBB->getFirstInsertionPt());
lib/Transforms/InstCombine/InstCombineVectorOps.cpp
  150       InsertNewInstWith(newEI, *InsertPos);
  582     IC.InsertNewInstWith(WideVec, *ExtElt->getParent()->getFirstInsertionPt());
lib/Transforms/InstCombine/InstructionCombining.cpp
 2470     for (const Instruction &Inst : *FreeInstrBB) {
 2501     Instruction &Instr = *It++;
 3153   I->moveBefore(&*InsertPos);
 3190         TmpUser[0]->insertBefore(&*InsertPos);
 3199         DII->moveBefore(&*InsertPos);
 3389       Instruction *Inst = &*BBI++;
 3494   for (BasicBlock &BB : F) {
lib/Transforms/Instrumentation/AddressSanitizer.cpp
 1771   for (auto &BB : GlobalInit.getBasicBlockList())
 2219   for (auto &G : M.globals()) {
 2596   for (Instruction &I : F.getEntryBlock()) {
 2653   for (auto &BB : F) {
 2657     for (auto &Inst : BB) {
 2949   BasicBlock &FirstBB = *F.begin();
lib/Transforms/Instrumentation/CFGMST.h
  123           (BFI != nullptr ? BFI->getBlockFreq(&*BB).getFrequency() : 2);
  137             Weight = BPI->getEdgeProbability(&*BB, TargetBB).scale(scaleFactor);
  138           auto *E = &addEdge(&*BB, TargetBB, Weight);
  144           if (&*BB == Entry) {
  161         Edge *ExitO = &addEdge(&*BB, nullptr, BBWeight);
lib/Transforms/Instrumentation/CGProfile.cpp
   40   for (auto &F : M) {
   47     for (auto &BB : F) {
   51       for (auto &I : BB) {
lib/Transforms/Instrumentation/ControlHeightReduction.cpp
  734   for (Instruction &I : *EntryBB) {
  825       for (Instruction &I : *BB) {
 1590     for (Instruction &I : *BB) {
 1791     for (Instruction &I : *NewBlocks[i])
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
  784   for (Function &i : M) {
  799     GlobalAlias *GA = &*i;
 1035             DFS.ArgTLS ? &*F->getEntryBlock().begin()
lib/Transforms/Instrumentation/GCOVProfiling.cpp
  351       for (auto &BB : *F) {
  379       for (BasicBlock &I : *F) {
  422       for (BasicBlock &I : *F) {
  438       for (BasicBlock &I : *F)
  595   for (auto &BB : F) {
  596     for (auto &I : BB) {
  622 	if (isa<AllocaInst>(*It)) return true;
  623 	if (isa<DbgInfoIntrinsic>(*It)) return true;
  633   for (auto &F : M->functions()) {
  691     for (auto &F : M->functions()) {
  718       for (auto &BB : F) {
  729         for (auto &I : BB) {
  777     for (auto &F : M->functions()) {
  788       for (auto &BB : F) {
  810       for (auto &BB : F) {
  815           IRBuilder<> BuilderForPhi(&*BB.begin());
  828           IRBuilder<> Builder(&*BB.getFirstInsertionPt());
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
  353   for (Function &F : M)
  953     IRB.SetInsertPoint(&*Br->getSuccessor(0)->begin());
 1117   for (auto &BB : F) {
 1118     for (auto &Inst : BB) {
 1165   Instruction *InsertPt = &*F.getEntryBlock().begin();
 1211     for (auto &BB : F)
 1212       for (auto &Inst : BB)
 1227     InsertPt = &*F.getEntryBlock().begin();
 1231       Instruction *I = &*II++;
 1403   for (GlobalVariable &GV : M.globals()) {
 1443   for (Function &F : M) {
lib/Transforms/Instrumentation/IndirectCallPromotion.cpp
  395   for (auto &F : M) {
lib/Transforms/Instrumentation/InstrOrderFile.cpp
   70     for (Function &F : M) {
  163     for (Function &F : M) {
lib/Transforms/Instrumentation/InstrProfiling.cpp
  251         InsertPts.push_back(&*ExitBlock->getFirstInsertionPt());
  412   for (BasicBlock &BB : *F) {
  415       InstrProfIncrementInst *Inc = castToIncrementInst(&*Instr);
  516   for (Function &F : M) {
  518     for (BasicBlock &BB : F)
  531   for (Function &F : M)
lib/Transforms/Instrumentation/Instrumentation.cpp
   31     I->moveBefore(&*IP);
lib/Transforms/Instrumentation/MemorySanitizer.cpp
 1151             Cmp, &*IRB.GetInsertPoint(), false, MS.OriginStoreWeights);
 3379     IRBuilder<> IRBAfter(&*NextInsn);
lib/Transforms/Instrumentation/PGOInstrumentation.cpp
  614   for (auto &BB : F) {
 1262   for (auto &BB : F) {
 1269   uint64_t FuncEntryCount = getBBInfo(&*F.begin()).CountValue;
 1272   for (auto &BB : F) {
 1292   for (auto &BB : F) {
 1335   for (auto &BB : F) {
 1450   for (Function &F : M)
 1453   for (GlobalVariable &GV : M.globals())
 1456   for (GlobalAlias &GA : M.aliases())
 1471   for (auto &F : M) {
 1564   for (auto &F : M) {
 1798       auto *I = &*BI;
lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp
  346   BasicBlock *MergeBB = SplitBlock(DefaultBB, &(*It), DT);
lib/Transforms/Instrumentation/PoisonChecking.cpp
  261   for (BasicBlock &BB : F)
  262     for (auto I = BB.begin(); isa<PHINode>(&*I); I++) {
  263       auto *OldPHI = cast<PHINode>(&*I);
  273   for (BasicBlock &BB : F)
  274     for (Instruction &I : BB) {
  301   for (BasicBlock &BB : F)
  302     for (auto I = BB.begin(); isa<PHINode>(&*I); I++) {
  303       auto *OldPHI = cast<PHINode>(&*I);
  319   for (auto &F : M)
lib/Transforms/Instrumentation/SanitizerCoverage.cpp
  451   for (auto &F : M)
  604   for (auto &BB : F) {
  607     for (auto &Inst : BB) {
  672   IRBuilder<> IRB(&*F.getEntryBlock().getFirstInsertionPt());
  864   IRBuilder<> IRB(&*IP);
  899     auto ThenTerm = SplitBlockAndInsertIfThen(IsStackLower, &*IP, false);
lib/Transforms/Instrumentation/ThreadSanitizer.cpp
  454   for (auto &BB : F) {
  455     for (auto &Inst : BB) {
lib/Transforms/ObjCARC/DependencyAnalysis.cpp
  251       Instruction *Inst = &*--LocalStartPos;
lib/Transforms/ObjCARC/ObjCARCAPElim.cpp
   74     for (const BasicBlock &BB : *Callee) {
   75       for (const Instruction &I : BB)
   95     Instruction *Inst = &*I++;
lib/Transforms/ObjCARC/ObjCARCContract.cpp
  129   while (IsNoopInstruction(&*I))
  131   if (&*I != Retain)
  228     Instruction *Inst = &*I;
  299   while (I != Begin && GetBasicARCInstKind(&*I) != ARCInstKind::Retain) {
  300     Instruction *Inst = &*I;
  309   Instruction *Retain = &*I;
  488     } while (IsNoopInstruction(&*BBI));
  490     if (&*BBI == GetArgRCIdentityRoot(Inst)) {
lib/Transforms/ObjCARC/ObjCARCOpts.cpp
  603       while (IsNoopInstruction(&*I))
  605       if (&*I == RetainRV)
  611         while (IsNoopInstruction(&*I))
  613         if (&*I == RetainRV)
  637     while (I != Begin && IsNoopInstruction(&*I));
  638     if (GetBasicARCInstKind(&*I) == ARCInstKind::AutoreleaseRV &&
  639         EquivalentArgs.count(GetArgRCIdentityRoot(&*I))) {
  643       LLVM_DEBUG(dbgs() << "Erasing autoreleaseRV,retainRV pair: " << *I << "\n"
  646       EraseInstruction(&*I);
 1296     Instruction *Inst = &*std::prev(I);
 1430   for (Instruction &Inst : *BB) {
 1505   for (BasicBlock &ExitBB : F) {
 1909     BasicBlock *CurrentBB = &*Current.getBasicBlockIterator();
 1913       Instruction *EarlierInst = &*std::prev(J);
 2157   for (BasicBlock &BB: F) {
lib/Transforms/ObjCARC/PtrState.cpp
  282     InsertReverseInsertPt(&*InsertAfter);
lib/Transforms/Scalar/ADCE.cpp
  224   for (auto &BB : F) {
  235     for (Instruction &I : *BBInfo.second.BB)
  640   for (auto &BB : F) {
lib/Transforms/Scalar/CallSiteSplitting.cpp
  212   for (auto &InstBeforeCall :
  246   BitCastInst* BCI = dyn_cast<BitCastInst>(&*II);
  250   ReturnInst* RI = dyn_cast<ReturnInst>(&*II);
  331         TailBB, PredBB, &*std::next(Instr->getIterator()), ValueToValueMaps[i],
  336         &*std::prev(SplitBlock->getTerminator()->getIterator());
  380   auto *OriginalBegin = &*TailBB->begin();
  396     Instruction *CurrentI = &*I++;
  407       NewPN->insertBefore(&*TailBB->begin());
  425   for (auto &BI : *Parent) {
  514     BasicBlock &BB = *BI++;
  521     while (II != IE && &*II != BB.getTerminator()) {
  522       Instruction *I = &*II++;
lib/Transforms/Scalar/ConstantHoisting.cpp
  329       InsertPts.insert(&*InsertPt);
  502   for (BasicBlock &BB : Fn)
  503     for (Instruction &Inst : BB)
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp
  840       Instruction *II = &*BI++;
lib/Transforms/Scalar/DCE.cpp
   53     for (auto &BB : F) {
   55         Instruction *Inst = &*DI++;
lib/Transforms/Scalar/DeadStoreElimination.cpp
  620       Instruction *I = &*BI;
  760   for (Instruction &I : Entry) {
  783     if (hasAnalyzableMemoryWrite(&*BBI, *TLI) && isRemovable(&*BBI)) {
  783     if (hasAnalyzableMemoryWrite(&*BBI, *TLI) && isRemovable(&*BBI)) {
  786       GetUnderlyingObjects(getStoredPointerOperand(&*BBI), Pointers, DL);
  797         Instruction *Dead = &*BBI;
  821     if (isInstructionTriviallyDead(&*BBI, TLI)) {
  823                         << *&*BBI << '\n');
  824       deleteDeadInstruction(&*BBI, &BBI, *MD, *TLI, IOL, OBB,
  834       DeadStackObjects.remove(&*BBI);
  838     if (auto *Call = dyn_cast<CallBase>(&*BBI)) {
  841       if (isAllocLikeFn(&*BBI, TLI))
  842         DeadStackObjects.remove(&*BBI);
  870     if (isa<FenceInst>(*BBI))
 1088     if (CallInst *F = isFreeCall(&*BBI, TLI)) {
 1096     Instruction *Inst = &*BBI++;
 1317   for (BasicBlock &BB : F)
lib/Transforms/Scalar/DivRemPairs.cpp
  127   for (auto &BB : F) {
  128     for (auto &I : BB) {
lib/Transforms/Scalar/EarlyCSE.cpp
  900     Instruction *Inst = &*I++;
lib/Transforms/Scalar/FlattenCFGPass.cpp
   62   for (auto &BB : F)
lib/Transforms/Scalar/Float2Int.cpp
  123   for (BasicBlock &BB : F) {
  129     for (Instruction &I : BB) {
lib/Transforms/Scalar/GVN.cpp
 2103     BasicBlock *BB = &*FI++;
 2159       ChangedFunction |= replaceOperandsForInBlockEquality(&*BI);
 2160     ChangedFunction |= processInstruction(&*BI);
 2436       Instruction *CurInst = &*BI++;
 2643     for (Instruction &Inst : *BB) {
lib/Transforms/Scalar/GVNHoist.cpp
  273       for (auto &Inst : *BB)
  395     for (const MemoryAccess &MA : *Acc)
 1087       for (Instruction &I1 : *BB) {
lib/Transforms/Scalar/GVNSink.cpp
  541       if (!isMemoryInst(&*I))
  543       if (isa<LoadInst>(&*I))
  545       CallInst *CI = dyn_cast<CallInst>(&*I);
  548       InvokeInst *II = dyn_cast<InvokeInst>(&*I);
  551       return lookupOrAdd(&*I);
  863   I0->moveBefore(&*BBEnd->getFirstInsertionPt());
lib/Transforms/Scalar/GuardWidening.cpp
  327     for (auto &I : *BB)
  392       for (auto &I : *CurBB) {
lib/Transforms/Scalar/IndVarSimplify.cpp
  494                                  &*PN->getParent()->getFirstInsertionPt());
 1566         IRBuilder<> Builder(&*WidePhi->getParent()->getFirstInsertionPt());
 1855     for (Instruction &I : make_range(Ctx->getIterator().getReverse(),
 2628     Instruction *ToMove = &*I;
 2921     for (auto &I : *BB)
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
 1158     for (Instruction &I : *ClonedBB)
lib/Transforms/Scalar/InferAddressSpaces.cpp
 1009           U.set(new AddrSpaceCastInst(NewV, V->getType(), "", &*InsertPos));
lib/Transforms/Scalar/InstSimplifyPass.cpp
   36     for (BasicBlock &BB : F) {
   43       for (Instruction &I : BB) {
lib/Transforms/Scalar/JumpThreading.cpp
  383   for (auto &BB : F)
  394     for (auto &BB : F) {
  458   for (Instruction &I : reverse(*BB)) {
  506   for (; &*I != StopAt; ++I) {
 1431     for (auto I = LoadBB->begin(); &*I != LoadI; ++I)
 1432       if (!isGuaranteedToTransferExecutionToSuccessor(&*I))
 2013     ValueMapping[&*BI] = New;
 2055   for (Instruction &I : *BB) {
 2342       ValueMapping[&*BI] = IV;
 2348       ValueMapping[&*BI] = New;
 2375   for (Instruction &I : *BB) {
 2676     for (auto &I : *BB)
 2738   for (auto BI = BB->begin(); &*BI != AfterGuard; ++BI)
 2739     if (!isa<PHINode>(&*BI))
 2740       ToRemove.push_back(&*BI);
 2742   Instruction *InsertionPoint = &*BB->getFirstInsertionPt();
lib/Transforms/Scalar/LICM.cpp
  355         for (const auto &MA : *Accesses) {
  421         InsertPts.push_back(&*ExitBlock->getFirstInsertionPt());
  435       for (AliasSet &AS : *CurAST) {
  523       Instruction &I = *--II;
  631         CommonSucc = &*It;
  827       Instruction &I = *II++;
 1048     for (AliasSet &AS : *CurAST) {
 1068       for (const auto &Acc : *Accs) {
 1239           for (const auto &MA : *Accesses)
 2266     for (Instruction &I : *BB) {
 2322       for (const auto &MA : *Accesses)
lib/Transforms/Scalar/LoopDataPrefetch.cpp
  227     for (auto &I : *BB)
  252     for (auto &I : *BB) {
lib/Transforms/Scalar/LoopDistribute.cpp
  219       for (auto &Inst : *Block)
  454     assert(&*OrigPH->begin() == OrigPH->getTerminator() &&
  794     if (!PH->getSinglePredecessor() || &*PH->begin() != PH->getTerminator())
lib/Transforms/Scalar/LoopFuse.cpp
  186       for (Instruction &I : *BB) {
 1022       for (Instruction &I : *BB)
 1219         PHI->moveBefore(&*FC0.Header->getFirstInsertionPt());
 1461         PHI->moveBefore(&*FC0.Header->getFirstInsertionPt());
lib/Transforms/Scalar/LoopIdiomRecognize.cpp
  581   for (Instruction &I : *BB) {
  643     Instruction *Inst = &*I++;
  646       WeakTrackingVH InstPtr(&*I);
  881     for (Instruction &I : **BI)
 1344       Instruction *Inst = &*Iter;
 1469     Instruction *Inst = &*Iter;
 2017     for (Instruction &I : *LoopBB) {
 2608     SExp.setInsertPoint(&*Builder.GetInsertPoint());
lib/Transforms/Scalar/LoopInstSimplify.cpp
   86       for (Instruction &I : *BB) {
lib/Transforms/Scalar/LoopInterchange.cpp
   94     for (Instruction &I : *BB) {
 1033     for (Instruction &Ins : *BB) {
lib/Transforms/Scalar/LoopPredication.cpp
  998     for (auto &I : *BB)
lib/Transforms/Scalar/LoopRerollPass.cpp
  583             dyn_cast<SCEVAddRecExpr>(SE->getSCEV(&*I))) {
  590         IVToIncMap[&*I] = IncSCEV->getValue()->getSExtValue();
  591         LLVM_DEBUG(dbgs() << "LRR: Possible IV: " << *I << " = " << *PHISCEV
  594         if (isLoopControlIV(L, &*I)) {
  596           LoopControlIV = &(*I);
  597           LLVM_DEBUG(dbgs() << "LRR: Possible loop control only IV: " << *I
  600           PossibleIVs.push_back(&*I);
  661     SimpleLoopReduction SLR(&*I, L);
  665     LLVM_DEBUG(dbgs() << "LRR: Possible reduction: " << *I << " (with "
 1013   for (auto &I : *L->getHeader()) {
 1311         for (auto &K : AST) {
 1437     unsigned I = Uses[&*J].find_first();
 1439       LLVM_DEBUG(dbgs() << "LRR: removing: " << *J << "\n");
lib/Transforms/Scalar/LoopSink.cpp
  231     IC->insertBefore(&*N->getFirstInsertionPt());
  244   I.moveBefore(&*MoveBB->getFirstInsertionPt());
  298     Instruction *I = &*II++;
lib/Transforms/Scalar/LoopStrengthReduce.cpp
 2188   for (IVStrideUse &U : IU)
 2424         if (&*UI != CondUse &&
 2429           const SCEV *B = IU.getStride(*UI, L);
 2475     if (&*++BasicBlock::iterator(Cond) != TermBr) {
 2656   for (const IVStrideUse &U : IU) {
 3051     for (Instruction &I : *BB) {
 3244   for (const IVStrideUse &U : IU) {
 5009   Instruction *Tentative = &*IP;
 5027         BetterPos = &*std::next(BasicBlock::iterator(Inst));
 5119   while (Rewriter.isInsertedInstruction(&*IP) && IP != LowestIP)
 5137   Rewriter.setInsertPoint(&*IP);
 5512   for (const IVStrideUse &U : IU) {
lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp
  258     for (Instruction &I : *BB) {
lib/Transforms/Scalar/LoopUnrollPass.cpp
  478     for (Instruction &I : *L->getHeader()) {
  514       for (Instruction &I : *BB) {
  620     for (Instruction &I : *ExitBB) {
lib/Transforms/Scalar/LoopUnswitch.cpp
  683     for (auto &I : *BB) {
  858   for (Instruction &I : *BB)
 1089     for (Instruction &I : *CurrentBB)
 1329                                     &*ExitSucc->getFirstInsertionPt());
 1343     for (Instruction &I : *NewBlocks[i]) {
lib/Transforms/Scalar/LoopVersioningLICM.cpp
  281   for (const auto &I : *CurAST) {
  393     for (auto &Inst : *Block) {
  547     for (auto &Inst : *Block) {
lib/Transforms/Scalar/LowerAtomic.cpp
  120     Instruction *Inst = &*DI++;
  140   for (BasicBlock &BB : F) {
lib/Transforms/Scalar/LowerConstantIntrinsics.cpp
   92     for (Instruction &I: *BB) {
lib/Transforms/Scalar/LowerExpectIntrinsic.cpp
  324   for (BasicBlock &BB : F) {
  338       Instruction *Inst = &*BI++;
lib/Transforms/Scalar/MemCpyOptimizer.cpp
  373   IRBuilder<> Builder(&*BI);
  470     auto *C = &*I;
  563         for (auto &I : make_range(++LI->getIterator(), SI->getIterator())) {
  634           if (isModOrRefSet(AA.getModRefInfo(&*I, StoreLoc))) {
 1339   for (BasicBlock &BB : F) {
 1349       Instruction *I = &*BI++;
lib/Transforms/Scalar/MergeICmps.cpp
  276   for (Instruction &Inst : *BB) {
  288     Inst->moveBefore(&*NewParent->begin());
  295   for (Instruction &Inst : *BB) {
  313   for (const Instruction &Inst : *BB) {
  883     if (auto *const Phi = dyn_cast<PHINode>(&*BBIt->begin()))
lib/Transforms/Scalar/MergedLoadStoreMotion.cpp
  174   for (const Instruction &Inst :
  190   for (Instruction &Inst : reverse(*BB1)) {
  259   SNew->insertBefore(&*InsertPt);
  309     Instruction *I = &*RBI;
  340       LLVM_DEBUG(dbgs() << "Search again\n"; Instruction *I = &*RBI; I->dump());
  357     BasicBlock *BB = &*FI++;
lib/Transforms/Scalar/NaryReassociate.cpp
  236       if (SE->isSCEVable(I->getType()) && isPotentiallyNaryReassociable(&*I)) {
  237         const SCEV *OldSCEV = SE->getSCEV(&*I);
  238         if (Instruction *NewI = tryReassociate(&*I)) {
  240           SE->forgetValue(&*I);
  245           RecursivelyDeleteTriviallyDeadInstructions(&*I, TLI);
  257         const SCEV *NewSCEV = SE->getSCEV(&*I);
  258         SeenExprs[NewSCEV].push_back(WeakTrackingVH(&*I));
  278           SeenExprs[OldSCEV].push_back(WeakTrackingVH(&*I));
lib/Transforms/Scalar/NewGVN.cpp
 2880       for (const auto &Def : *MemoryBlockDefs) {
 2897     for (auto &I : *BB) {
 2985   for (auto &I : *B) {
 3690     Instruction &Inst = *I++;
lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp
   99       CallInst *Call = dyn_cast<CallInst>(&*II);
  119             optimizeSQRT(Call, CalledFunc, *CurrBB, BB, TTI))
lib/Transforms/Scalar/PlaceSafepoints.cpp
  216     for (Instruction &I : *Current) {
  272     if (CallInst *CI = dyn_cast<CallInst>(&*BBI))
  276     assert(!isa<InvokeInst>(&*BBI) &&
  302     scanOneBB(&*BB->begin(), End, Calls, Seen, Worklist);
  409     return &*++I->getIterator();
  668   assert(isPotentiallyReachable(&*Start, &*After) &&
  668   assert(isPotentiallyReachable(&*Start, &*After) &&
  671   scanInlinedCode(&*Start, &*After, Calls, BBs);
  671   scanInlinedCode(&*Start, &*After, Calls, BBs);
lib/Transforms/Scalar/Reassociate.cpp
  183     for (Instruction &I : *BB)
  903     TheNeg->moveBefore(&*InsertPt);
 1106     V = CreateNeg(V, "neg", &*InsertPt, BO);
 2328     for (Instruction &I : *BI) {
 2413       if (isInstructionTriviallyDead(&*II)) {
 2414         EraseInst(&*II++);
 2416         OptimizeInst(&*II);
lib/Transforms/Scalar/Reg2Mem.cpp
   87       Type::getInt32Ty(F.getContext()), "reg2mem alloca point", &*I);
   92   for (BasicBlock &ibb : F)
   96           valueEscapes(&*iib)) {
   97         WorkList.push_front(&*iib);
  109   for (BasicBlock &ibb : F)
  113         WorkList.push_front(&*iib);
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
  131   for (Function &F : M) {
  175     for (Function &F : M) {
 1536     Builder.SetInsertPoint(&*UnwindBlock->getFirstInsertionPt());
 1553     Builder.SetInsertPoint(&*NormalDest->getFirstInsertionPt());
 1693   for (Instruction &I : F.getEntryBlock())
 1790         InsertClobbersAt(&*II->getNormalDest()->getFirstInsertionPt());
 1791         InsertClobbersAt(&*II->getUnwindDest()->getFirstInsertionPt());
 1872   for (auto &I : F.getEntryBlock())
 1903         CallInst::Create(Func, Values, "", &*++Call->getIterator()));
 1910       Func, Values, "", &*II->getNormalDest()->getFirstInsertionPt()));
 1912       Func, Values, "", &*II->getUnwindDest()->getFirstInsertionPt()));
 2151           &*Invoke->getNormalDest()->getFirstInsertionPt();
 2153           &*Invoke->getUnwindDest()->getFirstInsertionPt();
 2509   for (Function &F : M)
 2512   for (Function &F : M)
 2562   for (BasicBlock &BB : F)
 2588   for (BasicBlock &BB : F) {
 2641   for (auto &I : make_range(Begin, End)) {
 2673     for (auto &I : *Succ) {
 2689   for (Instruction &I : *BB)
 2729   for (BasicBlock &BB : F) {
 2786   for (BasicBlock &BB : F)
lib/Transforms/Scalar/SCCP.cpp
 1436   for (BasicBlock &BB : F) {
 1440     for (Instruction &I : BB) {
 1829   for (BasicBlock &BB : F) {
 1843       Instruction *Inst = &*BI++;
 1955   for (BasicBlock &BB : F) {
 2012   for (Function &F : M) {
 2041   for (GlobalVariable &G : M.globals()) {
 2053     for (Function &F : M)
 2067   for (Function &F : M) {
 2083       if (!Solver.isBlockExecutable(&*BB)) {
 2084         LLVM_DEBUG(dbgs() << "  BasicBlock Dead:" << *BB);
 2089         if (&*BB != &F.front())
 2090           BlocksToErase.push_back(&*BB);
 2095         Instruction *Inst = &*BI++;
 2163     for (BasicBlock &BB : F) {
 2165         Instruction *Inst = &*BI++;
lib/Transforms/Scalar/SROA.cpp
 1219     for (BasicBlock::iterator BBI(PN); &*BBI != LI; ++BBI)
 2576       IRB.SetInsertPoint(&*std::next(BasicBlock::iterator(&LI)));
 3156       PtrBuilder.SetInsertPoint(&*OldPtr->getParent()->getFirstInsertionPt());
lib/Transforms/Scalar/Scalarizer.cpp
  322       Instruction *I = &*II;
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp
 1126   for (BasicBlock &B : F) {
 1204       Instruction *Cur = &*I++;
 1212   for (BasicBlock &B : F) {
 1213     for (Instruction &I : B) {
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp
  161   for (Instruction &I : ExitBB) {
  226   Instruction *InsertPt = &*UnswitchedBB.begin();
  876         if (!isa<MemoryPhi>(*Defs->begin()) || (++Defs->begin() != Defs->end()))
 1054                           &*MergeBB->getFirstInsertionPt());
 1067     for (Instruction &I : *ClonedBB) {
 2547       for (auto &I : *BB)
 2636     for (auto &I : *BB) {
lib/Transforms/Scalar/SimplifyCFGPass.cpp
   79     BasicBlock &BB = *BBI++;
   96            Ret->getOperand(0) != &*I))
  163       if (simplifyCFG(&*BBIt++, TTI, Options, &LoopHeaders)) {
lib/Transforms/Scalar/Sink.cpp
  194   Inst->moveBefore(&*SuccToSinkTo->getFirstInsertionPt());
  216     Instruction *Inst = &*I; // The instruction to sink.
  246     for (BasicBlock &I : F)
lib/Transforms/Scalar/SpeculateAroundPHIs.cpp
  813     while (auto *PN = dyn_cast<PHINode>(&*BBI)) {
lib/Transforms/Scalar/SpeculativeExecution.cpp
  161   for (auto& B : F) {
  267   for (auto& I : FromBlock) {
  289     if (!NotHoisted.count(&*Current)) {
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp
  716     for (auto &I : *(Node->getBlock()))
lib/Transforms/Scalar/StructurizeCFG.cpp
  910     for (Instruction &I : *BB) {
lib/Transforms/Scalar/TailRecursionElimination.cpp
  200   for (auto &BB : F) {
  201     for (auto &I : BB)
  235     for (auto &I : *BB) {
  400   for (BasicBlock &BBI : *F) {
  445   return &*I;
  521   for (++BBI; &*BBI != Ret; ++BBI) {
  522     if (canMoveAboveCall(&*BBI, CI, AA))
  530              canTransformAccumulatorRecursion(&*BBI, CI))) {
  533       AccumulatorRecursionInstr = &*BBI;
  587             AI->moveBefore(&*NEBI);
  668     for (BasicBlock &BBI : *F)
  782     BasicBlock *BB = &*BBI++; // foldReturnAndProcessPred may delete BB.
lib/Transforms/Utils/AddDiscriminators.cpp
  188   for (BasicBlock &B : F) {
  189     for (auto &I : B.getInstList()) {
  231   for (BasicBlock &B : F) {
  233     for (auto &I : B.getInstList()) {
lib/Transforms/Utils/BasicBlockUtils.cpp
  128     if (!Reachable.count(&*I)) {
  129       BasicBlock *BB = &*I;
  248   Instruction *Start = &*BB->begin();
  323   Instruction &I = *BI;
  392   for (BasicBlock &BB : F) {
  431     MSSAU->moveAllAfterSpliceBlocks(Old, New, &*(New->begin()));
lib/Transforms/Utils/BreakCriticalEdges.cpp
  363   for (auto &BB : F) {
  438     assert(&*End == Target->getTerminator() &&
  461           PHINode::Create(IndPHI->getType(), 2, "merge", &*MergeInsert);
lib/Transforms/Utils/BypassSlowDivision.cpp
  451   Instruction *Next = &*BB->begin();
lib/Transforms/Utils/CallPromotionUtils.cpp
  176     InsertBefore = &*std::next(CS.getInstruction()->getIterator());
lib/Transforms/Utils/CanonicalizeAliases.cpp
   65   for (auto &GA : M.aliases())
lib/Transforms/Utils/CloneFunction.cpp
   53   for (const Instruction &I : *BB) {
  166     const BasicBlock &BB = *BI;
  209     for (Instruction &II : *BB)
  209     for (Instruction &II : *BB)
  356           VMap[&*II] = V;
  365     VMap[&*II] = NewInst; // Add instruction map to value.
  370       if (auto CS = ImmutableCallSite(&*II))
  493   for (const BasicBlock &BI : *OldFunc) {
  592         assert(VMap[&*OldI] == PN && "VMap mismatch");
  593         VMap[&*OldI] = NV;
  668     ConstantFoldTerminator(&*I);
  673     if (I != Begin && (pred_begin(&*I) == pred_end(&*I) ||
  673     if (I != Begin && (pred_begin(&*I) == pred_end(&*I) ||
  674                        I->getSinglePredecessor() == &*I)) {
  675       BasicBlock *DeadBB = &*I++;
  697     Dest->replaceAllUsesWith(&*I);
  742     for (auto &Inst : *BB)
  862   for (; StopAt != &*BI && BB->getTerminator() != &*BI; ++BI) {
  862   for (; StopAt != &*BI && BB->getTerminator() != &*BI; ++BI) {
  866     ValueMapping[&*BI] = New;
lib/Transforms/Utils/CloneModule.cpp
   70     GV->copyAttributesFrom(&*I);
   71     VMap[&*I] = GV;
   75   for (const Function &I : M) {
   86     if (!ShouldCloneDefinition(&*I)) {
  101       VMap[&*I] = GV;
  110     GA->copyAttributesFrom(&*I);
  111     VMap[&*I] = GA;
  123     GlobalVariable *GV = cast<GlobalVariable>(VMap[&*I]);
  124     if (!ShouldCloneDefinition(&*I)) {
  138     copyComdat(GV, &*I);
  143   for (const Function &I : M) {
  176     if (!ShouldCloneDefinition(&*I))
  178     GlobalAlias *GA = cast<GlobalAlias>(VMap[&*I]);
  188     const NamedMDNode &NMD = *I;
lib/Transforms/Utils/CodeExtractor.cpp
   97   for (Instruction const &Inst : BB)
  309   for (BasicBlock &BB : F) {
  375   for (BasicBlock &BB : *Func) {
  588     for (auto &BB : *F) {
  603     for (Instruction &II : *BB) {
  986       auto *II = dyn_cast<IntrinsicInst>(&*It);
 1251     Instruction *InsertBefore = &*InsertPt;
 1412       for (auto &I : *Block)
 1573   for (BasicBlock &BB : *newFunction) {
 1577       Instruction *Inst = &*BlockIt;
 1585     for (Instruction &I : BB)
lib/Transforms/Utils/DemoteRegToStack.cpp
  103   new StoreInst(&I, Slot, &*InsertPt);
  147       new LoadInst(P->getType(), Slot, P->getName() + ".reload", &*InsertPt);
lib/Transforms/Utils/EntryExitInstrumenter.cpp
   86     insertCall(F, EntryFunc, &*F.begin()->getFirstInsertionPt(), DL);
   92     for (BasicBlock &BB : F) {
lib/Transforms/Utils/EscapeEnumerator.cpp
   35     BasicBlock *CurBB = &*StateBB++;
   57   for (BasicBlock &BB : F)
   58     for (Instruction &II : BB)
lib/Transforms/Utils/Evaluator.cpp
  334     LLVM_DEBUG(dbgs() << "Evaluating Instruction: " << *CurInst << "\n");
  479       CallSite CS(&*CurInst);
  654       setVal(&*CurInst, InstResult);
lib/Transforms/Utils/FlattenCFG.cpp
  192         Instruction *CI = &*BI++;
  351     if (!iter1->isIdenticalTo(&*iter2))
  357       Instruction *CurI = &*iter1;
  372           if (!AA || AA->alias(&*iter1, &*BI))
  372           if (!AA || AA->alias(&*iter1, &*BI))
  437     Instruction *CI = &*BI;
lib/Transforms/Utils/FunctionComparator.cpp
  369       for(BasicBlock &BB : F->getBasicBlockList()) {
  769     if (int Res = cmpOperations(&*InstL, &*InstR, needToCmpOperands))
  769     if (int Res = cmpOperations(&*InstL, &*InstR, needToCmpOperands))
  937     for (auto &Inst : *BB) {
lib/Transforms/Utils/FunctionImportUtils.cpp
  292   for (GlobalVariable &GV : M.globals())
  294   for (Function &SF : M)
  296   for (GlobalAlias &GA : M.aliases())
lib/Transforms/Utils/ImportedFunctionsInliningStatistics.cpp
   63   for (const auto &F : M.functions()) {
lib/Transforms/Utils/InlineFunction.cpp
  527     Instruction *I = &*BBI++;
  618               &*BB, Invoke.getOuterResumeDest()))
  653   for (Instruction &I : *UnwindDest) {
  682         UpdatePHINodes(&*BB);
  746       UpdatePHINodes(&*BB);
  755               &*BB, UnwindDest, &FuncletUnwindMap))
  822   for (const BasicBlock &I : *CalledFunc)
  823     for (const Instruction &J : I) {
 1305                      Arg->getName(), &*Caller->begin()->begin());
 1521   for (BasicBlock &BB : *Callee)
 1524       for (Instruction &I : BB)
 1635             for (const BasicBlock &CalledBB : *CalledFunc) {
 1643           for (const BasicBlock &CalledBB : *CalledFunc) {
 1730                               &*FirstNewBlock, IFI);
 1809       for (BasicBlock &NewBlock :
 1811         for (Instruction &I : NewBlock) {
 1884         Instruction &I = *II++;
 2016     CallInst *SavedPtr = IRBuilder<>(&*FirstNewBlock, FirstNewBlock->begin())
 2040       HandleInlinedLandingPad(II, &*FirstNewBlock, InlinedFunctionInfo);
 2042       HandleInlinedEHPad(II, &*FirstNewBlock, InlinedFunctionInfo);
 2057         Instruction *I = &*BBI++;
 2214     for (BasicBlock &NewBB :
 2216       for (Instruction &I : NewBB)
 2298   Br->setOperand(0, &*FirstNewBlock);
lib/Transforms/Utils/InstructionNamer.cpp
   38       for (BasicBlock &BB : F) {
   42         for (Instruction &I : BB)
lib/Transforms/Utils/LCSSA.cpp
  353     for (Instruction &I : *BB) {
lib/Transforms/Utils/Local.cpp
  622     Instruction *I = &*BI;
  655     PhiIt = &*++BasicBlock::iterator(cast<Instruction>(PhiIt));
  976     while (isa<PHINode>(*BBI)) {
 1375     Builder.insertDbgValueIntrinsic(APN, DIVar, DIExpr, NewLoc, &*InsertionPt);
 1394   for (auto &FI : F)
 1395     for (Instruction &BI : FI)
 1456   for (auto &I : *BB) {
 1483         NewDbgII->insertBefore(&*InsertionPt);
 1884     Instruction *Inst = &*--EndInst->getIterator();
 2026     for (Instruction &I : *BB) {
 2227   for (BasicBlock &BB : F) {
 2615     Instruction *I = &*II;
lib/Transforms/Utils/LoopRotationUtils.cpp
   96     Value *OrigHeaderVal = &*I;
  318     if (auto *DII = dyn_cast<DbgVariableIntrinsic>(&*I))
  325     Instruction *Inst = &*I++;
  532     if (!isSafeToSpeculativelyExecute(&*I))
lib/Transforms/Utils/LoopSimplify.cpp
   91     if (&*BBI == SplitPreds[i])
  104     if (++BBI != NewBB->getParent()->end() && L->contains(&*BBI)) {
lib/Transforms/Utils/LoopUnroll.cpp
  112     for (Instruction &I : *BB) {
  221       Instruction *Inst = &*I++;
  422           for (auto &I : *BB)
  589       for (Instruction &I : *BB)
  685       for (Instruction &I : *NewBlock) {
lib/Transforms/Utils/LoopUnrollAndJam.cpp
  300       for (Instruction &I : *BB)
  382       for (Instruction &I : *NewBlock) {
  594     for (Instruction &I : *BB) {
lib/Transforms/Utils/LoopUnrollPeel.cpp
  311     for (auto BI = L->getHeader()->begin(); isa<PHINode>(&*BI); ++BI) {
  312       PHINode *Phi = cast<PHINode>(&*BI);
  536     PHINode *NewPHI = cast<PHINode>(VMap[&*I]);
  538       VMap[&*I] = NewPHI->getIncomingValueForBlock(PreHeader);
  543         VMap[&*I] = LVMap[LatchInst];
  545         VMap[&*I] = LatchVal;
lib/Transforms/Utils/LoopUnrollRuntime.cpp
  376     PHINode *NewPHI = cast<PHINode>(VMap[&*I]);
  383         VMap[&*I] = NewPHI->getIncomingValueForBlock(Preheader);
  802    for (auto &II : *BB) {
  879     for (Instruction &I : *BB) {
lib/Transforms/Utils/LoopUtils.cpp
  126     for (auto &Inst : *Block) {
  612     for (Instruction &I : *Block) {
lib/Transforms/Utils/LowerInvoke.cpp
   48   for (BasicBlock &BB : F)
lib/Transforms/Utils/LowerSwitch.cpp
  162     BasicBlock *Cur = &*I++; // Advance over block so we don't traverse new blocks
lib/Transforms/Utils/MetaRenamer.cpp
  124       for (auto &F : M) {
  149       for (auto &BB : F) {
  152         for (auto &I : BB)
lib/Transforms/Utils/ModuleUtils.cpp
  219     for (Function &F : M.functions())
  225     for (GlobalVariable &GV : M.globals())
  231     for (GlobalAlias &GA : M.aliases())
  264   for (auto &F : *M)
  266   for (auto &GV : M->globals())
  268   for (auto &GA : M->aliases())
  270   for (auto &IF : M->ifuncs())
lib/Transforms/Utils/NameAnonGlobals.cpp
   40     for (auto &F : TheModule) {
   46     for (auto &GV : TheModule.globals()) {
   77   for (auto &GA : M.aliases())
lib/Transforms/Utils/PromoteMemoryToRegister.cpp
  211     for (const Instruction &BBI : *BB)
  587       for (auto &BB : F)
  933     Instruction *I = &*II++; // get the instruction, increment iterator
lib/Transforms/Utils/SSAUpdater.cpp
  413     for (Instruction &I : *BB) {
lib/Transforms/Utils/SimplifyCFG.cpp
 1250   Instruction *I1 = &*BB1_Itr++, *I2 = &*BB2_Itr++;
 1250   Instruction *I1 = &*BB1_Itr++, *I2 = &*BB2_Itr++;
 1256       I1 = &*BB1_Itr++;
 1258       I2 = &*BB2_Itr++;
 1330     I1 = &*BB1_Itr++;
 1331     I2 = &*BB2_Itr++;
 1337         I1 = &*BB1_Itr++;
 1339         I2 = &*BB2_Itr++;
 1605   I0->moveBefore(&*BBEnd->getFirstInsertionPt());
 1990     Instruction *I = &*BBI;
 2107   for (auto &I : *ThenBB)
 2236     for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) {
 2256           TranslateMap[&*BBI] = V;
 2263           TranslateMap[&*BBI] = N;
 2383       if (!AggressiveInsts.count(&*I) && !isa<DbgInfoIntrinsic>(I)) {
 2396       if (!AggressiveInsts.count(&*I) && !isa<DbgInfoIntrinsic>(I)) {
 2535   for (Instruction &I : *PB) {
 2621   if (&*CondIt != BI)
 2631   for (auto I = BB->begin(); Cond != &*I; ++I) {
 2635     if (!I->hasOneUse() || !isSafeToSpeculativelyExecute(&*I))
 2731     for (auto BonusInst = BB->begin(); Cond != &*BonusInst; ++BonusInst) {
 2737       VMap[&*BonusInst] = NewBonusInst;
 2747       NewBonusInst->takeName(&*BonusInst);
 2868     for (Instruction &I : *BB)
 2884     for (auto &I : *BB)
 2976   for (auto &I : *QFB->getSinglePredecessor())
 2979   for (auto &I : *QFB)
 2983     for (auto &I : *QTB)
 2988     if (&*I != PStore && I->mayReadOrWriteMemory())
 3058   IRBuilder<> QB(&*PostBB->getFirstInsertionPt());
 3070       SplitBlockAndInsertIfThen(CombinedPred, &*QB.GetInsertPoint(), false);
 3191     for (auto &I : *BB)
 3198     for (auto &I : *BB)
 5749   if (isa<PHINode>(*Succ->begin()))
 5779       Instruction &Inst = *I;
lib/Transforms/Utils/SplitModule.cpp
  135       for (const BasicBlock &BB : *F) {
  254     for (Function &F : *M)
  256     for (GlobalVariable &GV : M->globals())
  258     for (GlobalAlias &GA : M->aliases())
  260     for (GlobalIFunc &GIF : M->ifuncs())
lib/Transforms/Utils/SymbolRewriter.cpp
  179   for (auto &C : (M.*Iterator)()) {
lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
   51   for (BasicBlock &I : F)
lib/Transforms/Utils/ValueMapper.cpp
  950   for (BasicBlock &BB : F)
  951     for (Instruction &I : BB)
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp
  533     if (!InstructionsToMove.count(&*BBI))
  535     Instruction *IM = &*BBI;
  550   for (Instruction &I : *BB) {
  618   for (Instruction &I : make_range(getBoundaryInstrs(Chain))) {
  745   for (Instruction &I : *BB) {
 1043   Builder.SetInsertPoint(&*Last);
 1192   Builder.SetInsertPoint(&*First);
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp
  580     for (Instruction &I : *BB) {
  881   for (Instruction &I : *BB) {
  943       for (Instruction &I : *BB)
  955     for (Instruction &I : *BB) {
lib/Transforms/Vectorize/LoopVectorize.cpp
 1724                                     &*LoopVectorBody->getFirstInsertionPt());
 2030     Builder.SetInsertPoint(&*NewIP);
 2532   IRBuilder<> Builder(&*Header->getFirstInsertionPt());
 2840         Index, Exp.expandCodeFor(Step, Index->getType(), &*B.GetInsertPoint()));
 2849                                            &*B.GetInsertPoint())));
 3069   Builder.SetInsertPoint(&*VecBody->getFirstInsertionPt());
 3203     Instruction *In = &*I++;
 3561     Builder.SetInsertPoint(&*LoopVectorBody->getFirstInsertionPt());
 3564         &*++BasicBlock::iterator(cast<Instruction>(PreviousLastPart)));
 3619   Builder.SetInsertPoint(&*LoopScalarPreHeader->begin());
 3718   Builder.SetInsertPoint(&*LoopMiddleBlock->getFirstInsertionPt());
 3764     Builder.SetInsertPoint(&*LoopMiddleBlock->getFirstInsertionPt());
 3918       I->moveBefore(&*PredBB->getFirstInsertionPt());
 3994           VecTy, 2, "vec.phi", &*LoopVectorBody->getFirstInsertionPt());
 4440     for (auto &I : *BB) {
 4707     for (auto &I : *BB) {
 5529     for (Instruction &I : *BB)
 5944     for (Instruction &I : *BB) {
 6043     for (Instruction &I : *BB) {
 7281   for (auto &Instr : make_range(Begin, End))
lib/Transforms/Vectorize/SLPVectorizer.cpp
 3401       if ((isa<CallInst>(&*PrevInstIt) &&
 3402            !isa<DbgInfoIntrinsic>(&*PrevInstIt)) &&
 3403           &*PrevInstIt != PrevInst)
 3601     for (auto &I : make_range(BasicBlock::iterator(Front), BB->end())) {
 4255       Builder.SetInsertPoint(&*++BasicBlock::iterator(I));
 4449       Instruction *In = &*it++;
 4650       if (&*UpIter == I) {
 4662       if (&*DownIter == I) {
 5468   for (Instruction &I : *BB) {
 6898     for (Instruction &I : *BB) {
 6951     if (R.isDeleted(&*it))
 6954     if (!VisitedInstrs.insert(&*it).second) {
 6955       if (it->use_empty() && KeyNodes.count(&*it) > 0 &&
 6991       KeyNodes.insert(&*it);
 7015       PostProcessInstructions.push_back(&*it);
lib/Transforms/Vectorize/VPlan.cpp
  199   for (VPRecipeBase &Recipe : Recipes)
  589   for (const VPRecipeBase &Recipe : *BasicBlock)
  649   for (auto &Instr : make_range(Begin, End))
  734     for (VPRecipeBase &VPI : *VPBB) {
lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp
  195   for (Instruction &InstRef : *BB) {
lib/Transforms/Vectorize/VPlanHCFGTransforms.cpp
   47       VPRecipeBase *Ingredient = &*I++;
lib/Transforms/Vectorize/VPlanSLP.cpp
  124     for (auto &I : *Parent) {
tools/bugpoint-passes/TestPasses.cpp
   37         if (isa<CallInst>(*I))
   87     for (auto &F : M.functions()) {
tools/bugpoint/CrashDebugger.cpp
  165   for (GlobalVariable &I : M->globals())
  260     for (Function &I : *M)
  266     for (GlobalAlias &Alias : M->aliases()) {
  287     for (Function &I : *M) {
  400   for (auto &BB : F)
  463   for (Function &F : M->functions()) {
  464     for (BasicBlock &BB : F) {
  495   for (auto &F : *M) {
  496     for (auto &BB : F)
  583   for (auto &F : *M)
  584     for (auto &BB : F)
  602   for (auto &F : *M) {
  603     for (auto &BB : F)
  692   for (auto &F : *M)
  695       if (!Blocks.count(&*BBIt)) {
  699       simplifyCFG(&*BBIt++, TTI);
  778         Instruction *Inst = &*I++;
  854   for (auto &NamedMD : M->named_metadata())
  918   for (auto &NamedMD : BD.getProgram().named_metadata()) {
  959   for (GlobalVariable &GV : M->globals()) {
  984   for (GlobalVariable &GV : OrigM.globals())
 1009     for (const Function &F : BD.getProgram())
 1010       for (const BasicBlock &BB : F)
 1011         for (const Instruction &I : BB)
 1063               outs() << "Checking instruction: " << *I;
 1065                   BD.deleteInstructionFromProgram(&*I, Simplification);
 1100   for (Function &F : BD.getProgram())
 1120   for (Function &F : BD.getProgram())
 1154     for (Function &F : BD.getProgram())
 1155       for (BasicBlock &BB : F)
 1176     for (Function &F : BD.getProgram())
 1177       for (BasicBlock &BB : F)
 1189     for (Function &F : BD.getProgram())
 1190       for (BasicBlock &BB : F)
 1228       for (auto &NamedMD : BD.getProgram().named_metadata())
 1240       for (auto &NamedMD : BD.getProgram().named_metadata())
tools/bugpoint/ExtractFunction.cpp
  101   Instruction *TheInst = &*RI; // Got the corresponding instruction!
  189         aliases.push_back(&*I);
  334   for (Function &I : *New)
  339   for (GlobalVariable &I : M->globals()) {
  386   for (Function &F : *M)
  387     for (BasicBlock &BB : F)
tools/bugpoint/Miscompilation.cpp
  545     for (BasicBlock &BB : *MiscompiledFunctions[i])
  622   for (Function &F : Prog)
  836         &*F != resolverFunc.getCallee() &&
tools/clang/lib/CodeGen/BackendUtil.cpp
  901     for (Function &F : *TheModule)
tools/clang/lib/CodeGen/CGBlocks.cpp
 1670             entry_ptr == entry->end() ? nullptr : &*entry_ptr);
tools/clang/lib/CodeGen/CGCall.cpp
 2758               dyn_cast<llvm::IntrinsicInst>(&*II)) {
 2764           if (isa<llvm::BitCastInst>(&*II) && (CastAddr == &*II))
 2764           if (isa<llvm::BitCastInst>(&*II) && (CastAddr == &*II))
 2768       I = &*II;
tools/clang/lib/CodeGen/CGCleanup.cpp
  464     CGBuilderTy(CGM, &*InsertBefore).CreateStore(Inst, Tmp);
tools/clang/lib/CodeGen/CGObjCMac.cpp
 4214     BlocksBeforeTry.insert(&*I);
 4272     llvm::BasicBlock &BB = *FI;
 4278       llvm::Instruction &I = *BI;
 4318     if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
 4318     if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
 4319       Locals.push_back(&*I);
tools/clang/lib/CodeGen/CGVTables.cpp
  128   for (auto &BB : Fn->getBasicBlockList()) {
  129     for (auto &I : BB) {
  210   Builder.SetInsertPoint(&*ThisStore);
  219     for (llvm::BasicBlock &BB : *Fn) {
tools/clang/lib/CodeGen/CodeGenAction.cpp
  207           for (Function &F : *LM.Module)
tools/clang/lib/CodeGen/CodeGenFunction.cpp
 1077   for (llvm::BasicBlock &BB : *F)
 1078     for (llvm::Instruction &I : BB)
tools/clang/unittests/CodeGen/IRMatchers.h
  418   for (const auto &I : *BB) {
  441     MC.push(&*P);
  443       return &*P;
tools/clang/unittests/CodeGen/IncrementalProcessingTest.cpp
  103   for (const auto& Func: M)
tools/clang/unittests/CodeGen/TBAAMetadataTest.cpp
   84     const llvm::Function &Func = *FuncPtr;
   94     const BasicBlock &BB = *BBPtr;
tools/lld/include/lld/Core/Simple.h
  190     return &*RefList::const_iterator(
  215     for (SimpleReference &node : _references) {
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp
 1263   for (TrieEdge &edge : _children) {
 1327   for (TrieEdge &edge : _children) {
 1355   for (TrieEdge &edge : _children) {
 1420   for (TrieEdge &edge : _children) {
tools/lldb/source/Expression/IRExecutionUnit.cpp
  329   for (llvm::Function &function : *m_module) {
  385   for (llvm::GlobalVariable &global_var : m_module->getGlobalList()) {
  389   for (llvm::GlobalAlias &global_alias : m_module->getAliasList()) {
tools/lldb/source/Expression/IRInterpreter.cpp
  513         LLDB_LOGF(log, "Unsupported instruction: %s", PrintValue(&*ii).c_str());
  535                     PrintValue(&*ii).c_str());
  555                     PrintValue(&*ii).c_str());
  689     const Instruction *inst = &*frame.m_ii;
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
 1154   for (const auto &func : module->getFunctionList()) {
tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp
  208       if (!InspectInstruction(*ii))
  225       if (!InspectBasicBlock(*bbi))
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
  898   for (Instruction &inst : basic_block) {
 1049   for (Instruction &inst : basic_block) {
 1148   for (Instruction &inst : basic_block) {
 1389   for (Instruction &inst : basic_block) {
 1421   for (Instruction &inst : basic_block) {
 1436   for (GlobalVariable &global_var : m_module->globals()) {
 1515   for (Instruction &inst : basic_block) {
 1918   for (llvm::Function &function : *m_module) {
 1919     for (BasicBlock &bb : function) {
 1959   for (llvm::Function &function : *m_module) {
 1960     for (llvm::BasicBlock &bb : function) {
 1980   for (llvm::Function &function : *m_module) {
 1981     for (BasicBlock &bb : function) {
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp
  131   for (auto &func : module.getFunctionList())
  132     for (auto &block : func.getBasicBlockList())
  133       for (auto &inst : block) {
tools/lli/lli.cpp
  707       for (const auto &F : M) {
tools/llvm-diff/DiffConsumer.cpp
   32       Numbering[&*FI] = IN++;
   38         Numbering[&*BI] = IN++;
tools/llvm-diff/DifferenceEngine.cpp
  198       Instruction *LeftI = &*LI, *RightI = &*RI;
  198       Instruction *LeftI = &*LI, *RightI = &*RI;
  219       unify(&*LI, &*RI);
  219       unify(&*LI, &*RI);
  500     tryUnify(&*L->begin(), &*R->begin());
  500     tryUnify(&*L->begin(), &*R->begin());
  551       if (matchForBlockDiff(&*LI, &*RI)) {
  551       if (matchForBlockDiff(&*LI, &*RI)) {
  555         TentativeValues.insert(std::make_pair(&*LI, &*RI));
  555         TentativeValues.insert(std::make_pair(&*LI, &*RI));
  587     unify(&*LI, &*RI);
  587     unify(&*LI, &*RI);
  598         Instruction *L = &*LI, *R = &*RI;
  598         Instruction *L = &*LI, *R = &*RI;
  607       Diff.addLeft(&*LI);
  613       Diff.addRight(&*RI);
  623     unify(&*LI, &*RI);
  623     unify(&*LI, &*RI);
  638     if (!isa<CallInst>(*I)) return;
  639     CallInst *LCall = cast<CallInst>(&*I);
  651     if (!isa<CallInst>(*I)) return;
  692     Function *LFn = &*I;
  708     Function *RFn = &*I;
tools/llvm-extract/llvm-extract.cpp
  176         GVs.insert(&*GA);
  207     for (auto &GV : M->globals()) {
  243         GVs.insert(&*F);
  282       BBs.push_back(&*Res);
  301       for (auto &BB : *F) {
  302         for (auto &I : BB) {
  327     for (auto &F : *M) {
tools/llvm-reduce/deltas/ReduceArguments.cpp
   49   for (auto &F : *Program)
  109   for (auto &F : *Program)
tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp
   88   for (auto &F : *Program)
   89     for (auto &BB : F)
   98   for (auto &F : *Program)
   99     for (auto &BB : F) {
  109   for (auto &F : *Program)
  110     for (auto &BB : F) {
  120     for (auto &I : *BB)
  131   for (auto &F : *Program)
  132     for (auto &BB : F) {
tools/llvm-reduce/deltas/ReduceFunctions.cpp
   29   for (auto &F : *Program)
   40   for (auto &F : *Program)
   65   for (auto &F : *Program)
tools/llvm-reduce/deltas/ReduceGlobalVars.cpp
   25   for (auto &GV : Program->globals())
   36   for (auto &GV : Program->globals())
   63   for (auto &GV : Program->globals())
tools/llvm-reduce/deltas/ReduceInstructions.cpp
   25   for (auto &F : *Program)
   26     for (auto &BB : F)
   27       for (auto &Inst : BB)
   36   for (auto &F : *Program)
   37     for (auto &BB : F)
   38       for (auto &Inst : BB)
   53   for (auto &F : *Program)
   54     for (auto &BB : F)
tools/llvm-reduce/deltas/ReduceMetadata.cpp
   61   for (auto &GV : Program->globals())
   64   for (auto &F : *Program) {
   66     for (auto &BB : F)
   67       for (auto &Inst : BB)
   72   for (auto &GV : Program->globals())
   75   for (auto &F : *Program) {
   77     for (auto &BB : F)
   78       for (auto &Inst : BB)
   86   for (auto &MD : Program->named_metadata()) {
  119   for (auto &GV : Program->globals())
  123   for (auto &F : *Program) {
  125     for (auto &BB : F)
  126       for (auto &I : BB)
tools/llvm-stress/llvm-stress.cpp
  709   for (auto &Instr : F->front()) {
tools/opt/Debugify.cpp
   93   for (Function &F : Functions) {
  105     for (BasicBlock &BB : F) {
  107       for (Instruction &I : BB)
  123       Instruction *InsertBefore = &*InsertPt;
  126       for (Instruction *I = &*BB.begin(); I != LastInst; I = I->getNextNode()) {
  237   for (Function &F : Functions) {
tools/opt/opt.cpp
  583       NamedMDNode *NMD = &*M->named_metadata_begin();
  845     for (Function &F : *M)
tools/polly/lib/Analysis/ScopBuilder.cpp
 1919     for (Instruction &Inst : *BB)
 1968   for (Instruction &Inst : *BB) {
 2101   for (Instruction &Inst : *BB) {
 2128   for (Instruction &Inst : *BB) {
 2142   for (Instruction &Inst : *BB) {
 2182     for (Instruction &Inst : *SR.getEntry())
 2249     for (Instruction &Inst : BB) {
 3380   for (AliasSet &AS : AST) {
 3551     for (auto &Inst : *BB) {
 3588     for (auto &Inst : *S->getRegion().getExit()) {
 3612     for (Instruction &Inst : *BB) {
 3640     for (Instruction &Inst : *R.getExit()) {
tools/polly/lib/Analysis/ScopDetection.cpp
 1555       if (!isValidInstruction(*I, Context) && !KeepGoing)
 1592       for (auto &I : *LBB)
tools/polly/lib/Analysis/ScopDetectionDiagnostic.cpp
  123     for (const Instruction &Inst : *BB) {
  792     for (const Instruction &Inst : *BB)
tools/polly/lib/Analysis/ScopInfo.cpp
 1723       for (Instruction &Inst : *BB)
 2398     for (Instruction &Inst : *BB) {
tools/polly/lib/CodeGen/BlockGenerators.cpp
   90       expandCodeFor(S, SE, DL, "polly", NewScev, Old->getType(), &*IP, &VTV,
  401     Instruction *NewInst = &*I;
  430                                   &*Builder.GetInsertPoint(), &DT, &LI);
  465     for (Instruction &Inst : *BB)
  517   Addr->insertBefore(&*EntryBB->getFirstInsertionPt());
  634   SplitBlockAndInsertIfThen(Cond, &*Builder.GetInsertPoint(), false, nullptr,
  815   Builder.SetInsertPoint(&*StartBlock->begin());
  888     MergePHI->insertBefore(&*MergeBB->getFirstInsertionPt());
  968     MergePHI->insertBefore(&*MergeBB->getFirstInsertionPt());
  981       for (auto &Inst : *Stmt.getBasicBlock())
  985         for (auto &Inst : *BB)
 1371                                   &*Builder.GetInsertPoint(), &DT, &LI);
 1394   for (Instruction &Inst : *BB)
 1477                                        &*Builder.GetInsertPoint(), &DT, &LI);
 1543                                       &*Builder.GetInsertPoint(), &DT, &LI);
 1611   Builder.SetInsertPoint(&*ExitBBCopy->getFirstInsertionPt());
 1768       Builder.SetInsertPoint(&*IP);
tools/polly/lib/CodeGen/CodeGeneration.cpp
  107   for (BasicBlock &BB : F) {
  152       if (auto *IT = dyn_cast<IntrinsicInst>(&*InstIt)) {
tools/polly/lib/CodeGen/IslExprBuilder.cpp
  320                       &*Builder.GetInsertPoint(), nullptr,
  607   auto NextBB = SplitBlock(InsertBB, &*InsertPoint, &DT, &LI);
tools/polly/lib/CodeGen/IslNodeBuilder.cpp
  210   for (Instruction &Inst : *BB) {
  630                                  &*Builder.GetInsertPoint(), &DT, &LI);
  696   Builder.SetInsertPoint(&*LoopBody);
  722   Builder.SetInsertPoint(&*AfterLoop);
  723   removeSubFuncFromDomTree((*LoopBody).getParent()->getParent(), DT);
  790                                   &*Builder.GetInsertPoint(), &DT, &LI);
 1276                                   &*Builder.GetInsertPoint(), &DT, &LI);
 1400   Alloca->insertBefore(&*EntryBB->getFirstInsertionPt());
 1513                                      &*Builder.GetInsertPoint(), &DT, &LI);
 1567   Instruction *InsertLocation = &*Builder.GetInsertPoint();
tools/polly/lib/CodeGen/LoopGenerators.cpp
  125   ExitBB = SplitBlock(BeforeBB, &*Builder.GetInsertPoint(), &DT, &LI);
  186   Builder.SetInsertPoint(&*BeforeLoop);
  230   Instruction *IP = &*EntryBB.getFirstInsertionPt();
tools/polly/lib/CodeGen/LoopGeneratorsGOMP.cpp
  154   Builder.SetInsertPoint(&*--Builder.GetInsertPoint());
  167   Builder.SetInsertPoint(&*LoopBody);
tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp
  252   Builder.SetInsertPoint(&*--Builder.GetInsertPoint());
  267   Builder.SetInsertPoint(&*LoopBody);
tools/polly/lib/Support/ScopHelper.cpp
  209   splitBlock(EntryBlock, &*I, DT, LI, RI);
  417     for (BasicBlock &I : *R.getEntry()->getParent())
  429   for (Instruction &Inst : BB)
  592       for (BasicBlock &I : *R.getEntry()->getParent())
  738   for (Instruction &Inst : *BB) {
tools/polly/lib/Support/ScopLocation.cpp
   27     for (const Instruction &Inst : *BB) {
tools/polly/lib/Support/VirtualInstruction.cpp
  209         for (Instruction &Inst : *BB)
tools/polly/lib/Transform/RewriteByReferenceParameters.cpp
   70                        "polly_byref_alloca_" + InstName, &*Entry->begin());
   82     for (BasicBlock &BB : F)
   83       for (Instruction &Inst : BB)
tools/verify-uselistorder/verify-uselistorder.cpp
  188   for (const GlobalVariable &G : M.globals())
  190   for (const GlobalAlias &A : M.aliases())
  192   for (const GlobalIFunc &IF : M.ifuncs())
  194   for (const Function &F : M)
  198   for (const GlobalVariable &G : M.globals())
  201   for (const GlobalAlias &A : M.aliases())
  203   for (const GlobalIFunc &IF : M.ifuncs())
  205   for (const Function &F : M) {
  215   for (const Function &F : M) {
  218     for (const BasicBlock &BB : F)
  220     for (const BasicBlock &BB : F)
  221       for (const Instruction &I : BB)
  225     for (const BasicBlock &BB : F)
  226       for (const Instruction &I : BB)
  464   for (GlobalVariable &G : M.globals())
  466   for (GlobalAlias &A : M.aliases())
  468   for (GlobalIFunc &IF : M.ifuncs())
  470   for (Function &F : M)
  474   for (GlobalVariable &G : M.globals())
  477   for (GlobalAlias &A : M.aliases())
  479   for (GlobalIFunc &IF : M.ifuncs())
  481   for (Function &F : M) {
  491   for (Function &F : M) {
  494     for (BasicBlock &BB : F)
  496     for (BasicBlock &BB : F)
  497       for (Instruction &I : BB)
  501     for (BasicBlock &BB : F)
  502       for (Instruction &I : BB)
unittests/ADT/IListIteratorTest.cpp
   65   EXPECT_EQ(&A, &*L.begin());
   66   EXPECT_EQ(&A, &*L.rbegin());
   89   EXPECT_EQ(&A, &*L.begin());
   90   EXPECT_EQ(&B, &*++L.begin());
   92   EXPECT_EQ(&B, &*L.rbegin());
   93   EXPECT_EQ(&A, &*++L.rbegin());
  111   EXPECT_EQ(&A, &*I);
  112   L.remove(*I++);
  113   EXPECT_EQ(&B, &*I);
  114   L.remove(*I++);
  126   EXPECT_EQ(&B, &*RI);
  127   L.remove(*RI++);
  128   EXPECT_EQ(&A, &*RI);
  129   L.remove(*RI++);
unittests/ADT/IListTest.cpp
  146   Node *N = &*List.begin();
  224       Other.removeNodeFromList(&*First);
  225       addNodeToList(&*First);
  297   (void)*L.begin();
unittests/ADT/SimpleIListTest.cpp
  111   EXPECT_EQ(&B, &*++L.begin());
  136   EXPECT_EQ(B, &*++L.begin());
  153   EXPECT_EQ(&B, &*++L.begin());
  170   EXPECT_EQ(&B, &*++L.begin());
  205   EXPECT_EQ(B, &*++L.begin());
  222   EXPECT_EQ(&B, &*++L.begin());
  241   EXPECT_EQ(&A, &*I++);
  242   EXPECT_EQ(&B, &*I++);
  243   EXPECT_EQ(&C, &*I++);
  244   EXPECT_EQ(&D, &*I++);
  245   EXPECT_EQ(&E, &*I++);
  265   EXPECT_EQ(&A, &*I++);
  266   EXPECT_EQ(B, &*I++);
  267   EXPECT_EQ(C, &*I++);
  268   EXPECT_EQ(D, &*I++);
  269   EXPECT_EQ(&E, &*I++);
  290   EXPECT_EQ(&A, &*I++);
  291   EXPECT_EQ(&B, &*I++);
  292   EXPECT_EQ(&C, &*I++);
  293   EXPECT_EQ(&D, &*I++);
  294   EXPECT_EQ(&E, &*I++);
  354   EXPECT_EQ(&A, &*I++);
  355   EXPECT_EQ(&B, &*I++);
  356   EXPECT_EQ(&C, &*I++);
  357   EXPECT_EQ(&D, &*I++);
  377   EXPECT_EQ(&A, &*I++);
  378   EXPECT_EQ(&B, &*I++);
  379   EXPECT_EQ(&C, &*I++);
  383   EXPECT_EQ(&D, &*I++);
  384   EXPECT_EQ(&E, &*I++);
  405   EXPECT_EQ(&A, &*I++);
  406   EXPECT_EQ(&B, &*I++);
  407   EXPECT_EQ(&C, &*I++);
  408   EXPECT_EQ(&D, &*I++);
  412   EXPECT_EQ(&E, &*I++);
  413   EXPECT_EQ(&F, &*I++);
  451       EXPECT_EQ(&N, &*I++);
  487   EXPECT_EQ(&Ns[0], &*I++);
  488   EXPECT_EQ(&Ns[3], &*I++);
  489   EXPECT_EQ(&Ns[4], &*I++);
  490   EXPECT_EQ(&Ns[1], &*I++);
  491   EXPECT_EQ(&Ns[2], &*I++);
  502   EXPECT_EQ(&Ns[1], &*I++);
  503   EXPECT_EQ(&Ns[2], &*I++);
  504   EXPECT_EQ(&Ns[0], &*I++);
  505   EXPECT_EQ(&Ns[3], &*I++);
  506   EXPECT_EQ(&Ns[4], &*I++);
  535       EXPECT_EQ(&N, &*I++);
  564     EXPECT_EQ(&N, &*I++);
  591     EXPECT_EQ(&Ns[O], &*I++);
  593     EXPECT_EQ(&Ns[O], &*I++);
  640     EXPECT_EQ(&Ns[I], &*I1++);
  648     EXPECT_EQ(&Ns[I], &*I2++);
unittests/Analysis/AliasSetTrackerTest.cpp
   70   for (auto &BB : *Test)
   77   for (auto &Inst : *Test->begin()) {
   77   for (auto &Inst : *Test->begin()) {
   79     for (AliasSet &AS : AST) {
unittests/Analysis/CFGTest.cpp
   65         ExclusionSet.insert(&*I);
  395   succ_iterator S = succ_begin(&*++M->getFunction("test")->begin());
unittests/Analysis/CGSCCPassManagerTest.cpp
 1174                                           "dummy", &*H2F.begin()->begin());
 1220         (void)CallInst::Create(&H3F, {}, "", &*H2F.begin()->begin());
unittests/Analysis/DivergenceAnalysisTest.cpp
   33   for (auto &BB : F) {
  299       for (auto &BB : F) {
  320     auto *C = &*ItBlocks++;
  321     auto *D = &*ItBlocks++;
  322     auto *E = &*ItBlocks;
  343     auto *D = &*ItBlocks++;
  344     auto *E = &*ItBlocks;
  364     auto *C = &*ItBlocks++;
  366     auto *E = &*ItBlocks;
unittests/Analysis/DomTreeUpdaterTest.cpp
   67   BasicBlock *BB0 = &*FI++;
   68   BasicBlock *BB1 = &*FI++;
   69   BasicBlock *BB2 = &*FI++;
   70   BasicBlock *BB3 = &*FI++;
  176   BasicBlock *BB0 = &*FI++;
  177   BasicBlock *BB1 = &*FI++;
  249   BasicBlock *BB0 = &*FI++;
  250   BasicBlock *BB1 = &*FI++;
  251   BasicBlock *BB2 = &*FI++;
  252   BasicBlock *BB3 = &*FI++;
  338   BasicBlock *BB0 = &*FI++;
  339   BasicBlock *BB1 = &*FI++;
  340   BasicBlock *BB2 = &*FI++;
  341   BasicBlock *BB3 = &*FI++;
  468   BasicBlock *BB0 = &*FI++;
  469   BasicBlock *BB1 = &*FI++;
  470   BasicBlock *BB2 = &*FI++;
  471   BasicBlock *BB3 = &*FI++;
  551   BasicBlock *BB0 = &*FI++;
  552   BasicBlock *BB1 = &*FI++;
  642   BasicBlock *BB0 = &*FI++;
  644   BasicBlock *BB2 = &*FI++;
  645   BasicBlock *BB3 = &*FI++;
  722   BasicBlock *BB0 = &*FI++;
  753   BasicBlock *BB0 = &*FI++;
  754   BasicBlock *BB1 = &*FI++;
  755   BasicBlock *BB2 = &*FI++;
unittests/Analysis/GlobalsModRefTest.cpp
   37   const Function &F1 = *I;
   39   const Function &F2 = *I;
   41   const Function &F3 = *I;
unittests/Analysis/IVDescriptorsTest.cpp
   78         BasicBlock *Header = &*(++FI);
   91           if ((&*BBI)->getName() == "inc")
   92             Inst_inc = &*BBI;
unittests/Analysis/LazyCallGraphTest.cpp
  396   for (Function &F : M)
unittests/Analysis/LoopInfoTest.cpp
   82     BasicBlock *Header = &*(++FI);
  132     BasicBlock *Header = &*(++FI);
  184   Function &F = *M->begin();
  193   Loop &L_0 = *LI.getLoopFor(&*I++);
  195   Loop &L_0_0 = *LI.getLoopFor(&*I++);
  197   Loop &L_0_1 = *LI.getLoopFor(&*I++);
  199   Loop &L_0_2 = *LI.getLoopFor(&*I++);
  201   Loop &L_1 = *LI.getLoopFor(&*I++);
  203   Loop &L_1_0 = *LI.getLoopFor(&*I++);
  205   Loop &L_1_1 = *LI.getLoopFor(&*I++);
  207   Loop &L_1_2 = *LI.getLoopFor(&*I++);
  263         BasicBlock *Entry = &*(FI);
  267         BasicBlock *Header = &*(++FI);
  321         BasicBlock *Entry = &*(FI);
  325         BasicBlock *Header = &*(++FI);
  379         BasicBlock *Entry = &*(FI);
  383         BasicBlock *Header = &*(++FI);
  437         BasicBlock *Entry = &*(FI);
  441         BasicBlock *Header = &*(++FI);
  495         BasicBlock *Entry = &*(FI);
  499         BasicBlock *Header = &*(++FI);
  554         BasicBlock *Entry = &*(FI);
  558         BasicBlock *Header = &*(++FI);
  612         BasicBlock *Entry = &*(FI);
  616         BasicBlock *Header = &*(++FI);
  667         BasicBlock *Entry = &*(FI);
  671         BasicBlock *Header = &*(++FI);
  725         BasicBlock *Entry = &*(FI);
  729         BasicBlock *Header = &*(++FI);
  783         BasicBlock *Entry = &*(FI);
  788         BasicBlock *Header = &*(++FI);
  843         BasicBlock *Entry = &*(FI);
  847         BasicBlock *Header = &*(++FI);
  903         BasicBlock *Entry = &*(FI);
  907         BasicBlock *Header = &*(++FI);
  967         BasicBlock *Header = &*(++FI);
 1019         BasicBlock *Header = &*(++FI);
 1072         BasicBlock *Entry = &*(FI);
 1076         BasicBlock *Header = &*(++FI);
 1141         BasicBlock *Entry = &*(FI);
 1145         BasicBlock *Header = &*(++FI);
 1171         Header = &*(++FI);
 1233         BasicBlock *Entry = &*(FI);
 1237         BasicBlock *Header = &*(++FI);
 1257         PHINode &Instruction_i = cast<PHINode>(*(II));
 1259         PHINode &Instruction_aux = cast<PHINode>(*(++II));
 1261         PHINode &Instruction_loopvariant = cast<PHINode>(*(++II));
 1264         PHINode &Instruction_usedoutside = cast<PHINode>(*(++II));
 1267         PHINode &Instruction_mulopcode = cast<PHINode>(*(++II));
 1301     BasicBlock *Header = &*(++FI);
 1346         BasicBlock *Header = &*(++FI);
 1347         BasicBlock *Latch = &*(++FI);
 1391     BasicBlock *Header = &*(++FI);
 1434     BasicBlock *Header = &*(++FI);
unittests/Analysis/OrderedBasicBlockTest.cpp
   41   Instruction *Add = &*I++;
   42   Instruction *Ret = &*I++;
unittests/Analysis/ScalarEvolutionTest.cpp
  129   auto *PN = PHINode::Create(Ty, 2, "", &*LoopBB->begin());
  377     PHINode *Phi = cast<PHINode>(&*II++);
unittests/Analysis/UnrollAnalyzerTest.cpp
   32     BasicBlock *Header = &*FI++;
   42         for (Instruction &I : *BB)
   95   Function *F = &*MI++;
   98   BasicBlock *Header = &*FI++;
  102   Instruction *Y1 = &*BBI++;
  103   Instruction *Y2 = &*BBI++;
  157   Function *F = &*MI++;
  160   BasicBlock *Header = &*FI++;
  161   BasicBlock *InnerBody = &*FI++;
  165   Instruction *Y1 = &*BBI;
  168   Instruction *Y2 = &*BBI;
  203   Function *F = &*MI++;
  206   BasicBlock *Header = &*FI++;
  210   Instruction *Y1 = &*BBI++;
  211   Instruction *Y2 = &*BBI++;
  250   Function *F = &*MI++;
  253   BasicBlock *Header = &*FI;
  257   Instruction *Y1 = &*BBI;
  296   Function *F = &*MI++;
  299   BasicBlock *Header = &*FI++;
  303   Instruction *Y1 = &*BBI++;
  304   Instruction *Y2 = &*BBI++;
  305   Instruction *Y3 = &*BBI++;
unittests/Analysis/ValueTrackingTest.cpp
  511   for (auto &I : BB) {
unittests/CodeGen/GlobalISel/GISelMITest.h
  129   for (auto &MBB : *MF)
  146     EntryMBB = &*MF->begin();
unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp
   39   EXPECT_TRUE(isa<LoadInst>(*II)) << "First instruction of stub should be a load.";
unittests/FuzzMutate/OperationsTest.cpp
  234   BasicBlock &BB = *std::next(M->getFunction("test")->begin(), 2);
  238   Descr.BuilderFunc({ConstantInt::getTrue(Ctx)},&*BB.getFirstInsertionPt());
  320   BasicBlock &BB = *F.begin();
  323   ASSERT_FALSE(Descr.SourcePreds[0].matches({}, &*BB.begin()));
  326   ASSERT_TRUE(Descr.SourcePreds[0].matches({}, &*std::next(BB.begin())));
unittests/FuzzMutate/RandomIRBuilderTest.cpp
   64   Function &F = *M->begin();
   65   BasicBlock &BB = *F.begin();
   69     Insts.push_back(&*I);
  106   Function &F = *M->begin();
  107   BasicBlock &BB = *F.begin();
  110   Instruction *Src = &*std::next(BB.begin());
  126           BB, &*BB.begin(), Srcs, IVDescr.SourcePreds[2]);
  150   Function &F = *M->begin();
  151   BasicBlock &BB = *F.begin();
  154   Instruction *Source = &*BB.begin();
  156   SmallVector<Instruction *, 1> Sinks = {&*std::next(BB.begin())};
  185   Function &F = *M->begin();
  186   BasicBlock &BB = *F.begin();
  189   Instruction *Source = &*std::next(BB.begin());
  227   BasicBlock &BB = *F.begin();
  229   Instruction *Invoke = &*BB.begin();
  256   BasicBlock &BB = *F.begin();
  258   Instruction *FuncPtr = &*BB.begin();
  260   Instruction *OpaquePtr = &*std::next(BB.begin());
  287   BasicBlock &BB = *F.begin();
  288   Instruction *Alloca = &*BB.begin();
unittests/IR/DominatorTreeTest.cpp
   79         BasicBlock *BB0 = &*FI++;
   81         Instruction *Y1 = &*BBI++;
   82         Instruction *Y2 = &*BBI++;
   83         Instruction *Y3 = &*BBI++;
   85         BasicBlock *BB1 = &*FI++;
   87         Instruction *Y4 = &*BBI++;
   89         BasicBlock *BB2 = &*FI++;
   91         Instruction *Y5 = &*BBI++;
   93         BasicBlock *BB3 = &*FI++;
   95         Instruction *Y6 = &*BBI++;
   96         Instruction *Y7 = &*BBI++;
   98         BasicBlock *BB4 = &*FI++;
  100         Instruction *Y8 = &*BBI++;
  101         Instruction *Y9 = &*BBI++;
  299         BasicBlock *BB0 = &*FI++;
  300         BasicBlock *BB1 = &*FI++;
  301         BasicBlock *BB2 = &*FI++;
  384         BasicBlock *B = &*FI++;
  385         BasicBlock *C = &*FI++;
  386         BasicBlock *D = &*FI++;
  478         BasicBlock *B = &*FI++;
  479         BasicBlock *C = &*FI++;
  480         BasicBlock *D = &*FI++;
  567         BasicBlock *B = &*FI++;
  568         BasicBlock *C = &*FI++;
  569         BasicBlock *C2 = &*FI++;
  570         BasicBlock *D = &*FI++;
  640         BasicBlock *A = &*FI++;
  641         BasicBlock *B = &*FI++;
  642         BasicBlock *C = &*FI++;
  643         BasicBlock *D = &*FI++;
  644         BasicBlock *E = &*FI++;
unittests/IR/IRBuilderTest.cpp
  662     EXPECT_EQ(F, &*Builder.GetInsertPoint());
unittests/IR/InstructionsTest.cpp
 1094   BasicBlock &BranchTestExit = *BBs;
 1096   BasicBlock &IfThen = *BBs;
unittests/IR/LegacyPassManagerTest.cpp
  271           Function &F = *I;
unittests/IR/PassManagerTest.cpp
  573   for (Function &F : *M)
unittests/IR/ValueTest.cpp
  135   Instruction *I0 = &*BB.begin();
  137   Instruction *I1 = &*++BB.begin();
  209   BasicBlock *BB2 = &*++F->begin();
  212   Instruction *I0 = &*EntryBB.begin();
  214   Instruction *I1 = &*++EntryBB.begin();
  242   BasicBlock *BB2 = &*++F->begin();
unittests/Linker/LinkModulesTest.cpp
  257   Function *F = &*Src->begin();
  262   NamedMDNode *NMD = &*Src->named_metadata_begin();
  287   F = &*Dst->begin();
  291   NMD = &*Dst->named_metadata_begin();
unittests/Transforms/Scalar/LoopPassManagerTest.cpp
  882   Function &F = *M->begin();
  886   BasicBlock &EntryBB = *BBI++;
  888   BasicBlock &Loop0BB = *BBI++;
  890   BasicBlock &Loop00PHBB = *BBI++;
  892   BasicBlock &Loop00BB = *BBI++;
  894   BasicBlock &Loop01PHBB = *BBI++;
  896   BasicBlock &Loop01BB = *BBI++;
  898   BasicBlock &Loop02PHBB = *BBI++;
  900   BasicBlock &Loop02BB = *BBI++;
  902   BasicBlock &Loop0LatchBB = *BBI++;
  904   BasicBlock &EndBB = *BBI++;
 1085   Function &F = *M->begin();
 1089   BasicBlock &EntryBB = *BBI++;
 1091   BasicBlock &Loop0BB = *BBI++;
 1093   BasicBlock &Loop00PHBB = *BBI++;
 1095   BasicBlock &Loop00BB = *BBI++;
 1097   BasicBlock &Loop02PHBB = *BBI++;
 1099   BasicBlock &Loop02BB = *BBI++;
 1101   BasicBlock &Loop0LatchBB = *BBI++;
 1103   BasicBlock &Loop2PHBB = *BBI++;
 1105   BasicBlock &Loop2BB = *BBI++;
 1107   BasicBlock &EndBB = *BBI++;
 1346   Function &F = *M->begin();
 1350   BasicBlock &EntryBB = *BBI++;
 1352   BasicBlock &Loop0BB = *BBI++;
 1354   BasicBlock &Loop00PHBB = *BBI++;
 1356   BasicBlock &Loop00BB = *BBI++;
 1358   BasicBlock &Loop01PHBB = *BBI++;
 1360   BasicBlock &Loop01BB = *BBI++;
 1362   BasicBlock &Loop02PHBB = *BBI++;
 1364   BasicBlock &Loop02BB = *BBI++;
 1366   BasicBlock &Loop020PHBB = *BBI++;
 1368   BasicBlock &Loop020BB = *BBI++;
 1370   BasicBlock &Loop02LatchBB = *BBI++;
 1372   BasicBlock &Loop0LatchBB = *BBI++;
 1374   BasicBlock &EndBB = *BBI++;
unittests/Transforms/Utils/CloningTest.cpp
  422         BasicBlock *Preheader = &*(++FI);
  423         BasicBlock *Header = &*(++FI);
unittests/Transforms/Utils/CodeExtractorTest.cpp
   26   for (auto &BB : *F)
unittests/Transforms/Utils/LocalTest.cpp
  160   for (const Instruction &I : F->front())
  215       BasicBlock *BB = &*I++;
  439       BasicBlock *BB = &*I++;
  451       BasicBlock *BB = &*I++;
  551     for (const Instruction &I : F->front()) {
unittests/Transforms/Vectorize/VPlanHCFGTest.cpp
   55   VPInstruction *Phi = dyn_cast<VPInstruction>(&*Iter++);
   58   VPInstruction *Idx = dyn_cast<VPInstruction>(&*Iter++);
   63   VPInstruction *Load = dyn_cast<VPInstruction>(&*Iter++);
   68   VPInstruction *Add = dyn_cast<VPInstruction>(&*Iter++);
   73   VPInstruction *Store = dyn_cast<VPInstruction>(&*Iter++);
   79   VPInstruction *IndvarAdd = dyn_cast<VPInstruction>(&*Iter++);
   84   VPInstruction *ICmp = dyn_cast<VPInstruction>(&*Iter++);
  136   auto *Phi = dyn_cast<VPWidenPHIRecipe>(&*Iter++);
  139   auto *Idx = dyn_cast<VPWidenRecipe>(&*Iter++);
  142   auto *Load = dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++);
  145   auto *Add = dyn_cast<VPWidenRecipe>(&*Iter++);
  148   auto *Store = dyn_cast<VPWidenMemoryInstructionRecipe>(&*Iter++);
  151   auto *LastWiden = dyn_cast<VPWidenRecipe>(&*Iter++);
unittests/Transforms/Vectorize/VPlanPredicatorTest.cpp
  185       &*std::next(InnerIfFSucc->getEntryBasicBlock()->begin(), 1));
unittests/Transforms/Vectorize/VPlanSlpTest.cpp
  104   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
  105   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
  171   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
  172   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
  190   VPInstruction *GetA = cast<VPInstruction>(&*std::next(Body->begin(), 1));
  191   VPInstruction *GetB = cast<VPInstruction>(&*std::next(Body->begin(), 3));
  238   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 8));
  239   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 10));
  297   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 5));
  298   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 10));
  329   VPInstruction *LoadvA0 = cast<VPInstruction>(&*std::next(Body->begin(), 2));
  330   VPInstruction *LoadvA1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
  337   VPInstruction *LoadvB0 = cast<VPInstruction>(&*std::next(Body->begin(), 4));
  338   VPInstruction *LoadvB1 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
  347   VPInstruction *LoadvC0 = cast<VPInstruction>(&*std::next(Body->begin(), 7));
  348   VPInstruction *LoadvC1 = cast<VPInstruction>(&*std::next(Body->begin(), 17));
  355   VPInstruction *LoadvD0 = cast<VPInstruction>(&*std::next(Body->begin(), 9));
  356   VPInstruction *LoadvD1 = cast<VPInstruction>(&*std::next(Body->begin(), 19));
  425   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 24));
  426   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 26));
  497   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 24));
  498   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 26));
  569   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 24));
  570   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 26));
  645   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 24));
  646   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 26));
  707   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(BB2->begin(), 3));
  708   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(BB2->begin(), 5));
  770   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(BB2->begin(), 1));
  771   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(BB2->begin(), 3));
  829   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
  830   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
  888   VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
  889   VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
usr/include/c++/7.4.0/bits/predefined_ops.h
   43       { return *__it1 < *__it2; }
   43       { return *__it1 < *__it2; }
  143         { return bool(_M_comp(*__it1, *__it2)); }
  143         { return bool(_M_comp(*__it1, *__it2)); }
  283 	{ return bool(_M_pred(*__it)); }
  351 	{ return !bool(_M_pred(*__it)); }
usr/include/c++/7.4.0/bits/stl_algo.h
 3884 	__f(*__first);
 4306 	*__result = __unary_op(*__first);
usr/include/c++/7.4.0/bits/stl_iterator.h
  172 	return *--__tmp;
utils/unittest/googlemock/include/gmock/gmock-matchers.h
 3122       *std::declval<StlContainerConstIterator &>())>::type Element;
 3190         match = matchers_[exam_pos].MatchAndExplain(*it, &s);
 3193         match = matchers_[exam_pos].Matches(*it);
 3503         *std::declval<StlContainerConstIterator &>())>::type Element;
utils/unittest/googletest/include/gtest/gtest-printers.h
  389     internal::UniversalPrint(*it, os);