Subzero: Use range-based for loops with llvm::ilist<Inst> lists.

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LinearScan class, which performs the
@@ skipping 91 matching lines @@
     if (Var->hasReg()) {
       Var->setRegNumTmp(Var->getRegNum());
       Var->setLiveRangeInfiniteWeight();
       UnhandledPrecolored.push_back(Var);
     }
   }
 
   // Build the (ordered) list of FakeKill instruction numbers.
   Kills.clear();
   for (CfgNode *Node : Func->getNodes()) {
-    for (auto I = Node->getInsts().begin(), E = Node->getInsts().end(); I != E;
-         ++I) {
-      if (auto Kill = llvm::dyn_cast<InstFakeKill>(I)) {
+    for (Inst &I : Node->getInsts()) {
+      if (auto Kill = llvm::dyn_cast<InstFakeKill>(&I)) {
         if (!Kill->isDeleted() && !Kill->getLinked()->isDeleted())
-          Kills.push_back(I->getNumber());
+          Kills.push_back(I.getNumber());
       }
     }
   }
 }
 
 // Prepare for very simple register allocation of only infinite-weight
 // Variables while respecting pre-colored Variables.  Some properties
 // we take advantage of:
 //
 // * Live ranges of interest consist of a single segment.
@@ skipping 26 matching lines @@
   FindOverlap = false;
   SizeT NumVars = 0;
   const VarList &Vars = Func->getVariables();
 
   // Iterate across all instructions and record the begin and end of
   // the live range for each variable that is pre-colored or infinite
   // weight.
   std::vector<InstNumberT> LRBegin(Vars.size(), Inst::NumberSentinel);
   std::vector<InstNumberT> LREnd(Vars.size(), Inst::NumberSentinel);
   for (CfgNode *Node : Func->getNodes()) {
-    for (auto Inst = Node->getInsts().begin(), E = Node->getInsts().end();
-         Inst != E; ++Inst) {
-      if (Inst->isDeleted())
+    for (Inst &Inst : Node->getInsts()) {
+      if (Inst.isDeleted())
         continue;
-      if (const Variable *Var = Inst->getDest()) {
+      if (const Variable *Var = Inst.getDest()) {
         if (Var->hasReg() || Var->getWeight() == RegWeight::Inf) {
           if (LRBegin[Var->getIndex()] == Inst::NumberSentinel) {
-            LRBegin[Var->getIndex()] = Inst->getNumber();
+            LRBegin[Var->getIndex()] = Inst.getNumber();
             ++NumVars;
           }
         }
       }
-      for (SizeT I = 0; I < Inst->getSrcSize(); ++I) {
-        Operand *Src = Inst->getSrc(I);
+      for (SizeT I = 0; I < Inst.getSrcSize(); ++I) {
+        Operand *Src = Inst.getSrc(I);
         SizeT NumVars = Src->getNumVars();
         for (SizeT J = 0; J < NumVars; ++J) {
           const Variable *Var = Src->getVar(J);
           if (Var->hasReg() || Var->getWeight() == RegWeight::Inf)
-            LREnd[Var->getIndex()] = Inst->getNumber();
+            LREnd[Var->getIndex()] = Inst.getNumber();
         }
       }
     }
   }
 
   Unhandled.reserve(NumVars);
   UnhandledPrecolored.reserve(NumVars);
   for (SizeT i = 0; i < Vars.size(); ++i) {
     Variable *Var = Vars[i];
     if (LRBegin[i] != Inst::NumberSentinel) {
@@ skipping 551 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice