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

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        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 PNaCl bitcode file to Ice, to machine code
@@ skipping 62 matching lines @@
 protected:
   // Note: For simple types, the return type of the signature will
   // be used to hold the simple type.
   Ice::FuncSigType Signature;
 
 private:
   ExtendedType::TypeKind Kind = Undefined;
 };
 
 Ice::Ostream &operator<<(Ice::Ostream &Stream, const ExtendedType &Ty) {
-  if (!ALLOW_DUMP)
+  if (!Ice::BuildDefs::dump())
     return Stream;
   Ty.dump(Stream);
   return Stream;
 }
 
 Ice::Ostream &operator<<(Ice::Ostream &Stream, ExtendedType::TypeKind Kind) {
-  if (!ALLOW_DUMP)
+  if (!Ice::BuildDefs::dump())
     return Stream;
   Stream << "ExtendedType::";
   switch (Kind) {
   case ExtendedType::Undefined:
     Stream << "Undefined";
     break;
   case ExtendedType::Simple:
     Stream << "Simple";
     break;
   case ExtendedType::FuncSig:
@@ skipping 28 matching lines @@
   void setReturnType(Ice::Type ReturnType) {
     Signature.setReturnType(ReturnType);
   }
   void appendArgType(Ice::Type ArgType) { Signature.appendArgType(ArgType); }
   static bool classof(const ExtendedType *Ty) {
     return Ty->getKind() == FuncSig;
   }
 };
 
 void ExtendedType::dump(Ice::Ostream &Stream) const {
-  if (!ALLOW_DUMP)
+  if (!Ice::BuildDefs::dump())
     return;
   Stream << Kind;
   switch (Kind) {
   case Simple: {
     Stream << " " << Signature.getReturnType();
     break;
   }
   case FuncSig: {
     Stream << " " << Signature;
   }
@@ skipping 1407 matching lines @@
   enum VectorIndexCheckValue {
     VectorIndexNotVector,
     VectorIndexNotConstant,
     VectorIndexNotInRange,
     VectorIndexNotI32,
     VectorIndexValid
   };
 
   void dumpVectorIndexCheckValue(raw_ostream &Stream,
                                  VectorIndexCheckValue Value) const {
-    if (!ALLOW_DUMP)
+    if (!Ice::BuildDefs::dump())
       return;
     switch (Value) {
     case VectorIndexNotVector:
       Stream << "Vector index on non vector";
       break;
     case VectorIndexNotConstant:
       Stream << "Vector index not integer constant";
       break;
     case VectorIndexNotInRange:
       Stream << "Vector index not in range of vector";
@@ skipping 1253 matching lines @@
   // (FP->getOperand will create fatal error).
   if (Index < getFunctionParser()->getNumGlobalIDs()) {
     reportUnableToAssign("instruction", Index, Name);
     // TODO(kschimpf) Remove error recovery once implementation complete.
     return;
   }
   if (isIRGenerationDisabled())
     return;
   Ice::Operand *Op = getFunctionParser()->getOperand(Index);
   if (Ice::Variable *V = dyn_cast<Ice::Variable>(Op)) {
-    if (ALLOW_DUMP) {
+    if (Ice::BuildDefs::dump()) {
       std::string Nm(Name.data(), Name.size());
       V->setName(getFunctionParser()->getFunc(), Nm);
     }
   } else {
     reportUnableToAssign("variable", Index, Name);
   }
 }
 
 void FunctionValuesymtabParser::setBbName(NaClBcIndexSize_t Index,
                                           StringType &Name) {
   if (isIRGenerationDisabled())
     return;
   if (Index >= getFunctionParser()->getFunc()->getNumNodes()) {
     reportUnableToAssign("block", Index, Name);
     return;
   }
   std::string Nm(Name.data(), Name.size());
-  if (ALLOW_DUMP)
+  if (Ice::BuildDefs::dump())
     getFunctionParser()->getFunc()->getNodes()[Index]->setName(Nm);
 }
 
 bool FunctionParser::ParseBlock(unsigned BlockID) {
   switch (BlockID) {
   case naclbitc::CONSTANTS_BLOCK_ID: {
     ConstantsParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::VALUE_SYMTAB_BLOCK_ID: {
@@ skipping 226 matching lines @@
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     ErrStream
         << IRFilename
         << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice