DWARFDebugInfoEntry.cpp revision dce4a407a24b04eebc6a376f8e62b41aaa7b071f 
1//===-- DWARFDebugInfoEntry.cpp -------------------------------------------===//
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#include "DWARFDebugInfoEntry.h"
11#include "DWARFCompileUnit.h"
12#include "DWARFContext.h"
13#include "DWARFDebugAbbrev.h"
14#include "llvm/DebugInfo/DWARFFormValue.h"
15#include "llvm/Support/Debug.h"
16#include "llvm/Support/Dwarf.h"
17#include "llvm/Support/Format.h"
18#include "llvm/Support/raw_ostream.h"
19using namespace llvm;
20using namespace dwarf;
21typedef DILineInfoSpecifier::FunctionNameKind FunctionNameKind;
22
23void DWARFDebugInfoEntryMinimal::dump(raw_ostream &OS, const DWARFUnit *u,
24                                      unsigned recurseDepth,
25                                      unsigned indent) const {
26  DataExtractor debug_info_data = u->getDebugInfoExtractor();
27  uint32_t offset = Offset;
28
29  if (debug_info_data.isValidOffset(offset)) {
30    uint32_t abbrCode = debug_info_data.getULEB128(&offset);
31
32    OS << format("\n0x%8.8x: ", Offset);
33    if (abbrCode) {
34      if (AbbrevDecl) {
35        const char *tagString = TagString(getTag());
36        if (tagString)
37          OS.indent(indent) << tagString;
38        else
39          OS.indent(indent) << format("DW_TAG_Unknown_%x", getTag());
40        OS << format(" [%u] %c\n", abbrCode,
41                     AbbrevDecl->hasChildren() ? '*' : ' ');
42
43        // Dump all data in the DIE for the attributes.
44        for (const auto &AttrSpec : AbbrevDecl->attributes()) {
45          dumpAttribute(OS, u, &offset, AttrSpec.Attr, AttrSpec.Form, indent);
46        }
47
48        const DWARFDebugInfoEntryMinimal *child = getFirstChild();
49        if (recurseDepth > 0 && child) {
50          while (child) {
51            child->dump(OS, u, recurseDepth-1, indent+2);
52            child = child->getSibling();
53          }
54        }
55      } else {
56        OS << "Abbreviation code not found in 'debug_abbrev' class for code: "
57           << abbrCode << '\n';
58      }
59    } else {
60      OS.indent(indent) << "NULL\n";
61    }
62  }
63}
64
65void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
66                                               const DWARFUnit *u,
67                                               uint32_t *offset_ptr,
68                                               uint16_t attr, uint16_t form,
69                                               unsigned indent) const {
70  OS << "            ";
71  OS.indent(indent+2);
72  const char *attrString = AttributeString(attr);
73  if (attrString)
74    OS << attrString;
75  else
76    OS << format("DW_AT_Unknown_%x", attr);
77  const char *formString = FormEncodingString(form);
78  if (formString)
79    OS << " [" << formString << ']';
80  else
81    OS << format(" [DW_FORM_Unknown_%x]", form);
82
83  DWARFFormValue formValue(form);
84
85  if (!formValue.extractValue(u->getDebugInfoExtractor(), offset_ptr, u))
86    return;
87
88  OS << "\t(";
89  formValue.dump(OS, u);
90  OS << ")\n";
91}
92
93bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit *U,
94                                             uint32_t *OffsetPtr) {
95  Offset = *OffsetPtr;
96  DataExtractor DebugInfoData = U->getDebugInfoExtractor();
97  uint32_t UEndOffset = U->getNextUnitOffset();
98  if (Offset >= UEndOffset || !DebugInfoData.isValidOffset(Offset))
99    return false;
100  uint64_t AbbrCode = DebugInfoData.getULEB128(OffsetPtr);
101  if (0 == AbbrCode) {
102    // NULL debug tag entry.
103    AbbrevDecl = nullptr;
104    return true;
105  }
106  AbbrevDecl = U->getAbbreviations()->getAbbreviationDeclaration(AbbrCode);
107  if (nullptr == AbbrevDecl) {
108    // Restore the original offset.
109    *OffsetPtr = Offset;
110    return false;
111  }
112  ArrayRef<uint8_t> FixedFormSizes = DWARFFormValue::getFixedFormSizes(
113      U->getAddressByteSize(), U->getVersion());
114  assert(FixedFormSizes.size() > 0);
115
116  // Skip all data in the .debug_info for the attributes
117  for (const auto &AttrSpec : AbbrevDecl->attributes()) {
118    uint16_t Form = AttrSpec.Form;
119
120    uint8_t FixedFormSize =
121        (Form < FixedFormSizes.size()) ? FixedFormSizes[Form] : 0;
122    if (FixedFormSize)
123      *OffsetPtr += FixedFormSize;
124    else if (!DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, U)) {
125      // Restore the original offset.
126      *OffsetPtr = Offset;
127      return false;
128    }
129  }
130  return true;
131}
132
133bool DWARFDebugInfoEntryMinimal::isSubprogramDIE() const {
134  return getTag() == DW_TAG_subprogram;
135}
136
137bool DWARFDebugInfoEntryMinimal::isSubroutineDIE() const {
138  uint32_t Tag = getTag();
139  return Tag == DW_TAG_subprogram ||
140         Tag == DW_TAG_inlined_subroutine;
141}
142
143bool DWARFDebugInfoEntryMinimal::getAttributeValue(
144    const DWARFUnit *U, const uint16_t Attr, DWARFFormValue &FormValue) const {
145  if (!AbbrevDecl)
146    return false;
147
148  uint32_t AttrIdx = AbbrevDecl->findAttributeIndex(Attr);
149  if (AttrIdx == -1U)
150    return false;
151
152  DataExtractor DebugInfoData = U->getDebugInfoExtractor();
153  uint32_t DebugInfoOffset = getOffset();
154
155  // Skip the abbreviation code so we are at the data for the attributes
156  DebugInfoData.getULEB128(&DebugInfoOffset);
157
158  // Skip preceding attribute values.
159  for (uint32_t i = 0; i < AttrIdx; ++i) {
160    DWARFFormValue::skipValue(AbbrevDecl->getFormByIndex(i),
161                              DebugInfoData, &DebugInfoOffset, U);
162  }
163
164  FormValue = DWARFFormValue(AbbrevDecl->getFormByIndex(AttrIdx));
165  return FormValue.extractValue(DebugInfoData, &DebugInfoOffset, U);
166}
167
168const char *DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
169    const DWARFUnit *U, const uint16_t Attr, const char *FailValue) const {
170  DWARFFormValue FormValue;
171  if (!getAttributeValue(U, Attr, FormValue))
172    return FailValue;
173  Optional<const char *> Result = FormValue.getAsCString(U);
174  return Result.hasValue() ? Result.getValue() : FailValue;
175}
176
177uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsAddress(
178    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
179  DWARFFormValue FormValue;
180  if (!getAttributeValue(U, Attr, FormValue))
181    return FailValue;
182  Optional<uint64_t> Result = FormValue.getAsAddress(U);
183  return Result.hasValue() ? Result.getValue() : FailValue;
184}
185
186uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsignedConstant(
187    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
188  DWARFFormValue FormValue;
189  if (!getAttributeValue(U, Attr, FormValue))
190    return FailValue;
191  Optional<uint64_t> Result = FormValue.getAsUnsignedConstant();
192  return Result.hasValue() ? Result.getValue() : FailValue;
193}
194
195uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsReference(
196    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
197  DWARFFormValue FormValue;
198  if (!getAttributeValue(U, Attr, FormValue))
199    return FailValue;
200  Optional<uint64_t> Result = FormValue.getAsReference(U);
201  return Result.hasValue() ? Result.getValue() : FailValue;
202}
203
204uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsSectionOffset(
205    const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const {
206  DWARFFormValue FormValue;
207  if (!getAttributeValue(U, Attr, FormValue))
208    return FailValue;
209  Optional<uint64_t> Result = FormValue.getAsSectionOffset();
210  return Result.hasValue() ? Result.getValue() : FailValue;
211}
212
213bool DWARFDebugInfoEntryMinimal::getLowAndHighPC(const DWARFUnit *U,
214                                                 uint64_t &LowPC,
215                                                 uint64_t &HighPC) const {
216  LowPC = getAttributeValueAsAddress(U, DW_AT_low_pc, -1ULL);
217  if (LowPC == -1ULL)
218    return false;
219  HighPC = getAttributeValueAsAddress(U, DW_AT_high_pc, -1ULL);
220  if (HighPC == -1ULL) {
221    // Since DWARF4, DW_AT_high_pc may also be of class constant, in which case
222    // it represents function size.
223    HighPC = getAttributeValueAsUnsignedConstant(U, DW_AT_high_pc, -1ULL);
224    if (HighPC != -1ULL)
225      HighPC += LowPC;
226  }
227  return (HighPC != -1ULL);
228}
229
230DWARFAddressRangesVector
231DWARFDebugInfoEntryMinimal::getAddressRanges(const DWARFUnit *U) const {
232  if (isNULL())
233    return DWARFAddressRangesVector();
234  // Single range specified by low/high PC.
235  uint64_t LowPC, HighPC;
236  if (getLowAndHighPC(U, LowPC, HighPC)) {
237    return DWARFAddressRangesVector(1, std::make_pair(LowPC, HighPC));
238  }
239  // Multiple ranges from .debug_ranges section.
240  uint32_t RangesOffset =
241      getAttributeValueAsSectionOffset(U, DW_AT_ranges, -1U);
242  if (RangesOffset != -1U) {
243    DWARFDebugRangeList RangeList;
244    if (U->extractRangeList(RangesOffset, RangeList))
245      return RangeList.getAbsoluteRanges(U->getBaseAddress());
246  }
247  return DWARFAddressRangesVector();
248}
249
250void DWARFDebugInfoEntryMinimal::collectChildrenAddressRanges(
251    const DWARFUnit *U, DWARFAddressRangesVector& Ranges) const {
252  if (isNULL())
253    return;
254  if (isSubprogramDIE()) {
255    const auto &DIERanges = getAddressRanges(U);
256    Ranges.insert(Ranges.end(), DIERanges.begin(), DIERanges.end());
257  }
258
259  const DWARFDebugInfoEntryMinimal *Child = getFirstChild();
260  while (Child) {
261    Child->collectChildrenAddressRanges(U, Ranges);
262    Child = Child->getSibling();
263  }
264}
265
266bool DWARFDebugInfoEntryMinimal::addressRangeContainsAddress(
267    const DWARFUnit *U, const uint64_t Address) const {
268  for (const auto& R : getAddressRanges(U)) {
269    if (R.first <= Address && Address < R.second)
270      return true;
271  }
272  return false;
273}
274
275const char *
276DWARFDebugInfoEntryMinimal::getSubroutineName(const DWARFUnit *U,
277                                              FunctionNameKind Kind) const {
278  if (!isSubroutineDIE() || Kind == FunctionNameKind::None)
279    return nullptr;
280  // Try to get mangled name only if it was asked for.
281  if (Kind == FunctionNameKind::LinkageName) {
282    if (const char *name =
283            getAttributeValueAsString(U, DW_AT_MIPS_linkage_name, nullptr))
284      return name;
285    if (const char *name =
286            getAttributeValueAsString(U, DW_AT_linkage_name, nullptr))
287      return name;
288  }
289  if (const char *name = getAttributeValueAsString(U, DW_AT_name, nullptr))
290    return name;
291  // Try to get name from specification DIE.
292  uint32_t spec_ref =
293      getAttributeValueAsReference(U, DW_AT_specification, -1U);
294  if (spec_ref != -1U) {
295    DWARFDebugInfoEntryMinimal spec_die;
296    if (spec_die.extractFast(U, &spec_ref)) {
297      if (const char *name = spec_die.getSubroutineName(U, Kind))
298        return name;
299    }
300  }
301  // Try to get name from abstract origin DIE.
302  uint32_t abs_origin_ref =
303      getAttributeValueAsReference(U, DW_AT_abstract_origin, -1U);
304  if (abs_origin_ref != -1U) {
305    DWARFDebugInfoEntryMinimal abs_origin_die;
306    if (abs_origin_die.extractFast(U, &abs_origin_ref)) {
307      if (const char *name = abs_origin_die.getSubroutineName(U, Kind))
308        return name;
309    }
310  }
311  return nullptr;
312}
313
314void DWARFDebugInfoEntryMinimal::getCallerFrame(const DWARFUnit *U,
315                                                uint32_t &CallFile,
316                                                uint32_t &CallLine,
317                                                uint32_t &CallColumn) const {
318  CallFile = getAttributeValueAsUnsignedConstant(U, DW_AT_call_file, 0);
319  CallLine = getAttributeValueAsUnsignedConstant(U, DW_AT_call_line, 0);
320  CallColumn = getAttributeValueAsUnsignedConstant(U, DW_AT_call_column, 0);
321}
322
323DWARFDebugInfoEntryInlinedChain
324DWARFDebugInfoEntryMinimal::getInlinedChainForAddress(
325    const DWARFUnit *U, const uint64_t Address) const {
326  DWARFDebugInfoEntryInlinedChain InlinedChain;
327  InlinedChain.U = U;
328  if (isNULL())
329    return InlinedChain;
330  for (const DWARFDebugInfoEntryMinimal *DIE = this; DIE; ) {
331    // Append current DIE to inlined chain only if it has correct tag
332    // (e.g. it is not a lexical block).
333    if (DIE->isSubroutineDIE()) {
334      InlinedChain.DIEs.push_back(*DIE);
335    }
336    // Try to get child which also contains provided address.
337    const DWARFDebugInfoEntryMinimal *Child = DIE->getFirstChild();
338    while (Child) {
339      if (Child->addressRangeContainsAddress(U, Address)) {
340        // Assume there is only one such child.
341        break;
342      }
343      Child = Child->getSibling();
344    }
345    DIE = Child;
346  }
347  // Reverse the obtained chain to make the root of inlined chain last.
348  std::reverse(InlinedChain.DIEs.begin(), InlinedChain.DIEs.end());
349  return InlinedChain;
350}
351