Simplify references to command line flags.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 704 matching lines @@
     GlobalPool->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().getAllowUninitializedGlobals())
+      if (Ice::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 std::string GlobalPrefix = Ctx->getFlags().getDefaultGlobalPrefix();
+  const std::string GlobalPrefix = getFlags().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 std::string FunctionPrefix = Ctx->getFlags().getDefaultFunctionPrefix();
+  const std::string FunctionPrefix = getFlags().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 52 matching lines @@
   for (Module::const_global_iterator I = Mod->global_begin(),
                                      E = Mod->global_end();
        I != E; ++I) {
     const GlobalVariable *GV = I;
     constexpr bool NoSuppressMangling = false;
     auto *Var = VariableDeclaration::create(
         GlobalDeclarationsPool.get(), NoSuppressMangling, GV->getLinkage());
     Var->setAlignment(GV->getAlignment());
     Var->setIsConstant(GV->isConstant());
     Var->setName(Ctx, GV->getName());
-    if (!Var->verifyLinkageCorrect(Ctx)) {
+    if (!Var->verifyLinkageCorrect()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Global " << Var->getName()
              << " has incorrect linkage: " << Var->getLinkageName();
       if (Var->isExternal())
         StrBuf << "\n  Use flag -allow-externally-defined-symbols to override";
       report_fatal_error(StrBuf.str());
     }
     GlobalDeclarationMap[GV] = Var;
   }
 }
 
 void Converter::convertGlobals(Module *Mod) {
   LLVM2ICEGlobalsConverter(*this, GlobalDeclarationsPool.get())
       .convertGlobalsToIce(Mod);
   lowerGlobals(std::move(GlobalDeclarationsPool));
 }
 
 void Converter::convertFunctions() {
   for (const Function &I : *Mod) {
     if (I.empty())
       continue;
     TimerMarker _(Ctx, I.getName());
     LLVM2ICEFunctionConverter FunctionConverter(*this);
     FunctionConverter.convertFunction(&I);
   }
 }
 
 } // end of namespace Ice