Use make_range(rbegin(), rend()) to allow foreach loops. NFC.

Instead of the pattern

for (auto I = x.rbegin(), E = x.end(); I != E; ++I)

we can use make_range to construct the reverse range and iterate using
that instead.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@243163 91177308-0d34-0410-b5e6-96231b3b80d8

lib/CodeGen/AsmPrinter/ARMException.cpp

@@ -115,9 +115,8 @@ void ARMException::emitTypeInfos(unsigned TTypeEncoding) {
     Entry = TypeInfos.size();
   }
 
-  for (std::vector<const GlobalValue *>::const_reverse_iterator
+  for (const GlobalValue *GV : make_range(TypeInfos.rbegin(),
-         I = TypeInfos.rbegin(), E = TypeInfos.rend(); I != E; ++I) {
+                                          TypeInfos.rend())) {
-    const GlobalValue *GV = *I;
     if (VerboseAsm)
       Asm->OutStreamer->AddComment("TypeInfo " + Twine(Entry--));
     Asm->EmitTTypeReference(GV, TTypeEncoding);

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

@@ -804,8 +804,7 @@ std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
 
   // Reverse iterate over our list to go from the outermost construct to the
   // innermost.
-  for (auto I = Parents.rbegin(), E = Parents.rend(); I != E; ++I) {
+  for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
-    const DIScope *Ctx = *I;
     StringRef Name = Ctx->getName();
     if (Name.empty() && isa<DINamespace>(Ctx))
       Name = "(anonymous namespace)";

lib/CodeGen/AsmPrinter/EHStreamer.cpp

@@ -662,9 +662,8 @@ void EHStreamer::emitTypeInfos(unsigned TTypeEncoding) {
     Entry = TypeInfos.size();
   }
 
-  for (std::vector<const GlobalValue *>::const_reverse_iterator
+  for (const GlobalValue *GV : make_range(TypeInfos.rbegin(),
-         I = TypeInfos.rbegin(), E = TypeInfos.rend(); I != E; ++I) {
+                                          TypeInfos.rend())) {
-    const GlobalValue *GV = *I;
     if (VerboseAsm)
       Asm->OutStreamer->AddComment("TypeInfo " + Twine(Entry--));
     Asm->EmitTTypeReference(GV, TTypeEncoding);

lib/CodeGen/DeadMachineInstructionElim.cpp

@@ -101,26 +101,23 @@ bool DeadMachineInstructionElim::runOnMachineFunction(MachineFunction &MF) {
   // Loop over all instructions in all blocks, from bottom to top, so that it's
   // more likely that chains of dependent but ultimately dead instructions will
   // be cleaned up.
-  for (MachineFunction::reverse_iterator I = MF.rbegin(), E = MF.rend();
+  for (MachineBasicBlock &MBB : make_range(MF.rbegin(), MF.rend())) {
-       I != E; ++I) {
-    MachineBasicBlock *MBB = &*I;
-
     // Start out assuming that reserved registers are live out of this block.
     LivePhysRegs = MRI->getReservedRegs();
 
     // Add live-ins from sucessors to LivePhysRegs. Normally, physregs are not
     // live across blocks, but some targets (x86) can have flags live out of a
     // block.
-    for (MachineBasicBlock::succ_iterator S = MBB->succ_begin(),
+    for (MachineBasicBlock::succ_iterator S = MBB.succ_begin(),
-           E = MBB->succ_end(); S != E; S++)
+           E = MBB.succ_end(); S != E; S++)
       for (MachineBasicBlock::livein_iterator LI = (*S)->livein_begin();
            LI != (*S)->livein_end(); LI++)
         LivePhysRegs.set(*LI);
 
     // Now scan the instructions and delete dead ones, tracking physreg
     // liveness as we go.
-    for (MachineBasicBlock::reverse_iterator MII = MBB->rbegin(),
+    for (MachineBasicBlock::reverse_iterator MII = MBB.rbegin(),
-         MIE = MBB->rend(); MII != MIE; ) {
+         MIE = MBB.rend(); MII != MIE; ) {
       MachineInstr *MI = &*MII;
 
       // If the instruction is dead, delete it!
@@ -132,7 +129,7 @@ bool DeadMachineInstructionElim::runOnMachineFunction(MachineFunction &MF) {
         MI->eraseFromParentAndMarkDBGValuesForRemoval();
         AnyChanges = true;
         ++NumDeletes;
-        MIE = MBB->rend();
+        MIE = MBB.rend();
         // MII is now pointing to the next instruction to process,
         // so don't increment it.
         continue;

lib/CodeGen/ExecutionDepsFix.cpp

@@ -559,12 +559,11 @@ void ExeDepsFix::processUndefReads(MachineBasicBlock *MBB) {
   MachineInstr *UndefMI = UndefReads.back().first;
   unsigned OpIdx = UndefReads.back().second;
 
-  for (MachineBasicBlock::reverse_iterator I = MBB->rbegin(), E = MBB->rend();
+  for (MachineInstr &I : make_range(MBB->rbegin(), MBB->rend())) {
-       I != E; ++I) {
     // Update liveness, including the current instruction's defs.
-    LiveRegSet.stepBackward(*I);
+    LiveRegSet.stepBackward(I);
 
-    if (UndefMI == &*I) {
+    if (UndefMI == &I) {
       if (!LiveRegSet.contains(UndefMI->getOperand(OpIdx).getReg()))
         TII->breakPartialRegDependency(UndefMI, OpIdx, TRI);
 

lib/IR/AsmWriter.cpp

@@ -232,8 +232,7 @@ static UseListOrderStack predictUseListOrder(const Module *M) {
   // We want to visit the functions backward now so we can list function-local
   // constants in the last Function they're used in.  Module-level constants
   // have already been visited above.
-  for (auto I = M->rbegin(), E = M->rend(); I != E; ++I) {
+  for (const Function &F : make_range(M->rbegin(), M->rend())) {
-    const Function &F = *I;
     if (F.isDeclaration())
       continue;
     for (const BasicBlock &BB : F)

lib/Target/AArch64/AArch64A53Fix835769.cpp

@@ -151,10 +151,9 @@ static MachineInstr *getLastNonPseudo(MachineBasicBlock &MBB,
   // If there is no non-pseudo in the current block, loop back around and try
   // the previous block (if there is one).
   while ((FMBB = getBBFallenThrough(FMBB, TII))) {
-    for (auto I = FMBB->rbegin(), E = FMBB->rend(); I != E; ++I) {
+    for (MachineInstr &I : make_range(FMBB->rbegin(), FMBB->rend()))
-      if (!I->isPseudo())
+      if (!I.isPseudo())
-        return &*I;
+        return &I;
-    }
   }
 
   // There was no previous non-pseudo in the fallen through blocks

lib/Transforms/Scalar/Float2Int.cpp

@@ -242,11 +242,11 @@ void Float2Int::walkBackwards(const SmallPtrSetImpl<Instruction*> &Roots) {
 // Walk forwards down the list of seen instructions, so we visit defs before
 // uses.
 void Float2Int::walkForwards() {
-  for (auto It = SeenInsts.rbegin(), E = SeenInsts.rend(); It != E; ++It) {
+  for (auto &It : make_range(SeenInsts.rbegin(), SeenInsts.rend())) {
-    if (It->second != unknownRange())
+    if (It.second != unknownRange())
       continue;
 
-    Instruction *I = It->first;
+    Instruction *I = It.first;
     std::function<ConstantRange(ArrayRef<ConstantRange>)> Op;
     switch (I->getOpcode()) {
       // FIXME: Handle select and phi nodes.
@@ -507,9 +507,8 @@ Value *Float2Int::convert(Instruction *I, Type *ToTy) {
 
 // Perform dead code elimination on the instructions we just modified.
 void Float2Int::cleanup() {
-  for (auto I = ConvertedInsts.rbegin(), E = ConvertedInsts.rend();
+  for (auto &I : make_range(ConvertedInsts.rbegin(), ConvertedInsts.rend()))
-       I != E; ++I)
+    I.first->eraseFromParent();
-    I->first->eraseFromParent();
 }
 
 bool Float2Int::runOnFunction(Function &F) {

lib/Transforms/Scalar/LoopDistribute.cpp

@@ -164,9 +164,7 @@ public:
 
     // Delete the instructions backwards, as it has a reduced likelihood of
     // having to update as many def-use and use-def chains.
-    for (auto I = Unused.rbegin(), E = Unused.rend(); I != E; ++I) {
+    for (auto *Inst : make_range(Unused.rbegin(), Unused.rend())) {
-      auto *Inst = *I;
-
       if (!Inst->use_empty())
         Inst->replaceAllUsesWith(UndefValue::get(Inst->getType()));
       Inst->eraseFromParent();

lib/Transforms/Utils/InlineFunction.cpp

@@ -851,9 +851,8 @@ updateInlinedAtInfo(DebugLoc DL, DILocation *InlinedAtNode, LLVMContext &Ctx,
   // Starting from the top, rebuild the nodes to point to the new inlined-at
   // location (then rebuilding the rest of the chain behind it) and update the
   // map of already-constructed inlined-at nodes.
-  for (auto I = InlinedAtLocations.rbegin(), E = InlinedAtLocations.rend();
+  for (const DILocation *MD : make_range(InlinedAtLocations.rbegin(),
-       I != E; ++I) {
+                                         InlinedAtLocations.rend())) {
-    const DILocation *MD = *I;
     Last = IANodes[MD] = DILocation::getDistinct(
         Ctx, MD->getLine(), MD->getColumn(), MD->getScope(), Last);
   }