1 //===- DWARFVerifier.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 "llvm/DebugInfo/DWARF/DWARFVerifier.h" 11 #include "llvm/ADT/SmallSet.h" 12 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h" 13 #include "llvm/DebugInfo/DWARF/DWARFContext.h" 14 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h" 15 #include "llvm/DebugInfo/DWARF/DWARFDie.h" 16 #include "llvm/DebugInfo/DWARF/DWARFExpression.h" 17 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h" 18 #include "llvm/DebugInfo/DWARF/DWARFSection.h" 19 #include "llvm/Support/DJB.h" 20 #include "llvm/Support/FormatVariadic.h" 21 #include "llvm/Support/WithColor.h" 22 #include "llvm/Support/raw_ostream.h" 23 #include <map> 24 #include <set> 25 #include <vector> 26 27 using namespace llvm; 28 using namespace dwarf; 29 using namespace object; 30 31 DWARFVerifier::DieRangeInfo::address_range_iterator 32 DWARFVerifier::DieRangeInfo::insert(const DWARFAddressRange &R) { 33 auto Begin = Ranges.begin(); 34 auto End = Ranges.end(); 35 auto Pos = std::lower_bound(Begin, End, R); 36 37 if (Pos != End) { 38 if (Pos->intersects(R)) 39 return Pos; 40 if (Pos != Begin) { 41 auto Iter = Pos - 1; 42 if (Iter->intersects(R)) 43 return Iter; 44 } 45 } 46 47 Ranges.insert(Pos, R); 48 return Ranges.end(); 49 } 50 51 DWARFVerifier::DieRangeInfo::die_range_info_iterator 52 DWARFVerifier::DieRangeInfo::insert(const DieRangeInfo &RI) { 53 auto End = Children.end(); 54 auto Iter = Children.begin(); 55 while (Iter != End) { 56 if (Iter->intersects(RI)) 57 return Iter; 58 ++Iter; 59 } 60 Children.insert(RI); 61 return Children.end(); 62 } 63 64 bool DWARFVerifier::DieRangeInfo::contains(const DieRangeInfo &RHS) const { 65 // Both list of ranges are sorted so we can make this fast. 66 67 if (Ranges.empty() || RHS.Ranges.empty()) 68 return false; 69 70 // Since the ranges are sorted we can advance where we start searching with 71 // this object's ranges as we traverse RHS.Ranges. 72 auto End = Ranges.end(); 73 auto Iter = findRange(RHS.Ranges.front()); 74 75 // Now linearly walk the ranges in this object and see if they contain each 76 // ranges from RHS.Ranges. 77 for (const auto &R : RHS.Ranges) { 78 while (Iter != End) { 79 if (Iter->contains(R)) 80 break; 81 ++Iter; 82 } 83 if (Iter == End) 84 return false; 85 } 86 return true; 87 } 88 89 bool DWARFVerifier::DieRangeInfo::intersects(const DieRangeInfo &RHS) const { 90 if (Ranges.empty() || RHS.Ranges.empty()) 91 return false; 92 93 auto End = Ranges.end(); 94 auto Iter = findRange(RHS.Ranges.front()); 95 for (const auto &R : RHS.Ranges) { 96 if(Iter == End) 97 return false; 98 if (R.HighPC <= Iter->LowPC) 99 continue; 100 while (Iter != End) { 101 if (Iter->intersects(R)) 102 return true; 103 ++Iter; 104 } 105 } 106 107 return false; 108 } 109 110 bool DWARFVerifier::verifyUnitHeader(const DWARFDataExtractor DebugInfoData, 111 uint32_t *Offset, unsigned UnitIndex, 112 uint8_t &UnitType, bool &isUnitDWARF64) { 113 uint32_t AbbrOffset, Length; 114 uint8_t AddrSize = 0; 115 uint16_t Version; 116 bool Success = true; 117 118 bool ValidLength = false; 119 bool ValidVersion = false; 120 bool ValidAddrSize = false; 121 bool ValidType = true; 122 bool ValidAbbrevOffset = true; 123 124 uint32_t OffsetStart = *Offset; 125 Length = DebugInfoData.getU32(Offset); 126 if (Length == UINT32_MAX) { 127 isUnitDWARF64 = true; 128 OS << format( 129 "Unit[%d] is in 64-bit DWARF format; cannot verify from this point.\n", 130 UnitIndex); 131 return false; 132 } 133 Version = DebugInfoData.getU16(Offset); 134 135 if (Version >= 5) { 136 UnitType = DebugInfoData.getU8(Offset); 137 AddrSize = DebugInfoData.getU8(Offset); 138 AbbrOffset = DebugInfoData.getU32(Offset); 139 ValidType = dwarf::isUnitType(UnitType); 140 } else { 141 UnitType = 0; 142 AbbrOffset = DebugInfoData.getU32(Offset); 143 AddrSize = DebugInfoData.getU8(Offset); 144 } 145 146 if (!DCtx.getDebugAbbrev()->getAbbreviationDeclarationSet(AbbrOffset)) 147 ValidAbbrevOffset = false; 148 149 ValidLength = DebugInfoData.isValidOffset(OffsetStart + Length + 3); 150 ValidVersion = DWARFContext::isSupportedVersion(Version); 151 ValidAddrSize = AddrSize == 4 || AddrSize == 8; 152 if (!ValidLength || !ValidVersion || !ValidAddrSize || !ValidAbbrevOffset || 153 !ValidType) { 154 Success = false; 155 error() << format("Units[%d] - start offset: 0x%08x \n", UnitIndex, 156 OffsetStart); 157 if (!ValidLength) 158 note() << "The length for this unit is too " 159 "large for the .debug_info provided.\n"; 160 if (!ValidVersion) 161 note() << "The 16 bit unit header version is not valid.\n"; 162 if (!ValidType) 163 note() << "The unit type encoding is not valid.\n"; 164 if (!ValidAbbrevOffset) 165 note() << "The offset into the .debug_abbrev section is " 166 "not valid.\n"; 167 if (!ValidAddrSize) 168 note() << "The address size is unsupported.\n"; 169 } 170 *Offset = OffsetStart + Length + 4; 171 return Success; 172 } 173 174 bool DWARFVerifier::verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType) { 175 uint32_t NumUnitErrors = 0; 176 unsigned NumDies = Unit.getNumDIEs(); 177 for (unsigned I = 0; I < NumDies; ++I) { 178 auto Die = Unit.getDIEAtIndex(I); 179 if (Die.getTag() == DW_TAG_null) 180 continue; 181 for (auto AttrValue : Die.attributes()) { 182 NumUnitErrors += verifyDebugInfoAttribute(Die, AttrValue); 183 NumUnitErrors += verifyDebugInfoForm(Die, AttrValue); 184 } 185 } 186 187 DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false); 188 if (!Die) { 189 error() << "Compilation unit without DIE.\n"; 190 NumUnitErrors++; 191 return NumUnitErrors == 0; 192 } 193 194 if (!dwarf::isUnitType(Die.getTag())) { 195 error() << "Compilation unit root DIE is not a unit DIE: " 196 << dwarf::TagString(Die.getTag()) << ".\n"; 197 NumUnitErrors++; 198 } 199 200 if (UnitType != 0 && 201 !DWARFUnit::isMatchingUnitTypeAndTag(UnitType, Die.getTag())) { 202 error() << "Compilation unit type (" << dwarf::UnitTypeString(UnitType) 203 << ") and root DIE (" << dwarf::TagString(Die.getTag()) 204 << ") do not match.\n"; 205 NumUnitErrors++; 206 } 207 208 DieRangeInfo RI; 209 NumUnitErrors += verifyDieRanges(Die, RI); 210 211 return NumUnitErrors == 0; 212 } 213 214 unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) { 215 unsigned NumErrors = 0; 216 if (Abbrev) { 217 const DWARFAbbreviationDeclarationSet *AbbrDecls = 218 Abbrev->getAbbreviationDeclarationSet(0); 219 for (auto AbbrDecl : *AbbrDecls) { 220 SmallDenseSet<uint16_t> AttributeSet; 221 for (auto Attribute : AbbrDecl.attributes()) { 222 auto Result = AttributeSet.insert(Attribute.Attr); 223 if (!Result.second) { 224 error() << "Abbreviation declaration contains multiple " 225 << AttributeString(Attribute.Attr) << " attributes.\n"; 226 AbbrDecl.dump(OS); 227 ++NumErrors; 228 } 229 } 230 } 231 } 232 return NumErrors; 233 } 234 235 bool DWARFVerifier::handleDebugAbbrev() { 236 OS << "Verifying .debug_abbrev...\n"; 237 238 const DWARFObject &DObj = DCtx.getDWARFObj(); 239 bool noDebugAbbrev = DObj.getAbbrevSection().empty(); 240 bool noDebugAbbrevDWO = DObj.getAbbrevDWOSection().empty(); 241 242 if (noDebugAbbrev && noDebugAbbrevDWO) { 243 return true; 244 } 245 246 unsigned NumErrors = 0; 247 if (!noDebugAbbrev) 248 NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrev()); 249 250 if (!noDebugAbbrevDWO) 251 NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrevDWO()); 252 return NumErrors == 0; 253 } 254 255 bool DWARFVerifier::handleDebugInfo() { 256 OS << "Verifying .debug_info Unit Header Chain...\n"; 257 258 const DWARFObject &DObj = DCtx.getDWARFObj(); 259 DWARFDataExtractor DebugInfoData(DObj, DObj.getInfoSection(), 260 DCtx.isLittleEndian(), 0); 261 uint32_t NumDebugInfoErrors = 0; 262 uint32_t OffsetStart = 0, Offset = 0, UnitIdx = 0; 263 uint8_t UnitType = 0; 264 bool isUnitDWARF64 = false; 265 bool isHeaderChainValid = true; 266 bool hasDIE = DebugInfoData.isValidOffset(Offset); 267 DWARFUnitSection<DWARFTypeUnit> TUSection{}; 268 DWARFUnitSection<DWARFCompileUnit> CUSection{}; 269 while (hasDIE) { 270 OffsetStart = Offset; 271 if (!verifyUnitHeader(DebugInfoData, &Offset, UnitIdx, UnitType, 272 isUnitDWARF64)) { 273 isHeaderChainValid = false; 274 if (isUnitDWARF64) 275 break; 276 } else { 277 DWARFUnitHeader Header; 278 Header.extract(DCtx, DebugInfoData, &OffsetStart); 279 std::unique_ptr<DWARFUnit> Unit; 280 switch (UnitType) { 281 case dwarf::DW_UT_type: 282 case dwarf::DW_UT_split_type: { 283 Unit.reset(new DWARFTypeUnit( 284 DCtx, DObj.getInfoSection(), Header, DCtx.getDebugAbbrev(), 285 &DObj.getRangeSection(), DObj.getStringSection(), 286 DObj.getStringOffsetSection(), &DObj.getAppleObjCSection(), 287 DObj.getLineSection(), DCtx.isLittleEndian(), false, TUSection)); 288 break; 289 } 290 case dwarf::DW_UT_skeleton: 291 case dwarf::DW_UT_split_compile: 292 case dwarf::DW_UT_compile: 293 case dwarf::DW_UT_partial: 294 // UnitType = 0 means that we are 295 // verifying a compile unit in DWARF v4. 296 case 0: { 297 Unit.reset(new DWARFCompileUnit( 298 DCtx, DObj.getInfoSection(), Header, DCtx.getDebugAbbrev(), 299 &DObj.getRangeSection(), DObj.getStringSection(), 300 DObj.getStringOffsetSection(), &DObj.getAppleObjCSection(), 301 DObj.getLineSection(), DCtx.isLittleEndian(), false, CUSection)); 302 break; 303 } 304 default: { llvm_unreachable("Invalid UnitType."); } 305 } 306 if (!verifyUnitContents(*Unit, UnitType)) 307 ++NumDebugInfoErrors; 308 } 309 hasDIE = DebugInfoData.isValidOffset(Offset); 310 ++UnitIdx; 311 } 312 if (UnitIdx == 0 && !hasDIE) { 313 warn() << ".debug_info is empty.\n"; 314 isHeaderChainValid = true; 315 } 316 NumDebugInfoErrors += verifyDebugInfoReferences(); 317 return (isHeaderChainValid && NumDebugInfoErrors == 0); 318 } 319 320 unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die, 321 DieRangeInfo &ParentRI) { 322 unsigned NumErrors = 0; 323 324 if (!Die.isValid()) 325 return NumErrors; 326 327 auto RangesOrError = Die.getAddressRanges(); 328 if (!RangesOrError) { 329 // FIXME: Report the error. 330 ++NumErrors; 331 llvm::consumeError(RangesOrError.takeError()); 332 return NumErrors; 333 } 334 335 DWARFAddressRangesVector Ranges = RangesOrError.get(); 336 // Build RI for this DIE and check that ranges within this DIE do not 337 // overlap. 338 DieRangeInfo RI(Die); 339 for (auto Range : Ranges) { 340 if (!Range.valid()) { 341 ++NumErrors; 342 error() << "Invalid address range " << Range << "\n"; 343 continue; 344 } 345 346 // Verify that ranges don't intersect. 347 const auto IntersectingRange = RI.insert(Range); 348 if (IntersectingRange != RI.Ranges.end()) { 349 ++NumErrors; 350 error() << "DIE has overlapping address ranges: " << Range << " and " 351 << *IntersectingRange << "\n"; 352 break; 353 } 354 } 355 356 // Verify that children don't intersect. 357 const auto IntersectingChild = ParentRI.insert(RI); 358 if (IntersectingChild != ParentRI.Children.end()) { 359 ++NumErrors; 360 error() << "DIEs have overlapping address ranges:"; 361 Die.dump(OS, 0); 362 IntersectingChild->Die.dump(OS, 0); 363 OS << "\n"; 364 } 365 366 // Verify that ranges are contained within their parent. 367 bool ShouldBeContained = !Ranges.empty() && !ParentRI.Ranges.empty() && 368 !(Die.getTag() == DW_TAG_subprogram && 369 ParentRI.Die.getTag() == DW_TAG_subprogram); 370 if (ShouldBeContained && !ParentRI.contains(RI)) { 371 ++NumErrors; 372 error() << "DIE address ranges are not contained in its parent's ranges:"; 373 ParentRI.Die.dump(OS, 0); 374 Die.dump(OS, 2); 375 OS << "\n"; 376 } 377 378 // Recursively check children. 379 for (DWARFDie Child : Die) 380 NumErrors += verifyDieRanges(Child, RI); 381 382 return NumErrors; 383 } 384 385 unsigned DWARFVerifier::verifyDebugInfoAttribute(const DWARFDie &Die, 386 DWARFAttribute &AttrValue) { 387 unsigned NumErrors = 0; 388 auto ReportError = [&](const Twine &TitleMsg) { 389 ++NumErrors; 390 error() << TitleMsg << '\n'; 391 Die.dump(OS, 0, DumpOpts); 392 OS << "\n"; 393 }; 394 395 const DWARFObject &DObj = DCtx.getDWARFObj(); 396 const auto Attr = AttrValue.Attr; 397 switch (Attr) { 398 case DW_AT_ranges: 399 // Make sure the offset in the DW_AT_ranges attribute is valid. 400 if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) { 401 if (*SectionOffset >= DObj.getRangeSection().Data.size()) 402 ReportError("DW_AT_ranges offset is beyond .debug_ranges bounds:"); 403 break; 404 } 405 ReportError("DIE has invalid DW_AT_ranges encoding:"); 406 break; 407 case DW_AT_stmt_list: 408 // Make sure the offset in the DW_AT_stmt_list attribute is valid. 409 if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) { 410 if (*SectionOffset >= DObj.getLineSection().Data.size()) 411 ReportError("DW_AT_stmt_list offset is beyond .debug_line bounds: " + 412 llvm::formatv("{0:x8}", *SectionOffset)); 413 break; 414 } 415 ReportError("DIE has invalid DW_AT_stmt_list encoding:"); 416 break; 417 case DW_AT_location: { 418 auto VerifyLocationExpr = [&](StringRef D) { 419 DWARFUnit *U = Die.getDwarfUnit(); 420 DataExtractor Data(D, DCtx.isLittleEndian(), 0); 421 DWARFExpression Expression(Data, U->getVersion(), 422 U->getAddressByteSize()); 423 bool Error = llvm::any_of(Expression, [](DWARFExpression::Operation &Op) { 424 return Op.isError(); 425 }); 426 if (Error) 427 ReportError("DIE contains invalid DWARF expression:"); 428 }; 429 if (Optional<ArrayRef<uint8_t>> Expr = AttrValue.Value.getAsBlock()) { 430 // Verify inlined location. 431 VerifyLocationExpr(llvm::toStringRef(*Expr)); 432 } else if (auto LocOffset = AttrValue.Value.getAsSectionOffset()) { 433 // Verify location list. 434 if (auto DebugLoc = DCtx.getDebugLoc()) 435 if (auto LocList = DebugLoc->getLocationListAtOffset(*LocOffset)) 436 for (const auto &Entry : LocList->Entries) 437 VerifyLocationExpr({Entry.Loc.data(), Entry.Loc.size()}); 438 } 439 break; 440 } 441 442 default: 443 break; 444 } 445 return NumErrors; 446 } 447 448 unsigned DWARFVerifier::verifyDebugInfoForm(const DWARFDie &Die, 449 DWARFAttribute &AttrValue) { 450 const DWARFObject &DObj = DCtx.getDWARFObj(); 451 unsigned NumErrors = 0; 452 const auto Form = AttrValue.Value.getForm(); 453 switch (Form) { 454 case DW_FORM_ref1: 455 case DW_FORM_ref2: 456 case DW_FORM_ref4: 457 case DW_FORM_ref8: 458 case DW_FORM_ref_udata: { 459 // Verify all CU relative references are valid CU offsets. 460 Optional<uint64_t> RefVal = AttrValue.Value.getAsReference(); 461 assert(RefVal); 462 if (RefVal) { 463 auto DieCU = Die.getDwarfUnit(); 464 auto CUSize = DieCU->getNextUnitOffset() - DieCU->getOffset(); 465 auto CUOffset = AttrValue.Value.getRawUValue(); 466 if (CUOffset >= CUSize) { 467 ++NumErrors; 468 error() << FormEncodingString(Form) << " CU offset " 469 << format("0x%08" PRIx64, CUOffset) 470 << " is invalid (must be less than CU size of " 471 << format("0x%08" PRIx32, CUSize) << "):\n"; 472 Die.dump(OS, 0, DumpOpts); 473 OS << "\n"; 474 } else { 475 // Valid reference, but we will verify it points to an actual 476 // DIE later. 477 ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset()); 478 } 479 } 480 break; 481 } 482 case DW_FORM_ref_addr: { 483 // Verify all absolute DIE references have valid offsets in the 484 // .debug_info section. 485 Optional<uint64_t> RefVal = AttrValue.Value.getAsReference(); 486 assert(RefVal); 487 if (RefVal) { 488 if (*RefVal >= DObj.getInfoSection().Data.size()) { 489 ++NumErrors; 490 error() << "DW_FORM_ref_addr offset beyond .debug_info " 491 "bounds:\n"; 492 Die.dump(OS, 0, DumpOpts); 493 OS << "\n"; 494 } else { 495 // Valid reference, but we will verify it points to an actual 496 // DIE later. 497 ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset()); 498 } 499 } 500 break; 501 } 502 case DW_FORM_strp: { 503 auto SecOffset = AttrValue.Value.getAsSectionOffset(); 504 assert(SecOffset); // DW_FORM_strp is a section offset. 505 if (SecOffset && *SecOffset >= DObj.getStringSection().size()) { 506 ++NumErrors; 507 error() << "DW_FORM_strp offset beyond .debug_str bounds:\n"; 508 Die.dump(OS, 0, DumpOpts); 509 OS << "\n"; 510 } 511 break; 512 } 513 default: 514 break; 515 } 516 return NumErrors; 517 } 518 519 unsigned DWARFVerifier::verifyDebugInfoReferences() { 520 // Take all references and make sure they point to an actual DIE by 521 // getting the DIE by offset and emitting an error 522 OS << "Verifying .debug_info references...\n"; 523 unsigned NumErrors = 0; 524 for (auto Pair : ReferenceToDIEOffsets) { 525 auto Die = DCtx.getDIEForOffset(Pair.first); 526 if (Die) 527 continue; 528 ++NumErrors; 529 error() << "invalid DIE reference " << format("0x%08" PRIx64, Pair.first) 530 << ". Offset is in between DIEs:\n"; 531 for (auto Offset : Pair.second) { 532 auto ReferencingDie = DCtx.getDIEForOffset(Offset); 533 ReferencingDie.dump(OS, 0, DumpOpts); 534 OS << "\n"; 535 } 536 OS << "\n"; 537 } 538 return NumErrors; 539 } 540 541 void DWARFVerifier::verifyDebugLineStmtOffsets() { 542 std::map<uint64_t, DWARFDie> StmtListToDie; 543 for (const auto &CU : DCtx.compile_units()) { 544 auto Die = CU->getUnitDIE(); 545 // Get the attribute value as a section offset. No need to produce an 546 // error here if the encoding isn't correct because we validate this in 547 // the .debug_info verifier. 548 auto StmtSectionOffset = toSectionOffset(Die.find(DW_AT_stmt_list)); 549 if (!StmtSectionOffset) 550 continue; 551 const uint32_t LineTableOffset = *StmtSectionOffset; 552 auto LineTable = DCtx.getLineTableForUnit(CU.get()); 553 if (LineTableOffset < DCtx.getDWARFObj().getLineSection().Data.size()) { 554 if (!LineTable) { 555 ++NumDebugLineErrors; 556 error() << ".debug_line[" << format("0x%08" PRIx32, LineTableOffset) 557 << "] was not able to be parsed for CU:\n"; 558 Die.dump(OS, 0, DumpOpts); 559 OS << '\n'; 560 continue; 561 } 562 } else { 563 // Make sure we don't get a valid line table back if the offset is wrong. 564 assert(LineTable == nullptr); 565 // Skip this line table as it isn't valid. No need to create an error 566 // here because we validate this in the .debug_info verifier. 567 continue; 568 } 569 auto Iter = StmtListToDie.find(LineTableOffset); 570 if (Iter != StmtListToDie.end()) { 571 ++NumDebugLineErrors; 572 error() << "two compile unit DIEs, " 573 << format("0x%08" PRIx32, Iter->second.getOffset()) << " and " 574 << format("0x%08" PRIx32, Die.getOffset()) 575 << ", have the same DW_AT_stmt_list section offset:\n"; 576 Iter->second.dump(OS, 0, DumpOpts); 577 Die.dump(OS, 0, DumpOpts); 578 OS << '\n'; 579 // Already verified this line table before, no need to do it again. 580 continue; 581 } 582 StmtListToDie[LineTableOffset] = Die; 583 } 584 } 585 586 void DWARFVerifier::verifyDebugLineRows() { 587 for (const auto &CU : DCtx.compile_units()) { 588 auto Die = CU->getUnitDIE(); 589 auto LineTable = DCtx.getLineTableForUnit(CU.get()); 590 // If there is no line table we will have created an error in the 591 // .debug_info verifier or in verifyDebugLineStmtOffsets(). 592 if (!LineTable) 593 continue; 594 595 // Verify prologue. 596 uint32_t MaxFileIndex = LineTable->Prologue.FileNames.size(); 597 uint32_t MaxDirIndex = LineTable->Prologue.IncludeDirectories.size(); 598 uint32_t FileIndex = 1; 599 StringMap<uint16_t> FullPathMap; 600 for (const auto &FileName : LineTable->Prologue.FileNames) { 601 // Verify directory index. 602 if (FileName.DirIdx > MaxDirIndex) { 603 ++NumDebugLineErrors; 604 error() << ".debug_line[" 605 << format("0x%08" PRIx64, 606 *toSectionOffset(Die.find(DW_AT_stmt_list))) 607 << "].prologue.file_names[" << FileIndex 608 << "].dir_idx contains an invalid index: " << FileName.DirIdx 609 << "\n"; 610 } 611 612 // Check file paths for duplicates. 613 std::string FullPath; 614 const bool HasFullPath = LineTable->getFileNameByIndex( 615 FileIndex, CU->getCompilationDir(), 616 DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FullPath); 617 assert(HasFullPath && "Invalid index?"); 618 (void)HasFullPath; 619 auto It = FullPathMap.find(FullPath); 620 if (It == FullPathMap.end()) 621 FullPathMap[FullPath] = FileIndex; 622 else if (It->second != FileIndex) { 623 warn() << ".debug_line[" 624 << format("0x%08" PRIx64, 625 *toSectionOffset(Die.find(DW_AT_stmt_list))) 626 << "].prologue.file_names[" << FileIndex 627 << "] is a duplicate of file_names[" << It->second << "]\n"; 628 } 629 630 FileIndex++; 631 } 632 633 // Verify rows. 634 uint64_t PrevAddress = 0; 635 uint32_t RowIndex = 0; 636 for (const auto &Row : LineTable->Rows) { 637 // Verify row address. 638 if (Row.Address < PrevAddress) { 639 ++NumDebugLineErrors; 640 error() << ".debug_line[" 641 << format("0x%08" PRIx64, 642 *toSectionOffset(Die.find(DW_AT_stmt_list))) 643 << "] row[" << RowIndex 644 << "] decreases in address from previous row:\n"; 645 646 DWARFDebugLine::Row::dumpTableHeader(OS); 647 if (RowIndex > 0) 648 LineTable->Rows[RowIndex - 1].dump(OS); 649 Row.dump(OS); 650 OS << '\n'; 651 } 652 653 // Verify file index. 654 if (Row.File > MaxFileIndex) { 655 ++NumDebugLineErrors; 656 error() << ".debug_line[" 657 << format("0x%08" PRIx64, 658 *toSectionOffset(Die.find(DW_AT_stmt_list))) 659 << "][" << RowIndex << "] has invalid file index " << Row.File 660 << " (valid values are [1," << MaxFileIndex << "]):\n"; 661 DWARFDebugLine::Row::dumpTableHeader(OS); 662 Row.dump(OS); 663 OS << '\n'; 664 } 665 if (Row.EndSequence) 666 PrevAddress = 0; 667 else 668 PrevAddress = Row.Address; 669 ++RowIndex; 670 } 671 } 672 } 673 674 bool DWARFVerifier::handleDebugLine() { 675 NumDebugLineErrors = 0; 676 OS << "Verifying .debug_line...\n"; 677 verifyDebugLineStmtOffsets(); 678 verifyDebugLineRows(); 679 return NumDebugLineErrors == 0; 680 } 681 682 unsigned DWARFVerifier::verifyAppleAccelTable(const DWARFSection *AccelSection, 683 DataExtractor *StrData, 684 const char *SectionName) { 685 unsigned NumErrors = 0; 686 DWARFDataExtractor AccelSectionData(DCtx.getDWARFObj(), *AccelSection, 687 DCtx.isLittleEndian(), 0); 688 AppleAcceleratorTable AccelTable(AccelSectionData, *StrData); 689 690 OS << "Verifying " << SectionName << "...\n"; 691 692 // Verify that the fixed part of the header is not too short. 693 if (!AccelSectionData.isValidOffset(AccelTable.getSizeHdr())) { 694 error() << "Section is too small to fit a section header.\n"; 695 return 1; 696 } 697 698 // Verify that the section is not too short. 699 if (Error E = AccelTable.extract()) { 700 error() << toString(std::move(E)) << '\n'; 701 return 1; 702 } 703 704 // Verify that all buckets have a valid hash index or are empty. 705 uint32_t NumBuckets = AccelTable.getNumBuckets(); 706 uint32_t NumHashes = AccelTable.getNumHashes(); 707 708 uint32_t BucketsOffset = 709 AccelTable.getSizeHdr() + AccelTable.getHeaderDataLength(); 710 uint32_t HashesBase = BucketsOffset + NumBuckets * 4; 711 uint32_t OffsetsBase = HashesBase + NumHashes * 4; 712 for (uint32_t BucketIdx = 0; BucketIdx < NumBuckets; ++BucketIdx) { 713 uint32_t HashIdx = AccelSectionData.getU32(&BucketsOffset); 714 if (HashIdx >= NumHashes && HashIdx != UINT32_MAX) { 715 error() << format("Bucket[%d] has invalid hash index: %u.\n", BucketIdx, 716 HashIdx); 717 ++NumErrors; 718 } 719 } 720 uint32_t NumAtoms = AccelTable.getAtomsDesc().size(); 721 if (NumAtoms == 0) { 722 error() << "No atoms: failed to read HashData.\n"; 723 return 1; 724 } 725 if (!AccelTable.validateForms()) { 726 error() << "Unsupported form: failed to read HashData.\n"; 727 return 1; 728 } 729 730 for (uint32_t HashIdx = 0; HashIdx < NumHashes; ++HashIdx) { 731 uint32_t HashOffset = HashesBase + 4 * HashIdx; 732 uint32_t DataOffset = OffsetsBase + 4 * HashIdx; 733 uint32_t Hash = AccelSectionData.getU32(&HashOffset); 734 uint32_t HashDataOffset = AccelSectionData.getU32(&DataOffset); 735 if (!AccelSectionData.isValidOffsetForDataOfSize(HashDataOffset, 736 sizeof(uint64_t))) { 737 error() << format("Hash[%d] has invalid HashData offset: 0x%08x.\n", 738 HashIdx, HashDataOffset); 739 ++NumErrors; 740 } 741 742 uint32_t StrpOffset; 743 uint32_t StringOffset; 744 uint32_t StringCount = 0; 745 unsigned Offset; 746 unsigned Tag; 747 while ((StrpOffset = AccelSectionData.getU32(&HashDataOffset)) != 0) { 748 const uint32_t NumHashDataObjects = 749 AccelSectionData.getU32(&HashDataOffset); 750 for (uint32_t HashDataIdx = 0; HashDataIdx < NumHashDataObjects; 751 ++HashDataIdx) { 752 std::tie(Offset, Tag) = AccelTable.readAtoms(HashDataOffset); 753 auto Die = DCtx.getDIEForOffset(Offset); 754 if (!Die) { 755 const uint32_t BucketIdx = 756 NumBuckets ? (Hash % NumBuckets) : UINT32_MAX; 757 StringOffset = StrpOffset; 758 const char *Name = StrData->getCStr(&StringOffset); 759 if (!Name) 760 Name = "<NULL>"; 761 762 error() << format( 763 "%s Bucket[%d] Hash[%d] = 0x%08x " 764 "Str[%u] = 0x%08x " 765 "DIE[%d] = 0x%08x is not a valid DIE offset for \"%s\".\n", 766 SectionName, BucketIdx, HashIdx, Hash, StringCount, StrpOffset, 767 HashDataIdx, Offset, Name); 768 769 ++NumErrors; 770 continue; 771 } 772 if ((Tag != dwarf::DW_TAG_null) && (Die.getTag() != Tag)) { 773 error() << "Tag " << dwarf::TagString(Tag) 774 << " in accelerator table does not match Tag " 775 << dwarf::TagString(Die.getTag()) << " of DIE[" << HashDataIdx 776 << "].\n"; 777 ++NumErrors; 778 } 779 } 780 ++StringCount; 781 } 782 } 783 return NumErrors; 784 } 785 786 unsigned 787 DWARFVerifier::verifyDebugNamesCULists(const DWARFDebugNames &AccelTable) { 788 // A map from CU offset to the (first) Name Index offset which claims to index 789 // this CU. 790 DenseMap<uint32_t, uint32_t> CUMap; 791 const uint32_t NotIndexed = std::numeric_limits<uint32_t>::max(); 792 793 CUMap.reserve(DCtx.getNumCompileUnits()); 794 for (const auto &CU : DCtx.compile_units()) 795 CUMap[CU->getOffset()] = NotIndexed; 796 797 unsigned NumErrors = 0; 798 for (const DWARFDebugNames::NameIndex &NI : AccelTable) { 799 if (NI.getCUCount() == 0) { 800 error() << formatv("Name Index @ {0:x} does not index any CU\n", 801 NI.getUnitOffset()); 802 ++NumErrors; 803 continue; 804 } 805 for (uint32_t CU = 0, End = NI.getCUCount(); CU < End; ++CU) { 806 uint32_t Offset = NI.getCUOffset(CU); 807 auto Iter = CUMap.find(Offset); 808 809 if (Iter == CUMap.end()) { 810 error() << formatv( 811 "Name Index @ {0:x} references a non-existing CU @ {1:x}\n", 812 NI.getUnitOffset(), Offset); 813 ++NumErrors; 814 continue; 815 } 816 817 if (Iter->second != NotIndexed) { 818 error() << formatv("Name Index @ {0:x} references a CU @ {1:x}, but " 819 "this CU is already indexed by Name Index @ {2:x}\n", 820 NI.getUnitOffset(), Offset, Iter->second); 821 continue; 822 } 823 Iter->second = NI.getUnitOffset(); 824 } 825 } 826 827 for (const auto &KV : CUMap) { 828 if (KV.second == NotIndexed) 829 warn() << formatv("CU @ {0:x} not covered by any Name Index\n", KV.first); 830 } 831 832 return NumErrors; 833 } 834 835 unsigned 836 DWARFVerifier::verifyNameIndexBuckets(const DWARFDebugNames::NameIndex &NI, 837 const DataExtractor &StrData) { 838 struct BucketInfo { 839 uint32_t Bucket; 840 uint32_t Index; 841 842 constexpr BucketInfo(uint32_t Bucket, uint32_t Index) 843 : Bucket(Bucket), Index(Index) {} 844 bool operator<(const BucketInfo &RHS) const { return Index < RHS.Index; }; 845 }; 846 847 uint32_t NumErrors = 0; 848 if (NI.getBucketCount() == 0) { 849 warn() << formatv("Name Index @ {0:x} does not contain a hash table.\n", 850 NI.getUnitOffset()); 851 return NumErrors; 852 } 853 854 // Build up a list of (Bucket, Index) pairs. We use this later to verify that 855 // each Name is reachable from the appropriate bucket. 856 std::vector<BucketInfo> BucketStarts; 857 BucketStarts.reserve(NI.getBucketCount() + 1); 858 for (uint32_t Bucket = 0, End = NI.getBucketCount(); Bucket < End; ++Bucket) { 859 uint32_t Index = NI.getBucketArrayEntry(Bucket); 860 if (Index > NI.getNameCount()) { 861 error() << formatv("Bucket {0} of Name Index @ {1:x} contains invalid " 862 "value {2}. Valid range is [0, {3}].\n", 863 Bucket, NI.getUnitOffset(), Index, NI.getNameCount()); 864 ++NumErrors; 865 continue; 866 } 867 if (Index > 0) 868 BucketStarts.emplace_back(Bucket, Index); 869 } 870 871 // If there were any buckets with invalid values, skip further checks as they 872 // will likely produce many errors which will only confuse the actual root 873 // problem. 874 if (NumErrors > 0) 875 return NumErrors; 876 877 // Sort the list in the order of increasing "Index" entries. 878 array_pod_sort(BucketStarts.begin(), BucketStarts.end()); 879 880 // Insert a sentinel entry at the end, so we can check that the end of the 881 // table is covered in the loop below. 882 BucketStarts.emplace_back(NI.getBucketCount(), NI.getNameCount() + 1); 883 884 // Loop invariant: NextUncovered is the (1-based) index of the first Name 885 // which is not reachable by any of the buckets we processed so far (and 886 // hasn't been reported as uncovered). 887 uint32_t NextUncovered = 1; 888 for (const BucketInfo &B : BucketStarts) { 889 // Under normal circumstances B.Index be equal to NextUncovered, but it can 890 // be less if a bucket points to names which are already known to be in some 891 // bucket we processed earlier. In that case, we won't trigger this error, 892 // but report the mismatched hash value error instead. (We know the hash 893 // will not match because we have already verified that the name's hash 894 // puts it into the previous bucket.) 895 if (B.Index > NextUncovered) { 896 error() << formatv("Name Index @ {0:x}: Name table entries [{1}, {2}] " 897 "are not covered by the hash table.\n", 898 NI.getUnitOffset(), NextUncovered, B.Index - 1); 899 ++NumErrors; 900 } 901 uint32_t Idx = B.Index; 902 903 // The rest of the checks apply only to non-sentinel entries. 904 if (B.Bucket == NI.getBucketCount()) 905 break; 906 907 // This triggers if a non-empty bucket points to a name with a mismatched 908 // hash. Clients are likely to interpret this as an empty bucket, because a 909 // mismatched hash signals the end of a bucket, but if this is indeed an 910 // empty bucket, the producer should have signalled this by marking the 911 // bucket as empty. 912 uint32_t FirstHash = NI.getHashArrayEntry(Idx); 913 if (FirstHash % NI.getBucketCount() != B.Bucket) { 914 error() << formatv( 915 "Name Index @ {0:x}: Bucket {1} is not empty but points to a " 916 "mismatched hash value {2:x} (belonging to bucket {3}).\n", 917 NI.getUnitOffset(), B.Bucket, FirstHash, 918 FirstHash % NI.getBucketCount()); 919 ++NumErrors; 920 } 921 922 // This find the end of this bucket and also verifies that all the hashes in 923 // this bucket are correct by comparing the stored hashes to the ones we 924 // compute ourselves. 925 while (Idx <= NI.getNameCount()) { 926 uint32_t Hash = NI.getHashArrayEntry(Idx); 927 if (Hash % NI.getBucketCount() != B.Bucket) 928 break; 929 930 const char *Str = NI.getNameTableEntry(Idx).getString(); 931 if (caseFoldingDjbHash(Str) != Hash) { 932 error() << formatv("Name Index @ {0:x}: String ({1}) at index {2} " 933 "hashes to {3:x}, but " 934 "the Name Index hash is {4:x}\n", 935 NI.getUnitOffset(), Str, Idx, 936 caseFoldingDjbHash(Str), Hash); 937 ++NumErrors; 938 } 939 940 ++Idx; 941 } 942 NextUncovered = std::max(NextUncovered, Idx); 943 } 944 return NumErrors; 945 } 946 947 unsigned DWARFVerifier::verifyNameIndexAttribute( 948 const DWARFDebugNames::NameIndex &NI, const DWARFDebugNames::Abbrev &Abbr, 949 DWARFDebugNames::AttributeEncoding AttrEnc) { 950 StringRef FormName = dwarf::FormEncodingString(AttrEnc.Form); 951 if (FormName.empty()) { 952 error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x}: {2} uses an " 953 "unknown form: {3}.\n", 954 NI.getUnitOffset(), Abbr.Code, AttrEnc.Index, 955 AttrEnc.Form); 956 return 1; 957 } 958 959 if (AttrEnc.Index == DW_IDX_type_hash) { 960 if (AttrEnc.Form != dwarf::DW_FORM_data8) { 961 error() << formatv( 962 "NameIndex @ {0:x}: Abbreviation {1:x}: DW_IDX_type_hash " 963 "uses an unexpected form {2} (should be {3}).\n", 964 NI.getUnitOffset(), Abbr.Code, AttrEnc.Form, dwarf::DW_FORM_data8); 965 return 1; 966 } 967 } 968 969 // A list of known index attributes and their expected form classes. 970 // DW_IDX_type_hash is handled specially in the check above, as it has a 971 // specific form (not just a form class) we should expect. 972 struct FormClassTable { 973 dwarf::Index Index; 974 DWARFFormValue::FormClass Class; 975 StringLiteral ClassName; 976 }; 977 static constexpr FormClassTable Table[] = { 978 {dwarf::DW_IDX_compile_unit, DWARFFormValue::FC_Constant, {"constant"}}, 979 {dwarf::DW_IDX_type_unit, DWARFFormValue::FC_Constant, {"constant"}}, 980 {dwarf::DW_IDX_die_offset, DWARFFormValue::FC_Reference, {"reference"}}, 981 {dwarf::DW_IDX_parent, DWARFFormValue::FC_Constant, {"constant"}}, 982 }; 983 984 ArrayRef<FormClassTable> TableRef(Table); 985 auto Iter = find_if(TableRef, [AttrEnc](const FormClassTable &T) { 986 return T.Index == AttrEnc.Index; 987 }); 988 if (Iter == TableRef.end()) { 989 warn() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} contains an " 990 "unknown index attribute: {2}.\n", 991 NI.getUnitOffset(), Abbr.Code, AttrEnc.Index); 992 return 0; 993 } 994 995 if (!DWARFFormValue(AttrEnc.Form).isFormClass(Iter->Class)) { 996 error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x}: {2} uses an " 997 "unexpected form {3} (expected form class {4}).\n", 998 NI.getUnitOffset(), Abbr.Code, AttrEnc.Index, 999 AttrEnc.Form, Iter->ClassName); 1000 return 1; 1001 } 1002 return 0; 1003 } 1004 1005 unsigned 1006 DWARFVerifier::verifyNameIndexAbbrevs(const DWARFDebugNames::NameIndex &NI) { 1007 if (NI.getLocalTUCount() + NI.getForeignTUCount() > 0) { 1008 warn() << formatv("Name Index @ {0:x}: Verifying indexes of type units is " 1009 "not currently supported.\n", 1010 NI.getUnitOffset()); 1011 return 0; 1012 } 1013 1014 unsigned NumErrors = 0; 1015 for (const auto &Abbrev : NI.getAbbrevs()) { 1016 StringRef TagName = dwarf::TagString(Abbrev.Tag); 1017 if (TagName.empty()) { 1018 warn() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} references an " 1019 "unknown tag: {2}.\n", 1020 NI.getUnitOffset(), Abbrev.Code, Abbrev.Tag); 1021 } 1022 SmallSet<unsigned, 5> Attributes; 1023 for (const auto &AttrEnc : Abbrev.Attributes) { 1024 if (!Attributes.insert(AttrEnc.Index).second) { 1025 error() << formatv("NameIndex @ {0:x}: Abbreviation {1:x} contains " 1026 "multiple {2} attributes.\n", 1027 NI.getUnitOffset(), Abbrev.Code, AttrEnc.Index); 1028 ++NumErrors; 1029 continue; 1030 } 1031 NumErrors += verifyNameIndexAttribute(NI, Abbrev, AttrEnc); 1032 } 1033 1034 if (NI.getCUCount() > 1 && !Attributes.count(dwarf::DW_IDX_compile_unit)) { 1035 error() << formatv("NameIndex @ {0:x}: Indexing multiple compile units " 1036 "and abbreviation {1:x} has no {2} attribute.\n", 1037 NI.getUnitOffset(), Abbrev.Code, 1038 dwarf::DW_IDX_compile_unit); 1039 ++NumErrors; 1040 } 1041 if (!Attributes.count(dwarf::DW_IDX_die_offset)) { 1042 error() << formatv( 1043 "NameIndex @ {0:x}: Abbreviation {1:x} has no {2} attribute.\n", 1044 NI.getUnitOffset(), Abbrev.Code, dwarf::DW_IDX_die_offset); 1045 ++NumErrors; 1046 } 1047 } 1048 return NumErrors; 1049 } 1050 1051 static SmallVector<StringRef, 2> getNames(const DWARFDie &DIE) { 1052 SmallVector<StringRef, 2> Result; 1053 if (const char *Str = DIE.getName(DINameKind::ShortName)) 1054 Result.emplace_back(Str); 1055 else if (DIE.getTag() == dwarf::DW_TAG_namespace) 1056 Result.emplace_back("(anonymous namespace)"); 1057 1058 if (const char *Str = DIE.getName(DINameKind::LinkageName)) { 1059 if (Result.empty() || Result[0] != Str) 1060 Result.emplace_back(Str); 1061 } 1062 1063 return Result; 1064 } 1065 1066 unsigned DWARFVerifier::verifyNameIndexEntries( 1067 const DWARFDebugNames::NameIndex &NI, 1068 const DWARFDebugNames::NameTableEntry &NTE) { 1069 // Verifying type unit indexes not supported. 1070 if (NI.getLocalTUCount() + NI.getForeignTUCount() > 0) 1071 return 0; 1072 1073 const char *CStr = NTE.getString(); 1074 if (!CStr) { 1075 error() << formatv( 1076 "Name Index @ {0:x}: Unable to get string associated with name {1}.\n", 1077 NI.getUnitOffset(), NTE.getIndex()); 1078 return 1; 1079 } 1080 StringRef Str(CStr); 1081 1082 unsigned NumErrors = 0; 1083 unsigned NumEntries = 0; 1084 uint32_t EntryID = NTE.getEntryOffset(); 1085 uint32_t NextEntryID = EntryID; 1086 Expected<DWARFDebugNames::Entry> EntryOr = NI.getEntry(&NextEntryID); 1087 for (; EntryOr; ++NumEntries, EntryID = NextEntryID, 1088 EntryOr = NI.getEntry(&NextEntryID)) { 1089 uint32_t CUIndex = *EntryOr->getCUIndex(); 1090 if (CUIndex > NI.getCUCount()) { 1091 error() << formatv("Name Index @ {0:x}: Entry @ {1:x} contains an " 1092 "invalid CU index ({2}).\n", 1093 NI.getUnitOffset(), EntryID, CUIndex); 1094 ++NumErrors; 1095 continue; 1096 } 1097 uint32_t CUOffset = NI.getCUOffset(CUIndex); 1098 uint64_t DIEOffset = CUOffset + *EntryOr->getDIEUnitOffset(); 1099 DWARFDie DIE = DCtx.getDIEForOffset(DIEOffset); 1100 if (!DIE) { 1101 error() << formatv("Name Index @ {0:x}: Entry @ {1:x} references a " 1102 "non-existing DIE @ {2:x}.\n", 1103 NI.getUnitOffset(), EntryID, DIEOffset); 1104 ++NumErrors; 1105 continue; 1106 } 1107 if (DIE.getDwarfUnit()->getOffset() != CUOffset) { 1108 error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched CU of " 1109 "DIE @ {2:x}: index - {3:x}; debug_info - {4:x}.\n", 1110 NI.getUnitOffset(), EntryID, DIEOffset, CUOffset, 1111 DIE.getDwarfUnit()->getOffset()); 1112 ++NumErrors; 1113 } 1114 if (DIE.getTag() != EntryOr->tag()) { 1115 error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched Tag of " 1116 "DIE @ {2:x}: index - {3}; debug_info - {4}.\n", 1117 NI.getUnitOffset(), EntryID, DIEOffset, EntryOr->tag(), 1118 DIE.getTag()); 1119 ++NumErrors; 1120 } 1121 1122 auto EntryNames = getNames(DIE); 1123 if (!is_contained(EntryNames, Str)) { 1124 error() << formatv("Name Index @ {0:x}: Entry @ {1:x}: mismatched Name " 1125 "of DIE @ {2:x}: index - {3}; debug_info - {4}.\n", 1126 NI.getUnitOffset(), EntryID, DIEOffset, Str, 1127 make_range(EntryNames.begin(), EntryNames.end())); 1128 ++NumErrors; 1129 } 1130 } 1131 handleAllErrors(EntryOr.takeError(), 1132 [&](const DWARFDebugNames::SentinelError &) { 1133 if (NumEntries > 0) 1134 return; 1135 error() << formatv("Name Index @ {0:x}: Name {1} ({2}) is " 1136 "not associated with any entries.\n", 1137 NI.getUnitOffset(), NTE.getIndex(), Str); 1138 ++NumErrors; 1139 }, 1140 [&](const ErrorInfoBase &Info) { 1141 error() 1142 << formatv("Name Index @ {0:x}: Name {1} ({2}): {3}\n", 1143 NI.getUnitOffset(), NTE.getIndex(), Str, 1144 Info.message()); 1145 ++NumErrors; 1146 }); 1147 return NumErrors; 1148 } 1149 1150 static bool isVariableIndexable(const DWARFDie &Die, DWARFContext &DCtx) { 1151 Optional<DWARFFormValue> Location = Die.findRecursively(DW_AT_location); 1152 if (!Location) 1153 return false; 1154 1155 auto ContainsInterestingOperators = [&](StringRef D) { 1156 DWARFUnit *U = Die.getDwarfUnit(); 1157 DataExtractor Data(D, DCtx.isLittleEndian(), U->getAddressByteSize()); 1158 DWARFExpression Expression(Data, U->getVersion(), U->getAddressByteSize()); 1159 return any_of(Expression, [](DWARFExpression::Operation &Op) { 1160 return !Op.isError() && (Op.getCode() == DW_OP_addr || 1161 Op.getCode() == DW_OP_form_tls_address || 1162 Op.getCode() == DW_OP_GNU_push_tls_address); 1163 }); 1164 }; 1165 1166 if (Optional<ArrayRef<uint8_t>> Expr = Location->getAsBlock()) { 1167 // Inlined location. 1168 if (ContainsInterestingOperators(toStringRef(*Expr))) 1169 return true; 1170 } else if (Optional<uint64_t> Offset = Location->getAsSectionOffset()) { 1171 // Location list. 1172 if (const DWARFDebugLoc *DebugLoc = DCtx.getDebugLoc()) { 1173 if (const DWARFDebugLoc::LocationList *LocList = 1174 DebugLoc->getLocationListAtOffset(*Offset)) { 1175 if (any_of(LocList->Entries, [&](const DWARFDebugLoc::Entry &E) { 1176 return ContainsInterestingOperators({E.Loc.data(), E.Loc.size()}); 1177 })) 1178 return true; 1179 } 1180 } 1181 } 1182 return false; 1183 } 1184 1185 unsigned DWARFVerifier::verifyNameIndexCompleteness( 1186 const DWARFDie &Die, const DWARFDebugNames::NameIndex &NI) { 1187 1188 // First check, if the Die should be indexed. The code follows the DWARF v5 1189 // wording as closely as possible. 1190 1191 // "All non-defining declarations (that is, debugging information entries 1192 // with a DW_AT_declaration attribute) are excluded." 1193 if (Die.find(DW_AT_declaration)) 1194 return 0; 1195 1196 // "DW_TAG_namespace debugging information entries without a DW_AT_name 1197 // attribute are included with the name (anonymous namespace). 1198 // All other debugging information entries without a DW_AT_name attribute 1199 // are excluded." 1200 // "If a subprogram or inlined subroutine is included, and has a 1201 // DW_AT_linkage_name attribute, there will be an additional index entry for 1202 // the linkage name." 1203 auto EntryNames = getNames(Die); 1204 if (EntryNames.empty()) 1205 return 0; 1206 1207 // We deviate from the specification here, which says: 1208 // "The name index must contain an entry for each debugging information entry 1209 // that defines a named subprogram, label, variable, type, or namespace, 1210 // subject to ..." 1211 // Instead whitelisting all TAGs representing a "type" or a "subprogram", to 1212 // make sure we catch any missing items, we instead blacklist all TAGs that we 1213 // know shouldn't be indexed. 1214 switch (Die.getTag()) { 1215 // Compile unit has a name but it shouldn't be indexed. 1216 case DW_TAG_compile_unit: 1217 return 0; 1218 1219 // Function and template parameters are not globally visible, so we shouldn't 1220 // index them. 1221 case DW_TAG_formal_parameter: 1222 case DW_TAG_template_value_parameter: 1223 case DW_TAG_template_type_parameter: 1224 case DW_TAG_GNU_template_parameter_pack: 1225 case DW_TAG_GNU_template_template_param: 1226 return 0; 1227 1228 // Object members aren't globally visible. 1229 case DW_TAG_member: 1230 return 0; 1231 1232 // According to a strict reading of the specification, enumerators should not 1233 // be indexed (and LLVM currently does not do that). However, this causes 1234 // problems for the debuggers, so we may need to reconsider this. 1235 case DW_TAG_enumerator: 1236 return 0; 1237 1238 // Imported declarations should not be indexed according to the specification 1239 // and LLVM currently does not do that. 1240 case DW_TAG_imported_declaration: 1241 return 0; 1242 1243 // "DW_TAG_subprogram, DW_TAG_inlined_subroutine, and DW_TAG_label debugging 1244 // information entries without an address attribute (DW_AT_low_pc, 1245 // DW_AT_high_pc, DW_AT_ranges, or DW_AT_entry_pc) are excluded." 1246 case DW_TAG_subprogram: 1247 case DW_TAG_inlined_subroutine: 1248 case DW_TAG_label: 1249 if (Die.findRecursively( 1250 {DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_entry_pc})) 1251 break; 1252 return 0; 1253 1254 // "DW_TAG_variable debugging information entries with a DW_AT_location 1255 // attribute that includes a DW_OP_addr or DW_OP_form_tls_address operator are 1256 // included; otherwise, they are excluded." 1257 // 1258 // LLVM extension: We also add DW_OP_GNU_push_tls_address to this list. 1259 case DW_TAG_variable: 1260 if (isVariableIndexable(Die, DCtx)) 1261 break; 1262 return 0; 1263 1264 default: 1265 break; 1266 } 1267 1268 // Now we know that our Die should be present in the Index. Let's check if 1269 // that's the case. 1270 unsigned NumErrors = 0; 1271 uint64_t DieUnitOffset = Die.getOffset() - Die.getDwarfUnit()->getOffset(); 1272 for (StringRef Name : EntryNames) { 1273 if (none_of(NI.equal_range(Name), [&](const DWARFDebugNames::Entry &E) { 1274 return E.getDIEUnitOffset() == DieUnitOffset; 1275 })) { 1276 error() << formatv("Name Index @ {0:x}: Entry for DIE @ {1:x} ({2}) with " 1277 "name {3} missing.\n", 1278 NI.getUnitOffset(), Die.getOffset(), Die.getTag(), 1279 Name); 1280 ++NumErrors; 1281 } 1282 } 1283 return NumErrors; 1284 } 1285 1286 unsigned DWARFVerifier::verifyDebugNames(const DWARFSection &AccelSection, 1287 const DataExtractor &StrData) { 1288 unsigned NumErrors = 0; 1289 DWARFDataExtractor AccelSectionData(DCtx.getDWARFObj(), AccelSection, 1290 DCtx.isLittleEndian(), 0); 1291 DWARFDebugNames AccelTable(AccelSectionData, StrData); 1292 1293 OS << "Verifying .debug_names...\n"; 1294 1295 // This verifies that we can read individual name indices and their 1296 // abbreviation tables. 1297 if (Error E = AccelTable.extract()) { 1298 error() << toString(std::move(E)) << '\n'; 1299 return 1; 1300 } 1301 1302 NumErrors += verifyDebugNamesCULists(AccelTable); 1303 for (const auto &NI : AccelTable) 1304 NumErrors += verifyNameIndexBuckets(NI, StrData); 1305 for (const auto &NI : AccelTable) 1306 NumErrors += verifyNameIndexAbbrevs(NI); 1307 1308 // Don't attempt Entry validation if any of the previous checks found errors 1309 if (NumErrors > 0) 1310 return NumErrors; 1311 for (const auto &NI : AccelTable) 1312 for (DWARFDebugNames::NameTableEntry NTE : NI) 1313 NumErrors += verifyNameIndexEntries(NI, NTE); 1314 1315 if (NumErrors > 0) 1316 return NumErrors; 1317 1318 for (const std::unique_ptr<DWARFCompileUnit> &CU : DCtx.compile_units()) { 1319 if (const DWARFDebugNames::NameIndex *NI = 1320 AccelTable.getCUNameIndex(CU->getOffset())) { 1321 for (const DWARFDebugInfoEntry &Die : CU->dies()) 1322 NumErrors += verifyNameIndexCompleteness(DWARFDie(CU.get(), &Die), *NI); 1323 } 1324 } 1325 return NumErrors; 1326 } 1327 1328 bool DWARFVerifier::handleAccelTables() { 1329 const DWARFObject &D = DCtx.getDWARFObj(); 1330 DataExtractor StrData(D.getStringSection(), DCtx.isLittleEndian(), 0); 1331 unsigned NumErrors = 0; 1332 if (!D.getAppleNamesSection().Data.empty()) 1333 NumErrors += 1334 verifyAppleAccelTable(&D.getAppleNamesSection(), &StrData, ".apple_names"); 1335 if (!D.getAppleTypesSection().Data.empty()) 1336 NumErrors += 1337 verifyAppleAccelTable(&D.getAppleTypesSection(), &StrData, ".apple_types"); 1338 if (!D.getAppleNamespacesSection().Data.empty()) 1339 NumErrors += verifyAppleAccelTable(&D.getAppleNamespacesSection(), &StrData, 1340 ".apple_namespaces"); 1341 if (!D.getAppleObjCSection().Data.empty()) 1342 NumErrors += 1343 verifyAppleAccelTable(&D.getAppleObjCSection(), &StrData, ".apple_objc"); 1344 1345 if (!D.getDebugNamesSection().Data.empty()) 1346 NumErrors += verifyDebugNames(D.getDebugNamesSection(), StrData); 1347 return NumErrors == 0; 1348 } 1349 1350 raw_ostream &DWARFVerifier::error() const { return WithColor::error(OS); } 1351 1352 raw_ostream &DWARFVerifier::warn() const { return WithColor::warning(OS); } 1353 1354 raw_ostream &DWARFVerifier::note() const { return WithColor::note(OS); } 1355
