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

src/IceCompileServer.cpp

 //===- subzero/src/IceCompileServer.cpp - Compile server ------------------===//
 //
 //                        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 basic commandline-based compile server.
@@ skipping 17 matching lines @@
 #include "IceClFlags.h"
 #include "IceClFlagsExtra.h"
 #include "IceCompileServer.h"
 #include "IceELFStreamer.h"
 #include "IceGlobalContext.h"
 
 namespace Ice {
 
 namespace {
 
-static_assert(
-!(INPUT_IS_TEXTUAL_BITCODE && PNACL_BROWSER_TRANSLATOR),
-  "Can not define INPUT_IS_TEXTUAL_BITCODE when building browswer translator");
+static_assert(!(BuildDefs::textualBitcode() && PNACL_BROWSER_TRANSLATOR),
+              "Can not define INPUT_IS_TEXTUAL_BITCODE when building browswer "
+              "translator");
 
 // Define a SmallVector backed buffer as a data stream, so that it
 // can hold the generated binary version of the textual bitcode in the
 // input file.
 class TextDataStreamer : public llvm::DataStreamer {
 public:
   TextDataStreamer() = default;
   ~TextDataStreamer() final = default;
   static TextDataStreamer *create(const IceString &Filename, std::string *Err);
   size_t GetBytes(unsigned char *Buf, size_t Len) final;
+
 private:
   llvm::SmallVector<char, 1024> BitcodeBuffer;
   size_t Cursor = 0;
 };
 
 TextDataStreamer *TextDataStreamer::create(const IceString &Filename,
                                            std::string *Err) {
   TextDataStreamer *Streamer = new TextDataStreamer();
   llvm::raw_string_ostream ErrStrm(*Err);
   if (std::error_code EC = llvm::readNaClRecordTextAndBuildBitcode(
@@ skipping 30 matching lines @@
 
 ErrorCodes getReturnValue(const Ice::ClFlagsExtra &Flags, ErrorCodes Val) {
   if (Flags.getAlwaysExitSuccess())
     return EC_None;
   return Val;
 }
 
 } // end of anonymous namespace
 
 void CLCompileServer::run() {
-  if (ALLOW_DUMP) {
+  if (BuildDefs::dump()) {
     llvm::sys::PrintStackTraceOnErrorSignal();
   }
   ClFlags::parseFlags(argc, argv);
   ClFlags Flags;
   ClFlagsExtra ExtraFlags;
   ClFlags::getParsedClFlags(Flags);
   ClFlags::getParsedClFlagsExtra(ExtraFlags);
 
   std::error_code EC;
   std::unique_ptr<Ostream> Ls = makeStream(ExtraFlags.getLogFilename(), EC);
@@ skipping 29 matching lines @@
       *Ls << "Failed to open output file: " << ExtraFlags.getOutputFilename()
           << ":\n" << EC.message() << "\n";
       return transferErrorCode(getReturnValue(ExtraFlags, Ice::EC_Args));
     }
     Os->SetUnbuffered();
   } break;
   }
 
   IceString StrError;
   std::unique_ptr<llvm::DataStreamer> InputStream(
-      INPUT_IS_TEXTUAL_BITCODE
-      ? TextDataStreamer::create(ExtraFlags.getIRFilename(), &StrError)
-      : llvm::getDataFileStreamer(ExtraFlags.getIRFilename(), &StrError)
-                                                  );
+      BuildDefs::textualBitcode()
+          ? TextDataStreamer::create(ExtraFlags.getIRFilename(), &StrError)
+          : llvm::getDataFileStreamer(ExtraFlags.getIRFilename(), &StrError));
   if (!StrError.empty() || !InputStream) {
     llvm::SMDiagnostic Err(ExtraFlags.getIRFilename(),
                            llvm::SourceMgr::DK_Error, StrError);
     Err.print(ExtraFlags.getAppName().c_str(), *Ls);
     return transferErrorCode(getReturnValue(ExtraFlags, Ice::EC_Bitcode));
   }
 
   Ctx.reset(
       new GlobalContext(Ls.get(), Os.get(), Ls.get(), ELFStr.get(), Flags));
   if (Ctx->getFlags().getNumTranslationThreads() != 0) {
     std::thread CompileThread([this, &ExtraFlags, &InputStream]() {
       Ctx->initParserThread();
       getCompiler().run(ExtraFlags, *Ctx.get(), std::move(InputStream));
     });
     CompileThread.join();
   } else {
     getCompiler().run(ExtraFlags, *Ctx.get(), std::move(InputStream));
   }
   transferErrorCode(getReturnValue(
       ExtraFlags, static_cast<ErrorCodes>(Ctx->getErrorStatus()->value())));
 }
 
 } // end of namespace Ice