[Analysis] Use range-based for loops (NFC)

lib/Analysis/AliasSetTracker.cpp

@@ -283,9 +283,8 @@ Instruction* AliasSet::getUniqueInstruction() {
 
 void AliasSetTracker::clear() {
   // Delete all the PointerRec entries.
-  for (PointerMapType::iterator I = PointerMap.begin(), E = PointerMap.end();
+  for (auto &I : PointerMap)
-       I != E; ++I)
+    I.second->eraseFromList();
-    I->second->eraseFromList();
 
   PointerMap.clear();
 
@@ -303,12 +302,11 @@ AliasSet *AliasSetTracker::mergeAliasSetsForPointer(const Value *Ptr,
                                                     bool &MustAliasAll) {
   AliasSet *FoundSet = nullptr;
   AliasResult AllAR = MustAlias;
-  for (iterator I = begin(), E = end(); I != E;) {
+  for (AliasSet &AS : llvm::make_early_inc_range(*this)) {
-    iterator Cur = I++;
+    if (AS.Forward)
-    if (Cur->Forward)
       continue;
 
-    AliasResult AR = Cur->aliasesPointer(Ptr, Size, AAInfo, AA);
+    AliasResult AR = AS.aliasesPointer(Ptr, Size, AAInfo, AA);
     if (AR == NoAlias)
       continue;
 
@@ -317,10 +315,10 @@ AliasSet *AliasSetTracker::mergeAliasSetsForPointer(const Value *Ptr,
 
     if (!FoundSet) {
       // If this is the first alias set ptr can go into, remember it.
-      FoundSet = &*Cur;
+      FoundSet = &AS;
     } else {
       // Otherwise, we must merge the sets.
-      FoundSet->mergeSetIn(*Cur, *this);
+      FoundSet->mergeSetIn(AS, *this);
     }
   }
 
@@ -330,16 +328,15 @@ AliasSet *AliasSetTracker::mergeAliasSetsForPointer(const Value *Ptr,
 
 AliasSet *AliasSetTracker::findAliasSetForUnknownInst(Instruction *Inst) {
   AliasSet *FoundSet = nullptr;
-  for (iterator I = begin(), E = end(); I != E;) {
+  for (AliasSet &AS : llvm::make_early_inc_range(*this)) {
-    iterator Cur = I++;
+    if (AS.Forward || !AS.aliasesUnknownInst(Inst, AA))
-    if (Cur->Forward || !Cur->aliasesUnknownInst(Inst, AA))
       continue;
     if (!FoundSet) {
       // If this is the first alias set ptr can go into, remember it.
-      FoundSet = &*Cur;
+      FoundSet = &AS;
     } else {
       // Otherwise, we must merge the sets.
-      FoundSet->mergeSetIn(*Cur, *this);
+      FoundSet->mergeSetIn(AS, *this);
     }
   }
   return FoundSet;

lib/Analysis/DivergenceAnalysis.cpp

@@ -398,8 +398,7 @@ DivergenceAnalysisPrinterPass::run(Function &F, FunctionAnalysisManager &FAM) {
       OS << (DI.isDivergent(Arg) ? "DIVERGENT: " : "           ");
       OS << Arg << "\n";
     }
-    for (auto BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
+    for (const BasicBlock &BB : F) {
-      auto &BB = *BI;
       OS << "\n           " << BB.getName() << ":\n";
       for (auto &I : BB.instructionsWithoutDebug()) {
         OS << (DI.isDivergent(I) ? "DIVERGENT:     " : "               ");

lib/Analysis/IRSimilarityIdentifier.cpp

@@ -176,8 +176,8 @@ void IRInstructionMapper::convertToUnsignedVec(
 
   if (HaveLegalRange) {
     mapToIllegalUnsigned(It, IntegerMappingForBB, InstrListForBB, true);
-    for_each(InstrListForBB,
+    for (IRInstructionData *ID : InstrListForBB)
-             [this](IRInstructionData *ID) { this->IDL->push_back(*ID); });
+      this->IDL->push_back(*ID);
     llvm::append_range(InstrList, InstrListForBB);
     llvm::append_range(IntegerMapping, IntegerMappingForBB);
   }

lib/Analysis/IVDescriptors.cpp

@@ -609,9 +609,8 @@ bool RecurrenceDescriptor::hasMultipleUsesOf(
     Instruction *I, SmallPtrSetImpl<Instruction *> &Insts,
     unsigned MaxNumUses) {
   unsigned NumUses = 0;
-  for (User::op_iterator Use = I->op_begin(), E = I->op_end(); Use != E;
+  for (const Use &U : I->operands()) {
-       ++Use) {
+    if (Insts.count(dyn_cast<Instruction>(U)))
-    if (Insts.count(dyn_cast<Instruction>(*Use)))
       ++NumUses;
     if (NumUses > MaxNumUses)
       return true;

lib/Analysis/LoopInfo.cpp

@@ -876,17 +876,14 @@ void LoopInfo::erase(Loop *Unloop) {
   // First handle the special case of no parent loop to simplify the algorithm.
   if (Unloop->isOutermost()) {
     // Since BBLoop had no parent, Unloop blocks are no longer in a loop.
-    for (Loop::block_iterator I = Unloop->block_begin(),
+    for (BasicBlock *BB : Unloop->blocks()) {
-                              E = Unloop->block_end();
-         I != E; ++I) {
-
       // Don't reparent blocks in subloops.
-      if (getLoopFor(*I) != Unloop)
+      if (getLoopFor(BB) != Unloop)
         continue;
 
       // Blocks no longer have a parent but are still referenced by Unloop until
       // the Unloop object is deleted.
-      changeLoopFor(*I, nullptr);
+      changeLoopFor(BB, nullptr);
     }
 
     // Remove the loop from the top-level LoopInfo object.

lib/Analysis/MemorySSAUpdater.cpp

@@ -1395,11 +1395,9 @@ void MemorySSAUpdater::removeBlocks(
     MemorySSA::AccessList *Acc = MSSA->getWritableBlockAccesses(BB);
     if (!Acc)
       continue;
-    for (auto AB = Acc->begin(), AE = Acc->end(); AB != AE;) {
+    for (MemoryAccess &MA : llvm::make_early_inc_range(*Acc)) {
-      MemoryAccess *MA = &*AB;
+      MSSA->removeFromLookups(&MA);
-      ++AB;
+      MSSA->removeFromLists(&MA);
-      MSSA->removeFromLookups(MA);
-      MSSA->removeFromLists(MA);
     }
   }
 }

lib/Analysis/ModuleSummaryAnalysis.cpp

@@ -511,10 +511,8 @@ static void findFuncPointers(const Constant *I, uint64_t StartingOffset,
     assert(STy);
     const StructLayout *SL = DL.getStructLayout(C->getType());
 
-    for (StructType::element_iterator EB = STy->element_begin(), EI = EB,
+    for (auto EI : llvm::enumerate(STy->elements())) {
-                                      EE = STy->element_end();
+      auto Offset = SL->getElementOffset(EI.index());
-         EI != EE; ++EI) {
-      auto Offset = SL->getElementOffset(EI - EB);
       unsigned Op = SL->getElementContainingOffset(Offset);
       findFuncPointers(cast<Constant>(I->getOperand(Op)),
                        StartingOffset + Offset, M, Index, VTableFuncs);

lib/Analysis/VectorUtils.cpp

@@ -586,8 +586,8 @@ llvm::computeMinimumValueSizes(ArrayRef<BasicBlock *> Blocks, DemandedBits &DB,
 
   for (auto I = ECs.begin(), E = ECs.end(); I != E; ++I) {
     uint64_t LeaderDemandedBits = 0;
-    for (auto MI = ECs.member_begin(I), ME = ECs.member_end(); MI != ME; ++MI)
+    for (Value *M : llvm::make_range(ECs.member_begin(I), ECs.member_end()))
-      LeaderDemandedBits |= DBits[*MI];
+      LeaderDemandedBits |= DBits[M];
 
     uint64_t MinBW = (sizeof(LeaderDemandedBits) * 8) -
                      llvm::countLeadingZeros(LeaderDemandedBits);
@@ -600,22 +600,22 @@ llvm::computeMinimumValueSizes(ArrayRef<BasicBlock *> Blocks, DemandedBits &DB,
     // indvars.
     // If we are required to shrink a PHI, abandon this entire equivalence class.
     bool Abort = false;
-    for (auto MI = ECs.member_begin(I), ME = ECs.member_end(); MI != ME; ++MI)
+    for (Value *M : llvm::make_range(ECs.member_begin(I), ECs.member_end()))
-      if (isa<PHINode>(*MI) && MinBW < (*MI)->getType()->getScalarSizeInBits()) {
+      if (isa<PHINode>(M) && MinBW < M->getType()->getScalarSizeInBits()) {
         Abort = true;
         break;
       }
     if (Abort)
       continue;
 
-    for (auto MI = ECs.member_begin(I), ME = ECs.member_end(); MI != ME; ++MI) {
+    for (Value *M : llvm::make_range(ECs.member_begin(I), ECs.member_end())) {
-      if (!isa<Instruction>(*MI))
+      if (!isa<Instruction>(M))
         continue;
-      Type *Ty = (*MI)->getType();
+      Type *Ty = M->getType();
-      if (Roots.count(*MI))
+      if (Roots.count(M))
-        Ty = cast<Instruction>(*MI)->getOperand(0)->getType();
+        Ty = cast<Instruction>(M)->getOperand(0)->getType();
       if (MinBW < Ty->getScalarSizeInBits())
-        MinBWs[cast<Instruction>(*MI)] = MinBW;
+        MinBWs[cast<Instruction>(M)] = MinBW;
     }
   }