Adds accessor methods to class ClFlags.

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 116 matching lines @@
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit,
                              ELFStreamer *ELFStr, VerboseMask Mask,
                              TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix, const ClFlags &Flags)
     : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
       StrEmit(OsEmit), VMask(Mask), Arch(Arch), Opt(Opt),
       TestPrefix(TestPrefix), Flags(Flags), RNG(""), ObjectWriter(),
-      CfgQ(/*MaxSize=*/Flags.NumTranslationThreads,
-           /*Sequential=*/(Flags.NumTranslationThreads == 0)) {
+      CfgQ(/*MaxSize=*/Flags.getNumTranslationThreads(),
+           /*Sequential=*/(Flags.getNumTranslationThreads() == 0)) {
   // 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 (ALLOW_DUMP) {
     // 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);
-  if (Flags.UseELFWriter) {
+  if (Flags.getUseELFWriter()) {
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
   }
 }
 
 void GlobalContext::translateFunctions() {
   while (std::unique_ptr<Cfg> Func = cfgQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
     Cfg::setCurrentCfg(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Set verbose level to none if the current function does NOT
     // match the -verbose-focus command-line option.
-    if (!matchSymbolName(Func->getFunctionName(), getFlags().VerboseFocusOn))
+    if (!matchSymbolName(Func->getFunctionName(),
+                         getFlags().getVerboseFocusOn()))
       Func->setVerbose(IceV_None);
     // Disable translation if -notranslate is specified, or if the
     // current function matches the -translate-only option.  If
     // translation is disabled, just dump the high-level IR and
     // continue.
-    if (getFlags().DisableTranslation ||
-        !matchSymbolName(Func->getFunctionName(), getFlags().TranslateOnly)) {
+    if (getFlags().getDisableTranslation() ||
+        !matchSymbolName(Func->getFunctionName(),
+                         getFlags().getTranslateOnly())) {
       Func->dump();
     } else {
       Func->translate();
       if (Func->hasError()) {
         getErrorStatus()->assign(EC_Translation);
         OstreamLocker L(this);
         getStrDump() << "ICE translation error: " << Func->getError() << "\n";
       } else {
-        if (getFlags().UseIntegratedAssembler)
+        if (getFlags().getUseIntegratedAssembler())
           Func->emitIAS();
         else
           Func->emit();
         // TODO(stichnot): actually add to emit queue
       }
       dumpStats(Func->getFunctionName());
     }
     Cfg::setCurrentCfg(nullptr);
     // The Cfg now gets deleted as Func goes out of scope.
   }
@@ skipping 356 matching lines @@
 // to modify queue elements.
 void GlobalContext::cfgQueueBlockingPush(std::unique_ptr<Cfg> Func) {
   CfgQ.blockingPush(Func.release());
 }
 
 std::unique_ptr<Cfg> GlobalContext::cfgQueueBlockingPop() {
   return std::unique_ptr<Cfg>(CfgQ.blockingPop());
 }
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
-  if (!ALLOW_DUMP || !getFlags().DumpStats)
+  if (!getFlags().getDumpStats())
     return;
   OstreamLocker OL(this);
   if (Final) {
     getStatsCumulative()->dump(Name, getStrDump());
   } else {
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, getStrDump());
   }
 }
 
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!ALLOW_DUMP)
     return;
   auto Timers = getTimers();
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
 void TimerMarker::push() {
   switch (StackID) {
   case GlobalContext::TSK_Default:
-    Active = Ctx->getFlags().SubzeroTimingEnabled;
+    Active = Ctx->getFlags().getSubzeroTimingEnabled();
     break;
   case GlobalContext::TSK_Funcs:
-    Active = Ctx->getFlags().TimeEachFunction;
+    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().SubzeroTimingEnabled;
+  Active =
+      Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice