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

src/IceTimerTree.cpp

 //===- subzero/src/IceTimerTree.cpp - Pass timer 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 the TimerTree class, which tracks flat and
 // cumulative execution time collection of call chains.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Timer.h"
 
 #include "IceDefs.h"
 #include "IceTimerTree.h"
 
 namespace Ice {
 
 TimerStack::TimerStack(const IceString &Name)
     : Name(Name), FirstTimestamp(timestamp()), LastTimestamp(FirstTimestamp) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Nodes.resize(1); // Reserve Nodes[0] for the root node (sentinel).
   IDs.resize(TT__num);
   LeafTimes.resize(TT__num);
   LeafCounts.resize(TT__num);
 #define STR(s) #s
 #define X(tag)                                                                 \
   IDs[TT_##tag] = STR(tag);                                                    \
   IDsIndex[STR(tag)] = TT_##tag;
   TIMERTREE_TABLE;
 #undef X
 #undef STR
 }
 
 // Returns the unique timer ID for the given Name, creating a new ID
 // if needed.
 TimerIdT TimerStack::getTimerID(const IceString &Name) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return 0;
   if (IDsIndex.find(Name) == IDsIndex.end()) {
     IDsIndex[Name] = IDs.size();
     IDs.push_back(Name);
     LeafTimes.push_back(decltype(LeafTimes)::value_type());
     LeafCounts.push_back(decltype(LeafCounts)::value_type());
   }
   return IDsIndex[Name];
 }
 
 // Creates a mapping from TimerIdT (leaf) values in the Src timer
 // stack into TimerIdT values in this timer stack.  Creates new
 // entries in this timer stack as needed.
 TimerStack::TranslationType
 TimerStack::translateIDsFrom(const TimerStack &Src) {
   size_t Size = Src.IDs.size();
   TranslationType Mapping(Size);
   for (TimerIdT i = 0; i < Size; ++i) {
     Mapping[i] = getTimerID(Src.IDs[i]);
   }
   return Mapping;
 }
 
 // Merges two timer stacks, by combining and summing corresponding
 // entries.  This timer stack is updated from Src.
 void TimerStack::mergeFrom(const TimerStack &Src) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   TranslationType Mapping = translateIDsFrom(Src);
   TTindex SrcIndex = 0;
   for (const TimerTreeNode &SrcNode : Src.Nodes) {
     // The first node is reserved as a sentinel, so avoid it.
     if (SrcIndex > 0) {
       // Find the full path to the Src node, translated to path
       // components corresponding to this timer stack.
       PathType MyPath = Src.getPath(SrcIndex, Mapping);
       // Find a node in this timer stack corresponding to the given
@@ skipping 50 matching lines @@
   // followed in reverse.
   for (TTindex Index : reverse_range(Path)) {
     CurIndex = getChildIndex(CurIndex, Index);
   }
   assert(CurIndex); // shouldn't be the sentinel node
   return CurIndex;
 }
 
 // Pushes a new marker onto the timer stack.
 void TimerStack::push(TimerIdT ID) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   const bool UpdateCounts = false;
   update(UpdateCounts);
   StackTop = getChildIndex(StackTop, ID);
   assert(StackTop);
 }
 
 // Pops the top marker from the timer stack.  Validates via assert()
 // that the expected marker is popped.
 void TimerStack::pop(TimerIdT ID) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   const bool UpdateCounts = true;
   update(UpdateCounts);
   assert(StackTop);
   assert(Nodes[StackTop].Parent < StackTop);
   // Verify that the expected ID is being popped.
   assert(Nodes[StackTop].Interior == ID);
   (void)ID;
   // Verify that the parent's child points to the current stack top.
   assert(Nodes[Nodes[StackTop].Parent].Children[ID] == StackTop);
   StackTop = Nodes[StackTop].Parent;
 }
 
 // At a state change (e.g. push or pop), updates the flat and
 // cumulative timings for everything on the timer stack.
 void TimerStack::update(bool UpdateCounts) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   ++StateChangeCount;
   // Whenever the stack is about to change, we grab the time delta
   // since the last change and add it to all active cumulative
   // elements and to the flat element for the top of the stack.
   double Current = timestamp();
   double Delta = Current - LastTimestamp;
   if (StackTop) {
     TimerIdT Leaf = Nodes[StackTop].Interior;
     if (Leaf >= LeafTimes.size()) {
@@ skipping 15 matching lines @@
     Prefix = Next;
   }
   // Capture the next timestamp *after* the updates are finished.
   // This minimizes how much the timer can perturb the reported
   // timing.  The numbers may not sum to 100%, and the missing amount
   // is indicative of the overhead of timing.
   LastTimestamp = timestamp();
 }
 
 void TimerStack::reset() {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   StateChangeCount = 0;
   FirstTimestamp = LastTimestamp = timestamp();
   LeafTimes.assign(LeafTimes.size(), 0);
   LeafCounts.assign(LeafCounts.size(), 0);
   for (TimerTreeNode &Node : Nodes) {
     Node.Time = 0;
     Node.UpdateCount = 0;
   }
 }
 
 namespace {
 
 typedef std::multimap<double, IceString> DumpMapType;
 
 // Dump the Map items in reverse order of their time contribution.
 void dumpHelper(Ostream &Str, const DumpMapType &Map, double TotalTime) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   for (auto &I : reverse_range(Map)) {
     char buf[80];
     snprintf(buf, llvm::array_lengthof(buf), "  %10.6f (%4.1f%%): ", I.first,
              I.first * 100 / TotalTime);
     Str << buf << I.second << "\n";
   }
 }
 
 // Write a printf() format string into Buf[], in the format "[%5lu] ",
 // where "5" is actually the number of digits in MaxVal.  E.g.,
 //   MaxVal=0     ==> "[%1lu] "
 //   MaxVal=5     ==> "[%1lu] "
 //   MaxVal=9876  ==> "[%4lu] "
 void makePrintfFormatString(char *Buf, size_t BufLen, size_t MaxVal) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   int NumDigits = 0;
   do {
     ++NumDigits;
     MaxVal /= 10;
   } while (MaxVal);
   snprintf(Buf, BufLen, "[%%%dlu] ", NumDigits);
 }
 
 } // end of anonymous namespace
 
 void TimerStack::dump(Ostream &Str, bool DumpCumulative) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   const bool UpdateCounts = true;
   update(UpdateCounts);
   double TotalTime = LastTimestamp - FirstTimestamp;
   assert(TotalTime);
   char FmtString[30], PrefixStr[30];
   if (DumpCumulative) {
     Str << Name << " - Cumulative times:\n";
     size_t MaxInternalCount = 0;
     for (TimerTreeNode &Node : Nodes)
@@ skipping 36 matching lines @@
   dumpHelper(Str, FlatMap, TotalTime);
   Str << "Number of timer updates: " << StateChangeCount << "\n";
 }
 
 double TimerStack::timestamp() {
   // TODO: Implement in terms of std::chrono for C++11.
   return llvm::TimeRecord::getCurrentTime(false).getWallTime();
 }
 
 } // end of namespace Ice