1 //===- DWARFContext.cpp ---------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/DebugInfo/DWARF/DWARFContext.h" 10 #include "llvm/ADT/MapVector.h" 11 #include "llvm/ADT/STLExtras.h" 12 #include "llvm/ADT/SmallString.h" 13 #include "llvm/ADT/SmallVector.h" 14 #include "llvm/ADT/StringRef.h" 15 #include "llvm/ADT/StringSwitch.h" 16 #include "llvm/BinaryFormat/Dwarf.h" 17 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h" 18 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h" 19 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h" 20 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h" 21 #include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h" 22 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h" 23 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h" 24 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h" 25 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h" 26 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h" 27 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h" 28 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h" 29 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h" 30 #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h" 31 #include "llvm/DebugInfo/DWARF/DWARFDie.h" 32 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h" 33 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h" 34 #include "llvm/DebugInfo/DWARF/DWARFListTable.h" 35 #include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h" 36 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h" 37 #include "llvm/DebugInfo/DWARF/DWARFSection.h" 38 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h" 39 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h" 40 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h" 41 #include "llvm/MC/TargetRegistry.h" 42 #include "llvm/Object/Decompressor.h" 43 #include "llvm/Object/MachO.h" 44 #include "llvm/Object/ObjectFile.h" 45 #include "llvm/Object/RelocationResolver.h" 46 #include "llvm/Support/Casting.h" 47 #include "llvm/Support/DataExtractor.h" 48 #include "llvm/Support/Error.h" 49 #include "llvm/Support/Format.h" 50 #include "llvm/Support/LEB128.h" 51 #include "llvm/Support/FormatVariadic.h" 52 #include "llvm/Support/MemoryBuffer.h" 53 #include "llvm/Support/Path.h" 54 #include "llvm/Support/raw_ostream.h" 55 #include <algorithm> 56 #include <cstdint> 57 #include <deque> 58 #include <map> 59 #include <string> 60 #include <utility> 61 #include <vector> 62 63 using namespace llvm; 64 using namespace dwarf; 65 using namespace object; 66 67 #define DEBUG_TYPE "dwarf" 68 69 using DWARFLineTable = DWARFDebugLine::LineTable; 70 using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind; 71 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind; 72 73 74 void fixupIndexV4(DWARFContext &C, DWARFUnitIndex &Index) { 75 using EntryType = DWARFUnitIndex::Entry::SectionContribution; 76 using EntryMap = DenseMap<uint32_t, EntryType>; 77 EntryMap Map; 78 const auto &DObj = C.getDWARFObj(); 79 if (DObj.getCUIndexSection().empty()) 80 return; 81 82 uint64_t Offset = 0; 83 uint32_t TruncOffset = 0; 84 DObj.forEachInfoDWOSections([&](const DWARFSection &S) { 85 if (!(C.getParseCUTUIndexManually() || 86 S.Data.size() >= std::numeric_limits<uint32_t>::max())) 87 return; 88 89 DWARFDataExtractor Data(DObj, S, C.isLittleEndian(), 0); 90 while (Data.isValidOffset(Offset)) { 91 DWARFUnitHeader Header; 92 if (Error ExtractionErr = Header.extract( 93 C, Data, &Offset, DWARFSectionKind::DW_SECT_INFO)) { 94 C.getWarningHandler()( 95 createError("Failed to parse CU header in DWP file: " + 96 toString(std::move(ExtractionErr)))); 97 Map.clear(); 98 break; 99 } 100 101 auto Iter = Map.insert({TruncOffset, 102 {Header.getOffset(), Header.getNextUnitOffset() - 103 Header.getOffset()}}); 104 if (!Iter.second) { 105 logAllUnhandledErrors( 106 createError("Collision occured between for truncated offset 0x" + 107 Twine::utohexstr(TruncOffset)), 108 errs()); 109 Map.clear(); 110 return; 111 } 112 113 Offset = Header.getNextUnitOffset(); 114 TruncOffset = Offset; 115 } 116 }); 117 118 if (Map.empty()) 119 return; 120 121 for (DWARFUnitIndex::Entry &E : Index.getMutableRows()) { 122 if (!E.isValid()) 123 continue; 124 DWARFUnitIndex::Entry::SectionContribution &CUOff = E.getContribution(); 125 auto Iter = Map.find(CUOff.getOffset()); 126 if (Iter == Map.end()) { 127 logAllUnhandledErrors(createError("Could not find CU offset 0x" + 128 Twine::utohexstr(CUOff.getOffset()) + 129 " in the Map"), 130 errs()); 131 break; 132 } 133 CUOff.setOffset(Iter->second.getOffset()); 134 if (CUOff.getOffset() != Iter->second.getOffset()) 135 logAllUnhandledErrors(createError("Length of CU in CU index doesn't " 136 "match calculated length at offset 0x" + 137 Twine::utohexstr(CUOff.getOffset())), 138 errs()); 139 } 140 } 141 142 void fixupIndexV5(DWARFContext &C, DWARFUnitIndex &Index) { 143 DenseMap<uint64_t, uint64_t> Map; 144 145 const auto &DObj = C.getDWARFObj(); 146 DObj.forEachInfoDWOSections([&](const DWARFSection &S) { 147 if (!(C.getParseCUTUIndexManually() || 148 S.Data.size() >= std::numeric_limits<uint32_t>::max())) 149 return; 150 DWARFDataExtractor Data(DObj, S, C.isLittleEndian(), 0); 151 uint64_t Offset = 0; 152 while (Data.isValidOffset(Offset)) { 153 DWARFUnitHeader Header; 154 if (Error ExtractionErr = Header.extract( 155 C, Data, &Offset, DWARFSectionKind::DW_SECT_INFO)) { 156 C.getWarningHandler()( 157 createError("Failed to parse CU header in DWP file: " + 158 toString(std::move(ExtractionErr)))); 159 break; 160 } 161 bool CU = Header.getUnitType() == DW_UT_split_compile; 162 uint64_t Sig = CU ? *Header.getDWOId() : Header.getTypeHash(); 163 Map[Sig] = Header.getOffset(); 164 Offset = Header.getNextUnitOffset(); 165 } 166 }); 167 if (Map.empty()) 168 return; 169 for (DWARFUnitIndex::Entry &E : Index.getMutableRows()) { 170 if (!E.isValid()) 171 continue; 172 DWARFUnitIndex::Entry::SectionContribution &CUOff = E.getContribution(); 173 auto Iter = Map.find(E.getSignature()); 174 if (Iter == Map.end()) { 175 logAllUnhandledErrors( 176 createError("Could not find unit with signature 0x" + 177 Twine::utohexstr(E.getSignature()) + " in the Map"), 178 errs()); 179 break; 180 } 181 CUOff.setOffset(Iter->second); 182 } 183 } 184 185 void fixupIndex(DWARFContext &C, DWARFUnitIndex &Index) { 186 if (Index.getVersion() < 5) 187 fixupIndexV4(C, Index); 188 else 189 fixupIndexV5(C, Index); 190 } 191 192 template <typename T> 193 static T &getAccelTable(std::unique_ptr<T> &Cache, const DWARFObject &Obj, 194 const DWARFSection &Section, StringRef StringSection, 195 bool IsLittleEndian) { 196 if (Cache) 197 return *Cache; 198 DWARFDataExtractor AccelSection(Obj, Section, IsLittleEndian, 0); 199 DataExtractor StrData(StringSection, IsLittleEndian, 0); 200 Cache = std::make_unique<T>(AccelSection, StrData); 201 if (Error E = Cache->extract()) 202 llvm::consumeError(std::move(E)); 203 return *Cache; 204 } 205 206 207 std::unique_ptr<DWARFDebugMacro> 208 DWARFContext::DWARFContextState::parseMacroOrMacinfo(MacroSecType SectionType) { 209 auto Macro = std::make_unique<DWARFDebugMacro>(); 210 auto ParseAndDump = [&](DWARFDataExtractor &Data, bool IsMacro) { 211 if (Error Err = IsMacro ? Macro->parseMacro(SectionType == MacroSection 212 ? D.compile_units() 213 : D.dwo_compile_units(), 214 SectionType == MacroSection 215 ? D.getStringExtractor() 216 : D.getStringDWOExtractor(), 217 Data) 218 : Macro->parseMacinfo(Data)) { 219 D.getRecoverableErrorHandler()(std::move(Err)); 220 Macro = nullptr; 221 } 222 }; 223 const DWARFObject &DObj = D.getDWARFObj(); 224 switch (SectionType) { 225 case MacinfoSection: { 226 DWARFDataExtractor Data(DObj.getMacinfoSection(), D.isLittleEndian(), 0); 227 ParseAndDump(Data, /*IsMacro=*/false); 228 break; 229 } 230 case MacinfoDwoSection: { 231 DWARFDataExtractor Data(DObj.getMacinfoDWOSection(), D.isLittleEndian(), 0); 232 ParseAndDump(Data, /*IsMacro=*/false); 233 break; 234 } 235 case MacroSection: { 236 DWARFDataExtractor Data(DObj, DObj.getMacroSection(), D.isLittleEndian(), 237 0); 238 ParseAndDump(Data, /*IsMacro=*/true); 239 break; 240 } 241 case MacroDwoSection: { 242 DWARFDataExtractor Data(DObj.getMacroDWOSection(), D.isLittleEndian(), 0); 243 ParseAndDump(Data, /*IsMacro=*/true); 244 break; 245 } 246 } 247 return Macro; 248 } 249 250 class ThreadUnsafeDWARFContextState : public DWARFContext::DWARFContextState { 251 252 DWARFUnitVector NormalUnits; 253 std::optional<DenseMap<uint64_t, DWARFTypeUnit *>> NormalTypeUnits; 254 std::unique_ptr<DWARFUnitIndex> CUIndex; 255 std::unique_ptr<DWARFGdbIndex> GdbIndex; 256 std::unique_ptr<DWARFUnitIndex> TUIndex; 257 std::unique_ptr<DWARFDebugAbbrev> Abbrev; 258 std::unique_ptr<DWARFDebugLoc> Loc; 259 std::unique_ptr<DWARFDebugAranges> Aranges; 260 std::unique_ptr<DWARFDebugLine> Line; 261 std::unique_ptr<DWARFDebugFrame> DebugFrame; 262 std::unique_ptr<DWARFDebugFrame> EHFrame; 263 std::unique_ptr<DWARFDebugMacro> Macro; 264 std::unique_ptr<DWARFDebugMacro> Macinfo; 265 std::unique_ptr<DWARFDebugNames> Names; 266 std::unique_ptr<AppleAcceleratorTable> AppleNames; 267 std::unique_ptr<AppleAcceleratorTable> AppleTypes; 268 std::unique_ptr<AppleAcceleratorTable> AppleNamespaces; 269 std::unique_ptr<AppleAcceleratorTable> AppleObjC; 270 DWARFUnitVector DWOUnits; 271 std::optional<DenseMap<uint64_t, DWARFTypeUnit *>> DWOTypeUnits; 272 std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO; 273 std::unique_ptr<DWARFDebugMacro> MacinfoDWO; 274 std::unique_ptr<DWARFDebugMacro> MacroDWO; 275 struct DWOFile { 276 object::OwningBinary<object::ObjectFile> File; 277 std::unique_ptr<DWARFContext> Context; 278 }; 279 StringMap<std::weak_ptr<DWOFile>> DWOFiles; 280 std::weak_ptr<DWOFile> DWP; 281 bool CheckedForDWP = false; 282 std::string DWPName; 283 284 public: 285 ThreadUnsafeDWARFContextState(DWARFContext &DC, std::string &DWP) : 286 DWARFContext::DWARFContextState(DC), 287 DWPName(std::move(DWP)) {} 288 289 DWARFUnitVector &getNormalUnits() override { 290 if (NormalUnits.empty()) { 291 const DWARFObject &DObj = D.getDWARFObj(); 292 DObj.forEachInfoSections([&](const DWARFSection &S) { 293 NormalUnits.addUnitsForSection(D, S, DW_SECT_INFO); 294 }); 295 NormalUnits.finishedInfoUnits(); 296 DObj.forEachTypesSections([&](const DWARFSection &S) { 297 NormalUnits.addUnitsForSection(D, S, DW_SECT_EXT_TYPES); 298 }); 299 } 300 return NormalUnits; 301 } 302 303 DWARFUnitVector &getDWOUnits(bool Lazy) override { 304 if (DWOUnits.empty()) { 305 const DWARFObject &DObj = D.getDWARFObj(); 306 307 DObj.forEachInfoDWOSections([&](const DWARFSection &S) { 308 DWOUnits.addUnitsForDWOSection(D, S, DW_SECT_INFO, Lazy); 309 }); 310 DWOUnits.finishedInfoUnits(); 311 DObj.forEachTypesDWOSections([&](const DWARFSection &S) { 312 DWOUnits.addUnitsForDWOSection(D, S, DW_SECT_EXT_TYPES, Lazy); 313 }); 314 } 315 return DWOUnits; 316 } 317 318 const DWARFDebugAbbrev *getDebugAbbrevDWO() override { 319 if (AbbrevDWO) 320 return AbbrevDWO.get(); 321 const DWARFObject &DObj = D.getDWARFObj(); 322 DataExtractor abbrData(DObj.getAbbrevDWOSection(), D.isLittleEndian(), 0); 323 AbbrevDWO = std::make_unique<DWARFDebugAbbrev>(abbrData); 324 return AbbrevDWO.get(); 325 } 326 327 const DWARFUnitIndex &getCUIndex() override { 328 if (CUIndex) 329 return *CUIndex; 330 331 DataExtractor Data(D.getDWARFObj().getCUIndexSection(), 332 D.isLittleEndian(), 0); 333 CUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_INFO); 334 if (CUIndex->parse(Data)) 335 fixupIndex(D, *CUIndex); 336 return *CUIndex; 337 } 338 const DWARFUnitIndex &getTUIndex() override { 339 if (TUIndex) 340 return *TUIndex; 341 342 DataExtractor Data(D.getDWARFObj().getTUIndexSection(), 343 D.isLittleEndian(), 0); 344 TUIndex = std::make_unique<DWARFUnitIndex>(DW_SECT_EXT_TYPES); 345 bool isParseSuccessful = TUIndex->parse(Data); 346 // If we are parsing TU-index and for .debug_types section we don't need 347 // to do anything. 348 if (isParseSuccessful && TUIndex->getVersion() != 2) 349 fixupIndex(D, *TUIndex); 350 return *TUIndex; 351 } 352 353 DWARFGdbIndex &getGdbIndex() override { 354 if (GdbIndex) 355 return *GdbIndex; 356 357 DataExtractor Data(D.getDWARFObj().getGdbIndexSection(), true /*LE*/, 0); 358 GdbIndex = std::make_unique<DWARFGdbIndex>(); 359 GdbIndex->parse(Data); 360 return *GdbIndex; 361 } 362 363 const DWARFDebugAbbrev *getDebugAbbrev() override { 364 if (Abbrev) 365 return Abbrev.get(); 366 367 DataExtractor Data(D.getDWARFObj().getAbbrevSection(), 368 D.isLittleEndian(), 0); 369 Abbrev = std::make_unique<DWARFDebugAbbrev>(Data); 370 return Abbrev.get(); 371 } 372 373 const DWARFDebugLoc *getDebugLoc() override { 374 if (Loc) 375 return Loc.get(); 376 377 const DWARFObject &DObj = D.getDWARFObj(); 378 // Assume all units have the same address byte size. 379 auto Data = 380 D.getNumCompileUnits() 381 ? DWARFDataExtractor(DObj, DObj.getLocSection(), D.isLittleEndian(), 382 D.getUnitAtIndex(0)->getAddressByteSize()) 383 : DWARFDataExtractor("", D.isLittleEndian(), 0); 384 Loc = std::make_unique<DWARFDebugLoc>(std::move(Data)); 385 return Loc.get(); 386 } 387 388 const DWARFDebugAranges *getDebugAranges() override { 389 if (Aranges) 390 return Aranges.get(); 391 392 Aranges = std::make_unique<DWARFDebugAranges>(); 393 Aranges->generate(&D); 394 return Aranges.get(); 395 } 396 397 Expected<const DWARFDebugLine::LineTable *> 398 getLineTableForUnit(DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) override { 399 if (!Line) 400 Line = std::make_unique<DWARFDebugLine>(); 401 402 auto UnitDIE = U->getUnitDIE(); 403 if (!UnitDIE) 404 return nullptr; 405 406 auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list)); 407 if (!Offset) 408 return nullptr; // No line table for this compile unit. 409 410 uint64_t stmtOffset = *Offset + U->getLineTableOffset(); 411 // See if the line table is cached. 412 if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset)) 413 return lt; 414 415 // Make sure the offset is good before we try to parse. 416 if (stmtOffset >= U->getLineSection().Data.size()) 417 return nullptr; 418 419 // We have to parse it first. 420 DWARFDataExtractor Data(U->getContext().getDWARFObj(), U->getLineSection(), 421 U->isLittleEndian(), U->getAddressByteSize()); 422 return Line->getOrParseLineTable(Data, stmtOffset, U->getContext(), U, 423 RecoverableErrorHandler); 424 425 } 426 427 void clearLineTableForUnit(DWARFUnit *U) override { 428 if (!Line) 429 return; 430 431 auto UnitDIE = U->getUnitDIE(); 432 if (!UnitDIE) 433 return; 434 435 auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list)); 436 if (!Offset) 437 return; 438 439 uint64_t stmtOffset = *Offset + U->getLineTableOffset(); 440 Line->clearLineTable(stmtOffset); 441 } 442 443 Expected<const DWARFDebugFrame *> getDebugFrame() override { 444 if (DebugFrame) 445 return DebugFrame.get(); 446 const DWARFObject &DObj = D.getDWARFObj(); 447 const DWARFSection &DS = DObj.getFrameSection(); 448 449 // There's a "bug" in the DWARFv3 standard with respect to the target address 450 // size within debug frame sections. While DWARF is supposed to be independent 451 // of its container, FDEs have fields with size being "target address size", 452 // which isn't specified in DWARF in general. It's only specified for CUs, but 453 // .eh_frame can appear without a .debug_info section. Follow the example of 454 // other tools (libdwarf) and extract this from the container (ObjectFile 455 // provides this information). This problem is fixed in DWARFv4 456 // See this dwarf-discuss discussion for more details: 457 // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html 458 DWARFDataExtractor Data(DObj, DS, D.isLittleEndian(), 459 DObj.getAddressSize()); 460 auto DF = 461 std::make_unique<DWARFDebugFrame>(D.getArch(), /*IsEH=*/false, 462 DS.Address); 463 if (Error E = DF->parse(Data)) 464 return std::move(E); 465 466 DebugFrame.swap(DF); 467 return DebugFrame.get(); 468 } 469 470 Expected<const DWARFDebugFrame *> getEHFrame() override { 471 if (EHFrame) 472 return EHFrame.get(); 473 const DWARFObject &DObj = D.getDWARFObj(); 474 475 const DWARFSection &DS = DObj.getEHFrameSection(); 476 DWARFDataExtractor Data(DObj, DS, D.isLittleEndian(), 477 DObj.getAddressSize()); 478 auto DF = 479 std::make_unique<DWARFDebugFrame>(D.getArch(), /*IsEH=*/true, 480 DS.Address); 481 if (Error E = DF->parse(Data)) 482 return std::move(E); 483 EHFrame.swap(DF); 484 return EHFrame.get(); 485 } 486 487 const DWARFDebugMacro *getDebugMacinfo() override { 488 if (!Macinfo) 489 Macinfo = parseMacroOrMacinfo(MacinfoSection); 490 return Macinfo.get(); 491 } 492 const DWARFDebugMacro *getDebugMacinfoDWO() override { 493 if (!MacinfoDWO) 494 MacinfoDWO = parseMacroOrMacinfo(MacinfoDwoSection); 495 return MacinfoDWO.get(); 496 } 497 const DWARFDebugMacro *getDebugMacro() override { 498 if (!Macro) 499 Macro = parseMacroOrMacinfo(MacroSection); 500 return Macro.get(); 501 } 502 const DWARFDebugMacro *getDebugMacroDWO() override { 503 if (!MacroDWO) 504 MacroDWO = parseMacroOrMacinfo(MacroDwoSection); 505 return MacroDWO.get(); 506 } 507 const DWARFDebugNames &getDebugNames() override { 508 const DWARFObject &DObj = D.getDWARFObj(); 509 return getAccelTable(Names, DObj, DObj.getNamesSection(), 510 DObj.getStrSection(), D.isLittleEndian()); 511 } 512 const AppleAcceleratorTable &getAppleNames() override { 513 const DWARFObject &DObj = D.getDWARFObj(); 514 return getAccelTable(AppleNames, DObj, DObj.getAppleNamesSection(), 515 DObj.getStrSection(), D.isLittleEndian()); 516 517 } 518 const AppleAcceleratorTable &getAppleTypes() override { 519 const DWARFObject &DObj = D.getDWARFObj(); 520 return getAccelTable(AppleTypes, DObj, DObj.getAppleTypesSection(), 521 DObj.getStrSection(), D.isLittleEndian()); 522 523 } 524 const AppleAcceleratorTable &getAppleNamespaces() override { 525 const DWARFObject &DObj = D.getDWARFObj(); 526 return getAccelTable(AppleNamespaces, DObj, 527 DObj.getAppleNamespacesSection(), 528 DObj.getStrSection(), D.isLittleEndian()); 529 530 } 531 const AppleAcceleratorTable &getAppleObjC() override { 532 const DWARFObject &DObj = D.getDWARFObj(); 533 return getAccelTable(AppleObjC, DObj, DObj.getAppleObjCSection(), 534 DObj.getStrSection(), D.isLittleEndian()); 535 } 536 537 std::shared_ptr<DWARFContext> 538 getDWOContext(StringRef AbsolutePath) override { 539 if (auto S = DWP.lock()) { 540 DWARFContext *Ctxt = S->Context.get(); 541 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt); 542 } 543 544 std::weak_ptr<DWOFile> *Entry = &DWOFiles[AbsolutePath]; 545 546 if (auto S = Entry->lock()) { 547 DWARFContext *Ctxt = S->Context.get(); 548 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt); 549 } 550 551 const DWARFObject &DObj = D.getDWARFObj(); 552 553 Expected<OwningBinary<ObjectFile>> Obj = [&] { 554 if (!CheckedForDWP) { 555 SmallString<128> DWPName; 556 auto Obj = object::ObjectFile::createObjectFile( 557 this->DWPName.empty() 558 ? (DObj.getFileName() + ".dwp").toStringRef(DWPName) 559 : StringRef(this->DWPName)); 560 if (Obj) { 561 Entry = &DWP; 562 return Obj; 563 } else { 564 CheckedForDWP = true; 565 // TODO: Should this error be handled (maybe in a high verbosity mode) 566 // before falling back to .dwo files? 567 consumeError(Obj.takeError()); 568 } 569 } 570 571 return object::ObjectFile::createObjectFile(AbsolutePath); 572 }(); 573 574 if (!Obj) { 575 // TODO: Actually report errors helpfully. 576 consumeError(Obj.takeError()); 577 return nullptr; 578 } 579 580 auto S = std::make_shared<DWOFile>(); 581 S->File = std::move(Obj.get()); 582 // Allow multi-threaded access if there is a .dwp file as the CU index and 583 // TU index might be accessed from multiple threads. 584 bool ThreadSafe = isThreadSafe(); 585 S->Context = DWARFContext::create( 586 *S->File.getBinary(), DWARFContext::ProcessDebugRelocations::Ignore, 587 nullptr, "", WithColor::defaultErrorHandler, 588 WithColor::defaultWarningHandler, ThreadSafe); 589 *Entry = S; 590 auto *Ctxt = S->Context.get(); 591 return std::shared_ptr<DWARFContext>(std::move(S), Ctxt); 592 } 593 594 bool isThreadSafe() const override { return false; } 595 596 const DenseMap<uint64_t, DWARFTypeUnit *> &getNormalTypeUnitMap() { 597 if (!NormalTypeUnits) { 598 NormalTypeUnits.emplace(); 599 for (const auto &U :D.normal_units()) { 600 if (DWARFTypeUnit *TU = dyn_cast<DWARFTypeUnit>(U.get())) 601 (*NormalTypeUnits)[TU->getTypeHash()] = TU; 602 } 603 } 604 return *NormalTypeUnits; 605 } 606 607 const DenseMap<uint64_t, DWARFTypeUnit *> &getDWOTypeUnitMap() { 608 if (!DWOTypeUnits) { 609 DWOTypeUnits.emplace(); 610 for (const auto &U :D.dwo_units()) { 611 if (DWARFTypeUnit *TU = dyn_cast<DWARFTypeUnit>(U.get())) 612 (*DWOTypeUnits)[TU->getTypeHash()] = TU; 613 } 614 } 615 return *DWOTypeUnits; 616 } 617 618 const DenseMap<uint64_t, DWARFTypeUnit *> & 619 getTypeUnitMap(bool IsDWO) override { 620 if (IsDWO) 621 return getDWOTypeUnitMap(); 622 else 623 return getNormalTypeUnitMap(); 624 } 625 626 627 }; 628 629 class ThreadSafeState : public ThreadUnsafeDWARFContextState { 630 std::recursive_mutex Mutex; 631 632 public: 633 ThreadSafeState(DWARFContext &DC, std::string &DWP) : 634 ThreadUnsafeDWARFContextState(DC, DWP) {} 635 636 DWARFUnitVector &getNormalUnits() override { 637 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 638 return ThreadUnsafeDWARFContextState::getNormalUnits(); 639 } 640 DWARFUnitVector &getDWOUnits(bool Lazy) override { 641 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 642 // We need to not do lazy parsing when we need thread safety as 643 // DWARFUnitVector, in lazy mode, will slowly add things to itself and 644 // will cause problems in a multi-threaded environment. 645 return ThreadUnsafeDWARFContextState::getDWOUnits(false); 646 } 647 const DWARFUnitIndex &getCUIndex() override { 648 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 649 return ThreadUnsafeDWARFContextState::getCUIndex(); 650 } 651 const DWARFDebugAbbrev *getDebugAbbrevDWO() override { 652 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 653 return ThreadUnsafeDWARFContextState::getDebugAbbrevDWO(); 654 } 655 656 const DWARFUnitIndex &getTUIndex() override { 657 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 658 return ThreadUnsafeDWARFContextState::getTUIndex(); 659 } 660 DWARFGdbIndex &getGdbIndex() override { 661 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 662 return ThreadUnsafeDWARFContextState::getGdbIndex(); 663 } 664 const DWARFDebugAbbrev *getDebugAbbrev() override { 665 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 666 return ThreadUnsafeDWARFContextState::getDebugAbbrev(); 667 } 668 const DWARFDebugLoc *getDebugLoc() override { 669 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 670 return ThreadUnsafeDWARFContextState::getDebugLoc(); 671 } 672 const DWARFDebugAranges *getDebugAranges() override { 673 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 674 return ThreadUnsafeDWARFContextState::getDebugAranges(); 675 } 676 Expected<const DWARFDebugLine::LineTable *> 677 getLineTableForUnit(DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) override { 678 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 679 return ThreadUnsafeDWARFContextState::getLineTableForUnit(U, RecoverableErrorHandler); 680 } 681 void clearLineTableForUnit(DWARFUnit *U) override { 682 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 683 return ThreadUnsafeDWARFContextState::clearLineTableForUnit(U); 684 } 685 Expected<const DWARFDebugFrame *> getDebugFrame() override { 686 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 687 return ThreadUnsafeDWARFContextState::getDebugFrame(); 688 } 689 Expected<const DWARFDebugFrame *> getEHFrame() override { 690 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 691 return ThreadUnsafeDWARFContextState::getEHFrame(); 692 } 693 const DWARFDebugMacro *getDebugMacinfo() override { 694 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 695 return ThreadUnsafeDWARFContextState::getDebugMacinfo(); 696 } 697 const DWARFDebugMacro *getDebugMacinfoDWO() override { 698 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 699 return ThreadUnsafeDWARFContextState::getDebugMacinfoDWO(); 700 } 701 const DWARFDebugMacro *getDebugMacro() override { 702 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 703 return ThreadUnsafeDWARFContextState::getDebugMacro(); 704 } 705 const DWARFDebugMacro *getDebugMacroDWO() override { 706 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 707 return ThreadUnsafeDWARFContextState::getDebugMacroDWO(); 708 } 709 const DWARFDebugNames &getDebugNames() override { 710 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 711 return ThreadUnsafeDWARFContextState::getDebugNames(); 712 } 713 const AppleAcceleratorTable &getAppleNames() override { 714 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 715 return ThreadUnsafeDWARFContextState::getAppleNames(); 716 } 717 const AppleAcceleratorTable &getAppleTypes() override { 718 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 719 return ThreadUnsafeDWARFContextState::getAppleTypes(); 720 } 721 const AppleAcceleratorTable &getAppleNamespaces() override { 722 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 723 return ThreadUnsafeDWARFContextState::getAppleNamespaces(); 724 } 725 const AppleAcceleratorTable &getAppleObjC() override { 726 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 727 return ThreadUnsafeDWARFContextState::getAppleObjC(); 728 } 729 std::shared_ptr<DWARFContext> 730 getDWOContext(StringRef AbsolutePath) override { 731 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 732 return ThreadUnsafeDWARFContextState::getDWOContext(AbsolutePath); 733 } 734 735 bool isThreadSafe() const override { return true; } 736 737 const DenseMap<uint64_t, DWARFTypeUnit *> & 738 getTypeUnitMap(bool IsDWO) override { 739 std::unique_lock<std::recursive_mutex> LockGuard(Mutex); 740 return ThreadUnsafeDWARFContextState::getTypeUnitMap(IsDWO); 741 } 742 }; 743 744 745 746 DWARFContext::DWARFContext(std::unique_ptr<const DWARFObject> DObj, 747 std::string DWPName, 748 std::function<void(Error)> RecoverableErrorHandler, 749 std::function<void(Error)> WarningHandler, 750 bool ThreadSafe) 751 : DIContext(CK_DWARF), 752 RecoverableErrorHandler(RecoverableErrorHandler), 753 WarningHandler(WarningHandler), DObj(std::move(DObj)) { 754 if (ThreadSafe) 755 State = std::make_unique<ThreadSafeState>(*this, DWPName); 756 else 757 State = std::make_unique<ThreadUnsafeDWARFContextState>(*this, DWPName); 758 } 759 760 DWARFContext::~DWARFContext() = default; 761 762 /// Dump the UUID load command. 763 static void dumpUUID(raw_ostream &OS, const ObjectFile &Obj) { 764 auto *MachO = dyn_cast<MachOObjectFile>(&Obj); 765 if (!MachO) 766 return; 767 for (auto LC : MachO->load_commands()) { 768 raw_ostream::uuid_t UUID; 769 if (LC.C.cmd == MachO::LC_UUID) { 770 if (LC.C.cmdsize < sizeof(UUID) + sizeof(LC.C)) { 771 OS << "error: UUID load command is too short.\n"; 772 return; 773 } 774 OS << "UUID: "; 775 memcpy(&UUID, LC.Ptr+sizeof(LC.C), sizeof(UUID)); 776 OS.write_uuid(UUID); 777 Triple T = MachO->getArchTriple(); 778 OS << " (" << T.getArchName() << ')'; 779 OS << ' ' << MachO->getFileName() << '\n'; 780 } 781 } 782 } 783 784 using ContributionCollection = 785 std::vector<std::optional<StrOffsetsContributionDescriptor>>; 786 787 // Collect all the contributions to the string offsets table from all units, 788 // sort them by their starting offsets and remove duplicates. 789 static ContributionCollection 790 collectContributionData(DWARFContext::unit_iterator_range Units) { 791 ContributionCollection Contributions; 792 for (const auto &U : Units) 793 if (const auto &C = U->getStringOffsetsTableContribution()) 794 Contributions.push_back(C); 795 // Sort the contributions so that any invalid ones are placed at 796 // the start of the contributions vector. This way they are reported 797 // first. 798 llvm::sort(Contributions, 799 [](const std::optional<StrOffsetsContributionDescriptor> &L, 800 const std::optional<StrOffsetsContributionDescriptor> &R) { 801 if (L && R) 802 return L->Base < R->Base; 803 return R.has_value(); 804 }); 805 806 // Uniquify contributions, as it is possible that units (specifically 807 // type units in dwo or dwp files) share contributions. We don't want 808 // to report them more than once. 809 Contributions.erase( 810 std::unique(Contributions.begin(), Contributions.end(), 811 [](const std::optional<StrOffsetsContributionDescriptor> &L, 812 const std::optional<StrOffsetsContributionDescriptor> &R) { 813 if (L && R) 814 return L->Base == R->Base && L->Size == R->Size; 815 return false; 816 }), 817 Contributions.end()); 818 return Contributions; 819 } 820 821 // Dump a DWARF string offsets section. This may be a DWARF v5 formatted 822 // string offsets section, where each compile or type unit contributes a 823 // number of entries (string offsets), with each contribution preceded by 824 // a header containing size and version number. Alternatively, it may be a 825 // monolithic series of string offsets, as generated by the pre-DWARF v5 826 // implementation of split DWARF; however, in that case we still need to 827 // collect contributions of units because the size of the offsets (4 or 8 828 // bytes) depends on the format of the referencing unit (DWARF32 or DWARF64). 829 static void dumpStringOffsetsSection(raw_ostream &OS, DIDumpOptions DumpOpts, 830 StringRef SectionName, 831 const DWARFObject &Obj, 832 const DWARFSection &StringOffsetsSection, 833 StringRef StringSection, 834 DWARFContext::unit_iterator_range Units, 835 bool LittleEndian) { 836 auto Contributions = collectContributionData(Units); 837 DWARFDataExtractor StrOffsetExt(Obj, StringOffsetsSection, LittleEndian, 0); 838 DataExtractor StrData(StringSection, LittleEndian, 0); 839 uint64_t SectionSize = StringOffsetsSection.Data.size(); 840 uint64_t Offset = 0; 841 for (auto &Contribution : Contributions) { 842 // Report an ill-formed contribution. 843 if (!Contribution) { 844 OS << "error: invalid contribution to string offsets table in section ." 845 << SectionName << ".\n"; 846 return; 847 } 848 849 dwarf::DwarfFormat Format = Contribution->getFormat(); 850 int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Format); 851 uint16_t Version = Contribution->getVersion(); 852 uint64_t ContributionHeader = Contribution->Base; 853 // In DWARF v5 there is a contribution header that immediately precedes 854 // the string offsets base (the location we have previously retrieved from 855 // the CU DIE's DW_AT_str_offsets attribute). The header is located either 856 // 8 or 16 bytes before the base, depending on the contribution's format. 857 if (Version >= 5) 858 ContributionHeader -= Format == DWARF32 ? 8 : 16; 859 860 // Detect overlapping contributions. 861 if (Offset > ContributionHeader) { 862 DumpOpts.RecoverableErrorHandler(createStringError( 863 errc::invalid_argument, 864 "overlapping contributions to string offsets table in section .%s.", 865 SectionName.data())); 866 } 867 // Report a gap in the table. 868 if (Offset < ContributionHeader) { 869 OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset); 870 OS << (ContributionHeader - Offset) << "\n"; 871 } 872 OS << format("0x%8.8" PRIx64 ": ", ContributionHeader); 873 // In DWARF v5 the contribution size in the descriptor does not equal 874 // the originally encoded length (it does not contain the length of the 875 // version field and the padding, a total of 4 bytes). Add them back in 876 // for reporting. 877 OS << "Contribution size = " << (Contribution->Size + (Version < 5 ? 0 : 4)) 878 << ", Format = " << dwarf::FormatString(Format) 879 << ", Version = " << Version << "\n"; 880 881 Offset = Contribution->Base; 882 unsigned EntrySize = Contribution->getDwarfOffsetByteSize(); 883 while (Offset - Contribution->Base < Contribution->Size) { 884 OS << format("0x%8.8" PRIx64 ": ", Offset); 885 uint64_t StringOffset = 886 StrOffsetExt.getRelocatedValue(EntrySize, &Offset); 887 OS << format("%0*" PRIx64 " ", OffsetDumpWidth, StringOffset); 888 const char *S = StrData.getCStr(&StringOffset); 889 if (S) 890 OS << format("\"%s\"", S); 891 OS << "\n"; 892 } 893 } 894 // Report a gap at the end of the table. 895 if (Offset < SectionSize) { 896 OS << format("0x%8.8" PRIx64 ": Gap, length = ", Offset); 897 OS << (SectionSize - Offset) << "\n"; 898 } 899 } 900 901 // Dump the .debug_addr section. 902 static void dumpAddrSection(raw_ostream &OS, DWARFDataExtractor &AddrData, 903 DIDumpOptions DumpOpts, uint16_t Version, 904 uint8_t AddrSize) { 905 uint64_t Offset = 0; 906 while (AddrData.isValidOffset(Offset)) { 907 DWARFDebugAddrTable AddrTable; 908 uint64_t TableOffset = Offset; 909 if (Error Err = AddrTable.extract(AddrData, &Offset, Version, AddrSize, 910 DumpOpts.WarningHandler)) { 911 DumpOpts.RecoverableErrorHandler(std::move(Err)); 912 // Keep going after an error, if we can, assuming that the length field 913 // could be read. If it couldn't, stop reading the section. 914 if (auto TableLength = AddrTable.getFullLength()) { 915 Offset = TableOffset + *TableLength; 916 continue; 917 } 918 break; 919 } 920 AddrTable.dump(OS, DumpOpts); 921 } 922 } 923 924 // Dump the .debug_rnglists or .debug_rnglists.dwo section (DWARF v5). 925 static void dumpRnglistsSection( 926 raw_ostream &OS, DWARFDataExtractor &rnglistData, 927 llvm::function_ref<std::optional<object::SectionedAddress>(uint32_t)> 928 LookupPooledAddress, 929 DIDumpOptions DumpOpts) { 930 uint64_t Offset = 0; 931 while (rnglistData.isValidOffset(Offset)) { 932 llvm::DWARFDebugRnglistTable Rnglists; 933 uint64_t TableOffset = Offset; 934 if (Error Err = Rnglists.extract(rnglistData, &Offset)) { 935 DumpOpts.RecoverableErrorHandler(std::move(Err)); 936 uint64_t Length = Rnglists.length(); 937 // Keep going after an error, if we can, assuming that the length field 938 // could be read. If it couldn't, stop reading the section. 939 if (Length == 0) 940 break; 941 Offset = TableOffset + Length; 942 } else { 943 Rnglists.dump(rnglistData, OS, LookupPooledAddress, DumpOpts); 944 } 945 } 946 } 947 948 949 static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts, 950 DWARFDataExtractor Data, const DWARFObject &Obj, 951 std::optional<uint64_t> DumpOffset) { 952 uint64_t Offset = 0; 953 954 while (Data.isValidOffset(Offset)) { 955 DWARFListTableHeader Header(".debug_loclists", "locations"); 956 if (Error E = Header.extract(Data, &Offset)) { 957 DumpOpts.RecoverableErrorHandler(std::move(E)); 958 return; 959 } 960 961 Header.dump(Data, OS, DumpOpts); 962 963 uint64_t EndOffset = Header.length() + Header.getHeaderOffset(); 964 Data.setAddressSize(Header.getAddrSize()); 965 DWARFDebugLoclists Loc(Data, Header.getVersion()); 966 if (DumpOffset) { 967 if (DumpOffset >= Offset && DumpOffset < EndOffset) { 968 Offset = *DumpOffset; 969 Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, Obj, 970 nullptr, DumpOpts, /*Indent=*/0); 971 OS << "\n"; 972 return; 973 } 974 } else { 975 Loc.dumpRange(Offset, EndOffset - Offset, OS, Obj, DumpOpts); 976 } 977 Offset = EndOffset; 978 } 979 } 980 981 static void dumpPubTableSection(raw_ostream &OS, DIDumpOptions DumpOpts, 982 DWARFDataExtractor Data, bool GnuStyle) { 983 DWARFDebugPubTable Table; 984 Table.extract(Data, GnuStyle, DumpOpts.RecoverableErrorHandler); 985 Table.dump(OS); 986 } 987 988 void DWARFContext::dump( 989 raw_ostream &OS, DIDumpOptions DumpOpts, 990 std::array<std::optional<uint64_t>, DIDT_ID_Count> DumpOffsets) { 991 uint64_t DumpType = DumpOpts.DumpType; 992 993 StringRef Extension = sys::path::extension(DObj->getFileName()); 994 bool IsDWO = (Extension == ".dwo") || (Extension == ".dwp"); 995 996 // Print UUID header. 997 const auto *ObjFile = DObj->getFile(); 998 if (DumpType & DIDT_UUID) 999 dumpUUID(OS, *ObjFile); 1000 1001 // Print a header for each explicitly-requested section. 1002 // Otherwise just print one for non-empty sections. 1003 // Only print empty .dwo section headers when dumping a .dwo file. 1004 bool Explicit = DumpType != DIDT_All && !IsDWO; 1005 bool ExplicitDWO = Explicit && IsDWO; 1006 auto shouldDump = [&](bool Explicit, const char *Name, unsigned ID, 1007 StringRef Section) -> std::optional<uint64_t> * { 1008 unsigned Mask = 1U << ID; 1009 bool Should = (DumpType & Mask) && (Explicit || !Section.empty()); 1010 if (!Should) 1011 return nullptr; 1012 OS << "\n" << Name << " contents:\n"; 1013 return &DumpOffsets[ID]; 1014 }; 1015 1016 // Dump individual sections. 1017 if (shouldDump(Explicit, ".debug_abbrev", DIDT_ID_DebugAbbrev, 1018 DObj->getAbbrevSection())) 1019 getDebugAbbrev()->dump(OS); 1020 if (shouldDump(ExplicitDWO, ".debug_abbrev.dwo", DIDT_ID_DebugAbbrev, 1021 DObj->getAbbrevDWOSection())) 1022 getDebugAbbrevDWO()->dump(OS); 1023 1024 auto dumpDebugInfo = [&](const char *Name, unit_iterator_range Units) { 1025 OS << '\n' << Name << " contents:\n"; 1026 if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugInfo]) 1027 for (const auto &U : Units) 1028 U->getDIEForOffset(*DumpOffset) 1029 .dump(OS, 0, DumpOpts.noImplicitRecursion()); 1030 else 1031 for (const auto &U : Units) 1032 U->dump(OS, DumpOpts); 1033 }; 1034 if ((DumpType & DIDT_DebugInfo)) { 1035 if (Explicit || getNumCompileUnits()) 1036 dumpDebugInfo(".debug_info", info_section_units()); 1037 if (ExplicitDWO || getNumDWOCompileUnits()) 1038 dumpDebugInfo(".debug_info.dwo", dwo_info_section_units()); 1039 } 1040 1041 auto dumpDebugType = [&](const char *Name, unit_iterator_range Units) { 1042 OS << '\n' << Name << " contents:\n"; 1043 for (const auto &U : Units) 1044 if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugTypes]) 1045 U->getDIEForOffset(*DumpOffset) 1046 .dump(OS, 0, DumpOpts.noImplicitRecursion()); 1047 else 1048 U->dump(OS, DumpOpts); 1049 }; 1050 if ((DumpType & DIDT_DebugTypes)) { 1051 if (Explicit || getNumTypeUnits()) 1052 dumpDebugType(".debug_types", types_section_units()); 1053 if (ExplicitDWO || getNumDWOTypeUnits()) 1054 dumpDebugType(".debug_types.dwo", dwo_types_section_units()); 1055 } 1056 1057 DIDumpOptions LLDumpOpts = DumpOpts; 1058 if (LLDumpOpts.Verbose) 1059 LLDumpOpts.DisplayRawContents = true; 1060 1061 if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc, 1062 DObj->getLocSection().Data)) { 1063 getDebugLoc()->dump(OS, *DObj, LLDumpOpts, *Off); 1064 } 1065 if (const auto *Off = 1066 shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists, 1067 DObj->getLoclistsSection().Data)) { 1068 DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(), 1069 0); 1070 dumpLoclistsSection(OS, LLDumpOpts, Data, *DObj, *Off); 1071 } 1072 if (const auto *Off = 1073 shouldDump(ExplicitDWO, ".debug_loclists.dwo", DIDT_ID_DebugLoclists, 1074 DObj->getLoclistsDWOSection().Data)) { 1075 DWARFDataExtractor Data(*DObj, DObj->getLoclistsDWOSection(), 1076 isLittleEndian(), 0); 1077 dumpLoclistsSection(OS, LLDumpOpts, Data, *DObj, *Off); 1078 } 1079 1080 if (const auto *Off = 1081 shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc, 1082 DObj->getLocDWOSection().Data)) { 1083 DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(), 1084 4); 1085 DWARFDebugLoclists Loc(Data, /*Version=*/4); 1086 if (*Off) { 1087 uint64_t Offset = **Off; 1088 Loc.dumpLocationList(&Offset, OS, 1089 /*BaseAddr=*/std::nullopt, *DObj, nullptr, 1090 LLDumpOpts, 1091 /*Indent=*/0); 1092 OS << "\n"; 1093 } else { 1094 Loc.dumpRange(0, Data.getData().size(), OS, *DObj, LLDumpOpts); 1095 } 1096 } 1097 1098 if (const std::optional<uint64_t> *Off = 1099 shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame, 1100 DObj->getFrameSection().Data)) { 1101 if (Expected<const DWARFDebugFrame *> DF = getDebugFrame()) 1102 (*DF)->dump(OS, DumpOpts, *Off); 1103 else 1104 RecoverableErrorHandler(DF.takeError()); 1105 } 1106 1107 if (const std::optional<uint64_t> *Off = 1108 shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame, 1109 DObj->getEHFrameSection().Data)) { 1110 if (Expected<const DWARFDebugFrame *> DF = getEHFrame()) 1111 (*DF)->dump(OS, DumpOpts, *Off); 1112 else 1113 RecoverableErrorHandler(DF.takeError()); 1114 } 1115 1116 if (shouldDump(Explicit, ".debug_macro", DIDT_ID_DebugMacro, 1117 DObj->getMacroSection().Data)) { 1118 if (auto Macro = getDebugMacro()) 1119 Macro->dump(OS); 1120 } 1121 1122 if (shouldDump(Explicit, ".debug_macro.dwo", DIDT_ID_DebugMacro, 1123 DObj->getMacroDWOSection())) { 1124 if (auto MacroDWO = getDebugMacroDWO()) 1125 MacroDWO->dump(OS); 1126 } 1127 1128 if (shouldDump(Explicit, ".debug_macinfo", DIDT_ID_DebugMacro, 1129 DObj->getMacinfoSection())) { 1130 if (auto Macinfo = getDebugMacinfo()) 1131 Macinfo->dump(OS); 1132 } 1133 1134 if (shouldDump(Explicit, ".debug_macinfo.dwo", DIDT_ID_DebugMacro, 1135 DObj->getMacinfoDWOSection())) { 1136 if (auto MacinfoDWO = getDebugMacinfoDWO()) 1137 MacinfoDWO->dump(OS); 1138 } 1139 1140 if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges, 1141 DObj->getArangesSection())) { 1142 uint64_t offset = 0; 1143 DWARFDataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(), 1144 0); 1145 DWARFDebugArangeSet set; 1146 while (arangesData.isValidOffset(offset)) { 1147 if (Error E = 1148 set.extract(arangesData, &offset, DumpOpts.WarningHandler)) { 1149 RecoverableErrorHandler(std::move(E)); 1150 break; 1151 } 1152 set.dump(OS); 1153 } 1154 } 1155 1156 auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser, 1157 DIDumpOptions DumpOpts, 1158 std::optional<uint64_t> DumpOffset) { 1159 while (!Parser.done()) { 1160 if (DumpOffset && Parser.getOffset() != *DumpOffset) { 1161 Parser.skip(DumpOpts.WarningHandler, DumpOpts.WarningHandler); 1162 continue; 1163 } 1164 OS << "debug_line[" << format("0x%8.8" PRIx64, Parser.getOffset()) 1165 << "]\n"; 1166 Parser.parseNext(DumpOpts.WarningHandler, DumpOpts.WarningHandler, &OS, 1167 DumpOpts.Verbose); 1168 } 1169 }; 1170 1171 auto DumpStrSection = [&](StringRef Section) { 1172 DataExtractor StrData(Section, isLittleEndian(), 0); 1173 uint64_t Offset = 0; 1174 uint64_t StrOffset = 0; 1175 while (StrData.isValidOffset(Offset)) { 1176 Error Err = Error::success(); 1177 const char *CStr = StrData.getCStr(&Offset, &Err); 1178 if (Err) { 1179 DumpOpts.WarningHandler(std::move(Err)); 1180 return; 1181 } 1182 OS << format("0x%8.8" PRIx64 ": \"", StrOffset); 1183 OS.write_escaped(CStr); 1184 OS << "\"\n"; 1185 StrOffset = Offset; 1186 } 1187 }; 1188 1189 if (const auto *Off = shouldDump(Explicit, ".debug_line", DIDT_ID_DebugLine, 1190 DObj->getLineSection().Data)) { 1191 DWARFDataExtractor LineData(*DObj, DObj->getLineSection(), isLittleEndian(), 1192 0); 1193 DWARFDebugLine::SectionParser Parser(LineData, *this, normal_units()); 1194 DumpLineSection(Parser, DumpOpts, *Off); 1195 } 1196 1197 if (const auto *Off = 1198 shouldDump(ExplicitDWO, ".debug_line.dwo", DIDT_ID_DebugLine, 1199 DObj->getLineDWOSection().Data)) { 1200 DWARFDataExtractor LineData(*DObj, DObj->getLineDWOSection(), 1201 isLittleEndian(), 0); 1202 DWARFDebugLine::SectionParser Parser(LineData, *this, dwo_units()); 1203 DumpLineSection(Parser, DumpOpts, *Off); 1204 } 1205 1206 if (shouldDump(Explicit, ".debug_cu_index", DIDT_ID_DebugCUIndex, 1207 DObj->getCUIndexSection())) { 1208 getCUIndex().dump(OS); 1209 } 1210 1211 if (shouldDump(Explicit, ".debug_tu_index", DIDT_ID_DebugTUIndex, 1212 DObj->getTUIndexSection())) { 1213 getTUIndex().dump(OS); 1214 } 1215 1216 if (shouldDump(Explicit, ".debug_str", DIDT_ID_DebugStr, 1217 DObj->getStrSection())) 1218 DumpStrSection(DObj->getStrSection()); 1219 1220 if (shouldDump(ExplicitDWO, ".debug_str.dwo", DIDT_ID_DebugStr, 1221 DObj->getStrDWOSection())) 1222 DumpStrSection(DObj->getStrDWOSection()); 1223 1224 if (shouldDump(Explicit, ".debug_line_str", DIDT_ID_DebugLineStr, 1225 DObj->getLineStrSection())) 1226 DumpStrSection(DObj->getLineStrSection()); 1227 1228 if (shouldDump(Explicit, ".debug_addr", DIDT_ID_DebugAddr, 1229 DObj->getAddrSection().Data)) { 1230 DWARFDataExtractor AddrData(*DObj, DObj->getAddrSection(), 1231 isLittleEndian(), 0); 1232 dumpAddrSection(OS, AddrData, DumpOpts, getMaxVersion(), getCUAddrSize()); 1233 } 1234 1235 if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges, 1236 DObj->getRangesSection().Data)) { 1237 uint8_t savedAddressByteSize = getCUAddrSize(); 1238 DWARFDataExtractor rangesData(*DObj, DObj->getRangesSection(), 1239 isLittleEndian(), savedAddressByteSize); 1240 uint64_t offset = 0; 1241 DWARFDebugRangeList rangeList; 1242 while (rangesData.isValidOffset(offset)) { 1243 if (Error E = rangeList.extract(rangesData, &offset)) { 1244 DumpOpts.RecoverableErrorHandler(std::move(E)); 1245 break; 1246 } 1247 rangeList.dump(OS); 1248 } 1249 } 1250 1251 auto LookupPooledAddress = 1252 [&](uint32_t Index) -> std::optional<SectionedAddress> { 1253 const auto &CUs = compile_units(); 1254 auto I = CUs.begin(); 1255 if (I == CUs.end()) 1256 return std::nullopt; 1257 return (*I)->getAddrOffsetSectionItem(Index); 1258 }; 1259 1260 if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists, 1261 DObj->getRnglistsSection().Data)) { 1262 DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsSection(), 1263 isLittleEndian(), 0); 1264 dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts); 1265 } 1266 1267 if (shouldDump(ExplicitDWO, ".debug_rnglists.dwo", DIDT_ID_DebugRnglists, 1268 DObj->getRnglistsDWOSection().Data)) { 1269 DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsDWOSection(), 1270 isLittleEndian(), 0); 1271 dumpRnglistsSection(OS, RnglistData, LookupPooledAddress, DumpOpts); 1272 } 1273 1274 if (shouldDump(Explicit, ".debug_pubnames", DIDT_ID_DebugPubnames, 1275 DObj->getPubnamesSection().Data)) { 1276 DWARFDataExtractor PubTableData(*DObj, DObj->getPubnamesSection(), 1277 isLittleEndian(), 0); 1278 dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/false); 1279 } 1280 1281 if (shouldDump(Explicit, ".debug_pubtypes", DIDT_ID_DebugPubtypes, 1282 DObj->getPubtypesSection().Data)) { 1283 DWARFDataExtractor PubTableData(*DObj, DObj->getPubtypesSection(), 1284 isLittleEndian(), 0); 1285 dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/false); 1286 } 1287 1288 if (shouldDump(Explicit, ".debug_gnu_pubnames", DIDT_ID_DebugGnuPubnames, 1289 DObj->getGnuPubnamesSection().Data)) { 1290 DWARFDataExtractor PubTableData(*DObj, DObj->getGnuPubnamesSection(), 1291 isLittleEndian(), 0); 1292 dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/true); 1293 } 1294 1295 if (shouldDump(Explicit, ".debug_gnu_pubtypes", DIDT_ID_DebugGnuPubtypes, 1296 DObj->getGnuPubtypesSection().Data)) { 1297 DWARFDataExtractor PubTableData(*DObj, DObj->getGnuPubtypesSection(), 1298 isLittleEndian(), 0); 1299 dumpPubTableSection(OS, DumpOpts, PubTableData, /*GnuStyle=*/true); 1300 } 1301 1302 if (shouldDump(Explicit, ".debug_str_offsets", DIDT_ID_DebugStrOffsets, 1303 DObj->getStrOffsetsSection().Data)) 1304 dumpStringOffsetsSection( 1305 OS, DumpOpts, "debug_str_offsets", *DObj, DObj->getStrOffsetsSection(), 1306 DObj->getStrSection(), normal_units(), isLittleEndian()); 1307 if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo", DIDT_ID_DebugStrOffsets, 1308 DObj->getStrOffsetsDWOSection().Data)) 1309 dumpStringOffsetsSection(OS, DumpOpts, "debug_str_offsets.dwo", *DObj, 1310 DObj->getStrOffsetsDWOSection(), 1311 DObj->getStrDWOSection(), dwo_units(), 1312 isLittleEndian()); 1313 1314 if (shouldDump(Explicit, ".gdb_index", DIDT_ID_GdbIndex, 1315 DObj->getGdbIndexSection())) { 1316 getGdbIndex().dump(OS); 1317 } 1318 1319 if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames, 1320 DObj->getAppleNamesSection().Data)) 1321 getAppleNames().dump(OS); 1322 1323 if (shouldDump(Explicit, ".apple_types", DIDT_ID_AppleTypes, 1324 DObj->getAppleTypesSection().Data)) 1325 getAppleTypes().dump(OS); 1326 1327 if (shouldDump(Explicit, ".apple_namespaces", DIDT_ID_AppleNamespaces, 1328 DObj->getAppleNamespacesSection().Data)) 1329 getAppleNamespaces().dump(OS); 1330 1331 if (shouldDump(Explicit, ".apple_objc", DIDT_ID_AppleObjC, 1332 DObj->getAppleObjCSection().Data)) 1333 getAppleObjC().dump(OS); 1334 if (shouldDump(Explicit, ".debug_names", DIDT_ID_DebugNames, 1335 DObj->getNamesSection().Data)) 1336 getDebugNames().dump(OS); 1337 } 1338 1339 DWARFTypeUnit *DWARFContext::getTypeUnitForHash(uint16_t Version, uint64_t Hash, 1340 bool IsDWO) { 1341 DWARFUnitVector &DWOUnits = State->getDWOUnits(); 1342 if (const auto &TUI = getTUIndex()) { 1343 if (const auto *R = TUI.getFromHash(Hash)) 1344 return dyn_cast_or_null<DWARFTypeUnit>( 1345 DWOUnits.getUnitForIndexEntry(*R)); 1346 return nullptr; 1347 } 1348 const DenseMap<uint64_t, DWARFTypeUnit *> &Map = State->getTypeUnitMap(IsDWO); 1349 auto Iter = Map.find(Hash); 1350 if (Iter != Map.end()) 1351 return Iter->second; 1352 return nullptr; 1353 } 1354 1355 DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) { 1356 DWARFUnitVector &DWOUnits = State->getDWOUnits(LazyParse); 1357 1358 if (const auto &CUI = getCUIndex()) { 1359 if (const auto *R = CUI.getFromHash(Hash)) 1360 return dyn_cast_or_null<DWARFCompileUnit>( 1361 DWOUnits.getUnitForIndexEntry(*R)); 1362 return nullptr; 1363 } 1364 1365 // If there's no index, just search through the CUs in the DWO - there's 1366 // probably only one unless this is something like LTO - though an in-process 1367 // built/cached lookup table could be used in that case to improve repeated 1368 // lookups of different CUs in the DWO. 1369 for (const auto &DWOCU : dwo_compile_units()) { 1370 // Might not have parsed DWO ID yet. 1371 if (!DWOCU->getDWOId()) { 1372 if (std::optional<uint64_t> DWOId = 1373 toUnsigned(DWOCU->getUnitDIE().find(DW_AT_GNU_dwo_id))) 1374 DWOCU->setDWOId(*DWOId); 1375 else 1376 // No DWO ID? 1377 continue; 1378 } 1379 if (DWOCU->getDWOId() == Hash) 1380 return dyn_cast<DWARFCompileUnit>(DWOCU.get()); 1381 } 1382 return nullptr; 1383 } 1384 1385 DWARFDie DWARFContext::getDIEForOffset(uint64_t Offset) { 1386 if (auto *CU = State->getNormalUnits().getUnitForOffset(Offset)) 1387 return CU->getDIEForOffset(Offset); 1388 return DWARFDie(); 1389 } 1390 1391 bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) { 1392 bool Success = true; 1393 DWARFVerifier verifier(OS, *this, DumpOpts); 1394 1395 Success &= verifier.handleDebugAbbrev(); 1396 if (DumpOpts.DumpType & DIDT_DebugCUIndex) 1397 Success &= verifier.handleDebugCUIndex(); 1398 if (DumpOpts.DumpType & DIDT_DebugTUIndex) 1399 Success &= verifier.handleDebugTUIndex(); 1400 if (DumpOpts.DumpType & DIDT_DebugInfo) 1401 Success &= verifier.handleDebugInfo(); 1402 if (DumpOpts.DumpType & DIDT_DebugLine) 1403 Success &= verifier.handleDebugLine(); 1404 if (DumpOpts.DumpType & DIDT_DebugStrOffsets) 1405 Success &= verifier.handleDebugStrOffsets(); 1406 Success &= verifier.handleAccelTables(); 1407 return Success; 1408 } 1409 1410 const DWARFUnitIndex &DWARFContext::getCUIndex() { 1411 return State->getCUIndex(); 1412 } 1413 1414 const DWARFUnitIndex &DWARFContext::getTUIndex() { 1415 return State->getTUIndex(); 1416 } 1417 1418 DWARFGdbIndex &DWARFContext::getGdbIndex() { 1419 return State->getGdbIndex(); 1420 } 1421 1422 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() { 1423 return State->getDebugAbbrev(); 1424 } 1425 1426 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() { 1427 return State->getDebugAbbrevDWO(); 1428 } 1429 1430 const DWARFDebugLoc *DWARFContext::getDebugLoc() { 1431 return State->getDebugLoc(); 1432 } 1433 1434 const DWARFDebugAranges *DWARFContext::getDebugAranges() { 1435 return State->getDebugAranges(); 1436 } 1437 1438 Expected<const DWARFDebugFrame *> DWARFContext::getDebugFrame() { 1439 return State->getDebugFrame(); 1440 } 1441 1442 Expected<const DWARFDebugFrame *> DWARFContext::getEHFrame() { 1443 return State->getEHFrame(); 1444 } 1445 1446 const DWARFDebugMacro *DWARFContext::getDebugMacro() { 1447 return State->getDebugMacro(); 1448 } 1449 1450 const DWARFDebugMacro *DWARFContext::getDebugMacroDWO() { 1451 return State->getDebugMacroDWO(); 1452 } 1453 1454 const DWARFDebugMacro *DWARFContext::getDebugMacinfo() { 1455 return State->getDebugMacinfo(); 1456 } 1457 1458 const DWARFDebugMacro *DWARFContext::getDebugMacinfoDWO() { 1459 return State->getDebugMacinfoDWO(); 1460 } 1461 1462 1463 const DWARFDebugNames &DWARFContext::getDebugNames() { 1464 return State->getDebugNames(); 1465 } 1466 1467 const AppleAcceleratorTable &DWARFContext::getAppleNames() { 1468 return State->getAppleNames(); 1469 } 1470 1471 const AppleAcceleratorTable &DWARFContext::getAppleTypes() { 1472 return State->getAppleTypes(); 1473 } 1474 1475 const AppleAcceleratorTable &DWARFContext::getAppleNamespaces() { 1476 return State->getAppleNamespaces(); 1477 } 1478 1479 const AppleAcceleratorTable &DWARFContext::getAppleObjC() { 1480 return State->getAppleObjC(); 1481 } 1482 1483 const DWARFDebugLine::LineTable * 1484 DWARFContext::getLineTableForUnit(DWARFUnit *U) { 1485 Expected<const DWARFDebugLine::LineTable *> ExpectedLineTable = 1486 getLineTableForUnit(U, WarningHandler); 1487 if (!ExpectedLineTable) { 1488 WarningHandler(ExpectedLineTable.takeError()); 1489 return nullptr; 1490 } 1491 return *ExpectedLineTable; 1492 } 1493 1494 Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit( 1495 DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) { 1496 return State->getLineTableForUnit(U, RecoverableErrorHandler); 1497 } 1498 1499 void DWARFContext::clearLineTableForUnit(DWARFUnit *U) { 1500 return State->clearLineTableForUnit(U); 1501 } 1502 1503 DWARFUnitVector &DWARFContext::getDWOUnits(bool Lazy) { 1504 return State->getDWOUnits(Lazy); 1505 } 1506 1507 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint64_t Offset) { 1508 return dyn_cast_or_null<DWARFCompileUnit>( 1509 State->getNormalUnits().getUnitForOffset(Offset)); 1510 } 1511 1512 DWARFCompileUnit *DWARFContext::getCompileUnitForCodeAddress(uint64_t Address) { 1513 uint64_t CUOffset = getDebugAranges()->findAddress(Address); 1514 return getCompileUnitForOffset(CUOffset); 1515 } 1516 1517 DWARFCompileUnit *DWARFContext::getCompileUnitForDataAddress(uint64_t Address) { 1518 uint64_t CUOffset = getDebugAranges()->findAddress(Address); 1519 if (DWARFCompileUnit *OffsetCU = getCompileUnitForOffset(CUOffset)) 1520 return OffsetCU; 1521 1522 // Global variables are often missed by the above search, for one of two 1523 // reasons: 1524 // 1. .debug_aranges may not include global variables. On clang, it seems we 1525 // put the globals in the aranges, but this isn't true for gcc. 1526 // 2. Even if the global variable is in a .debug_arange, global variables 1527 // may not be captured in the [start, end) addresses described by the 1528 // parent compile unit. 1529 // 1530 // So, we walk the CU's and their child DI's manually, looking for the 1531 // specific global variable. 1532 for (std::unique_ptr<DWARFUnit> &CU : compile_units()) { 1533 if (CU->getVariableForAddress(Address)) { 1534 return static_cast<DWARFCompileUnit *>(CU.get()); 1535 } 1536 } 1537 return nullptr; 1538 } 1539 1540 DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address) { 1541 DIEsForAddress Result; 1542 1543 DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address); 1544 if (!CU) 1545 return Result; 1546 1547 Result.CompileUnit = CU; 1548 Result.FunctionDIE = CU->getSubroutineForAddress(Address); 1549 1550 std::vector<DWARFDie> Worklist; 1551 Worklist.push_back(Result.FunctionDIE); 1552 while (!Worklist.empty()) { 1553 DWARFDie DIE = Worklist.back(); 1554 Worklist.pop_back(); 1555 1556 if (!DIE.isValid()) 1557 continue; 1558 1559 if (DIE.getTag() == DW_TAG_lexical_block && 1560 DIE.addressRangeContainsAddress(Address)) { 1561 Result.BlockDIE = DIE; 1562 break; 1563 } 1564 1565 append_range(Worklist, DIE); 1566 } 1567 1568 return Result; 1569 } 1570 1571 /// TODO: change input parameter from "uint64_t Address" 1572 /// into "SectionedAddress Address" 1573 static bool getFunctionNameAndStartLineForAddress( 1574 DWARFCompileUnit *CU, uint64_t Address, FunctionNameKind Kind, 1575 DILineInfoSpecifier::FileLineInfoKind FileNameKind, 1576 std::string &FunctionName, std::string &StartFile, uint32_t &StartLine, 1577 std::optional<uint64_t> &StartAddress) { 1578 // The address may correspond to instruction in some inlined function, 1579 // so we have to build the chain of inlined functions and take the 1580 // name of the topmost function in it. 1581 SmallVector<DWARFDie, 4> InlinedChain; 1582 CU->getInlinedChainForAddress(Address, InlinedChain); 1583 if (InlinedChain.empty()) 1584 return false; 1585 1586 const DWARFDie &DIE = InlinedChain[0]; 1587 bool FoundResult = false; 1588 const char *Name = nullptr; 1589 if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) { 1590 FunctionName = Name; 1591 FoundResult = true; 1592 } 1593 std::string DeclFile = DIE.getDeclFile(FileNameKind); 1594 if (!DeclFile.empty()) { 1595 StartFile = DeclFile; 1596 FoundResult = true; 1597 } 1598 if (auto DeclLineResult = DIE.getDeclLine()) { 1599 StartLine = DeclLineResult; 1600 FoundResult = true; 1601 } 1602 if (auto LowPcAddr = toSectionedAddress(DIE.find(DW_AT_low_pc))) 1603 StartAddress = LowPcAddr->Address; 1604 return FoundResult; 1605 } 1606 1607 static std::optional<int64_t> 1608 getExpressionFrameOffset(ArrayRef<uint8_t> Expr, 1609 std::optional<unsigned> FrameBaseReg) { 1610 if (!Expr.empty() && 1611 (Expr[0] == DW_OP_fbreg || 1612 (FrameBaseReg && Expr[0] == DW_OP_breg0 + *FrameBaseReg))) { 1613 unsigned Count; 1614 int64_t Offset = decodeSLEB128(Expr.data() + 1, &Count, Expr.end()); 1615 // A single DW_OP_fbreg or DW_OP_breg. 1616 if (Expr.size() == Count + 1) 1617 return Offset; 1618 // Same + DW_OP_deref (Fortran arrays look like this). 1619 if (Expr.size() == Count + 2 && Expr[Count + 1] == DW_OP_deref) 1620 return Offset; 1621 // Fallthrough. Do not accept ex. (DW_OP_breg W29, DW_OP_stack_value) 1622 } 1623 return std::nullopt; 1624 } 1625 1626 void DWARFContext::addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram, 1627 DWARFDie Die, std::vector<DILocal> &Result) { 1628 if (Die.getTag() == DW_TAG_variable || 1629 Die.getTag() == DW_TAG_formal_parameter) { 1630 DILocal Local; 1631 if (const char *Name = Subprogram.getSubroutineName(DINameKind::ShortName)) 1632 Local.FunctionName = Name; 1633 1634 std::optional<unsigned> FrameBaseReg; 1635 if (auto FrameBase = Subprogram.find(DW_AT_frame_base)) 1636 if (std::optional<ArrayRef<uint8_t>> Expr = FrameBase->getAsBlock()) 1637 if (!Expr->empty() && (*Expr)[0] >= DW_OP_reg0 && 1638 (*Expr)[0] <= DW_OP_reg31) { 1639 FrameBaseReg = (*Expr)[0] - DW_OP_reg0; 1640 } 1641 1642 if (Expected<std::vector<DWARFLocationExpression>> Loc = 1643 Die.getLocations(DW_AT_location)) { 1644 for (const auto &Entry : *Loc) { 1645 if (std::optional<int64_t> FrameOffset = 1646 getExpressionFrameOffset(Entry.Expr, FrameBaseReg)) { 1647 Local.FrameOffset = *FrameOffset; 1648 break; 1649 } 1650 } 1651 } else { 1652 // FIXME: missing DW_AT_location is OK here, but other errors should be 1653 // reported to the user. 1654 consumeError(Loc.takeError()); 1655 } 1656 1657 if (auto TagOffsetAttr = Die.find(DW_AT_LLVM_tag_offset)) 1658 Local.TagOffset = TagOffsetAttr->getAsUnsignedConstant(); 1659 1660 if (auto Origin = 1661 Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin)) 1662 Die = Origin; 1663 if (auto NameAttr = Die.find(DW_AT_name)) 1664 if (std::optional<const char *> Name = dwarf::toString(*NameAttr)) 1665 Local.Name = *Name; 1666 if (auto Type = Die.getAttributeValueAsReferencedDie(DW_AT_type)) 1667 Local.Size = Type.getTypeSize(getCUAddrSize()); 1668 if (auto DeclFileAttr = Die.find(DW_AT_decl_file)) { 1669 if (const auto *LT = CU->getContext().getLineTableForUnit(CU)) 1670 LT->getFileNameByIndex( 1671 *DeclFileAttr->getAsUnsignedConstant(), CU->getCompilationDir(), 1672 DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, 1673 Local.DeclFile); 1674 } 1675 if (auto DeclLineAttr = Die.find(DW_AT_decl_line)) 1676 Local.DeclLine = *DeclLineAttr->getAsUnsignedConstant(); 1677 1678 Result.push_back(Local); 1679 return; 1680 } 1681 1682 if (Die.getTag() == DW_TAG_inlined_subroutine) 1683 if (auto Origin = 1684 Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin)) 1685 Subprogram = Origin; 1686 1687 for (auto Child : Die) 1688 addLocalsForDie(CU, Subprogram, Child, Result); 1689 } 1690 1691 std::vector<DILocal> 1692 DWARFContext::getLocalsForAddress(object::SectionedAddress Address) { 1693 std::vector<DILocal> Result; 1694 DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address.Address); 1695 if (!CU) 1696 return Result; 1697 1698 DWARFDie Subprogram = CU->getSubroutineForAddress(Address.Address); 1699 if (Subprogram.isValid()) 1700 addLocalsForDie(CU, Subprogram, Subprogram, Result); 1701 return Result; 1702 } 1703 1704 DILineInfo DWARFContext::getLineInfoForAddress(object::SectionedAddress Address, 1705 DILineInfoSpecifier Spec) { 1706 DILineInfo Result; 1707 DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address.Address); 1708 if (!CU) 1709 return Result; 1710 1711 getFunctionNameAndStartLineForAddress( 1712 CU, Address.Address, Spec.FNKind, Spec.FLIKind, Result.FunctionName, 1713 Result.StartFileName, Result.StartLine, Result.StartAddress); 1714 if (Spec.FLIKind != FileLineInfoKind::None) { 1715 if (const DWARFLineTable *LineTable = getLineTableForUnit(CU)) { 1716 LineTable->getFileLineInfoForAddress( 1717 {Address.Address, Address.SectionIndex}, CU->getCompilationDir(), 1718 Spec.FLIKind, Result); 1719 } 1720 } 1721 1722 return Result; 1723 } 1724 1725 DILineInfo 1726 DWARFContext::getLineInfoForDataAddress(object::SectionedAddress Address) { 1727 DILineInfo Result; 1728 DWARFCompileUnit *CU = getCompileUnitForDataAddress(Address.Address); 1729 if (!CU) 1730 return Result; 1731 1732 if (DWARFDie Die = CU->getVariableForAddress(Address.Address)) { 1733 Result.FileName = Die.getDeclFile(FileLineInfoKind::AbsoluteFilePath); 1734 Result.Line = Die.getDeclLine(); 1735 } 1736 1737 return Result; 1738 } 1739 1740 DILineInfoTable DWARFContext::getLineInfoForAddressRange( 1741 object::SectionedAddress Address, uint64_t Size, DILineInfoSpecifier Spec) { 1742 DILineInfoTable Lines; 1743 DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address.Address); 1744 if (!CU) 1745 return Lines; 1746 1747 uint32_t StartLine = 0; 1748 std::string StartFileName; 1749 std::string FunctionName(DILineInfo::BadString); 1750 std::optional<uint64_t> StartAddress; 1751 getFunctionNameAndStartLineForAddress(CU, Address.Address, Spec.FNKind, 1752 Spec.FLIKind, FunctionName, 1753 StartFileName, StartLine, StartAddress); 1754 1755 // If the Specifier says we don't need FileLineInfo, just 1756 // return the top-most function at the starting address. 1757 if (Spec.FLIKind == FileLineInfoKind::None) { 1758 DILineInfo Result; 1759 Result.FunctionName = FunctionName; 1760 Result.StartFileName = StartFileName; 1761 Result.StartLine = StartLine; 1762 Result.StartAddress = StartAddress; 1763 Lines.push_back(std::make_pair(Address.Address, Result)); 1764 return Lines; 1765 } 1766 1767 const DWARFLineTable *LineTable = getLineTableForUnit(CU); 1768 1769 // Get the index of row we're looking for in the line table. 1770 std::vector<uint32_t> RowVector; 1771 if (!LineTable->lookupAddressRange({Address.Address, Address.SectionIndex}, 1772 Size, RowVector)) { 1773 return Lines; 1774 } 1775 1776 for (uint32_t RowIndex : RowVector) { 1777 // Take file number and line/column from the row. 1778 const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex]; 1779 DILineInfo Result; 1780 LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(), 1781 Spec.FLIKind, Result.FileName); 1782 Result.FunctionName = FunctionName; 1783 Result.Line = Row.Line; 1784 Result.Column = Row.Column; 1785 Result.StartFileName = StartFileName; 1786 Result.StartLine = StartLine; 1787 Result.StartAddress = StartAddress; 1788 Lines.push_back(std::make_pair(Row.Address.Address, Result)); 1789 } 1790 1791 return Lines; 1792 } 1793 1794 DIInliningInfo 1795 DWARFContext::getInliningInfoForAddress(object::SectionedAddress Address, 1796 DILineInfoSpecifier Spec) { 1797 DIInliningInfo InliningInfo; 1798 1799 DWARFCompileUnit *CU = getCompileUnitForCodeAddress(Address.Address); 1800 if (!CU) 1801 return InliningInfo; 1802 1803 const DWARFLineTable *LineTable = nullptr; 1804 SmallVector<DWARFDie, 4> InlinedChain; 1805 CU->getInlinedChainForAddress(Address.Address, InlinedChain); 1806 if (InlinedChain.size() == 0) { 1807 // If there is no DIE for address (e.g. it is in unavailable .dwo file), 1808 // try to at least get file/line info from symbol table. 1809 if (Spec.FLIKind != FileLineInfoKind::None) { 1810 DILineInfo Frame; 1811 LineTable = getLineTableForUnit(CU); 1812 if (LineTable && LineTable->getFileLineInfoForAddress( 1813 {Address.Address, Address.SectionIndex}, 1814 CU->getCompilationDir(), Spec.FLIKind, Frame)) 1815 InliningInfo.addFrame(Frame); 1816 } 1817 return InliningInfo; 1818 } 1819 1820 uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0; 1821 for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) { 1822 DWARFDie &FunctionDIE = InlinedChain[i]; 1823 DILineInfo Frame; 1824 // Get function name if necessary. 1825 if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind)) 1826 Frame.FunctionName = Name; 1827 if (auto DeclLineResult = FunctionDIE.getDeclLine()) 1828 Frame.StartLine = DeclLineResult; 1829 Frame.StartFileName = FunctionDIE.getDeclFile(Spec.FLIKind); 1830 if (auto LowPcAddr = toSectionedAddress(FunctionDIE.find(DW_AT_low_pc))) 1831 Frame.StartAddress = LowPcAddr->Address; 1832 if (Spec.FLIKind != FileLineInfoKind::None) { 1833 if (i == 0) { 1834 // For the topmost frame, initialize the line table of this 1835 // compile unit and fetch file/line info from it. 1836 LineTable = getLineTableForUnit(CU); 1837 // For the topmost routine, get file/line info from line table. 1838 if (LineTable) 1839 LineTable->getFileLineInfoForAddress( 1840 {Address.Address, Address.SectionIndex}, CU->getCompilationDir(), 1841 Spec.FLIKind, Frame); 1842 } else { 1843 // Otherwise, use call file, call line and call column from 1844 // previous DIE in inlined chain. 1845 if (LineTable) 1846 LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(), 1847 Spec.FLIKind, Frame.FileName); 1848 Frame.Line = CallLine; 1849 Frame.Column = CallColumn; 1850 Frame.Discriminator = CallDiscriminator; 1851 } 1852 // Get call file/line/column of a current DIE. 1853 if (i + 1 < n) { 1854 FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn, 1855 CallDiscriminator); 1856 } 1857 } 1858 InliningInfo.addFrame(Frame); 1859 } 1860 return InliningInfo; 1861 } 1862 1863 std::shared_ptr<DWARFContext> 1864 DWARFContext::getDWOContext(StringRef AbsolutePath) { 1865 return State->getDWOContext(AbsolutePath); 1866 } 1867 1868 static Error createError(const Twine &Reason, llvm::Error E) { 1869 return make_error<StringError>(Reason + toString(std::move(E)), 1870 inconvertibleErrorCode()); 1871 } 1872 1873 /// SymInfo contains information about symbol: it's address 1874 /// and section index which is -1LL for absolute symbols. 1875 struct SymInfo { 1876 uint64_t Address; 1877 uint64_t SectionIndex; 1878 }; 1879 1880 /// Returns the address of symbol relocation used against and a section index. 1881 /// Used for futher relocations computation. Symbol's section load address is 1882 static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj, 1883 const RelocationRef &Reloc, 1884 const LoadedObjectInfo *L, 1885 std::map<SymbolRef, SymInfo> &Cache) { 1886 SymInfo Ret = {0, (uint64_t)-1LL}; 1887 object::section_iterator RSec = Obj.section_end(); 1888 object::symbol_iterator Sym = Reloc.getSymbol(); 1889 1890 std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end(); 1891 // First calculate the address of the symbol or section as it appears 1892 // in the object file 1893 if (Sym != Obj.symbol_end()) { 1894 bool New; 1895 std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}}); 1896 if (!New) 1897 return CacheIt->second; 1898 1899 Expected<uint64_t> SymAddrOrErr = Sym->getAddress(); 1900 if (!SymAddrOrErr) 1901 return createError("failed to compute symbol address: ", 1902 SymAddrOrErr.takeError()); 1903 1904 // Also remember what section this symbol is in for later 1905 auto SectOrErr = Sym->getSection(); 1906 if (!SectOrErr) 1907 return createError("failed to get symbol section: ", 1908 SectOrErr.takeError()); 1909 1910 RSec = *SectOrErr; 1911 Ret.Address = *SymAddrOrErr; 1912 } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) { 1913 RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl()); 1914 Ret.Address = RSec->getAddress(); 1915 } 1916 1917 if (RSec != Obj.section_end()) 1918 Ret.SectionIndex = RSec->getIndex(); 1919 1920 // If we are given load addresses for the sections, we need to adjust: 1921 // SymAddr = (Address of Symbol Or Section in File) - 1922 // (Address of Section in File) + 1923 // (Load Address of Section) 1924 // RSec is now either the section being targeted or the section 1925 // containing the symbol being targeted. In either case, 1926 // we need to perform the same computation. 1927 if (L && RSec != Obj.section_end()) 1928 if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec)) 1929 Ret.Address += SectionLoadAddress - RSec->getAddress(); 1930 1931 if (CacheIt != Cache.end()) 1932 CacheIt->second = Ret; 1933 1934 return Ret; 1935 } 1936 1937 static bool isRelocScattered(const object::ObjectFile &Obj, 1938 const RelocationRef &Reloc) { 1939 const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj); 1940 if (!MachObj) 1941 return false; 1942 // MachO also has relocations that point to sections and 1943 // scattered relocations. 1944 auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl()); 1945 return MachObj->isRelocationScattered(RelocInfo); 1946 } 1947 1948 namespace { 1949 struct DWARFSectionMap final : public DWARFSection { 1950 RelocAddrMap Relocs; 1951 }; 1952 1953 class DWARFObjInMemory final : public DWARFObject { 1954 bool IsLittleEndian; 1955 uint8_t AddressSize; 1956 StringRef FileName; 1957 const object::ObjectFile *Obj = nullptr; 1958 std::vector<SectionName> SectionNames; 1959 1960 using InfoSectionMap = MapVector<object::SectionRef, DWARFSectionMap, 1961 std::map<object::SectionRef, unsigned>>; 1962 1963 InfoSectionMap InfoSections; 1964 InfoSectionMap TypesSections; 1965 InfoSectionMap InfoDWOSections; 1966 InfoSectionMap TypesDWOSections; 1967 1968 DWARFSectionMap LocSection; 1969 DWARFSectionMap LoclistsSection; 1970 DWARFSectionMap LoclistsDWOSection; 1971 DWARFSectionMap LineSection; 1972 DWARFSectionMap RangesSection; 1973 DWARFSectionMap RnglistsSection; 1974 DWARFSectionMap StrOffsetsSection; 1975 DWARFSectionMap LineDWOSection; 1976 DWARFSectionMap FrameSection; 1977 DWARFSectionMap EHFrameSection; 1978 DWARFSectionMap LocDWOSection; 1979 DWARFSectionMap StrOffsetsDWOSection; 1980 DWARFSectionMap RangesDWOSection; 1981 DWARFSectionMap RnglistsDWOSection; 1982 DWARFSectionMap AddrSection; 1983 DWARFSectionMap AppleNamesSection; 1984 DWARFSectionMap AppleTypesSection; 1985 DWARFSectionMap AppleNamespacesSection; 1986 DWARFSectionMap AppleObjCSection; 1987 DWARFSectionMap NamesSection; 1988 DWARFSectionMap PubnamesSection; 1989 DWARFSectionMap PubtypesSection; 1990 DWARFSectionMap GnuPubnamesSection; 1991 DWARFSectionMap GnuPubtypesSection; 1992 DWARFSectionMap MacroSection; 1993 1994 DWARFSectionMap *mapNameToDWARFSection(StringRef Name) { 1995 return StringSwitch<DWARFSectionMap *>(Name) 1996 .Case("debug_loc", &LocSection) 1997 .Case("debug_loclists", &LoclistsSection) 1998 .Case("debug_loclists.dwo", &LoclistsDWOSection) 1999 .Case("debug_line", &LineSection) 2000 .Case("debug_frame", &FrameSection) 2001 .Case("eh_frame", &EHFrameSection) 2002 .Case("debug_str_offsets", &StrOffsetsSection) 2003 .Case("debug_ranges", &RangesSection) 2004 .Case("debug_rnglists", &RnglistsSection) 2005 .Case("debug_loc.dwo", &LocDWOSection) 2006 .Case("debug_line.dwo", &LineDWOSection) 2007 .Case("debug_names", &NamesSection) 2008 .Case("debug_rnglists.dwo", &RnglistsDWOSection) 2009 .Case("debug_str_offsets.dwo", &StrOffsetsDWOSection) 2010 .Case("debug_addr", &AddrSection) 2011 .Case("apple_names", &AppleNamesSection) 2012 .Case("debug_pubnames", &PubnamesSection) 2013 .Case("debug_pubtypes", &PubtypesSection) 2014 .Case("debug_gnu_pubnames", &GnuPubnamesSection) 2015 .Case("debug_gnu_pubtypes", &GnuPubtypesSection) 2016 .Case("apple_types", &AppleTypesSection) 2017 .Case("apple_namespaces", &AppleNamespacesSection) 2018 .Case("apple_namespac", &AppleNamespacesSection) 2019 .Case("apple_objc", &AppleObjCSection) 2020 .Case("debug_macro", &MacroSection) 2021 .Default(nullptr); 2022 } 2023 2024 StringRef AbbrevSection; 2025 StringRef ArangesSection; 2026 StringRef StrSection; 2027 StringRef MacinfoSection; 2028 StringRef MacinfoDWOSection; 2029 StringRef MacroDWOSection; 2030 StringRef AbbrevDWOSection; 2031 StringRef StrDWOSection; 2032 StringRef CUIndexSection; 2033 StringRef GdbIndexSection; 2034 StringRef TUIndexSection; 2035 StringRef LineStrSection; 2036 2037 // A deque holding section data whose iterators are not invalidated when 2038 // new decompressed sections are inserted at the end. 2039 std::deque<SmallString<0>> UncompressedSections; 2040 2041 StringRef *mapSectionToMember(StringRef Name) { 2042 if (DWARFSection *Sec = mapNameToDWARFSection(Name)) 2043 return &Sec->Data; 2044 return StringSwitch<StringRef *>(Name) 2045 .Case("debug_abbrev", &AbbrevSection) 2046 .Case("debug_aranges", &ArangesSection) 2047 .Case("debug_str", &StrSection) 2048 .Case("debug_macinfo", &MacinfoSection) 2049 .Case("debug_macinfo.dwo", &MacinfoDWOSection) 2050 .Case("debug_macro.dwo", &MacroDWOSection) 2051 .Case("debug_abbrev.dwo", &AbbrevDWOSection) 2052 .Case("debug_str.dwo", &StrDWOSection) 2053 .Case("debug_cu_index", &CUIndexSection) 2054 .Case("debug_tu_index", &TUIndexSection) 2055 .Case("gdb_index", &GdbIndexSection) 2056 .Case("debug_line_str", &LineStrSection) 2057 // Any more debug info sections go here. 2058 .Default(nullptr); 2059 } 2060 2061 /// If Sec is compressed section, decompresses and updates its contents 2062 /// provided by Data. Otherwise leaves it unchanged. 2063 Error maybeDecompress(const object::SectionRef &Sec, StringRef Name, 2064 StringRef &Data) { 2065 if (!Sec.isCompressed()) 2066 return Error::success(); 2067 2068 Expected<Decompressor> Decompressor = 2069 Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8); 2070 if (!Decompressor) 2071 return Decompressor.takeError(); 2072 2073 SmallString<0> Out; 2074 if (auto Err = Decompressor->resizeAndDecompress(Out)) 2075 return Err; 2076 2077 UncompressedSections.push_back(std::move(Out)); 2078 Data = UncompressedSections.back(); 2079 2080 return Error::success(); 2081 } 2082 2083 public: 2084 DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, 2085 uint8_t AddrSize, bool IsLittleEndian) 2086 : IsLittleEndian(IsLittleEndian) { 2087 for (const auto &SecIt : Sections) { 2088 if (StringRef *SectionData = mapSectionToMember(SecIt.first())) 2089 *SectionData = SecIt.second->getBuffer(); 2090 else if (SecIt.first() == "debug_info") 2091 // Find debug_info and debug_types data by section rather than name as 2092 // there are multiple, comdat grouped, of these sections. 2093 InfoSections[SectionRef()].Data = SecIt.second->getBuffer(); 2094 else if (SecIt.first() == "debug_info.dwo") 2095 InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer(); 2096 else if (SecIt.first() == "debug_types") 2097 TypesSections[SectionRef()].Data = SecIt.second->getBuffer(); 2098 else if (SecIt.first() == "debug_types.dwo") 2099 TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer(); 2100 } 2101 } 2102 DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L, 2103 function_ref<void(Error)> HandleError, 2104 function_ref<void(Error)> HandleWarning, 2105 DWARFContext::ProcessDebugRelocations RelocAction) 2106 : IsLittleEndian(Obj.isLittleEndian()), 2107 AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()), 2108 Obj(&Obj) { 2109 2110 StringMap<unsigned> SectionAmountMap; 2111 for (const SectionRef &Section : Obj.sections()) { 2112 StringRef Name; 2113 if (auto NameOrErr = Section.getName()) 2114 Name = *NameOrErr; 2115 else 2116 consumeError(NameOrErr.takeError()); 2117 2118 ++SectionAmountMap[Name]; 2119 SectionNames.push_back({ Name, true }); 2120 2121 // Skip BSS and Virtual sections, they aren't interesting. 2122 if (Section.isBSS() || Section.isVirtual()) 2123 continue; 2124 2125 // Skip sections stripped by dsymutil. 2126 if (Section.isStripped()) 2127 continue; 2128 2129 StringRef Data; 2130 Expected<section_iterator> SecOrErr = Section.getRelocatedSection(); 2131 if (!SecOrErr) { 2132 HandleError(createError("failed to get relocated section: ", 2133 SecOrErr.takeError())); 2134 continue; 2135 } 2136 2137 // Try to obtain an already relocated version of this section. 2138 // Else use the unrelocated section from the object file. We'll have to 2139 // apply relocations ourselves later. 2140 section_iterator RelocatedSection = 2141 Obj.isRelocatableObject() ? *SecOrErr : Obj.section_end(); 2142 if (!L || !L->getLoadedSectionContents(*RelocatedSection, Data)) { 2143 Expected<StringRef> E = Section.getContents(); 2144 if (E) 2145 Data = *E; 2146 else 2147 // maybeDecompress below will error. 2148 consumeError(E.takeError()); 2149 } 2150 2151 if (auto Err = maybeDecompress(Section, Name, Data)) { 2152 HandleError(createError("failed to decompress '" + Name + "', ", 2153 std::move(Err))); 2154 continue; 2155 } 2156 2157 // Map platform specific debug section names to DWARF standard section 2158 // names. 2159 Name = Name.substr(Name.find_first_not_of("._")); 2160 Name = Obj.mapDebugSectionName(Name); 2161 2162 if (StringRef *SectionData = mapSectionToMember(Name)) { 2163 *SectionData = Data; 2164 if (Name == "debug_ranges") { 2165 // FIXME: Use the other dwo range section when we emit it. 2166 RangesDWOSection.Data = Data; 2167 } else if (Name == "debug_frame" || Name == "eh_frame") { 2168 if (DWARFSection *S = mapNameToDWARFSection(Name)) 2169 S->Address = Section.getAddress(); 2170 } 2171 } else if (InfoSectionMap *Sections = 2172 StringSwitch<InfoSectionMap *>(Name) 2173 .Case("debug_info", &InfoSections) 2174 .Case("debug_info.dwo", &InfoDWOSections) 2175 .Case("debug_types", &TypesSections) 2176 .Case("debug_types.dwo", &TypesDWOSections) 2177 .Default(nullptr)) { 2178 // Find debug_info and debug_types data by section rather than name as 2179 // there are multiple, comdat grouped, of these sections. 2180 DWARFSectionMap &S = (*Sections)[Section]; 2181 S.Data = Data; 2182 } 2183 2184 if (RelocatedSection == Obj.section_end() || 2185 (RelocAction == DWARFContext::ProcessDebugRelocations::Ignore)) 2186 continue; 2187 2188 StringRef RelSecName; 2189 if (auto NameOrErr = RelocatedSection->getName()) 2190 RelSecName = *NameOrErr; 2191 else 2192 consumeError(NameOrErr.takeError()); 2193 2194 // If the section we're relocating was relocated already by the JIT, 2195 // then we used the relocated version above, so we do not need to process 2196 // relocations for it now. 2197 StringRef RelSecData; 2198 if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData)) 2199 continue; 2200 2201 // In Mach-o files, the relocations do not need to be applied if 2202 // there is no load offset to apply. The value read at the 2203 // relocation point already factors in the section address 2204 // (actually applying the relocations will produce wrong results 2205 // as the section address will be added twice). 2206 if (!L && isa<MachOObjectFile>(&Obj)) 2207 continue; 2208 2209 if (!Section.relocations().empty() && Name.ends_with(".dwo") && 2210 RelSecName.starts_with(".debug")) { 2211 HandleWarning(createError("unexpected relocations for dwo section '" + 2212 RelSecName + "'")); 2213 } 2214 2215 // TODO: Add support for relocations in other sections as needed. 2216 // Record relocations for the debug_info and debug_line sections. 2217 RelSecName = RelSecName.substr(RelSecName.find_first_not_of("._")); 2218 DWARFSectionMap *Sec = mapNameToDWARFSection(RelSecName); 2219 RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr; 2220 if (!Map) { 2221 // Find debug_info and debug_types relocs by section rather than name 2222 // as there are multiple, comdat grouped, of these sections. 2223 if (RelSecName == "debug_info") 2224 Map = &static_cast<DWARFSectionMap &>(InfoSections[*RelocatedSection]) 2225 .Relocs; 2226 else if (RelSecName == "debug_types") 2227 Map = 2228 &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection]) 2229 .Relocs; 2230 else 2231 continue; 2232 } 2233 2234 if (Section.relocation_begin() == Section.relocation_end()) 2235 continue; 2236 2237 // Symbol to [address, section index] cache mapping. 2238 std::map<SymbolRef, SymInfo> AddrCache; 2239 SupportsRelocation Supports; 2240 RelocationResolver Resolver; 2241 std::tie(Supports, Resolver) = getRelocationResolver(Obj); 2242 for (const RelocationRef &Reloc : Section.relocations()) { 2243 // FIXME: it's not clear how to correctly handle scattered 2244 // relocations. 2245 if (isRelocScattered(Obj, Reloc)) 2246 continue; 2247 2248 Expected<SymInfo> SymInfoOrErr = 2249 getSymbolInfo(Obj, Reloc, L, AddrCache); 2250 if (!SymInfoOrErr) { 2251 HandleError(SymInfoOrErr.takeError()); 2252 continue; 2253 } 2254 2255 // Check if Resolver can handle this relocation type early so as not to 2256 // handle invalid cases in DWARFDataExtractor. 2257 // 2258 // TODO Don't store Resolver in every RelocAddrEntry. 2259 if (Supports && Supports(Reloc.getType())) { 2260 auto I = Map->try_emplace( 2261 Reloc.getOffset(), 2262 RelocAddrEntry{ 2263 SymInfoOrErr->SectionIndex, Reloc, SymInfoOrErr->Address, 2264 std::optional<object::RelocationRef>(), 0, Resolver}); 2265 // If we didn't successfully insert that's because we already had a 2266 // relocation for that offset. Store it as a second relocation in the 2267 // same RelocAddrEntry instead. 2268 if (!I.second) { 2269 RelocAddrEntry &entry = I.first->getSecond(); 2270 if (entry.Reloc2) { 2271 HandleError(createError( 2272 "At most two relocations per offset are supported")); 2273 } 2274 entry.Reloc2 = Reloc; 2275 entry.SymbolValue2 = SymInfoOrErr->Address; 2276 } 2277 } else { 2278 SmallString<32> Type; 2279 Reloc.getTypeName(Type); 2280 // FIXME: Support more relocations & change this to an error 2281 HandleWarning( 2282 createError("failed to compute relocation: " + Type + ", ", 2283 errorCodeToError(object_error::parse_failed))); 2284 } 2285 } 2286 } 2287 2288 for (SectionName &S : SectionNames) 2289 if (SectionAmountMap[S.Name] > 1) 2290 S.IsNameUnique = false; 2291 } 2292 2293 std::optional<RelocAddrEntry> find(const DWARFSection &S, 2294 uint64_t Pos) const override { 2295 auto &Sec = static_cast<const DWARFSectionMap &>(S); 2296 RelocAddrMap::const_iterator AI = Sec.Relocs.find(Pos); 2297 if (AI == Sec.Relocs.end()) 2298 return std::nullopt; 2299 return AI->second; 2300 } 2301 2302 const object::ObjectFile *getFile() const override { return Obj; } 2303 2304 ArrayRef<SectionName> getSectionNames() const override { 2305 return SectionNames; 2306 } 2307 2308 bool isLittleEndian() const override { return IsLittleEndian; } 2309 StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; } 2310 const DWARFSection &getLineDWOSection() const override { 2311 return LineDWOSection; 2312 } 2313 const DWARFSection &getLocDWOSection() const override { 2314 return LocDWOSection; 2315 } 2316 StringRef getStrDWOSection() const override { return StrDWOSection; } 2317 const DWARFSection &getStrOffsetsDWOSection() const override { 2318 return StrOffsetsDWOSection; 2319 } 2320 const DWARFSection &getRangesDWOSection() const override { 2321 return RangesDWOSection; 2322 } 2323 const DWARFSection &getRnglistsDWOSection() const override { 2324 return RnglistsDWOSection; 2325 } 2326 const DWARFSection &getLoclistsDWOSection() const override { 2327 return LoclistsDWOSection; 2328 } 2329 const DWARFSection &getAddrSection() const override { return AddrSection; } 2330 StringRef getCUIndexSection() const override { return CUIndexSection; } 2331 StringRef getGdbIndexSection() const override { return GdbIndexSection; } 2332 StringRef getTUIndexSection() const override { return TUIndexSection; } 2333 2334 // DWARF v5 2335 const DWARFSection &getStrOffsetsSection() const override { 2336 return StrOffsetsSection; 2337 } 2338 StringRef getLineStrSection() const override { return LineStrSection; } 2339 2340 // Sections for DWARF5 split dwarf proposal. 2341 void forEachInfoDWOSections( 2342 function_ref<void(const DWARFSection &)> F) const override { 2343 for (auto &P : InfoDWOSections) 2344 F(P.second); 2345 } 2346 void forEachTypesDWOSections( 2347 function_ref<void(const DWARFSection &)> F) const override { 2348 for (auto &P : TypesDWOSections) 2349 F(P.second); 2350 } 2351 2352 StringRef getAbbrevSection() const override { return AbbrevSection; } 2353 const DWARFSection &getLocSection() const override { return LocSection; } 2354 const DWARFSection &getLoclistsSection() const override { return LoclistsSection; } 2355 StringRef getArangesSection() const override { return ArangesSection; } 2356 const DWARFSection &getFrameSection() const override { 2357 return FrameSection; 2358 } 2359 const DWARFSection &getEHFrameSection() const override { 2360 return EHFrameSection; 2361 } 2362 const DWARFSection &getLineSection() const override { return LineSection; } 2363 StringRef getStrSection() const override { return StrSection; } 2364 const DWARFSection &getRangesSection() const override { return RangesSection; } 2365 const DWARFSection &getRnglistsSection() const override { 2366 return RnglistsSection; 2367 } 2368 const DWARFSection &getMacroSection() const override { return MacroSection; } 2369 StringRef getMacroDWOSection() const override { return MacroDWOSection; } 2370 StringRef getMacinfoSection() const override { return MacinfoSection; } 2371 StringRef getMacinfoDWOSection() const override { return MacinfoDWOSection; } 2372 const DWARFSection &getPubnamesSection() const override { return PubnamesSection; } 2373 const DWARFSection &getPubtypesSection() const override { return PubtypesSection; } 2374 const DWARFSection &getGnuPubnamesSection() const override { 2375 return GnuPubnamesSection; 2376 } 2377 const DWARFSection &getGnuPubtypesSection() const override { 2378 return GnuPubtypesSection; 2379 } 2380 const DWARFSection &getAppleNamesSection() const override { 2381 return AppleNamesSection; 2382 } 2383 const DWARFSection &getAppleTypesSection() const override { 2384 return AppleTypesSection; 2385 } 2386 const DWARFSection &getAppleNamespacesSection() const override { 2387 return AppleNamespacesSection; 2388 } 2389 const DWARFSection &getAppleObjCSection() const override { 2390 return AppleObjCSection; 2391 } 2392 const DWARFSection &getNamesSection() const override { 2393 return NamesSection; 2394 } 2395 2396 StringRef getFileName() const override { return FileName; } 2397 uint8_t getAddressSize() const override { return AddressSize; } 2398 void forEachInfoSections( 2399 function_ref<void(const DWARFSection &)> F) const override { 2400 for (auto &P : InfoSections) 2401 F(P.second); 2402 } 2403 void forEachTypesSections( 2404 function_ref<void(const DWARFSection &)> F) const override { 2405 for (auto &P : TypesSections) 2406 F(P.second); 2407 } 2408 }; 2409 } // namespace 2410 2411 std::unique_ptr<DWARFContext> 2412 DWARFContext::create(const object::ObjectFile &Obj, 2413 ProcessDebugRelocations RelocAction, 2414 const LoadedObjectInfo *L, std::string DWPName, 2415 std::function<void(Error)> RecoverableErrorHandler, 2416 std::function<void(Error)> WarningHandler, 2417 bool ThreadSafe) { 2418 auto DObj = std::make_unique<DWARFObjInMemory>( 2419 Obj, L, RecoverableErrorHandler, WarningHandler, RelocAction); 2420 return std::make_unique<DWARFContext>(std::move(DObj), 2421 std::move(DWPName), 2422 RecoverableErrorHandler, 2423 WarningHandler, 2424 ThreadSafe); 2425 } 2426 2427 std::unique_ptr<DWARFContext> 2428 DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, 2429 uint8_t AddrSize, bool isLittleEndian, 2430 std::function<void(Error)> RecoverableErrorHandler, 2431 std::function<void(Error)> WarningHandler, 2432 bool ThreadSafe) { 2433 auto DObj = 2434 std::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian); 2435 return std::make_unique<DWARFContext>( 2436 std::move(DObj), "", RecoverableErrorHandler, WarningHandler, ThreadSafe); 2437 } 2438 2439 uint8_t DWARFContext::getCUAddrSize() { 2440 // In theory, different compile units may have different address byte 2441 // sizes, but for simplicity we just use the address byte size of the 2442 // first compile unit. In practice the address size field is repeated across 2443 // various DWARF headers (at least in version 5) to make it easier to dump 2444 // them independently, not to enable varying the address size. 2445 auto CUs = compile_units(); 2446 return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize(); 2447 } 2448