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 "SyntaxHighlighting.h" 11 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h" 12 #include "llvm/DebugInfo/DWARF/DWARFContext.h" 13 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h" 14 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h" 15 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h" 16 #include "llvm/Support/DataTypes.h" 17 #include "llvm/Support/Debug.h" 18 #include "llvm/Support/Dwarf.h" 19 #include "llvm/Support/Format.h" 20 #include "llvm/Support/raw_ostream.h" 21 using namespace llvm; 22 using namespace dwarf; 23 using namespace syntax; 24 25 // Small helper to extract a DIE pointed by a reference 26 // attribute. It looks up the Unit containing the DIE and calls 27 // DIE.extractFast with the right unit. Returns new unit on success, 28 // nullptr otherwise. 29 static const DWARFUnit *findUnitAndExtractFast(DWARFDebugInfoEntryMinimal &DIE, 30 const DWARFUnit *Unit, 31 uint32_t *Offset) { 32 Unit = Unit->getUnitSection().getUnitForOffset(*Offset); 33 return (Unit && DIE.extractFast(Unit, Offset)) ? Unit : nullptr; 34 } 35 36 void DWARFDebugInfoEntryMinimal::dump(raw_ostream &OS, DWARFUnit *u, 37 unsigned recurseDepth, 38 unsigned indent) const { 39 DataExtractor debug_info_data = u->getDebugInfoExtractor(); 40 uint32_t offset = Offset; 41 42 if (debug_info_data.isValidOffset(offset)) { 43 uint32_t abbrCode = debug_info_data.getULEB128(&offset); 44 WithColor(OS, syntax::Address).get() << format("\n0x%8.8x: ", Offset); 45 46 if (abbrCode) { 47 if (AbbrevDecl) { 48 const char *tagString = TagString(getTag()); 49 if (tagString) 50 WithColor(OS, syntax::Tag).get().indent(indent) << tagString; 51 else 52 WithColor(OS, syntax::Tag).get().indent(indent) << 53 format("DW_TAG_Unknown_%x", getTag()); 54 55 OS << format(" [%u] %c\n", abbrCode, 56 AbbrevDecl->hasChildren() ? '*' : ' '); 57 58 // Dump all data in the DIE for the attributes. 59 for (const auto &AttrSpec : AbbrevDecl->attributes()) { 60 dumpAttribute(OS, u, &offset, AttrSpec.Attr, AttrSpec.Form, indent); 61 } 62 63 const DWARFDebugInfoEntryMinimal *child = getFirstChild(); 64 if (recurseDepth > 0 && child) { 65 while (child) { 66 child->dump(OS, u, recurseDepth-1, indent+2); 67 child = child->getSibling(); 68 } 69 } 70 } else { 71 OS << "Abbreviation code not found in 'debug_abbrev' class for code: " 72 << abbrCode << '\n'; 73 } 74 } else { 75 OS.indent(indent) << "NULL\n"; 76 } 77 } 78 } 79 80 static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) { 81 OS << " ("; 82 do { 83 uint64_t Shift = countTrailingZeros(Val); 84 assert(Shift < 64 && "undefined behavior"); 85 uint64_t Bit = 1ULL << Shift; 86 if (const char *PropName = ApplePropertyString(Bit)) 87 OS << PropName; 88 else 89 OS << format("DW_APPLE_PROPERTY_0x%" PRIx64, Bit); 90 if (!(Val ^= Bit)) 91 break; 92 OS << ", "; 93 } while (true); 94 OS << ")"; 95 } 96 97 static void dumpRanges(raw_ostream &OS, const DWARFAddressRangesVector& Ranges, 98 unsigned AddressSize, unsigned Indent) { 99 if (Ranges.empty()) 100 return; 101 102 for (const auto &Range: Ranges) { 103 OS << '\n'; 104 OS.indent(Indent); 105 OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")", 106 AddressSize*2, Range.first, 107 AddressSize*2, Range.second); 108 } 109 } 110 111 void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS, 112 DWARFUnit *u, 113 uint32_t *offset_ptr, 114 uint16_t attr, uint16_t form, 115 unsigned indent) const { 116 const char BaseIndent[] = " "; 117 OS << BaseIndent; 118 OS.indent(indent+2); 119 const char *attrString = AttributeString(attr); 120 if (attrString) 121 WithColor(OS, syntax::Attribute) << attrString; 122 else 123 WithColor(OS, syntax::Attribute).get() << format("DW_AT_Unknown_%x", attr); 124 125 const char *formString = FormEncodingString(form); 126 if (formString) 127 OS << " [" << formString << ']'; 128 else 129 OS << format(" [DW_FORM_Unknown_%x]", form); 130 131 DWARFFormValue formValue(form); 132 133 if (!formValue.extractValue(u->getDebugInfoExtractor(), offset_ptr, u)) 134 return; 135 136 OS << "\t("; 137 138 const char *Name = nullptr; 139 std::string File; 140 auto Color = syntax::Enumerator; 141 if (attr == DW_AT_decl_file || attr == DW_AT_call_file) { 142 Color = syntax::String; 143 if (const auto *LT = u->getContext().getLineTableForUnit(u)) 144 if (LT->getFileNameByIndex( 145 formValue.getAsUnsignedConstant().getValue(), 146 u->getCompilationDir(), 147 DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File)) { 148 File = '"' + File + '"'; 149 Name = File.c_str(); 150 } 151 } else if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant()) 152 Name = AttributeValueString(attr, *Val); 153 154 if (Name) 155 WithColor(OS, Color) << Name; 156 else if (attr == DW_AT_decl_line || attr == DW_AT_call_line) 157 OS << *formValue.getAsUnsignedConstant(); 158 else 159 formValue.dump(OS, u); 160 161 // We have dumped the attribute raw value. For some attributes 162 // having both the raw value and the pretty-printed value is 163 // interesting. These attributes are handled below. 164 if (attr == DW_AT_specification || attr == DW_AT_abstract_origin) { 165 Optional<uint64_t> Ref = formValue.getAsReference(u); 166 if (Ref.hasValue()) { 167 uint32_t RefOffset = Ref.getValue(); 168 DWARFDebugInfoEntryMinimal DIE; 169 if (const DWARFUnit *RefU = findUnitAndExtractFast(DIE, u, &RefOffset)) 170 if (const char *Name = DIE.getName(RefU, DINameKind::LinkageName)) 171 OS << " \"" << Name << '\"'; 172 } 173 } else if (attr == DW_AT_APPLE_property_attribute) { 174 if (Optional<uint64_t> OptVal = formValue.getAsUnsignedConstant()) 175 dumpApplePropertyAttribute(OS, *OptVal); 176 } else if (attr == DW_AT_ranges) { 177 dumpRanges(OS, getAddressRanges(u), u->getAddressByteSize(), 178 sizeof(BaseIndent)+indent+4); 179 } 180 181 OS << ")\n"; 182 } 183 184 bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit *U, 185 uint32_t *OffsetPtr) { 186 Offset = *OffsetPtr; 187 DataExtractor DebugInfoData = U->getDebugInfoExtractor(); 188 uint32_t UEndOffset = U->getNextUnitOffset(); 189 if (Offset >= UEndOffset || !DebugInfoData.isValidOffset(Offset)) 190 return false; 191 uint64_t AbbrCode = DebugInfoData.getULEB128(OffsetPtr); 192 if (0 == AbbrCode) { 193 // NULL debug tag entry. 194 AbbrevDecl = nullptr; 195 return true; 196 } 197 AbbrevDecl = U->getAbbreviations()->getAbbreviationDeclaration(AbbrCode); 198 if (nullptr == AbbrevDecl) { 199 // Restore the original offset. 200 *OffsetPtr = Offset; 201 return false; 202 } 203 ArrayRef<uint8_t> FixedFormSizes = DWARFFormValue::getFixedFormSizes( 204 U->getAddressByteSize(), U->getVersion()); 205 assert(FixedFormSizes.size() > 0); 206 207 // Skip all data in the .debug_info for the attributes 208 for (const auto &AttrSpec : AbbrevDecl->attributes()) { 209 uint16_t Form = AttrSpec.Form; 210 211 uint8_t FixedFormSize = 212 (Form < FixedFormSizes.size()) ? FixedFormSizes[Form] : 0; 213 if (FixedFormSize) 214 *OffsetPtr += FixedFormSize; 215 else if (!DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, U)) { 216 // Restore the original offset. 217 *OffsetPtr = Offset; 218 return false; 219 } 220 } 221 return true; 222 } 223 224 bool DWARFDebugInfoEntryMinimal::isSubprogramDIE() const { 225 return getTag() == DW_TAG_subprogram; 226 } 227 228 bool DWARFDebugInfoEntryMinimal::isSubroutineDIE() const { 229 uint32_t Tag = getTag(); 230 return Tag == DW_TAG_subprogram || 231 Tag == DW_TAG_inlined_subroutine; 232 } 233 234 bool DWARFDebugInfoEntryMinimal::getAttributeValue( 235 const DWARFUnit *U, const uint16_t Attr, DWARFFormValue &FormValue) const { 236 if (!AbbrevDecl) 237 return false; 238 239 uint32_t AttrIdx = AbbrevDecl->findAttributeIndex(Attr); 240 if (AttrIdx == -1U) 241 return false; 242 243 DataExtractor DebugInfoData = U->getDebugInfoExtractor(); 244 uint32_t DebugInfoOffset = getOffset(); 245 246 // Skip the abbreviation code so we are at the data for the attributes 247 DebugInfoData.getULEB128(&DebugInfoOffset); 248 249 // Skip preceding attribute values. 250 for (uint32_t i = 0; i < AttrIdx; ++i) { 251 DWARFFormValue::skipValue(AbbrevDecl->getFormByIndex(i), 252 DebugInfoData, &DebugInfoOffset, U); 253 } 254 255 FormValue = DWARFFormValue(AbbrevDecl->getFormByIndex(AttrIdx)); 256 return FormValue.extractValue(DebugInfoData, &DebugInfoOffset, U); 257 } 258 259 const char *DWARFDebugInfoEntryMinimal::getAttributeValueAsString( 260 const DWARFUnit *U, const uint16_t Attr, const char *FailValue) const { 261 DWARFFormValue FormValue; 262 if (!getAttributeValue(U, Attr, FormValue)) 263 return FailValue; 264 Optional<const char *> Result = FormValue.getAsCString(U); 265 return Result.hasValue() ? Result.getValue() : FailValue; 266 } 267 268 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsAddress( 269 const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const { 270 DWARFFormValue FormValue; 271 if (!getAttributeValue(U, Attr, FormValue)) 272 return FailValue; 273 Optional<uint64_t> Result = FormValue.getAsAddress(U); 274 return Result.hasValue() ? Result.getValue() : FailValue; 275 } 276 277 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsignedConstant( 278 const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const { 279 DWARFFormValue FormValue; 280 if (!getAttributeValue(U, Attr, FormValue)) 281 return FailValue; 282 Optional<uint64_t> Result = FormValue.getAsUnsignedConstant(); 283 return Result.hasValue() ? Result.getValue() : FailValue; 284 } 285 286 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsReference( 287 const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const { 288 DWARFFormValue FormValue; 289 if (!getAttributeValue(U, Attr, FormValue)) 290 return FailValue; 291 Optional<uint64_t> Result = FormValue.getAsReference(U); 292 return Result.hasValue() ? Result.getValue() : FailValue; 293 } 294 295 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsSectionOffset( 296 const DWARFUnit *U, const uint16_t Attr, uint64_t FailValue) const { 297 DWARFFormValue FormValue; 298 if (!getAttributeValue(U, Attr, FormValue)) 299 return FailValue; 300 Optional<uint64_t> Result = FormValue.getAsSectionOffset(); 301 return Result.hasValue() ? Result.getValue() : FailValue; 302 } 303 304 uint64_t 305 DWARFDebugInfoEntryMinimal::getRangesBaseAttribute(const DWARFUnit *U, 306 uint64_t FailValue) const { 307 uint64_t Result = 308 getAttributeValueAsSectionOffset(U, DW_AT_ranges_base, -1ULL); 309 if (Result != -1ULL) 310 return Result; 311 return getAttributeValueAsSectionOffset(U, DW_AT_GNU_ranges_base, FailValue); 312 } 313 314 bool DWARFDebugInfoEntryMinimal::getLowAndHighPC(const DWARFUnit *U, 315 uint64_t &LowPC, 316 uint64_t &HighPC) const { 317 LowPC = getAttributeValueAsAddress(U, DW_AT_low_pc, -1ULL); 318 if (LowPC == -1ULL) 319 return false; 320 HighPC = getAttributeValueAsAddress(U, DW_AT_high_pc, -1ULL); 321 if (HighPC == -1ULL) { 322 // Since DWARF4, DW_AT_high_pc may also be of class constant, in which case 323 // it represents function size. 324 HighPC = getAttributeValueAsUnsignedConstant(U, DW_AT_high_pc, -1ULL); 325 if (HighPC != -1ULL) 326 HighPC += LowPC; 327 } 328 return (HighPC != -1ULL); 329 } 330 331 DWARFAddressRangesVector 332 DWARFDebugInfoEntryMinimal::getAddressRanges(const DWARFUnit *U) const { 333 if (isNULL()) 334 return DWARFAddressRangesVector(); 335 // Single range specified by low/high PC. 336 uint64_t LowPC, HighPC; 337 if (getLowAndHighPC(U, LowPC, HighPC)) { 338 return DWARFAddressRangesVector(1, std::make_pair(LowPC, HighPC)); 339 } 340 // Multiple ranges from .debug_ranges section. 341 uint32_t RangesOffset = 342 getAttributeValueAsSectionOffset(U, DW_AT_ranges, -1U); 343 if (RangesOffset != -1U) { 344 DWARFDebugRangeList RangeList; 345 if (U->extractRangeList(RangesOffset, RangeList)) 346 return RangeList.getAbsoluteRanges(U->getBaseAddress()); 347 } 348 return DWARFAddressRangesVector(); 349 } 350 351 void DWARFDebugInfoEntryMinimal::collectChildrenAddressRanges( 352 const DWARFUnit *U, DWARFAddressRangesVector& Ranges) const { 353 if (isNULL()) 354 return; 355 if (isSubprogramDIE()) { 356 const auto &DIERanges = getAddressRanges(U); 357 Ranges.insert(Ranges.end(), DIERanges.begin(), DIERanges.end()); 358 } 359 360 const DWARFDebugInfoEntryMinimal *Child = getFirstChild(); 361 while (Child) { 362 Child->collectChildrenAddressRanges(U, Ranges); 363 Child = Child->getSibling(); 364 } 365 } 366 367 bool DWARFDebugInfoEntryMinimal::addressRangeContainsAddress( 368 const DWARFUnit *U, const uint64_t Address) const { 369 for (const auto& R : getAddressRanges(U)) { 370 if (R.first <= Address && Address < R.second) 371 return true; 372 } 373 return false; 374 } 375 376 const char * 377 DWARFDebugInfoEntryMinimal::getSubroutineName(const DWARFUnit *U, 378 DINameKind Kind) const { 379 if (!isSubroutineDIE()) 380 return nullptr; 381 return getName(U, Kind); 382 } 383 384 const char * 385 DWARFDebugInfoEntryMinimal::getName(const DWARFUnit *U, 386 DINameKind Kind) const { 387 if (Kind == DINameKind::None) 388 return nullptr; 389 // Try to get mangled name only if it was asked for. 390 if (Kind == DINameKind::LinkageName) { 391 if (const char *name = 392 getAttributeValueAsString(U, DW_AT_MIPS_linkage_name, nullptr)) 393 return name; 394 if (const char *name = 395 getAttributeValueAsString(U, DW_AT_linkage_name, nullptr)) 396 return name; 397 } 398 if (const char *name = getAttributeValueAsString(U, DW_AT_name, nullptr)) 399 return name; 400 // Try to get name from specification DIE. 401 uint32_t spec_ref = 402 getAttributeValueAsReference(U, DW_AT_specification, -1U); 403 if (spec_ref != -1U) { 404 DWARFDebugInfoEntryMinimal spec_die; 405 if (const DWARFUnit *RefU = findUnitAndExtractFast(spec_die, U, &spec_ref)) { 406 if (const char *name = spec_die.getName(RefU, Kind)) 407 return name; 408 } 409 } 410 // Try to get name from abstract origin DIE. 411 uint32_t abs_origin_ref = 412 getAttributeValueAsReference(U, DW_AT_abstract_origin, -1U); 413 if (abs_origin_ref != -1U) { 414 DWARFDebugInfoEntryMinimal abs_origin_die; 415 if (const DWARFUnit *RefU = findUnitAndExtractFast(abs_origin_die, U, 416 &abs_origin_ref)) { 417 if (const char *name = abs_origin_die.getName(RefU, Kind)) 418 return name; 419 } 420 } 421 return nullptr; 422 } 423 424 void DWARFDebugInfoEntryMinimal::getCallerFrame(const DWARFUnit *U, 425 uint32_t &CallFile, 426 uint32_t &CallLine, 427 uint32_t &CallColumn) const { 428 CallFile = getAttributeValueAsUnsignedConstant(U, DW_AT_call_file, 0); 429 CallLine = getAttributeValueAsUnsignedConstant(U, DW_AT_call_line, 0); 430 CallColumn = getAttributeValueAsUnsignedConstant(U, DW_AT_call_column, 0); 431 } 432 433 DWARFDebugInfoEntryInlinedChain 434 DWARFDebugInfoEntryMinimal::getInlinedChainForAddress( 435 const DWARFUnit *U, const uint64_t Address) const { 436 DWARFDebugInfoEntryInlinedChain InlinedChain; 437 InlinedChain.U = U; 438 if (isNULL()) 439 return InlinedChain; 440 for (const DWARFDebugInfoEntryMinimal *DIE = this; DIE; ) { 441 // Append current DIE to inlined chain only if it has correct tag 442 // (e.g. it is not a lexical block). 443 if (DIE->isSubroutineDIE()) { 444 InlinedChain.DIEs.push_back(*DIE); 445 } 446 // Try to get child which also contains provided address. 447 const DWARFDebugInfoEntryMinimal *Child = DIE->getFirstChild(); 448 while (Child) { 449 if (Child->addressRangeContainsAddress(U, Address)) { 450 // Assume there is only one such child. 451 break; 452 } 453 Child = Child->getSibling(); 454 } 455 DIE = Child; 456 } 457 // Reverse the obtained chain to make the root of inlined chain last. 458 std::reverse(InlinedChain.DIEs.begin(), InlinedChain.DIEs.end()); 459 return InlinedChain; 460 } 461
