DWARFDebugInfoEntry.h revision 2e56d575b7ea507684935d5cd6d5aee96d72ceb4 
1//===-- DWARFDebugInfoEntry.h -----------------------------------*- 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#ifndef LLVM_DEBUGINFO_DWARFDEBUGINFOENTRY_H
11#define LLVM_DEBUGINFO_DWARFDEBUGINFOENTRY_H
12
13#include "DWARFAbbreviationDeclaration.h"
14#include "llvm/ADT/SmallVector.h"
15#include "llvm/Support/DataTypes.h"
16
17namespace llvm {
18
19class DWARFDebugAranges;
20class DWARFCompileUnit;
21class DWARFUnit;
22class DWARFContext;
23class DWARFFormValue;
24struct DWARFDebugInfoEntryInlinedChain;
25
26/// DWARFDebugInfoEntryMinimal - A DIE with only the minimum required data.
27class DWARFDebugInfoEntryMinimal {
28  /// Offset within the .debug_info of the start of this entry.
29  uint32_t Offset;
30
31  /// How many to subtract from "this" to get the parent.
32  /// If zero this die has no parent.
33  uint32_t ParentIdx;
34
35  /// How many to add to "this" to get the sibling.
36  uint32_t SiblingIdx;
37
38  const DWARFAbbreviationDeclaration *AbbrevDecl;
39public:
40  DWARFDebugInfoEntryMinimal()
41    : Offset(0), ParentIdx(0), SiblingIdx(0), AbbrevDecl(0) {}
42
43  void dump(raw_ostream &OS, const DWARFUnit *u, unsigned recurseDepth,
44            unsigned indent = 0) const;
45  void dumpAttribute(raw_ostream &OS, const DWARFUnit *u, uint32_t *offset_ptr,
46                     uint16_t attr, uint16_t form, unsigned indent = 0) const;
47
48  /// Extracts a debug info entry, which is a child of a given compile unit,
49  /// starting at a given offset. If DIE can't be extracted, returns false and
50  /// doesn't change OffsetPtr.
51  bool extractFast(const DWARFUnit *U, const uint8_t *FixedFormSizes,
52                   uint32_t *OffsetPtr);
53
54  /// Extract a debug info entry for a given compile unit from the
55  /// .debug_info and .debug_abbrev data starting at the given offset.
56  /// If compile unit can't be parsed, returns false and doesn't change
57  /// OffsetPtr.
58  bool extract(const DWARFUnit *U, uint32_t *OffsetPtr);
59
60  uint32_t getTag() const { return AbbrevDecl ? AbbrevDecl->getTag() : 0; }
61  bool isNULL() const { return AbbrevDecl == 0; }
62
63  /// Returns true if DIE represents a subprogram (not inlined).
64  bool isSubprogramDIE() const;
65  /// Returns true if DIE represents a subprogram or an inlined
66  /// subroutine.
67  bool isSubroutineDIE() const;
68
69  uint32_t getOffset() const { return Offset; }
70  uint32_t getNumAttributes() const {
71    return !isNULL() ? AbbrevDecl->getNumAttributes() : 0;
72  }
73  bool hasChildren() const { return !isNULL() && AbbrevDecl->hasChildren(); }
74
75  // We know we are kept in a vector of contiguous entries, so we know
76  // our parent will be some index behind "this".
77  DWARFDebugInfoEntryMinimal *getParent() {
78    return ParentIdx > 0 ? this - ParentIdx : 0;
79  }
80  const DWARFDebugInfoEntryMinimal *getParent() const {
81    return ParentIdx > 0 ? this - ParentIdx : 0;
82  }
83  // We know we are kept in a vector of contiguous entries, so we know
84  // our sibling will be some index after "this".
85  DWARFDebugInfoEntryMinimal *getSibling() {
86    return SiblingIdx > 0 ? this + SiblingIdx : 0;
87  }
88  const DWARFDebugInfoEntryMinimal *getSibling() const {
89    return SiblingIdx > 0 ? this + SiblingIdx : 0;
90  }
91  // We know we are kept in a vector of contiguous entries, so we know
92  // we don't need to store our child pointer, if we have a child it will
93  // be the next entry in the list...
94  DWARFDebugInfoEntryMinimal *getFirstChild() {
95    return hasChildren() ? this + 1 : 0;
96  }
97  const DWARFDebugInfoEntryMinimal *getFirstChild() const {
98    return hasChildren() ? this + 1 : 0;
99  }
100
101  void setParent(DWARFDebugInfoEntryMinimal *parent) {
102    if (parent) {
103      // We know we are kept in a vector of contiguous entries, so we know
104      // our parent will be some index behind "this".
105      ParentIdx = this - parent;
106    } else
107      ParentIdx = 0;
108  }
109  void setSibling(DWARFDebugInfoEntryMinimal *sibling) {
110    if (sibling) {
111      // We know we are kept in a vector of contiguous entries, so we know
112      // our sibling will be some index after "this".
113      SiblingIdx = sibling - this;
114      sibling->setParent(getParent());
115    } else
116      SiblingIdx = 0;
117  }
118
119  const DWARFAbbreviationDeclaration *getAbbreviationDeclarationPtr() const {
120    return AbbrevDecl;
121  }
122
123  bool getAttributeValue(const DWARFUnit *U, const uint16_t Attr,
124                         DWARFFormValue &FormValue) const;
125
126  const char *getAttributeValueAsString(const DWARFUnit *U, const uint16_t Attr,
127                                        const char *FailValue) const;
128
129  uint64_t getAttributeValueAsAddress(const DWARFUnit *U, const uint16_t Attr,
130                                      uint64_t FailValue) const;
131
132  uint64_t getAttributeValueAsUnsigned(const DWARFUnit *U, const uint16_t Attr,
133                                       uint64_t FailValue) const;
134
135  uint64_t getAttributeValueAsReference(const DWARFUnit *U, const uint16_t Attr,
136                                        uint64_t FailValue) const;
137
138  /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
139  /// Returns true if both attributes are present.
140  bool getLowAndHighPC(const DWARFUnit *U, uint64_t &LowPC,
141                       uint64_t &HighPC) const;
142
143  void buildAddressRangeTable(const DWARFUnit *U,
144                              DWARFDebugAranges *DebugAranges,
145                              uint32_t CUOffsetInAranges) const;
146
147  bool addressRangeContainsAddress(const DWARFUnit *U,
148                                   const uint64_t Address) const;
149
150  /// If a DIE represents a subprogram (or inlined subroutine),
151  /// returns its mangled name (or short name, if mangled is missing).
152  /// This name may be fetched from specification or abstract origin
153  /// for this subprogram. Returns null if no name is found.
154  const char *getSubroutineName(const DWARFUnit *U) const;
155
156  /// Retrieves values of DW_AT_call_file, DW_AT_call_line and
157  /// DW_AT_call_column from DIE (or zeroes if they are missing).
158  void getCallerFrame(const DWARFUnit *U, uint32_t &CallFile,
159                      uint32_t &CallLine, uint32_t &CallColumn) const;
160
161  /// Get inlined chain for a given address, rooted at the current DIE.
162  /// Returns empty chain if address is not contained in address range
163  /// of current DIE.
164  DWARFDebugInfoEntryInlinedChain
165  getInlinedChainForAddress(const DWARFUnit *U, const uint64_t Address) const;
166};
167
168/// DWARFDebugInfoEntryInlinedChain - represents a chain of inlined_subroutine
169/// DIEs, (possibly ending with subprogram DIE), all of which are contained
170/// in some concrete inlined instance tree. Address range for each DIE
171/// (except the last DIE) in this chain is contained in address
172/// range for next DIE in the chain.
173struct DWARFDebugInfoEntryInlinedChain {
174  DWARFDebugInfoEntryInlinedChain() : U(0) {}
175  SmallVector<DWARFDebugInfoEntryMinimal, 4> DIEs;
176  const DWARFUnit *U;
177};
178
179}
180
181#endif
182