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

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        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 TargetLoweringX8632 class, which
@@ skipping 651 matching lines @@
   //  * SpillAreaPaddingBytes:  area 3
   //  * GlobalsSize:            area 4
   //  * GlobalsAndSubsequentPaddingSize: areas 4 - 5
   //  * LocalsSpillAreaSize:    area 6
   //  * SpillAreaSizeBytes:     areas 3 - 7
 
   // Make a final pass over the Cfg to determine which variables need
   // stack slots.
   llvm::BitVector IsVarReferenced(Func->getNumVariables());
   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())
         IsVarReferenced[Var->getIndex()] = true;
-      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);
           IsVarReferenced[Var->getIndex()] = true;
         }
       }
     }
   }
 
   // If SimpleCoalescing is false, each variable without a register
@@ skipping 3458 matching lines @@
   InstCall *Call = makeHelperCall("ice_unreachable", Dest, MaxSrcs);
   lowerCall(Call);
 }
 
 // Turn an i64 Phi instruction into a pair of i32 Phi instructions, to
 // preserve integrity of liveness analysis.  Undef values are also
 // turned into zeroes, since loOperand() and hiOperand() don't expect
 // Undef input.
 void TargetX8632::prelowerPhis() {
   CfgNode *Node = Context.getNode();
-  for (auto I = Node->getPhis().begin(), E = Node->getPhis().end(); I != E;
-       ++I) {
-    auto Phi = llvm::dyn_cast<InstPhi>(I);
+  for (Inst &I : Node->getPhis()) {
+    auto Phi = llvm::dyn_cast<InstPhi>(&I);
     if (Phi->isDeleted())
       continue;
     Variable *Dest = Phi->getDest();
     if (Dest->getType() == IceType_i64) {
       Variable *DestLo = llvm::cast<Variable>(loOperand(Dest));
       Variable *DestHi = llvm::cast<Variable>(hiOperand(Dest));
       InstPhi *PhiLo = InstPhi::create(Func, Phi->getSrcSize(), DestLo);
       InstPhi *PhiHi = InstPhi::create(Func, Phi->getSrcSize(), DestHi);
       for (SizeT I = 0; I < Phi->getSrcSize(); ++I) {
         Operand *Src = Phi->getSrc(I);
@@ skipping 43 matching lines @@
   // available (not live) at the beginning of the successor block,
   // minus all registers used as Dest operands in the Assignments.  To
   // do this, we start off assuming all registers are available, then
   // iterate through the Assignments and remove Dest registers.
   // During this iteration, we also determine whether we will actually
   // need any extra registers for memory-to-memory copies.  If so, we
   // do the actual work of removing the live-in registers from the
   // set.  TODO(stichnot): This work is being repeated for every split
   // edge to the successor, so consider updating LiveIn just once
   // after all the edges are split.
-  for (auto I = Assignments.begin(), E = Assignments.end(); I != E; ++I) {
-    Variable *Dest = I->getDest();
+  for (const Inst &I : Assignments) {
+    Variable *Dest = I.getDest();
     if (Dest->hasReg()) {
       Available[Dest->getRegNum()] = false;
-    } else if (isMemoryOperand(I->getSrc(0))) {
+    } else if (isMemoryOperand(I.getSrc(0))) {
       NeedsRegs = true; // Src and Dest are both in memory
     }
   }
   if (NeedsRegs) {
     LivenessBV &LiveIn = Func->getLiveness()->getLiveIn(Succ);
     for (int i = LiveIn.find_first(); i != -1; i = LiveIn.find_next(i)) {
       Variable *Var = Func->getLiveness()->getVariable(i, Succ);
       if (Var->hasReg())
         Available[Var->getRegNum()] = false;
     }
@@ skipping 480 matching lines @@
   } else if (IsConstant || IsExternal)
     Str << "\t.zero\t" << Size << "\n";
   // Size is part of .comm.
 
   if (IsConstant || HasNonzeroInitializer || IsExternal)
     Str << "\t.size\t" << MangledName << ", " << Size << "\n";
   // Size is part of .comm.
 }
 
 } // end of namespace Ice