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/SmallVector.h"
19#include "llvm/Support/Dwarf.h"
20#include <vector>
21
22namespace llvm {
23class AsmPrinter;
24class MCExpr;
25class MCSymbol;
26class raw_ostream;
27class DwarfTypeUnit;
28
29//===--------------------------------------------------------------------===//
30/// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
31/// Dwarf abbreviation.
32class DIEAbbrevData {
33  /// Attribute - Dwarf attribute code.
34  ///
35  dwarf::Attribute Attribute;
36
37  /// Form - Dwarf form code.
38  ///
39  dwarf::Form Form;
40
41public:
42  DIEAbbrevData(dwarf::Attribute A, dwarf::Form F) : Attribute(A), Form(F) {}
43
44  // Accessors.
45  dwarf::Attribute getAttribute() const { return Attribute; }
46  dwarf::Form getForm() const { return Form; }
47
48  /// Profile - Used to gather unique data for the abbreviation folding set.
49  ///
50  void Profile(FoldingSetNodeID &ID) const;
51};
52
53//===--------------------------------------------------------------------===//
54/// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
55/// information object.
56class DIEAbbrev : public FoldingSetNode {
57  /// Unique number for node.
58  ///
59  unsigned Number;
60
61  /// Tag - Dwarf tag code.
62  ///
63  dwarf::Tag Tag;
64
65  /// Children - Whether or not this node has children.
66  ///
67  // This cheats a bit in all of the uses since the values in the standard
68  // are 0 and 1 for no children and children respectively.
69  bool Children;
70
71  /// Data - Raw data bytes for abbreviation.
72  ///
73  SmallVector<DIEAbbrevData, 12> Data;
74
75public:
76  DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C), Data() {}
77
78  // Accessors.
79  dwarf::Tag getTag() const { return Tag; }
80  unsigned getNumber() const { return Number; }
81  bool hasChildren() const { return Children; }
82  const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }
83  void setChildrenFlag(bool hasChild) { Children = hasChild; }
84  void setNumber(unsigned N) { Number = N; }
85
86  /// AddAttribute - Adds another set of attribute information to the
87  /// abbreviation.
88  void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {
89    Data.push_back(DIEAbbrevData(Attribute, Form));
90  }
91
92  /// Profile - Used to gather unique data for the abbreviation folding set.
93  ///
94  void Profile(FoldingSetNodeID &ID) const;
95
96  /// Emit - Print the abbreviation using the specified asm printer.
97  ///
98  void Emit(const AsmPrinter *AP) const;
99
100#ifndef NDEBUG
101  void print(raw_ostream &O);
102  void dump();
103#endif
104};
105
106//===--------------------------------------------------------------------===//
107/// DIE - A structured debug information entry.  Has an abbreviation which
108/// describes its organization.
109class DIEValue;
110
111class DIE {
112protected:
113  /// Offset - Offset in debug info section.
114  ///
115  unsigned Offset;
116
117  /// Size - Size of instance + children.
118  ///
119  unsigned Size;
120
121  /// Abbrev - Buffer for constructing abbreviation.
122  ///
123  DIEAbbrev Abbrev;
124
125  /// Children DIEs.
126  ///
127  // This can't be a vector<DIE> because pointer validity is requirent for the
128  // Parent pointer and DIEEntry.
129  // It can't be a list<DIE> because some clients need pointer validity before
130  // the object has been added to any child list
131  // (eg: DwarfUnit::constructVariableDIE). These aren't insurmountable, but may
132  // be more convoluted than beneficial.
133  std::vector<std::unique_ptr<DIE>> Children;
134
135  DIE *Parent;
136
137  /// Attribute values.
138  ///
139  SmallVector<DIEValue *, 12> Values;
140
141protected:
142  DIE()
143      : Offset(0), Size(0), Abbrev((dwarf::Tag)0, dwarf::DW_CHILDREN_no),
144        Parent(nullptr) {}
145
146public:
147  explicit DIE(dwarf::Tag Tag)
148      : Offset(0), Size(0), Abbrev((dwarf::Tag)Tag, dwarf::DW_CHILDREN_no),
149        Parent(nullptr) {}
150
151  // Accessors.
152  DIEAbbrev &getAbbrev() { return Abbrev; }
153  const DIEAbbrev &getAbbrev() const { return Abbrev; }
154  unsigned getAbbrevNumber() const { return Abbrev.getNumber(); }
155  dwarf::Tag getTag() const { return Abbrev.getTag(); }
156  unsigned getOffset() const { return Offset; }
157  unsigned getSize() const { return Size; }
158  const std::vector<std::unique_ptr<DIE>> &getChildren() const {
159    return Children;
160  }
161  const SmallVectorImpl<DIEValue *> &getValues() const { return Values; }
162  DIE *getParent() const { return Parent; }
163  /// Climb up the parent chain to get the compile or type unit DIE this DIE
164  /// belongs to.
165  const DIE *getUnit() const;
166  /// Similar to getUnit, returns null when DIE is not added to an
167  /// owner yet.
168  const DIE *getUnitOrNull() const;
169  void setOffset(unsigned O) { Offset = O; }
170  void setSize(unsigned S) { Size = S; }
171
172  /// addValue - Add a value and attributes to a DIE.
173  ///
174  void addValue(dwarf::Attribute Attribute, dwarf::Form Form, DIEValue *Value) {
175    Abbrev.AddAttribute(Attribute, Form);
176    Values.push_back(Value);
177  }
178
179  /// addChild - Add a child to the DIE.
180  ///
181  void addChild(std::unique_ptr<DIE> Child) {
182    assert(!Child->getParent());
183    Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
184    Child->Parent = this;
185    Children.push_back(std::move(Child));
186  }
187
188  /// findAttribute - Find a value in the DIE with the attribute given,
189  /// returns NULL if no such attribute exists.
190  DIEValue *findAttribute(dwarf::Attribute Attribute) const;
191
192#ifndef NDEBUG
193  void print(raw_ostream &O, unsigned IndentCount = 0) const;
194  void dump();
195#endif
196};
197
198//===--------------------------------------------------------------------===//
199/// DIEValue - A debug information entry value. Some of these roughly correlate
200/// to DWARF attribute classes.
201///
202class DIEValue {
203  virtual void anchor();
204
205public:
206  enum Type {
207    isInteger,
208    isString,
209    isExpr,
210    isLabel,
211    isDelta,
212    isEntry,
213    isTypeSignature,
214    isBlock,
215    isLoc,
216    isLocList,
217  };
218
219protected:
220  /// Ty - Type of data stored in the value.
221  ///
222  Type Ty;
223
224  explicit DIEValue(Type T) : Ty(T) {}
225  virtual ~DIEValue() {}
226
227public:
228  // Accessors
229  Type getType() const { return Ty; }
230
231  /// EmitValue - Emit value via the Dwarf writer.
232  ///
233  virtual void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const = 0;
234
235  /// SizeOf - Return the size of a value in bytes.
236  ///
237  virtual unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const = 0;
238
239#ifndef NDEBUG
240  virtual void print(raw_ostream &O) const = 0;
241  void dump() const;
242#endif
243};
244
245//===--------------------------------------------------------------------===//
246/// DIEInteger - An integer value DIE.
247///
248class DIEInteger : public DIEValue {
249  uint64_t Integer;
250
251public:
252  explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
253
254  /// BestForm - Choose the best form for integer.
255  ///
256  static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {
257    if (IsSigned) {
258      const int64_t SignedInt = Int;
259      if ((char)Int == SignedInt)
260        return dwarf::DW_FORM_data1;
261      if ((short)Int == SignedInt)
262        return dwarf::DW_FORM_data2;
263      if ((int)Int == SignedInt)
264        return dwarf::DW_FORM_data4;
265    } else {
266      if ((unsigned char)Int == Int)
267        return dwarf::DW_FORM_data1;
268      if ((unsigned short)Int == Int)
269        return dwarf::DW_FORM_data2;
270      if ((unsigned int)Int == Int)
271        return dwarf::DW_FORM_data4;
272    }
273    return dwarf::DW_FORM_data8;
274  }
275
276  /// EmitValue - Emit integer of appropriate size.
277  ///
278  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
279
280  uint64_t getValue() const { return Integer; }
281  void setValue(uint64_t Val) { Integer = Val; }
282
283  /// SizeOf - Determine size of integer value in bytes.
284  ///
285  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
286
287  // Implement isa/cast/dyncast.
288  static bool classof(const DIEValue *I) { return I->getType() == isInteger; }
289
290#ifndef NDEBUG
291  void print(raw_ostream &O) const override;
292#endif
293};
294
295//===--------------------------------------------------------------------===//
296/// DIEExpr - An expression DIE.
297//
298class DIEExpr : public DIEValue {
299  const MCExpr *Expr;
300
301public:
302  explicit DIEExpr(const MCExpr *E) : DIEValue(isExpr), Expr(E) {}
303
304  /// EmitValue - Emit expression value.
305  ///
306  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
307
308  /// getValue - Get MCExpr.
309  ///
310  const MCExpr *getValue() const { return Expr; }
311
312  /// SizeOf - Determine size of expression value in bytes.
313  ///
314  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
315
316  // Implement isa/cast/dyncast.
317  static bool classof(const DIEValue *E) { return E->getType() == isExpr; }
318
319#ifndef NDEBUG
320  void print(raw_ostream &O) const override;
321#endif
322};
323
324//===--------------------------------------------------------------------===//
325/// DIELabel - A label DIE.
326//
327class DIELabel : public DIEValue {
328  const MCSymbol *Label;
329
330public:
331  explicit DIELabel(const MCSymbol *L) : DIEValue(isLabel), Label(L) {}
332
333  /// EmitValue - Emit label value.
334  ///
335  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
336
337  /// getValue - Get MCSymbol.
338  ///
339  const MCSymbol *getValue() const { return Label; }
340
341  /// SizeOf - Determine size of label value in bytes.
342  ///
343  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
344
345  // Implement isa/cast/dyncast.
346  static bool classof(const DIEValue *L) { return L->getType() == isLabel; }
347
348#ifndef NDEBUG
349  void print(raw_ostream &O) const override;
350#endif
351};
352
353//===--------------------------------------------------------------------===//
354/// DIEDelta - A simple label difference DIE.
355///
356class DIEDelta : public DIEValue {
357  const MCSymbol *LabelHi;
358  const MCSymbol *LabelLo;
359
360public:
361  DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo)
362      : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {}
363
364  /// EmitValue - Emit delta value.
365  ///
366  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
367
368  /// SizeOf - Determine size of delta value in bytes.
369  ///
370  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
371
372  // Implement isa/cast/dyncast.
373  static bool classof(const DIEValue *D) { return D->getType() == isDelta; }
374
375#ifndef NDEBUG
376  void print(raw_ostream &O) const override;
377#endif
378};
379
380//===--------------------------------------------------------------------===//
381/// DIEString - A container for string values.
382///
383class DIEString : public DIEValue {
384  const DIEValue *Access;
385  StringRef Str;
386
387public:
388  DIEString(const DIEValue *Acc, StringRef S)
389      : DIEValue(isString), Access(Acc), Str(S) {}
390
391  /// getString - Grab the string out of the object.
392  StringRef getString() const { return Str; }
393
394  /// EmitValue - Emit delta value.
395  ///
396  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
397
398  /// SizeOf - Determine size of delta value in bytes.
399  ///
400  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
401
402  // Implement isa/cast/dyncast.
403  static bool classof(const DIEValue *D) { return D->getType() == isString; }
404
405#ifndef NDEBUG
406  void print(raw_ostream &O) const override;
407#endif
408};
409
410//===--------------------------------------------------------------------===//
411/// DIEEntry - A pointer to another debug information entry.  An instance of
412/// this class can also be used as a proxy for a debug information entry not
413/// yet defined (ie. types.)
414class DIEEntry : public DIEValue {
415  DIE &Entry;
416
417public:
418  explicit DIEEntry(DIE &E) : DIEValue(isEntry), Entry(E) {
419  }
420
421  DIE &getEntry() const { return Entry; }
422
423  /// EmitValue - Emit debug information entry offset.
424  ///
425  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
426
427  /// SizeOf - Determine size of debug information entry in bytes.
428  ///
429   unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override {
430    return Form == dwarf::DW_FORM_ref_addr ? getRefAddrSize(AP)
431                                           : sizeof(int32_t);
432  }
433
434  /// Returns size of a ref_addr entry.
435  static unsigned getRefAddrSize(const AsmPrinter *AP);
436
437  // Implement isa/cast/dyncast.
438  static bool classof(const DIEValue *E) { return E->getType() == isEntry; }
439
440#ifndef NDEBUG
441  void print(raw_ostream &O) const override;
442#endif
443};
444
445//===--------------------------------------------------------------------===//
446/// \brief A signature reference to a type unit.
447class DIETypeSignature : public DIEValue {
448  const DwarfTypeUnit &Unit;
449
450public:
451  explicit DIETypeSignature(const DwarfTypeUnit &Unit)
452      : DIEValue(isTypeSignature), Unit(Unit) {}
453
454  /// \brief Emit type unit signature.
455  void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const override;
456
457  /// Returns size of a ref_sig8 entry.
458  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override {
459    assert(Form == dwarf::DW_FORM_ref_sig8);
460    return 8;
461  }
462
463  // \brief Implement isa/cast/dyncast.
464  static bool classof(const DIEValue *E) {
465    return E->getType() == isTypeSignature;
466  }
467#ifndef NDEBUG
468  void print(raw_ostream &O) const override;
469  void dump() const;
470#endif
471};
472
473//===--------------------------------------------------------------------===//
474/// DIELoc - Represents an expression location.
475//
476class DIELoc : public DIEValue, public DIE {
477  mutable unsigned Size; // Size in bytes excluding size header.
478public:
479  DIELoc() : DIEValue(isLoc), Size(0) {}
480
481  /// ComputeSize - Calculate the size of the location expression.
482  ///
483  unsigned ComputeSize(const AsmPrinter *AP) const;
484
485  /// BestForm - Choose the best form for data.
486  ///
487  dwarf::Form BestForm(unsigned DwarfVersion) const {
488    if (DwarfVersion > 3)
489      return dwarf::DW_FORM_exprloc;
490    // Pre-DWARF4 location expressions were blocks and not exprloc.
491    if ((unsigned char)Size == Size)
492      return dwarf::DW_FORM_block1;
493    if ((unsigned short)Size == Size)
494      return dwarf::DW_FORM_block2;
495    if ((unsigned int)Size == Size)
496      return dwarf::DW_FORM_block4;
497    return dwarf::DW_FORM_block;
498  }
499
500  /// EmitValue - Emit location data.
501  ///
502  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
503
504  /// SizeOf - Determine size of location data in bytes.
505  ///
506  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
507
508  // Implement isa/cast/dyncast.
509  static bool classof(const DIEValue *E) { return E->getType() == isLoc; }
510
511#ifndef NDEBUG
512  void print(raw_ostream &O) const override;
513#endif
514};
515
516//===--------------------------------------------------------------------===//
517/// DIEBlock - Represents a block of values.
518//
519class DIEBlock : public DIEValue, public DIE {
520  mutable unsigned Size; // Size in bytes excluding size header.
521public:
522  DIEBlock() : DIEValue(isBlock), Size(0) {}
523
524  /// ComputeSize - Calculate the size of the location expression.
525  ///
526  unsigned ComputeSize(const AsmPrinter *AP) const;
527
528  /// BestForm - Choose the best form for data.
529  ///
530  dwarf::Form BestForm() const {
531    if ((unsigned char)Size == Size)
532      return dwarf::DW_FORM_block1;
533    if ((unsigned short)Size == Size)
534      return dwarf::DW_FORM_block2;
535    if ((unsigned int)Size == Size)
536      return dwarf::DW_FORM_block4;
537    return dwarf::DW_FORM_block;
538  }
539
540  /// EmitValue - Emit location data.
541  ///
542  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
543
544  /// SizeOf - Determine size of location data in bytes.
545  ///
546  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
547
548  // Implement isa/cast/dyncast.
549  static bool classof(const DIEValue *E) { return E->getType() == isBlock; }
550
551#ifndef NDEBUG
552  void print(raw_ostream &O) const override;
553#endif
554};
555
556//===--------------------------------------------------------------------===//
557/// DIELocList - Represents a pointer to a location list in the debug_loc
558/// section.
559//
560class DIELocList : public DIEValue {
561  // Index into the .debug_loc vector.
562  size_t Index;
563
564public:
565  DIELocList(size_t I) : DIEValue(isLocList), Index(I) {}
566
567  /// getValue - Grab the current index out.
568  size_t getValue() const { return Index; }
569
570  /// EmitValue - Emit location data.
571  ///
572  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const override;
573
574  /// SizeOf - Determine size of location data in bytes.
575  ///
576  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const override;
577
578  // Implement isa/cast/dyncast.
579  static bool classof(const DIEValue *E) { return E->getType() == isLocList; }
580
581#ifndef NDEBUG
582  void print(raw_ostream &O) const override;
583#endif
584};
585
586} // end llvm namespace
587
588#endif
589