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

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand 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 Operand class and its target-independent
@@ skipping 73 matching lines @@
        I != E; ++I) {
     if (OtherBegin < I->first) {
       Result = false;
       break;
     }
     if (OtherBegin < I->second) {
       Result = true;
       break;
     }
   }
-#if 0
-  // An equivalent but less inefficient implementation:
-  LiveRange Temp;
-  Temp.addSegment(OtherBegin, OtherBegin + 1);
-  bool Validation = overlaps(Temp);
-  assert(Result == Validation);
-#endif
+  // This is an equivalent but less inefficient implementation.  It's
+  // expensive enough that we wouldn't want to run it under any build,
+  // but it could be enabled if e.g. the LiveRange implementation
+  // changes and extra testing is needed.
+  if (buildAllowsExtraValidation()) {
+    LiveRange Temp;
+    Temp.addSegment(OtherBegin, OtherBegin + 1);
+    bool Validation = overlaps(Temp);
+    (void)Validation;
+    assert(Result == Validation);
+  }
   return Result;
 }
 
 // Returns true if the live range contains the given instruction
 // number.  This is only used for validating the live range
 // calculation.  The IsDest argument indicates whether the Variable
 // being tested is used in the Dest position (as opposed to a Src
 // position).
 bool LiveRange::containsValue(InstNumberT Value, bool IsDest) const {
   for (const RangeElementType &I : Range) {
@@ skipping 11 matching lines @@
 
 IceString Variable::getName(const Cfg *Func) const {
   if (Func && NameIndex >= 0)
     return Func->getIdentifierName(NameIndex);
   return "__" + std::to_string(getIndex());
 }
 
 Variable *Variable::asType(Type Ty) {
   // Note: This returns a Variable, even if the "this" object is a
   // subclass of Variable.
-  if (!ALLOW_DUMP || getType() == Ty)
+  if (!buildAllowsDump() || getType() == Ty)
     return this;
   Variable *V = new (getCurrentCfgAllocator()->Allocate<Variable>())
       Variable(kVariable, Ty, Number);
   V->NameIndex = NameIndex;
   V->RegNum = RegNum;
   V->StackOffset = StackOffset;
   return V;
 }
 
 void VariableTracking::markUse(MetadataKind TrackingKind, const Inst *Instr,
@@ skipping 238 matching lines @@
     return nullptr; // conservative answer
   SizeT VarNum = Var->getIndex();
   return Metadata[VarNum].getNode();
 }
 
 const InstDefList VariablesMetadata::NoDefinitions;
 
 // ======================== dump routines ======================== //
 
 void Variable::emit(const Cfg *Func) const {
-  if (ALLOW_DUMP)
+  if (buildAllowsDump())
     Func->getTarget()->emitVariable(this);
 }
 
 void Variable::dump(const Cfg *Func, Ostream &Str) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   if (Func == nullptr) {
     Str << "%" << getName(Func);
     return;
   }
   if (Func->isVerbose(IceV_RegOrigins) ||
       (!hasReg() && !Func->getTarget()->hasComputedFrame()))
     Str << "%" << getName(Func);
   if (hasReg()) {
     if (Func->isVerbose(IceV_RegOrigins))
@@ skipping 33 matching lines @@
 
 void ConstantRelocatable::emit(TargetLowering *Target) const {
   Target->emit(this);
 }
 
 void ConstantRelocatable::emitWithoutPrefix(TargetLowering *Target) const {
   Target->emitWithoutPrefix(this);
 }
 
 void ConstantRelocatable::dump(const Cfg *Func, Ostream &Str) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Str << "@";
   if (Func && !SuppressMangling) {
     Str << Func->getContext()->mangleName(Name);
   } else {
     Str << Name;
   }
   if (Offset)
     Str << "+" << Offset;
 }
 
 void ConstantUndef::emit(TargetLowering *Target) const { Target->emit(this); }
 
 void LiveRange::dump(Ostream &Str) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Str << "(weight=" << Weight << ") ";
   bool First = true;
   for (const RangeElementType &I : Range) {
     if (!First)
       Str << ", ";
     First = false;
     Str << "[" << I.first << ":" << I.second << ")";
   }
 }
 
 Ostream &operator<<(Ostream &Str, const LiveRange &L) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return Str;
   L.dump(Str);
   return Str;
 }
 
 Ostream &operator<<(Ostream &Str, const RegWeight &W) {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return Str;
   if (W.getWeight() == RegWeight::Inf)
     Str << "Inf";
   else
     Str << W.getWeight();
   return Str;
 }
 
 // =========== Immediate Randomization and Pooling routines ==============
 // Specialization of the template member function for ConstantInteger32
 // TODO(stichnot): try to move this specialization into a target-specific
 // file.
 template <>
 bool ConstantInteger32::shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
   uint32_t Threshold = Ctx->getFlags().getRandomizeAndPoolImmediatesThreshold();
   if (Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_None)
     return false;
   if (getType() != IceType_i32 && getType() != IceType_i16 &&
       getType() != IceType_i8)
     return false;
   // The Following checks if the signed representation of Value is between
   // -Threshold/2 and +Threshold/2
   bool largerThanThreshold = Threshold / 2 + Value >= Threshold;
   return largerThanThreshold;
 }
 
 } // end of namespace Ice