Subzero: Auto-awesome iterators.

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand 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 Operand class and its target-independent
@@ skipping 105 matching lines @@
       ++I2;
       continue;
     }
     return true;
   }
   return false;
 }
 
 bool LiveRange::overlaps(InstNumberT OtherBegin) const {
   bool Result = false;
-  for (RangeType::const_iterator I = Range.begin(), E = Range.end(); I != E;
-       ++I) {
-    if (OtherBegin < I->first) {
+  for (const RangeElementType &I : Range) {
+    if (OtherBegin < I.first) {
       Result = false;
       break;
     }
-    if (OtherBegin < I->second) {
+    if (OtherBegin < I.second) {
       Result = true;
       break;
     }
   }
 #if 0
   // An equivalent but less inefficient implementation:
   LiveRange Temp;
   Temp.addSegment(OtherBegin, OtherBegin + 1);
   bool Validation = overlaps(Temp);
   assert(Result == Validation);
 #endif
   return Result;
 }
 
 // Returns true if the live range contains the given instruction
 // number.  This is only used for validating the live range
 // calculation.
 bool LiveRange::containsValue(InstNumberT Value) const {
-  for (RangeType::const_iterator I = Range.begin(), E = Range.end(); I != E;
-       ++I) {
-    if (I->first <= Value && Value <= I->second)
+  for (const RangeElementType &I : Range) {
+    if (I.first <= Value && Value <= I.second)
       return true;
   }
   return false;
 }
 
 IceString Variable::getName() const {
   if (!Name.empty())
     return Name;
   char buf[30];
   snprintf(buf, llvm::array_lengthof(buf), "__%u", getIndex());
@@ skipping 111 matching lines @@
   }
 }
 
 void VariablesMetadata::init() {
   static TimerIdT IDvmetadata = GlobalContext::getTimerID("vmetadata");
   TimerMarker T(IDvmetadata, Func->getContext());
   Metadata.clear();
   Metadata.resize(Func->getNumVariables());
 
   // Mark implicit args as being used in the entry node.
-  const VarList &ImplicitArgList = Func->getImplicitArgs();
-  for (VarList::const_iterator I = ImplicitArgList.begin(),
-                               E = ImplicitArgList.end();
-       I != E; ++I) {
-    const Variable *Var = *I;
+  for (Variable *Var : Func->getImplicitArgs()) {
     const Inst *NoInst = NULL;
     const CfgNode *EntryNode = Func->getEntryNode();
     const bool IsFromDef = false;
     const bool IsImplicit = true;
     Metadata[Var->getIndex()].markUse(NoInst, EntryNode, IsFromDef, IsImplicit);
   }
 
   SizeT NumNodes = Func->getNumNodes();
   for (SizeT N = 0; N < NumNodes; ++N) {
     CfgNode *Node = Func->getNodes()[N];
-    const InstList &Insts = Node->getInsts();
-    for (InstList::const_iterator I = Insts.begin(), E = Insts.end(); I != E;
-         ++I) {
-      if ((*I)->isDeleted())
+    for (Inst *I : Node->getInsts()) {
+      if (I->isDeleted())
         continue;
-      if (InstFakeKill *Kill = llvm::dyn_cast<InstFakeKill>(*I)) {
+      if (InstFakeKill *Kill = llvm::dyn_cast<InstFakeKill>(I)) {
         // A FakeKill instruction indicates certain Variables (usually
         // physical scratch registers) are redefined, so we register
         // them as defs.
-        for (SizeT SrcNum = 0; SrcNum < (*I)->getSrcSize(); ++SrcNum) {
-          Variable *Var = llvm::cast<Variable>((*I)->getSrc(SrcNum));
+        for (SizeT SrcNum = 0; SrcNum < I->getSrcSize(); ++SrcNum) {
+          Variable *Var = llvm::cast<Variable>(I->getSrc(SrcNum));
           SizeT VarNum = Var->getIndex();
           assert(VarNum < Metadata.size());
           Metadata[VarNum].markDef(Kill, Node);
         }
         continue; // no point in executing the rest
       }
-      if (Variable *Dest = (*I)->getDest()) {
+      if (Variable *Dest = I->getDest()) {
         SizeT DestNum = Dest->getIndex();
         assert(DestNum < Metadata.size());
-        Metadata[DestNum].markDef(*I, Node);
+        Metadata[DestNum].markDef(I, Node);
       }
-      for (SizeT SrcNum = 0; SrcNum < (*I)->getSrcSize(); ++SrcNum) {
-        Operand *Src = (*I)->getSrc(SrcNum);
+      for (SizeT SrcNum = 0; SrcNum < I->getSrcSize(); ++SrcNum) {
+        Operand *Src = I->getSrc(SrcNum);
         SizeT NumVars = Src->getNumVars();
         for (SizeT J = 0; J < NumVars; ++J) {
           const Variable *Var = Src->getVar(J);
           SizeT VarNum = Var->getIndex();
           assert(VarNum < Metadata.size());
           const bool IsFromDef = false;
           const bool IsImplicit = false;
-          Metadata[VarNum].markUse(*I, Node, IsFromDef, IsImplicit);
+          Metadata[VarNum].markUse(I, Node, IsFromDef, IsImplicit);
         }
       }
     }
   }
 }
 
 bool VariablesMetadata::isMultiDef(const Variable *Var) const {
   if (Var->getIsArg())
     return false;
   if (!isTracked(Var))
@@ skipping 91 matching lines @@
 }
 
 void ConstantRelocatable::dump(const Cfg *, Ostream &Str) const {
   Str << "@" << Name;
   if (Offset)
     Str << "+" << Offset;
 }
 
 void LiveRange::dump(Ostream &Str) const {
   Str << "(weight=" << Weight << ") ";
-  for (RangeType::const_iterator I = Range.begin(), E = Range.end(); I != E;
-       ++I) {
-    if (I != Range.begin())
+  bool First = true;
+  for (const RangeElementType &I : Range) {
+    if (First)
       Str << ", ";
-    Str << "[" << (*I).first << ":" << (*I).second << ")";
+    First = false;
+    Str << "[" << I.first << ":" << I.second << ")";
   }
 }
 
 Ostream &operator<<(Ostream &Str, const LiveRange &L) {
   L.dump(Str);
   return Str;
 }
 
 Ostream &operator<<(Ostream &Str, const RegWeight &W) {
   if (W.getWeight() == RegWeight::Inf)
     Str << "Inf";
   else
     Str << W.getWeight();
   return Str;
 }
 
 } // end of namespace Ice