Subzero: Auto-awesome iterators.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        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 LLVM to ICE converter.
@@ skipping 52 matching lines @@
         Ice::GlobalContext::getTimerID("llvmConvert");
     Ice::TimerMarker T(IDllvmConvert, Ctx);
     VarMap.clear();
     NodeMap.clear();
     Func = new Ice::Cfg(Ctx);
     Func->setFunctionName(F->getName());
     Func->setReturnType(convertToIceType(F->getReturnType()));
     Func->setInternal(F->hasInternalLinkage());
 
     // The initial definition/use of each arg is the entry node.
-    for (Function::const_arg_iterator ArgI = F->arg_begin(),
-                                      ArgE = F->arg_end();
-         ArgI != ArgE; ++ArgI) {
+    for (auto ArgI = F->arg_begin(), ArgE = F->arg_end(); ArgI != ArgE;
+         ++ArgI) {
       Func->addArg(mapValueToIceVar(ArgI));
     }
 
     // Make an initial pass through the block list just to resolve the
     // blocks in the original linearized order.  Otherwise the ICE
     // linearized order will be affected by branch targets in
     // terminator instructions.
-    for (Function::const_iterator BBI = F->begin(), BBE = F->end(); BBI != BBE;
-         ++BBI) {
-      mapBasicBlockToNode(BBI);
-    }
-    for (Function::const_iterator BBI = F->begin(), BBE = F->end(); BBI != BBE;
-         ++BBI) {
-      convertBasicBlock(BBI);
-    }
+    for (const BasicBlock &BBI : *F)
+      mapBasicBlockToNode(&BBI);
+    for (const BasicBlock &BBI : *F)
+      convertBasicBlock(&BBI);
     Func->setEntryNode(mapBasicBlockToNode(&F->getEntryBlock()));
     Func->computePredecessors();
 
     return Func;
   }
 
   // convertConstant() does not use Func or require it to be a valid
   // Ice::Cfg pointer.  As such, it's suitable for e.g. constructing
   // global initializers.
   Ice::Constant *convertConstant(const Constant *Const) {
@@ skipping 456 matching lines @@
 
     return Ice::InstAlloca::create(Func, ByteCount, Align, Dest);
   }
 
   Ice::Inst *convertUnreachableInstruction(const UnreachableInst * /*Inst*/) {
     return Ice::InstUnreachable::create(Func);
   }
 
   Ice::CfgNode *convertBasicBlock(const BasicBlock *BB) {
     Ice::CfgNode *Node = mapBasicBlockToNode(BB);
-    for (BasicBlock::const_iterator II = BB->begin(), II_e = BB->end();
-         II != II_e; ++II) {
-      Ice::Inst *Inst = convertInstruction(II);
+    for (const Instruction &II : *BB) {
+      Ice::Inst *Inst = convertInstruction(&II);
       Node->appendInst(Inst);
     }
     return Node;
   }
 
   void validateIntrinsicCall(const Ice::InstCall *Call,
                              const Ice::Intrinsics::FullIntrinsicInfo *I) {
     Ice::SizeT ArgIndex = 0;
     switch (I->validateCall(Call, ArgIndex)) {
     default:
@@ skipping 45 matching lines @@
 void Converter::convertToIce() {
   static TimerIdT IDconvertToIce = GlobalContext::getTimerID("convertToIce");
   TimerMarker T(IDconvertToIce, Ctx);
   nameUnnamedGlobalAddresses(Mod);
   if (!Ctx->getFlags().DisableGlobals)
     convertGlobals(Mod);
   convertFunctions();
 }
 
 void Converter::convertFunctions() {
-  for (Module::const_iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
-    if (I->empty())
+  for (const Function &I : *Mod) {
+    if (I.empty())
       continue;
     LLVM2ICEConverter FunctionConverter(Ctx, Mod->getContext());
 
-    Cfg *Fcn = FunctionConverter.convertFunction(I);
+    Cfg *Fcn = FunctionConverter.convertFunction(&I);
     translateFcn(Fcn);
   }
 
   emitConstants();
 }
 
 } // end of namespace Ice