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

References

  287     for (const auto &Arg : Args)
  347     for (const auto &NamedVar : VarNames)

  166   for (const auto &InputFile : InputFiles) {
  182   for (const auto &InputArg : InputArgv)

   90   for (const auto &Identifier : AArch64PreLegalizerCombinerHelperOption)

   85     while (*ChildIt != GT::child_end(Node)) {

  268     for (; I != E; ++I)

  212     for (; I != E; ++I)

  130       while (*Opt != GT::child_end(Node)) {

  109     for (auto *E : Edges)
  124     return (findEdgeTo(N) != Edges.end());

  406   while (first != last && store_and_advance(buffer_ptr, buffer_end,
  415   while (first != last) {
  419     while (first != last && store_and_advance(buffer_ptr, buffer_end,

  211   for (auto I = O, E = Vector.end(); I != E; ++I) {
  218     if (I != O) {

  127     while (VisitStack.back().second != GT::child_end(VisitStack.back().first)) {

  199     for (auto I = V.begin(); I != E; ++I)

  157   while (VisitStack.back().NextChild != GT::child_end(VisitStack.back().Node)) {

  322     while (this->I != End && !Pred(*this->I))
  607     return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
  720         std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
 1129   for (auto V : C)
 1225   return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);

   26        SI != SE; ++SI)

  151     for (; Start != End; ++Start)
  160       assert(I != vector_.end() && "Corrupted SetVector instances!");
  248     for (typename STy::const_iterator SI = S.begin(), SE = S.end(); SI != SE;
  261     for (typename STy::const_iterator SI = S.begin(), SE = S.end(); SI != SE;

  388     for (; I != E; ++I)

  203     for (; I != E; ++I)

  320   for (IteratorT I = Begin; I != End; ++I)
  324   while (++Begin != End) {

   45       for (auto It = Begin; It != End; ++It)

 1073   for (rpot_iterator I = rpot_begin(), E = rpot_end(); I != E; ++I) {
 1093   for (const LoopT *L : *LI)
 1107     for (const LoopT *L : *Loop)
 1235   for (rpot_iterator I = rpot_begin(), IE = rpot_end(); I != IE; ++I) {
 1272     for (const auto Succ : children<const BlockT *>(BB))
 1323          SI != SE; ++SI)

  160     for (NodeT Succ : make_range(GT::child_begin(Node), GT::child_end(Node))) {

  184       for (const auto Succ : children<BlockT *>(currentBB)) {
  197          NI != NE; ++NI) {

   67     for (BasicBlock *Node : Nodes)
   77     for (BasicBlock *Successor : Successors)

  146       while (SuccIt != EndIt) {                 // Loop over all interval succs
  185            E = GT::child_end(Node); I != E; ++I)
  215              E = IGT::child_end(Node); I != E; ++I) {
  238              End = GT::child_end(Node); It != End; ++It)

  211     for (const auto &Succ : children<const BlockT *>(BB)) {
  229     return std::find(PredBegin, PredEnd, BB) != PredEnd;
  238     for (const auto Pred : children<Inverse<BlockT *>>(H))
  317     for (const auto Pred : children<Inverse<BlockT *>>(H))
  443     assert(I != Blocks.end() && "N is not in this list!");
  485     for (auto *SubLoop : SubLoops)
  874     for (auto *L : TopLevelLoops)
  886     for (auto *L : TopLevelLoops)
  950     assert(I != end() && "Cannot remove end iterator!");
  972     assert(I != TopLevelLoops.end() && "Old loop not at top level!");

   38     for (const auto &Succ : children<BlockT *>(BB))
   66     for (const auto &Succ : children<BlockT *>(BB))
   91     for (BlockT *Predecessor : children<Inverse<BlockT *>>(EB))
  108     for (BlockT *Successor : children<BlockT *>(BB))
  145     for (const auto &Succ : children<BlockT *>(BB))
  175   if (SI != BlockTraits::child_end(Out))
  195   for (const auto Pred : children<Inverse<BlockT *>>(Header)) {
  213   for (const auto Pred : children<Inverse<BlockT *>>(Header)) {
  271   assert(I != SubLoops.end() && "OldChild not in loop!");
  338     for (auto BB : Blocks) {
  347   for (iterator I = begin(), E = end(); I != E; ++I)
  372   for (iterator I = begin(), E = end(); I != E; ++I)
  405   for (iterator I = begin(), E = end(); I != E; ++I)
  464       for (const auto Pred : children<Inverse<BlockT *>>(PredBB)) {
  547     for (const auto Backedge : children<Inverse<BlockT *>>(Header)) {
  592   for (LoopT *RootL : *this) {
  633   for (LoopT *SL : L)
  656   for (const LoopT *SubL : *L) {
  684   for (iterator I = begin(), E = end(); I != E; ++I) {
  696     for (LoopT *ChildLoop : *L)
  709   for (LoopT *L : OtherLI)
  715   for (LoopT *L : *this) {

  737     for (auto &SubR : *R)

   78     for (std::unique_ptr<RegionT> &Child : *R) {
   96     for (std::unique_ptr<RegionT> &Child : *R) {
  167   for (BlockT *Pred : make_range(InvBlockTraits::child_begin(entry),
  190        PI != PE; ++PI) {
  211   for (BlockT *Pred : make_range(InvBlockTraits::child_begin(exit),
  261   for (BlockT *Succ :
  269     for (BlockT *Pred : make_range(InvBlockTraits::child_begin(BB),
  286   for (BlockT *Succ :
  307   for (const std::unique_ptr<RegionT> &R : *this)
  385   for (std::unique_ptr<RegionT> &R : *this) {
  420   for (std::unique_ptr<RegionT> &R : *this) {
  443   assert(I != children.end() && "Region does not exit. Unable to remove.");
  468     for (BlockT *Pred : make_range(InvBlockTraits::child_begin(getExit()),
  480   for (BlockT *Pred : make_range(InvBlockTraits::child_begin(getExit()),
  516     for (const std::unique_ptr<RegionT> &R : *this)
  534   for (std::unique_ptr<RegionT> &R : *this)
  568   for (BlockT *P : make_range(InvBlockTraits::child_begin(BB),
  768   for (DomTreeNodeBase<BlockT> *C : *N) {
  859     for (BlockT *Pred : make_range(InvBlockTraits::child_begin(Exit),

  110       while (BlockTraits::child_end(node->getEntry()) != BItor && isExit(*BItor))
  146       while (BItor != BlockTraits::child_end(getNode()->getEntry())
  190     while (BlockTraits::child_end(Node->getEntry()) != Itor &&

  579     for (const auto &Abbrev : Abbrevs)

 1240     for(auto SizeAndAction: v) {

  624       while (Idx != EndIdx && Seg != EndSeg) {
  640         if (NotLessEnd != NotLessStart) {

  189     for (const Candidate &C : Candidates)
  216     for (Candidate &C : Candidates)

  175       for (const auto &NodeNum : Topo)
  370     for (SUnit *SU : *this) {

  574       for (auto AEId : adjEdgeIds(N1Id)) {
  636       for (auto AEId : adjEdgeIds(NId))

  202       for (auto EId : G.adjEdgeIds(NId)) {

   53     for (auto &C : Constraints)

  529            E = Nodes.end(); I != E; ++I)

  151       for (auto &X : Items) {
  160       for (auto &X : Items) {
  183       for (auto &Item : Items) {

   25     for (auto Visitor : Pipeline) {
   33     for (auto Visitor : Pipeline) {
   41     for (auto Visitor : Pipeline) {
   49     for (auto Visitor : Pipeline) {

   26     for (auto Visitor : Pipeline) {
   34     for (auto Visitor : Pipeline) {
   42     for (auto Visitor : Pipeline) {
   50     for (auto Visitor : Pipeline) {
   58     for (auto Visitor : Pipeline) {
   66     for (auto Visitor : Pipeline) {
   74     for (auto Visitor : Pipeline) {
  100     for (auto Visitor : Pipeline) {
  109     for (auto Visitor : Pipeline) {

  255       for (const auto &Entry : List.second.getEntries())
  263     for (const auto &Entry : List.second.getEntries())

  481     if (It != DieArray.end() && It->getOffset() == Offset)

   70       if (Iter != Begin)

  232       for (auto BLK : BaseLayerVModuleKeys)
  241       for (auto &BLK : BaseLayerVModuleKeys)

  118     for (const auto &CtorDtorName : CtorDtorNames) {

  158       for (auto &Frame : RegisteredEHFrames) {
  167       for (auto &ObjAllocs : Unmapped) {
  182       for (auto &ObjAllocs : Unfinalized) {
  197       for (auto &EHFrame : UnfinalizedEHFrames) {
  271       for (auto &Alloc : Allocs) {
  294         for (auto &Alloc : Allocs) {

  179     for (auto &Arg : Args)

  588     for (const auto &E : V)
  605     for (auto &E : V)

   54     for (auto &I : Items)

 1339       for (auto &Summary : GlobalList.second.SummaryList) {

   86       for (uint64_t Arg : P.first) {
  216     for (auto &FSum : FSums) {
  218       for (auto &RefGUID : FSum.Refs) {
  238       for (auto &Sum : P.second.SummaryList) {

  440     for (const std::unique_ptr<ResourceState> &Resource : Resources)

  157     for (const auto &AnalysisImpl : AnalysisImpls) {

  462     for (const FunctionRecord *F : Instantiations)

  531   for (auto Name : IterRange)
  563   if (Result != MD5NameMap.end() && Result->first == FuncMD5Hash)
  574   if (Result != MD5FuncMap.end() && Result->first == FuncMD5Hash)

  242   for (auto I = Begin; I != End; ++I)

  371     for (auto &ErrPayload : Payloads) {
  401         for (auto &Payload : E2List.Payloads)
  910     for (auto &P : List.Payloads)

  405     if (Begin != End) {
  411     while (Begin != End) {

  106     for (auto &R : Replacements) {

  104     for (const DomTreeNodeBase *I : *Other) {
  109     for (const DomTreeNodeBase *I : *this) {
  122     assert(I != IDom->Children.end() &&
  158       for (DomTreeNodeBase *C : *Current) {
  185        I != E; ++I)
  631       assert(I != IDom->Children.end() &&
  781     for (const auto &Pred : children<Inverse<N>>(NewBB))
  787     for (const auto &Pred : children<Inverse<N>>(NewBBSucc)) {

 1144     assert(ChIt != IDom->Children.end());
 1323     for (const NodePtr N : NumToNode) {
 1520       for (TreeNodePtr Child : TN->getChildren())
 1547       for (const TreeNodePtr N : Siblings) {
 1554         for (const TreeNodePtr S : Siblings) {

  199       for (auto DomChild : *Node) {

   89     for (unsigned i = 0; EI != EE && i != 64; ++EI, ++i) {
  103     if (EI != EE && hasEdgeSourceLabels)
  230     for (unsigned i = 0; EI != EE && i != 64; ++EI, ++i)
  233     for (; EI != EE; ++EI)

  165     for (const auto &V : C)

  874     if (this->canElideEmptySequence() && !(Val.begin() != Val.end()))
 1100     for (StringRef key : io.keys())

   88     for (char C : AggregateString) {

   41     for (const auto &Info : Err.Infos) {

  608       for (CallGraphNode *Node : *I)

  136     for (auto MapEntry : ConstGEPCandMap)
  140     for (auto MapEntry : ConstGEPInfoMap)

  198              E = Traits::BlkSucc_end(Info->BB); SI != E; ++SI) {

   65   for (auto &AA : AAs)
   92   for (AnalysisKey *ID : AADeps)
  112   for (const auto &AA : AAs) {
  128   for (const auto &AA : AAs)
  138   for (const auto &AA : AAs) {
  187   for (const auto &AA : AAs) {
  254   for (const auto &AA : AAs) {
  385   for (const auto &AA : AAs) {
  399   for (const auto &AA : AAs) {

  141        I1 != E; ++I1) {
  147     for (SetVector<Value *>::iterator I2 = Pointers.begin(); I2 != I1; ++I2) {
  177     for (Value *Load : Loads) {
  178       for (Value *Store : Stores) {
  204          I1 != E; ++I1) {
  205       for (SetVector<Value *>::iterator I2 = Stores.begin(); I2 != I1; ++I2) {
  232     for (auto Pointer : Pointers) {

  624   for (auto Cur : ASVector) {

  647   for (auto &I : Nodes)
  691   for (const auto *I : SCC)

  971     for (auto *BB : Scc) {

  559     if (RangePair.first != RangePair.second) {
  568       for (const auto &OVal : make_range(RangePair)) {
  618       for (auto &Edge : ValueInfo.getNodeInfoAtLevel(I).Edges) {
  684     for (const auto &AssignEdge : NodeInfo->Edges)
  688     for (const auto &RevAssignEdge : NodeInfo->ReverseEdges)
  752     for (const auto &Dst : WorkList) {
  796     for (const auto &Item : WorkList)

  218       for (auto &Edge : ValueInfo.getNodeInfoAtLevel(I).Edges)

   70   for (auto &Pass : Passes) {

  169   for (const auto &I : *this) {
  188     assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");
  215     assert(I != CalledFunctions.end() && "Cannot find callee to remove!");
  232     assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");

  171   for (CallGraphNode *CGN : CurSCC) {
  208                   : CurSCC) CGN->dump(););
  216        SCCIdx != E; ++SCCIdx, ++FunctionNo) {
  229     for (CallGraphNode::iterator I = CGN->begin(), E = CGN->end(); I != E; ) {
  388     for (CallGraphNode *CGN : CurSCC)
  428            I != E; ++I) {
  429         if (I != CurSCC.begin()) OS << ", ";
  650       for (CallGraphNode *CGN : SCC) {
  687   for (CallGraphNode *CGN : SCC) {

   70   for (auto &E : N.getEdges())
  156     for (auto *E : *N)

  522   for (auto BB : Callbacks) {

  475     for (auto *CGN : SCC)
  499       for (auto *Node : SCC)
  537            CI != E && !KnowNothing; ++CI)
  557       for (auto *Node : SCC)
  563     for (auto *Node : SCC) {

 1920     for (Loop *L : LI) {

   41   for (const BasicBlock *Node : Nodes)
   45   for (const BasicBlock *Predecessor : Predecessors)
   49   for (const BasicBlock *Successor : Successors)

   54        It != End; ++It)
   64   for (BasicBlock *Successor : Int->Successors)

  827     for (auto A : Accesses)
  862         for (auto AC : S) {
 1665              I1E = Accesses[*AI].end(); I1 != I1E; ++I1)
 1671                I2 != I2E; ++I2) {
 2412   for (Loop *TopLevelLoop : *LI)

  727          POI != POE; ++POI) {
  880       assert(I != end() && "Couldn't find loop");
  908     assert(I != ParentLoop->end() && "Couldn't find loop");

  112       for (const NonLocalDepEntry &I : NLDI) {

  807     for (auto &Entry : Cache)
  848     if (Entry != Cache.begin() && std::prev(Entry)->getBB() == DirtyBB)
  852     if (Entry != Cache.begin() + NumSortedEntries &&
  985   if (Entry != Cache->begin() && (Entry - 1)->getBB() == BB)
  989   if (Entry != Cache->begin() + NumSortedEntries && Entry->getBB() == BB)
 1136         for (auto &Entry : CacheInfo->NonLocalDeps)
 1156         for (auto &Entry : CacheInfo->NonLocalDeps)
 1179       for (auto &Entry : *Cache) {
 1193     for (auto &Entry : *Cache) {
 1547     for (auto &Entry : BlockMap)
 1628       for (auto &Entry : INLD.first) {
 1668       for (auto &Entry : NLPDI) {
 1713     for (const auto &Entry : DepKV.second.NonLocalDeps)
 1720     for (const auto &Entry : INLD.first)

  399       for (const auto *I : Instrs) {
  425     for (auto &VI : StoreRefEdges)
  433     for (auto &VI : LoadRefEdges)
  437     for (auto &VI : StoreRefEdges)
  539   for (auto &P : VTableFuncs) {

   42   for (const auto &E : R)

  119     for (const auto &RI : R)

 3849     for (const auto &VE : SI->second)
11484   for (Loop *I : *L)
11639   for (Loop *I : LI)

 1790       for (auto const &VOPair : *Set) {

  270     for (auto &Link : Links) {
  279     for (auto &Link : StratLinks) {

   33   for (auto &Node : SCC)
   39     for (auto &E : children_edges<CallGraphType>(Node)) {

 1558   return I != VectorDescs.end() && StringRef(I->ScalarFnName) == funcName;
 1568   while (I != VectorDescs.end() && StringRef(I->ScalarFnName) == F) {

   39   for (const_iterator i = begin(), e = end(); i != e; ++i) {

  130     for (const auto &Attr : Attrs)
  497   for (auto &MD : MDs)
 7511     for (auto TIDRef : FwdRefTIDs->second) {
 7600     for (auto P : I.second) {
 7618     for (auto TIDRef : FwdRefTIDs->second) {
 7941     for (auto VIRef : FwdRefVIs->second) {
 7952     for (auto AliaseeRef : FwdRefAliasees->second) {
 8353     for (auto P : I.second) {
 8440     for (auto P : I.second) {
 8489   for (auto &VC : VContexts) {
 8501     for (auto P : I.second) {
 8596     for (auto P : I.second) {
 8637     for (auto P : I.second) {
 8676     for (auto P : I.second) {

   59   for (auto &Item : Array)

  221         if (Stack.back().ArrayIt != Stack.back().Node.getArray().end())

 2914   for (uint64_t BitPos : DeferredMetadataInfo) {
 2985   for (auto &Pair : UpgradedVariables) {

  485     for (auto CU_SP : CUSubprograms)

  196           assert(It != ResolveConstants.end() && It->first == *I);

  194       for (auto &Summary : GUIDSummaryLists.second.SummaryList)
  454         for (auto &Summary : Summaries.second.SummaryList)
  745   for (ValueEnumerator::IndexAndAttrSet Pair : AttrGrps) {
 1095   for (const Comdat *C : VE.getComdats()) {
 1252     for (const auto P : M.getSourceFileName())
 2102     for (auto &Elt : IndexPos) {
 3630   for (auto &P : Summary) {
 4384   for (Module *M : Mods) {
 4562     for (const auto P : M.getSourceFileName())

  736   for (const Metadata *MD : MDs)

  162          SE = BB->succ_end(); SI != SE; ++SI)
  163     for (const auto &LI : (*SI)->liveins()) {

  721     for (const MachineBasicBlock *Succ : Visiting->successors())

   83   for (auto &Bucket : Buckets)
  252     for (auto &Hash : Bucket) {
  268     for (auto *Hash : Buckets[i]) {
  320     for (auto *HD : Buckets[i]) {
  333     for (auto &Hash : Buckets[i]) {
  345       for (const auto *V : Hash->Values)
  401     for (auto *Hash : Bucket) {
  402       for (auto *Value : Hash->Values) {
  445     for (auto *Hash : Bucket.value()) {
  503     for (auto *Hash : Bucket) {
  506       for (const auto *Value : Hash->Values)
  658   for (auto *Value : Values)
  667     for (auto *V : Entry.second.Values)
  672   for (auto &Bucket : Buckets)
  673     for (auto &Hash : Bucket)

 1289   for (auto &I : GlobalGOTEquivs) {
 1434       for (const auto &Stub : Stubs) {
 1451       for (const auto &Stub : Stubs) {
 2857   for (const MachineLoop *CL : *Loop) {
 2911       std::find(MBB.pred_begin(), MBB.pred_end(), MBB.getPrevNode()) !=

  549     for (auto I = RestrRegs.begin(), E = RestrRegs.end(); I != E; I++) {
  550       if(I != RestrRegs.begin())

  579   for (auto &P : FnDebugInfo)
 1084     for (auto Annot : FI.Annotations) {
 1102     for (auto HeapAllocSite : FI.HeapAllocSites) {
 1301   for (const auto &I : DbgValues) {
 2161   for (const ClassInfo::MemberInfo &IndirectField : NestedInfo.Members)
 2324   for (const DIDerivedType *I : Info.Inheritance) {
 2352   for (ClassInfo::MemberInfo &MemberInfo : Info.Members) {
 2397   for (auto &MethodItr : Info.Methods) {
 2430   for (const DIType *Nested : Info.NestedTypes) {

  142   for (DIEAbbrev *Abbrev : Abbreviations)

  340   for (const auto &VarRangePair : *this) {

  212   for (const auto &I : DbgValues) {
  269   for (const auto &I : DbgLabels) {

   75   for (const Function *Personality : MMI->getPersonalities()) {

 1068   for (const auto &P : CUMap) {
 1171   for (const auto &P : CUMap) {
 1514   for (const auto &I : DbgValues) {
 1588   for (const auto &I : DbgLabels) {
 2044   for (const auto &NU : CUMap) {
 2349   for (const auto &P : SectionRanges) {
 2378     for (const auto *RS : P.second) {
 2490   for (const SymbolCU &SCU : ArangeLabels) {
 2506   for (auto &I : SectionMap) {
 2579   for (DwarfCompileUnit *CU : CUs) {
 2616     for (const ArangeSpan &Span : List) {
 2762   for (const auto &P : CUMap) {

   93          I = FilterIds.begin(), E = FilterIds.end(); I != E; ++I) {

   57        FI != IE; ++FI) {
   82     for (GCFunctionInfo::iterator PI = MD.begin(), PE = MD.end(); PI != PE;
  113          LI != LE; ++LI) {

  117        I != IE; ++I) {
  122     for (GCFunctionInfo::iterator J = FI.begin(), JE = FI.end(); J != JE; ++J) {
  136        I != IE; ++I) {
  157     for (GCFunctionInfo::iterator J = FI.begin(), JE = FI.end(); J != JE; ++J) {
  173            K != KE; ++K) {

   46   for (const LandingPadInfo &Info : MF->getLandingPads()) {

   54   for (const Function *F : Functions)
   59   for (const MCSymbol *S : LongjmpTargets) {

  433     for (MachineBasicBlock::RegisterMaskPair P : NewDest.liveins()) {
  744        CurMPIter != B && CurMPIter->getHash() == CurHash; --CurMPIter) {
  933     for (MachineBasicBlock *Pred : MBB->predecessors()) {
 1146     for (MachineBasicBlock *PBB : I->predecessors()) {
 1230   for (const auto &Src : SameTails) {
 1243          SuccI != SuccE; ++SuccI, ++EdgeFreq)
 1259          SuccI != SuccE; ++SuccI, ++EdgeFreq) {
 1379   for (MachineBasicBlock *SuccBB : MBB.successors())
 1385   for (MachineBasicBlock *PredBB : MBB.predecessors())
 1748       for (MachineBasicBlock *PredBB : MBB->predecessors()) {
 1780       for (MachineBasicBlock *SuccBB : MBB->successors()) {
 1845   for (MachineBasicBlock *SuccBB : BB->successors())

  459     for (const MachineBasicBlock *Succ : MBB->successors()) {
  460       for (const MachineBasicBlock::RegisterMaskPair &LiveIn : Succ->liveins())

  234     for (auto *Succ : CurrentInfo.MBB->successors()) {
  314     for (MachineBasicBlock *Succ : CurrMBB->successors()) {

 1893       if (it != LargeOffsetGEPMap.end()) {
 5283   for (auto &Entry : LargeOffsetGEPMap) {
 6214   for (auto *I : MaybeDead) {
 6892   for (GetElementPtrInst *UGEPI : UGEPIs) {
 6900   for (GetElementPtrInst *UGEPI : UGEPIs) {

   72          SE = BB->succ_end(); SI != SE; ++SI)
   73     for (const auto &LI : (*SI)->liveins()) {

   69   for (auto U : InsnClass)
  184   for (auto &M : Mutations)
  214       for (MachineInstr *MI : CurrentPacketMIs) {
  246   for (SUnit &SU : VLIWScheduler->SUnits)
  288       for (auto MJ : CurrentPacketMIs) {

  117            E = MBB.succ_end(); S != E; S++)
  118       for (const auto &LI : (*S)->liveins())

   48            SE = MBB.succ_end(); SI != SE; ++SI)
   88            SE = MBB.succ_end(); SI != SE; ++SI)

  169   for (MachineBasicBlock *pred : MBB->predecessors()) {
  215   for (DomainValue *OldLiveReg : MBBOutRegsInfos[MBBNumber]) {
  462     for (DomainValue *OutLiveReg : OutLiveRegs) {

   92   for (auto &Fault : FFI) {

  114        RI != RE; ++RI)
  118   for (GCFunctionInfo::iterator PI = FD->begin(), PE = FD->end(); PI != PE;

  294        RI != FI->roots_end();) {

 1106   for (auto CopyTy : MemOps) {
 1211   for (auto CopyTy : MemOps) {

  473     for (const CaseCluster &C : Clusters) {
  679        SI != SE; ++SI) {
 2174   for (auto &JTCase : SL->JTCases) {
 2391   for (const MachineBasicBlock::RegisterMaskPair &LiveIn : EntryBB->liveins())

  350         for (SizeAndAction BitsizeAndAction : VectorSpecifiedActions.second) {
  570   assert(It != Vec.begin() && "Does Vec not start with size 1?");
  721     for (unsigned Opcode : FailedOpcodes)

  811     for (auto &Succ : Src.successors())

  191   for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I) {
  204   for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)

  613   for (MachineBasicBlock *SuccBB : BB->successors()) {
 1455   for (const MachineBasicBlock *Predecessor : MBB.predecessors()) {
 1645       for (MachineBasicBlock *PBB : CvtMBB.predecessors()) {
 1712     if (NewTrueBBIter != BBI.BB->succ_end())
 2215     for (MachineBasicBlock *Succ : Succs) {

  500       for (MachineBasicBlock *P : MBB->predecessors()) {
 1467   for (auto &Ent : MergeableSpills) {

  124        E = Queue.end(); I != E; ++I)
  128   if (Best != std::prev(Queue.end()))
  137   assert(I != Queue.end() && "Queue doesn't contain the SU being removed!");
  138   if (I != std::prev(Queue.end()))
  147   for (const SUnit *SU : Queue) {

 1144   for (auto p : MBB.predecessors()) {
 1391           for (auto s : MBB->successors())

 1209   for (auto &Pair : NewLocations) {

 1331            PE = MBB->pred_end(); PI != PE; ++PI)

  327     for (const auto &LI : MBB.liveins()) {
  401       for (const MachineBasicBlock *Pred : MBB->predecessors()) {
  417     for (const MachineBasicBlock *Pred : MBB->predecessors()) {
  647   for (MachineBasicBlock *Succ : KillMBB->successors()) {
  846     for (const MachineBasicBlock *Pred : PHIMBB->predecessors())

  158   for (const auto &LI : MBB.liveins()) {
  194     for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
  205   for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
  213   for (const MachineBasicBlock *Succ : MBB.successors())
  227       for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())

  286     for (MachineBasicBlock *S : B.successors())
  295   for (MachineBasicBlock *P : MBB.predecessors())
  338     for (MachineBasicBlock *P : B.predecessors())
  386     for (MachineBasicBlock *Pred : MBB->predecessors()) {
  518         for (MachineBasicBlock *Pred : MBB->predecessors()) {
  602     for (const MachineBasicBlock *P : B->predecessors())

   87   for (const auto &LI : MBB.liveins())
  110     for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
  121   for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())
  132   for (const MachineBasicBlock *Succ : MBB.successors())

  178          E = MBB->pred_end(); PI != E; ++PI)
  567   for (const auto &LI : MBB->liveins()) {
  602          SE = MBB->succ_end(); SI != SE; ++SI) {
  606     for (const auto &LI : SuccMBB->liveins()) {
  747   for (const MachineBasicBlock *SuccMBB : MBB.successors()) {

   46       for (MachineBasicBlock *Succ : ActiveMBB->successors()) {

  107   for (auto *II : instructions) {
  123   for (auto &II : StringInstrMap) {
  167   for (auto *II : Instructions) {
  183   for (auto *II : Instructions) {
  316   for (MachineInstr *MI : Copies) {
  343     for (auto *MO : Uses)
  386   if (llvm::find(bbNames, MBB->getName()) != bbNames.end()) {
  437     for (auto *MO : RenameMOs) {
  470            : RPOList) { dbgs() << MBB->getName() << "\n"; } dbgs()
  481   for (auto MBB : RPOList)

  348   for (auto YamlCSInfo : YamlMF.CallSitesInfo) {
  368     for (auto ArgRegPair : YamlCSInfo.ArgForwardingRegs) {
  503   for (const auto &VReg : YamlMF.VirtualRegisters) {
  543   for (const auto &LiveIn : YamlMF.LiveIns) {
  562     for (const auto &RegSource : YamlMF.CalleeSavedRegisters.getValue()) {
  665   for (const auto &Object : YamlMF.FixedStackObjects) {
  692   for (const auto &Object : YamlMF.StackObjects) {
  815   for (const auto &YamlConstant : YamlMF.Constants) {
  841   for (const auto &Entry : YamlJTI.Entries) {
  843     for (const auto &MBBSource : Entry.Blocks) {

  410   for (const auto &CSInfo : MFI.getCalleeSavedInfo()) {
  504   for (const MachineConstantPoolEntry &Constant : ConstantPool.getConstants()) {
  528   for (const auto &Table : JTI.getJumpTables()) {
  532     for (const auto *MBB : Table.MBBs) {
  653     for (auto I = MBB.succ_begin(), E = MBB.succ_end(); I != E; ++I) {
  654       if (I != MBB.succ_begin())
  672     for (const auto &LI : MBB.liveins()) {

  163   for (auto &vreg : VRegs) {
  195     if (llvm::find(renamedInOtherBB, Reg) != renamedInOtherBB.end()) {
  241     for (auto *MO : RenameMOs) {
  265   for (auto candidate : Candidates) {

  238   for (const_succ_iterator I = succ_begin(), E = succ_end(); I != E; ++I)
  348     for (auto I = pred_begin(), E = pred_end(); I != E; ++I) {
  349       if (I != pred_begin())
  361     for (auto I = succ_begin(), E = succ_end(); I != E; ++I) {
  362       if (I != succ_begin())
  373       for (auto I = succ_begin(), E = succ_end(); I != E; ++I) {
  375         if (I != succ_begin())
  395     for (const auto &LI : liveins()) {
  469   return I != livein_end() && (I->LaneMask & LaneMask).any();
  554       for (succ_iterator SI = succ_begin(), SE = succ_end(); SI != SE; ++SI) {
  594   for (succ_iterator SI = succ_begin(), SE = succ_end(); SI != SE; ++SI) {
  644   for (auto Prob : Probs)
  678   assert(OldI != succ_end() && "Old is not a successor of this block!");
  701   assert(I != Successors.end() && "Not a current successor!");
  724   for (succ_iterator I = succ_begin(); I != E; ++I) {
  727       if (NewI != E)
  732       if (OldI != E)
  736   assert(OldI != E && "Old is not a successor of this block");
  770   assert(I != Predecessors.end() && "Pred is not a predecessor of this block!");
  987   for (const auto &LI : Succ->liveins())
 1271   while (SI != succ_end()) {
 1339     for (auto &P : Probs) {
 1412     for (MachineBasicBlock *S : successors()) {
 1413       for (const MachineBasicBlock::RegisterMaskPair &LI : S->liveins()) {
 1468     for (const MachineBasicBlock::RegisterMaskPair &LI : liveins())

  603   for (MachineBasicBlock *Succ : MBB->successors()) {
  650   for (MachineBasicBlock *Succ : BB->successors()) {
  698   for (MachineBasicBlock *Succ : BB.successors())
  794   for (MachineBasicBlock *SuccPred : Succ->predecessors()) {
  906     for (auto SuccPred : Succ->predecessors()) {
  910         for (MachineBasicBlock *CheckSucc : SuccPred->successors())
 1005     for (MachineBasicBlock *SuccPred : Succ->predecessors()) {
 1079   for (MachineBasicBlock *Pred : Succ->predecessors()) {
 1177     for (MachineBasicBlock *Succ : BB.successors()) {
 1197     for (MachineBasicBlock* Pred : PDom->predecessors()) {
 1419   for (MachineBasicBlock *Pred : Succ->predecessors()) {
 1683     for (MachineBasicBlock *Pred : ChainBB->predecessors()) {
 1809   for (MachineBasicBlock *Pred : Top->predecessors()) {
 1817       for (MachineBasicBlock *Succ : Pred->successors()) {
 1877    for (MachineBasicBlock *Pred : NewTop->predecessors()) {
 1895      for (MachineBasicBlock *Succ : BestPred->successors()) {
 1968   for (MachineBasicBlock *Pred : OldTop->predecessors()) {
 2087     for (MachineBasicBlock *Succ : MBB->successors()) {
 2173   for (MachineBasicBlock *Pred : Top->predecessors()) {
 2181       for (MachineBasicBlock *Succ : Pred->successors()) {
 2224     for (MachineBasicBlock *Succ : Bottom->successors()) {
 2311   for (auto *Pred : ChainHeaderBB->predecessors()) {
 2333     for (auto *Succ : BB->successors()) {
 2441     for (auto LoopPred : L.getHeader()->predecessors())
 2467   for (const MachineLoop *InnerLoop : L)
 2593   for (MachineLoop *L : *MLI)
 2964     for (MachineBasicBlock *NewSucc : Pred->successors()) {
 3148     for (MachineBasicBlock *Succ : MBB.successors()) {

   66        E = MBB->succ_end(); I != E; ++I) {

  751     for (MachineDomTreeNode *Child : Children)
  858     for (MachineDomTreeNode *Child : Children)

  105     for (MachineBasicBlock *PredBB : Succ->predecessors()) {

  129   for (auto &I : getCalleeSavedInfo())

  502          I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {
  506       if (std::next(I) != E)
  803        E = FilterEnds.end(); I != E; ++I) {

  511     for (const auto &LI : BB->liveins()) {
 1351   for (const MachineInstr *PrevMI : PrevMIs)

  124   for (MachineBasicBlock *P : HB->predecessors()) {
  135   for (MachineBasicBlock *S : Preheader->successors()) {

  554           for (SuffixTreeNode *Leaf : LeafChildren)
  908     for (const Candidate &C : OF.Candidates)
 1019     for (const unsigned &StartIdx : RS.StartIndices) {
 1204   for (OutlinedFunction &OF : FunctionList) {
 1229     for (Candidate &C : OF.Candidates) {

  223   for (auto &L : *MLI)
  235   for (auto &InnerLoop : L)
  664   for (auto &SU : SUnits) {
  760   for (SUnit &I : SUnits) {
  843   for (SUnit &I : SUnits) {
 1288   for (SUnit &SU : DAG->SUnits) {
 1369          I != E; ++I) {
 1379        I != E; ++I) {
 1450        I != E; ++I) {
 1483        I != E; ++I) {
 1550   for (SUnit *SU : NS) {
 1564   for (SUnit *SU : NS)
 1600     for (auto &SU : SUnits) {
 1777         for (NodeSet::iterator NII = J->begin(), ENI = J->end(); NII != ENI;
 1831       for (auto &N : Nodes)
 1839       for (SUnit *SU : Nodes) {
 1952     for (SUnit *I : NodeOrder)
 2036     } while (++NI != NE && scheduleFound);
 2275   for (auto &M : Mutations)
 2863   for (const auto &I : Nodes)

  213   for (auto &I : LiveIns)
  443   for (livein_iterator I = livein_begin(), E = livein_end(); I != E; ++I)
  452   for (livein_iterator I = livein_begin(), E = livein_end(); I != E; ++I)
  461   for (livein_iterator I = livein_begin(), E = livein_end(); I != E; ++I)

  165          E = BB->pred_end(); PI != E; ++PI) {
  285            E = BB->pred_end(); PI != E; ++PI)

  598   for (const SUnit *SU : Queue)
  821   for (auto &m : Mutations)
  828   for (SUnit &SU : SUnits) {
  894          DI = DbgValues.end(), DE = DbgValues.begin(); DI != DE; --DI) {
  995   for (SUnit &SU : SUnits)
 1061                   : RegionCriticalPSets) dbgs()
 1167   for (const SUnit &SU : SUnits) {
 1602   for (SUnit &SU : DAG->SUnits) {
 1823   for (SUnit &SU : DAG->SUnits) {
 1892   for (SUnit &SU : DAG->SUnits) {
 2392     for (ReadyQueue::iterator I = Available.begin(); I != Available.end();) {
 2845   for (const SUnit *SU : Bot.Available) {
 3111   for (SUnit *SU : Q) {
 3401   for (SUnit *SU : Q) {

  328     for (auto &Pair : ToSplit) {
  525            E = ToBB->pred_end(); PI != E; ++PI) {
  602   for (const auto &DTChild : Children)
 1120   for (auto *SI : CurBB.successors()) {
 1229   for (MachineBasicBlock *SI : CurBB.successors())

  335   for (const MachineBasicBlock *Pred : MBB->predecessors()) {
  359   for (const MachineBasicBlock *Succ : MBB->successors()) {
  536       for (const MachineBasicBlock *Pred : MBB->predecessors()) {
  561       for (const MachineBasicBlock *Succ : MBB->successors()) {

  571            SuE = MBB->succ_end(); SuI != SuE; ++SuI)
  625     for (const auto &LI : MBB->liveins()) {
  637        E = MBB->succ_end(); I != E; ++I) {
  651        E = MBB->pred_end(); I != E; ++I) {
  799     for (const auto &LI : MBB->liveins()) {
 2146            SuE = MBB.succ_end(); SuI != SuE; ++SuI) {
 2160            SuE = MBB->succ_end(); SuI != SuE; ++SuI) {
 2179            PrE = MBB.pred_end(); PrI != PrE; ++PrI) {
 2193            PrE = MBB->pred_end(); PrI != PrE; ++PrI) {
 2259       for (MachineBasicBlock *Pred : MBB.predecessors()) {
 2635          PE = MFI->pred_end(); PI != PE; ++PI) {
 2807          E = MBB->pred_end(); I != E; ++I) {
 2823          E = MBB->succ_end(); I != E; ++I) {

  102       for (SUnit &SU : DAG.SUnits) {
  135     for (SUnit &ISU : DAG->SUnits)

   25   for (MachineInstr *MI : ScheduledInstrs)
  265   assert(LoopExitI != KernelBB->succ_end() && "Expecting a successor");
 1957   for (auto *L : MLI) {

  490              SE = opBlock.succ_end(); SI != SE; ++SI) {
  662     for (const MachineBasicBlock *SI : MBB->successors())

  443   for (auto &M : Mutations)
  694          DI = DbgValues.end(), DE = DbgValues.begin(); DI != DE; --DI) {

  336          i = FrameSDOps.begin(), e = FrameSDOps.end(); i != e; ++i) {
  411     for (auto &CS : CSI) {
  498     for (MachineBasicBlock *SuccBB : CurBB->successors())

   41     for (const auto &LI : MBB->liveins()) {
   55   for (MachineBasicBlock *pred : MBB->predecessors()) {
   90   for (int &OutLiveReg : MBBOutRegsInfos[MBBNumber])
  159     for (MBBRegUnitDefs &RegUnitDefs : MBBDefs)

 1255   for (const MachineBasicBlock::RegisterMaskPair LI : MBB.liveins())

  550     for (MachineLoop *L : *Loops) {
 3148   for (MachineLoop *SubLoop : *L) {

 1058   for (MachineBasicBlock *Pred : MBB.predecessors()) {

  324         for (MachineBasicBlock *PredMBB : MBB.predecessors()) {

  393   for (const SUnit &SUnit : SUnits) {
  480   for (SUnit &SU : SUnits) {
  514   for (SUnit &SU : SUnits)  {
  698   for (unsigned LI : L) {

  218     for (const MachineBasicBlock *Succ : BB->successors()) {
  219       for (const auto &LI : Succ->liveins()) {
  631     if (Itr != end()) {
  650     for (auto &I : *this)
  663   for (auto &I : Val2SUsMap)
  672   if (Itr != Val2SUsMap.end())
  680   for (auto &I : map) {
  692   for (Value2SUsMap::iterator I = map.begin(), EE = map.end(); I != EE;) {
 1022   for (auto &Itr : *this) {
 1048   for (auto &I : stores)
 1051   for (auto &I : loads)
 1166   for (const SUnit &SU : SUnits)
 1339     for (const std::pair<const SUnit*, const SUnit*> &P : ConnectionPairs) {

12498   for (auto *U : Users) {

  222   for (auto &P : FuncInfo.PHINodesToUpdate)
 1173   for (auto &Arg : CLI.getArgs()) {

  187           for (TargetLowering::AsmOperandInfo &Op : Ops) {

  593     for (auto I = std::next(Queue.begin()), E = Queue.end(); I != E; ++I) {
  603     for (auto I = std::next(Queue.begin()), E = Queue.end(); I != E; ++I)
  609   if (Best != std::prev(Queue.end()))
  621   if (I != std::prev(Queue.end()))

 1812     if (I != std::prev(Queue.end()))
 1842   for (auto I = std::next(Q.begin()), E = Q.end(); I != E; ++I)
 1846   if (Best != std::prev(Q.end()))
 2012   for (const SUnit &SU : *SUnits)
 2808     for (SUnit &SU : sunits)
 2942   for (SUnit &SU : *SUnits) {
 3054   for (SUnit &SU : *SUnits) {

  697   for (const SUnit &SU : SUnits)

 8438   for (auto N : TopoOrder) {

 1144   for (auto &DDIMI : DanglingDebugInfoMap) {
 1149     for (auto &DDI : DDIV)
 1166   for (auto &DDI : DDIV) {
 1362   for (auto &Pair : DanglingDebugInfoMap)
 1363     for (auto &DDI : Pair.second)
 7744     for (const auto &Code : Codes)
 8058   for (auto &T : TargetConstraints) {
10176              SI != SE; ++SI) {
10483   for (CaseCluster &CC : Clusters) {
10537     for (const CaseCluster &C : Clusters) {

 1774   for (auto &BTB : SDB->SL->BitTestCases) {

  872   for (const GCRelocateInst *Relocate : ISP.getRelocates()) {

 4192   for (InlineAsm::ConstraintInfo &CI : IA->ParseConstraints()) {

  316   for (MachineBasicBlock *BB : BBs) {

   83   for (const MachineBasicBlock *SMBB : MBB.successors())
 1244   for (MachineBasicBlock *P : B.predecessors()) {
 1460     for (const MachineBasicBlock *Pred : MBB.predecessors()) {

  645              PE = MBB->pred_end(); PI != PE; ++PI) {
  776            PE = BB->pred_end(); PI != PE; ++PI) {

  178   for (const auto &CSI : CSInfos) {
  357   if (CurrentIt != FnInfos.end())
  441   for (auto const &FR : FnInfos) {
  457   for (const auto &ConstEntry : ConstPool) {
  495   for (const auto &CSI : CSInfos) {

  183       for (auto *Pred : MBB->predecessors()) {

   49   for (CaseCluster &C : Clusters)
  237   for (MachineBasicBlock *Succ : Table) {
  269   for (const CaseCluster &C : Clusters)
  444   for (auto &CB : CBV) {
  461   for (const CaseCluster &CC : Clusters)

  637   for (auto SB : TailBB.successors()) {
  675   for (MachineBasicBlock *BB : A.successors())
  683   for (MachineBasicBlock *PredBB : BB.predecessors()) {
  865     for (MachineBasicBlock *Succ : TailBB->successors())

   72   for (const CalleeSavedInfo &Info : MFI.getCalleeSavedInfo())

  129       while (BB->succ_begin() != BB->succ_end()) {

  726   for (auto &Funclets : FuncletBlocks) {
  737     for (BasicBlock *BB : BlocksInFunclet) {
  769     for (auto &BBMapping : Orig2Clone) {
  799     for (BasicBlock *BB : BlocksInFunclet)
  808     for (auto &BBMapping : Orig2Clone) {
  851     for (auto &BBMapping : Orig2Clone) {
  864     for (auto &BBMapping : Orig2Clone) {
  933   for (auto &Funclet : FuncletBlocks) {
  941     for (BasicBlock *BB : BlocksInFunclet) {

   92   for (auto C : Fragments)

  254     for (auto V : Value) {

   95   for (const auto &FC : Checksums) {

   86   for (const auto &Item : Ids) {

   91   for (const auto &E : Entries) {

  113   for (const auto &B : Blocks) {
  139   for (const auto &B : Blocks) {

   23   for (const auto &Record : Records) {

  103   for (auto C : Fragments)

  120   for (auto C : Fragments)

  215   for (auto Entry : EnvBlock.Fields) {
  595   for (auto FuncID : Caller.Indices)
  642   for (StringRef Str : Annot.Strings)

  486     for (auto Name : Record.MethodNames)

  411   for (const auto &Attr : Attributes)
  527   for (const auto &Attr : Abbr.Attributes)

  142   for (auto &Contribution : Contributions) {
 1142   for (uint32_t RowIndex : RowVector) {
 1698     for (SectionName &S : SectionNames)
 1750     for (auto &P : InfoDWOSections)
 1755     for (auto &P : TypesDWOSections)
 1804     for (auto &P : InfoSections)
 1809     for (auto &P : TypesSections)

   51   for (const auto &Decl : Decls)
   59     for (const auto &Decl : Decls) {

  154     for (uint64_t Addr : Addrs)

  107   for (const auto &Desc : ArangeDescriptors) {

   31     for (const auto &Desc : Set.descriptors()) {
   60         for (const auto &R : *CURanges)
   87   for (const auto &E : Endpoints) {
  119   if (It != Aranges.end() && It->LowPC <= Address)

  276   for (const auto &Instr : Instructions) {
  538   if (It != Entries.end() && (*It)->getOffset() == Offset)
  552   for (const auto &Entry : Entries)

  460     for (const Row &R : Rows) {
  998   while (SeqPos != LastSeq && SeqPos->LowPC < EndAddr) {

   49   for (const Set &S : Sets) {
   57     for (const Entry &E : S.Entries) {

   61   for (const RangeListEntry &RLE : Entries) {
   73   for (const RangeListEntry &RLE : Entries) {

  118   for (const RangeListEntry &RLE : Entries) {

   69   for (const DWARFAddressRange &R : Ranges) {
  513   for (const auto &R : RangesOrError.get())

  102     for (const auto &Off : Offsets) {

  606       for (const auto &R : DIERangesOrError.get()) {

   35   if (Pos != End) {
   38     if (Pos != Begin) {
   69   while (I1 != E1) {
   89   while (I1 != E1 && I2 != E2) {
   89   while (I1 != E1 && I2 != E2) {
  244     for (auto AbbrDecl : *AbbrDecls) {
  394     for (auto Range : Ranges) {
  713     for (const auto &FileName : LineTable->Prologue.FileNames) {
  749     for (const auto &Row : LineTable->Rows) {
 1015   for (const BucketInfo &B : BucketStarts) {
 1150     for (const auto &AttrEnc : Abbrev.Attributes) {
 1455       for (const DWARFDebugInfoEntry &Die : CU->dies())

  100   for (const auto &FuncInfo : Funcs) {
  126   for (auto File: Files) {
  138   for (const auto &FuncInfo : Funcs) {
  150   for (auto AddrInfoOffset: AddrInfoOffsets) {
  193   while (Curr != Funcs.end()) {
  196     if (Prev != Funcs.end()) {
  262   for (auto &FI : Funcs) {
  271   for (const auto &FI : Funcs) {

   25   for (auto Range : II.Ranges) {
   34   for (const auto &Child : II.Children)
   47     for (const auto &Child : II.Children) {
  140     for (const auto &Child : Children) {
  143       for (const auto &ChildRange: Child.Ranges) {

  139     for (const auto &line_entry : Lines) {
  146         if (Pos != End && Pos->Delta == LineDelta)
  201   for (const auto &Curr : Lines) {
  284   for (const auto &LineEntry : LT)

   26   while (It2 != Ranges.end() && It2->Start < Range.End)
   28   if (It != It2) {
   32   if (It != Ranges.begin() && Range.Start < It[-1].End)
   42   return It != Ranges.begin() && Addr < It[-1].End;
   89   for (auto Range : Ranges)
  100   for (auto &Range : Ranges)

   87   for (auto B : DirectoryBlocks)
  241   for (const auto &D : StreamData) {
  375   for (const auto &Blocks : Layout.StreamMap) {

  100     for (auto &Entry : CacheIter->second) {
  285     for (const auto &Alloc : MapEntry.second) {

   29     for (uint8_t c : Checksum)

   91   for (const auto &Builder : C13Builders) {
  158     for (ArrayRef<uint8_t> Syms : Symbols) {
  165     for (const auto &Builder : C13Builders) {

  139   for (const auto &M : ModiList)
  164   for (const auto &M : ModiList)
  210   for (const auto &MI : ModiList) {
  228   for (const auto &MI : ModiList) {
  258   for (auto &MI : ModiList)
  321   for (auto &MI : ModiList) {
  403   for (auto &M : ModiList) {

   89   for (const auto &Sym : Records)
  137   for (const CVSymbol &Sym : Records) {
  180     for (const auto &Entry : Bucket)
  270   for (auto &Sym : PublicsByAddr) {

   76   for (auto E : Features) {

  169   for (TypeIndex TI : HashMap[Bucket]) {
  194   for (TypeIndex TI : HashMap[BucketIdx]) {

  155   for (auto Rec : TypeRecords) {
  171     for (auto &IndexOffset : TypeIndexOffsets) {

  134   for (auto &LI : LayoutItems) {
  205   for (auto &Base : Bases) {
  226   for (auto &Data : Members) {
  235   for (auto &VB : VirtualBaseSyms) {
  270   for (BaseClassLayout *BL : AllBases) {

   74   for (auto &P : Symbols)
   93     while (I != E) {
   95       while (++I != E && OI->first.Addr == I->first.Addr) {
  148   for (auto I = ExportSyms.begin(), E = ExportSyms.end(); I != E; ++I) {
  151     uint32_t NextOffset = I != E ? I->Offset : Export.Offset + 1;

  296   for (const auto &Path : Opts.DsymHints) {
  299   for (const auto &Path : DsymPaths) {

   48     for (void *Allocation : Allocations)

   30     for (auto *B : Blocks)
   31       for (auto &E : B->edges())

  166       for (auto &E : Sym->getBlock().edges()) {

  131   for (auto &P : Passes)
  174         for (auto *B : *SIEntry.first)
  196     for (auto *B : SegLists.ContentBlocks) {
  205     for (auto *B : SegLists.ZeroFillBlocks) {
  247       for (auto *B : *SIList) {
  322     for (auto &E : Sym->getBlock().edges()) {
  337     for (auto *Sym : SymbolsToRemove) {
  350     for (auto *B : BlocksToRemove) {

  168       for (auto *B : SegLayout.ContentBlocks) {
  202         for (auto &E : B->edges()) {

  665   for (JITEventListener *L : EventListeners)

  234   for (auto *GV : GVsToAdd)
  289           for (auto &GV : PromotedGlobals)

  214     for (auto &KV : make_range(std::next(JDs.begin()), JDs.end())) {
  742     assert(I != DefGenerators.end() && "Generator not found");
  763         for (auto &SI : AddedSyms)
  978       for (auto &Q : MI.takeQueriesMeeting(SymbolState::Resolved)) {
 1093             for (auto &Q : DependantMI.takeQueriesMeeting(SymbolState::Ready)) {
 1109         for (auto &Q : MI.takeQueriesMeeting(SymbolState::Ready)) {
 1231       for (auto &Q : MII->second.pendingQueries()) {
 1278     if (I != SearchOrder.end())
 1289     if (I != SearchOrder.end())
 1332     for (auto &SymbolMaterializerItrPair : SymbolsToRemove) {
 1357     for (auto &DG : DefGenerators) {
 1409   for (auto &DG : DefGenerators) {
 1510   for (auto &Name : ToRemove)
 1531     for (auto &DG : DefGenerators) {
 1566     for (auto &MU : MUs)
 1635   for (auto &Name : ToRemove)
 1646     for (auto &KV : SearchOrder)
 1678       for (const auto &Q : KV.second.pendingQueries())
 1709   assert(I != PendingQueries.end() &&
 1762   for (auto &S : MUDefsOverridden)
 1766   for (auto &S : ExistingDefsOverridden) {
 1833     for (auto &JD : JDs)
 1959       for (auto &KV : SearchOrder) {
 1985         for (auto &MU : KV.second)
 2018       for (auto &MU : KV.second)
 2113     for (auto &JD : JDs)

  124     for (auto &Name : KV.second) {
  135       for (auto &Name : KV.second) {
  150   for (auto &P : CXXDestructorDataPairs)

   63   for (const auto &F : FeatureVec)

  210       for (auto &E : Sym->getBlock().edges()) {
  251         for (auto &E : Sym->getBlock().edges()) {
  272       for (auto &WLEntry : Worklist) {
  339   for (auto &P : Plugins)
  344   for (auto &P : Plugins)
  351   for (auto &P : Plugins)
  368   for (auto &P : Plugins)
  389   for (auto &P : Plugins)

  245     for (auto &DtorRunner : IRStaticDestructorRunners)
  498     for (auto &Listener : EventListeners)
  505     for (auto &Listener : EventListeners)

  392     for (object::OwningBinary<object::Archive> &OB : Archives) {

  144   for (auto &Frame : EHFrames)

  740   for (auto &Sym : SymbolsToAllocate) {

   68   for (std::string &S : Args)
  132   for (std::string &S : Args)

   57   for (const auto &Getter : AllowedTypes)
   62   for (const auto &Strategy : Strategies)

  539   for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) {
 2621   for (const Comdat *C : Comdats) {
 2690   for (auto &ModPair : moduleVec) {
 2705     for (auto &Summary : GlobalList.second.SummaryList)
 2819   for (auto &P : TI) {
 2831   for (auto arg : Args) {
 2991     for (auto &GUID : TIDInfo.TypeTests) {
 3055   for (auto &VFuncId : VCallList) {
 3066   for (auto &ConstVCall : VCallList) {
 4138   for (const auto &I : asVec)

  105   for (const auto &I : AllMacrosPerParent) {

   60   for (auto *I : DistinctMDNodes)
   74   for (MDNode *I : DistinctMDNodes)

  113   for (auto *PassInf : PassesToPrint) {
  460     for (auto &OnTheFlyManager : OnTheFlyManagers) {
  850   for (const PassInfo *ImmPI : PassInf->getInterfacesImplemented())
 1720   for (auto &OnTheFlyManager : OnTheFlyManagers) {
 1781   for (auto &OnTheFlyManager : OnTheFlyManagers) {
 1935   for (PMDataManager *Manager : S)

   70     for (auto &GlobSummary : GlobalList.second.SummaryList) {
  159     for (auto &S : P.second.SummaryList) {
  205     for (const ValueInfo V : *I) {
  260   for (auto &A : Attrs)
  479   for (auto &E : CrossModuleEdges) {
  487     for (auto DstMod : ModList)

   66   for (auto *Listener : Listeners)

   51   for (auto &Entry : DetailedSummary) {

 2093   for (const auto &Pair : SiblingFuncletInfo) {

  125   for (auto &A : Conf.MAttrs)
  260         for (uint64_t Arg : ByArg.first)
  367     for (auto &S : I.second.SummaryList)
  390   for (auto &S : GVSummaryList) {
  781   for (GlobalValue *GV : Mod.Keep) {
  880     for (auto &S : P.second.SummaryList) {
  934   for (auto &M : RegularLTO.ModsWithSummaries)
 1281   for (auto &Mod : ThinLTO.ModuleMap)
 1367   for (auto &Mod : ThinLTO.ModuleMap) {

  132   for (const std::string &A : Conf.MAttrs)
  472   for (GlobalValue *GV : DeadGVs) {
  528     assert(I != ModuleMap.end());

  638     for (std::string &Arg : CodegenOptions)

  645   for (const NameAndAttributes &Sym : _symbols) {

  110   if (StrongDefForLinker != GVSummaryList.end())
  145   for (auto &M : Modules) {
  569   for (auto &Mod : Modules) {
  913     for (auto &Mod : Modules) {
  964   for (const auto &M : Modules)
 1016   for (auto &Module : Modules) {
 1041     for (auto IndexCount : ModulesOrdering) {

   42        I != E; ++I) {
   73          I != E; ++I)
  175              I != E; ++I) {

  783   for (StructType *ST : Types) {
 1101   for (const auto Elem : RAUWWorklist) {
 1541   for (StructType *Ty : StructTypes) {

  409   for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
  535     for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
  546     for (GlobalValue *GV : ValuesToLink)

   89   for (auto &CPI : ConstantPools) {

  763   for (ELFSymbolData &MSD : LocalSymbolData) {
  774   for (ELFSymbolData &MSD : ExternalSymbolData) {
  801   for (const MCSymbol *Sym : OWriter.AddrsigSyms)
 1071   for (const MCSectionELF *Section : SectionTable) {
 1165   for (MCSectionELF *Group : Groups) {
 1174     for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
 1199     for (MCSectionELF *RelSection : Relocations) {
 1222     for (const MCAssembler::CGProfileEntry &CGPE : Asm.CGProfile) {
 1280   for (const std::pair<StringRef, const MCSymbol *> &P : Asm.Symvers) {
 1325   for (const MCSymbol *&Sym : AddrsigSyms) {

   24     for (const AsmToken &T : Value) {
   37   for (const MCAsmMacroParameter &P : Parameters) {

  348   for (auto I = Locs.begin(), E = Locs.end(); I != E;) {
  369     for (auto J = I; J != FileSegEnd; ++J) {
  377       for (auto J = I; J != FileSegEnd; ++J) {

  161   for (const MCDwarfLineEntry &LineEntry : LineEntries) {
  529   for (const auto &LineSec : MCLineSections.getMCLineEntries())
  903   for (MCSection *Sec : Sections) {
  994     assert(TextSection != Sections.end() && "No text section found");
 1060   for (const auto &Entry : Entries) {
 1108   for (MCSection *Sec : Sections) {
 1872   for (auto I = FrameArrayX.begin(), E = FrameArrayX.end(); I != E;) {

  491   for (MCAssembler::CGProfileEntry &E : getAssembler().CGProfile) {

 2450         for (const AsmToken &Token : A[Index])
 2487           for (const AsmToken &Token : A[Index])
 4387     for (const MCAsmMacroParameter& CurrParam : Parameters)
 5616   for (const MCAsmMacroArgument &Arg : A) {

  124   for (auto &FI : DwarfFrameInfos)
  433     for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) {

  184   for (const std::string &Feature : Features.getFeatures()) {
  281   for (std::string F : T.getFeatures()) {

   26   for (const auto &I : Insns) {
  270   for (const auto &I : Insns) {
  467   for (auto *EpilogStart : Epilogs) {
  469     assert(InstrsIter != info->EpilogMap.end() &&
  551   for (auto &I : info->EpilogMap) {
  559       assert(EpilogInfo.find(MatchingEpilog) != EpilogInfo.end() &&
  604   for (auto &I : EpilogInfo) {
  625   for (auto &I : info->EpilogMap) {

  319     for (MachSymbolData &Entry : *SymbolData)
  425   for (const std::string &Option : Options)
  441   for (const std::string &Option : Options) {
  488          ie = Asm.indirect_symbol_end(); it != ie; ++it) {
  504          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
  520          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
  623     for (MachSymbolData &Entry : *SymbolData)
  627     for (RelAndSymbol &Rel : Relocations[&Section]) {
  807   for (const auto &Option : Asm.getLinkerOptions()) {
  949   for (const auto &Option : Asm.getLinkerOptions())
  977          it != ie; ++it) {
 1013            ie = Asm.indirect_symbol_end(); it != ie; ++it) {
 1037       for (MachSymbolData &Entry : *SymbolData)

  144     for (StringPair *P : Strings) {

   57   for (auto &F : Features)

  907   for (const WasmRelocationEntry &RelEntry : Relocs) {
  923   for (const auto &Sec : CustomSections) {
 1002       for (const WasmComdatEntry &Entry : C.second) {
 1493     for (const WasmRelocationEntry &RelEntry : CodeRelocations)
 1495     for (const WasmRelocationEntry &RelEntry : DataRelocations)
 1580   for (auto &CustomSection : CustomSections)

  558   for (auto &Section : Sections)
  564   for (auto &Section : Arr) {
  654   for (const auto &Relocation : Sec.Relocations)
  883   for (const std::unique_ptr<COFFSection> &Section : Sections)
  886   for (const std::unique_ptr<COFFSection> &Section : Sections)
  931       for (auto &Relocation : Sec->Relocations) {
  967   for (auto &Symbol : Symbols) {
  978   for (const auto &S : Sections)
  981   for (const auto &S : Symbols)
  987   for (const auto &S : Sections)
  989   for (auto &S : Symbols)
  993   for (auto &Symbol : Symbols) {
 1004   for (auto &Section : Sections) {
 1039     for (const MCSymbol *S : AddrsigSyms) {
 1073   for (; I != IE && J != JE; ++I, ++J)
 1080   for (auto &Symbol : Symbols)

  123   for (auto I = PendingSet.begin(), E = PendingSet.end(); I != E;) {
  159   for (auto I = WaitSet.begin(), E = WaitSet.end(); I != E;) {
  220   for (auto I = IssuedSet.begin(), E = IssuedSet.end(); I != E;) {
  251   for (const InstRef &IR : make_range(PendingSet.begin(), EndIt)) {
  273   for (InstRef &IR : IssuedSet)
  277   for (InstRef &IR : PendingSet)
  280   for (InstRef &IR : WaitSet)

  332     for (unsigned StringOffset : M.Symbols) {
  575     for (const auto &M : Data) {
  621   for (const MemberData &M : Data)

 1797   if (RelocsForOffset.first != RelocsForOffset.second) {

  436   for (const auto &Entry : PltEntries)

   31   for (auto &M : this->Mods)
  121   for (auto BM : *BMsOrErr) {

  166       for (auto &Alias : KV.second)

  210     for (auto AliasName : Symver.second) {

   91   for (SymEntry &P : Addresses) {

  476   for (auto &I : Imports) {

  941   for (auto DataNodes : DataEntriesTreeOrder) {

   70          i != e; ++i) {
  109          i != e; ++i) {
  189   for (auto &SS : CVSS) {
  199   for (const auto &B : Builders) {
  219   for (COFFYAML::Section &S : CP.Obj.Sections) {
  232   for (COFFYAML::Section &S : CP.Obj.Sections) {
  280        i != e; ++i) {
  360   for (const COFFYAML::Section &S : CP.Obj.Sections) {
  477        i != e; ++i) {
  495        I != E; ++I) {
  501   for (const COFFYAML::Section &S : CP.Obj.Sections) {
  509     for (const COFFYAML::Relocation &R : S.Relocations) {
  528        i != e; ++i) {

  406   for (const auto &CS : Checksums) {
  421   for (const auto &LC : Lines.Blocks) {
  433       for (const auto &L : LC.Lines) {
  450   for (const auto &Site : InlineeLines.Sites) {
  456     for (auto EF : Site.ExtraFiles) {
  468   for (const auto &M : Exports)
  481   for (const auto &M : Imports) {
  482     for (const auto Id : M.ImportIds)
  492   for (const auto &Sym : Symbols)
  503   for (const auto &Str : this->Strings)
  514   for (const auto &YF : Frames) {
  535   for (const auto &RVA : RVAs)

   78   for (const auto &H : DebugH.Hashes) {

  495   for (const auto &Member : Members) {

   72   for (auto Str : DI.DebugStrings) {
   79   for (auto AbbrevDecl : DI.AbbrevDecls) {
   83     for (auto Attr : AbbrevDecl.Attributes) {
   95   for (auto Range : DI.ARanges) {
  107     for (auto Descriptor : Range.Descriptors) {
  124   for (auto Entry : Sect.Entries) {
  213   for (const auto &LineTable : DI.DebugLines) {
  227     for (auto OpcodeLength : LineTable.StandardOpcodeLengths)
  230     for (auto IncludeDir : LineTable.IncludeDirs) {
  236     for (auto File : LineTable.Files)
  240     for (auto Op : LineTable.Opcodes) {
  257           for (auto OpByte : Op.UnknownOpcodeData)
  286           for (auto OpData : Op.StandardOpcodeData) {

   47   for (auto &Unit : DebugInfo.CompileUnits) {
   51     for (auto &Entry : Unit.Entries) {
   59            FormVal != Entry.Values.end() && AbbrForm != Abbrev.Attributes.end();
   59            FormVal != Entry.Values.end() && AbbrForm != Abbrev.Attributes.end();

  208   for (std::unique_ptr<ELFYAML::Section> &D : Doc.Sections) {
  236   for (StringRef SecName : ImplicitSections) {
  290   for (const auto &YamlPhdr : Doc.ProgramHeaders) {
  649   for (auto &YamlPhdr : Doc.ProgramHeaders) {
  653     for (const ELFYAML::SectionName &SecName : YamlPhdr.Sections) {
  672       for (Elf_Shdr *SHeader : Sections)
  680     for (Elf_Shdr *SHeader : Sections) {
  701       for (Elf_Shdr *SHeader : Sections)
  752   for (const auto &Rel : Section.Relocations) {
  780   for (uint32_t E : Shndx.Entries)
  802   for (const ELFYAML::SectionOrType &Member : Section.Members) {
  818   for (uint16_t Version : Section.Entries)
  838   for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
  864   for (uint32_t Val : *Section.Bucket)
  866   for (uint32_t Val : *Section.Chain)
 1013   for (const ELFYAML::DynamicEntry &DE : Section.Entries) {
 1037   for (const ELFYAML::AddrsigSymbol &Sym : *Section.Symbols) {
 1058   for (const ELFYAML::NoteEntry &NE : *Section.Notes) {
 1126     for (const ELFYAML::Symbol &Sym : *Doc.Symbols)
 1131   for (const ELFYAML::Symbol &Sym : Doc.DynamicSymbols)
 1136   for (const std::unique_ptr<ELFYAML::Section> &Sec : Doc.Sections) {
 1138       for (const ELFYAML::VerneedEntry &VE : VerNeed->VerneedV) {
 1140         for (const ELFYAML::VernauxEntry &Aux : VE.AuxV)
 1144       for (const ELFYAML::VerdefEntry &E : VerDef->Entries)
 1145         for (StringRef Name : E.VerNames)

  875     for (std::pair<StringRef, uint8_t> &P :
  898     if (It != Flags.end())
  914     for (StOtherPiece &Val : *Other)
 1278     for (const ELFYAML::AddrsigSymbol &AS : *Sec->Symbols)

  118   for (const auto &Sec : LC.Sections) {
  133   for (const auto &Sec : LC.Sections) {
  179   for (const auto &T : LC.Tools) {
  209   for (auto &LC : Obj.LoadCommands) {
  259   for (auto &LC : Obj.LoadCommands) {
  270       for (auto &Sec : LC.Sections) {
  327   for (auto Opcode : BindOpcodes) {
  330     for (auto Data : Opcode.ULEBExtraData) {
  333     for (auto Data : Opcode.SLEBExtraData) {
  359   for (auto EE : Entry.Children) {
  364   for (auto EE : Entry.Children)
  394   for (auto &LC : Obj.LoadCommands) {
  423   for (auto writeOp : WriteQueue) {
  432   for (auto Opcode : LinkEdit.RebaseOpcodes) {
  435     for (auto Data : Opcode.ExtraData)
  453   for (auto NLE : Obj.LinkEdit.NameList) {
  462   for (auto Str : Obj.LinkEdit.StringTable) {
  554   for (auto Arch : FatFile.FatArchs) {

  109   for (const auto &Callback : Callbacks)
  159   for (auto &E : S.Entries)
  166   for (auto &E : S.Entries)

  164   for (StringRef Needed : Section.Needed)
  183     for (const WasmYAML::SymbolInfo &Info : Section.SymbolTable) {
  219     for (const WasmYAML::SegmentInfo &SegmentInfo : Section.SegmentInfos) {
  231     for (const WasmYAML::InitFunction &Func : Section.InitFunctions) {
  242     for (const auto &C : Section.Comdats) {
  246       for (const WasmYAML::ComdatEntry &Entry : C.Entries) {
  264     for (const WasmYAML::NameEntry &NameEntry : Section.FunctionNames) {
  288     for (auto &Entry : *Field.second) {
  299   for (auto &E : Section.Features) {
  327   for (const WasmYAML::Signature &Sig : Section.Signatures) {
  335     for (auto ParamType : Sig.ParamTypes)
  338     for (auto ReturnType : Sig.ReturnTypes)
  346   for (const WasmYAML::Import &Import : Section.Imports) {
  382   for (uint32_t FuncType : Section.FunctionTypes)
  389   for (const WasmYAML::Export &Export : Section.Exports) {
  404   for (auto &Table : Section.Tables) {
  413   for (const WasmYAML::Limits &Mem : Section.Memories)
  421   for (auto &Global : Section.Globals) {
  437   for (auto &Event : Section.Events) {
  451   for (auto &Segment : Section.Segments) {
  456     for (auto &Function : Segment.Functions)
  465   for (auto &Func : Section.Functions) {
  475     for (auto &LocalDecl : Func.Locals) {
  492   for (auto &Segment : Section.Segments) {
  529   for (auto Reloc : Sec.Relocations) {
  551   for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
  605   for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {

  332     for (auto &Reader : CoverageReadersOrErr.get())
  356     while (I != E && I->FileID != FileID)
  358     assert(I != E && "function does not cover the given file");
  625   for (const auto &CR : Function.CountedRegions)
  660     for (const auto &CR : Function.CountedRegions)
  707   for (const auto &CR : Function.CountedRegions)
  726   for (const auto &CR : Expansion.Function.CountedRegions)
  786   while (Next != CD.end() && Next->Line == Line)

  303     for (auto &R : MappingRegions) {
  309     for (auto &R : MappingRegions) {
  785       for (auto &Reader : ChildReadersOrErr.get())
  795       for (auto &Buffer : Ar->takeThinBuffers())

  921   for (const auto &FC : FuncCoverages) {

  373   if (It != AddrToMD5Map.end() && It->first == Address)
  685   for (auto &Count : this->Counts) {

  153       for (uint64_t I : ProfRecord.Counts)
  406   for (uint64_t Count : Func.Counts)

   72   for (const uint32_t Cutoff : DetailedSummaryCutoffs) {

  223   for (auto &Sym : SortedList) {
  238   for (auto &Sym : SortedList)

  608   for (auto &Entry : SecHdrTable) {
  663   for (auto Offset : OffsetsToUse) {
  776   for (auto &Entry : SecHdrTable) {
  790   for (auto &Entry : SecHdrTable) {
  798   for (auto &Entry : SecHdrTable) {

   58   for (const auto &I : V) {
  162   for (auto entry : FuncOffsetTable) {
  306   for (const auto &I : NameTable)
  344   for (auto entry : FuncOffsetTable) {
  489   for (auto Entry : Entries) {

   58   for (StringRef Str : serialize()) {

 2155     for (auto I : GlobalParser->MoreHelp)
 2199          I != E; ++I)
 2218          Category != E; ++Category) {
 2242       for (const Option *Opt : CategoryOptions)
 2413       for (auto I : *ExtraVersionPrinters)

  130              it2 != ie2; ++it2)
  189          ie = Dependencies.end(); it != ie; ++it) {
  208            ie = pred_end(Change); it != ie; ++it) {
  235       if (succ_begin(*it) != succ_end(*it)) {
  238              it2 != ie2; ++it2) {
  239           if (it2 != succ_begin(*it))
  251          it != ie; ++it) {

   55   for (auto &d : *CurrentDebugType) {

   35     for (auto Name : CounterInstance) {

   61          ie = Sets.end(); it != ie; ++it)
   74          ie = Sets.end(); it != ie; ++it) {

   47     return Handle == Process || Find(Handle) != Handles.end();
   56       if (Find(Handle) != Handles.end()) {
   78       for (void *Handle : Handles) {

  645     for (const auto &Substitution : Substitutions) {
  725     for (const auto &Substitution : Substitutions) {
 1143   for (const auto &PatternString : Req.ImplicitCheckNot) {
 1274     if (I != E) {
 1278     for (; I != E; ++I)
 1572   for (const FileCheckPattern *Pat : NotStrings) {
 1617        PatItr != PatEnd; ++PatItr) {
 1734   for (StringRef Prefix : Req.CheckPrefixes) {
 1758   for (StringRef Prefix : Req.CheckPrefixes) {
 1783   for (StringRef CmdlineDef : CmdlineDefines) {

  126   for (auto &entry : VFSWriter.getMappings()) {

  617       for (const Value &E : *V.getAsArray())
  622       for (const Object::value_type *E : sortedElements(*V.getAsObject()))

  419   if (find_if(LineContents, isNonASCII) != LineContents.end()) {

   66   for (auto& RegExKV : RegExes)
  100   for (const auto &Path : Paths) {
  210   for (auto &SectionIter : Sections)

  155   for (auto *Stat : Stats) {
  209   for (const TrackingStatistic *Stat : Stats.Stats) {
  258   for (const auto &Stat : StatInfo->statistics())

  105   for (auto &Worker : Threads)

  143     for (const auto &E : SortedTotals) {

  306   for (const PrintRecord &Record : TimersToPrint)
  414   for (const PrintRecord &R : TimersToPrint) {

   39   for (unsigned Char : Regex) {

 1111   for (const auto &Root : Roots)
 1128     for (std::unique_ptr<Entry> &SubEntry :
 1218       for (const auto &Root : FS->Roots) {
 1227       for (std::unique_ptr<RedirectingFileSystem::Entry> &Content :
 1268       for (std::unique_ptr<RedirectingFileSystem::Entry> &SubEntry :
 1574     for (auto &E : RootEntries)
 1646   for (const auto &Root : Roots) {
 1691   for (const std::unique_ptr<RedirectingFileSystem::Entry> &DirEntry :
 1832     for (std::unique_ptr<RedirectingFileSystem::Entry> &SubEntry :
 2070   assert((IsFirstTime || Current != End) && "cannot iterate past end");
 2073   while (Current != End) {

  307     for (auto &N : SQ->Entries) {

  295   for (auto &E : Entry.Loop->Entries) {
  412   for (auto &E : Source) {
  873   for (const auto &L : Loops) {
 2633   for (SmallVectorImpl<LetRecord> &LetInfo : LetStack)
 2644   for (auto &E : Entry.Loop->Entries) {
 3137       for (auto &E : NewEntries) {
 3149   for (auto &E : NewEntries) {
 3229   for (const auto &E : Entries)
 3240   for (const auto &E : Entries)

  143   for (MachineBasicBlock *S : MBB->predecessors())
  232   for (auto &MI : Sequences) {

  357   for (auto &I : AllChains)
  360   for (auto &I : AllChains)
  361     for (auto &J : AllChains)
  397   for (auto &I : V)
  418   for (auto I = L.begin(), E = L.end(); I != E; ++I) {
  569     for (auto J : ToErase)

  717     for (auto *JTBB : JTBBs)

   73     for (auto &JTE : JTI->getJumpTables())
   74       for (auto *MBB : JTE.MBBs)

   88     for (MachineDomTreeNode *N : *Node) {

  515     for (const MachineBasicBlock *Succ : MBB.successors()) {
  516       for (const auto &LI : Succ->liveins()) {

  100   for (auto Block : JT.MBBs) {

  155   for (auto SuccBB : MBB->successors())

  605     for (auto I = CmpBB->succ_begin(), E = CmpBB->succ_end(); I != E; ++I) {

  139   for (Loop *L : LI)
  832   for (MachineLoop *I : LI)

  337   for (const auto &Info : MF.getFrameInfo().getCalleeSavedInfo())
  358   for (const auto &Info : CSI) {

 1274   for (auto *BB : MBB->successors())
 5105         for (outliner::Candidate &C : RepeatedSequenceLocs)
 5193     for (outliner::Candidate &C : RepeatedSequenceLocs) {

  198       for (const auto &Info : MFI.getCalleeSavedInfo()) {

  295     for (auto &I : IRT) {
  297       for (auto &Repl : I.ReplOpc)
  515   for (auto &I : IRT) {
  524       for (auto &Repl : I.ReplOpc) {

  682   for (const LandingPadInfo &LPI : MF.getLandingPads())

  439   for (auto &I : Allocas) {
  569   for (auto &I : Allocas) {
  613   for (auto &I : Allocas) {

  104     for (GlobalAlias* A : AliasesToRemove) {

  220     for (auto I : *Node) {
  346   for (CallGraphNode *I : SCC) {

  106   for (auto &BB : Checklist) {

  502          std::find(UseNative.begin(), UseNative.end(), F) != UseNative.end();

  527     for (auto CI : Children) {
  561     for (auto MRTI : Children) {
  587     for (auto CI : Children) {
  607     for (auto &CI : Children) {
  771        SI != E; ++SI) {
  827   for (auto CI : *Children) {
 1260        SI != E; ++SI) {
 1302        SI != SE; ++SI) {
 1332   for (auto CI : *Children) {
 1344   for (auto CI : *Children) {
 1784        PI != E; ++PI) {
 1803          PI != E; ++PI) {
 1816        PI != E; ++PI) {
 1841          PI != E; ++PI) {
 2584        PI != E; ++PI) {
 2593   for (auto SI = MBB->succ_begin(), SE = MBB->succ_end(); SI != SE; ++SI) {
 2652   for (auto CI = Children->begin(), CE = Children->end(); CI != CE; ++CI) {
 2789   for (auto CI : *Children) {
 2843          CI != CE; ++CI) {

  375   for (CallGraphNode *I : SCC) {

  420   for (Value *V : WorkList) {
  829   for (Value *V : WorkList) {

  728     for (SUnit &SU : DAG->SUnits) {
  859     for (SUnit &SU : DAG->SUnits) {
  874       for ( ; Lat && LastSALU != E; ++LastSALU) {

  197          iterEnd = LoopInfo.end(); iter != iterEnd; ++iter) {
  656        iterEnd = SrcMBB->succ_end(); It != iterEnd; ++It)
  719        E = MLI->end(); It != E; ++It) {
  884          blockIter != blockEnd; ++blockIter) {
 1015   for (auto &It: *MLI)
 1055   for (auto *LB : inverse_children<MachineBasicBlock*>(LoopHeader))
 1347          PE = LandBlk->pred_end(); PI != PE; ++PI) {

 1231   if (Result != Symbols->end()) {

  386   for (MachineBasicBlock *Pred : MBB->predecessors()) {

  300   for (const SUnit &SU : SUnits)
  304   for (const SUnit &SU : SUnits)
  351   for (auto &SU : SUnits)

  111   for (const auto R : Regions) {
  293   for (auto I = Schedule.end(), B = Schedule.begin(); I != B;) {
  350     if (D != DbgE)
  381   for (const auto &I : Schedule) {
  458   for (auto R : Regions) {
  514     for (auto R : Regions) {
  549   for (auto R : Regions) {
  593   for (auto R : Regions) {

  207   for (MachineInstr *I : R) {

  150   for (SUnit *SU : Q) {
  398   for (MachineInstr *MI : Unsched) {

   88        E = BranchStack.end(); I != E; ++I) {
  381       if (It != Lits.end()) {

  222     if (ChanPos != UpdatedUndef.end())
  300     for (MachineInstr *MI : PreviousRegSeqByReg[MOp->getReg()]) {

 1086   for (auto &CS : CSI) {

11021       for (auto &TC : TargetConstraints) {

 1492     for (BlockInfo &BI : BlockInfos) {
 1515         for (MachineBasicBlock *Succ : BI.MBB->successors()) {

 4456     for (auto &Succ : RemainderBB->successors()) {
 6108          PI != E; ++PI) {

  188         for (MachineBasicBlock *Succ : MBB->successors())
  199       for (MachineBasicBlock *Succ : MBB->successors())
  205       for (MachineBasicBlock *Pred : MBB->predecessors()) {
  336       for (MachineBasicBlock *Pred : Dom->predecessors()) {
  388       for (MachineBasicBlock *Succ : MBB->successors()) {

  265   for (SUnit* SU : TopReadySUs) {
  293   for (SUnit* SU : SUnits) {
  337   for (SUnit* SU : ScheduledSUnits) {
  411   for (SUnit* SU : SUnits) {
  431   for (SUnit* SU : SUnits) {
  441   for (SUnit* SU : SUnits) {
  528   for (SUnit* SU : SUnits) {
  541   for (SIScheduleBlock* P : Preds) {
  560   for (std::pair<SIScheduleBlock*, SIScheduleBlockLinkKind> &S : Succs) {
  586   for (SIScheduleBlock* P : Preds) {
  591   for (std::pair<SIScheduleBlock*, SIScheduleBlockLinkKind> S : Succs) {
  613     for (const SUnit* SU : SUnits)
  616     for (const SUnit* SU : SUnits)
  703   for (unsigned SUNum : DAG->TopDownIndex2SU) {
  742           for (unsigned k : SubGraph) {
  778         for (unsigned j : AdditionalElements)
  816   for (unsigned SUNum : DAG->TopDownIndex2SU) {
  858   for (unsigned SUNum : DAG->BottomUpIndex2SU) {
  941   for (unsigned SUNum : DAG->BottomUpIndex2SU) {
 1011   for (unsigned SUNum : DAG->BottomUpIndex2SU) {
 1037   for (unsigned SUNum : DAG->BottomUpIndex2SU) {
 1058   for (unsigned SUNum : DAG->BottomUpIndex2SU) {
 1080   for (unsigned SUNum : DAG->BottomUpIndex2SU) {
 1086   for (unsigned SUNum : DAG->BottomUpIndex2SU) {
 1119   for (unsigned SUNum : DAG->BottomUpIndex2SU) {
 1151   for (unsigned SUNum : DAG->TopDownIndex2SU) {
 1176         for (unsigned k : SubGraph) {
 1312     for (SIScheduleBlock* Pred : Block->getPreds()) {
 1322     for (SIScheduleBlock* Pred : Block->getPreds()) {
 1361     for (SUnit* SU : SUs) {
 1424       for (SIScheduleBlock *Pred : Block->getPreds()) {
 1471       for (SIScheduleBlock* Pred: Block->getPreds()) {
 1535       for (SIScheduleBlock* Pred: Block->getPreds()) {
 1563                                             : BlocksScheduled) {
 1630                   : ReadyBlocks) dbgs()
 1642        E = ReadyBlocks.end(); I != E; ++I) {
 1792     for (SUnit* SU : SUs)
 2032        E = ScheduledSUnits.end(); I != E; ++I) {

  340     for (P = std::next(P); P != E; P = std::next(P)) {
  352          S != E; S = std::next(S)) {

  259   for (MachineBasicBlock *Succ : MBB.successors()) {

  373         for (auto *Pred : CurBB->predecessors()) {

  149   for (unsigned Reg : RegsToRewrite) {

  488   for (MachineBasicBlock *Pred : MBB.predecessors()) {
  499   for (MachineBasicBlock *Succ : MBB.successors()) {

  169   for (auto P : BranchToPCList) {

   80   for (auto Reg : CSI) {
  223   for (const auto &Entry : CSI) {
  339   for (auto I = V.begin(), E = V.end(); I != E; ++I) {
  379       if (RegI != CSI.end())
  385   for (auto &I : CSI) {

  531       for (auto &Stub : Stubs)
  544       for (auto &Stub : Stubs)
  957   for (MachineBasicBlock *MBB : JTBBs) {
 1000   for (MachineBasicBlock *MBB : JTBBs) {
 1032   for (auto MBB : JTBBs) {

 3158              SE = MBB->succ_end(); SI != SE; ++SI)

  548   for (auto *V : *Visited) {
  576   for (auto *V : *Visited) {
  667   for (auto V : *Visited) {
  713   for (auto *V : *Visited) {
  768   for (auto *V : Visited) {
  983              for (auto *I : CurrentVisited)
  987   for (auto *V : CurrentVisited) {

 1495     if (IP != WaterList.end())
 1512   if (IP != WaterList.end())
 2430   for (const MachineBasicBlock::RegisterMaskPair &RegMaskPair : BB->liveins())

  624     for (const auto &Entry : CSI) {
  657     for (const auto &Entry : CSI) {
  684     for (const auto &Entry : CSI) {
 1495     for (auto &Table: MF.getJumpTableInfo()->getJumpTables())
 2301     for (MachineBasicBlock *PredBB : CurMBB->predecessors()) {
 2317   for (const auto &LI : PrologueMBB.liveins()) {

 9805          I = LPadList.begin(), E = LPadList.end(); I != E; ++I) {
 9880        E = MBB->succ_end(); I != E; ++I)
10384          sItr != sEnd; ++sItr) {

 1958       for (CalleeSavedInfo &Info : MFI.getCalleeSavedInfo()) {

  106   for (auto ML : MLI) {
  218   for (auto I = ML->begin(), E = ML->end(); I != E; ++I)
  251     for (auto *MBB : ML->getHeader()->predecessors()) {

   92   for (auto MI : ToRemove) {

  119       for (auto *Add : Adds) {
  185         for (auto *Add : Adds)

  983   for (auto Inner : *L)

10923   for (auto Feature : Features)

  268          E = CSI.end(); I != E; ++I) {
  349   for (auto &I : CSI) {
  377     for (auto &I : CSI) {
  532       for (auto &I : MFI.getCalleeSavedInfo()) {
  573   for (const CalleeSavedInfo &CSI : MF.getFrameInfo().getCalleeSavedInfo())
  952   for (CalleeSavedInfo I : CSI) {

 1040   for (auto *Pred : MBB.predecessors()) {

  289   for (const CalleeSavedInfo &CCSI : CSI) {

  283   for (auto Call : CallList) {
  337   for (auto Call : PreserveUnionIndexCalls) {

  148   for (auto I : GPR32LiveDefs)

  181   for (const auto &Enum : EnumValues) {
  254   for (const auto &Member : Members) {
  305   for (const auto &Param : Parameters) {
  360   for (const auto &V : Vars) {
  731   for (const auto &TypeEntry : TypeEntries)
  741   for (const auto &TypeEntry : TypeEntries)
  746   for (const auto &S : StringTable.getTable()) {
  803     for (const auto &FuncInfo : FuncSec.second) {
  817     for (const auto &LineInfo : LineSec.second) {
  836       for (const auto &FieldRelocInfo : FieldRelocSec.second) {
  904   for (const auto &TypeEntry : TypeEntries)
  934   for (const auto &TypeEntry : TypeEntries)
 1161     for (const auto &StructType : StructTypes) {
 1173     for (auto &DType : Fixup.second.second) {
 1179   for (const auto &TypeEntry : TypeEntries)

  961     for (const MachineBasicBlock *SB : B.successors()) {
  972     for (const MachineBasicBlock *SB : B.successors())
  976   for (const MachineBasicBlock *TB : Targets)

  276   for (auto *DTN : children<MachineDomTreeNode*>(MDT->getNode(&B)))
  991   for (auto *DTN : children<MachineDomTreeNode*>(N))
  999   for (auto MI : Instrs) {
 1722   for (auto I : Instrs) {
 2277     for (MachineInstr *In : NewMIs) {
 3132     for (auto &I : Phis) {
 3330     for (auto PI = B.pred_begin(), PE = B.pred_end(); PI != PE; ++PI) {
 3340     for (auto SI = B.succ_begin(), SE = B.succ_end(); SI != SE; ++SI) {
 3354   for (auto &C : Cand)

   76   for (auto &R : RL)
   90   while (Iter != end()-1) {
  145   for (iterator Next, I = begin(); I != end(); I = Next) {
  238   for (auto I : B.liveins()) {
  398   for (auto *SB : B.successors())
  452     while (A != Z) {
  515   for (auto &R : RL)

  109   for (MachineBasicBlock *PB : MBB->predecessors())
  227               for (const auto &OrigLI : OrigLiveIn)
  229               for (const auto &NewLI : NewLiveIn)

  274     for (const_iterator I = S.begin(), E = S.end(); I != E; ++I)
  293       for (UseSet::const_iterator J = Us.begin(), F = Us.end(); J != F; ++J) {
  329   for (auto *DTN : children<DomTreeNode*>(DT->getNode(Root)))
  418   for (ValueVect::iterator I = BO.begin(), E = BO.end(); I != E; ++I) {
  436     for (const_iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I) {
  541   for (NodeVect::iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I) {
  630   for (NodeVect::iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I) {
  649   for (NodeVect::iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I) {
  672     for (typename T::iterator I = Blocks.begin(), E = Blocks.end(); I != E;
  687   while (++I != E) {
  703     while (I != E && !*I)
  708     while (++I != E) {
  729     for (iterator I = Values.begin(), E = Values.end(); I != E; ++I) {
  773     for (UseSet::iterator I = Us.begin(), E = Us.end(); I != E; ++I) {
  788     for (NodeVect::iterator I = Cs.begin(), E = Cs.end(); I != E; ++I) {
  829     for (NodeVect::iterator I = Cs.begin(), E = Cs.end(); I != E; ++I)
  919     for (NodeVect::iterator I = Cs.begin(), E = Cs.end(); I != E; ++I)
  983   for (Use *U : Us) {
  987   for (Use *U : NewUs)
 1021     for (UseSet::iterator J = Us.begin(), F = Us.end(); J != F; ++J) {
 1050     for (UseSet::iterator J = Us.begin(), F = Us.end(); J != F; ++J)
 1064   for (NodeVect::iterator I = Roots.begin(), E = Roots.end(); I != E; ++I)
 1070     for (NodeVect::iterator I = Roots.begin(), E = Roots.end(); I != E; ++I)
 1077     for (NodeVect::iterator I = Roots.begin(), E = Roots.end(); I != E; ++I)
 1151       for (UseSet::iterator I = Us.begin(), E = Us.end(); I != E; ++I)
 1221       for (NodeVect::iterator I = Cs.begin(), E = Cs.end(); I != E; ++I) {
 1236       for (UseSet::iterator I = Us.begin(), E = Us.end(); I != E; ++I) {
 1250     for (auto DTN : children<DomTreeNode*>(DT->getNode(B)))
 1263     for (ValueVect::iterator I = Ins.begin(), E = Ins.end(); I != E; ++I) {

  559       for (unsigned I : Q.second)
 1316       for (unsigned I : P.second)
 1332   for (const OffsetRange &R : Ranges)
 1397       for (unsigned I : RangeMap[N->Range])
 1873     for (std::pair<MachineInstr*,unsigned> P : RegOps) {
 1904     for (const std::pair<Loc,IndexList> &Q : Defs) {
 1907       for (unsigned I : Q.second)

  751     for (const MachineBasicBlock *SB : B.successors()) {
  771     for (const MachineBasicBlock *SB : B.successors())
  775   for (const MachineBasicBlock *TB : Targets) {
  839   for (const MachineBasicBlock *SB : MB->successors())
  928       for (const MachineBasicBlock *SSB : SB->successors())
  939       for (const MachineBasicBlock *SB : B.successors()) {
  972   for (MachineBasicBlock *B : POT) {
 1014       for (MachineBasicBlock *SB : B->successors()) {

  650     for (MachineLoop::iterator I = L->begin(), E = L->end(); I != E; ++I)
  975   for (auto I = B->pred_begin(), E = B->pred_end(); I != E; ++I)
 1064   for (MachineLoopInfo::iterator I = MLI->begin(), E = MLI->end(); I != E; ++I)

  392     for (MachineBasicBlock *D : Defs)
  404       for (auto *P : B->predecessors())

  425     for (auto SI = I.succ_begin(), SE = I.succ_end(); SI != SE; ++SI) {
  537       for (auto &R : CSI)
  787     for (auto &R : CSI)
  791       for (auto &SB : MBB.successors())
  810   for (auto &SB : MBB.successors())
  819       for (auto &R : CSI)
  828     for (auto &R : CSI)
 1961     for (auto *RC : SpillRCs) {
 1988     for (auto &DR : F->second)
 2214       for (auto I : FIs) {
 2237     for (auto FI : BlockFIMap[&B]) {
 2242       for (auto &Range : RL) {
 2412   for (auto &R : CSI)

  223   for (auto *DTN : children<DomTreeNode*>(DT->getNode(B)))

  427     for (OrderedRegisterList::const_iterator I = B; I != E; ++I) {
  428       if (I != B)
  453   if (L != Seq.end())
  765   for (pred_iterator I = ToB->pred_begin(), E = ToB->pred_end(); I != E; ++I) {
  840         for (iterator I = B; I != NewB; ++I)
  842         for (iterator I = NewE; I != E; ++I)
  852     if (B != E) {
  853       for (iterator I = B; I != E; ++I)
  875   for (iterator I = AVs.begin(), E = AVs.end(); I != E; ++I) {
  979   for (auto *DTN : children<MachineDomTreeNode*>(MDT->getNode(B))) {
 1088     if (End != LL.end())
 1178   if (End != LL.end())
 1335     assert(MinI != LL.end());
 1455   for (auto *DTN : children<MachineDomTreeNode*>(N))
 1463   for (auto I = Instrs.begin(), E = Instrs.end(); I != E; ++I) {

  489   for (VectOfInst::iterator I = Erase.begin(), E = Erase.end(); I != E; ++I)
  519     for (iterator I = Copy.begin(), E = Copy.end(); I != E; ++I) {

  391   for (auto &L : *MLI)
  569   assert(PI != TopMBB->pred_end() &&
  575   if (PI != TopMBB->pred_end())  // multiple backedges?
 1134   for (MachineLoop::iterator I = L->begin(), E = L->end(); I != E; ++I) {
 1882   for (MBBVector::iterator I = Preds.begin(), E = Preds.end(); I != E; ++I) {
 1965   for (MBBVector::iterator I = Preds.begin(), E = Preds.end(); I != E; ++I) {

  980   for (auto I : Nodes) {
 1028   for (auto I : Nodes) {
 1092   for (SDNode *N : Nodes) {
 1157   for (SDNode *N : Nodes) {

  202   for (Node N : FirstQ) {
  341     for (RowType &Row : Table)
  737   for (const auto &R : Ops) {
  990     for (const OpRef &R : Node.Ops) {
 2013   for (int &Idx : Mask)

  160   for (MachineBasicBlock *PB : BB->predecessors()) {
 1699     for (auto I : MBB->successors())
 3622         for (const MachineBasicBlock *SB : B.successors()) {

  530     for (Rule &R : Rules) {
 1083   for (Instruction *In : LoopIns)
 1366   for (Value *V : Inputs)
 1369   for (Value *V : Internal)

  503   for (ReadyQueue::iterator I = Q.begin(), E = Q.end(); I != E; ++I) {
  777   for (ReadyQueue::iterator I = Q.begin(), E = Q.end(); I != E; ++I) {

  185         for (auto &SU : DAG->SUnits)

  539              SI != SIE; ++SI) {

  178   for (NodeId N : PartlyDead) {

  577   for (auto I : *MLI)
  580     for (auto I : *WorkQ[i])

  176   for (auto SI : Stores) {
  221   for (auto I = AllInsns.begin(), E = AllInsns.end(); I != E; ++I) {
  246   for (auto I = Begin; I != End; ++I) {
  307   assert(Begin != End && "No instructions to analyze");
  352   for (InstrGroup::iterator I = Begin + 1; I != End; ++I) {
  402   for (InstrGroup::iterator I = OG.begin(), E = OG.end(); I != E; ++I) {
  476     for (auto I : OG)
  479     for (auto I : NG)
  494   for (auto I : OG)
  518   for (auto I : OG)
  526   for (auto I : NG)
  541   while (I != E) {
  576   for (auto &G : SGs) {

  129   for (SUnit &SU : DAG->SUnits) {
  142   for (SUnit &SU : DAG->SUnits) {

  379   for (auto BI : CurrentPacketMIs) {
  436   for (auto BI : CurrentPacketMIs) {
  664   for (auto I : CurrentPacketMIs) {
  750   for (auto I : CurrentPacketMIs) {
  915   for (auto I : CurrentPacketMIs) {
  985   for (auto I : CurrentPacketMIs) {
 1359     for (MachineInstr *PI : CurrentPacketMIs) {
 1475       if (Itr != IgnoreDepMIs.end()) {
 1672   for (auto MJ : CurrentPacketMIs) {
 1771       for (MachineInstr *MI : CurrentPacketMIs) {
 1786   for (MachineInstr *MI : CurrentPacketMIs) {
 1858   for (auto J : CurrentPacketMIs) {
 1869   for (auto J : OldPacketMIs) {

  449   for (auto *D : Dependences) {
  720   for (auto *D : Dependences) {

  163   for (auto *I : VecPrintList) {

  321   return std::find(table.begin(), table.end(), CPU) != table.end();

  671     for (auto const &I : AppliedRestrictions) {

   82   for (auto I : *N)
  106     for (NodeId I : Copies) {
  133   for (NodeId C : Copies) {

  144     for (NodeId N : LiveNodes) {
  187   for (auto I : Nodes) {

  272     for (int I : Ns) {
  281   for (MachineBasicBlock *B : BB->predecessors())
  288   for (MachineBasicBlock *B : BB->successors())
  900     for (auto I : EntryB.liveins())
  928       for (MachineBasicBlock *PB : B.predecessors())
 1415   for (auto DB : IDF) {
 1462     for (unsigned I : Closure)
 1471   for (MachineBasicBlock *PB : MBB->predecessors())
 1677   for (auto I : *N) {
 1695   for (MachineBasicBlock *SB : MBB->successors()) {

  159   for (NodeId N : DefQ) {
  230   for (NodeId T : Tmp) {
  812       for (auto I = B.livein_begin(), E = B.livein_end(); I != E; ++I)
  816       for (auto I : LV)
  827       for (auto I : LV)
  839     for (auto I = B.livein_begin(), E = B.livein_end(); I != E; ++I)
  841     for (auto I : T)
  859     for (auto I : B->liveins()) {
  876   for (auto SI : B->successors())
  954   for (auto I : *N) {
  966     for (auto I : *N)

  113     for (const uint32_t *RM : RegMasks) {
  123   for (const uint32_t *RM : RegMasks) {

   48       if (F != Map.end())
   56       assert(F != Map.end());

  423            SI != SE; ++SI)

  160         for (MachineBasicBlock *Succ : MBB->successors()) {

   88   for (InputIt I = First; I != Last; ++I) {
  208   for (const auto &R : Relocs)

   76          E = CSI.end(); I != E; ++I) {

  340   for (const auto &I : CSI) {
  494   if (PI2 != MBB->pred_end())

  598        E = MBB->succ_end(); I != E; ++I)
 1358     if (IP != WaterList.end())
 1369   if (IP != WaterList.end())

  407        SE = MBB.succ_end(); SI != SE; ++SI)
  409       for (const auto &LI : (*SI)->liveins())
  804        PE = SuccBB->pred_end(); PI != PE; ++PI)

  456            E = CSI.end(); I != E; ++I) {

  420   for (auto I = MBB.pred_begin(); I != MBB.pred_end(); ++I) {

 1450     for (const auto &TOCMapPair : TOC) {
 1666       for (const Function *Personality : MMI->getPersonalities()) {

  182          PIE = MBB->pred_end(); PI != PIE; ++PI)

   66            PIE = ReturnMBB.pred_end(); PI != PIE; ++PI) {

  353     for (auto &Succ : MBB->successors()) {
  385     for (auto &LI : MBB->liveins())

  934     for (CalleeSavedInfo CSI : Info) {
  956       for (CalleeSavedInfo CSI : Info) {
 1515     for (CalleeSavedInfo CSI : Info) {
 2162   for (auto &CS : CSI) {

  209   for (auto I = LI->begin(), IE = LI->end(); I != IE; ++I)

   47   for (const std::pair<unsigned, ISD::ArgFlagsTy> &LiveIn : LiveInAttrs)
   54   for (const std::pair<unsigned, ISD::ArgFlagsTy> &LiveIn : LiveInAttrs)

  264           for (auto &Succ : MBB.successors())
  275           for (auto &SuccMBB : MBB.successors())

  241   for (auto *Succ : NewMBB->successors()) {

  945   for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)

  166   for (const auto &Entry : CSI) {
  301   for (const auto &Entry : CSI) {

  108   for (auto SI = MBB.succ_begin(), SE = MBB.succ_end(); SI != SE; ++SI)

  369     for (auto &Save : CSI) {
  437   for (auto &Save : CSI) {

 6536     for (auto SI = MBB->succ_begin(), SE = MBB->succ_end(); SI != SE; ++SI)

  108   for (auto I = Node->begin(), E = Node->end(); I != E; ++I)

   49     for (auto I = MBB->pred_begin(); I != MBB->pred_end(); ++I)

  136     for (auto Br : BrL.List)

  132   for (auto &Pair : Replacements) {

  252         for (const MachineBasicBlock *Pred : MBB.predecessors())
  288           for (auto DeferredBlock : E.Deferred)
  294     for (MachineBasicBlock *Succ : MBB->successors()) {
  374         for (auto Pred : MBB.predecessors())
  381         for (auto Pred : MBB.predecessors())
  390       for (auto Pred : MBB.predecessors())

  224   for (MachineBasicBlock *Pred : MBB.predecessors()) {
  450   for (auto *Pred : MBB.predecessors()) {
  891       for (auto *Succ : MBB.successors()) {
 1122       for (auto *Succ : MBB->successors()) {

  132     for (auto *Succ : MBB->successors())
  169   for (auto &SubE : SubExceptions)
  183   for (auto *WE : TopLevelExceptions)

   80         for (auto *Pred : MBB->predecessors()) {
  132       for (auto *Succ : MBB->successors()) {
  147         for (auto *Pred : MBB->predecessors()) {
  166       for (auto *Pred : Looper->predecessors()) {
  201     for (auto *Pred : Entry->predecessors()) {
  212         for (auto *Pred : MBB->predecessors()) {
  385     for (auto *Pred : Entry->predecessors()) {
  395     for (auto *Entry : Pred->successors()) {
  410     for (auto *Entry : Pred->successors())
  421     for (auto *Entry : Pred->successors()) {
  458     for (auto *Succ : Pred->successors()) {

 1172   for (auto MBB : MBBs)

 1075   for (Instruction *I : SetjmpTableInsts)
 1077   for (Instruction *I : SetjmpTableSizeInsts)

  134     for (auto &AssociatedAndMore : PriorityAndMore.second) {
  149       for (auto Dtor : AssociatedAndMore.second)

  671     for (auto &Stub : Stubs)

  363          PB != PE; ++PB) {

  227     for (MachineLoop *Child : Loops[i]->getSubLoops())
  582   for (auto I = BB->succ_begin(), E = BB->succ_end(); I != E; ++I) {

  773   for (Closure &C : Closures) {

  168   for (auto P : TargetMBBs) {

  286   for (auto SI = MBB.succ_begin(), SE = MBB.succ_end(); SI != SE; ++SI)
  295   for (MachineBasicBlock *Succ : NewMBB.successors())
  304   for (MachineBasicBlock *Succ : NewMBB.successors()) {
  446         for (auto *PredMBB : MBB->predecessors()) {
  644       for (MachineBasicBlock *SuccMBB : UseMBB.successors())

  128            I != MBB->livein_end(); ) {

  197   for (MachineBasicBlock::RegisterMaskPair RegMask : MBB.liveins()) {
  240   for (const MachineBasicBlock *Succ : MBB.successors())
  474          I = CSI.begin(), E = CSI.end(); I != E; ++I) {
 2339   for (const auto &LI : PrologueMBB.liveins()) {
 2660     for (const auto &LI : PrologueMBB.liveins()) {
 3145   for (auto &Obj : SortingObjects) {

29610          sItr != sEnd; ++sItr) {
31104   for (auto &LP : LPadList)

 5669   if (I != Table.end() && I->KeyOp == MemOp)

 2491   for (auto SI = MBB->succ_begin(), SE = MBB->succ_end(); SI != SE; ++SI) {
 2715     for (auto *Succ : MBB.successors())
 3787     for (MachineBasicBlock *Successor : MBB->successors())
 7889            I != E; ++I) {
 8006     for (outliner::Candidate &C : RepeatedSequenceLocs)
 8015   for (outliner::Candidate &C : RepeatedSequenceLocs)

  157        I != MBB->succ_end(); ++I) {

  311   for (auto &LI : Succ.liveins())
  584     for (MachineBasicBlock *SuccMBB : MBB.successors())
 1042     for (MachineBasicBlock *Succ : MBB.successors())
 1077     for (MachineBasicBlock *Pred : MBB.predecessors()) {

  272          SI != SE; ++SI)
  343       for (MachineBasicBlock *Succ : MBB.successors())

  150     for (MachineBasicBlock *Pred : MBB->predecessors())
  297   for (auto &P : Lowerings)

  315     for (const auto &SpillLabel : XFI->getSpillLabels()) {
  433                                                     it != CSI.end(); ++it) {

   20   for (auto Arch : Archs) {

   25   if (I != Container.end() && I->getInstallName() == InstallName)
   65   if ((Iter != ParentUmbrellas.end()) && !(Target_ < Iter->first)) {
   79   if ((Iter != UUIDs.end()) && !(Target_ < Iter->first)) {

  453       for (const auto &Iter : File->umbrellas()) {
  459       for (const auto &Library : File->allowableClients())
  462       for (const auto &Library : File->reexportedLibraries())
  476         for (const auto &Library : File->allowableClients())
  480         for (const auto &Library : File->reexportedLibraries())
  620       for (auto &ID : UUIDs)
  640       for (const auto &Section : Exports) {
  644         for (const auto &Lib : Section.AllowableClients)
  648         for (const auto &Lib : Section.ReexportedLibraries)
  652         for (const auto &Symbol : Section.Symbols) {
  660         for (auto &Symbol : Section.Classes) {
  666         for (auto &Symbol : Section.ClassEHs)
  668         for (auto &Symbol : Section.IVars) {
  675         for (auto &Symbol : Section.WeakDefSymbols)
  678         for (auto &Symbol : Section.TLVSymbols)
  683       for (const auto &Section : Undefineds) {
  686         for (auto &Symbol : Section.Symbols) {
  696         for (auto &Symbol : Section.Classes) {
  703         for (auto &Symbol : Section.ClassEHs)
  706         for (auto &Symbol : Section.IVars) {
  713         for (auto &Symbol : Section.WeakRefSymbols)
  810       for (const auto &IT : File->uuids())
  829         for (const auto &it : File->umbrellas())
  914       for (auto &id : UUIDs)
  921       for (const auto &CurrentSection : ParentUmbrellas)
  922         for (const auto &target : CurrentSection.Targets)
  929       for (const auto &CurrentSection : AllowableClients) {
  930         for (const auto &lib : CurrentSection.Values)
  931           for (const auto &Target : CurrentSection.Targets)
  935       for (const auto &CurrentSection : ReexportedLibraries) {
  936         for (const auto &Lib : CurrentSection.Values)
  937           for (const auto &Target : CurrentSection.Targets)
  943         for (const auto &CurrentSection : CurrentSections) {
  944           for (auto &sym : CurrentSection.Symbols)
  948           for (auto &sym : CurrentSection.Classes)
  952           for (auto &sym : CurrentSection.ClassEHs)
  956           for (auto &sym : CurrentSection.Ivars)
  960           for (auto &sym : CurrentSection.WeakSymbols)
  963           for (auto &sym : CurrentSection.TlvSymbols)
  997       for (const auto &library : Libraries) {

  156   for (COFFShortExport& E : Def->Exports) {
  164     for (COFFShortExport& E : Def->Exports) {

  359   for (NewArchiveMember &Member : Members) {

  237   for (auto Itr : InstInfoMap) {
  301   for (auto &Itr : InstInfoMap) { // Forward

 1545     for (CallGraphNode *CGN : SCC)

  286             for (auto II : ArgIndex.second) {
 1132     for (CallGraphNode *OldNode : SCC) {

  731     for (const Use *U : Uses) {
  742     for (const Use *U : NextUses)
 1064   for (auto &It : ReturnedValues) {
 1129   for (auto &It : ReturnedValues) {
 1170     for (auto &RetValAAIt : RetValAA.returned_values()) {
 1197     for (auto &RetValAAIt : RetValAA.returned_values()) {
 1220   for (auto &It : NewRVsMap) {
 3183     for (auto &It : RVAA.returned_values()) {
 4428   for (Instruction *I :
 4496     for (AbstractAttribute *AA : Worklist)

  142   for (uint64_t TypeId : TypeIds) {

   72   for (auto &S : ForceAttributes) {

  783          I != E && !SCCCaptured; ++I) {
  796     for (ArgumentGraphNode *I : ArgumentSCC) {
  801          I != E && !SCCCaptured; ++I) {
 1500   for (CallGraphNode *I : SCC) {

  757     for (auto &S : Entry.second.SummaryList)
  861       for (auto &S : P.second.SummaryList)
 1183       for (const auto *GV : GlobalsToImport)
 1240     for (auto &S : I.second.SummaryList) {

  401   for (Function *F : DeadFunctions) {
  414   for (GlobalVariable *GV : DeadGlobalVars)
  418   for (GlobalAlias *GA : DeadAliases)
  422   for (GlobalIFunc *GIF : DeadIFuncs)

  581     for (OutliningRegion &Region : Regions) {

  203     for (AllocaInst *AvailableAlloca : AllocasForType) {
  538   for (CallGraphNode *Node : SCC) {
  556   for (CallGraphNode *Node : SCC) {

  206   for (uint64_t ObjIndex : Fragment)
  373     for (auto P : FunctionAliases)
 1159     for (CallInst *CI : TIUI.CallSites) {
 1630   for (auto &&MemSet : TypeMembers)
 1638   for (auto &&F : GLB.Fragments) {
 1639     for (auto &&Offset : F) {
 1803     for (GlobalAlias *GA : AliasesToErase)
 1845       for (auto &GVS : I.second.SummaryList)
 1990       for (GlobalTypeMember *GTM : TypeIdInfo[TypeId].RefGlobals)
 2057       for (auto &S : P.second.SummaryList) {
 2098   for (const auto &S : Sets) {

  321          I != E && i < Max; ++I, ++i) {
  323       for (std::vector<WeakTrackingVH>::iterator J = I; J != E && j < Max;
  342         for (std::vector<WeakTrackingVH>::iterator K = J; K != E && k < Max;
  407   for (auto I = HashedFuncs.begin(), IE = HashedFuncs.end(); I != IE; ++I) {
  410     if ((I != S && std::prev(I)->first == I->first) ||
  411         (std::next(I) != IE && std::next(I)->first == I->first) ) {
  426     for (WeakTrackingVH &I : Worklist) {

  947   for (User *User : Users) {
 1144       for (Value *value : Inputs)
 1146       for (Value *output : Outputs)
 1392   for (User *User : Users) {

   68   for (CallGraphNode *I : SCC)
   73   for (CallGraphNode *I : SCC)
   86        (!SCCMightUnwind || !SCCMightReturn) && I != E; ++I) {
  151     for (CallGraphNode *I : SCC) {
  165   for (CallGraphNode *I : SCC) {

  944         for (const auto *FS : findIndirectCallFunctionSamples(*I, Sum)) {

  182   for (GlobalValue *GV : V)
  319   for (auto V : CfiFunctions) {

  187       for (auto &&B : Used)
  198       for (auto &&B : Used) {
  724     for (auto &SlotSummary : T.second) {
  843   for (const TypeIdOffsetVtableInfo P : TIdInfo) {
  871     for (auto &&VCallSite : CSInfo.CallSites) {
  903     for (auto *FS : CSInfo.SummaryTypeCheckedLoadUsers) {
  907     for (auto *FS : CSInfo.SummaryTypeTestAssumeUsers) {
 1093     for (auto &&VCallSite : CSInfo.CallSites) {
 1193   for (auto Call : CSInfo.CallSites)
 1301   for (auto &&Call : CSInfo.CallSites) {
 1369   for (auto Call : CSInfo.CallSites) {
 1793     for (auto &S : CallSlots)
 1820       for (auto &S : P.second.SummaryList) {
 1858   for (auto &S : CallSlots) {
 1881         for (const auto &T : TargetsForSlot)
 1893       for (auto FS : S.second.CSInfo.SummaryTypeCheckedLoadUsers)
 1896         for (auto FS : CCS.second.SummaryTypeCheckedLoadUsers)
 1918     for (VTableBits &B : Bits)
 1941     for (auto &S : P.second.SummaryList) {
 1947         for (StringRef Name : NameByGUID[VF.GUID]) {
 1952         for (StringRef Name : NameByGUID[VF.GUID]) {
 1958         for (StringRef Name : NameByGUID[VC.VFunc.GUID]) {
 1966         for (StringRef Name : NameByGUID[VC.VFunc.GUID]) {
 1977   for (auto &S : CallSlots) {

  590     for (auto *PN : PHIs)
  599   for (Value *Val : Explored) {
  660   for (Value *Val : Explored) {
  672   for (Value *Val : Explored) {
  712   for (Value *Val : Explored) {
  730   for (Value *Val : Explored) {

  289   if (Loc != WorkMap.end())

  210     for (auto &Ei : AllEdges) {
  221     for (auto &Ei : AllEdges) {
  247     for (auto &EI : AllEdges)

   89   for (auto E : Counts) {

  998   for (auto It = R->begin(); It != R->end(); ++It) {
 1001     Region *NextSubR = NextIt != R->end() ? NextIt->get() : nullptr;

  828        i != e; ++i) {
  925   for (Function *i : FnsToInstrument) {
  962          i != e; ++i) {
  975       for (Value *V : DFSF.NonZeroChecks) {
 1258       for (auto Child : Children)

  475   for (Regex &Re : Regexes) {

 1065     for (auto *DDI : AllocaDeclareMap.lookup(AI)) {
 1427   for (GlobalVariable *GV : Globals) {
 1463   for (auto &P : PersonalityFns) {
 1493     for (Function *F : P.second)

  337   for (auto &C : Candidates) {
  354   for (auto &I : findIndirectCalls(F)) {

  455   for (const auto &LoadStore : PromotionCandidates) {
  937   for (auto *NamePtr : ReferencedNames)
  962   for (Value *Data : UsedVars)

  593     for (auto &E : MST.AllEdges) {
  726   for (auto &E : MST.AllEdges)
  729   for (auto &E : EdgeList) {
  736   for (auto &E : MST.AllEdges) {
  820   for (auto *InstrBB : InstrumentBBs) {
  847     for (VPCandidateInfo Cand : FuncInfo.ValueSites[Kind]) {
 1077   for (BasicBlock *InstrBB : InstrumentBBs) {
 1095   for (auto &E : FuncInfo.MST.AllEdges) {
 1431   for (VPCandidateInfo &I : ValueSites) {
 1625   for (auto &F : HotFunctions) {
 1630   for (auto &F : ColdFunctions) {

  151     for (auto &MI : WorkList) {

   61     for (Instruction *I : Result) {

  377        MI != ME; ++MI) {
  385   for (auto MI = top_down_ptr_begin(), ME = top_down_ptr_end(); MI != ME; ++MI)
  420        MI != ME; ++MI) {
  428   for (auto MI = bottom_up_ptr_begin(), ME = bottom_up_ptr_end(); MI != ME;
  441          I != E; ++I) {
  461          I != E; ++I) {
 1113        I != E; ++I) {
 1249        MI != ME; ++MI) {
 1385        MI != ME; ++MI) {
 1648       assert(It != Retains.end());
 1832        I != E; ++I) {

   70   for (Value *V1 : Values) {
   72     for (Value *V2 : Values) {

  234   for (auto &BBInfo : BlockInfo)
  240   for (auto &BBInfo : BlockInfo)
  297   for (auto &PDTChild : children<DomTreeNode *>(PDT.getRootNode())) {
  320   for (auto &BBInfo : BlockInfo)

  215   for (auto BB : BBs) {
  252     for (auto ChildDomNode : DT.getNode(Node)->getChildren()) {
  325     for (auto BB : BBs) {
  557     for (auto ConstCand = S; ConstCand != E; ++ConstCand) {
  567   for (auto ConstCand = S; ConstCand != E; ++ConstCand) {
  581       for (auto C2 = S; C2 != E; ++C2) {
  626   for (auto ConstCand = S; ConstCand != E; ++ConstCand) {
  660        CC != E; ++CC) {
  839     for (Instruction *IP : IPSet) {
  919   for (auto const &I : ClonedCastMap)
  942   for (auto &MapEntry : ConstGEPCandMap)
  951   for (auto MapEntry : ConstGEPInfoMap)

  148   for (auto &RemPair : RemMap) {

 1298     } else if (NodeToProcess->childIter() != NodeToProcess->end()) {

   69     for (WeakVH &BlockHandle : Blocks) {

  152   if (IT != SeenInsts.end())
  191     if (SeenInsts.find(I) != SeenInsts.end())
  300         assert(SeenInsts.find(OI) != SeenInsts.end() &&
  436   if (ConvertedInsts.find(I) != ConvertedInsts.end())

 1162   for (auto &PredLoad : PredLoads) {
 1240   for (const auto &PredLoad : PredLoads) {
 2642   for (BasicBlock *BB : DeadBlocks) {

  766     for (const auto &R : Ranks) {

 1380   for (Loop *SubLoop : *Original)

 2161   for (Loop *InnerL : L->getSubLoops()) {
 2261   if (CurLoop->begin() != CurLoop->end())

  205   for (Loop *I : *LI)

  151   if (L->begin() != L->end()) {

  982   for (Loop *TopLevelLoop : *LI)

  460         if (!isRemovedLoop(L) && L->begin() != L->end())

  632   for (auto &SL : StoreRefsForMemset)
  635   for (auto &SL : StoreRefsForMemsetPattern)
  759        it != e; ++it) {

 1085   for (auto &Row : DepMatrix) {
 1133   for (Loop *L : *OuterLoop)

  609   for (Loop *TopLevelLoop : LI)

   35   for (auto &Pass : Passes) {

 1081   while (I != In.end() && (I->second.test(Val) == 0 ||
 1109     for (auto It = Start; It != End; ++It)
 1194   for (auto &KV : Uses) {
 1204                   : Uses) {
 1224     while (BaseIt != Uses.end() && RootIt != Uses.end()) {
 1224     while (BaseIt != Uses.end() && RootIt != Uses.end()) {
 1256         while (TryIt != Uses.end() &&
 1497     for (auto &KV : Uses)

  299     for (auto I = DFS.beginPostorder(), E = DFS.endPostorder(); I != E; ++I) {

 1392   for (Loop *RootL : Loops) {
 1436   for (auto &L : LI) {

  923   for (Loop *I : *L)
 1477     for (Instruction *UI : Worklist)

  748   for (auto &Cmp : Comparisons_) {

 3167   for (const auto *CC : CongruenceClasses) {

  125     for (Loop *I : *L)
  135     for (Loop *I : *LI) {
  534     for (Instruction *Term : PollLocations) {
  562         for (BasicBlock *Header : Headers) {
  679   for (auto *CI : Calls) {

  379     for (Value *V : LiveSet)
  627   if (Found != Cache.end()) {
  848   for (auto Pair : States) {
  859     assert(I != States.end() && "lookup failed!");
  873     for (auto Pair : States) {
  923   for (auto Pair : States) {
  930   for (auto Pair : States) {
 1027   for (auto Pair : States) {
 1117   for (auto Pair : States) {
 1162   for (Value *ptr : live) {
 1183     for (auto &Pair : PointerToBase) {
 1611   for (Value *L : LiveSet) {
 1668   for (auto RematerializedValuePair: RematerializedValues) {
 1722     for (auto RematerializedValuePair : Info.RematerializedValues) {
 2028   for (Value *LiveValue: Info.LiveSet) {
 2254     for (auto Pair : Info.PointerToBase)
 2268       for (auto Pair : Info.PointerToBase) {
 2287     for (auto &BasePair : Info.PointerToBase)
 2318   for (auto &PR : Replacements)
 2700   for (Value *V : Live) {
 2735     for (Value *Kill : Data.KillSet[&BB])
 2817   for (auto V : Updated)
 2825   for (auto V : Updated)
 2833   for (auto KVPair : Info.PointerToBase)
 2841   for (auto KVPair : Info.PointerToBase)

  414       assert(It != TrackedMultipleRetVals.end());
  844     if (TFRVI != TrackedRetVals.end()) {
 2192   for (const auto &I : RV) {

 1325     for (Loop *ChildL : OrigL) {
 1432   for (Loop *ChildL : OrigL) {
 1736   for (auto *BB : make_range(BlocksSplitI, Blocks.end()))
 1840   for (auto *HoistedL : make_range(SubLoopsSplitI, SubLoops.end())) {
 1893     for (DomTreeNode *ChildN : *N) {
 2254     for (Loop *ChildL : UpdateL) {

  169       I != E && SuccToSinkTo == nullptr; ++I) {

  730   for (auto *UnlinkedInst : UnlinkedInstructions) {

  606   for (const auto &AddedPhi : AddedPhis) {
  614     for (const auto &PI : Map) {

  424       for (DomTreeNode *I : Children)
  841       for (DomTreeNode *Child : Children)

  215   for (auto *BB : Result) {
  600   for (BasicBlock *BB : Blocks) {
  745   for (BasicBlock *Block : Blocks)
  787   for (Value *value : inputs) {
  793   for (Value *output : outputs) {
  803     for (Type *i : paramTy)
  945     for (User *use : Users)
  964   for (auto &U : Users)
  984   for (BasicBlock *BB : Blocks) {
 1076   for (Value *input : inputs) {
 1088   for (Value *output : outputs) {
 1106            ve = StructValues.end(); v != ve; ++v)
 1191   for (BasicBlock *Block : Blocks) {
 1331   for (BasicBlock *Block : Blocks) {
 1411     for (BasicBlock *Block : Blocks)
 1425   for (BasicBlock *Block : Blocks) {
 1482   for (auto *II : SinkingCands) {
 1491   for (auto *II : SinkingCands) {
 1500     for (auto *II : HoistingCands)

  106   for (const auto &Node : SortedNodes) {
  168   for (const auto &Name : NonImportedCallers) {

  848   for (const MDNode *I : MD) {
  856   for (const MDNode *I : MD) {
 1201   for (; I != E; ++I) {
 1737       for (auto &VH : InlinedFunctionInfo.OperandBundleCallSites) {

  390   for (Loop *SubLoop : L.getSubLoops())
  401   for (auto &L : *LI)

  818   for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
  848   for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)

  109   for (BasicBlock *BB : Blocks) {
  584   for (Loop *SubLoop : *L)
  621         for (PHINode *OrigPHI : OrigPHINode) {
  684     for (BasicBlock *NewBlock : NewBlocks) {
  695   for (PHINode *PN : OrigPHINode) {
  829     for (auto *BB : OriginalLoopBlocks) {
  832       for (auto *ChildDomNode : BBDomNode->getChildren()) {
  851         for (BasicBlock *Iter : TermBlocks) {
  875   for (BasicBlock *Latch : Latches) {

  381     for (BasicBlock *NewBlock : NewBlocks) {

  851       for (auto *DomChild : DomNodeBB->getChildren()) {
  878   for (BasicBlock *BB : NewBlocks) {

  500     for (DomTreeNode *Child : Worklist[I]->getChildren())

  273     for (Loop *TopLevelLoop : *LI)

   67   return I != Ranges.end() && I->Low <= R.Low;
  190        B != E;) {
  192     if (++B != E)
  416     for (CaseItr J = std::next(I), E = Cases.end(); J != E; ++J) {
  428       } else if (++I != J) {
  524     for (const auto &I : Cases) {
  553          I != E; ++I) {
  556       if (Next != E) {

   89       for (auto C : M.getModuleIdentifier())
  115       for (StructType *STy : StructTypes) {

  661   for (Instruction *A : Allocas) {

 1179       for (ValueEqualityComparisonCase &V : PredCases)

  570   for (const auto &MapFile : MapFiles)

   67     for (BasicBlock *BB : UnreachableBlocks) {
  103   for (BasicBlock *BB : ReturningBlocks) {

  851   for (const std::pair<ChainID, InstrList> &Chain : Map) {

  348   for (Loop *SubLp : *Lp)
 1080   for (Loop *SubLp : *Lp)

 1082     return VF > 1 && MinBWs.find(I) != MinBWs.end() &&
 1575   for (Loop *InnerL : L)
 1799   assert(II != Legal->getInductionVars()->end() && "IV is not an induction");
 3002   for (auto &InductionEntry : *List) {
 3293   for (const auto &KV : Cost->getMinimalBitwidths()) {
 3396   for (const auto &KV : Cost->getMinimalBitwidths()) {
 3444   for (auto &Entry : *Legal->getInductionVars())
 4460   for (auto &Induction : *Legal->getInductionVars()) {
 4503   for (auto &Induction : *Legal->getInductionVars()) {
 4785   for (auto &Induction : *Legal->getInductionVars()) {
 6372   for (auto &Induction : *Legal->getInductionVars()) {
 6536   for (auto &Induction : *Legal->getInductionVars()) {
 7173     for (Instruction *Instr : Ingredients) {
 7838   for (auto &L : *LI)
 7847   for (Loop *L : *LI)

  564     for (auto &Iter : BlocksSchedules) {
 2133       if (ExtI != ExternallyUsedValues.end()) {
 4242   for (auto &BSIter : BlocksSchedules) {
 4395   for (Instruction *I : GatherSeq) {
 4426   for (BasicBlock *BB : CSEBlocks)
 6294           if (I != ExtraArgs.end() && !I->second) {
 6399     for (auto &Pair : ExtraArgs) {
 6485       for (auto &Pair : ExternallyUsedValues) {
 7023   for (auto &Entry : GEPs) {
 7088       for (auto *V : Candidates) {
 7113   for (StoreListMap::iterator it = Stores.begin(), e = Stores.end(); it != e;

  197   for (const auto &Y : YAMLSleds) {

   31   for (auto *V : Visitors)

   31     for (const auto &PathData : Block.PathData)
  206       for (const auto &PathAndData : Block.PathData) {
  239       for (const auto &PathAndData : Block.PathData) {
  338   for (const auto &E : T) {

  300     for (auto &R : FDRRecords)
  311       for (auto &B : Blocks) {
  313         for (auto *R : B.Records)
  337       for (auto &B : Blocks) {
  338         for (auto *R : B.Records)

  790   for (auto it : fpArrays) {

  333     for (auto *R : RTLs.UsedRTLs) {

  296     for (auto *F : ToRemove) {
  353   for (auto A : Attrs)
  520     for (const auto &BI : BlockInfo) {
  568   for (const auto *BB : BBs)
  627     for (auto &BI : BlockInfo) {
  672   for (const auto *BB : BBs)
  719     for (auto &BI : BlockInfo) {
  847   for (const std::string &Name : NamedMDs)
  860   for (auto *NamedMD : ToDelete)
 1129     for (std::string &Name : FunctionNames) {

  393   for (BasicBlock *BB : BBs) {

  391       for (Function *F : MiscompiledFunctions) {

  218        I != E; ++I)
  222        I != E; ++I)

  178        i != e; ++i) {
  271   for (const auto &Arg : CompilerArgs)
  276   for (const auto &Arg : CompilerArgs)
  638        I != E; ++I)
  786        I != E; ++I)

  227   for (const PassInfo *PI : PassList)

 4484     for (auto &M : ComponentListMap) {

  182     for (Decl *D : AST.getTraversalScope())

  647     for (auto &I : *this)

 1317     for (const auto &Ext : getTargetOpts().OpenCLExtensionsAsWritten) {

   45   for (auto &C : Callbacks) {
   54   for (auto &C : Callbacks) {
   64   for (auto &C : Callbacks) {
   74   for (auto &C : Callbacks) {

 1133     for (const std::pair<CallDescription, T> &I : LinearMap)

   40     for (auto &Fix : Fixes) {

  122     for (const auto &Part : Parts)

  204          E = CInvok->getDiagnosticOpts().Warnings.end(); I != E; ++I) {

   52            RI = D.range_begin(), RE = D.range_end(); RI != RE; ++RI) {

  568        I = IndentationRanges.begin(), E = IndentationRanges.end(); I!=E; ++I) {

  331            E = MigrateCtx.traversers_end(); I != E; ++I)
  344            E = MigrateCtx.traversers_end(); I != E; ++I)
  355          I = traversers_begin(), E = traversers_end(); I != E; ++I)
  511          I = traversers_begin(), E = traversers_end(); I != E; ++I)

10247   return I != MangleNumbers.end() ? I->second : 1;
10257   return I != StaticLocalNumbers.end() ? I->second : 1;

  562   for (const_iterator I = Other.begin(), IE = Other.end(); I != IE; ++I) {
  572   for (iterator I = begin(), IEnd = end(); I != IEnd; ++I) {
  649            OM != OMEnd;
  738   for (auto &OM : FinalOverriders) {
  739     for (auto &SO : OM.second) {

   27        I != E; ++I) {
   40   if (O != S.begin() && *(O - 1) == ' ')

   28        I != E; I++) {

 1880          M != MEnd && !Done; ++M) {
 1883            SO != SOEnd && !Done; ++SO) {

  258   for (const std::unique_ptr<ASTImporter> &I : Importers)
  273   for (const std::unique_ptr<ASTImporter> &I : Importers)
  288     for (const std::unique_ptr<ASTImporter> &Importer : Importers) {
  406   for (const auto &I : Importers)

   66   for (auto &Anon : AnonFuncs) {

  179   for (const auto &Overrider : FinalOverriders) {
  183     for (const auto &M : Methods) {
 3424   for (const BaseSubobject &BSO : FullPath) {
 3536       for (const BaseSubobject &BSO : *BestPath)

  551     for (const auto &MP : Matchers) {
  574     for (unsigned short I : Filter) {

   44   for (const std::string &S : Matches)
  164     for (auto &IM : InnerMatchers) {
  351   for (StringRef Name : Names)
  525     for (const StringRef Pattern : Names) {

  600     for (const auto &O : Overloads) {
  621     for (const auto &O : Overloads) {
  631     for (const auto &O : Overloads) {
  640     for (const auto &O : Overloads) {
  649     for (const auto &O : Overloads) {

  541        I != E; ++I) {
  547   for (const auto &Completion : S->getMatcherCompletions(AcceptedTypes)) {
  551   for (const auto &Completion : getNamedValueCompletions(AcceptedTypes)) {

  625         for (const std::vector<ArgKind> &Arg : ArgsKinds) {
  632           for (const ArgKind &AK : Arg) {

  165     for (const DynTypedMatcher &Matcher : Matchers) {
  207     for (const VariantMatcher &Matcher : Args) {

 1547                                    E = BackpatchBlocks.end(); I != E; ++I ) {

  355   for (CloneDetector::CloneGroup &Group : Sequences) {
  479   for (auto &HashGroup : CloneGroups) {

  636         it = vec.begin(), ei = vec.end(); it != ei; ++it) {
  654          de = declVec.end(); di != de; ++di) {

  413   for (const auto D : BatchDiags)
 1100   for (const auto &I : *this)

  697          E = cfg->try_blocks_end() ; I != E; ++I) {

  880   for (auto *A : CurrentArguments)
  901   for (auto *V : CurrentInstructions)
  943   for (auto *Ph : IncompleteArgs) {

  466   for (diag::kind Diag : AllDiags)
  784     for (char c : S) {

   68        I != IEnd; ++I) {
  131                            Feature) != LangOpts.ModuleFeatures.end();
  248            I = TopHeaderNames.begin(), E = TopHeaderNames.end(); I != E; ++I) {
  309          Sub != SubEnd; ++Sub) {
  343        I != E; ++I) {
  519        MI != MIEnd; ++MI)
  645     for (auto &C : V.M->Conflicts) {

   38   for (auto &S : Sections) {
   57   for (auto &S : SanitizerSections)

  405   for (const auto &F : FeatureVec) {

  286   for (const auto &Feature : Features) {

  233   for (auto &I : TargetOpts.FeaturesAsWritten) {

  378   for (auto Feature : TargetFeatures)
  392   for (const auto &Feature : FeaturesVec) {
  428   for (const auto &Feature : Features) {

   80   for (auto &F : Features) {

  316     for (const auto &Feature : Features) {

   43   for (const StringRef Feature : Opts.FeaturesAsWritten) {

   34   for (const auto &Feature : Features) {
  227   if (llvm::find(FeaturesVec, "-vsx") != FeaturesVec.end()) {
  228     if (llvm::find(FeaturesVec, "+power8-vector") != FeaturesVec.end()) {
  234     if (llvm::find(FeaturesVec, "+direct-move") != FeaturesVec.end()) {
  240     if (llvm::find(FeaturesVec, "+float128") != FeaturesVec.end()) {
  246     if (llvm::find(FeaturesVec, "+power9-vector") != FeaturesVec.end()) {
  319       llvm::find(FeaturesVec, "+float128") != FeaturesVec.end()) {

  148   for (const auto &Feature : Features) {

   43     if (Feature != Features.end()) {

  112     for (const auto &Feature : Features) {

  135   for (const auto &Feature : Features) {

  727   for (const auto &Feature : Features) {

  347     for (auto &FuncName : CodeGenOpts.getNoBuiltinFuncs())
  373   for (const auto &MapFile : Opts.RewriteMapFiles)
  502   for (const auto &Entry : HSOpts.UserEntries)
 1079   for (auto &PluginFN : CodeGenOpts.PassPlugins) {
 1387     for (auto &Summary : GlobalList.second.SummaryList) {

 1806   for (StringRef Attr : CodeGenOpts.DefaultFunctionAttrs) {

 2385     for (auto &M : PPOpts.Macros) {
 2391       for (char c : Macro)
 4690       for (auto &MD : P.second)
 4697   for (const auto &P : ReplaceMap) {
 4710   for (const auto &P : FwdDeclReplaceMap) {
 4731   for (auto &RT : RetainedTypes)

  499   for (CharUnits VBPtrOffset : VBPtrOffsets) {

 1576     for (auto *C : Categories) {
 1594     for (auto clsAlias : ClassAliases)
 1642       for (const auto &lateInit : EarlyInitList) {
 3669     for (auto &untypedSel : allSelectors) {
 3833        iter != ClassAliases.end(); ++iter) {

 5590     for (const auto *Sym : DefinedSymbols)
 5593     for (const auto *Sym : LazySymbols)

 1327   for (const auto &Pair : DeferredVariantFunction) {
 7979         if (It != Info.end()) {
 8017     for (const auto &M : Info) {
 8060       if (CI != DeferredInfo.end()) {
 8126     for (const auto &M : Info) {

 2301     for (auto &Rec : I->getSecond().LocalVarData) {
 4796   if (VDI != I->getSecond().LocalVarData.end())
 4805       if (VDI != I->getSecond().LocalVarData.end())

  570        IsZeroInitializableAsBase && Member != MemberEnd; ++Member) {
  591        Member != MemberEnd; ++Member) {
  623        Member != MemberEnd; ++Member) {
  653        Member != MemberEnd; ++Member) {
  669         Pad != PadEnd; ++Pad)
  677        Member != MemberEnd; ++Member) {

  579   for (const auto &LocalAddrPair : LocalAddrs) {
  611     if (I != LocalAddrs.end()) {

  997   for (const CXXRecordDecl *RD : DeferredVTables)
 1109   for (auto AP : AddressPoints) {

  902     for (const CodeGenOptions::BitcodeFileToLink &F :

  404   for (const auto &FuncletAndParent : TerminateFunclets)
 2224     for (const auto &F : ParsedAttr.Features) {

  300   for (const GlobalDecl &GD : Aliases) {
  360   for (const GlobalDecl &GD : Aliases) {
  977   for (StringRef Feat : Info.Features) {
 1088   if (FoundName != MangledDeclNames.end())
 1165   for (const auto &I : Fns) {
 1629     for (const CXXRecordDecl *Base : getMostBaseClasses(MD->getParent())) {
 2018   for (Module *M : ImportedModules) {
 2036     for (const auto &SM : Mod->submodules()) {
 2060   for (Module *M : LinkModules)
 2099   for (GlobalDecl &D : CurDeclsToEmit) {
 2151   for (const CXXRecordDecl *RD : OpportunisticVTables) {
 2854   for (GlobalDecl GD : MultiVersionFuncs) {
 5426            Sub != SubEnd; ++Sub) {
 5517   for (const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
 5583   for (auto &I : StaticExternCValues) {
 5610   for (auto &I : MangledDeclNames) {

   96   for (auto &entry : SelfReferences) {
  115     for (auto &entry : SelfReferences) {

  230     for (const auto &Region : SourceRegions) {
  310     for (const auto &Region : SourceRegions) {
 1395   for (auto &S : CoverageMappings) {

  752       for (const CXXRecordDecl *Base : CGM.getMostBaseClasses(RD)) {

  149       for (auto &&Lib : CodeGenOpts.DependentLibraries)
  151       for (auto &&Opt : CodeGenOpts.LinkerOptions)

   47   for (const auto &File : Scan) {

 1631     for (StringRef S : DiagnosticIDs::getDiagnosticFlags())
 1775     for (const Multilib &Multilib : TC.getMultilibs())

   92   for (StringRef Flag : Flags) {
  118   for (const auto &Flag : Flags)
  121   for (const auto &Flag : Other.Flags)
  145   for (StringRef Flag : M.flags()) {
  199       for (const auto &Base : *this) {
  249   for (StringRef Flag : Flags)
  253     for (StringRef Flag : M.flags()) {
  290   for (const auto &M : *this)

  955   for (const auto &BLPath : BlacklistFiles) {
  960   for (const auto &Dep : ExtraDeps) {

  859     for (const auto &P :

  265   if (std::find(ItBegin, ItEnd, "+v8.4a") != ItEnd) {
  286       const bool HasSM4  = (std::find(ItBegin, ItEnd, "+sm4") != ItEnd);
  287       const bool HasSHA3 = (std::find(ItBegin, ItEnd, "+sha3") != ItEnd);
  288       const bool HasSHA2 = (std::find(ItBegin, ItEnd, "+sha2") != ItEnd);
  289       const bool HasAES  = (std::find(ItBegin, ItEnd, "+aes") != ItEnd);
  308       const bool HasSHA2 = (std::find(ItBegin, ItEnd, "+sha2") != ItEnd);
  309       const bool HasAES  = (std::find(ItBegin, ItEnd, "+aes") != ItEnd);
  310       const bool HasV82a = (std::find(ItBegin, ItEnd, "+v8.2a") != ItEnd);
  311       const bool HasV83a = (std::find(ItBegin, ItEnd, "+v8.3a") != ItEnd);
  312       const bool HasV84a = (std::find(ItBegin, ItEnd, "+v8.4a") != ItEnd);

 5746   for (auto EHVal : EHArgs) {

  238     for (const auto &P : DriverArgs.getAllArgValues(options::OPT_isystem_after))

  404   for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
  487   for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_fatbinary))

  219         for (const auto &Path : PathsCallback(SelectedMultilib))

  421   for (const auto &Opt : ToolChain.ExtraOpts)
 1860   for (const auto &Multilib : Multilibs)

  151   for(auto OneFeature : Features) {
  314   for (auto Path :
  323   for (auto Lib : DriverArgs.getAllArgValues(options::OPT_hip_device_lib_EQ)) {

  232   for (const auto &Opt : HTC.ExtraOpts)
  341       for (StringRef Lib : OsLibs)
  443   for (auto &Dir : RootDirs) {

  216     for (const auto &Path : PathsCallback(Multilib))
  690       for (const auto &Path : Callback(GCCInstallation.getMultilib()))

  353     for (const auto &LibPath : Args.getAllArgValues(options::OPT_L))
  669   for (const auto &Include : Includes)
 1239   for (const auto &Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))

   86   for (auto Lib : Args.getAllArgValues(options::OPT_l))
  204   for (auto Lib : Args.getAllArgValues(options::OPT_l)) {

   59     for (const auto &Path : Callback(SelectedMultilib))
   99     for (std::string Path : Callback(SelectedMultilib)) {

  258       for (const auto &Path : Callback(GCCInstallation.getMultilib()))

  103       for (const auto &B : Bundles) {
  130     for (const auto &Filename :
  139     for (const auto &Filename :
  148     for (const auto &Filename :
  162       for (const auto &Arg : SpecifiedModes) {
  197   for (const auto &Always : AlwaysInstrumentFiles) {
  203   for (const auto &Never : NeverInstrumentFiles) {
  209   for (const auto &AttrFile : AttrListFiles) {
  215   for (const auto &Dep : ExtraDeps) {
  221   for (const auto &Mode : Modes) {