Subzero. Flags refactoring.

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
 /// \brief Defines aspects of the compilation that persist across multiple
 /// functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceGlobalContext.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
-#include "IceClFlagsExtra.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceGlobalInits.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTimerTree.h"
 #include "IceTypes.def"
 #include "IceTypes.h"
 
 #ifdef __clang__
@@ skipping 388 matching lines @@
     Ostream &Stream = getStrDump();
     for (const Ice::VariableDeclaration *Global : Globals) {
       Global->dump(Stream);
     }
   }
   if (Flags.getDisableTranslation())
     return;
 
   saveBlockInfoPtrs();
   // If we need to shuffle the layout of global variables, shuffle them now.
-  if (getFlags().shouldReorderGlobalVariables()) {
+  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); });
   }
   DataLowering->lowerGlobals(Globals, SectionSuffix);
   if (ProfileBlockInfos.empty() && DisposeGlobalVariablesAfterLowering) {
     Globals.clearAndPurge();
   } else {
@@ skipping 46 matching lines @@
   // the work queue, and if it's not the item we're waiting for, we
   // insert it into Pending and repeat.  The work item is deleted
   // after it is processed.
   std::vector<std::unique_ptr<EmitterWorkItem>> Pending;
   uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
   uint32_t ShuffleStartIndex = DesiredSequenceNumber;
   uint32_t ShuffleEndIndex = DesiredSequenceNumber;
   bool EmitQueueEmpty = false;
   const uint32_t ShuffleWindowSize =
       std::max(1u, getFlags().getReorderFunctionsWindowSize());
-  bool Shuffle = Threaded && getFlags().shouldReorderFunctions();
+  bool Shuffle = Threaded && getFlags().getReorderFunctions();
   // Create a random number generator for function reordering.
   RandomNumberGenerator RNG(getFlags().getRandomSeed(), RPE_FunctionReordering);
 
   while (!EmitQueueEmpty) {
     resizePending(&Pending, DesiredSequenceNumber);
     // See if Pending contains DesiredSequenceNumber.
     if (Pending[DesiredSequenceNumber] == nullptr) {
       // We need to fetch an EmitterWorkItem from the queue.
       auto RawItem = emitQueueBlockingPop();
       if (RawItem == nullptr) {
@@ skipping 286 matching lines @@
   JumpTableDataList JumpTables(*getJumpTableList());
   // Make order deterministic by sorting into functions and then ID of the jump
   // table within that function.
   std::sort(JumpTables.begin(), JumpTables.end(),
             [](const JumpTableData &A, const JumpTableData &B) {
               if (A.getFunctionName() != B.getFunctionName())
                 return A.getFunctionName() < B.getFunctionName();
               return A.getId() < B.getId();
             });
 
-  if (getFlags().shouldReorderPooledConstants()) {
+  if (getFlags().getReorderPooledConstants()) {
     // If reorder-pooled-constants option is set to true, we also shuffle the
     // jump tables before emitting them.
 
     // Create a random number generator for jump tables reordering, considering
     // jump tables as pooled constants.
     RandomNumberGenerator RNG(getFlags().getRandomSeed(),
                               RPE_PooledConstantReordering);
     RandomShuffle(JumpTables.begin(), JumpTables.end(),
                   [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
   }
@@ skipping 97 matching lines @@
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!BuildDefs::timers())
     return;
   auto Timers = getTimers();
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
 ClFlags GlobalContext::Flags;
-ClFlagsExtra GlobalContext::ExtraFlags;
 
 TimerIdT TimerMarker::getTimerIdFromFuncName(GlobalContext *Ctx,
                                              const IceString &FuncName) {
   if (!BuildDefs::timers())
     return 0;
   if (!Ctx->getFlags().getTimeEachFunction())
     return 0;
   return Ctx->getTimerID(GlobalContext::TSK_Funcs, FuncName);
 }
 
@@ skipping 16 matching lines @@
   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