Subzero: Add -Wshadow to the build.

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares aspects of the compilation that persist across
@@ skipping 27 matching lines @@
 class EmitterWorkItem;
 class FuncSigType;
 
 // LockedPtr is a way to provide automatically locked access to some object.
 template <typename T> class LockedPtr {
   LockedPtr() = delete;
   LockedPtr(const LockedPtr &) = delete;
   LockedPtr &operator=(const LockedPtr &) = delete;
 
 public:
-  LockedPtr(T *Value, GlobalLockType *Lock) : Value(Value), Lock(Lock) {
+  LockedPtr(T *MyValue, GlobalLockType *MyLock) : Value(MyValue), Lock(MyLock) {
     Lock->lock();
   }
   LockedPtr(LockedPtr &&Other) : Value(Other.Value), Lock(Other.Lock) {
     Other.Value = nullptr;
     Other.Lock = nullptr;
   }
   ~LockedPtr() { Lock->unlock(); }
   T *operator->() const { return Value; }
 
 private:
@@ skipping 274 matching lines @@
   void emitFileHeader();
 
   void lowerConstants();
 
   void emitQueueBlockingPush(EmitterWorkItem *Item);
   EmitterWorkItem *emitQueueBlockingPop();
   void emitQueueNotifyEnd() { EmitQ.notifyEnd(); }
 
   void initParserThread() {
     ThreadContext *Tls = new ThreadContext();
-    auto Timers = getTimers();
-    Timers->initInto(Tls->Timers);
+    auto MyTimers = getTimers();
+    MyTimers->initInto(Tls->Timers);
     AllThreadContexts.push_back(Tls);
     ICE_TLS_SET_FIELD(TLS, Tls);
   }
 
   void startWorkerThreads() {
     size_t NumWorkers = getFlags().getNumTranslationThreads();
-    auto Timers = getTimers();
+    auto MyTimers = getTimers();
     for (size_t i = 0; i < NumWorkers; ++i) {
       ThreadContext *WorkerTLS = new ThreadContext();
-      Timers->initInto(WorkerTLS->Timers);
+      MyTimers->initInto(WorkerTLS->Timers);
       AllThreadContexts.push_back(WorkerTLS);
       TranslationThreads.push_back(std::thread(
           &GlobalContext::translateFunctionsWrapper, this, WorkerTLS));
     }
     if (NumWorkers) {
       ThreadContext *WorkerTLS = new ThreadContext();
-      Timers->initInto(WorkerTLS->Timers);
+      MyTimers->initInto(WorkerTLS->Timers);
       AllThreadContexts.push_back(WorkerTLS);
       EmitterThreads.push_back(
           std::thread(&GlobalContext::emitterWrapper, this, WorkerTLS));
     }
   }
 
   void waitForWorkerThreads() {
     optQueueNotifyEnd();
     for (std::thread &Worker : TranslationThreads) {
       Worker.join();
     }
     TranslationThreads.clear();
 
     // Only notify the emit queue to end after all the translation
     // threads have ended.
     emitQueueNotifyEnd();
     for (std::thread &Worker : EmitterThreads) {
       Worker.join();
     }
     EmitterThreads.clear();
 
     if (BuildDefs::dump()) {
-      auto Timers = getTimers();
+      auto MyTimers = getTimers();
       for (ThreadContext *TLS : AllThreadContexts)
-        Timers->mergeFrom(TLS->Timers);
+        MyTimers->mergeFrom(TLS->Timers);
     }
     if (BuildDefs::dump()) {
       // Do a separate loop over AllThreadContexts to avoid holding
       // two locks at once.
       auto Stats = getStatsCumulative();
       for (ThreadContext *TLS : AllThreadContexts)
         Stats->add(TLS->StatsCumulative);
     }
   }
 
@@ skipping 153 matching lines @@
 
 // Helper class to push and pop a timer marker.  The constructor
 // pushes a marker, and the destructor pops it.  This is for
 // convenient timing of regions of code.
 class TimerMarker {
   TimerMarker() = delete;
   TimerMarker(const TimerMarker &) = delete;
   TimerMarker &operator=(const TimerMarker &) = delete;
 
 public:
-  TimerMarker(TimerIdT ID, GlobalContext *Ctx,
-              TimerStackIdT StackID = GlobalContext::TSK_Default)
-      : ID(ID), Ctx(Ctx), StackID(StackID) {
+  TimerMarker(TimerIdT MyID, GlobalContext *MyCtx,
+              TimerStackIdT MyStackID = GlobalContext::TSK_Default)
+      : ID(MyID), Ctx(MyCtx), StackID(MyStackID) {
     if (BuildDefs::dump())
       push();
   }
-  TimerMarker(TimerIdT ID, const Cfg *Func,
-              TimerStackIdT StackID = GlobalContext::TSK_Default)
-      : ID(ID), Ctx(nullptr), StackID(StackID) {
+  TimerMarker(TimerIdT MyID, const Cfg *Func,
+              TimerStackIdT MyStackID = GlobalContext::TSK_Default)
+      : ID(MyID), Ctx(nullptr), StackID(MyStackID) {
     // Ctx gets set at the beginning of pushCfg().
     if (BuildDefs::dump())
       pushCfg(Func);
   }
 
   ~TimerMarker() {
     if (BuildDefs::dump() && Active)
       Ctx->popTimer(ID, StackID);
   }
 
 private:
   void push();
   void pushCfg(const Cfg *Func);
   const TimerIdT ID;
   GlobalContext *Ctx;
   const TimerStackIdT StackID;
   bool Active = false;
 };
 
 // Helper class for locking the streams and then automatically
 // unlocking them.
 class OstreamLocker {
 private:
   OstreamLocker() = delete;
   OstreamLocker(const OstreamLocker &) = delete;
   OstreamLocker &operator=(const OstreamLocker &) = delete;
 
 public:
-  explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
+  explicit OstreamLocker(GlobalContext *MyCtx) : Ctx(MyCtx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H