Subzero. Fixes memory leaks.

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,
 // global variable declarations, and the corresponding variable
 // initializers in Subzero. Global variable initializers are
 // represented as a sequence of simple initializers.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALINITS_H
 #define SUBZERO_SRC_ICEGLOBALINITS_H
 
+#include <memory>
+#include <utility>
+
+#include "llvm/Bitcode/NaCl/NaClBitcodeParser.h" // for NaClBitcodeRecord.
 #include "llvm/IR/CallingConv.h"
-#include "llvm/IR/GlobalValue.h" // for GlobalValue::LinkageTypes
+#include "llvm/IR/GlobalValue.h" // for GlobalValue::LinkageTypes.
 
 #include "IceDefs.h"
 #include "IceTypes.h"
 
 // TODO(kschimpf): Remove ourselves from using LLVM representation for calling
 // conventions and linkage types.
 
 namespace Ice {
 
 /// Base class for global variable and function declarations.
@@ skipping 15 matching lines @@
   bool isInternal() const {
     return Linkage == llvm::GlobalValue::InternalLinkage;
   }
   llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
   bool isExternal() const {
     return Linkage == llvm::GlobalValue::ExternalLinkage;
   }
   void setLinkage(llvm::GlobalValue::LinkageTypes NewLinkage) {
     Linkage = NewLinkage;
   }
-  virtual ~GlobalDeclaration() {}
+  virtual ~GlobalDeclaration() = default;
 
   /// Prints out type of the global declaration.
   virtual void dumpType(Ostream &Stream) const = 0;
 
   /// Prints out the global declaration.
   virtual void dump(GlobalContext *Ctx, Ostream &Stream) const = 0;
   void dump(Ostream &Stream) const {
     if (!ALLOW_DUMP)
       return;
     GlobalContext *const Ctx = nullptr;
@@ skipping 20 matching lines @@
 };
 
 // Models a function declaration. This includes the type signature of
 // the function, its calling conventions, and its linkage.
 class FunctionDeclaration : public GlobalDeclaration {
   FunctionDeclaration() = delete;
   FunctionDeclaration(const FunctionDeclaration &) = delete;
   FunctionDeclaration &operator=(const FunctionDeclaration &) = delete;
 
 public:
-  static FunctionDeclaration *create(const FuncSigType &Signature,
+  static FunctionDeclaration *create(GlobalContext *Context,
+                                     const FuncSigType &Signature,
                                      llvm::CallingConv::ID CallingConv,
                                      llvm::GlobalValue::LinkageTypes Linkage,
-                                     bool IsProto);
-  ~FunctionDeclaration() final {}
+                                     bool IsProto) {
+    return new (Context->allocate<FunctionDeclaration>())
+        FunctionDeclaration(Signature, CallingConv, Linkage, IsProto);
+  }
   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;
   }
   void dumpType(Ostream &Stream) const final;
   void dump(GlobalContext *Ctx, Ostream &Stream) const final;
   bool getSuppressMangling() const final { return isExternal() && IsProto; }
@@ skipping 22 matching lines @@
     Initializer &operator=(const Initializer &) = delete;
 
   public:
     /// Discriminator for LLVM-style RTTI.
     enum InitializerKind {
       DataInitializerKind,
       ZeroInitializerKind,
       RelocInitializerKind
     };
     InitializerKind getKind() const { return Kind; }
-    virtual ~Initializer() {}
+    virtual ~Initializer() = default;
     virtual SizeT getNumBytes() const = 0;
     virtual void dump(GlobalContext *Ctx, Ostream &Stream) const = 0;
     void dump(Ostream &Stream) const {
       if (ALLOW_DUMP)
         dump(nullptr, Stream);
     }
     virtual void dumpType(Ostream &Stream) const;
 
   protected:
     explicit Initializer(InitializerKind Kind) : Kind(Kind) {}
 
   private:
     const InitializerKind Kind;
   };
 
   // Models the data in a data initializer.
   typedef std::vector<char> DataVecType;
 
   /// Defines a sequence of byte values as a data initializer.
   class DataInitializer : public Initializer {
     DataInitializer(const DataInitializer &) = delete;
     DataInitializer &operator=(const DataInitializer &) = delete;
 
   public:
-    template <class IntContainer>
-    DataInitializer(const IntContainer &Values)
-        : Initializer(DataInitializerKind), Contents(Values.size()) {
-      size_t i = 0;
-      for (auto &V : Values) {
-        Contents[i] = static_cast<int8_t>(V);
-        ++i;
-      }
+    template <class... Args>
+    static std::unique_ptr<DataInitializer> create(Args &&... TheArgs) {
+      return makeUnique<DataInitializer>(std::forward<Args>(TheArgs)...);
     }
-    DataInitializer(const char *Str, size_t StrLen)
-        : Initializer(DataInitializerKind), Contents(StrLen) {
-      for (size_t i = 0; i < StrLen; ++i)
-        Contents[i] = Str[i];
-    }
-    ~DataInitializer() override {}
+
     const DataVecType &getContents() const { return Contents; }
     SizeT getNumBytes() const final { return Contents.size(); }
     void dump(GlobalContext *Ctx, Ostream &Stream) const final;
     static bool classof(const Initializer *D) {
       return D->getKind() == DataInitializerKind;
     }
 
   private:
+    ENABLE_MAKE_UNIQUE;
+
+    DataInitializer(const llvm::NaClBitcodeRecord::RecordVector &Values)
+        : Initializer(DataInitializerKind), Contents(Values.size()) {
+      for (SizeT I = 0; I < Values.size(); ++I)
+        Contents[I] = static_cast<int8_t>(Values[I]);
+    }
+
+    DataInitializer(const char *Str, size_t StrLen)
+        : Initializer(DataInitializerKind), Contents(StrLen) {
+      for (size_t i = 0; i < StrLen; ++i)
+        Contents[i] = Str[i];
+    }
+
     // The byte contents of the data initializer.
     DataVecType Contents;
   };
 
   /// Defines a sequence of bytes initialized to zero.
   class ZeroInitializer : public Initializer {
     ZeroInitializer(const ZeroInitializer &) = delete;
     ZeroInitializer &operator=(const ZeroInitializer &) = delete;
 
   public:
-    explicit ZeroInitializer(SizeT Size)
-        : Initializer(ZeroInitializerKind), Size(Size) {}
-    ~ZeroInitializer() override {}
+    static std::unique_ptr<ZeroInitializer> create(SizeT Size) {
+      return makeUnique<ZeroInitializer>(Size);
+    }
     SizeT getNumBytes() const final { return Size; }
     void dump(GlobalContext *Ctx, Ostream &Stream) const final;
     static bool classof(const Initializer *Z) {
       return Z->getKind() == ZeroInitializerKind;
     }
 
   private:
+    ENABLE_MAKE_UNIQUE;
+
+    explicit ZeroInitializer(SizeT Size)
+        : Initializer(ZeroInitializerKind), Size(Size) {}
+
     // The number of bytes to be zero initialized.
     SizeT Size;
   };
 
   /// Defines the relocation value of another global declaration.
   class RelocInitializer : public Initializer {
     RelocInitializer(const RelocInitializer &) = delete;
     RelocInitializer &operator=(const RelocInitializer &) = delete;
 
   public:
-    RelocInitializer(const GlobalDeclaration *Declaration, RelocOffsetT Offset)
-        : Initializer(RelocInitializerKind), Declaration(Declaration),
-          Offset(Offset) {}
-    ~RelocInitializer() override {}
+    static std::unique_ptr<RelocInitializer>
+    create(const GlobalDeclaration *Declaration, RelocOffsetT Offset) {
+      return makeUnique<RelocInitializer>(Declaration, Offset);
+    }
+
     RelocOffsetT getOffset() const { return Offset; }
     const GlobalDeclaration *getDeclaration() const { return Declaration; }
     SizeT getNumBytes() const final { return RelocAddrSize; }
     void dump(GlobalContext *Ctx, Ostream &Stream) const final;
     void dumpType(Ostream &Stream) const final;
     static bool classof(const Initializer *R) {
       return R->getKind() == RelocInitializerKind;
     }
 
   private:
-    // The global declaration used in the relocation.
+    ENABLE_MAKE_UNIQUE;
+
+    RelocInitializer(const GlobalDeclaration *Declaration, RelocOffsetT Offset)
+        : Initializer(RelocInitializerKind), Declaration(Declaration),
+          Offset(Offset) {} // 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;
+  typedef std::vector<std::unique_ptr<Initializer>> InitializerListType;
 
-  static VariableDeclaration *create();
-  ~VariableDeclaration() final;
+  static VariableDeclaration *create(GlobalContext *Context) {
+    return new (Context->allocate<VariableDeclaration>()) VariableDeclaration();
+  }
 
-  const InitializerListType &getInitializers() const { return Initializers; }
+  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 hasInitializer() const { return HasInitializer; }
   bool hasNonzeroInitializer() const {
-    return !(Initializers.size() == 1 &&
-             llvm::isa<ZeroInitializer>(Initializers[0]));
+    return !(Initializers->size() == 1 &&
+             llvm::isa<ZeroInitializer>((*Initializers)[0].get()));
   }
 
   /// Returns the number of bytes for the initializer of the global
   /// address.
   SizeT getNumBytes() const {
     SizeT Count = 0;
-    for (Initializer *Init : Initializers) {
+    for (const std::unique_ptr<Initializer> &Init : *Initializers) {
       Count += Init->getNumBytes();
     }
     return Count;
   }
 
   /// Adds Initializer to the list of initializers. Takes ownership of
   /// the initializer.
-  void addInitializer(Initializer *Initializer) {
-    Initializers.push_back(Initializer);
+  void addInitializer(std::unique_ptr<Initializer> Initializer) {
+    Initializers->emplace_back(std::move(Initializer));
+    HasInitializer = true;
   }
 
   /// 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).
   void dump(GlobalContext *Ctx, Ostream &Stream) const final;
 
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
   }
 
   bool getSuppressMangling() const final {
     if (ForceSuppressMangling)
       return true;
     return isExternal() && !hasInitializer();
   }
 
   void setSuppressMangling() { ForceSuppressMangling = true; }
 
+  void discardInitializers() { Initializers = nullptr; }
+
 private:
   // list of initializers for the declared variable.
-  InitializerListType Initializers;
+  std::unique_ptr<InitializerListType> Initializers;
+  bool HasInitializer;
   // The alignment of the declared variable.
   uint32_t Alignment;
   // True if a declared (global) constant.
   bool IsConstant;
   // If set to true, force getSuppressMangling() to return true.
   bool ForceSuppressMangling;
 
   VariableDeclaration()
       : GlobalDeclaration(VariableDeclarationKind,
                           llvm::GlobalValue::InternalLinkage),
+        Initializers(new InitializerListType), HasInitializer(false),
         Alignment(0), IsConstant(false), ForceSuppressMangling(false) {}
 };
 
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
                               const VariableDeclaration::Initializer &Init) {
   Init.dump(Stream);
   return Stream;
 }
 
 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