contrib/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

   1 //===- DWARFDie.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 "SyntaxHighlighting.h"
  11 #include "llvm/ADT/None.h"
  12 #include "llvm/ADT/Optional.h"
  13 #include "llvm/ADT/StringRef.h"
  14 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
  15 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
  16 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
  17 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
  18 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
  19 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
  20 #include "llvm/Support/DataExtractor.h"
  21 #include "llvm/Support/Dwarf.h"
  22 #include "llvm/Support/Format.h"
  23 #include "llvm/Support/MathExtras.h"
  24 #include "llvm/Support/raw_ostream.h"
  25 #include <algorithm>
  26 #include <cassert>
  27 #include <cinttypes>
  28 #include <cstdint>
  29 #include <string>
  30 #include <utility>
  31
  32 using namespace llvm;
  33 using namespace dwarf;
  34 using namespace syntax;
  35
  36 static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) {
  37   OS << " (";
  38   do {
  39     uint64_t Shift = countTrailingZeros(Val);
  40     assert(Shift < 64 && "undefined behavior");
  41     uint64_t Bit = 1ULL << Shift;
  42     auto PropName = ApplePropertyString(Bit);
  43     if (!PropName.empty())
  44       OS << PropName;
  45     else
  46       OS << format("DW_APPLE_PROPERTY_0x%" PRIx64, Bit);
  47     if (!(Val ^= Bit))
  48       break;
  49     OS << ", ";
  50   } while (true);
  51   OS << ")";
  52 }
  53
  54 static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges,
  55                        unsigned AddressSize, unsigned Indent) {
  56   if (Ranges.empty())
  57     return;
  58
  59   for (const auto &Range: Ranges) {
  60     OS << '\n';
  61     OS.indent(Indent);
  62     OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")",
  63                  AddressSize*2, Range.LowPC,
  64                  AddressSize*2, Range.HighPC);
  65   }
  66 }
  67
  68 static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
  69                           uint32_t *OffsetPtr, dwarf::Attribute Attr,
  70                           dwarf::Form Form, unsigned Indent) {
  71   if (!Die.isValid())
  72     return;
  73   const char BaseIndent[] = "            ";
  74   OS << BaseIndent;
  75   OS.indent(Indent+2);
  76   auto attrString = AttributeString(Attr);
  77   if (!attrString.empty())
  78     WithColor(OS, syntax::Attribute) << attrString;
  79   else
  80     WithColor(OS, syntax::Attribute).get() << format("DW_AT_Unknown_%x", Attr);
  81
  82   auto formString = FormEncodingString(Form);
  83   if (!formString.empty())
  84     OS << " [" << formString << ']';
  85   else
  86     OS << format(" [DW_FORM_Unknown_%x]", Form);
  87
  88   DWARFUnit *U = Die.getDwarfUnit();
  89   DWARFFormValue formValue(Form);
  90
  91   if (!formValue.extractValue(U->getDebugInfoExtractor(), OffsetPtr, U))
  92     return;
  93
  94   OS << "\t(";
  95
  96   StringRef Name;
  97   std::string File;
  98   auto Color = syntax::Enumerator;
  99   if (Attr == DW_AT_decl_file || Attr == DW_AT_call_file) {
 100     Color = syntax::String;
 101     if (const auto *LT = U->getContext().getLineTableForUnit(U))
 102       if (LT->getFileNameByIndex(formValue.getAsUnsignedConstant().getValue(), U->getCompilationDir(), DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File)) {
 103         File = '"' + File + '"';
 104         Name = File;
 105       }
 106   } else if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant())
 107     Name = AttributeValueString(Attr, *Val);
 108
 109   if (!Name.empty())
 110     WithColor(OS, Color) << Name;
 111   else if (Attr == DW_AT_decl_line || Attr == DW_AT_call_line)
 112     OS << *formValue.getAsUnsignedConstant();
 113   else
 114     formValue.dump(OS);
 115
 116   // We have dumped the attribute raw value. For some attributes
 117   // having both the raw value and the pretty-printed value is
 118   // interesting. These attributes are handled below.
 119   if (Attr == DW_AT_specification || Attr == DW_AT_abstract_origin) {
 120     if (const char *Name = Die.getAttributeValueAsReferencedDie(Attr).getName(DINameKind::LinkageName))
 121         OS << " \"" << Name << '\"';
 122   } else if (Attr == DW_AT_APPLE_property_attribute) {
 123     if (Optional<uint64_t> OptVal = formValue.getAsUnsignedConstant())
 124       dumpApplePropertyAttribute(OS, *OptVal);
 125   } else if (Attr == DW_AT_ranges) {
 126     dumpRanges(OS, Die.getAddressRanges(), U->getAddressByteSize(),
 127                sizeof(BaseIndent)+Indent+4);
 128   }
 129
 130   OS << ")\n";
 131 }
 132
 133 bool DWARFDie::isSubprogramDIE() const {
 134   return getTag() == DW_TAG_subprogram;
 135 }
 136
 137 bool DWARFDie::isSubroutineDIE() const {
 138   auto Tag = getTag();
 139   return Tag == DW_TAG_subprogram || Tag == DW_TAG_inlined_subroutine;
 140 }
 141
 142 Optional<DWARFFormValue>
 143 DWARFDie::find(dwarf::Attribute Attr) const {
 144   if (!isValid())
 145     return None;
 146   auto AbbrevDecl = getAbbreviationDeclarationPtr();
 147   if (AbbrevDecl)
 148     return AbbrevDecl->getAttributeValue(getOffset(), Attr, *U);
 149   return None;
 150 }
 151
 152 Optional<DWARFFormValue>
 153 DWARFDie::find(ArrayRef<dwarf::Attribute> Attrs) const {
 154   if (!isValid())
 155     return None;
 156   auto AbbrevDecl = getAbbreviationDeclarationPtr();
 157   if (AbbrevDecl) {
 158     for (auto Attr : Attrs) {
 159       if (auto Value = AbbrevDecl->getAttributeValue(getOffset(), Attr, *U))
 160         return Value;
 161     }
 162   }
 163   return None;
 164 }
 165
 166 Optional<DWARFFormValue>
 167 DWARFDie::findRecursively(ArrayRef<dwarf::Attribute> Attrs) const {
 168   if (!isValid())
 169     return None;
 170   auto Die = *this;
 171   if (auto Value = Die.find(Attrs))
 172     return Value;
 173   if (auto D = Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
 174     Die = D;
 175   if (auto Value = Die.find(Attrs))
 176     return Value;
 177   if (auto D = Die.getAttributeValueAsReferencedDie(DW_AT_specification))
 178     Die = D;
 179   if (auto Value = Die.find(Attrs))
 180     return Value;
 181   return None;
 182 }
 183
 184 DWARFDie
 185 DWARFDie::getAttributeValueAsReferencedDie(dwarf::Attribute Attr) const {
 186   auto SpecRef = toReference(find(Attr));
 187   if (SpecRef) {
 188     auto SpecUnit = U->getUnitSection().getUnitForOffset(*SpecRef);
 189     if (SpecUnit)
 190       return SpecUnit->getDIEForOffset(*SpecRef);
 191   }
 192   return DWARFDie();
 193 }
 194
 195 Optional<uint64_t>
 196 DWARFDie::getRangesBaseAttribute() const {
 197   return toSectionOffset(find({DW_AT_rnglists_base, DW_AT_GNU_ranges_base}));
 198 }
 199
 200 Optional<uint64_t> DWARFDie::getHighPC(uint64_t LowPC) const {
 201   if (auto FormValue = find(DW_AT_high_pc)) {
 202     if (auto Address = FormValue->getAsAddress()) {
 203       // High PC is an address.
 204       return Address;
 205     }
 206     if (auto Offset = FormValue->getAsUnsignedConstant()) {
 207       // High PC is an offset from LowPC.
 208       return LowPC + *Offset;
 209     }
 210   }
 211   return None;
 212 }
 213
 214 bool DWARFDie::getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC,
 215                                uint64_t &SectionIndex) const {
 216   auto F = find(DW_AT_low_pc);
 217   auto LowPcAddr = toAddress(F);
 218   if (!LowPcAddr)
 219     return false;
 220   if (auto HighPcAddr = getHighPC(*LowPcAddr)) {
 221     LowPC = *LowPcAddr;
 222     HighPC = *HighPcAddr;
 223     SectionIndex = F->getSectionIndex();
 224     return true;
 225   }
 226   return false;
 227 }
 228
 229 DWARFAddressRangesVector
 230 DWARFDie::getAddressRanges() const {
 231   if (isNULL())
 232     return DWARFAddressRangesVector();
 233   // Single range specified by low/high PC.
 234   uint64_t LowPC, HighPC, Index;
 235   if (getLowAndHighPC(LowPC, HighPC, Index))
 236     return {{LowPC, HighPC, Index}};
 237
 238   // Multiple ranges from .debug_ranges section.
 239   auto RangesOffset = toSectionOffset(find(DW_AT_ranges));
 240   if (RangesOffset) {
 241     DWARFDebugRangeList RangeList;
 242     if (U->extractRangeList(*RangesOffset, RangeList))
 243       return RangeList.getAbsoluteRanges(U->getBaseAddress());
 244   }
 245   return DWARFAddressRangesVector();
 246 }
 247
 248 void
 249 DWARFDie::collectChildrenAddressRanges(DWARFAddressRangesVector& Ranges) const {
 250   if (isNULL())
 251     return;
 252   if (isSubprogramDIE()) {
 253     const auto &DIERanges = getAddressRanges();
 254     Ranges.insert(Ranges.end(), DIERanges.begin(), DIERanges.end());
 255   }
 256
 257   for (auto Child: children())
 258     Child.collectChildrenAddressRanges(Ranges);
 259 }
 260
 261 bool DWARFDie::addressRangeContainsAddress(const uint64_t Address) const {
 262   for (const auto& R : getAddressRanges()) {
 263     if (R.LowPC <= Address && Address < R.HighPC)
 264       return true;
 265   }
 266   return false;
 267 }
 268
 269 const char *
 270 DWARFDie::getSubroutineName(DINameKind Kind) const {
 271   if (!isSubroutineDIE())
 272     return nullptr;
 273   return getName(Kind);
 274 }
 275
 276 const char *
 277 DWARFDie::getName(DINameKind Kind) const {
 278   if (!isValid() || Kind == DINameKind::None)
 279     return nullptr;
 280   // Try to get mangled name only if it was asked for.
 281   if (Kind == DINameKind::LinkageName) {
 282     if (auto Name = dwarf::toString(findRecursively({DW_AT_MIPS_linkage_name,
 283                                     DW_AT_linkage_name}), nullptr))
 284       return Name;
 285   }
 286   if (auto Name = dwarf::toString(findRecursively(DW_AT_name), nullptr))
 287     return Name;
 288   return nullptr;
 289 }
 290
 291 uint64_t DWARFDie::getDeclLine() const {
 292   return toUnsigned(findRecursively(DW_AT_decl_line), 0);
 293 }
 294
 295 void DWARFDie::getCallerFrame(uint32_t &CallFile, uint32_t &CallLine,
 296                               uint32_t &CallColumn,
 297                               uint32_t &CallDiscriminator) const {
 298   CallFile = toUnsigned(find(DW_AT_call_file), 0);
 299   CallLine = toUnsigned(find(DW_AT_call_line), 0);
 300   CallColumn = toUnsigned(find(DW_AT_call_column), 0);
 301   CallDiscriminator = toUnsigned(find(DW_AT_GNU_discriminator), 0);
 302 }
 303
 304 void DWARFDie::dump(raw_ostream &OS, unsigned RecurseDepth,
 305                     unsigned Indent) const {
 306   if (!isValid())
 307     return;
 308   DataExtractor debug_info_data = U->getDebugInfoExtractor();
 309   const uint32_t Offset = getOffset();
 310   uint32_t offset = Offset;
 311
 312   if (debug_info_data.isValidOffset(offset)) {
 313     uint32_t abbrCode = debug_info_data.getULEB128(&offset);
 314     WithColor(OS, syntax::Address).get() << format("\n0x%8.8x: ", Offset);
 315
 316     if (abbrCode) {
 317       auto AbbrevDecl = getAbbreviationDeclarationPtr();
 318       if (AbbrevDecl) {
 319         auto tagString = TagString(getTag());
 320         if (!tagString.empty())
 321           WithColor(OS, syntax::Tag).get().indent(Indent) << tagString;
 322         else
 323           WithColor(OS, syntax::Tag).get().indent(Indent)
 324           << format("DW_TAG_Unknown_%x", getTag());
 325
 326         OS << format(" [%u] %c\n", abbrCode,
 327                      AbbrevDecl->hasChildren() ? '*' : ' ');
 328
 329         // Dump all data in the DIE for the attributes.
 330         for (const auto &AttrSpec : AbbrevDecl->attributes()) {
 331           if (AttrSpec.Form == DW_FORM_implicit_const) {
 332             // We are dumping .debug_info section ,
 333             // implicit_const attribute values are not really stored here,
 334             // but in .debug_abbrev section. So we just skip such attrs.
 335             continue;
 336           }
 337           dumpAttribute(OS, *this, &offset, AttrSpec.Attr, AttrSpec.Form,
 338                         Indent);
 339         }
 340
 341         DWARFDie child = getFirstChild();
 342         if (RecurseDepth > 0 && child) {
 343           while (child) {
 344             child.dump(OS, RecurseDepth-1, Indent+2);
 345             child = child.getSibling();
 346           }
 347         }
 348       } else {
 349         OS << "Abbreviation code not found in 'debug_abbrev' class for code: "
 350         << abbrCode << '\n';
 351       }
 352     } else {
 353       OS.indent(Indent) << "NULL\n";
 354     }
 355   }
 356 }
 357
 358 DWARFDie DWARFDie::getParent() const {
 359   if (isValid())
 360     return U->getParent(Die);
 361   return DWARFDie();
 362 }
 363
 364 DWARFDie DWARFDie::getSibling() const {
 365   if (isValid())
 366     return U->getSibling(Die);
 367   return DWARFDie();
 368 }
 369
 370 iterator_range<DWARFDie::attribute_iterator>
 371 DWARFDie::attributes() const {
 372   return make_range(attribute_iterator(*this, false),
 373                     attribute_iterator(*this, true));
 374 }
 375
 376 DWARFDie::attribute_iterator::attribute_iterator(DWARFDie D, bool End) :
 377     Die(D), AttrValue(0), Index(0) {
 378   auto AbbrDecl = Die.getAbbreviationDeclarationPtr();
 379   assert(AbbrDecl && "Must have abbreviation declaration");
 380   if (End) {
 381     // This is the end iterator so we set the index to the attribute count.
 382     Index = AbbrDecl->getNumAttributes();
 383   } else {
 384     // This is the begin iterator so we extract the value for this->Index.
 385     AttrValue.Offset = D.getOffset() + AbbrDecl->getCodeByteSize();
 386     updateForIndex(*AbbrDecl, 0);
 387   }
 388 }
 389
 390 void DWARFDie::attribute_iterator::updateForIndex(
 391     const DWARFAbbreviationDeclaration &AbbrDecl, uint32_t I) {
 392   Index = I;
 393   // AbbrDecl must be valid befor calling this function.
 394   auto NumAttrs = AbbrDecl.getNumAttributes();
 395   if (Index < NumAttrs) {
 396     AttrValue.Attr = AbbrDecl.getAttrByIndex(Index);
 397     // Add the previous byte size of any previous attribute value.
 398     AttrValue.Offset += AttrValue.ByteSize;
 399     AttrValue.Value.setForm(AbbrDecl.getFormByIndex(Index));
 400     uint32_t ParseOffset = AttrValue.Offset;
 401     auto U = Die.getDwarfUnit();
 402     assert(U && "Die must have valid DWARF unit");
 403     bool b = AttrValue.Value.extractValue(U->getDebugInfoExtractor(),
 404                                           &ParseOffset, U);
 405     (void)b;
 406     assert(b && "extractValue cannot fail on fully parsed DWARF");
 407     AttrValue.ByteSize = ParseOffset - AttrValue.Offset;
 408   } else {
 409     assert(Index == NumAttrs && "Indexes should be [0, NumAttrs) only");
 410     AttrValue.clear();
 411   }
 412 }
 413
 414 DWARFDie::attribute_iterator &DWARFDie::attribute_iterator::operator++() {
 415   if (auto AbbrDecl = Die.getAbbreviationDeclarationPtr())
 416     updateForIndex(*AbbrDecl, Index + 1);
 417   return *this;
 418 }