Adds accessor methods to class ClFlags.

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 173 matching lines @@
   unsigned getNumErrors() const { return NumErrors; }
 
   /// Returns the number of bytes in the bitcode header.
   size_t getHeaderSize() const { return Header.getHeaderSize(); }
 
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(unsigned NewSize) { TypeIDValues.resize(NewSize); }
 
   /// Returns true if generation of Subzero IR is disabled.
   bool isIRGenerationDisabled() const {
-    return ALLOW_DISABLE_IR_GEN ? Translator.getFlags().DisableIRGeneration
+    return ALLOW_DISABLE_IR_GEN ? Translator.getFlags().getDisableIRGeneration()

[Jim Stichnoth, 2015/02/05 22:30:09]

Change to
  return ALLOW_DISABLE_IR_GEN &&
getTranslator().getFlags().getDisableIRGeneration();

Or better yet, change getDisableIRGeneration() to
  return ALLOW_DISABLE_IR_GEN && DisableIRGeneration;
and simplify the two uses in this file and the one in IceGlobalContext.h.

[Karl, 2015/02/05 23:57:38]

Done. Also did similar changes to: getDumpStats, getGenerateUnitTestMessages,
and getTimeEachFunction.

                                 : false;
   }
 
   /// Returns the undefined type associated with type ID.
   /// Note: Returns extended type ready to be defined.
   ExtendedType *getTypeByIDForDefining(unsigned ID) {
     // Get corresponding element, verifying the value is still undefined
     // (and hence allowed to be defined).
     ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Undefined);
     if (Ty)
@@ skipping 246 matching lines @@
 };
 
 bool TopLevelParser::Error(const std::string &Message) {
   ErrorStatus.assign(Ice::EC_Bitcode);
   ++NumErrors;
   Ice::GlobalContext *Context = Translator.getContext();
   Ice::OstreamLocker L(Context);
   raw_ostream &OldErrStream = setErrStream(Context->getStrDump());
   NaClBitcodeParser::Error(Message);
   setErrStream(OldErrStream);
-  if (!Translator.getFlags().AllowErrorRecovery)
+  if (!Translator.getFlags().getAllowErrorRecovery())
     report_fatal_error("Unable to continue");
   return true;
 }
 
 void TopLevelParser::reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
                                        ExtendedType::TypeKind WantedType) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   if (Ty == nullptr) {
     StrBuf << "Can't find extended type for type id: " << ID;
@@ skipping 73 matching lines @@
   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(); }
 
   const Ice::ClFlags &getFlags() const { return getTranslator().getFlags(); }
 
   bool isIRGenerationDisabled() const {
-    return ALLOW_DISABLE_IR_GEN ? getTranslator().getFlags().DisableIRGeneration
-                                : false;
+    return ALLOW_DISABLE_IR_GEN
+               ? getTranslator().getFlags().getDisableIRGeneration()
+               : false;
   }
 
   // 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;
 
@@ skipping 58 matching lines @@
 // Generates an error Message with the bit address prefixed to it.
 bool BlockParserBaseClass::Error(const std::string &Message) {
   uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8;
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8),
                           static_cast<unsigned>(Bit % 8)) << ") ";
   // 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 (ALLOW_DUMP && !getFlags().GenerateUnitTestMessages) {
+  if (ALLOW_DUMP && !getFlags().getGenerateUnitTestMessages()) {
     StrBuf << Message;
   } else {
     StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
     for (const uint64_t Val : Record.GetValues()) {
       StrBuf << " " << Val;
     }
     StrBuf << ">";
   }
   return Context->Error(StrBuf.str());
 }
@@ skipping 438 matching lines @@
         Func(nullptr), CurrentBbIndex(0),
         FcnId(Context->getNextFunctionBlockValueID()),
         FuncDecl(Context->getFunctionByID(FcnId)),
         CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
         NextLocalInstIndex(Context->getNumGlobalIDs()),
         InstIsTerminating(false) {}
 
   bool convertFunction() {
     const Ice::TimerStackIdT StackID = Ice::GlobalContext::TSK_Funcs;
     Ice::TimerIdT TimerID = 0;
-    const bool TimeThisFunction = ALLOW_DUMP && getFlags().TimeEachFunction;
+    const bool TimeThisFunction =
+        ALLOW_DUMP && getFlags().getTimeEachFunction();
     if (TimeThisFunction) {
       TimerID = getTranslator().getContext()->getTimerID(StackID,
                                                          FuncDecl->getName());
       getTranslator().getContext()->pushTimer(TimerID, StackID);
     }
 
     if (!isIRGenerationDisabled())
       Func = Ice::Cfg::create(getTranslator().getContext());
     Ice::Cfg::setCurrentCfg(Func.get());
 
@@ skipping 1349 matching lines @@
         if (!IntrinsicInfo) {
           std::string Buffer;
           raw_string_ostream StrBuf(Buffer);
           StrBuf << "Invalid PNaCl intrinsic call to " << Name;
           Error(StrBuf.str());
           appendErrorInstruction(ReturnType);
           return;
         }
       }
     } else {
-      if (getFlags().StubConstantCalls &&
+      if (getFlags().getStubConstantCalls() &&
           llvm::isa<Ice::ConstantInteger32>(Callee)) {
         Callee = Context->getStubbedConstCallValue(Callee);
       }
       ReturnType = Context->getSimpleTypeByID(Values[2]);
     }
 
     // Extract call information.
     uint64_t CCInfo = Values[0];
     CallingConv::ID CallingConv;
     if (!naclbitc::DecodeCallingConv(CCInfo >> 1, CallingConv)) {
@@ skipping 329 matching lines @@
   // and have generated global constant initializers.
   bool GlobalDeclarationNamesAndInitializersInstalled;
 
   // Generates names for unnamed global addresses (i.e. functions and
   // global variables). Then lowers global variable declaration
   // initializers to the target. May be called multiple times. Only
   // the first call will do the installation.
   void InstallGlobalNamesAndGlobalVarInitializers() {
     if (!GlobalDeclarationNamesAndInitializersInstalled) {
       Ice::Translator &Trans = getTranslator();
-      const Ice::IceString &GlobalPrefix = getFlags().DefaultGlobalPrefix;
+      const Ice::IceString &GlobalPrefix = getFlags().getDefaultGlobalPrefix();
       if (!GlobalPrefix.empty()) {
         uint32_t NameIndex = 0;
         for (Ice::VariableDeclaration *Var : Context->getGlobalVariables()) {
           installDeclarationName(Trans, Var, GlobalPrefix, "global", NameIndex);
         }
       }
-      const Ice::IceString &FunctionPrefix = getFlags().DefaultFunctionPrefix;
+      const Ice::IceString &FunctionPrefix =
+          getFlags().getDefaultFunctionPrefix();
       if (!FunctionPrefix.empty()) {
         uint32_t NameIndex = 0;
         for (Ice::FunctionDeclaration *Func :
              Context->getFunctionDeclarationList()) {
           installDeclarationName(Trans, Func, FunctionPrefix, "function",
                                  NameIndex);
         }
       }
       getTranslator().lowerGlobals(Context->getGlobalVariables());
       GlobalDeclarationNamesAndInitializersInstalled = true;
@@ skipping 189 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus.assign(EC_Bitcode);
   }
 }
 
 } // end of namespace Ice