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