Simplify references to command line flags.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 428 matching lines @@
   size_t NextDefiningFunctionID = 0;
   // The set of global variables.
   std::unique_ptr<Ice::VariableDeclarationList> VariableDeclarations;
   // Relocatable constants associated with global declarations.
   Ice::ConstantList ValueIDConstants;
   // Error recovery value to use when getFuncSigTypeByID fails.
   Ice::FuncSigType UndefinedFuncSigType;
   // Defines if a module block has already been parsed.
   bool ParsedModuleBlock = false;
 
-  static const Ice::ClFlags &getFlags() {
-    return Ice::GlobalContext::getFlags();
-  }
-
   bool ParseBlock(unsigned BlockID) override;
 
   // Gets extended type associated with the given index, assuming the extended
   // type is of the WantedKind. Generates error message if corresponding
   // extended type of WantedKind can't be found, and returns nullptr.
   ExtendedType *getTypeByIDAsKind(NaClBcIndexSize_t ID,
                                   ExtendedType::TypeKind WantedKind) {
     ExtendedType *Ty = nullptr;
     if (ID < TypeIDValues.size()) {
       Ty = &TypeIDValues[ID];
@@ skipping 23 matching lines @@
       } else {
         Decl->setName(Ctx);
       }
       ++NameIndex;
     }
   }
 
   // Installs names for global variables without names.
   void installGlobalVarNames() {
     assert(VariableDeclarations);
-    const std::string &GlobalPrefix = getFlags().getDefaultGlobalPrefix();
+    const std::string &GlobalPrefix = Ice::getFlags().getDefaultGlobalPrefix();
     if (!GlobalPrefix.empty()) {
       NaClBcIndexSize_t NameIndex = 0;
       for (Ice::VariableDeclaration *Var : *VariableDeclarations) {
         installDeclarationName(Var, GlobalPrefix, "global", NameIndex);
       }
     }
   }
 
   // Installs names for functions without names.
   void installFunctionNames() {
-    const std::string &FunctionPrefix = getFlags().getDefaultFunctionPrefix();
+    const std::string &FunctionPrefix =
+        Ice::getFlags().getDefaultFunctionPrefix();
     if (!FunctionPrefix.empty()) {
       NaClBcIndexSize_t NameIndex = 0;
       for (Ice::FunctionDeclaration *Func : FunctionDeclarations) {
         installDeclarationName(Func, FunctionPrefix, "function", NameIndex);
       }
     }
   }
 
   // Builds a constant symbol named Name.  IsExternal is true iff the symbol is
   // external.
@@ skipping 24 matching lines @@
     for (const Ice::FunctionDeclaration *Func : FunctionDeclarations) {
       if (!Func->verifyLinkageCorrect(Ctx))
         reportLinkageError("Function", *Func);
       Ice::Constant *C = getConstantSym(Func->getName(), Func->isProto());
       ValueIDConstants.push_back(C);
     }
   }
 
   // Converts global variable declarations into constant value IDs.
   void createValueIDsForGlobalVars() {
-    Ice::GlobalContext *Ctx = getTranslator().getContext();
     for (const Ice::VariableDeclaration *Decl : *VariableDeclarations) {
-      if (!Decl->verifyLinkageCorrect(Ctx))
+      if (!Decl->verifyLinkageCorrect())
         reportLinkageError("Global", *Decl);
       Ice::Constant *C =
           getConstantSym(Decl->getName(), !Decl->hasInitializer());
       ValueIDConstants.push_back(C);
     }
   }
 
   // Reports that type ID is undefined, or not of the WantedType.
   void reportBadTypeIDAs(NaClBcIndexSize_t ID, const ExtendedType *Ty,
                          ExtendedType::TypeKind WantedType);
@@ skipping 18 matching lines @@
   {
     std::unique_lock<Ice::GlobalLockType> _(ErrorReportingLock);
     ErrorStatus.assign(Ice::EC_Bitcode);
   }
   { // Lock while printing out error message.
     Ice::OstreamLocker L(Context);
     raw_ostream &OldErrStream = setErrStream(Context->getStrError());
     NaClBitcodeParser::ErrorAt(Level, Bit, Message);
     setErrStream(OldErrStream);
   }
-  if (Level >= naclbitc::Error && !getFlags().getAllowErrorRecovery())
+  if (Level >= naclbitc::Error && !Ice::getFlags().getAllowErrorRecovery())
     Fatal();
   return true;
 }
 
 void TopLevelParser::reportBadTypeIDAs(NaClBcIndexSize_t ID,
                                        const ExtendedType *Ty,
                                        ExtendedType::TypeKind WantedType) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   if (Ty == nullptr) {
@@ skipping 83 matching lines @@
   bool BlockHasError = false;
 
   // Constructor for nested block parsers.
   BlockParserBaseClass(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : NaClBitcodeParser(BlockID, EnclosingParser),
         Context(EnclosingParser->Context) {}
 
   // Gets the translator associated with the bitcode parser.
   Ice::Translator &getTranslator() const { return Context->getTranslator(); }
 
-  static const Ice::ClFlags &getFlags() {
-    return Ice::GlobalContext::getFlags();
-  }
-
   // Default implementation. Reports that block is unknown and skips its
   // contents.
   bool ParseBlock(unsigned BlockID) override;
 
   // Default implementation. Reports that the record is not understood.
   void ProcessRecord() override;
 
   // Checks if the size of the record is Size. Return true if valid. Otherwise
   // generates an error and returns false.
   bool isValidRecordSize(size_t Size, const char *RecordName) {
@@ skipping 55 matching lines @@
 
 // Generates an error Message with the bit address prefixed to it.
 bool BlockParserBaseClass::ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
                                    const std::string &Message) {
   BlockHasError = true;
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   // Note: If dump routines have been turned off, the error messages will not
   // be readable. Hence, replace with simple error. We also use the simple form
   // for unit tests.
-  if (getFlags().getGenerateUnitTestMessages()) {
+  if (Ice::getFlags().getGenerateUnitTestMessages()) {
     StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
     for (const uint64_t Val : Record.GetValues()) {
       StrBuf << " " << Val;
     }
     StrBuf << ">";
   } else {
     StrBuf << Message;
   }
   return Context->ErrorAt(Level, Bit, StrBuf.str());
 }
@@ skipping 2205 matching lines @@
 class ModuleParser final : public BlockParserBaseClass {
   ModuleParser() = delete;
   ModuleParser(const ModuleParser &) = delete;
   ModuleParser &operator=(const ModuleParser &) = delete;
 
 public:
   ModuleParser(unsigned BlockID, TopLevelParser *Context)
       : BlockParserBaseClass(BlockID, Context),
         Timer(Ice::TimerStack::TT_parseModule,
               Context->getTranslator().getContext()),
-        IsParseParallel(Ice::GlobalContext::Flags.isParseParallel()) {}
+        IsParseParallel(Ice::getFlags().isParseParallel()) {}
   ~ModuleParser() override = default;
   const char *getBlockName() const override { return "module"; }
   NaClBitstreamCursor &getCursor() const { return Record.GetCursor(); }
 
 private:
   Ice::TimerMarker Timer;
   // True if we have already installed names for unnamed global declarations,
   // and have generated global constant initializers.
   bool GlobalDeclarationNamesAndInitializersInstalled = false;
   // True if we have already processed the symbol table for the module.
@@ skipping 159 matching lines @@
       }
       Ctx->optQueueBlockingPush(Ice::makeUnique<CfgParserWorkItem>(
           BlockID, FcnId, this, std::move(Buffer), BufferSize, StartBit,
           SeqNumber));
       return false;
     } else {
       FunctionParser Parser(BlockID, this, FcnId);
       std::unique_ptr<Ice::Cfg> Func = Parser.parseFunction(SeqNumber);
       bool Failed = Func->hasError();
       getTranslator().translateFcn(std::move(Func));
-      return Failed && !getFlags().getAllowErrorRecovery();
+      return Failed && !Ice::getFlags().getAllowErrorRecovery();
     }
   }
   default:
     return BlockParserBaseClass::ParseBlock(BlockID);
   }
 }
 
 void ModuleParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
@@ skipping 108 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << IRFilename << ": Does not contain a module!";
     llvm::report_fatal_error(StrBuf.str());
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice