Adds accessor methods to class ClFlags.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        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 LLVM to ICE converter.
@@ skipping 698 matching lines @@
     VariableDeclarations.push_back(VarDecl);
 
     if (!GV->hasInternalLinkage() && GV->hasInitializer()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Can't define external global declaration: " << GV->getName();
       report_fatal_error(StrBuf.str());
     }
 
     if (!GV->hasInitializer()) {
-      if (Ctx->getFlags().AllowUninitializedGlobals)
+      if (Ctx->getFlags().getAllowUninitializedGlobals())
         continue;
       else {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Global declaration missing initializer: " << GV->getName();
         report_fatal_error(StrBuf.str());
       }
     }
 
     const Constant *Initializer = GV->getInitializer();
@@ skipping 64 matching lines @@
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Unhandled global initializer: " << Initializer;
   report_fatal_error(StrBuf.str());
 }
 
 } // end of anonymous namespace
 
 namespace Ice {
 
 void Converter::nameUnnamedGlobalVariables(Module *Mod) {
-  const IceString &GlobalPrefix = Flags.DefaultGlobalPrefix;
+  const IceString &GlobalPrefix = Flags.getDefaultGlobalPrefix();
   if (GlobalPrefix.empty())
     return;
   uint32_t NameIndex = 0;
   for (auto V = Mod->global_begin(), E = Mod->global_end(); V != E; ++V) {
     if (!V->hasName()) {
       V->setName(createUnnamedName(GlobalPrefix, NameIndex));
       ++NameIndex;
     } else {
       checkIfUnnamedNameSafe(V->getName(), "global", GlobalPrefix);
     }
   }
 }
 
 void Converter::nameUnnamedFunctions(Module *Mod) {
-  const IceString &FunctionPrefix = Flags.DefaultFunctionPrefix;
+  const IceString &FunctionPrefix = Flags.getDefaultFunctionPrefix();
   if (FunctionPrefix.empty())
     return;
   uint32_t NameIndex = 0;
   for (Function &F : *Mod) {
     if (!F.hasName()) {
       F.setName(createUnnamedName(FunctionPrefix, NameIndex));
       ++NameIndex;
     } else {
       checkIfUnnamedNameSafe(F.getName(), "function", FunctionPrefix);
     }
@@ skipping 59 matching lines @@
 }
 
 void Converter::convertFunctions() {
   const TimerStackIdT StackID = GlobalContext::TSK_Funcs;
   for (const Function &I : *Mod) {
     if (I.empty())
       continue;
 
     TimerIdT TimerID = 0;
     const bool TimeThisFunction =
-        ALLOW_DUMP && Ctx->getFlags().TimeEachFunction;
+        ALLOW_DUMP && Ctx->getFlags().getTimeEachFunction();
     if (TimeThisFunction) {
       TimerID = Ctx->getTimerID(StackID, I.getName());
       Ctx->pushTimer(TimerID, StackID);
     }
     LLVM2ICEFunctionConverter FunctionConverter(*this);
     FunctionConverter.convertFunction(&I);
     if (TimeThisFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 }
 
 } // end of namespace Ice