Simplify references to command line flags.

src/IceGlobalInits.h

 //===- subzero/src/IceGlobalInits.h - Global declarations -------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 91 matching lines @@
   /// should have ExternalLinkage (as a special case).
   virtual bool isPNaClABIExternalName(const std::string &Name) const = 0;
 
 protected:
   GlobalDeclaration(GlobalDeclarationKind Kind,
                     llvm::GlobalValue::LinkageTypes Linkage)
       : Kind(Kind), Linkage(Linkage) {}
 
   /// Returns true if linkage is defined correctly for the global declaration,
   /// based on default rules.
-  bool verifyLinkageDefault(const GlobalContext *Ctx) const {
+  bool verifyLinkageDefault() const {
     switch (Linkage) {
     default:
       return false;
     case llvm::GlobalValue::InternalLinkage:
       return true;
     case llvm::GlobalValue::ExternalLinkage:
-      return Ctx->getFlags().getAllowExternDefinedSymbols();
+      return getFlags().getAllowExternDefinedSymbols();
     }
   }
 
   const GlobalDeclarationKind Kind;
   llvm::GlobalValue::LinkageTypes Linkage;
   GlobalString Name;
 };
 
 /// Models a function declaration. This includes the type signature of the
 /// function, its calling conventions, and its linkage.
@@ skipping 23 matching lines @@
   bool getSuppressMangling() const final { return isExternal() && IsProto; }
 
   /// Returns true if linkage is correct for the function declaration.
   bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
     if (getName().hasStdString()) {
       if (isPNaClABIExternalName(getName().toString()) ||
           isIntrinsicName(Ctx)) {
         return Linkage == llvm::GlobalValue::ExternalLinkage;
       }
     }
-    return verifyLinkageDefault(Ctx);
+    return verifyLinkageDefault();
   }
 
   /// Validates that the type signature of the function is correct. Returns true
   /// if valid.
   bool validateTypeSignature(const GlobalContext *Ctx) const {
     bool IsIntrinsic;
     if (const Intrinsics::FullIntrinsicInfo *Info =
             getIntrinsicInfo(Ctx, &IsIntrinsic))
       return validateIntrinsicTypeSignature(Info);
     return !IsIntrinsic && validateRegularTypeSignature();
@@ skipping 280 matching lines @@
   }
 
   /// Prints out type for initializer associated with the declaration to Stream.
   void dumpType(Ostream &Stream) const final;
 
   /// Prints out the definition of the global variable declaration (including
   /// initialization).
   virtual void dump(Ostream &Stream) const override;
 
   /// Returns true if linkage is correct for the variable declaration.
-  bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
+  bool verifyLinkageCorrect() const {
     if (getName().hasStdString()) {
       if (isPNaClABIExternalName(getName().toString())) {
         return Linkage == llvm::GlobalValue::ExternalLinkage;
       }
     }
-    return verifyLinkageDefault(Ctx);
+    return verifyLinkageDefault();
   }
 
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
   }
 
   bool getSuppressMangling() const final {
     if (ForceSuppressMangling)
       return true;
     return isExternal() && !hasInitializer();
@@ skipping 32 matching lines @@
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
                               const GlobalDeclaration &Addr) {
   Addr.dump(Stream);
   return Stream;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALINITS_H