Subzero: Reduce the amount of #ifdef'd code.

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 180 matching lines @@
   TypePool<IceType_i16, int16_t, ConstantInteger32> Integers16;
   TypePool<IceType_i32, int32_t, ConstantInteger32> Integers32;
   TypePool<IceType_i64, int64_t, ConstantInteger64> Integers64;
   TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable> Relocatables;
   TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable>
       ExternRelocatables;
   UndefPool Undefs;
 };
 
 void GlobalContext::CodeStats::dump(const IceString &Name, Ostream &Str) {
-  if (!ALLOW_DUMP)
+  if (!BuildDefs::dump())
     return;
 #define X(str, tag)                                                            \
   Str << "|" << Name << "|" str "|" << Stats[CS_##tag] << "\n";
   CODESTATS_TABLE
 #undef X
   Str << "|" << Name << "|Spills+Fills|"
       << Stats[CS_NumSpills] + Stats[CS_NumFills] << "\n";
   Str << "|" << Name << "|Memory Usage|";
   if (ssize_t MemUsed = llvm::TimeRecord::getCurrentTime(false).getMemUsed())
     Str << MemUsed;
@@ skipping 21 matching lines @@
   // 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) {
+  if (BuildDefs::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);
   switch (Flags.getOutFileType()) {
   case FT_Elf:
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
     break;
@@ skipping 108 matching lines @@
     Pending.resize(Index + 1);
 }
 
 } // end of anonymous namespace
 
 void GlobalContext::emitFileHeader() {
   TimerMarker T1(Ice::TimerStack::TT_emit, this);
   if (getFlags().getOutFileType() == FT_Elf) {
     getObjectWriter()->writeInitialELFHeader();
   } else {
-    if (!ALLOW_DUMP) {
+    if (!BuildDefs::dump()) {
       getStrError() << "emitFileHeader for non-ELF";
       getErrorStatus()->assign(EC_Translation);
     }
     TargetHeaderLowering::createLowering(this)->lower();
   }
 }
 
 void GlobalContext::lowerConstants() { DataLowering->lowerConstants(); }
 
 void GlobalContext::lowerGlobals(const IceString &SectionSuffix) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, this);
-  const bool DumpGlobalVariables =
-      ALLOW_DUMP && Flags.getVerbose() && Flags.getVerboseFocusOn().empty();
+  const bool DumpGlobalVariables = BuildDefs::dump() && Flags.getVerbose() &&
+                                   Flags.getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(this);
     Ostream &Stream = getStrDump();
     for (const Ice::VariableDeclaration *Global : Globals) {
       Global->dump(this, Stream);
     }
   }
   if (Flags.getDisableTranslation())
     return;
 
@@ skipping 70 matching lines @@
         OstreamLocker L(this);
         Cfg::emitTextHeader(MangledName, this, Asm.get());
         Asm->emitIASBytes(this);
       } break;
       case FT_Asm:
         llvm::report_fatal_error("Unexpected FT_Asm");
         break;
       }
     } break;
     case EmitterWorkItem::WI_Cfg: {
-      if (!ALLOW_DUMP)
+      if (!BuildDefs::dump())
         llvm::report_fatal_error("WI_Cfg work item created inappropriately");
       lowerGlobalsIfNoCodeHasBeenSeen();
       accumulateGlobals(Item->getGlobalInits());
 
       assert(getFlags().getOutFileType() == FT_Asm);
       std::unique_ptr<Cfg> Func = Item->getCfg();
       // Unfortunately, we have to temporarily install the Cfg in TLS
       // because Variable::asType() uses the allocator to create the
       // differently-typed copy.
       Cfg::setCurrentCfg(Func.get());
@@ skipping 102 matching lines @@
 // prefix.
 IceString GlobalContext::mangleName(const IceString &Name) const {
   // An already-nested name like foo::bar() gets pushed down one
   // level, making it equivalent to Prefix::foo::bar().
   //   _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz
   // A non-nested but mangled name like bar() gets nested, making it
   // equivalent to Prefix::bar().
   //   _Z3barxyz ==> ZN6Prefix3barExyz
   // An unmangled, extern "C" style name, gets a simple prefix:
   //   bar ==> Prefixbar
-  if (!ALLOW_DUMP || getFlags().getTestPrefix().empty())
+  if (!BuildDefs::dump() || getFlags().getTestPrefix().empty())
     return Name;
 
   const IceString &TestPrefix = getFlags().getTestPrefix();
   unsigned PrefixLength = TestPrefix.length();
   ManglerVector NameBase(1 + Name.length());
   const size_t BufLen = 30 + Name.length() + PrefixLength;
   ManglerVector NewName(BufLen);
   uint32_t BaseLength = 0; // using uint32_t due to sscanf format string
 
   int ItemsParsed = sscanf(Name.c_str(), "_ZN%s", NameBase.data());
@@ skipping 198 matching lines @@
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
 ConstantList GlobalContext::getConstantExternSyms() {
   return getConstPool()->ExternRelocatables.getConstantPool();
 }
 
 TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
-  if (!ALLOW_DUMP)
+  if (!BuildDefs::dump())
     return 0;
   auto Timers = getTimers();
   TimerStackIdT NewID = Timers->size();
   Timers->push_back(TimerStack(Name));
   return NewID;
 }
 
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
                                    const IceString &Name) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
@@ skipping 58 matching lines @@
     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)
+  if (!BuildDefs::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:
@@ skipping 13 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