Subzero: Remove the GlobalContext::GlobalDeclarations vector.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the representation of function declarations,
@@ skipping 73 matching lines @@
   const GlobalDeclarationKind Kind;
   IceString Name;
   llvm::GlobalValue::LinkageTypes Linkage;
 };
 
 // Models a function declaration. This includes the type signature of
 // the function, its calling conventions, and its linkage.
 class FunctionDeclaration : public GlobalDeclaration {
   FunctionDeclaration(const FunctionDeclaration &) = delete;
   FunctionDeclaration &operator=(const FunctionDeclaration &) = delete;
-  friend class GlobalContext;
 
 public:
-  static FunctionDeclaration *create(GlobalContext *Ctx,
-                                     const FuncSigType &Signature,
+  static FunctionDeclaration *create(const FuncSigType &Signature,
                                      llvm::CallingConv::ID CallingConv,
                                      llvm::GlobalValue::LinkageTypes Linkage,
                                      bool IsProto);
   ~FunctionDeclaration() final {}
   const FuncSigType &getSignature() const { return Signature; }
   llvm::CallingConv::ID getCallingConv() const { return CallingConv; }
   // isProto implies that there isn't a (local) definition for the function.
   bool isProto() const { return IsProto; }
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == FunctionDeclarationKind;
@@ skipping 13 matching lines @@
                       llvm::CallingConv::ID CallingConv,
                       llvm::GlobalValue::LinkageTypes Linkage, bool IsProto)
       : GlobalDeclaration(FunctionDeclarationKind, Linkage),
         Signature(Signature), CallingConv(CallingConv), IsProto(IsProto) {}
 };
 
 /// Models a global variable declaration, and its initializers.
 class VariableDeclaration : public GlobalDeclaration {
   VariableDeclaration(const VariableDeclaration &) = delete;
   VariableDeclaration &operator=(const VariableDeclaration &) = delete;
-  friend class GlobalContext;
-  // TODO(kschimpf) Factor out allocation of initializers into the
-  // global context, so that memory allocation/collection can be
-  // optimized.
 public:
   /// Base class for a global variable initializer.
   class Initializer {
     Initializer(const Initializer &) = delete;
     Initializer &operator=(const Initializer &) = delete;
 
   public:
     /// Discriminator for LLVM-style RTTI.
     enum InitializerKind {
       DataInitializerKind,
@@ skipping 95 matching lines @@
   private:
     // The global declaration used in the relocation.
     const GlobalDeclaration *Declaration;
     // The offset to add to the relocation.
     const RelocOffsetT Offset;
   };
 
   /// Models the list of initializers.
   typedef std::vector<Initializer *> InitializerListType;
 
-  static VariableDeclaration *create(GlobalContext *Ctx);
+  static VariableDeclaration *create();
   ~VariableDeclaration() final;
 
   const InitializerListType &getInitializers() const { return Initializers; }
   bool getIsConstant() const { return IsConstant; }
   void setIsConstant(bool NewValue) { IsConstant = NewValue; }
   uint32_t getAlignment() const { return Alignment; }
   void setAlignment(uint32_t NewAlignment) { Alignment = NewAlignment; }
   bool hasInitializer() const { return !Initializers.empty(); }
   bool hasNonzeroInitializer() const {
     return !(Initializers.size() == 1 &&
@@ skipping 56 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