Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- lib/CodeGen/DIE.h - DWARF Info Entries -------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// Data structures for DWARF info entries.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CODEGEN_DIE_H

#define LLVM_CODEGEN_DIE_H

#include "llvm/ADT/FoldingSet.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/PointerUnion.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/iterator.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/BinaryFormat/Dwarf.h"

#include "llvm/CodeGen/DwarfStringPoolEntry.h"

#include "llvm/Support/AlignOf.h"

#include "llvm/Support/Allocator.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <iterator>

#include <new>

#include <type_traits>

#include <utility>

#include <vector>

namespace llvm {

class AsmPrinter;

class DIE;

class DIEUnit;

class DwarfCompileUnit;

class MCExpr;

class MCSection;

class MCSymbol;

class raw_ostream;

//===--------------------------------------------------------------------===//

/// Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation.

class DIEAbbrevData {

  /// Dwarf attribute code.

  dwarf::Attribute Attribute;

  /// Dwarf form code.

  dwarf::Form Form;

  /// Dwarf attribute value for DW_FORM_implicit_const

  int64_t Value = 0;

public:

  DIEAbbrevData(dwarf::Attribute A, dwarf::Form F)

      : Attribute(A), Form(F) {}

  DIEAbbrevData(dwarf::Attribute A, int64_t V)

      : Attribute(A), Form(dwarf::DW_FORM_implicit_const), Value(V) {}

  /// Accessors.

  /// @{

  dwarf::Attribute getAttribute() const { return Attribute; }

  dwarf::Form getForm() const { return Form; }

  int64_t getValue() const { return Value; }

  /// @}

  /// Used to gather unique data for the abbreviation folding set.

  void Profile(FoldingSetNodeID &ID) const;

};

//===--------------------------------------------------------------------===//

/// Dwarf abbreviation, describes the organization of a debug information

/// object.

class DIEAbbrev : public FoldingSetNode {

  /// Unique number for node.

  unsigned Number = 0;

  /// Dwarf tag code.

  dwarf::Tag Tag;

  /// Whether or not this node has children.

  ///

  /// This cheats a bit in all of the uses since the values in the standard

  /// are 0 and 1 for no children and children respectively.

  bool Children;

  /// Raw data bytes for abbreviation.

  SmallVector<DIEAbbrevData, 12> Data;

public:

  DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {}

  /// Accessors.

  /// @{

  dwarf::Tag getTag() const { return Tag; }

  unsigned getNumber() const { return Number; }

  bool hasChildren() const { return Children; }

  const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }

  void setChildrenFlag(bool hasChild) { Children = hasChild; }

  void setNumber(unsigned N) { Number = N; }

  /// @}

  /// Adds another set of attribute information to the abbreviation.

  void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {

    Data.push_back(DIEAbbrevData(Attribute, Form));

  }

  /// Adds attribute with DW_FORM_implicit_const value

  void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) {

    Data.push_back(DIEAbbrevData(Attribute, Value));

  }

  /// Used to gather unique data for the abbreviation folding set.

  void Profile(FoldingSetNodeID &ID) const;

  /// Print the abbreviation using the specified asm printer.

  void Emit(const AsmPrinter *AP) const;

  void print(raw_ostream &O) const;

  void dump() const;

};

//===--------------------------------------------------------------------===//

/// Helps unique DIEAbbrev objects and assigns abbreviation numbers.

///

/// This class will unique the DIE abbreviations for a llvm::DIE object and

/// assign a unique abbreviation number to each unique DIEAbbrev object it

/// finds. The resulting collection of DIEAbbrev objects can then be emitted

/// into the .debug_abbrev section.

class DIEAbbrevSet {

  /// The bump allocator to use when creating DIEAbbrev objects in the uniqued

  /// storage container.

  BumpPtrAllocator &Alloc;

  /// FoldingSet that uniques the abbreviations.

  FoldingSet<DIEAbbrev> AbbreviationsSet;

  /// A list of all the unique abbreviations in use.

  std::vector<DIEAbbrev *> Abbreviations;

public:

  DIEAbbrevSet(BumpPtrAllocator &A) : Alloc(A) {}

  ~DIEAbbrevSet();

  /// Generate the abbreviation declaration for a DIE and return a pointer to

  /// the generated abbreviation.

  ///

  /// \param Die the debug info entry to generate the abbreviation for.

  /// \returns A reference to the uniqued abbreviation declaration that is

  /// owned by this class.

  DIEAbbrev &uniqueAbbreviation(DIE &Die);

  /// Print all abbreviations using the specified asm printer.

  void Emit(const AsmPrinter *AP, MCSection *Section) const;

};

//===--------------------------------------------------------------------===//

/// An integer value DIE.

///

class DIEInteger {

  uint64_t Integer;

public:

  explicit DIEInteger(uint64_t I) : Integer(I) {}

  /// Choose the best form for integer.

  static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {

    if (IsSigned) {

      const int64_t SignedInt = Int;

      if ((char)Int == SignedInt)

        return dwarf::DW_FORM_data1;

      if ((short)Int == SignedInt)

        return dwarf::DW_FORM_data2;

      if ((int)Int == SignedInt)

        return dwarf::DW_FORM_data4;

    } else {

      if ((unsigned char)Int == Int)

        return dwarf::DW_FORM_data1;

      if ((unsigned short)Int == Int)

        return dwarf::DW_FORM_data2;

      if ((unsigned int)Int == Int)

        return dwarf::DW_FORM_data4;

    }

    return dwarf::DW_FORM_data8;

  }

  uint64_t getValue() const { return Integer; }

  void setValue(uint64_t Val) { Integer = Val; }

  void emitValue(const AsmPrinter *Asm, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// An expression DIE.

class DIEExpr {

  const MCExpr *Expr;

public:

  explicit DIEExpr(const MCExpr *E) : Expr(E) {}

  /// Get MCExpr.

  const MCExpr *getValue() const { return Expr; }

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// A label DIE.

class DIELabel {

  const MCSymbol *Label;

public:

  explicit DIELabel(const MCSymbol *L) : Label(L) {}

  /// Get MCSymbol.

  const MCSymbol *getValue() const { return Label; }

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// A BaseTypeRef DIE.

class DIEBaseTypeRef {

  const DwarfCompileUnit *CU;

  const uint64_t Index;

  static constexpr unsigned ULEB128PadSize = 4;

public:

  explicit DIEBaseTypeRef(const DwarfCompileUnit *TheCU, uint64_t Idx)

    : CU(TheCU), Index(Idx) {}

  /// EmitValue - Emit base type reference.

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  /// sizeOf - Determine size of the base type reference in bytes.

  unsigned sizeOf(const dwarf::FormParams &, dwarf::Form) const;

  void print(raw_ostream &O) const;

  uint64_t getIndex() const { return Index; }

};

//===--------------------------------------------------------------------===//

/// A simple label difference DIE.

///

class DIEDelta {

  const MCSymbol *LabelHi;

  const MCSymbol *LabelLo;

public:

  DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// A container for string pool string values.

///

/// This class is used with the DW_FORM_strp and DW_FORM_GNU_str_index forms.

class DIEString {

  DwarfStringPoolEntryRef S;

public:

  DIEString(DwarfStringPoolEntryRef S) : S(S) {}

  /// Grab the string out of the object.

  StringRef getString() const { return S.getString(); }

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// A container for inline string values.

///

/// This class is used with the DW_FORM_string form.

class DIEInlineString {

  StringRef S;

public:

  template <typename Allocator>

  explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {}

  ~DIEInlineString() = default;

  /// Grab the string out of the object.

  StringRef getString() const { return S; }

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &, dwarf::Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// A pointer to another debug information entry.  An instance of this class can

/// also be used as a proxy for a debug information entry not yet defined

/// (ie. types.)

class DIEEntry {

  DIE *Entry;

public:

  DIEEntry() = delete;

  explicit DIEEntry(DIE &E) : Entry(&E) {}

  DIE &getEntry() const { return *Entry; }

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// Represents a pointer to a location list in the debug_loc

/// section.

class DIELocList {

  /// Index into the .debug_loc vector.

  size_t Index;

public:

  DIELocList(size_t I) : Index(I) {}

  /// Grab the current index out.

  size_t getValue() const { return Index; }

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// A BaseTypeRef DIE.

class DIEAddrOffset {

  DIEInteger Addr;

  DIEDelta Offset;

public:

  explicit DIEAddrOffset(uint64_t Idx, const MCSymbol *Hi, const MCSymbol *Lo)

      : Addr(Idx), Offset(Hi, Lo) {}

  void emitValue(const AsmPrinter *AP, dwarf::Form Form) const;

  unsigned sizeOf(const dwarf::FormParams &FormParams, dwarf::Form Form) const;

  void print(raw_ostream &O) const;

};

//===--------------------------------------------------------------------===//

/// A debug information entry value. Some of these roughly correlate

/// to DWARF attribute classes.

class DIEBlock;

class DIELoc;

class DIEValue {

public:

  enum Type {

    isNone,

#define HANDLE_DIEVALUE(T) is##T,

#include "llvm/CodeGen/DIEValue.def"

  };

private:

  /// Type of data stored in the value.

  Type Ty = isNone;

  dwarf::Attribute Attribute = (dwarf::Attribute)0;

  dwarf::Form Form = (dwarf::Form)0;

  /// Storage for the value.

  ///

  /// All values that aren't standard layout (or are larger than 8 bytes)

  /// should be stored by reference instead of by value.

  using ValTy =

      AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel,

                            DIEDelta *, DIEEntry, DIEBlock *, DIELoc *,

                            DIELocList, DIEBaseTypeRef *, DIEAddrOffset *>;

  static_assert(sizeof(ValTy) <= sizeof(uint64_t) ||

                    sizeof(ValTy) <= sizeof(void *),

                "Expected all large types to be stored via pointer");

  /// Underlying stored value.

  ValTy Val;

  template <class T> void construct(T V) {

    static_assert(std::is_standard_layout<T>::value ||

                      std::is_pointer<T>::value,

                  "Expected standard layout or pointer");

    new (reinterpret_cast<void *>(&Val)) T(V);

  }

  template <class T> T *get() { return reinterpret_cast<T *>(&Val); }

  template <class T> const T *get() const {

    return reinterpret_cast<const T *>(&Val);

  }

  template <class T> void destruct() { get<T>()->~T(); }

  /// Destroy the underlying value.

  ///

  /// This should get optimized down to a no-op.  We could skip it if we could

  /// add a static assert on \a std::is_trivially_copyable(), but we currently

  /// support versions of GCC that don't understand that.

  void destroyVal() {

    switch (Ty) {

    case isNone:

      return;

#define HANDLE_DIEVALUE_SMALL(T)                                               \

  case is##T:                                                                  \

    destruct<DIE##T>();                                                        \

    return;

#define HANDLE_DIEVALUE_LARGE(T)                                               \

  case is##T:                                                                  \

    destruct<const DIE##T *>();                                                \

    return;

#include "llvm/CodeGen/DIEValue.def"

    }

  }

  /// Copy the underlying value.

  ///

  /// This should get optimized down to a simple copy.  We need to actually

  /// construct the value, rather than calling memcpy, to satisfy strict

  /// aliasing rules.

  void copyVal(const DIEValue &X) {

    switch (Ty) {

    case isNone:

      return;

#define HANDLE_DIEVALUE_SMALL(T)                                               \

  case is##T:                                                                  \

    construct<DIE##T>(*X.get<DIE##T>());                                       \

    return;

#define HANDLE_DIEVALUE_LARGE(T)                                               \

  case is##T:                                                                  \

    construct<const DIE##T *>(*X.get<const DIE##T *>());                       \

    return;

#include "llvm/CodeGen/DIEValue.def"

    }

  }

public:

  DIEValue() = default;

  DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {

    copyVal(X);

  }

  DIEValue &operator=(const DIEValue &X) {

    destroyVal();

    Ty = X.Ty;

    Attribute = X.Attribute;

    Form = X.Form;

    copyVal(X);

    return *this;

  }

  ~DIEValue() { destroyVal(); }

#define HANDLE_DIEVALUE_SMALL(T)                                               \

  DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T &V)      \

      : Ty(is##T), Attribute(Attribute), Form(Form) {                          \

    construct<DIE##T>(V);                                                      \

  }

#define HANDLE_DIEVALUE_LARGE(T)                                               \

  DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T *V)      \

      : Ty(is##T), Attribute(Attribute), Form(Form) {                          \

    assert(V && "Expected valid value");                                       \

    construct<const DIE##T *>(V);                                              \

  }

#include "llvm/CodeGen/DIEValue.def"

  /// Accessors.

  /// @{

  Type getType() const { return Ty; }

  dwarf::Attribute getAttribute() const { return Attribute; }

  dwarf::Form getForm() const { return Form; }

  explicit operator bool() const { return Ty; }

  /// @}

#define HANDLE_DIEVALUE_SMALL(T)                                               \

  const DIE##T &getDIE##T() const {                                            \

    assert(getType() == is##T && "Expected " #T);                              \

    return *get<DIE##T>();                                                     \

  }

#define HANDLE_DIEVALUE_LARGE(T)                                               \

  const DIE##T &getDIE##T() const {                                            \

    assert(getType() == is##T && "Expected " #T);                              \

    return **get<const DIE##T *>();                                            \

  }

#include "llvm/CodeGen/DIEValue.def"

  /// Emit value via the Dwarf writer.

  void emitValue(const AsmPrinter *AP) const;

  /// Return the size of a value in bytes.

  unsigned sizeOf(const dwarf::FormParams &FormParams) const;

  void print(raw_ostream &O) const;

  void dump() const;

};

struct IntrusiveBackListNode {

  PointerIntPair<IntrusiveBackListNode *, 1> Next;

  IntrusiveBackListNode() : Next(this, true) {}

  IntrusiveBackListNode *getNext() const {

    return Next.getInt() ? nullptr : Next.getPointer();

  }

};

struct IntrusiveBackListBase {

  using Node = IntrusiveBackListNode;

  Node *Last = nullptr;

  bool empty() const { return !Last; }

  void push_back(Node &N) {

    assert(N.Next.getPointer() == &N && "Expected unlinked node");

    assert(N.Next.getInt() == true && "Expected unlinked node");

    if (Last) {

      N.Next = Last->Next;

      Last->Next.setPointerAndInt(&N, false);

    }

    Last = &N;

  }

  void push_front(Node &N) {

    assert(N.Next.getPointer() == &N && "Expected unlinked node");

    assert(N.Next.getInt() == true && "Expected unlinked node");

    if (Last) {

      N.Next.setPointerAndInt(Last->Next.getPointer(), false);

      Last->Next.setPointerAndInt(&N, true);

    } else {

      Last = &N;

    }

  }

};

template <class T> class IntrusiveBackList : IntrusiveBackListBase {

public:

  using IntrusiveBackListBase::empty;

  void push_back(T &N) { IntrusiveBackListBase::push_back(N); }

  void push_front(T &N) { IntrusiveBackListBase::push_front(N); }

  T &back() { return *static_cast<T *>(Last); }

  const T &back() const { return *static_cast<T *>(Last); }

  T &front() {

    return *static_cast<T *>(Last ? Last->Next.getPointer() : nullptr);

  }

  const T &front() const {

    return *static_cast<T *>(Last ? Last->Next.getPointer() : nullptr);

  }

  void takeNodes(IntrusiveBackList<T> &Other) {

    if (Other.empty())

      return;

    T *FirstNode = static_cast<T *>(Other.Last->Next.getPointer());

    T *IterNode = FirstNode;

    do {

      // Keep a pointer to the node and increment the iterator.

      T *TmpNode = IterNode;

      IterNode = static_cast<T *>(IterNode->Next.getPointer());

      // Unlink the node and push it back to this list.

      TmpNode->Next.setPointerAndInt(TmpNode, true);

      push_back(*TmpNode);

    } while (IterNode != FirstNode);

    Other.Last = nullptr;

  }

  class const_iterator;

  class iterator

      : public iterator_facade_base<iterator, std::forward_iterator_tag, T> {

    friend class const_iterator;

    Node *N = nullptr;

  public:

    iterator() = default;

    explicit iterator(T *N) : N(N) {}

    iterator &operator++() {

      N = N->getNext();

      return *this;

    }

    explicit operator bool() const { return N; }

    T &operator*() const { return *static_cast<T *>(N); }

    bool operator==(const iterator &X) const { return N == X.N; }

  };

  class const_iterator

      : public iterator_facade_base<const_iterator, std::forward_iterator_tag,

                                    const T> {

    const Node *N = nullptr;

  public:

    const_iterator() = default;

    // Placate MSVC by explicitly scoping 'iterator'.

    const_iterator(typename IntrusiveBackList<T>::iterator X) : N(X.N) {}

    explicit const_iterator(const T *N) : N(N) {}

    const_iterator &operator++() {

      N = N->getNext();

      return *this;

    }

    explicit operator bool() const { return N; }

    const T &operator*() const { return *static_cast<const T *>(N); }

    bool operator==(const const_iterator &X) const { return N == X.N; }

  };

  iterator begin() {

    return Last ? iterator(static_cast<T *>(Last->Next.getPointer())) : end();

  }

  const_iterator begin() const {

    return const_cast<IntrusiveBackList *>(this)->begin();

  }

  iterator end() { return iterator(); }

  const_iterator end() const { return const_iterator(); }

  static iterator toIterator(T &N) { return iterator(&N); }

  static const_iterator toIterator(const T &N) { return const_iterator(&N); }

};

/// A list of DIE values.

///

/// This is a singly-linked list, but instead of reversing the order of

/// insertion, we keep a pointer to the back of the list so we can push in

/// order.

///

/// There are two main reasons to choose a linked list over a customized

/// vector-like data structure.

///

///  1. For teardown efficiency, we want DIEs to be BumpPtrAllocated.  Using a

///     linked list here makes this way easier to accomplish.

///  2. Carrying an extra pointer per \a DIEValue isn't expensive.  45% of DIEs

///     have 2 or fewer values, and 90% have 5 or fewer.  A vector would be

///     over-allocated by 50% on average anyway, the same cost as the

///     linked-list node.

class DIEValueList {

  struct Node : IntrusiveBackListNode {

    DIEValue V;

    explicit Node(DIEValue V) : V(V) {}

  };

  using ListTy = IntrusiveBackList<Node>;

  ListTy List;

public:

  class const_value_iterator;

  class value_iterator

      : public iterator_adaptor_base<value_iterator, ListTy::iterator,

                                     std::forward_iterator_tag, DIEValue> {

    friend class const_value_iterator;

    using iterator_adaptor =

        iterator_adaptor_base<value_iterator, ListTy::iterator,

                              std::forward_iterator_tag, DIEValue>;

  public:

    value_iterator() = default;

    explicit value_iterator(ListTy::iterator X) : iterator_adaptor(X) {}

    explicit operator bool() const { return bool(wrapped()); }

    DIEValue &operator*() const { return wrapped()->V; }

  };

  class const_value_iterator : public iterator_adaptor_base<

                                   const_value_iterator, ListTy::const_iterator,

                                   std::forward_iterator_tag, const DIEValue> {

    using iterator_adaptor =

        iterator_adaptor_base<const_value_iterator, ListTy::const_iterator,

                              std::forward_iterator_tag, const DIEValue>;

  public:

    const_value_iterator() = default;

    const_value_iterator(DIEValueList::value_iterator X)

        : iterator_adaptor(X.wrapped()) {}

    explicit const_value_iterator(ListTy::const_iterator X)

        : iterator_adaptor(X) {}

    explicit operator bool() const { return bool(wrapped()); }

    const DIEValue &operator*() const { return wrapped()->V; }

  };

  using value_range = iterator_range<value_iterator>;

  using const_value_range = iterator_range<const_value_iterator>;

  value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V) {

    List.push_back(*new (Alloc) Node(V));

    return value_iterator(ListTy::toIterator(List.back()));

  }

  template <class T>

  value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,

                    dwarf::Form Form, T &&Value) {

    return addValue(Alloc, DIEValue(Attribute, Form, std::forward<T>(Value)));

  }

  /// Take ownership of the nodes in \p Other, and append them to the back of

  /// the list.

  void takeValues(DIEValueList &Other) { List.takeNodes(Other.List); }

  value_range values() {

    return make_range(value_iterator(List.begin()), value_iterator(List.end()));

  }

  const_value_range values() const {

    return make_range(const_value_iterator(List.begin()),

                      const_value_iterator(List.end()));

  }

};

//===--------------------------------------------------------------------===//

/// A structured debug information entry.  Has an abbreviation which

/// describes its organization.

class DIE : IntrusiveBackListNode, public DIEValueList {

  friend class IntrusiveBackList<DIE>;

  friend class DIEUnit;

  /// Dwarf unit relative offset.

  unsigned Offset = 0;

  /// Size of instance + children.

  unsigned Size = 0;

  unsigned AbbrevNumber = ~0u;

  /// Dwarf tag code.

  dwarf::Tag Tag = (dwarf::Tag)0;

  /// Set to true to force a DIE to emit an abbreviation that says it has

  /// children even when it doesn't. This is used for unit testing purposes.

  bool ForceChildren = false;

  /// Children DIEs.

  IntrusiveBackList<DIE> Children;

  /// The owner is either the parent DIE for children of other DIEs, or a

  /// DIEUnit which contains this DIE as its unit DIE.

  PointerUnion<DIE *, DIEUnit *> Owner;

  explicit DIE(dwarf::Tag Tag) : Tag(Tag) {}

public:

  DIE() = delete;

  DIE(const DIE &RHS) = delete;

  DIE(DIE &&RHS) = delete;

  DIE &operator=(const DIE &RHS) = delete;

  DIE &operator=(const DIE &&RHS) = delete;

  static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {

    return new (Alloc) DIE(Tag);

  }

  // Accessors.

  unsigned getAbbrevNumber() const { return AbbrevNumber; }

  dwarf::Tag getTag() const { return Tag; }