|
|
reference, declaration → definition
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.cpp10717 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.cpp30946 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);