[BOLT][NFC] Use llvm::reverse

[Amir]

Summary

Use llvm::reverse instead of for (auto I = rbegin(), E = rend(); I != E; ++I)

bolt/include/bolt/Passes/DataflowAnalysis.h

if (!Backward) {
         Worklist.push(&BB);
         MCInst *Prev = nullptr;
         for (MCInst &Inst : BB) {
           PrevPoint[&Inst] = Prev ? ProgramPoint(Prev) : ProgramPoint(&BB);
           Prev = &Inst;
         }
       }
     } else {
-      for (auto I = Func.rbegin(), E = Func.rend(); I != E; ++I) {
-        Worklist.push(&*I);
+      for (BinaryBasicBlock &BB : llvm::reverse(Func)) {
+        Worklist.push(&BB);
         MCInst *Prev = nullptr;
-        for (auto J = (*I).rbegin(), E2 = (*I).rend(); J != E2; ++J) {
-          MCInst &Inst = *J;
-          PrevPoint[&Inst] = Prev ? ProgramPoint(Prev) : ProgramPoint(&*I);
+        for (MCInst &Inst : llvm::reverse(BB)) {
+          PrevPoint[&Inst] = Prev ? ProgramPoint(Prev) : ProgramPoint(&BB);
           Prev = &Inst;
         }
       }
     }
 
     // Main dataflow loop
     while (!Worklist.empty()) {
       BinaryBasicBlock *BB = Worklist.front();
while (!Worklist.empty()) {
         }
         PrevState = &St;
       };
 
       if (!Backward)
         for (MCInst &Inst : *BB)
           doNext(Inst, *BB);
       else
-        for (auto I = BB->rbegin(), E = BB->rend(); I != E; ++I)
-          doNext(*I, *BB);
+        for (MCInst &Inst : llvm::reverse(*BB))
+          doNext(Inst, *BB);
 
       if (Changed) {
         if (!Backward) {
           for (BinaryBasicBlock *Succ : BB->successors())
             Worklist.push(Succ);
           for (BinaryBasicBlock *LandingPad : BB->landing_pads())
             Worklist.push(LandingPad);
         } else {

bolt/lib/Core/BinaryBasicBlock.cpp

assert(
       "can only calculate CFI state when function is in or past the CFG state");
 
   const BinaryFunction::CFIInstrMapType &FDEProgram =
       getFunction()->getFDEProgram();
 
   // Find the last CFI preceding Instr in this basic block.
   const MCInst *LastCFI = nullptr;
   bool InstrSeen = (Instr == nullptr);
-  for (auto RII = Instructions.rbegin(), E = Instructions.rend(); RII != E;
-       ++RII) {
+  for (const MCInst &Inst : llvm::reverse(Instructions)) {
     if (!InstrSeen) {
-      InstrSeen = (&*RII == Instr);
+      InstrSeen = (&Inst == Instr);
       continue;
     }
-    if (Function->getBinaryContext().MIB->isCFI(*RII)) {
-      LastCFI = &*RII;
+    if (Function->getBinaryContext().MIB->isCFI(Inst)) {
+      LastCFI = &Inst;
       break;
     }
   }
 
   assert(InstrSeen && "instruction expected in basic block");
 
   // CFI state is the same as at basic block entry point.
   if (!LastCFI)

bolt/lib/Core/BinaryFunction.cpp

BinaryFunction::processIndirectBranch(MCInst &Instruction, unsigned Size,
   uint64_t PCRelAddr = 0;
 
   auto Begin = Instructions.begin();
   if (BC.isAArch64()) {
     PreserveNops = BC.HasRelocations;
     // Start at the last label as an approximation of the current basic block.
     // This is a heuristic, since the full set of labels have yet to be
     // determined
-    for (auto LI = Labels.rbegin(); LI != Labels.rend(); ++LI) {
-      auto II = Instructions.find(LI->first);
+    for (const uint32_t Offset :
+         llvm::make_first_range(llvm::reverse(Labels))) {
+      auto II = Instructions.find(Offset);
       if (II != Instructions.end()) {
         Begin = II;
         break;
       }
     }
   }
 
   IndirectBranchType BranchType = BC.MIB->analyzeIndirectBranch(
if (Instr->getOperation() == MCCFIInstruction::OpRestoreState) {
       NewCFIs.insert(NewCFIs.end(), Iter->second.begin(), Iter->second.end());
       // RestoreState / Remember will be filtered out later by CFISnapshotDiff,
       // so we might as well fall-through here.
     }
     NewCFIs.push_back(CurState);
   }
 
   // Replay instructions while avoiding duplicates
-  for (auto I = NewCFIs.rbegin(), E = NewCFIs.rend(); I != E; ++I) {
-    if (CFIDiff.isRedundant(FrameInstructions[*I]))
+  for (int32_t State : llvm::reverse(NewCFIs)) {
+    if (CFIDiff.isRedundant(FrameInstructions[State]))
       continue;
-    InsertIt = addCFIPseudo(InBB, InsertIt, *I);
+    InsertIt = addCFIPseudo(InBB, InsertIt, State);
   }
 
   return true;
 }
 
 SmallVector<int32_t, 4>
 BinaryFunction::unwindCFIState(int32_t FromState, int32_t ToState,
                                BinaryBasicBlock *InBB,

bolt/lib/Core/DebugData.cpp

for (auto I = Abbrevs->begin(), E = Abbrevs->end(); I != E; ++I) {
     encodeULEB128(Abbrev.getCode(), OS);
     encodeULEB128(Abbrev.getTag(), OS);
     encodeULEB128(Abbrev.hasChildren(), OS);
     for (const DWARFAbbreviationDeclaration::AttributeSpec &AttrSpec :
          Abbrev.attributes()) {
       if (Patch != UnitPatches.end()) {
         bool Patched = false;
         // Patches added later take a precedence over earlier ones.
-        for (auto I = Patch->second.rbegin(), E = Patch->second.rend(); I != E;
-             ++I) {
-          if (I->OldAttr != AttrSpec.Attr)
+        for (const PatchInfo &PI : llvm::reverse(Patch->second)) {
+          if (PI.OldAttr != AttrSpec.Attr)
             continue;
 
-          encodeULEB128(I->NewAttr, OS);
-          encodeULEB128(I->NewAttrForm, OS);
+          encodeULEB128(PI.NewAttr, OS);
+          encodeULEB128(PI.NewAttrForm, OS);
           Patched = true;
           break;
         }
         if (Patched)
           continue;
       }
 
       encodeULEB128(AttrSpec.Attr, OS);

bolt/lib/Core/DynoStats.cpp

if (opts::PrintDynoOpcodeStat && Printer) {
     for (const OpcodeStatTy &Stat : OpcodeHistogram)
       SortedHistogram.emplace_back(Stat.second.first, Stat.first);
 
     // Sort using lexicographic ordering
     llvm::sort(SortedHistogram);
 
     // Dump in ascending order: Start with Opcode with Highest execution
     // count.
-    for (auto Stat = SortedHistogram.rbegin(); Stat != SortedHistogram.rend();
-         ++Stat) {
-      OS << format("%20s,%'18lld", Printer->getOpcodeName(Stat->second).data(),
-                   Stat->first * opts::DynoStatsScale);
+    for (auto &Stat : llvm::reverse(SortedHistogram)) {
+      OS << format("%20s,%'18lld", Printer->getOpcodeName(Stat.second).data(),
+                   Stat.first * opts::DynoStatsScale);
 
-      MaxOpcodeHistogramTy MaxMultiMap =
-          OpcodeHistogram.at(Stat->second).second;
+      MaxOpcodeHistogramTy MaxMultiMap = OpcodeHistogram.at(Stat.second).second;
       // Start with function name:BB offset with highest execution count.
-      for (auto Max = MaxMultiMap.rbegin(); Max != MaxMultiMap.rend(); ++Max) {
-        OS << format(", %'18lld, ", Max->first * opts::DynoStatsScale)
-           << Max->second.first.str() << ':' << Max->second.second;
+      for (auto &Max : llvm::reverse(MaxMultiMap)) {
+        OS << format(", %'18lld, ", Max.first * opts::DynoStatsScale)
+           << Max.second.first.str() << ':' << Max.second.second;
       }
       OS << '\n';
     }
   }
 }
 
 void DynoStats::operator+=(const DynoStats &Other) {
   for (auto Stat = DynoStats::FIRST_DYNO_STAT + 1;
        Stat < DynoStats::LAST_DYNO_STAT; ++Stat) {
     Stats[Stat] += Other[Stat];
   }
   for (const OpcodeStatTy &Stat : Other.OpcodeHistogram) {
     auto I = OpcodeHistogram.find(Stat.first);
     if (I == OpcodeHistogram.end()) {
       OpcodeHistogram.emplace(Stat);
     } else {
       // Merge Other Historgrams, log only the opts::PrintDynoOpcodeStat'th
       // maximum counts.
       I->second.first += Stat.second.first;
       auto &MMap = I->second.second;
       auto &OtherMMap = Stat.second.second;
       auto Size = MMap.size();
       assert(Size <= opts::PrintDynoOpcodeStat);
-      for (auto Iter = OtherMMap.rbegin(); Iter != OtherMMap.rend(); ++Iter) {
+      for (auto OtherMMapPair : llvm::reverse(OtherMMap)) {
         if (Size++ >= opts::PrintDynoOpcodeStat) {
           auto First = MMap.begin();
-          if (Iter->first <= First->first)
+          if (OtherMMapPair.first <= First->first)
             break;
           MMap.erase(First);
         }
-        MMap.emplace(*Iter);
+        MMap.emplace(OtherMMapPair);
       }
     }
   }
 }
 
 DynoStats getDynoStats(BinaryFunction &BF) {
   auto &BC = BF.getBinaryContext();
 

bolt/lib/Passes/AllocCombiner.cpp

 }
 
 } // end anonymous namespace
 
 void AllocCombinerPass::combineAdjustments(BinaryFunction &BF) {
   BinaryContext &BC = BF.getBinaryContext();
   for (BinaryBasicBlock &BB : BF) {
     MCInst *Prev = nullptr;
-    for (auto I = BB.rbegin(), E = BB.rend(); I != E; ++I) {
-      MCInst &Inst = *I;
+    for (MCInst &Inst : llvm::reverse(BB)) {
       if (isIndifferentToSP(Inst, BC))
         continue; // Skip updating Prev
 
       int64_t Adjustment = 0LL;
       if (!Prev || !BC.MIB->isStackAdjustment(Inst) ||
           !BC.MIB->isStackAdjustment(*Prev) ||
           !getStackAdjustmentSize(BC, *Prev, Adjustment)) {
         Prev = &Inst;

bolt/lib/Passes/FrameOptimizer.cpp

void FrameOptimizerPass::removeUnusedStores(const FrameAnalysis &FA,
   SRU.run();
 
   LLVM_DEBUG(dbgs() << "Performing unused stores removal\n");
   std::vector<std::pair<BinaryBasicBlock *, MCInst *>> ToErase;
   bool Changed = false;
   for (BinaryBasicBlock &BB : BF) {
     LLVM_DEBUG(dbgs() << "\tNow at BB " << BB.getName() << "\n");
     const MCInst *Prev = nullptr;
-    for (auto I = BB.rbegin(), E = BB.rend(); I != E; ++I) {
-      MCInst &Inst = *I;
+    for (MCInst &Inst : llvm::reverse(BB)) {
       LLVM_DEBUG({
         dbgs() << "\t\tNow at ";
         Inst.dump();
         for (auto I = Prev ? SRU.expr_begin(*Prev) : SRU.expr_begin(BB);
              I != SRU.expr_end(); ++I) {
           dbgs() << "\t\t\tReached by: ";
           (*I)->dump();
         }

bolt/lib/Passes/ShrinkWrapping.cpp

 }
 
 void CalleeSavedAnalysis::analyzeRestores() {
   ReachingDefOrUse</*Def=*/false> &RU = Info.getReachingUses();
 
   // Now compute all restores of these callee-saved regs
   for (BinaryBasicBlock &BB : BF) {
     const MCInst *Prev = nullptr;
-    for (auto I = BB.rbegin(), E = BB.rend(); I != E; ++I) {
-      MCInst &Inst = *I;
+    for (MCInst &Inst : llvm::reverse(BB)) {
       if (ErrorOr<const FrameIndexEntry &> FIE = FA.getFIEFor(Inst)) {
         if (!FIE->IsLoad || !CalleeSaved[FIE->RegOrImm]) {
           Prev = &Inst;
           continue;
         }
 
         // If this reg is used locally after a restore, then we are probably
         // not dealing with a callee-saved reg. Except if this use is by

 }
 
 void StackLayoutModifier::classifyStackAccesses() {
   // Understand when stack slots are being used non-locally
   StackReachingUses &SRU = Info.getStackReachingUses();
 
   for (BinaryBasicBlock &BB : BF) {
     const MCInst *Prev = nullptr;
-    for (auto I = BB.rbegin(), E = BB.rend(); I != E; ++I) {
-      MCInst &Inst = *I;
+    for (MCInst &Inst : llvm::reverse(BB)) {
       checkFramePointerInitialization(Inst);
       checkStackPointerRestore(Inst);
       ErrorOr<const FrameIndexEntry &> FIEX = FA.getFIEFor(Inst);
       if (!FIEX) {
         Prev = &Inst;
         continue;
       }
       if (!FIEX->IsSimple || (FIEX->IsStore && !FIEX->IsStoreFromReg)) {
bool StackLayoutModifier::insertRegion(ProgramPoint P, int64_t RegionSz) {
 
   InsertedRegions.insert(RegionAddr);
   return true;
 }
 
 void StackLayoutModifier::performChanges() {
   std::set<uint32_t> ModifiedCFIIndices;
   for (BinaryBasicBlock &BB : BF) {
-    for (auto I = BB.rbegin(), E = BB.rend(); I != E; ++I) {
-      MCInst &Inst = *I;
+    for (MCInst &Inst : llvm::reverse(BB)) {
       if (BC.MIB->hasAnnotation(Inst, "AccessesDeletedPos")) {
         assert(BC.MIB->isPop(Inst) || BC.MIB->isPush(Inst));
         BC.MIB->removeAnnotation(Inst, "AccessesDeletedPos");
       }
       if (!BC.MIB->hasAnnotation(Inst, getTodoTag()))
         continue;
       auto &WList = BC.MIB->getAnnotationAs<std::vector<WorklistItem>>(
           Inst, getTodoTag());
if (SPT.getStateAt(ProgramPoint::getLastPointAt(*BB))->first ==
       BitVector BV = *RI.getStateAt(ProgramPoint::getLastPointAt(*BB));
       BV &= UsesByReg[CSR];
       if (!BV.any()) {
         Found = true;
         PP = BB;
         continue;
       }
     }
-    for (auto RIt = BB->rbegin(), End = BB->rend(); RIt != End; ++RIt) {
-      if (SPT.getStateBefore(*RIt)->first == SaveOffset) {
-        BitVector BV = *RI.getStateAt(*RIt);
+    for (MCInst &Inst : llvm::reverse(*BB)) {
+      if (SPT.getStateBefore(Inst)->first == SaveOffset) {
+        BitVector BV = *RI.getStateAt(Inst);
         BV &= UsesByReg[CSR];
         if (!BV.any()) {
           Found = true;
-          PP = &*RIt;
+          PP = &Inst;
           break;
         }
       }
     }
     if (!Found) {
       LLVM_DEBUG({
         dbgs() << "Could not find restore insertion point for " << CSR
                << ", falling back to load/store mode\n";
       });
       FixedRestorePoints.clear();
       return FixedRestorePoints;
     }
   }
   return FixedRestorePoints;
 }
 
 void ShrinkWrapping::scheduleOldSaveRestoresRemoval(unsigned CSR,
                                                     bool UsePushPops) {
 
   for (BinaryBasicBlock *BB : BF.getLayout().blocks()) {
     std::vector<MCInst *> CFIs;
-    for (auto I = BB->rbegin(), E = BB->rend(); I != E; ++I) {
-      MCInst &Inst = *I;
+    for (MCInst &Inst : llvm::reverse(*BB)) {
       if (BC.MIB->isCFI(Inst)) {
         // Delete all offset CFIs related to this CSR
         if (SLM.getOffsetCFIReg(Inst) == CSR) {
           HasDeletedOffsetCFIs[CSR] = true;
           scheduleChange(&Inst, WorklistItem(WorklistItem::Erase, CSR));
           continue;
         }
         CFIs.push_back(&Inst);
if (DisablePushPopMode && UsedPushPopMode) {
     for (BinaryBasicBlock &BB : BF) {
       auto WRI = Todo.find(&BB);
       if (WRI != Todo.end()) {
         std::vector<WorklistItem> &TodoList = WRI->second;
         for (WorklistItem &Item : TodoList)
           if (Item.Action == WorklistItem::InsertPushOrPop)
             Item.Action = WorklistItem::InsertLoadOrStore;
       }
-      for (auto I = BB.rbegin(), E = BB.rend(); I != E; ++I) {
-        MCInst &Inst = *I;
+      for (MCInst &Inst : llvm::reverse(BB)) {
         auto TodoList = BC.MIB->tryGetAnnotationAs<std::vector<WorklistItem>>(
             Inst, getAnnotationIndex());
         if (!TodoList)
           continue;
         bool isCFI = BC.MIB->isCFI(Inst);
         for (WorklistItem &Item : *TodoList) {
           if (Item.Action == WorklistItem::InsertPushOrPop)
             Item.Action = WorklistItem::InsertLoadOrStore;

 } // namespace
 
 bool ShrinkWrapping::foldIdenticalSplitEdges() {
   bool Changed = false;
   for (auto Iter = BF.begin(); Iter != BF.end(); ++Iter) {
     BinaryBasicBlock &BB = *Iter;
     if (!BB.getName().startswith(".LSplitEdge"))
       continue;
-    for (auto RIter = BF.rbegin(); RIter != BF.rend(); ++RIter) {
-      BinaryBasicBlock &RBB = *RIter;
+    for (BinaryBasicBlock &RBB : llvm::reverse(BF)) {
       if (&RBB == &BB)
         break;
       if (!RBB.getName().startswith(".LSplitEdge") || !RBB.isValid() ||
           !isIdenticalSplitEdgeBB(BC, *Iter, RBB))
         continue;
       assert(RBB.pred_size() == 1 && "Invalid split edge BB");
       BinaryBasicBlock *Pred = *RBB.pred_begin();
       uint64_t OrigCount = Pred->branch_info_begin()->Count;

 };
 
 } // end anonymous namespace
 
 void ShrinkWrapping::insertUpdatedCFI(unsigned CSR, int SPValPush,
                                       int SPValPop) {
   MCInst *SavePoint = nullptr;
   for (BinaryBasicBlock &BB : BF) {
-    for (auto InstIter = BB.rbegin(), EndIter = BB.rend(); InstIter != EndIter;
-         ++InstIter) {
+    for (MCInst &Inst : llvm::reverse(BB)) {
       int32_t SrcImm = 0;
       MCPhysReg Reg = 0;
       MCPhysReg StackPtrReg = 0;
       int64_t StackOffset = 0;
       bool IsIndexed = false;
       bool IsLoad = false;
       bool IsStore = false;
       bool IsSimple = false;
       bool IsStoreFromReg = false;
       uint8_t Size = 0;
-      if (!BC.MIB->isStackAccess(*InstIter, IsLoad, IsStore, IsStoreFromReg,
-                                 Reg, SrcImm, StackPtrReg, StackOffset, Size,
+      if (!BC.MIB->isStackAccess(Inst, IsLoad, IsStore, IsStoreFromReg, Reg,
+                                 SrcImm, StackPtrReg, StackOffset, Size,
                                  IsSimple, IsIndexed))
         continue;
       if (Reg != CSR || !IsStore || !IsSimple)
         continue;
-      SavePoint = &*InstIter;
+      SavePoint = &Inst;
       break;
     }
     if (SavePoint)
       break;
   }
   assert(SavePoint);
   LLVM_DEBUG({
     dbgs() << "Now using as save point for reg " << CSR << " :";

bolt/lib/Profile/DataReader.cpp

if (NormalizeByInsnCount)
       outs() << "BOLT-INFO: normalizing samples by instruction count.\n";
     else if (NormalizeByCalls)
       outs() << "BOLT-INFO: normalizing samples by branches.\n";
 
     NagUser = false;
   }
   uint64_t LastOffset = BF.getSize();
   uint64_t TotalEntryCount = 0;
-  for (auto I = BF.BasicBlockOffsets.rbegin(), E = BF.BasicBlockOffsets.rend();
-       I != E; ++I) {
-    uint64_t CurOffset = I->first;
+  for (BinaryFunction::BasicBlockOffset &BBOffset :
+       llvm::reverse(BF.BasicBlockOffsets)) {
+    uint64_t CurOffset = BBOffset.first;
     // Always work with samples multiplied by 1000 to avoid losing them if we
     // later need to normalize numbers
     uint64_t NumSamples =
         SampleDataOrErr->getSamples(CurOffset, LastOffset) * 1000;
-    if (NormalizeByInsnCount && I->second->getNumNonPseudos()) {
-      NumSamples /= I->second->getNumNonPseudos();
+    if (NormalizeByInsnCount && BBOffset.second->getNumNonPseudos()) {
+      NumSamples /= BBOffset.second->getNumNonPseudos();
     } else if (NormalizeByCalls) {
-      uint32_t NumCalls = I->second->getNumCalls();
+      uint32_t NumCalls = BBOffset.second->getNumCalls();
       NumSamples /= NumCalls + 1;
     }
-    I->second->setExecutionCount(NumSamples);
-    if (I->second->isEntryPoint())
+    BBOffset.second->setExecutionCount(NumSamples);
+    if (BBOffset.second->isEntryPoint())
       TotalEntryCount += NumSamples;
     LastOffset = CurOffset;
   }
 
   BF.ExecutionCount = TotalEntryCount;
 
   estimateEdgeCounts(BF);
 }

 }
 
 namespace {
 template <typename MapTy>
 decltype(MapTy::MapEntryTy::second) *
 fetchMapEntry(MapTy &Map, const std::vector<MCSymbol *> &Symbols) {
   // Do a reverse order iteration since the name in profile has a higher chance
   // of matching a name at the end of the list.
-  for (auto SI = Symbols.rbegin(), SE = Symbols.rend(); SI != SE; ++SI) {
-    auto I = Map.find(normalizeName((*SI)->getName()));
+  for (const MCSymbol *Symbol : llvm::reverse(Symbols)) {
+    auto I = Map.find(normalizeName(Symbol->getName()));
     if (I != Map.end())
       return &I->getValue();
   }
   return nullptr;
 }
 
 template <typename MapTy>
 decltype(MapTy::MapEntryTy::second) *
 fetchMapEntry(MapTy &Map, const std::vector<StringRef> &FuncNames) {
   // Do a reverse order iteration since the name in profile has a higher chance
   // of matching a name at the end of the list.
-  for (auto FI = FuncNames.rbegin(), FE = FuncNames.rend(); FI != FE; ++FI) {
-    auto I = Map.find(normalizeName(*FI));
+  for (StringRef Name : llvm::reverse(FuncNames)) {
+    auto I = Map.find(normalizeName(Name));
     if (I != Map.end())
       return &I->getValue();
   }
   return nullptr;
 }
 
 template <typename MapTy>
 std::vector<decltype(MapTy::MapEntryTy::second) *> fetchMapEntriesRegex(
     MapTy &Map,
     const StringMap<std::vector<decltype(MapTy::MapEntryTy::second) *>>
         &LTOCommonNameMap,
     const std::vector<StringRef> &FuncNames) {
   std::vector<decltype(MapTy::MapEntryTy::second) *> AllData;
   // Do a reverse order iteration since the name in profile has a higher chance
   // of matching a name at the end of the list.
-  for (auto FI = FuncNames.rbegin(), FE = FuncNames.rend(); FI != FE; ++FI) {
-    std::string Name = normalizeName(*FI);
+  for (StringRef FuncName : llvm::reverse(FuncNames)) {
+    std::string Name = normalizeName(FuncName);
     const std::optional<StringRef> LTOCommonName = getLTOCommonName(Name);
     if (LTOCommonName) {
       auto I = LTOCommonNameMap.find(*LTOCommonName);
       if (I != LTOCommonNameMap.end()) {
         const std::vector<decltype(MapTy::MapEntryTy::second) *> &CommonData =
             I->getValue();
         AllData.insert(AllData.end(), CommonData.begin(), CommonData.end());
       }

bolt/lib/Rewrite/BoltDiff.cpp

 //===- bolt/Rewrite/BoltDiff.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // RewriteInstance methods related to comparing one instance to another, used
 // by the boltdiff tool to print a report.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Passes/IdenticalCodeFolding.h"
 #include "bolt/Profile/ProfileReaderBase.h"
 #include "bolt/Rewrite/RewriteInstance.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 
 #undef  DEBUG_TYPE
 #define DEBUG_TYPE "boltdiff"
 
 using namespace llvm;
 using namespace object;
 using namespace bolt;
void reportHottestBBDiffs() {
     unsigned Printed = 0;
     setTitleColor();
     outs()
         << "\nTop " << opts::DisplayCount
         << " largest differences in basic block performance bin 2 -> bin 1:\n";
     outs() << "=========================================================\n";
     setRegularColor();
     outs() << " * Functions with different contents do not appear here\n\n";
-    for (auto I = LargestDiffs.rbegin(), E = LargestDiffs.rend(); I != E; ++I) {
-      const BinaryBasicBlock *BB2 = I->second;
+    for (const BinaryBasicBlock *BB2 :
+         llvm::make_second_range(llvm::reverse(LargestDiffs))) {
       const double Score2 = getNormalizedScore(*BB2, RI2);
       const double Score1 = getNormalizedScore(*BBMap[BB2], RI1);
       outs() << "BB " << BB2->getName() << " from "
              << BBToFuncMap[BB2]->getDemangledName()
              << "\n\tScore bin1 = " << format("%.4f", Score1 * 100.0)
              << "%\n\tScore bin2 = " << format("%.4f", Score2 * 100.0);
       outs() << "%\t(Difference: ";
       printColoredPercentage((Score2 - Score1) * 100.0);
class RewriteInstanceDiff {
   void reportHottestEdgeDiffs() {
     unsigned Printed = 0;
     setTitleColor();
     outs() << "\nTop " << opts::DisplayCount
            << " largest differences in edge hotness bin 2 -> bin 1:\n";
     outs() << "=========================================================\n";
     setRegularColor();
     outs() << " * Functions with different contents do not appear here\n";
-    for (auto I = EdgeMap.rbegin(), E = EdgeMap.rend(); I != E; ++I) {
-      std::tuple<const BinaryBasicBlock *, const BinaryBasicBlock *, double>
-          &Edge2 = I->second.first;
-      std::tuple<const BinaryBasicBlock *, const BinaryBasicBlock *, double>
-          &Edge1 = I->second.second;
+    for (std::pair<EdgeTy, EdgeTy> &EI :
+         llvm::make_second_range(llvm::reverse(EdgeMap))) {
+      EdgeTy &Edge2 = EI.first;
+      EdgeTy &Edge1 = EI.second;
       const double Score2 = std::get<2>(Edge2);
       const double Score1 = std::get<2>(Edge1);
       outs() << "Edge (" << std::get<0>(Edge2)->getName() << " -> "
              << std::get<1>(Edge2)->getName() << ") in "
              << BBToFuncMap[std::get<0>(Edge2)]->getDemangledName()
              << "\n\tScore bin1 = " << format("%.4f", Score1 * 100.0)
              << "%\n\tScore bin2 = " << format("%.4f", Score2 * 100.0);
       outs() << "%\t(Difference: ";
void reportHottestFuncDiffs() {
     }
 
     unsigned Printed = 0;
     setTitleColor();
     outs() << "\nTop " << opts::DisplayCount
            << " largest differences in performance bin 2 -> bin 1:\n";
     outs() << "=========================================================\n";
     setRegularColor();
-    for (auto I = LargestDiffs.rbegin(), E = LargestDiffs.rend(); I != E; ++I) {
-      const std::pair<const BinaryFunction *const, const BinaryFunction *>
-          &MapEntry = I->second;
+    for (decltype(this->FuncMap)::value_type &MapEntry :
+         llvm::make_second_range(llvm::reverse(LargestDiffs))) {
       if (opts::IgnoreUnchanged &&
           MapEntry.second->computeHash(/*UseDFS=*/true) ==
               MapEntry.first->computeHash(/*UseDFS=*/true))
         continue;
       const std::pair<double, double> &Scores = ScoreMap[MapEntry.first];
       outs() << "Function " << MapEntry.first->getDemangledName();
       if (MapEntry.first->getDemangledName() !=
           MapEntry.second->getDemangledName())
class RewriteInstanceDiff {
   /// Print hottest functions from each binary
   void reportHottestFuncs() {
     unsigned Printed = 0;
     setTitleColor();
     outs() << "\nTop " << opts::DisplayCount
            << " hottest functions in binary 2:\n";
     outs() << "=====================================\n";
     setRegularColor();
-    for (auto I = LargestBin2.rbegin(), E = LargestBin2.rend(); I != E; ++I) {
-      const std::pair<const double, const BinaryFunction *> &MapEntry = *I;
+    for (std::pair<const double, const BinaryFunction *> &MapEntry :
+         llvm::reverse(LargestBin2)) {
       outs() << "Function " << MapEntry.second->getDemangledName() << "\n";
       auto Iter = ScoreMap.find(MapEntry.second);
       if (Iter != ScoreMap.end())
         outs() << "\tScore bin1 = "
                << format("%.2f", Iter->second.first * 100.0) << "%\n";
       outs() << "\tScore bin2 = " << format("%.2f", MapEntry.first * 100.0)
              << "%\n";
       if (Printed++ == opts::DisplayCount)
         break;
     }
 
     Printed = 0;
     setTitleColor();
     outs() << "\nTop " << opts::DisplayCount
            << " hottest functions in binary 1:\n";
     outs() << "=====================================\n";
     setRegularColor();
-    for (auto I = LargestBin1.rbegin(), E = LargestBin1.rend(); I != E; ++I) {
-      const std::pair<const double, const BinaryFunction *> &MapEntry = *I;
+    for (const std::pair<const double, const BinaryFunction *> &MapEntry :
+         llvm::reverse(LargestBin1)) {
       outs() << "Function " << MapEntry.second->getDemangledName()
              << "\n\tScore bin1 = " << format("%.2f", MapEntry.first * 100.0)
              << "%\n";
       if (Printed++ == opts::DisplayCount)
         break;
     }
   }