Line data Source code
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 1594446 : : Attribute(A), Form(F) {}
62 : DIEAbbrevData(dwarf::Attribute A, int64_t V)
63 5 : : Attribute(A), Form(dwarf::DW_FORM_implicit_const), Value(V) {}
64 :
65 : /// Accessors.
66 : /// @{
67 0 : dwarf::Attribute getAttribute() const { return Attribute; }
68 0 : dwarf::Form getForm() const { return Form; }
69 0 : 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 475911 : 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 464203 : DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {}
97 :
98 : /// Accessors.
99 : /// @{
100 0 : dwarf::Tag getTag() const { return Tag; }
101 0 : unsigned getNumber() const { return Number; }
102 0 : bool hasChildren() const { return Children; }
103 : const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }
104 461 : void setChildrenFlag(bool hasChild) { Children = hasChild; }
105 15877 : 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 1594446 : 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 5 : 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 54031 : 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 7115 : 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 0 : if ((char)Int == SignedInt)
174 : return dwarf::DW_FORM_data1;
175 0 : if ((short)Int == SignedInt)
176 : return dwarf::DW_FORM_data2;
177 0 : if ((int)Int == SignedInt)
178 : return dwarf::DW_FORM_data4;
179 : } else {
180 539881 : if ((unsigned char)Int == Int)
181 : return dwarf::DW_FORM_data1;
182 151175 : if ((unsigned short)Int == Int)
183 : return dwarf::DW_FORM_data2;
184 172 : if ((unsigned int)Int == Int)
185 : return dwarf::DW_FORM_data4;
186 : }
187 : return dwarf::DW_FORM_data8;
188 : }
189 :
190 0 : 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 296714 : 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 89340 : 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 474 : explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {}
278 :
279 : ~DIEInlineString() = default;
280 :
281 : /// Grab the string out of the object.
282 0 : 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 421364 : explicit DIEEntry(DIE &E) : Entry(&E) {}
300 :
301 0 : 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 0 : 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 3213162 : 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 3005028 : return reinterpret_cast<const T *>(Val.buffer);
372 : }
373 0 : 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 0 : 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 3213162 : void copyVal(const DIEValue &X) {
402 3213162 : 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 685 : DIEValue() = default;
419 :
420 3211757 : DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {
421 3211757 : copyVal(X);
422 : }
423 :
424 : DIEValue &operator=(const DIEValue &X) {
425 : destroyVal();
426 1406 : Ty = X.Ty;
427 1406 : Attribute = X.Attribute;
428 1406 : Form = X.Form;
429 1392 : 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 0 : Type getType() const { return Ty; }
451 0 : dwarf::Attribute getAttribute() const { return Attribute; }
452 0 : dwarf::Form getForm() const { return Form; }
453 0 : 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 11432692 : return Next.getInt() ? nullptr : Next.getPointer();
485 : }
486 : };
487 :
488 940784 : struct IntrusiveBackListBase {
489 : using Node = IntrusiveBackListNode;
490 :
491 : Node *Last = nullptr;
492 :
493 0 : bool empty() const { return !Last; }
494 :
495 0 : 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 1605865 : if (Last) {
500 1437693 : N.Next = Last->Next;
501 : Last->Next.setPointerAndInt(&N, false);
502 : }
503 461810 : Last = &N;
504 0 : }
505 : };
506 :
507 : template <class T> class IntrusiveBackList : IntrusiveBackListBase {
508 : public:
509 : using IntrusiveBackListBase::empty;
510 :
511 460914 : void push_back(T &N) { IntrusiveBackListBase::push_back(N); }
512 0 : 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 1388 : iterator() = default;
524 0 : 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 0 : T &operator*() const { return *static_cast<T *>(N); }
533 :
534 0 : bool operator==(const iterator &X) const { return N == X.N; }
535 0 : 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 0 : const T &operator*() const { return *static_cast<const T *>(N); }
556 :
557 0 : bool operator==(const const_iterator &X) const { return N == X.N; }
558 0 : bool operator!=(const const_iterator &X) const { return N != X.N; }
559 : };
560 :
561 0 : iterator begin() {
562 1717085 : return Last ? iterator(static_cast<T *>(Last->Next.getPointer())) : end();
563 : }
564 0 : const_iterator begin() const {
565 0 : return const_cast<IntrusiveBackList *>(this)->begin();
566 : }
567 0 : iterator end() { return iterator(); }
568 0 : const_iterator end() const { return const_iterator(); }
569 :
570 : static iterator toIterator(T &N) { return iterator(&N); }
571 1103919 : static const_iterator toIterator(const T &N) { return const_iterator(&N); }
572 : };
573 0 :
574 0 : /// 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 3191782 : explicit Node(DIEValue V) : V(V) {}
594 : };
595 :
596 : using ListTy = IntrusiveBackList<Node>;
597 :
598 : ListTy List;
599 19948 :
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 111 : 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 1583418 : 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 3217665 : value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V) {
641 1595891 : List.push_back(*new (Alloc) Node(V));
642 1595891 : return value_iterator(ListTy::toIterator(List.back()));
643 : }
644 : template <class T>
645 : value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
646 9974 : dwarf::Form Form, T &&Value) {
647 1614593 : return addValue(Alloc, DIEValue(Attribute, Form, std::forward<T>(Value)));
648 9974 : }
649 :
650 : value_range values() {
651 : return make_range(value_iterator(List.begin()), value_iterator(List.end()));
652 : }
653 9280 : const_value_range values() const {
654 : return make_range(const_value_iterator(List.begin()),
655 : const_value_iterator(List.end()));
656 : }
657 461061 : };
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 919068 : 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 6196 : DIE &operator=(const DIE &RHS) = delete;
690 : DIE &operator=(const DIE &&RHS) = delete;
691 :
692 459534 : static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {
693 459534 : return new (Alloc) DIE(Tag);
694 : }
695 :
696 : // Accessors.
697 : unsigned getAbbrevNumber() const { return AbbrevNumber; }
698 1427 : dwarf::Tag getTag() const { return Tag; }
699 1427 : /// Get the compile/type unit relative offset of this DIE.
700 0 : unsigned getOffset() const { return Offset; }
701 0 : unsigned getSize() const { return Size; }
702 : bool hasChildren() const { return ForceChildren || !Children.empty(); }
703 0 : void setForceChildren(bool B) { ForceChildren = B; }
704 0 :
705 : using child_iterator = IntrusiveBackList<DIE>::iterator;
706 0 : using const_child_iterator = IntrusiveBackList<DIE>::const_iterator;
707 0 : using child_range = iterator_range<child_iterator>;
708 1385901 : 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 158388 : 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 462508 : /// 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 462506 : Child->Owner = this;
772 462506 : 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 0 : void setSection(MCSection *Section) {
816 : assert(!this->Section);
817 1433 : this->Section = Section;
818 0 : }
819 :
820 30 : virtual const MCSymbol *getCrossSectionRelativeBaseAddress() const {
821 30 : return nullptr;
822 : }
823 :
824 : /// Return the section that this DIEUnit will be emitted into.
825 : ///
826 0 : /// \returns Section pointer which can be NULL.
827 0 : MCSection *getSection() const { return Section; }
828 1425 : void setDebugSectionOffset(unsigned O) { Offset = O; }
829 0 : unsigned getDebugSectionOffset() const { return Offset; }
830 40 : void setLength(uint64_t L) { Length = L; }
831 0 : uint64_t getLength() const { return Length; }
832 0 : uint16_t getDwarfVersion() const { return Version; }
833 0 : uint16_t getAddressSize() const { return AddrSize; }
834 472651 : DIE &getUnitDie() { return Die; }
835 1406 : 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 576 : : DIEUnit(Version, AddrSize, UnitTag) {}
841 : };
842 :
843 : //===--------------------------------------------------------------------===//
844 : /// DIELoc - Represents an expression location.
845 : //
846 199 : class DIELoc : public DIEValueList {
847 : mutable unsigned Size = 0; // Size in bytes excluding size header.
848 :
849 : public:
850 14787 : DIELoc() = default;
851 :
852 : /// ComputeSize - Calculate the size of the location expression.
853 : ///
854 : unsigned ComputeSize(const AsmPrinter *AP) const;
855 :
856 87 : /// BestForm - Choose the best form for data.
857 : ///
858 0 : dwarf::Form BestForm(unsigned DwarfVersion) const {
859 8863 : if (DwarfVersion > 3)
860 0 : return dwarf::DW_FORM_exprloc;
861 : // Pre-DWARF4 location expressions were blocks and not exprloc.
862 424 : if ((unsigned char)Size == Size)
863 0 : return dwarf::DW_FORM_block1;
864 0 : if ((unsigned short)Size == Size)
865 0 : 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 48 : DIEBlock() = default;
885 :
886 : /// ComputeSize - Calculate the size of the location expression.
887 : ///
888 : unsigned ComputeSize(const AsmPrinter *AP) const;
889 :
890 598 : /// BestForm - Choose the best form for data.
891 : ///
892 0 : dwarf::Form BestForm() const {
893 14 : if ((unsigned char)Size == Size)
894 0 : return dwarf::DW_FORM_block1;
895 0 : if ((unsigned short)Size == Size)
896 0 : 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
|
