Subzero: Auto-awesome iterators.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 24 matching lines @@
 // KeyTypeHasFP with C++11.
 template <typename KeyType, typename ValueType, bool KeyTypeHasFP = false>
 class TypePool {
   TypePool(const TypePool &) LLVM_DELETED_FUNCTION;
   TypePool &operator=(const TypePool &) LLVM_DELETED_FUNCTION;
 
 public:
   TypePool() : NextPoolID(0) {}
   ValueType *getOrAdd(GlobalContext *Ctx, Type Ty, KeyType Key) {
     TupleType TupleKey = std::make_pair(Ty, Key);
-    typename ContainerType::const_iterator Iter = Pool.find(TupleKey);
+    auto Iter = Pool.find(TupleKey);
     if (Iter != Pool.end())
       return Iter->second;
     ValueType *Result = ValueType::create(Ctx, Ty, Key, NextPoolID++);
     Pool[TupleKey] = Result;
     return Result;
   }
   ConstantList getConstantPool() const {
     ConstantList Constants;
     Constants.reserve(Pool.size());
-    // TODO: replace the loop with std::transform + lambdas.
-    for (typename ContainerType::const_iterator I = Pool.begin(),
-                                                E = Pool.end();
-         I != E; ++I) {
-      Constants.push_back(I->second);
-    }
+    for (auto &I : Pool)
+      Constants.push_back(I.second);
     return Constants;
   }
 
 private:
   typedef std::pair<Type, KeyType> TupleType;
   struct TupleCompare {
     bool operator()(const TupleType &A, const TupleType &B) const {
       if (A.first != B.first)
         return A.first < B.first;
       if (KeyTypeHasFP)
         return memcmp(&A.second, &B.second, sizeof(KeyType)) < 0;
       return A.second < B.second;
     }
   };
   typedef std::map<const TupleType, ValueType *, TupleCompare> ContainerType;
   ContainerType Pool;
   uint32_t NextPoolID;
 };
 
 // UndefPool maps ICE types to the corresponding ConstantUndef values.
 class UndefPool {
   UndefPool(const UndefPool &) LLVM_DELETED_FUNCTION;
   UndefPool &operator=(const UndefPool &) LLVM_DELETED_FUNCTION;
 
 public:
   UndefPool() : NextPoolID(0) {}
 
   ConstantUndef *getOrAdd(GlobalContext *Ctx, Type Ty) {
-    ContainerType::iterator I = Pool.find(Ty);
+    auto I = Pool.find(Ty);
     if (I != Pool.end())
       return I->second;
     ConstantUndef *Undef = ConstantUndef::create(Ctx, Ty, NextPoolID++);
     Pool[Ty] = Undef;
     return Undef;
   }
 
 private:
   uint32_t NextPoolID;
   typedef std::map<Type, ConstantUndef *> ContainerType;
@@ skipping 300 matching lines @@
     } else {
       StatsFunction.dump(Name, getStrDump());
       StatsCumulative.dump("_TOTAL_", getStrDump());
     }
   }
 }
 
 void GlobalContext::dumpTimers() { Timers->dump(getStrDump()); }
 
 } // end of namespace Ice