Subzero: Add -Wshadow to the build.

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
 // multiple functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceGlobalContext.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceGlobalInits.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wshadow"
 #include "llvm/Support/Timer.h"
 #pragma clang diagnostic pop
 
 #include <algorithm> // max()
 #include <cctype>    // isdigit(), isupper()
 #include <locale>    // locale
 #include <unordered_map>
 
 namespace std {
 template <> struct hash<Ice::RelocatableTuple> {
@@ skipping 173 matching lines @@
       << Stats[CS_NumSpills] + Stats[CS_NumFills] << "\n";
   Str << "|" << Name << "|Memory Usage|";
   if (ssize_t MemUsed = llvm::TimeRecord::getCurrentTime(false).getMemUsed())
     Str << MemUsed;
   else
     Str << "(requires '-track-memory')";
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
-                             ELFStreamer *ELFStr, const ClFlags &Flags)
+                             ELFStreamer *ELFStr, const ClFlags &MyFlags)
     : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
-      StrEmit(OsEmit), StrError(OsError), Flags(Flags),
+      StrEmit(OsEmit), StrError(OsError), Flags(MyFlags),
       RNG(Flags.getRandomSeed()), ObjectWriter(),
       OptQ(/*Sequential=*/Flags.isSequential(),
            /*MaxSize=*/Flags.getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
       EmitQ(/*Sequential=*/Flags.isSequential()),
       DataLowering(TargetDataLowering::createLowering(this)) {
   assert(OsDump && "OsDump is not defined for GlobalContext");
   assert(OsEmit && "OsEmit is not defined for GlobalContext");
   assert(OsError && "OsError is not defined for GlobalContext");
   // Make sure thread_local fields are properly initialized before any
@@ skipping 635 matching lines @@
   llvm_unreachable("Unknown type");
 }
 
 ConstantList GlobalContext::getConstantExternSyms() {
   return getConstPool()->ExternRelocatables.getConstantPool();
 }
 
 TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
   if (!BuildDefs::dump())
     return 0;
-  auto Timers = getTimers();
-  TimerStackIdT NewID = Timers->size();
-  Timers->push_back(TimerStack(Name));
+  auto MyTimers = getTimers();
+  TimerStackIdT NewID = MyTimers->size();
+  MyTimers->push_back(TimerStack(Name));
   return NewID;
 }
 
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
                                    const IceString &Name) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
-  assert(StackID < Timers->size());
-  return Timers->at(StackID).getTimerID(Name);
+  auto MyTimers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  assert(StackID < MyTimers->size());
+  return MyTimers->at(StackID).getTimerID(Name);
 }
 
 void GlobalContext::pushTimer(TimerIdT ID, TimerStackIdT StackID) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
-  assert(StackID < Timers->size());
-  Timers->at(StackID).push(ID);
+  auto MyTimers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  assert(StackID < MyTimers->size());
+  MyTimers->at(StackID).push(ID);
 }
 
 void GlobalContext::popTimer(TimerIdT ID, TimerStackIdT StackID) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
-  assert(StackID < Timers->size());
-  Timers->at(StackID).pop(ID);
+  auto MyTimers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  assert(StackID < MyTimers->size());
+  MyTimers->at(StackID).pop(ID);
 }
 
 void GlobalContext::resetTimer(TimerStackIdT StackID) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
-  assert(StackID < Timers->size());
-  Timers->at(StackID).reset();
+  auto MyTimers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  assert(StackID < MyTimers->size());
+  MyTimers->at(StackID).reset();
 }
 
 void GlobalContext::setTimerName(TimerStackIdT StackID,
                                  const IceString &NewName) {
-  auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
-  assert(StackID < Timers->size());
-  Timers->at(StackID).setName(NewName);
+  auto MyTimers = &ICE_TLS_GET_FIELD(TLS)->Timers;
+  assert(StackID < MyTimers->size());
+  MyTimers->at(StackID).setName(NewName);
 }
 
 // Note: optQueueBlockingPush and optQueueBlockingPop use unique_ptr
 // at the interface to take and transfer ownership, but they
 // internally store the raw Cfg pointer in the work queue.  This
 // allows e.g. future queue optimizations such as the use of atomics
 // to modify queue elements.
 void GlobalContext::optQueueBlockingPush(std::unique_ptr<Cfg> Func) {
   assert(Func);
   OptQ.blockingPush(Func.release());
@@ skipping 23 matching lines @@
   if (Final) {
     getStatsCumulative()->dump(Name, getStrDump());
   } else {
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, getStrDump());
   }
 }
 
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!BuildDefs::dump())
     return;
-  auto Timers = getTimers();
-  assert(Timers->size() > StackID);
+  auto MyTimers = getTimers();
+  assert(MyTimers->size() > StackID);
   OstreamLocker L(this);
-  Timers->at(StackID).dump(getStrDump(), DumpCumulative);
+  MyTimers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
 void TimerMarker::push() {
   switch (StackID) {
   case GlobalContext::TSK_Default:
     Active = Ctx->getFlags().getSubzeroTimingEnabled();
     break;
   case GlobalContext::TSK_Funcs:
     Active = Ctx->getFlags().getTimeEachFunction();
     break;
   default:
     break;
   }
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 void TimerMarker::pushCfg(const Cfg *Func) {
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice