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

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LinearScan class, which performs the
@@ skipping 32 matching lines @@
   const InstDefList &Defs = VMetadata->getLatterDefinitions(Var);
   for (size_t i = 0; i < Defs.size(); ++i) {
     if (Item->getLiveRange().overlapsInst(Defs[i]->getNumber(), UseTrimmed))
       return true;
   }
   return false;
 }
 
 void dumpDisableOverlap(const Cfg *Func, const Variable *Var,
                         const char *Reason) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   if (Func->isVerbose(IceV_LinearScan)) {
     VariablesMetadata *VMetadata = Func->getVMetadata();
     Ostream &Str = Func->getContext()->getStrDump();
     Str << "Disabling Overlap due to " << Reason << " " << *Var
         << " LIVE=" << Var->getLiveRange() << " Defs=";
     if (const Inst *FirstDef = VMetadata->getFirstDefinition(Var))
       Str << FirstDef->getNumber();
     const InstDefList &Defs = VMetadata->getLatterDefinitions(Var);
     for (size_t i = 0; i < Defs.size(); ++i) {
       Str << "," << Defs[i]->getNumber();
     }
     Str << "\n";
   }
 }
 
 void dumpLiveRange(const Variable *Var, const Cfg *Func) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   const static size_t BufLen = 30;
   char buf[BufLen];
   snprintf(buf, BufLen, "%2d", Var->getRegNumTmp());
   Str << "R=" << buf << "  V=";
   Var->dump(Func);
   Str << "  Range=" << Var->getLiveRange();
 }
 
@@ skipping 176 matching lines @@
 // cases.
 //
 // Requires running Cfg::liveness(Liveness_Intervals) in
 // preparation.  Results are assigned to Variable::RegNum for each
 // Variable.
 void LinearScan::scan(const llvm::SmallBitVector &RegMaskFull,
                       bool Randomized) {
   TimerMarker T(TimerStack::TT_linearScan, Func);
   assert(RegMaskFull.any()); // Sanity check
   GlobalContext *Ctx = Func->getContext();
-  const bool Verbose = ALLOW_DUMP && Func->isVerbose(IceV_LinearScan);
+  const bool Verbose = buildAllowsDump() && Func->isVerbose(IceV_LinearScan);
   if (Verbose)
     Ctx->lockStr();
   Func->resetCurrentNode();
   VariablesMetadata *VMetadata = Func->getVMetadata();
   const size_t NumRegisters = RegMaskFull.size();
   llvm::SmallBitVector PreDefinedRegisters(NumRegisters);
   if (Randomized) {
     for (Variable *Var : UnhandledPrecolored) {
       PreDefinedRegisters[Var->getRegNum()] = true;
     }
@@ skipping 449 matching lines @@
   // Unhandled list with just the unallocated variables, saving time
   // but not offering second-chance opportunities.
 
   if (Verbose)
     Ctx->unlockStr();
 }
 
 // ======================== Dump routines ======================== //
 
 void LinearScan::dump(Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   if (!Func->isVerbose(IceV_LinearScan))
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Func->resetCurrentNode();
   Str << "**** Current regalloc state:\n";
   Str << "++++++ Handled:\n";
   for (const Variable *Item : Handled) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
   Str << "++++++ Unhandled:\n";
   for (const Variable *Item : reverse_range(Unhandled)) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
   Str << "++++++ Active:\n";
   for (const Variable *Item : Active) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice