third_party/subzero/src/IceGlobalInits.h - SwiftShader - Git at Google

 //===- 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
 /// \brief 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 "IceDefs.h"
 #include "IceFixups.h"
 #include "IceGlobalContext.h"
 #include "IceIntrinsics.h"
 #include "IceMangling.h"
 #include "IceOperand.h"
 #include "IceTypes.h"

 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 #endif // __clang__

 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h" // for NaClBitcodeRecord.
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/GlobalValue.h" // for GlobalValue::LinkageTypes.

 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif // __clang__

 #include <memory>
 #include <utility>

 // TODO(kschimpf): Remove ourselves from using LLVM representation for calling
 // conventions and linkage types.

 namespace Ice {

 /// Base class for global variable and function declarations.
 class GlobalDeclaration {
   GlobalDeclaration() = delete;
   GlobalDeclaration(const GlobalDeclaration &) = delete;
   GlobalDeclaration &operator=(const GlobalDeclaration &) = delete;

 public:
   /// Discriminator for LLVM-style RTTI.
   enum GlobalDeclarationKind {
     FunctionDeclarationKind,
     VariableDeclarationKind
   };
   GlobalDeclarationKind getKind() const { return Kind; }
   GlobalString getName() const { return Name; }
   void setName(GlobalContext *Ctx, const std::string &NewName) {
     Name = Ctx->getGlobalString(getSuppressMangling() ? NewName
                                                       : mangleName(NewName));
   }
   void setName(GlobalString NewName) { Name = NewName; }
   void setName(GlobalContext *Ctx) {
     Name = GlobalString::createWithoutString(Ctx);
   }
   bool hasName() const { return Name.hasStdString(); }
   bool isInternal() const {
     return Linkage == llvm::GlobalValue::InternalLinkage;
   }
   llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
   void setLinkage(llvm::GlobalValue::LinkageTypes L) {
     assert(!hasName());
     Linkage = L;
   }
   bool isExternal() const {
     return Linkage == llvm::GlobalValue::ExternalLinkage;
   }
   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(Ostream &Stream) const = 0;

   /// Returns true if when emitting names, we should suppress mangling.
   virtual bool getSuppressMangling() const = 0;

   /// Returns textual name of linkage.
   const char *getLinkageName() const {
     return isInternal() ? "internal" : "external";
   }

 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 {
     switch (Linkage) {
     default:
       return false;
     case llvm::GlobalValue::InternalLinkage:
       return true;
     case llvm::GlobalValue::ExternalLinkage:
       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.
 class FunctionDeclaration : public GlobalDeclaration {
   FunctionDeclaration() = delete;
   FunctionDeclaration(const FunctionDeclaration &) = delete;
   FunctionDeclaration &operator=(const FunctionDeclaration &) = delete;

 public:
   static FunctionDeclaration *create(GlobalContext *Context,
                                      const FuncSigType &Signature,
                                      llvm::CallingConv::ID CallingConv,
                                      llvm::GlobalValue::LinkageTypes Linkage,
                                      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(Ostream &Stream) const final;
   bool getSuppressMangling() const final { return isExternal() && IsProto; }

   /// Returns true if linkage is correct for the function declaration.
   bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
     return verifyLinkageDefault();
   }

   /// Validates that the type signature of the function is correct. Returns true
   /// if valid.
   bool validateTypeSignature() const;

   /// Generates an error message describing why validateTypeSignature returns
   /// false.
   std::string getTypeSignatureError(const GlobalContext *Ctx);

 private:
   const Ice::FuncSigType Signature;
   llvm::CallingConv::ID CallingConv;
   const bool IsProto;

   FunctionDeclaration(const FuncSigType &Signature,
                       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;

 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,
       ZeroInitializerKind,
       RelocInitializerKind
     };
     InitializerKind getKind() const { return Kind; }
     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 = 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 DataInitializer *create(VariableDeclarationList *VDL,
                                    Args &&... TheArgs) {
       return new (VDL->allocate_initializer<DataInitializer>())
           DataInitializer(VDL, std::forward<Args>(TheArgs)...);
     }

     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:
     DataInitializer(VariableDeclarationList *VDL,
                     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 delete[]d, just use char --
           // AllocOwner->allocate_array will allocate a buffer with the right
           // size.
           Contents(new (VDL->allocate_initializer<char>(ContentsSize)) char) {
       for (SizeT I = 0; I < Values.size(); ++I)
         Contents[I] = static_cast<int8_t>(Values[I]);
     }

     DataInitializer(VariableDeclarationList *VDL, const char *Str,
                     size_t StrLen)
         : Initializer(DataInitializerKind), ContentsSize(StrLen),
           Contents(new (VDL->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 ZeroInitializer *create(VariableDeclarationList *VDL, SizeT Size) {
       return new (VDL->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:
     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 RelocInitializer *create(VariableDeclarationList *VDL,
                                     const GlobalDeclaration *Declaration,
                                     const RelocOffsetArray &OffsetExpr) {
       constexpr bool NoFixup = false;
       return new (VDL->allocate_initializer<RelocInitializer>())
           RelocInitializer(VDL, Declaration, OffsetExpr, NoFixup);
     }

     static RelocInitializer *create(VariableDeclarationList *VDL,
                                     const GlobalDeclaration *Declaration,
                                     const RelocOffsetArray &OffsetExpr,
                                     FixupKind Fixup) {
       constexpr bool HasFixup = true;
       return new (VDL->allocate_initializer<RelocInitializer>())
           RelocInitializer(VDL, Declaration, OffsetExpr, HasFixup, Fixup);
     }

     RelocOffsetT getOffset() const {
       RelocOffsetT Offset = 0;
       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:
     RelocInitializer(VariableDeclarationList *VDL,
                      const GlobalDeclaration *Declaration,
                      const RelocOffsetArray &OffsetExpr, bool HasFixup,
                      FixupKind Fixup = 0)
         : Initializer(RelocInitializerKind),
           Declaration(Declaration), // The global declaration used in the reloc.
           OffsetExprSize(OffsetExpr.size()),
           OffsetExpr(new (VDL->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 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.
   // TODO(jpp): missing allocator.
   using InitializerListType = std::vector<Initializer *>;

   static VariableDeclaration *create(VariableDeclarationList *VDL,
                                      bool SuppressMangling = false,
                                      llvm::GlobalValue::LinkageTypes Linkage =
                                          llvm::GlobalValue::InternalLinkage) {
     return new (VDL->allocate_variable_declaration<VariableDeclaration>())
         VariableDeclaration(Linkage, SuppressMangling);
   }

   static VariableDeclaration *createExternal(VariableDeclarationList *VDL) {
     constexpr bool SuppressMangling = true;
     constexpr llvm::GlobalValue::LinkageTypes Linkage =
         llvm::GlobalValue::ExternalLinkage;
     return create(VDL, SuppressMangling, Linkage);
   }

   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]));
   }

   /// Returns the number of bytes for the initializer of the global address.
   SizeT getNumBytes() const {
     SizeT Count = 0;
     for (const auto *Init : Initializers) {
       Count += Init->getNumBytes();
     }
     return Count;
   }

   /// Adds Initializer to the list of initializers. Takes ownership of the
   /// initializer.
   void addInitializer(Initializer *Initializer) {
     const bool OldSuppressMangling = getSuppressMangling();
     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.hasStdString() || SameMangling);
   }

   /// 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 { return verifyLinkageDefault(); }

   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
   }

   bool getSuppressMangling() const final {
     if (ForceSuppressMangling)
       return true;
     return isExternal() && !hasInitializer();
   }

   void discardInitializers() { Initializers.clear(); }

 private:
   /// List of initializers for the declared variable.
   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),
         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
	//===- 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
	/// \brief 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 "IceDefs.h"
	#include "IceFixups.h"
	#include "IceGlobalContext.h"
	#include "IceIntrinsics.h"
	#include "IceMangling.h"
	#include "IceOperand.h"
	#include "IceTypes.h"

	#ifdef __clang__
	#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Wunused-parameter"
	#endif // __clang__

	#include "llvm/Bitcode/NaCl/NaClBitcodeParser.h" // for NaClBitcodeRecord.
	#include "llvm/IR/CallingConv.h"
	#include "llvm/IR/GlobalValue.h" // for GlobalValue::LinkageTypes.

	#ifdef __clang__
	#pragma clang diagnostic pop
	#endif // __clang__

	#include <memory>
	#include <utility>

	// TODO(kschimpf): Remove ourselves from using LLVM representation for calling
	// conventions and linkage types.

	namespace Ice {

	/// Base class for global variable and function declarations.
	class GlobalDeclaration {
	GlobalDeclaration() = delete;
	GlobalDeclaration(const GlobalDeclaration &) = delete;
	GlobalDeclaration &operator=(const GlobalDeclaration &) = delete;

	public:
	/// Discriminator for LLVM-style RTTI.
	enum GlobalDeclarationKind {
	FunctionDeclarationKind,
	VariableDeclarationKind
	};
	GlobalDeclarationKind getKind() const { return Kind; }
	GlobalString getName() const { return Name; }
	void setName(GlobalContext *Ctx, const std::string &NewName) {
	Name = Ctx->getGlobalString(getSuppressMangling() ? NewName
	: mangleName(NewName));
	}
	void setName(GlobalString NewName) { Name = NewName; }
	void setName(GlobalContext *Ctx) {
	Name = GlobalString::createWithoutString(Ctx);
	}
	bool hasName() const { return Name.hasStdString(); }
	bool isInternal() const {
	return Linkage == llvm::GlobalValue::InternalLinkage;
	}
	llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
	void setLinkage(llvm::GlobalValue::LinkageTypes L) {
	assert(!hasName());
	Linkage = L;
	}
	bool isExternal() const {
	return Linkage == llvm::GlobalValue::ExternalLinkage;
	}
	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(Ostream &Stream) const = 0;

	/// Returns true if when emitting names, we should suppress mangling.
	virtual bool getSuppressMangling() const = 0;

	/// Returns textual name of linkage.
	const char *getLinkageName() const {
	return isInternal() ? "internal" : "external";
	}

	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 {
	switch (Linkage) {
	default:
	return false;
	case llvm::GlobalValue::InternalLinkage:
	return true;
	case llvm::GlobalValue::ExternalLinkage:
	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.
	class FunctionDeclaration : public GlobalDeclaration {
	FunctionDeclaration() = delete;
	FunctionDeclaration(const FunctionDeclaration &) = delete;
	FunctionDeclaration &operator=(const FunctionDeclaration &) = delete;

	public:
	static FunctionDeclaration create(GlobalContext Context,
	const FuncSigType &Signature,
	llvm::CallingConv::ID CallingConv,
	llvm::GlobalValue::LinkageTypes Linkage,
	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(Ostream &Stream) const final;
	bool getSuppressMangling() const final { return isExternal() && IsProto; }

	/// Returns true if linkage is correct for the function declaration.
	bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
	return verifyLinkageDefault();
	}

	/// Validates that the type signature of the function is correct. Returns true
	/// if valid.
	bool validateTypeSignature() const;

	/// Generates an error message describing why validateTypeSignature returns
	/// false.
	std::string getTypeSignatureError(const GlobalContext *Ctx);

	private:
	const Ice::FuncSigType Signature;
	llvm::CallingConv::ID CallingConv;
	const bool IsProto;

	FunctionDeclaration(const FuncSigType &Signature,
	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;

	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,
	ZeroInitializerKind,
	RelocInitializerKind
	};
	InitializerKind getKind() const { return Kind; }
	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 = 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 DataInitializer create(VariableDeclarationList VDL,
	Args &&... TheArgs) {
	return new (VDL->allocate_initializer<DataInitializer>())
	DataInitializer(VDL, std::forward<Args>(TheArgs)...);
	}

	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:
	DataInitializer(VariableDeclarationList *VDL,
	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 delete[]d, just use char --
	// AllocOwner->allocate_array will allocate a buffer with the right
	// size.
	Contents(new (VDL->allocate_initializer<char>(ContentsSize)) char) {
	for (SizeT I = 0; I < Values.size(); ++I)
	Contents[I] = static_cast<int8_t>(Values[I]);
	}

	DataInitializer(VariableDeclarationList VDL, const char Str,
	size_t StrLen)
	: Initializer(DataInitializerKind), ContentsSize(StrLen),
	Contents(new (VDL->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 ZeroInitializer create(VariableDeclarationList VDL, SizeT Size) {
	return new (VDL->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:
	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 RelocInitializer create(VariableDeclarationList VDL,
	const GlobalDeclaration *Declaration,
	const RelocOffsetArray &OffsetExpr) {
	constexpr bool NoFixup = false;
	return new (VDL->allocate_initializer<RelocInitializer>())
	RelocInitializer(VDL, Declaration, OffsetExpr, NoFixup);
	}

	static RelocInitializer create(VariableDeclarationList VDL,
	const GlobalDeclaration *Declaration,
	const RelocOffsetArray &OffsetExpr,
	FixupKind Fixup) {
	constexpr bool HasFixup = true;
	return new (VDL->allocate_initializer<RelocInitializer>())
	RelocInitializer(VDL, Declaration, OffsetExpr, HasFixup, Fixup);
	}

	RelocOffsetT getOffset() const {
	RelocOffsetT Offset = 0;
	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:
	RelocInitializer(VariableDeclarationList *VDL,
	const GlobalDeclaration *Declaration,
	const RelocOffsetArray &OffsetExpr, bool HasFixup,
	FixupKind Fixup = 0)
	: Initializer(RelocInitializerKind),
	Declaration(Declaration), // The global declaration used in the reloc.
	OffsetExprSize(OffsetExpr.size()),
	OffsetExpr(new (VDL->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 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.
	// TODO(jpp): missing allocator.
	using InitializerListType = std::vector<Initializer *>;

	static VariableDeclaration create(VariableDeclarationList VDL,
	bool SuppressMangling = false,
	llvm::GlobalValue::LinkageTypes Linkage =
	llvm::GlobalValue::InternalLinkage) {
	return new (VDL->allocate_variable_declaration<VariableDeclaration>())
	VariableDeclaration(Linkage, SuppressMangling);
	}

	static VariableDeclaration createExternal(VariableDeclarationList VDL) {
	constexpr bool SuppressMangling = true;
	constexpr llvm::GlobalValue::LinkageTypes Linkage =
	llvm::GlobalValue::ExternalLinkage;
	return create(VDL, SuppressMangling, Linkage);
	}

	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]));
	}

	/// Returns the number of bytes for the initializer of the global address.
	SizeT getNumBytes() const {
	SizeT Count = 0;
	for (const auto *Init : Initializers) {
	Count += Init->getNumBytes();
	}
	return Count;
	}

	/// Adds Initializer to the list of initializers. Takes ownership of the
	/// initializer.
	void addInitializer(Initializer *Initializer) {
	const bool OldSuppressMangling = getSuppressMangling();
	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.hasStdString() \|\| SameMangling);
	}

	/// 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 { return verifyLinkageDefault(); }

	static bool classof(const GlobalDeclaration *Addr) {
	return Addr->getKind() == VariableDeclarationKind;
	}

	bool getSuppressMangling() const final {
	if (ForceSuppressMangling)
	return true;
	return isExternal() && !hasInitializer();
	}

	void discardInitializers() { Initializers.clear(); }

	private:
	/// List of initializers for the declared variable.
	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),
	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