Simplify references to command line flags.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 269 matching lines @@
   if (Func != nullptr) {
     Str << "|" << Name << "|Cfg Memory  |" << Func->getTotalMemoryMB()
         << " MB\n";
   }
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
                              ELFStreamer *ELFStr)
     : Strings(new StringPool()), ConstPool(new ConstantPool()), ErrorStatus(),
       StrDump(OsDump), StrEmit(OsEmit), StrError(OsError), IntrinsicsInfo(this),
-      ObjectWriter(),
-      OptQ(/*Sequential=*/Flags.isSequential(),
-           /*MaxSize=*/
-           Flags.isParseParallel() ? MaxOptQSize
-                                   : Flags.getNumTranslationThreads()),
+      ObjectWriter(), OptQ(/*Sequential=*/getFlags().isSequential(),
+                           /*MaxSize=*/
+                           getFlags().isParseParallel()
+                               ? MaxOptQSize
+                               : getFlags().getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
-      EmitQ(/*Sequential=*/Flags.isSequential()),
+      EmitQ(/*Sequential=*/getFlags().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
   // accesses are made.  Do this here instead of at the start of
   // main() so that all clients (e.g. unit tests) can benefit for
   // free.
   GlobalContext::TlsInit();
   Cfg::TlsInit();
   // Create a new ThreadContext for the current thread.  No need to
   // lock AllThreadContexts at this point since no other threads have
   // access yet to this GlobalContext object.
   ThreadContext *MyTLS = new ThreadContext();
   AllThreadContexts.push_back(MyTLS);
   ICE_TLS_SET_FIELD(TLS, MyTLS);
   // Pre-register built-in stack names.
   if (BuildDefs::timers()) {
     // TODO(stichnot): There needs to be a strong relationship between
     // the newTimerStackID() return values and TSK_Default/TSK_Funcs.
     newTimerStackID("Total across all functions");
     newTimerStackID("Per-function summary");
   }
   Timers.initInto(MyTLS->Timers);
-  switch (Flags.getOutFileType()) {
+  switch (getFlags().getOutFileType()) {
   case FT_Elf:
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
     break;
   case FT_Asm:
   case FT_Iasm:
     break;
   }
 // Cache up front common constants.
 #define X(tag, sizeLog2, align, elts, elty, str, rcstr)                        \
   ConstZeroForType[IceType_##tag] = getConstantZeroInternal(IceType_##tag);
@@ skipping 109 matching lines @@
 void GlobalContext::saveBlockInfoPtrs() {
   for (VariableDeclaration *Global : Globals) {
     if (Cfg::isProfileGlobal(*Global)) {
       ProfileBlockInfos.push_back(Global);
     }
   }
 }
 
 void GlobalContext::lowerGlobals(const std::string &SectionSuffix) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, this);
-  const bool DumpGlobalVariables = BuildDefs::dump() &&
-                                   (Flags.getVerbose() & IceV_GlobalInit) &&
-                                   Flags.getVerboseFocusOn().empty();
+  const bool DumpGlobalVariables =
+      BuildDefs::dump() && (getFlags().getVerbose() & IceV_GlobalInit) &&
+      getFlags().getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(this);
     Ostream &Stream = getStrDump();
     for (const Ice::VariableDeclaration *Global : Globals) {
       Global->dump(Stream);
     }
   }
-  if (Flags.getDisableTranslation())
+  if (getFlags().getDisableTranslation())
     return;
 
   saveBlockInfoPtrs();
   // If we need to shuffle the layout of global variables, shuffle them now.
   if (getFlags().getReorderGlobalVariables()) {
     // Create a random number generator for global variable reordering.
     RandomNumberGenerator RNG(getFlags().getRandomSeed(),
                               RPE_GlobalVariableReordering);
     RandomShuffle(Globals.begin(), Globals.end(),
                   [&RNG](int N) { return (uint32_t)RNG.next(N); });
@@ skipping 193 matching lines @@
     return;
   OstreamLocker _(this);
   Ostream &Str = getStrDump();
   Str << "GlobalContext strings:\n";
   getStrings()->dump(Str);
 }
 
 void GlobalContext::dumpConstantLookupCounts() {
   if (!BuildDefs::dump())
     return;
-  const bool DumpCounts = (Flags.getVerbose() & IceV_ConstPoolStats) &&
-                          Flags.getVerboseFocusOn().empty();
+  const bool DumpCounts = (getFlags().getVerbose() & IceV_ConstPoolStats) &&
+                          getFlags().getVerboseFocusOn().empty();
   if (!DumpCounts)
     return;
 
   OstreamLocker _(this);
   Ostream &Str = getStrDump();
   Str << "Constant pool use stats: count+value+type\n";
 #define X(WhichPool)                                                           \
   for (auto *C : getConstPool()->WhichPool.getConstantPool()) {                \
     Str << C->getLookupCount() << " ";                                         \
     C->dump(Str);                                                              \
@@ skipping 279 matching lines @@
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
 LockedPtr<StringPool>
 GlobalStringPoolTraits::getStrings(const GlobalContext *PoolOwner) {
   return PoolOwner->getStrings();
 }
 
-ClFlags GlobalContext::Flags;
-
 TimerIdT TimerMarker::getTimerIdFromFuncName(GlobalContext *Ctx,
                                              const std::string &FuncName) {
   if (!BuildDefs::timers())
     return 0;
-  if (!Ctx->getFlags().getTimeEachFunction())
+  if (!getFlags().getTimeEachFunction())
     return 0;
   return Ctx->getTimerID(GlobalContext::TSK_Funcs, FuncName);
 }
 
 void TimerMarker::push() {
   switch (StackID) {
   case GlobalContext::TSK_Default:
-    Active = Ctx->getFlags().getSubzeroTimingEnabled();
+    Active = getFlags().getSubzeroTimingEnabled();
     break;
   case GlobalContext::TSK_Funcs:
-    Active = Ctx->getFlags().getTimeEachFunction();
+    Active = 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();
+  Active = Func->getFocusedTiming() || getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice