contrib/llvm/include/llvm/CodeGen/DIE.h

   1 //===- lib/CodeGen/DIE.h - DWARF Info Entries -------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Data structures for DWARF info entries.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
  15 #define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
  16
  17 #include "llvm/ADT/FoldingSet.h"
  18 #include "llvm/ADT/PointerIntPair.h"
  19 #include "llvm/ADT/PointerUnion.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/ADT/iterator.h"
  23 #include "llvm/ADT/iterator_range.h"
  24 #include "llvm/BinaryFormat/Dwarf.h"
  25 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
  26 #include "llvm/Support/AlignOf.h"
  27 #include "llvm/Support/Allocator.h"
  28 #include <cassert>
  29 #include <cstddef>
  30 #include <cstdint>
  31 #include <iterator>
  32 #include <new>
  33 #include <type_traits>
  34 #include <utility>
  35 #include <vector>
  36
  37 namespace llvm {
  38
  39 class AsmPrinter;
  40 class DIE;
  41 class DIEUnit;
  42 class MCExpr;
  43 class MCSection;
  44 class MCSymbol;
  45 class raw_ostream;
  46
  47 //===--------------------------------------------------------------------===//
  48 /// Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation.
  49 class DIEAbbrevData {
  50   /// Dwarf attribute code.
  51   dwarf::Attribute Attribute;
  52
  53   /// Dwarf form code.
  54   dwarf::Form Form;
  55
  56   /// Dwarf attribute value for DW_FORM_implicit_const
  57   int64_t Value = 0;
  58
  59 public:
  60   DIEAbbrevData(dwarf::Attribute A, dwarf::Form F)
  61       : Attribute(A), Form(F) {}
  62   DIEAbbrevData(dwarf::Attribute A, int64_t V)
  63       : Attribute(A), Form(dwarf::DW_FORM_implicit_const), Value(V) {}
  64
  65   /// Accessors.
  66   /// @{
  67   dwarf::Attribute getAttribute() const { return Attribute; }
  68   dwarf::Form getForm() const { return Form; }
  69   int64_t getValue() const { return Value; }
  70   /// @}
  71
  72   /// Used to gather unique data for the abbreviation folding set.
  73   void Profile(FoldingSetNodeID &ID) const;
  74 };
  75
  76 //===--------------------------------------------------------------------===//
  77 /// Dwarf abbreviation, describes the organization of a debug information
  78 /// object.
  79 class DIEAbbrev : public FoldingSetNode {
  80   /// Unique number for node.
  81   unsigned Number;
  82
  83   /// Dwarf tag code.
  84   dwarf::Tag Tag;
  85
  86   /// Whether or not this node has children.
  87   ///
  88   /// This cheats a bit in all of the uses since the values in the standard
  89   /// are 0 and 1 for no children and children respectively.
  90   bool Children;
  91
  92   /// Raw data bytes for abbreviation.
  93   SmallVector<DIEAbbrevData, 12> Data;
  94
  95 public:
  96   DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {}
  97
  98   /// Accessors.
  99   /// @{
 100   dwarf::Tag getTag() const { return Tag; }
 101   unsigned getNumber() const { return Number; }
 102   bool hasChildren() const { return Children; }
 103   const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }
 104   void setChildrenFlag(bool hasChild) { Children = hasChild; }
 105   void setNumber(unsigned N) { Number = N; }
 106   /// @}
 107
 108   /// Adds another set of attribute information to the abbreviation.
 109   void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {
 110     Data.push_back(DIEAbbrevData(Attribute, Form));
 111   }
 112
 113   /// Adds attribute with DW_FORM_implicit_const value
 114   void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) {
 115     Data.push_back(DIEAbbrevData(Attribute, Value));
 116   }
 117
 118   /// Used to gather unique data for the abbreviation folding set.
 119   void Profile(FoldingSetNodeID &ID) const;
 120
 121   /// Print the abbreviation using the specified asm printer.
 122   void Emit(const AsmPrinter *AP) const;
 123
 124   void print(raw_ostream &O) const;
 125   void dump() const;
 126 };
 127
 128 //===--------------------------------------------------------------------===//
 129 /// Helps unique DIEAbbrev objects and assigns abbreviation numbers.
 130 ///
 131 /// This class will unique the DIE abbreviations for a llvm::DIE object and
 132 /// assign a unique abbreviation number to each unique DIEAbbrev object it
 133 /// finds. The resulting collection of DIEAbbrev objects can then be emitted
 134 /// into the .debug_abbrev section.
 135 class DIEAbbrevSet {
 136   /// The bump allocator to use when creating DIEAbbrev objects in the uniqued
 137   /// storage container.
 138   BumpPtrAllocator &Alloc;
 139   /// FoldingSet that uniques the abbreviations.
 140   FoldingSet<DIEAbbrev> AbbreviationsSet;
 141   /// A list of all the unique abbreviations in use.
 142   std::vector<DIEAbbrev *> Abbreviations;
 143
 144 public:
 145   DIEAbbrevSet(BumpPtrAllocator &A) : Alloc(A) {}
 146   ~DIEAbbrevSet();
 147
 148   /// Generate the abbreviation declaration for a DIE and return a pointer to
 149   /// the generated abbreviation.
 150   ///
 151   /// \param Die the debug info entry to generate the abbreviation for.
 152   /// \returns A reference to the uniqued abbreviation declaration that is
 153   /// owned by this class.
 154   DIEAbbrev &uniqueAbbreviation(DIE &Die);
 155
 156   /// Print all abbreviations using the specified asm printer.
 157   void Emit(const AsmPrinter *AP, MCSection *Section) const;
 158 };
 159
 160 //===--------------------------------------------------------------------===//
 161 /// An integer value DIE.
 162 ///
 163 class DIEInteger {
 164   uint64_t Integer;
 165
 166 public:
 167   explicit DIEInteger(uint64_t I) : Integer(I) {}
 168
 169   /// Choose the best form for integer.
 170   static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {
 171     if (IsSigned) {
 172       const int64_t SignedInt = Int;
 173       if ((char)Int == SignedInt)
 174         return dwarf::DW_FORM_data1;
 175       if ((short)Int == SignedInt)
 176         return dwarf::DW_FORM_data2;
 177       if ((int)Int == SignedInt)
 178         return dwarf::DW_FORM_data4;
 179     } else {
 180       if ((unsigned char)Int == Int)
 181         return dwarf::DW_FORM_data1;
 182       if ((unsigned short)Int == Int)
 183         return dwarf::DW_FORM_data2;
 184       if ((unsigned int)Int == Int)
 185         return dwarf::DW_FORM_data4;
 186     }
 187     return dwarf::DW_FORM_data8;
 188   }
 189
 190   uint64_t getValue() const { return Integer; }
 191   void setValue(uint64_t Val) { Integer = Val; }
 192
 193   void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
 194   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 195
 196   void print(raw_ostream &O) const;
 197 };
 198
 199 //===--------------------------------------------------------------------===//
 200 /// An expression DIE.
 201 class DIEExpr {
 202   const MCExpr *Expr;
 203
 204 public:
 205   explicit DIEExpr(const MCExpr *E) : Expr(E) {}
 206
 207   /// Get MCExpr.
 208   const MCExpr *getValue() const { return Expr; }
 209
 210   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 211   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 212
 213   void print(raw_ostream &O) const;
 214 };
 215
 216 //===--------------------------------------------------------------------===//
 217 /// A label DIE.
 218 class DIELabel {
 219   const MCSymbol *Label;
 220
 221 public:
 222   explicit DIELabel(const MCSymbol *L) : Label(L) {}
 223
 224   /// Get MCSymbol.
 225   const MCSymbol *getValue() const { return Label; }
 226
 227   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 228   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 229
 230   void print(raw_ostream &O) const;
 231 };
 232
 233 //===--------------------------------------------------------------------===//
 234 /// A simple label difference DIE.
 235 ///
 236 class DIEDelta {
 237   const MCSymbol *LabelHi;
 238   const MCSymbol *LabelLo;
 239
 240 public:
 241   DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
 242
 243   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 244   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 245
 246   void print(raw_ostream &O) const;
 247 };
 248
 249 //===--------------------------------------------------------------------===//
 250 /// A container for string pool string values.
 251 ///
 252 /// This class is used with the DW_FORM_strp and DW_FORM_GNU_str_index forms.
 253 class DIEString {
 254   DwarfStringPoolEntryRef S;
 255
 256 public:
 257   DIEString(DwarfStringPoolEntryRef S) : S(S) {}
 258
 259   /// Grab the string out of the object.
 260   StringRef getString() const { return S.getString(); }
 261
 262   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 263   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 264
 265   void print(raw_ostream &O) const;
 266 };
 267
 268 //===--------------------------------------------------------------------===//
 269 /// A container for inline string values.
 270 ///
 271 /// This class is used with the DW_FORM_string form.
 272 class DIEInlineString {
 273   StringRef S;
 274
 275 public:
 276   template <typename Allocator>
 277   explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {}
 278
 279   ~DIEInlineString() = default;
 280
 281   /// Grab the string out of the object.
 282   StringRef getString() const { return S; }
 283
 284   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 285   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 286
 287   void print(raw_ostream &O) const;
 288 };
 289
 290 //===--------------------------------------------------------------------===//
 291 /// A pointer to another debug information entry.  An instance of this class can
 292 /// also be used as a proxy for a debug information entry not yet defined
 293 /// (ie. types.)
 294 class DIEEntry {
 295   DIE *Entry;
 296
 297 public:
 298   DIEEntry() = delete;
 299   explicit DIEEntry(DIE &E) : Entry(&E) {}
 300
 301   DIE &getEntry() const { return *Entry; }
 302
 303   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 304   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 305
 306   void print(raw_ostream &O) const;
 307 };
 308
 309 //===--------------------------------------------------------------------===//
 310 /// Represents a pointer to a location list in the debug_loc
 311 /// section.
 312 class DIELocList {
 313   /// Index into the .debug_loc vector.
 314   size_t Index;
 315
 316 public:
 317   DIELocList(size_t I) : Index(I) {}
 318
 319   /// Grab the current index out.
 320   size_t getValue() const { return Index; }
 321
 322   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 323   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 324
 325   void print(raw_ostream &O) const;
 326 };
 327
 328 //===--------------------------------------------------------------------===//
 329 /// A debug information entry value. Some of these roughly correlate
 330 /// to DWARF attribute classes.
 331 class DIEBlock;
 332 class DIELoc;
 333 class DIEValue {
 334 public:
 335   enum Type {
 336     isNone,
 337 #define HANDLE_DIEVALUE(T) is##T,
 338 #include "llvm/CodeGen/DIEValue.def"
 339   };
 340
 341 private:
 342   /// Type of data stored in the value.
 343   Type Ty = isNone;
 344   dwarf::Attribute Attribute = (dwarf::Attribute)0;
 345   dwarf::Form Form = (dwarf::Form)0;
 346
 347   /// Storage for the value.
 348   ///
 349   /// All values that aren't standard layout (or are larger than 8 bytes)
 350   /// should be stored by reference instead of by value.
 351   using ValTy = AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel,
 352                                       DIEDelta *, DIEEntry, DIEBlock *,
 353                                       DIELoc *, DIELocList>;
 354
 355   static_assert(sizeof(ValTy) <= sizeof(uint64_t) ||
 356                     sizeof(ValTy) <= sizeof(void *),
 357                 "Expected all large types to be stored via pointer");
 358
 359   /// Underlying stored value.
 360   ValTy Val;
 361
 362   template <class T> void construct(T V) {
 363     static_assert(std::is_standard_layout<T>::value ||
 364                       std::is_pointer<T>::value,
 365                   "Expected standard layout or pointer");
 366     new (reinterpret_cast<void *>(Val.buffer)) T(V);
 367   }
 368
 369   template <class T> T *get() { return reinterpret_cast<T *>(Val.buffer); }
 370   template <class T> const T *get() const {
 371     return reinterpret_cast<const T *>(Val.buffer);
 372   }
 373   template <class T> void destruct() { get<T>()->~T(); }
 374
 375   /// Destroy the underlying value.
 376   ///
 377   /// This should get optimized down to a no-op.  We could skip it if we could
 378   /// add a static assert on \a std::is_trivially_copyable(), but we currently
 379   /// support versions of GCC that don't understand that.
 380   void destroyVal() {
 381     switch (Ty) {
 382     case isNone:
 383       return;
 384 #define HANDLE_DIEVALUE_SMALL(T)                                               \
 385   case is##T:                                                                  \
 386     destruct<DIE##T>();                                                        \
 387     return;
 388 #define HANDLE_DIEVALUE_LARGE(T)                                               \
 389   case is##T:                                                                  \
 390     destruct<const DIE##T *>();                                                \
 391     return;
 392 #include "llvm/CodeGen/DIEValue.def"
 393     }
 394   }
 395
 396   /// Copy the underlying value.
 397   ///
 398   /// This should get optimized down to a simple copy.  We need to actually
 399   /// construct the value, rather than calling memcpy, to satisfy strict
 400   /// aliasing rules.
 401   void copyVal(const DIEValue &X) {
 402     switch (Ty) {
 403     case isNone:
 404       return;
 405 #define HANDLE_DIEVALUE_SMALL(T)                                               \
 406   case is##T:                                                                  \
 407     construct<DIE##T>(*X.get<DIE##T>());                                       \
 408     return;
 409 #define HANDLE_DIEVALUE_LARGE(T)                                               \
 410   case is##T:                                                                  \
 411     construct<const DIE##T *>(*X.get<const DIE##T *>());                       \
 412     return;
 413 #include "llvm/CodeGen/DIEValue.def"
 414     }
 415   }
 416
 417 public:
 418   DIEValue() = default;
 419
 420   DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {
 421     copyVal(X);
 422   }
 423
 424   DIEValue &operator=(const DIEValue &X) {
 425     destroyVal();
 426     Ty = X.Ty;
 427     Attribute = X.Attribute;
 428     Form = X.Form;
 429     copyVal(X);
 430     return *this;
 431   }
 432
 433   ~DIEValue() { destroyVal(); }
 434
 435 #define HANDLE_DIEVALUE_SMALL(T)                                               \
 436   DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T &V)      \
 437       : Ty(is##T), Attribute(Attribute), Form(Form) {                          \
 438     construct<DIE##T>(V);                                                      \
 439   }
 440 #define HANDLE_DIEVALUE_LARGE(T)                                               \
 441   DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T *V)      \
 442       : Ty(is##T), Attribute(Attribute), Form(Form) {                          \
 443     assert(V && "Expected valid value");                                       \
 444     construct<const DIE##T *>(V);                                              \
 445   }
 446 #include "llvm/CodeGen/DIEValue.def"
 447
 448   /// Accessors.
 449   /// @{
 450   Type getType() const { return Ty; }
 451   dwarf::Attribute getAttribute() const { return Attribute; }
 452   dwarf::Form getForm() const { return Form; }
 453   explicit operator bool() const { return Ty; }
 454   /// @}
 455
 456 #define HANDLE_DIEVALUE_SMALL(T)                                               \
 457   const DIE##T &getDIE##T() const {                                            \
 458     assert(getType() == is##T && "Expected " #T);                              \
 459     return *get<DIE##T>();                                                     \
 460   }
 461 #define HANDLE_DIEVALUE_LARGE(T)                                               \
 462   const DIE##T &getDIE##T() const {                                            \
 463     assert(getType() == is##T && "Expected " #T);                              \
 464     return **get<const DIE##T *>();                                            \
 465   }
 466 #include "llvm/CodeGen/DIEValue.def"
 467
 468   /// Emit value via the Dwarf writer.
 469   void EmitValue(const AsmPrinter *AP) const;
 470
 471   /// Return the size of a value in bytes.
 472   unsigned SizeOf(const AsmPrinter *AP) const;
 473
 474   void print(raw_ostream &O) const;
 475   void dump() const;
 476 };
 477
 478 struct IntrusiveBackListNode {
 479   PointerIntPair<IntrusiveBackListNode *, 1> Next;
 480
 481   IntrusiveBackListNode() : Next(this, true) {}
 482
 483   IntrusiveBackListNode *getNext() const {
 484     return Next.getInt() ? nullptr : Next.getPointer();
 485   }
 486 };
 487
 488 struct IntrusiveBackListBase {
 489   using Node = IntrusiveBackListNode;
 490
 491   Node *Last = nullptr;
 492
 493   bool empty() const { return !Last; }
 494
 495   void push_back(Node &N) {
 496     assert(N.Next.getPointer() == &N && "Expected unlinked node");
 497     assert(N.Next.getInt() == true && "Expected unlinked node");
 498
 499     if (Last) {
 500       N.Next = Last->Next;
 501       Last->Next.setPointerAndInt(&N, false);
 502     }
 503     Last = &N;
 504   }
 505 };
 506
 507 template <class T> class IntrusiveBackList : IntrusiveBackListBase {
 508 public:
 509   using IntrusiveBackListBase::empty;
 510
 511   void push_back(T &N) { IntrusiveBackListBase::push_back(N); }
 512   T &back() { return *static_cast<T *>(Last); }
 513   const T &back() const { return *static_cast<T *>(Last); }
 514
 515   class const_iterator;
 516   class iterator
 517       : public iterator_facade_base<iterator, std::forward_iterator_tag, T> {
 518     friend class const_iterator;
 519
 520     Node *N = nullptr;
 521
 522   public:
 523     iterator() = default;
 524     explicit iterator(T *N) : N(N) {}
 525
 526     iterator &operator++() {
 527       N = N->getNext();
 528       return *this;
 529     }
 530
 531     explicit operator bool() const { return N; }
 532     T &operator*() const { return *static_cast<T *>(N); }
 533
 534     bool operator==(const iterator &X) const { return N == X.N; }
 535     bool operator!=(const iterator &X) const { return N != X.N; }
 536   };
 537
 538   class const_iterator
 539       : public iterator_facade_base<const_iterator, std::forward_iterator_tag,
 540                                     const T> {
 541     const Node *N = nullptr;
 542
 543   public:
 544     const_iterator() = default;
 545     // Placate MSVC by explicitly scoping 'iterator'.
 546     const_iterator(typename IntrusiveBackList<T>::iterator X) : N(X.N) {}
 547     explicit const_iterator(const T *N) : N(N) {}
 548
 549     const_iterator &operator++() {
 550       N = N->getNext();
 551       return *this;
 552     }
 553
 554     explicit operator bool() const { return N; }
 555     const T &operator*() const { return *static_cast<const T *>(N); }
 556
 557     bool operator==(const const_iterator &X) const { return N == X.N; }
 558     bool operator!=(const const_iterator &X) const { return N != X.N; }
 559   };
 560
 561   iterator begin() {
 562     return Last ? iterator(static_cast<T *>(Last->Next.getPointer())) : end();
 563   }
 564   const_iterator begin() const {
 565     return const_cast<IntrusiveBackList *>(this)->begin();
 566   }
 567   iterator end() { return iterator(); }
 568   const_iterator end() const { return const_iterator(); }
 569
 570   static iterator toIterator(T &N) { return iterator(&N); }
 571   static const_iterator toIterator(const T &N) { return const_iterator(&N); }
 572 };
 573
 574 /// A list of DIE values.
 575 ///
 576 /// This is a singly-linked list, but instead of reversing the order of
 577 /// insertion, we keep a pointer to the back of the list so we can push in
 578 /// order.
 579 ///
 580 /// There are two main reasons to choose a linked list over a customized
 581 /// vector-like data structure.
 582 ///
 583 ///  1. For teardown efficiency, we want DIEs to be BumpPtrAllocated.  Using a
 584 ///     linked list here makes this way easier to accomplish.
 585 ///  2. Carrying an extra pointer per \a DIEValue isn't expensive.  45% of DIEs
 586 ///     have 2 or fewer values, and 90% have 5 or fewer.  A vector would be
 587 ///     over-allocated by 50% on average anyway, the same cost as the
 588 ///     linked-list node.
 589 class DIEValueList {
 590   struct Node : IntrusiveBackListNode {
 591     DIEValue V;
 592
 593     explicit Node(DIEValue V) : V(V) {}
 594   };
 595
 596   using ListTy = IntrusiveBackList<Node>;
 597
 598   ListTy List;
 599
 600 public:
 601   class const_value_iterator;
 602   class value_iterator
 603       : public iterator_adaptor_base<value_iterator, ListTy::iterator,
 604                                      std::forward_iterator_tag, DIEValue> {
 605     friend class const_value_iterator;
 606
 607     using iterator_adaptor =
 608         iterator_adaptor_base<value_iterator, ListTy::iterator,
 609                               std::forward_iterator_tag, DIEValue>;
 610
 611   public:
 612     value_iterator() = default;
 613     explicit value_iterator(ListTy::iterator X) : iterator_adaptor(X) {}
 614
 615     explicit operator bool() const { return bool(wrapped()); }
 616     DIEValue &operator*() const { return wrapped()->V; }
 617   };
 618
 619   class const_value_iterator : public iterator_adaptor_base<
 620                                    const_value_iterator, ListTy::const_iterator,
 621                                    std::forward_iterator_tag, const DIEValue> {
 622     using iterator_adaptor =
 623         iterator_adaptor_base<const_value_iterator, ListTy::const_iterator,
 624                               std::forward_iterator_tag, const DIEValue>;
 625
 626   public:
 627     const_value_iterator() = default;
 628     const_value_iterator(DIEValueList::value_iterator X)
 629         : iterator_adaptor(X.wrapped()) {}
 630     explicit const_value_iterator(ListTy::const_iterator X)
 631         : iterator_adaptor(X) {}
 632
 633     explicit operator bool() const { return bool(wrapped()); }
 634     const DIEValue &operator*() const { return wrapped()->V; }
 635   };
 636
 637   using value_range = iterator_range<value_iterator>;
 638   using const_value_range = iterator_range<const_value_iterator>;
 639
 640   value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V) {
 641     List.push_back(*new (Alloc) Node(V));
 642     return value_iterator(ListTy::toIterator(List.back()));
 643   }
 644   template <class T>
 645   value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
 646                     dwarf::Form Form, T &&Value) {
 647     return addValue(Alloc, DIEValue(Attribute, Form, std::forward<T>(Value)));
 648   }
 649
 650   value_range values() {
 651     return make_range(value_iterator(List.begin()), value_iterator(List.end()));
 652   }
 653   const_value_range values() const {
 654     return make_range(const_value_iterator(List.begin()),
 655                       const_value_iterator(List.end()));
 656   }
 657 };
 658
 659 //===--------------------------------------------------------------------===//
 660 /// A structured debug information entry.  Has an abbreviation which
 661 /// describes its organization.
 662 class DIE : IntrusiveBackListNode, public DIEValueList {
 663   friend class IntrusiveBackList<DIE>;
 664   friend class DIEUnit;
 665
 666   /// Dwarf unit relative offset.
 667   unsigned Offset = 0;
 668   /// Size of instance + children.
 669   unsigned Size = 0;
 670   unsigned AbbrevNumber = ~0u;
 671   /// Dwarf tag code.
 672   dwarf::Tag Tag = (dwarf::Tag)0;
 673   /// Set to true to force a DIE to emit an abbreviation that says it has
 674   /// children even when it doesn't. This is used for unit testing purposes.
 675   bool ForceChildren = false;
 676   /// Children DIEs.
 677   IntrusiveBackList<DIE> Children;
 678
 679   /// The owner is either the parent DIE for children of other DIEs, or a
 680   /// DIEUnit which contains this DIE as its unit DIE.
 681   PointerUnion<DIE *, DIEUnit *> Owner;
 682
 683   explicit DIE(dwarf::Tag Tag) : Tag(Tag) {}
 684
 685 public:
 686   DIE() = delete;
 687   DIE(const DIE &RHS) = delete;
 688   DIE(DIE &&RHS) = delete;
 689   DIE &operator=(const DIE &RHS) = delete;
 690   DIE &operator=(const DIE &&RHS) = delete;
 691
 692   static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {
 693     return new (Alloc) DIE(Tag);
 694   }
 695
 696   // Accessors.
 697   unsigned getAbbrevNumber() const { return AbbrevNumber; }
 698   dwarf::Tag getTag() const { return Tag; }
 699   /// Get the compile/type unit relative offset of this DIE.
 700   unsigned getOffset() const { return Offset; }
 701   unsigned getSize() const { return Size; }
 702   bool hasChildren() const { return ForceChildren || !Children.empty(); }
 703   void setForceChildren(bool B) { ForceChildren = B; }
 704
 705   using child_iterator = IntrusiveBackList<DIE>::iterator;
 706   using const_child_iterator = IntrusiveBackList<DIE>::const_iterator;
 707   using child_range = iterator_range<child_iterator>;
 708   using const_child_range = iterator_range<const_child_iterator>;
 709
 710   child_range children() {
 711     return make_range(Children.begin(), Children.end());
 712   }
 713   const_child_range children() const {
 714     return make_range(Children.begin(), Children.end());
 715   }
 716
 717   DIE *getParent() const;
 718
 719   /// Generate the abbreviation for this DIE.
 720   ///
 721   /// Calculate the abbreviation for this, which should be uniqued and
 722   /// eventually used to call \a setAbbrevNumber().
 723   DIEAbbrev generateAbbrev() const;
 724
 725   /// Set the abbreviation number for this DIE.
 726   void setAbbrevNumber(unsigned I) { AbbrevNumber = I; }
 727
 728   /// Get the absolute offset within the .debug_info or .debug_types section
 729   /// for this DIE.
 730   unsigned getDebugSectionOffset() const;
 731
 732   /// Compute the offset of this DIE and all its children.
 733   ///
 734   /// This function gets called just before we are going to generate the debug
 735   /// information and gives each DIE a chance to figure out its CU relative DIE
 736   /// offset, unique its abbreviation and fill in the abbreviation code, and
 737   /// return the unit offset that points to where the next DIE will be emitted
 738   /// within the debug unit section. After this function has been called for all
 739   /// DIE objects, the DWARF can be generated since all DIEs will be able to
 740   /// properly refer to other DIE objects since all DIEs have calculated their
 741   /// offsets.
 742   ///
 743   /// \param AP AsmPrinter to use when calculating sizes.
 744   /// \param AbbrevSet the abbreviation used to unique DIE abbreviations.
 745   /// \param CUOffset the compile/type unit relative offset in bytes.
 746   /// \returns the offset for the DIE that follows this DIE within the
 747   /// current compile/type unit.
 748   unsigned computeOffsetsAndAbbrevs(const AsmPrinter *AP,
 749                                     DIEAbbrevSet &AbbrevSet, unsigned CUOffset);
 750
 751   /// Climb up the parent chain to get the compile unit or type unit DIE that
 752   /// this DIE belongs to.
 753   ///
 754   /// \returns the compile or type unit DIE that owns this DIE, or NULL if
 755   /// this DIE hasn't been added to a unit DIE.
 756   const DIE *getUnitDie() const;
 757
 758   /// Climb up the parent chain to get the compile unit or type unit that this
 759   /// DIE belongs to.
 760   ///
 761   /// \returns the DIEUnit that represents the compile or type unit that owns
 762   /// this DIE, or NULL if this DIE hasn't been added to a unit DIE.
 763   const DIEUnit *getUnit() const;
 764
 765   void setOffset(unsigned O) { Offset = O; }
 766   void setSize(unsigned S) { Size = S; }
 767
 768   /// Add a child to the DIE.
 769   DIE &addChild(DIE *Child) {
 770     assert(!Child->getParent() && "Child should be orphaned");
 771     Child->Owner = this;
 772     Children.push_back(*Child);
 773     return Children.back();
 774   }
 775
 776   /// Find a value in the DIE with the attribute given.
 777   ///
 778   /// Returns a default-constructed DIEValue (where \a DIEValue::getType()
 779   /// gives \a DIEValue::isNone) if no such attribute exists.
 780   DIEValue findAttribute(dwarf::Attribute Attribute) const;
 781
 782   void print(raw_ostream &O, unsigned IndentCount = 0) const;
 783   void dump() const;
 784 };
 785
 786 //===--------------------------------------------------------------------===//
 787 /// Represents a compile or type unit.
 788 class DIEUnit {
 789   /// The compile unit or type unit DIE. This variable must be an instance of
 790   /// DIE so that we can calculate the DIEUnit from any DIE by traversing the
 791   /// parent backchain and getting the Unit DIE, and then casting itself to a
 792   /// DIEUnit. This allows us to be able to find the DIEUnit for any DIE without
 793   /// having to store a pointer to the DIEUnit in each DIE instance.
 794   DIE Die;
 795   /// The section this unit will be emitted in. This may or may not be set to
 796   /// a valid section depending on the client that is emitting DWARF.
 797   MCSection *Section;
 798   uint64_t Offset; /// .debug_info or .debug_types absolute section offset.
 799   uint32_t Length; /// The length in bytes of all of the DIEs in this unit.
 800   const uint16_t Version; /// The Dwarf version number for this unit.
 801   const uint8_t AddrSize; /// The size in bytes of an address for this unit.
 802 protected:
 803   ~DIEUnit() = default;
 804
 805 public:
 806   DIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag);
 807   DIEUnit(const DIEUnit &RHS) = delete;
 808   DIEUnit(DIEUnit &&RHS) = delete;
 809   void operator=(const DIEUnit &RHS) = delete;
 810   void operator=(const DIEUnit &&RHS) = delete;
 811   /// Set the section that this DIEUnit will be emitted into.
 812   ///
 813   /// This function is used by some clients to set the section. Not all clients
 814   /// that emit DWARF use this section variable.
 815   void setSection(MCSection *Section) {
 816     assert(!this->Section);
 817     this->Section = Section;
 818   }
 819
 820   virtual const MCSymbol *getCrossSectionRelativeBaseAddress() const {
 821     return nullptr;
 822   }
 823
 824   /// Return the section that this DIEUnit will be emitted into.
 825   ///
 826   /// \returns Section pointer which can be NULL.
 827   MCSection *getSection() const { return Section; }
 828   void setDebugSectionOffset(unsigned O) { Offset = O; }
 829   unsigned getDebugSectionOffset() const { return Offset; }
 830   void setLength(uint64_t L) { Length = L; }
 831   uint64_t getLength() const { return Length; }
 832   uint16_t getDwarfVersion() const { return Version; }
 833   uint16_t getAddressSize() const { return AddrSize; }
 834   DIE &getUnitDie() { return Die; }
 835   const DIE &getUnitDie() const { return Die; }
 836 };
 837
 838 struct BasicDIEUnit final : DIEUnit {
 839   BasicDIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag)
 840       : DIEUnit(Version, AddrSize, UnitTag) {}
 841 };
 842
 843 //===--------------------------------------------------------------------===//
 844 /// DIELoc - Represents an expression location.
 845 //
 846 class DIELoc : public DIEValueList {
 847   mutable unsigned Size = 0; // Size in bytes excluding size header.
 848
 849 public:
 850   DIELoc() = default;
 851
 852   /// ComputeSize - Calculate the size of the location expression.
 853   ///
 854   unsigned ComputeSize(const AsmPrinter *AP) const;
 855
 856   /// BestForm - Choose the best form for data.
 857   ///
 858   dwarf::Form BestForm(unsigned DwarfVersion) const {
 859     if (DwarfVersion > 3)
 860       return dwarf::DW_FORM_exprloc;
 861     // Pre-DWARF4 location expressions were blocks and not exprloc.
 862     if ((unsigned char)Size == Size)
 863       return dwarf::DW_FORM_block1;
 864     if ((unsigned short)Size == Size)
 865       return dwarf::DW_FORM_block2;
 866     if ((unsigned int)Size == Size)
 867       return dwarf::DW_FORM_block4;
 868     return dwarf::DW_FORM_block;
 869   }
 870
 871   void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
 872   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 873
 874   void print(raw_ostream &O) const;
 875 };
 876
 877 //===--------------------------------------------------------------------===//
 878 /// DIEBlock - Represents a block of values.
 879 //
 880 class DIEBlock : public DIEValueList {
 881   mutable unsigned Size = 0; // Size in bytes excluding size header.
 882
 883 public:
 884   DIEBlock() = default;
 885
 886   /// ComputeSize - Calculate the size of the location expression.
 887   ///
 888   unsigned ComputeSize(const AsmPrinter *AP) const;
 889
 890   /// BestForm - Choose the best form for data.
 891   ///
 892   dwarf::Form BestForm() const {
 893     if ((unsigned char)Size == Size)
 894       return dwarf::DW_FORM_block1;
 895     if ((unsigned short)Size == Size)
 896       return dwarf::DW_FORM_block2;
 897     if ((unsigned int)Size == Size)
 898       return dwarf::DW_FORM_block4;
 899     return dwarf::DW_FORM_block;
 900   }
 901
 902   void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
 903   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 904
 905   void print(raw_ostream &O) const;
 906 };
 907
 908 } // end namespace llvm
 909
 910 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H