lib/DebugInfo/DWARFDebugInfoEntry.cpp

   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"
  19 using namespace llvm;
  20 using namespace dwarf;
  21 typedef DILineInfoSpecifier::FunctionNameKind FunctionNameKind;
  22
  23 void 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
  65 void 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
  93 bool 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
 133 bool DWARFDebugInfoEntryMinimal::isSubprogramDIE() const {
 134   return getTag() == DW_TAG_subprogram;
 135 }
 136
 137 bool DWARFDebugInfoEntryMinimal::isSubroutineDIE() const {
 138   uint32_t Tag = getTag();
 139   return Tag == DW_TAG_subprogram ||
 140          Tag == DW_TAG_inlined_subroutine;
 141 }
 142
 143 bool 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
 168 const 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
 177 uint64_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
 186 uint64_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
 195 uint64_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
 204 uint64_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
 213 bool 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
 230 DWARFAddressRangesVector
 231 DWARFDebugInfoEntryMinimal::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
 250 void 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
 266 bool 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
 275 const char *
 276 DWARFDebugInfoEntryMinimal::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
 314 void 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
 323 DWARFDebugInfoEntryInlinedChain
 324 DWARFDebugInfoEntryMinimal::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 }