1 //===--- lib/CodeGen/DIE.h - DWARF Info Entries -----------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Data structures for DWARF info entries.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
15 #define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
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"
32 //===--------------------------------------------------------------------===//
33 /// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
34 /// Dwarf abbreviation.
36 /// Attribute - Dwarf attribute code.
38 dwarf::Attribute Attribute;
40 /// Form - Dwarf form code.
45 DIEAbbrevData(dwarf::Attribute A, dwarf::Form F) : Attribute(A), Form(F) {}
48 dwarf::Attribute getAttribute() const { return Attribute; }
49 dwarf::Form getForm() const { return Form; }
51 /// Profile - Used to gather unique data for the abbreviation folding set.
53 void Profile(FoldingSetNodeID &ID) const;
56 //===--------------------------------------------------------------------===//
57 /// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
58 /// information object.
59 class DIEAbbrev : public FoldingSetNode {
60 /// Unique number for node.
64 /// Tag - Dwarf tag code.
68 /// Children - Whether or not this node has children.
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.
74 /// Data - Raw data bytes for abbreviation.
76 SmallVector<DIEAbbrevData, 12> Data;
79 DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C), Data() {}
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; }
89 /// AddAttribute - Adds another set of attribute information to the
91 void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {
92 Data.push_back(DIEAbbrevData(Attribute, Form));
95 /// Profile - Used to gather unique data for the abbreviation folding set.
97 void Profile(FoldingSetNodeID &ID) const;
99 /// Emit - Print the abbreviation using the specified asm printer.
101 void Emit(const AsmPrinter *AP) const;
104 void print(raw_ostream &O);
109 //===--------------------------------------------------------------------===//
110 /// DIEInteger - An integer value DIE.
116 explicit DIEInteger(uint64_t I) : Integer(I) {}
118 /// BestForm - Choose the best form for integer.
120 static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {
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;
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;
137 return dwarf::DW_FORM_data8;
140 uint64_t getValue() const { return Integer; }
141 void setValue(uint64_t Val) { Integer = Val; }
143 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
144 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
147 void print(raw_ostream &O) const;
151 //===--------------------------------------------------------------------===//
152 /// DIEExpr - An expression DIE.
158 explicit DIEExpr(const MCExpr *E) : Expr(E) {}
160 /// getValue - Get MCExpr.
162 const MCExpr *getValue() const { return Expr; }
164 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
165 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
168 void print(raw_ostream &O) const;
172 //===--------------------------------------------------------------------===//
173 /// DIELabel - A label DIE.
176 const MCSymbol *Label;
179 explicit DIELabel(const MCSymbol *L) : Label(L) {}
181 /// getValue - Get MCSymbol.
183 const MCSymbol *getValue() const { return Label; }
185 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
186 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
189 void print(raw_ostream &O) const;
193 //===--------------------------------------------------------------------===//
194 /// DIEDelta - A simple label difference DIE.
197 const MCSymbol *LabelHi;
198 const MCSymbol *LabelLo;
201 DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}
203 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
204 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
207 void print(raw_ostream &O) const;
211 //===--------------------------------------------------------------------===//
212 /// DIEString - A container for string values.
215 DwarfStringPoolEntryRef S;
218 DIEString(DwarfStringPoolEntryRef S) : S(S) {}
220 /// getString - Grab the string out of the object.
221 StringRef getString() const { return S.getString(); }
223 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
224 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
227 void print(raw_ostream &O) const;
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.)
242 explicit DIEEntry(DIE &E) : Entry(&E) {}
244 DIE &getEntry() const { return *Entry; }
246 /// Returns size of a ref_addr entry.
247 static unsigned getRefAddrSize(const AsmPrinter *AP);
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)
256 void print(raw_ostream &O) const;
260 //===--------------------------------------------------------------------===//
261 /// \brief A signature reference to a type unit.
262 class DIETypeSignature {
263 const DwarfTypeUnit *Unit;
265 DIETypeSignature() = delete;
268 explicit DIETypeSignature(const DwarfTypeUnit &Unit) : Unit(&Unit) {}
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);
277 void print(raw_ostream &O) const;
281 //===--------------------------------------------------------------------===//
282 /// DIELocList - Represents a pointer to a location list in the debug_loc
286 // Index into the .debug_loc vector.
290 DIELocList(size_t I) : Index(I) {}
292 /// getValue - Grab the current index out.
293 size_t getValue() const { return Index; }
295 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
296 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
299 void print(raw_ostream &O) const;
303 //===--------------------------------------------------------------------===//
304 /// DIEValue - A debug information entry value. Some of these roughly correlate
305 /// to DWARF attribute classes.
313 #define HANDLE_DIEVALUE(T) is##T,
314 #include "llvm/CodeGen/DIEValue.def"
318 /// Ty - Type of data stored in the value.
321 dwarf::Attribute Attribute = (dwarf::Attribute)0;
322 dwarf::Form Form = (dwarf::Form)0;
324 /// Storage for the value.
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");
335 /// Underlying stored value.
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);
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);
349 template <class T> void destruct() { get<T>()->~T(); }
351 /// Destroy the underlying value.
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.
360 #define HANDLE_DIEVALUE_SMALL(T) \
364 #define HANDLE_DIEVALUE_LARGE(T) \
366 destruct<const DIE##T *>();
368 #include "llvm/CodeGen/DIEValue.def"
372 /// Copy the underlying value.
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
377 void copyVal(const DIEValue &X) {
381 #define HANDLE_DIEVALUE_SMALL(T) \
383 construct<DIE##T>(*X.get<DIE##T>()); \
385 #define HANDLE_DIEVALUE_LARGE(T) \
387 construct<const DIE##T *>(*X.get<const DIE##T *>()); \
389 #include "llvm/CodeGen/DIEValue.def"
394 DIEValue() = default;
395 DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {
398 DIEValue &operator=(const DIEValue &X) {
401 Attribute = X.Attribute;
406 ~DIEValue() { destroyVal(); }
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); \
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); \
419 #include "llvm/CodeGen/DIEValue.def"
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; }
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>(); \
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 *>(); \
437 #include "llvm/CodeGen/DIEValue.def"
439 /// EmitValue - Emit value via the Dwarf writer.
441 void EmitValue(const AsmPrinter *AP) const;
443 /// SizeOf - Return the size of a value in bytes.
445 unsigned SizeOf(const AsmPrinter *AP) const;
448 void print(raw_ostream &O) const;
453 struct IntrusiveBackListNode {
454 PointerIntPair<IntrusiveBackListNode *, 1> Next;
455 IntrusiveBackListNode() : Next(this, true) {}
457 IntrusiveBackListNode *getNext() const {
458 return Next.getInt() ? nullptr : Next.getPointer();
462 struct IntrusiveBackListBase {
463 typedef IntrusiveBackListNode Node;
464 Node *Last = nullptr;
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");
473 Last->Next.setPointerAndInt(&N, false);
479 template <class T> class IntrusiveBackList : IntrusiveBackListBase {
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); }
486 class const_iterator;
488 : public iterator_facade_base<iterator, std::forward_iterator_tag, T> {
489 friend class const_iterator;
493 iterator() = default;
494 explicit iterator(T *N) : N(N) {}
496 iterator &operator++() {
501 explicit operator bool() const { return N; }
502 T &operator*() const { return *static_cast<T *>(N); }
504 bool operator==(const iterator &X) const { return N == X.N; }
505 bool operator!=(const iterator &X) const { return N != X.N; }
509 : public iterator_facade_base<const_iterator, std::forward_iterator_tag,
511 const Node *N = nullptr;
514 const_iterator() = default;
515 // Placate MSVC by explicitly scoping 'iterator'.
516 const_iterator(typename IntrusiveBackList<T>::iterator X) : N(X.N) {}
517 explicit const_iterator(const T *N) : N(N) {}
519 const_iterator &operator++() {
524 explicit operator bool() const { return N; }
525 const T &operator*() const { return *static_cast<const T *>(N); }
527 bool operator==(const const_iterator &X) const { return N == X.N; }
528 bool operator!=(const const_iterator &X) const { return N != X.N; }
532 return Last ? iterator(static_cast<T *>(Last->Next.getPointer())) : end();
534 const_iterator begin() const {
535 return const_cast<IntrusiveBackList *>(this)->begin();
537 iterator end() { return iterator(); }
538 const_iterator end() const { return const_iterator(); }
540 static iterator toIterator(T &N) { return iterator(&N); }
541 static const_iterator toIterator(const T &N) { return const_iterator(&N); }
544 /// A list of DIE values.
546 /// This is a singly-linked list, but instead of reversing the order of
547 /// insertion, we keep a pointer to the back of the list so we can push in
550 /// There are two main reasons to choose a linked list over a customized
551 /// vector-like data structure.
553 /// 1. For teardown efficiency, we want DIEs to be BumpPtrAllocated. Using a
554 /// linked list here makes this way easier to accomplish.
555 /// 2. Carrying an extra pointer per \a DIEValue isn't expensive. 45% of DIEs
556 /// have 2 or fewer values, and 90% have 5 or fewer. A vector would be
557 /// over-allocated by 50% on average anyway, the same cost as the
558 /// linked-list node.
560 struct Node : IntrusiveBackListNode {
562 explicit Node(DIEValue V) : V(V) {}
565 typedef IntrusiveBackList<Node> ListTy;
569 bool empty() const { return List.empty(); }
571 class const_iterator;
573 : public iterator_adaptor_base<iterator, ListTy::iterator,
574 std::forward_iterator_tag, DIEValue> {
575 friend class const_iterator;
576 typedef iterator_adaptor_base<iterator, ListTy::iterator,
577 std::forward_iterator_tag,
578 DIEValue> iterator_adaptor;
581 iterator() = default;
582 explicit iterator(ListTy::iterator X) : iterator_adaptor(X) {}
584 explicit operator bool() const { return bool(wrapped()); }
585 DIEValue &operator*() const { return wrapped()->V; }
589 : public iterator_adaptor_base<const_iterator, ListTy::const_iterator,
590 std::forward_iterator_tag,
592 typedef iterator_adaptor_base<const_iterator, ListTy::const_iterator,
593 std::forward_iterator_tag,
594 const DIEValue> iterator_adaptor;
597 const_iterator() = default;
598 const_iterator(DIEValueList::iterator X) : iterator_adaptor(X.wrapped()) {}
599 explicit const_iterator(ListTy::const_iterator X) : iterator_adaptor(X) {}
601 explicit operator bool() const { return bool(wrapped()); }
602 const DIEValue &operator*() const { return wrapped()->V; }
605 iterator insert(BumpPtrAllocator &Alloc, DIEValue V) {
606 List.push_back(*new (Alloc) Node(V));
607 return iterator(ListTy::toIterator(List.back()));
609 template <class... Ts>
610 iterator emplace(BumpPtrAllocator &Alloc, Ts &&... Args) {
611 return insert(Alloc, DIEValue(std::forward<Ts>(Args)...));
614 iterator begin() { return iterator(List.begin()); }
615 iterator end() { return iterator(List.end()); }
616 const_iterator begin() const { return const_iterator(List.begin()); }
617 const_iterator end() const { return const_iterator(List.end()); }
620 //===--------------------------------------------------------------------===//
621 /// DIE - A structured debug information entry. Has an abbreviation which
622 /// describes its organization.
623 class DIE : IntrusiveBackListNode {
624 friend class IntrusiveBackList<DIE>;
627 /// Offset - Offset in debug info section.
631 /// Size - Size of instance + children.
635 unsigned AbbrevNumber = ~0u;
637 /// Tag - Dwarf tag code.
639 dwarf::Tag Tag = (dwarf::Tag)0;
642 IntrusiveBackList<DIE> Children;
644 DIE *Parent = nullptr;
646 /// Attribute values.
651 DIE() : Offset(0), Size(0) {}
654 explicit DIE(dwarf::Tag Tag) : Offset(0), Size(0), Tag(Tag) {}
657 static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {
658 return new (Alloc) DIE(Tag);
662 unsigned getAbbrevNumber() const { return AbbrevNumber; }
663 dwarf::Tag getTag() const { return Tag; }
664 unsigned getOffset() const { return Offset; }
665 unsigned getSize() const { return Size; }
666 bool hasChildren() const { return !Children.empty(); }
668 typedef IntrusiveBackList<DIE>::iterator child_iterator;
669 typedef IntrusiveBackList<DIE>::const_iterator const_child_iterator;
670 typedef iterator_range<child_iterator> child_range;
671 typedef iterator_range<const_child_iterator> const_child_range;
673 child_range children() {
674 return llvm::make_range(Children.begin(), Children.end());
676 const_child_range children() const {
677 return llvm::make_range(Children.begin(), Children.end());
680 typedef DIEValueList::iterator value_iterator;
681 typedef iterator_range<value_iterator> value_range;
683 value_range values() {
684 return llvm::make_range(Values.begin(), Values.end());
687 typedef DIEValueList::const_iterator const_value_iterator;
688 typedef iterator_range<const_value_iterator> const_value_range;
690 const_value_range values() const {
691 return llvm::make_range(Values.begin(), Values.end());
694 DIE *getParent() const { return Parent; }
696 /// Generate the abbreviation for this DIE.
698 /// Calculate the abbreviation for this, which should be uniqued and
699 /// eventually used to call \a setAbbrevNumber().
700 DIEAbbrev generateAbbrev() const;
702 /// Set the abbreviation number for this DIE.
703 void setAbbrevNumber(unsigned I) { AbbrevNumber = I; }
705 /// Climb up the parent chain to get the compile or type unit DIE this DIE
707 const DIE *getUnit() const;
708 /// Similar to getUnit, returns null when DIE is not added to an
710 const DIE *getUnitOrNull() const;
711 void setOffset(unsigned O) { Offset = O; }
712 void setSize(unsigned S) { Size = S; }
714 /// addValue - Add a value and attributes to a DIE.
716 value_iterator addValue(BumpPtrAllocator &Alloc, DIEValue Value) {
717 return Values.insert(Alloc, Value);
720 value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
721 dwarf::Form Form, T &&Value) {
722 return Values.emplace(Alloc, Attribute, Form, std::forward<T>(Value));
725 /// Add a child to the DIE.
726 DIE &addChild(DIE *Child) {
727 assert(!Child->getParent() && "Child should be orphaned");
728 Child->Parent = this;
729 Children.push_back(*Child);
730 return Children.back();
733 /// Find a value in the DIE with the attribute given.
735 /// Returns a default-constructed DIEValue (where \a DIEValue::getType()
736 /// gives \a DIEValue::isNone) if no such attribute exists.
737 DIEValue findAttribute(dwarf::Attribute Attribute) const;
740 void print(raw_ostream &O, unsigned IndentCount = 0) const;
745 //===--------------------------------------------------------------------===//
746 /// DIELoc - Represents an expression location.
748 class DIELoc : public DIE {
749 mutable unsigned Size; // Size in bytes excluding size header.
752 DIELoc() : Size(0) {}
754 /// ComputeSize - Calculate the size of the location expression.
756 unsigned ComputeSize(const AsmPrinter *AP) const;
758 /// BestForm - Choose the best form for data.
760 dwarf::Form BestForm(unsigned DwarfVersion) const {
761 if (DwarfVersion > 3)
762 return dwarf::DW_FORM_exprloc;
763 // Pre-DWARF4 location expressions were blocks and not exprloc.
764 if ((unsigned char)Size == Size)
765 return dwarf::DW_FORM_block1;
766 if ((unsigned short)Size == Size)
767 return dwarf::DW_FORM_block2;
768 if ((unsigned int)Size == Size)
769 return dwarf::DW_FORM_block4;
770 return dwarf::DW_FORM_block;
773 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
774 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
777 void print(raw_ostream &O) const;
781 //===--------------------------------------------------------------------===//
782 /// DIEBlock - Represents a block of values.
784 class DIEBlock : public DIE {
785 mutable unsigned Size; // Size in bytes excluding size header.
788 DIEBlock() : Size(0) {}
790 /// ComputeSize - Calculate the size of the location expression.
792 unsigned ComputeSize(const AsmPrinter *AP) const;
794 /// BestForm - Choose the best form for data.
796 dwarf::Form BestForm() const {
797 if ((unsigned char)Size == Size)
798 return dwarf::DW_FORM_block1;
799 if ((unsigned short)Size == Size)
800 return dwarf::DW_FORM_block2;
801 if ((unsigned int)Size == Size)
802 return dwarf::DW_FORM_block4;
803 return dwarf::DW_FORM_block;
806 void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
807 unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
810 void print(raw_ostream &O) const;
814 } // end llvm namespace