Subzero. Allocate global initializers from a dedicated arena.

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 202 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() = default;
     virtual SizeT getNumBytes() const = 0;
     virtual void dump(Ostream &Stream) const = 0;
     virtual void dumpType(Ostream &Stream) const;
 
   protected:
     explicit Initializer(InitializerKind Kind) : Kind(Kind) {}
 
   private:
     const InitializerKind Kind;
   };
+  static_assert(std::is_trivially_destructible<Initializer>::value,
+                "Initializer must be trivially destructible.");
 
   /// Models the data in a data initializer.
-  using DataVecType = std::vector<char>;
+  using DataVecType = char *;
 
   /// 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... Args>
-    static std::unique_ptr<DataInitializer> create(Args &&... TheArgs) {
-      return makeUnique<DataInitializer>(std::forward<Args>(TheArgs)...);
+    template <typename T, class... Args>
+    static DataInitializer *create(T *AllocOwner, Args &&... TheArgs) {
+      return new (AllocOwner->template allocate_initializer<DataInitializer>())
+          DataInitializer(AllocOwner, std::forward<Args>(TheArgs)...);
     }
 
-    const DataVecType &getContents() const { return Contents; }
-    SizeT getNumBytes() const final { return Contents.size(); }
+    const llvm::StringRef getContents() const {
+      return llvm::StringRef(Contents, ContentsSize);
+    }
+    SizeT getNumBytes() const final { return ContentsSize; }
     void dump(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()) {
+    template <typename T>
+    DataInitializer(T *AllocOwner,
+                    const llvm::NaClBitcodeRecord::RecordVector &Values)
+        : Initializer(DataInitializerKind), ContentsSize(Values.size()),
+          // ugh, we should actually do new char[], but this may involve
+          // implementation-specific details. Given that Contents is arena
+          // allocated, and never detele[]d, just use char --
+          // AllocOwner->allocate_array will allocate a buffer with the right
+          // size.
+          Contents(new (AllocOwner->template allocate_initializer<char>(
+              ContentsSize)) char) {
       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) {
+    template <typename T>
+    DataInitializer(T *AllocOwner, const char *Str, size_t StrLen)
+        : Initializer(DataInitializerKind), ContentsSize(StrLen),
+          Contents(new (AllocOwner->template allocate_initializer<char>(
+              ContentsSize)) char) {
       for (size_t i = 0; i < StrLen; ++i)
         Contents[i] = Str[i];
     }
 
     /// The byte contents of the data initializer.
+    const SizeT ContentsSize;
     DataVecType Contents;
   };
+  static_assert(std::is_trivially_destructible<DataInitializer>::value,
+                "DataInitializer must be trivially destructible.");
 
   /// Defines a sequence of bytes initialized to zero.
   class ZeroInitializer : public Initializer {
     ZeroInitializer(const ZeroInitializer &) = delete;
     ZeroInitializer &operator=(const ZeroInitializer &) = delete;
 
   public:
-    static std::unique_ptr<ZeroInitializer> create(SizeT Size) {
-      return makeUnique<ZeroInitializer>(Size);
+    template <typename T>
+    static ZeroInitializer *create(T *AllocOwner, SizeT Size) {
+      return new (AllocOwner->template allocate_initializer<ZeroInitializer>())
+          ZeroInitializer(Size);
     }
     SizeT getNumBytes() const final { return Size; }
     void dump(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;
   };
+  static_assert(std::is_trivially_destructible<ZeroInitializer>::value,
+                "ZeroInitializer must be trivially destructible.");
 
   /// Defines the relocation value of another global declaration.
   class RelocInitializer : public Initializer {
     RelocInitializer(const RelocInitializer &) = delete;
     RelocInitializer &operator=(const RelocInitializer &) = delete;
 
   public:
-    static std::unique_ptr<RelocInitializer>
-    create(const GlobalDeclaration *Declaration,
-           const RelocOffsetArray &OffsetExpr) {
+    template <typename T>
+    static RelocInitializer *create(T *AllocOwner,
+                                    const GlobalDeclaration *Declaration,
+                                    const RelocOffsetArray &OffsetExpr) {
       constexpr bool NoFixup = false;
-      return makeUnique<RelocInitializer>(Declaration, OffsetExpr, NoFixup);
+      return new (AllocOwner->template allocate_initializer<RelocInitializer>())
+          RelocInitializer(AllocOwner, Declaration, OffsetExpr, NoFixup);
     }
 
-    static std::unique_ptr<RelocInitializer>
-    create(const GlobalDeclaration *Declaration,
+    template <typename T>
+    static RelocInitializer *
+    create(T *AllocOwner, const GlobalDeclaration *Declaration,
            const RelocOffsetArray &OffsetExpr, FixupKind Fixup) {
       constexpr bool HasFixup = true;
-      return makeUnique<RelocInitializer>(Declaration, OffsetExpr, HasFixup,
-                                          Fixup);
+      return new (AllocOwner->template allocate_initializer<RelocInitializer>())
+          RelocInitializer(AllocOwner, Declaration, OffsetExpr, HasFixup,
+                           Fixup);
     }
 
     RelocOffsetT getOffset() const {
       RelocOffsetT Offset = 0;
-      for (const auto *RelocOffset : OffsetExpr) {
-        Offset += RelocOffset->getOffset();
+      for (SizeT i = 0; i < OffsetExprSize; ++i) {
+        Offset += OffsetExpr[i]->getOffset();
       }
       return Offset;
     }
 
     bool hasFixup() const { return HasFixup; }
     FixupKind getFixup() const {
       assert(HasFixup);
       return Fixup;
     }
 
     const GlobalDeclaration *getDeclaration() const { return Declaration; }
     SizeT getNumBytes() const final { return RelocAddrSize; }
     void dump(Ostream &Stream) const final;
     void dumpType(Ostream &Stream) const final;
     static bool classof(const Initializer *R) {
       return R->getKind() == RelocInitializerKind;
     }
 
   private:
-    ENABLE_MAKE_UNIQUE;
-
-    RelocInitializer(const GlobalDeclaration *Declaration,
+    template <typename T>
+    RelocInitializer(T *AllocOwner, const GlobalDeclaration *Declaration,
                      const RelocOffsetArray &OffsetExpr, bool HasFixup,
                      FixupKind Fixup = 0)
         : Initializer(RelocInitializerKind),
           Declaration(Declaration), // The global declaration used in the reloc.
-          OffsetExpr(OffsetExpr), HasFixup(HasFixup), Fixup(Fixup) {}
+          OffsetExprSize(OffsetExpr.size()),
+          OffsetExpr(
+              new (AllocOwner->template allocate_initializer<RelocOffset *>(
+                  OffsetExprSize)) RelocOffset *),
+          HasFixup(HasFixup), Fixup(Fixup) {
+      for (SizeT i = 0; i < OffsetExprSize; ++i) {
+        this->OffsetExpr[i] = OffsetExpr[i];
+      }
+    }
 
     const GlobalDeclaration *Declaration;
     /// The offset to add to the relocation.
-    const RelocOffsetArray OffsetExpr;
+    const SizeT OffsetExprSize;
+    RelocOffset **OffsetExpr;
     const bool HasFixup = false;
     const FixupKind Fixup = 0;
   };
+  static_assert(std::is_trivially_destructible<RelocInitializer>::value,
+                "RelocInitializer must be trivially destructible.");
 
   /// Models the list of initializers.
-  using InitializerListType = std::vector<std::unique_ptr<Initializer>>;
+  // TODO(jpp): missing allocator.
+  using InitializerListType = std::vector<Initializer *>;
 
-  static VariableDeclaration *create(GlobalContext *Context,
+  template <typename T>
+  static VariableDeclaration *create(T *AllocOwner,
                                      bool SuppressMangling = false,
                                      llvm::GlobalValue::LinkageTypes Linkage =
                                          llvm::GlobalValue::InternalLinkage) {
-    return new (Context->allocate<VariableDeclaration>())
+    return new (
+        AllocOwner
+            ->template allocate_variable_declaration<VariableDeclaration>())
         VariableDeclaration(Linkage, SuppressMangling);
   }
-  static VariableDeclaration *createExternal(GlobalContext *Context) {
+
+  template <typename T>
+  static VariableDeclaration *createExternal(T *AllocOwner) {
     constexpr bool SuppressMangling = true;
     constexpr llvm::GlobalValue::LinkageTypes Linkage =
         llvm::GlobalValue::ExternalLinkage;
-    return create(Context, SuppressMangling, Linkage);
+    return create(AllocOwner, SuppressMangling, Linkage);
   }
 
-  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 HasInitializer; }
   bool hasNonzeroInitializer() const {
-    return !(Initializers->size() == 1 &&
-             llvm::isa<ZeroInitializer>((*Initializers)[0].get()));
+    return !(Initializers.size() == 1 &&
+             llvm::isa<ZeroInitializer>(Initializers[0]));
   }
 
   /// Returns the number of bytes for the initializer of the global address.
   SizeT getNumBytes() const {
     SizeT Count = 0;
-    for (const std::unique_ptr<Initializer> &Init : *Initializers) {
+    for (const auto *Init : Initializers) {
       Count += Init->getNumBytes();
     }
     return Count;
   }
 
   /// Adds Initializer to the list of initializers. Takes ownership of the
   /// initializer.
-  void addInitializer(std::unique_ptr<Initializer> Initializer) {
+  void addInitializer(Initializer *Initializer) {
     const bool OldSuppressMangling = getSuppressMangling();
-    Initializers->emplace_back(std::move(Initializer));
+    Initializers.emplace_back(Initializer);
     HasInitializer = true;
     // The getSuppressMangling() logic depends on whether the global variable
     // has initializers.  If its value changed as a result of adding an
     // initializer, then make sure we haven't previously set the name based on
     // faulty SuppressMangling logic.
     const bool SameMangling = (OldSuppressMangling == getSuppressMangling());
     (void)SameMangling;
     assert(!Name.empty() || SameMangling);
   }
 
@@ skipping 12 matching lines @@
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
   }
 
   bool getSuppressMangling() const final {
     if (ForceSuppressMangling)
       return true;
     return isExternal() && !hasInitializer();
   }
 
-  void discardInitializers() { Initializers = nullptr; }
+  void discardInitializers() { Initializers.clear(); }
 
 private:
   /// List of initializers for the declared variable.
-  std::unique_ptr<InitializerListType> Initializers;
+  InitializerListType Initializers;
   bool HasInitializer = false;
   /// The alignment of the declared variable.
   uint32_t Alignment = 0;
   /// True if a declared (global) constant.
   bool IsConstant = false;
   /// If set to true, force getSuppressMangling() to return true.
   const bool ForceSuppressMangling;
 
   VariableDeclaration(llvm::GlobalValue::LinkageTypes Linkage,
                       bool SuppressMangling)
       : GlobalDeclaration(VariableDeclarationKind, Linkage),
-        Initializers(new InitializerListType),
         ForceSuppressMangling(SuppressMangling) {}
 };
 
 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