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/STLExtras.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
  22 #include "llvm/Support/Dwarf.h"
  23 #include <vector>
  24
  25 namespace llvm {
  26 class AsmPrinter;
  27 class MCExpr;
  28 class MCSymbol;
  29 class raw_ostream;
  30 class DwarfTypeUnit;
  31
  32 //===--------------------------------------------------------------------===//
  33 /// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
  34 /// Dwarf abbreviation.
  35 class DIEAbbrevData {
  36   /// Attribute - Dwarf attribute code.
  37   ///
  38   dwarf::Attribute Attribute;
  39
  40   /// Form - Dwarf form code.
  41   ///
  42   dwarf::Form Form;
  43
  44 public:
  45   DIEAbbrevData(dwarf::Attribute A, dwarf::Form F) : Attribute(A), Form(F) {}
  46
  47   // Accessors.
  48   dwarf::Attribute getAttribute() const { return Attribute; }
  49   dwarf::Form getForm() const { return Form; }
  50
  51   /// Profile - Used to gather unique data for the abbreviation folding set.
  52   ///
  53   void Profile(FoldingSetNodeID &ID) const;
  54 };
  55
  56 //===--------------------------------------------------------------------===//
  57 /// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
  58 /// information object.
  59 class DIEAbbrev : public FoldingSetNode {
  60   /// Unique number for node.
  61   ///
  62   unsigned Number;
  63
  64   /// Tag - Dwarf tag code.
  65   ///
  66   dwarf::Tag Tag;
  67
  68   /// Children - Whether or not this node has children.
  69   ///
  70   // This cheats a bit in all of the uses since the values in the standard
  71   // are 0 and 1 for no children and children respectively.
  72   bool Children;
  73
  74   /// Data - Raw data bytes for abbreviation.
  75   ///
  76   SmallVector<DIEAbbrevData, 12> Data;
  77
  78 public:
  79   DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C), Data() {}
  80
  81   // Accessors.
  82   dwarf::Tag getTag() const { return Tag; }
  83   unsigned getNumber() const { return Number; }
  84   bool hasChildren() const { return Children; }
  85   const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }
  86   void setChildrenFlag(bool hasChild) { Children = hasChild; }
  87   void setNumber(unsigned N) { Number = N; }
  88
  89   /// AddAttribute - Adds another set of attribute information to the
  90   /// abbreviation.
  91   void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {
  92     Data.push_back(DIEAbbrevData(Attribute, Form));
  93   }
  94
  95   /// Profile - Used to gather unique data for the abbreviation folding set.
  96   ///
  97   void Profile(FoldingSetNodeID &ID) const;
  98
  99   /// Emit - Print the abbreviation using the specified asm printer.
 100   ///
 101   void Emit(const AsmPrinter *AP) const;
 102
 103 #ifndef NDEBUG
 104   void print(raw_ostream &O);
 105   void dump();
 106 #endif
 107 };
 108
 109 //===--------------------------------------------------------------------===//
 110 /// DIEInteger - An integer value DIE.
 111 ///
 112 class DIEInteger {
 113   uint64_t Integer;
 114
 115 public:
 116   explicit DIEInteger(uint64_t I) : Integer(I) {}
 117
 118   /// BestForm - Choose the best form for integer.
 119   ///
 120   static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {
 121     if (IsSigned) {
 122       const int64_t SignedInt = Int;
 123       if ((char)Int == SignedInt)
 124         return dwarf::DW_FORM_data1;
 125       if ((short)Int == SignedInt)
 126         return dwarf::DW_FORM_data2;
 127       if ((int)Int == SignedInt)
 128         return dwarf::DW_FORM_data4;
 129     } else {
 130       if ((unsigned char)Int == Int)
 131         return dwarf::DW_FORM_data1;
 132       if ((unsigned short)Int == Int)
 133         return dwarf::DW_FORM_data2;
 134       if ((unsigned int)Int == Int)
 135         return dwarf::DW_FORM_data4;
 136     }
 137     return dwarf::DW_FORM_data8;
 138   }
 139
 140   uint64_t getValue() const { return Integer; }
 141   void setValue(uint64_t Val) { Integer = Val; }
 142
 143   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 144   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 145
 146 #ifndef NDEBUG
 147   void print(raw_ostream &O) const;
 148 #endif
 149 };
 150
 151 //===--------------------------------------------------------------------===//
 152 /// DIEExpr - An expression DIE.
 153 //
 154 class DIEExpr {
 155   const MCExpr *Expr;
 156
 157 public:
 158   explicit DIEExpr(const MCExpr *E) : Expr(E) {}
 159
 160   /// getValue - Get MCExpr.
 161   ///
 162   const MCExpr *getValue() const { return Expr; }
 163
 164   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 165   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 166
 167 #ifndef NDEBUG
 168   void print(raw_ostream &O) const;
 169 #endif
 170 };
 171
 172 //===--------------------------------------------------------------------===//
 173 /// DIELabel - A label DIE.
 174 //
 175 class DIELabel {
 176   const MCSymbol *Label;
 177
 178 public:
 179   explicit DIELabel(const MCSymbol *L) : Label(L) {}
 180
 181   /// getValue - Get MCSymbol.
 182   ///
 183   const MCSymbol *getValue() const { return Label; }
 184
 185   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 186   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 187
 188 #ifndef NDEBUG
 189   void print(raw_ostream &O) const;
 190 #endif
 191 };
 192
 193 //===--------------------------------------------------------------------===//
 194 /// DIEDelta - A simple label difference DIE.
 195 ///
 196 class DIEDelta {
 197   const MCSymbol *LabelHi;
 198   const MCSymbol *LabelLo;
 199
 200 public:
 201   DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
 202
 203   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 204   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 205
 206 #ifndef NDEBUG
 207   void print(raw_ostream &O) const;
 208 #endif
 209 };
 210
 211 //===--------------------------------------------------------------------===//
 212 /// DIEString - A container for string values.
 213 ///
 214 class DIEString {
 215   DwarfStringPoolEntryRef S;
 216
 217 public:
 218   DIEString(DwarfStringPoolEntryRef S) : S(S) {}
 219
 220   /// getString - Grab the string out of the object.
 221   StringRef getString() const { return S.getString(); }
 222
 223   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 224   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 225
 226 #ifndef NDEBUG
 227   void print(raw_ostream &O) const;
 228 #endif
 229 };
 230
 231 //===--------------------------------------------------------------------===//
 232 /// DIEEntry - A pointer to another debug information entry.  An instance of
 233 /// this class can also be used as a proxy for a debug information entry not
 234 /// yet defined (ie. types.)
 235 class DIE;
 236 class DIEEntry {
 237   DIE *Entry;
 238
 239   DIEEntry() = delete;
 240
 241 public:
 242   explicit DIEEntry(DIE &E) : Entry(&E) {}
 243
 244   DIE &getEntry() const { return *Entry; }
 245
 246   /// Returns size of a ref_addr entry.
 247   static unsigned getRefAddrSize(const AsmPrinter *AP);
 248
 249   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 250   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 251     return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP)
 252                                            : sizeof(int32_t);
 253   }
 254
 255 #ifndef NDEBUG
 256   void print(raw_ostream &O) const;
 257 #endif
 258 };
 259
 260 //===--------------------------------------------------------------------===//
 261 /// \brief A signature reference to a type unit.
 262 class DIETypeSignature {
 263   const DwarfTypeUnit *Unit;
 264
 265   DIETypeSignature() = delete;
 266
 267 public:
 268   explicit DIETypeSignature(const DwarfTypeUnit &Unit) : Unit(&Unit) {}
 269
 270   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 271   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
 272     assert(Form == dwarf::DW_FORM_ref_sig8);
 273     return 8;
 274   }
 275
 276 #ifndef NDEBUG
 277   void print(raw_ostream &O) const;
 278 #endif
 279 };
 280
 281 //===--------------------------------------------------------------------===//
 282 /// DIELocList - Represents a pointer to a location list in the debug_loc
 283 /// section.
 284 //
 285 class DIELocList {
 286   // Index into the .debug_loc vector.
 287   size_t Index;
 288
 289 public:
 290   DIELocList(size_t I) : Index(I) {}
 291
 292   /// getValue - Grab the current index out.
 293   size_t getValue() const { return Index; }
 294
 295   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 296   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 297
 298 #ifndef NDEBUG
 299   void print(raw_ostream &O) const;
 300 #endif
 301 };
 302
 303 //===--------------------------------------------------------------------===//
 304 /// DIEValue - A debug information entry value. Some of these roughly correlate
 305 /// to DWARF attribute classes.
 306 ///
 307 class DIEBlock;
 308 class DIELoc;
 309 class DIEValue {
 310 public:
 311   enum Type {
 312     isNone,
 313 #define HANDLE_DIEVALUE(T) is##T,
 314 #include "llvm/CodeGen/DIEValue.def"
 315   };
 316
 317 private:
 318   /// Ty - Type of data stored in the value.
 319   ///
 320   Type Ty = isNone;
 321   dwarf::Attribute Attribute = (dwarf::Attribute)0;
 322   dwarf::Form Form = (dwarf::Form)0;
 323
 324   /// Storage for the value.
 325   ///
 326   /// All values that aren't standard layout (or are larger than 8 bytes)
 327   /// should be stored by reference instead of by value.
 328   typedef AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel,
 329                                 DIEDelta *, DIEEntry, DIETypeSignature,
 330                                 DIEBlock *, DIELoc *, DIELocList> ValTy;
 331   static_assert(sizeof(ValTy) <= sizeof(uint64_t) ||
 332                     sizeof(ValTy) <= sizeof(void *),
 333                 "Expected all large types to be stored via pointer");
 334
 335   /// Underlying stored value.
 336   ValTy Val;
 337
 338   template <class T> void construct(T V) {
 339     static_assert(std::is_standard_layout<T>::value ||
 340                       std::is_pointer<T>::value,
 341                   "Expected standard layout or pointer");
 342     new (reinterpret_cast<void *>(Val.buffer)) T(V);
 343   }
 344
 345   template <class T> T *get() { return reinterpret_cast<T *>(Val.buffer); }
 346   template <class T> const T *get() const {
 347     return reinterpret_cast<const T *>(Val.buffer);
 348   }
 349   template <class T> void destruct() { get<T>()->~T(); }
 350
 351   /// Destroy the underlying value.
 352   ///
 353   /// This should get optimized down to a no-op.  We could skip it if we could
 354   /// add a static assert on \a std::is_trivially_copyable(), but we currently
 355   /// support versions of GCC that don't understand that.
 356   void destroyVal() {
 357     switch (Ty) {
 358     case isNone:
 359       return;
 360 #define HANDLE_DIEVALUE_SMALL(T)                                               \
 361   case is##T:                                                                  \
 362     destruct<DIE##T>();
 363     return;
 364 #define HANDLE_DIEVALUE_LARGE(T)                                               \
 365   case is##T:                                                                  \
 366     destruct<const DIE##T *>();
 367     return;
 368 #include "llvm/CodeGen/DIEValue.def"
 369     }
 370   }
 371
 372   /// Copy the underlying value.
 373   ///
 374   /// This should get optimized down to a simple copy.  We need to actually
 375   /// construct the value, rather than calling memcpy, to satisfy strict
 376   /// aliasing rules.
 377   void copyVal(const DIEValue &X) {
 378     switch (Ty) {
 379     case isNone:
 380       return;
 381 #define HANDLE_DIEVALUE_SMALL(T)                                               \
 382   case is##T:                                                                  \
 383     construct<DIE##T>(*X.get<DIE##T>());                                       \
 384     return;
 385 #define HANDLE_DIEVALUE_LARGE(T)                                               \
 386   case is##T:                                                                  \
 387     construct<const DIE##T *>(*X.get<const DIE##T *>());                       \
 388     return;
 389 #include "llvm/CodeGen/DIEValue.def"
 390     }
 391   }
 392
 393 public:
 394   DIEValue() = default;
 395   DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {
 396     copyVal(X);
 397   }
 398   DIEValue &operator=(const DIEValue &X) {
 399     destroyVal();
 400     Ty = X.Ty;
 401     Attribute = X.Attribute;
 402     Form = X.Form;
 403     copyVal(X);
 404     return *this;
 405   }
 406   ~DIEValue() { destroyVal(); }
 407
 408 #define HANDLE_DIEVALUE_SMALL(T)                                               \
 409   DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T &V)      \
 410       : Ty(is##T), Attribute(Attribute), Form(Form) {                          \
 411     construct<DIE##T>(V);                                                      \
 412   }
 413 #define HANDLE_DIEVALUE_LARGE(T)                                               \
 414   DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T *V)      \
 415       : Ty(is##T), Attribute(Attribute), Form(Form) {                          \
 416     assert(V && "Expected valid value");                                       \
 417     construct<const DIE##T *>(V);                                              \
 418   }
 419 #include "llvm/CodeGen/DIEValue.def"
 420
 421   // Accessors
 422   Type getType() const { return Ty; }
 423   dwarf::Attribute getAttribute() const { return Attribute; }
 424   dwarf::Form getForm() const { return Form; }
 425   explicit operator bool() const { return Ty; }
 426
 427 #define HANDLE_DIEVALUE_SMALL(T)                                               \
 428   const DIE##T &getDIE##T() const {                                            \
 429     assert(getType() == is##T && "Expected " #T);                              \
 430     return *get<DIE##T>();                                                     \
 431   }
 432 #define HANDLE_DIEVALUE_LARGE(T)                                               \
 433   const DIE##T &getDIE##T() const {                                            \
 434     assert(getType() == is##T && "Expected " #T);                              \
 435     return **get<const DIE##T *>();                                            \
 436   }
 437 #include "llvm/CodeGen/DIEValue.def"
 438
 439   /// EmitValue - Emit value via the Dwarf writer.
 440   ///
 441   void EmitValue(const AsmPrinter *AP) const;
 442
 443   /// SizeOf - Return the size of a value in bytes.
 444   ///
 445   unsigned SizeOf(const AsmPrinter *AP) const;
 446
 447 #ifndef NDEBUG
 448   void print(raw_ostream &O) const;
 449   void dump() const;
 450 #endif
 451 };
 452
 453 struct IntrusiveBackListNode {
 454   PointerIntPair<IntrusiveBackListNode *, 1> Next;
 455   IntrusiveBackListNode() : Next(this, true) {}
 456
 457   IntrusiveBackListNode *getNext() const {
 458     return Next.getInt() ? nullptr : Next.getPointer();
 459   }
 460 };
 461
 462 struct IntrusiveBackListBase {
 463   typedef IntrusiveBackListNode Node;
 464   Node *Last = nullptr;
 465
 466   bool empty() const { return !Last; }
 467   void push_back(Node &N) {
 468     assert(N.Next.getPointer() == &N && "Expected unlinked node");
 469     assert(N.Next.getInt() == true && "Expected unlinked node");
 470
 471     if (Last) {
 472       N.Next = Last->Next;
 473       Last->Next.setPointerAndInt(&N, false);
 474     }
 475     Last = &N;
 476   }
 477 };
 478
 479 template <class T> class IntrusiveBackList : IntrusiveBackListBase {
 480 public:
 481   using IntrusiveBackListBase::empty;
 482   void push_back(T &N) { IntrusiveBackListBase::push_back(N); }
 483   T &back() { return *static_cast<T *>(Last); }
 484   const T &back() const { return *static_cast<T *>(Last); }
 485
 486   class const_iterator;
 487   class iterator
 488       : public iterator_facade_base<iterator, std::forward_iterator_tag, T> {
 489     friend class const_iterator;
 490     Node *N = nullptr;
 491
 492   public:
 493     iterator() = default;
 494     explicit iterator(T *N) : N(N) {}
 495
 496     iterator &operator++() {
 497       N = N->getNext();
 498       return *this;
 499     }
 500
 501     explicit operator bool() const { return N; }
 502     T &operator*() const { return *static_cast<T *>(N); }
 503
 504     bool operator==(const iterator &X) const { return N == X.N; }
 505     bool operator!=(const iterator &X) const { return N != X.N; }
 506   };
 507
 508   class const_iterator
 509       : public iterator_facade_base<const_iterator, std::forward_iterator_tag,
 510                                     const T> {
 511     const Node *N = nullptr;
 512
 513   public:
 514     const_iterator() = default;
 515     const_iterator(iterator X) : N(X.N) {}
 516     explicit const_iterator(const T *N) : N(N) {}
 517
 518     const_iterator &operator++() {
 519       N = N->getNext();
 520       return *this;
 521     }
 522
 523     explicit operator bool() const { return N; }
 524     const T &operator*() const { return *static_cast<const T *>(N); }
 525
 526     bool operator==(const const_iterator &X) const { return N == X.N; }
 527     bool operator!=(const const_iterator &X) const { return N != X.N; }
 528   };
 529
 530   iterator begin() {
 531     return Last ? iterator(static_cast<T *>(Last->Next.getPointer())) : end();
 532   }
 533   const_iterator begin() const {
 534     return const_cast<IntrusiveBackList *>(this)->begin();
 535   }
 536   iterator end() { return iterator(); }
 537   const_iterator end() const { return const_iterator(); }
 538
 539   static iterator toIterator(T &N) { return iterator(&N); }
 540   static const_iterator toIterator(const T &N) { return const_iterator(&N); }
 541 };
 542
 543 /// A list of DIE values.
 544 ///
 545 /// This is a singly-linked list, but instead of reversing the order of
 546 /// insertion, we keep a pointer to the back of the list so we can push in
 547 /// order.
 548 class DIEValueList {
 549   struct Node : IntrusiveBackListNode {
 550     DIEValue V;
 551     explicit Node(DIEValue V) : V(V) {}
 552   };
 553
 554   typedef IntrusiveBackList<Node> ListTy;
 555   ListTy List;
 556
 557 public:
 558   bool empty() const { return List.empty(); }
 559
 560   class const_iterator;
 561   class iterator
 562       : public iterator_adaptor_base<iterator, ListTy::iterator,
 563                                      std::forward_iterator_tag, DIEValue> {
 564     friend class const_iterator;
 565     typedef iterator_adaptor_base<iterator, ListTy::iterator,
 566                                   std::forward_iterator_tag,
 567                                   DIEValue> iterator_adaptor;
 568
 569   public:
 570     iterator() = default;
 571     explicit iterator(ListTy::iterator X) : iterator_adaptor(X) {}
 572
 573     explicit operator bool() const { return bool(wrapped()); }
 574     DIEValue &operator*() const { return wrapped()->V; }
 575   };
 576
 577   class const_iterator
 578       : public iterator_adaptor_base<const_iterator, ListTy::const_iterator,
 579                                      std::forward_iterator_tag,
 580                                      const DIEValue> {
 581     typedef iterator_adaptor_base<const_iterator, ListTy::const_iterator,
 582                                   std::forward_iterator_tag,
 583                                   const DIEValue> iterator_adaptor;
 584
 585   public:
 586     const_iterator() = default;
 587     const_iterator(DIEValueList::iterator X) : iterator_adaptor(X.wrapped()) {}
 588     explicit const_iterator(ListTy::const_iterator X) : iterator_adaptor(X) {}
 589
 590     explicit operator bool() const { return bool(wrapped()); }
 591     const DIEValue &operator*() const { return wrapped()->V; }
 592   };
 593
 594   iterator insert(BumpPtrAllocator &Alloc, DIEValue V) {
 595     List.push_back(*new (Alloc) Node(V));
 596     return iterator(ListTy::toIterator(List.back()));
 597   }
 598   template <class... Ts>
 599   iterator emplace(BumpPtrAllocator &Alloc, Ts &&... Args) {
 600     return insert(Alloc, DIEValue(std::forward<Ts>(Args)...));
 601   }
 602
 603   iterator begin() { return iterator(List.begin()); }
 604   iterator end() { return iterator(List.end()); }
 605   const_iterator begin() const { return const_iterator(List.begin()); }
 606   const_iterator end() const { return const_iterator(List.end()); }
 607 };
 608
 609 //===--------------------------------------------------------------------===//
 610 /// DIE - A structured debug information entry.  Has an abbreviation which
 611 /// describes its organization.
 612 class DIE : IntrusiveBackListNode {
 613   friend class IntrusiveBackList<DIE>;
 614
 615 protected:
 616   /// Offset - Offset in debug info section.
 617   ///
 618   unsigned Offset;
 619
 620   /// Size - Size of instance + children.
 621   ///
 622   unsigned Size;
 623
 624   unsigned AbbrevNumber = ~0u;
 625
 626   /// Tag - Dwarf tag code.
 627   ///
 628   dwarf::Tag Tag = (dwarf::Tag)0;
 629
 630   /// Children DIEs.
 631   IntrusiveBackList<DIE> Children;
 632
 633   DIE *Parent = nullptr;
 634
 635   /// Attribute values.
 636   ///
 637   DIEValueList Values;
 638
 639 protected:
 640   DIE() : Offset(0), Size(0) {}
 641
 642 private:
 643   explicit DIE(dwarf::Tag Tag) : Offset(0), Size(0), Tag(Tag) {}
 644
 645 public:
 646   static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {
 647     return new (Alloc) DIE(Tag);
 648   }
 649
 650   // Accessors.
 651   unsigned getAbbrevNumber() const { return AbbrevNumber; }
 652   dwarf::Tag getTag() const { return Tag; }
 653   unsigned getOffset() const { return Offset; }
 654   unsigned getSize() const { return Size; }
 655   bool hasChildren() const { return !Children.empty(); }
 656
 657   typedef IntrusiveBackList<DIE>::iterator child_iterator;
 658   typedef IntrusiveBackList<DIE>::const_iterator const_child_iterator;
 659   typedef iterator_range<child_iterator> child_range;
 660   typedef iterator_range<const_child_iterator> const_child_range;
 661
 662   child_range children() {
 663     return llvm::make_range(Children.begin(), Children.end());
 664   }
 665   const_child_range children() const {
 666     return llvm::make_range(Children.begin(), Children.end());
 667   }
 668
 669   typedef DIEValueList::iterator value_iterator;
 670   typedef iterator_range<value_iterator> value_range;
 671
 672   value_range values() {
 673     return llvm::make_range(Values.begin(), Values.end());
 674   }
 675
 676   typedef DIEValueList::const_iterator const_value_iterator;
 677   typedef iterator_range<const_value_iterator> const_value_range;
 678
 679   const_value_range values() const {
 680     return llvm::make_range(Values.begin(), Values.end());
 681   }
 682
 683   DIE *getParent() const { return Parent; }
 684
 685   /// Generate the abbreviation for this DIE.
 686   ///
 687   /// Calculate the abbreviation for this, which should be uniqued and
 688   /// eventually used to call \a setAbbrevNumber().
 689   DIEAbbrev generateAbbrev() const;
 690
 691   /// Set the abbreviation number for this DIE.
 692   void setAbbrevNumber(unsigned I) { AbbrevNumber = I; }
 693
 694   /// Climb up the parent chain to get the compile or type unit DIE this DIE
 695   /// belongs to.
 696   const DIE *getUnit() const;
 697   /// Similar to getUnit, returns null when DIE is not added to an
 698   /// owner yet.
 699   const DIE *getUnitOrNull() const;
 700   void setOffset(unsigned O) { Offset = O; }
 701   void setSize(unsigned S) { Size = S; }
 702
 703   /// addValue - Add a value and attributes to a DIE.
 704   ///
 705   value_iterator addValue(BumpPtrAllocator &Alloc, DIEValue Value) {
 706     return Values.insert(Alloc, Value);
 707   }
 708   template <class T>
 709   value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
 710                           dwarf::Form Form, T &&Value) {
 711     return Values.emplace(Alloc, Attribute, Form, std::forward<T>(Value));
 712   }
 713
 714   /// Add a child to the DIE.
 715   DIE &addChild(DIE *Child) {
 716     assert(!Child->getParent() && "Child should be orphaned");
 717     Child->Parent = this;
 718     Children.push_back(*Child);
 719     return Children.back();
 720   }
 721
 722   /// Find a value in the DIE with the attribute given.
 723   ///
 724   /// Returns a default-constructed DIEValue (where \a DIEValue::getType()
 725   /// gives \a DIEValue::isNone) if no such attribute exists.
 726   DIEValue findAttribute(dwarf::Attribute Attribute) const;
 727
 728 #ifndef NDEBUG
 729   void print(raw_ostream &O, unsigned IndentCount = 0) const;
 730   void dump();
 731 #endif
 732 };
 733
 734 //===--------------------------------------------------------------------===//
 735 /// DIELoc - Represents an expression location.
 736 //
 737 class DIELoc : public DIE {
 738   mutable unsigned Size; // Size in bytes excluding size header.
 739
 740 public:
 741   DIELoc() : Size(0) {}
 742
 743   /// ComputeSize - Calculate the size of the location expression.
 744   ///
 745   unsigned ComputeSize(const AsmPrinter *AP) const;
 746
 747   /// BestForm - Choose the best form for data.
 748   ///
 749   dwarf::Form BestForm(unsigned DwarfVersion) const {
 750     if (DwarfVersion > 3)
 751       return dwarf::DW_FORM_exprloc;
 752     // Pre-DWARF4 location expressions were blocks and not exprloc.
 753     if ((unsigned char)Size == Size)
 754       return dwarf::DW_FORM_block1;
 755     if ((unsigned short)Size == Size)
 756       return dwarf::DW_FORM_block2;
 757     if ((unsigned int)Size == Size)
 758       return dwarf::DW_FORM_block4;
 759     return dwarf::DW_FORM_block;
 760   }
 761
 762   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 763   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 764
 765 #ifndef NDEBUG
 766   void print(raw_ostream &O) const;
 767 #endif
 768 };
 769
 770 //===--------------------------------------------------------------------===//
 771 /// DIEBlock - Represents a block of values.
 772 //
 773 class DIEBlock : public DIE {
 774   mutable unsigned Size; // Size in bytes excluding size header.
 775
 776 public:
 777   DIEBlock() : Size(0) {}
 778
 779   /// ComputeSize - Calculate the size of the location expression.
 780   ///
 781   unsigned ComputeSize(const AsmPrinter *AP) const;
 782
 783   /// BestForm - Choose the best form for data.
 784   ///
 785   dwarf::Form BestForm() const {
 786     if ((unsigned char)Size == Size)
 787       return dwarf::DW_FORM_block1;
 788     if ((unsigned short)Size == Size)
 789       return dwarf::DW_FORM_block2;
 790     if ((unsigned int)Size == Size)
 791       return dwarf::DW_FORM_block4;
 792     return dwarf::DW_FORM_block;
 793   }
 794
 795   void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
 796   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
 797
 798 #ifndef NDEBUG
 799   void print(raw_ostream &O) const;
 800 #endif
 801 };
 802
 803 } // end llvm namespace
 804
 805 #endif