1 //===-- llvm-dwp.cpp - Split DWARF merging tool for llvm ------------------===// 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 // A utility for merging DWARF 5 Split DWARF .dwo files into .dwp (DWARF 10 // package files). 11 // 12 //===----------------------------------------------------------------------===// 13 #include "llvm/DWP/DWP.h" 14 #include "llvm/ADT/Twine.h" 15 #include "llvm/DWP/DWPError.h" 16 #include "llvm/MC/MCContext.h" 17 #include "llvm/MC/MCObjectFileInfo.h" 18 #include "llvm/MC/MCTargetOptionsCommandFlags.h" 19 #include "llvm/Object/Decompressor.h" 20 #include "llvm/Object/ELFObjectFile.h" 21 #include "llvm/Support/CommandLine.h" 22 #include "llvm/Support/MemoryBuffer.h" 23 #include <limits> 24 25 using namespace llvm; 26 using namespace llvm::object; 27 28 static mc::RegisterMCTargetOptionsFlags MCTargetOptionsFlags; 29 30 // Returns the size of debug_str_offsets section headers in bytes. 31 static uint64_t debugStrOffsetsHeaderSize(DataExtractor StrOffsetsData, 32 uint16_t DwarfVersion) { 33 if (DwarfVersion <= 4) 34 return 0; // There is no header before dwarf 5. 35 uint64_t Offset = 0; 36 uint64_t Length = StrOffsetsData.getU32(&Offset); 37 if (Length == llvm::dwarf::DW_LENGTH_DWARF64) 38 return 16; // unit length: 12 bytes, version: 2 bytes, padding: 2 bytes. 39 return 8; // unit length: 4 bytes, version: 2 bytes, padding: 2 bytes. 40 } 41 42 static uint64_t getCUAbbrev(StringRef Abbrev, uint64_t AbbrCode) { 43 uint64_t Offset = 0; 44 DataExtractor AbbrevData(Abbrev, true, 0); 45 while (AbbrevData.getULEB128(&Offset) != AbbrCode) { 46 // Tag 47 AbbrevData.getULEB128(&Offset); 48 // DW_CHILDREN 49 AbbrevData.getU8(&Offset); 50 // Attributes 51 while (AbbrevData.getULEB128(&Offset) | AbbrevData.getULEB128(&Offset)) 52 ; 53 } 54 return Offset; 55 } 56 57 static Expected<const char *> 58 getIndexedString(dwarf::Form Form, DataExtractor InfoData, uint64_t &InfoOffset, 59 StringRef StrOffsets, StringRef Str, uint16_t Version) { 60 if (Form == dwarf::DW_FORM_string) 61 return InfoData.getCStr(&InfoOffset); 62 uint64_t StrIndex; 63 switch (Form) { 64 case dwarf::DW_FORM_strx1: 65 StrIndex = InfoData.getU8(&InfoOffset); 66 break; 67 case dwarf::DW_FORM_strx2: 68 StrIndex = InfoData.getU16(&InfoOffset); 69 break; 70 case dwarf::DW_FORM_strx3: 71 StrIndex = InfoData.getU24(&InfoOffset); 72 break; 73 case dwarf::DW_FORM_strx4: 74 StrIndex = InfoData.getU32(&InfoOffset); 75 break; 76 case dwarf::DW_FORM_strx: 77 case dwarf::DW_FORM_GNU_str_index: 78 StrIndex = InfoData.getULEB128(&InfoOffset); 79 break; 80 default: 81 return make_error<DWPError>( 82 "string field must be encoded with one of the following: " 83 "DW_FORM_string, DW_FORM_strx, DW_FORM_strx1, DW_FORM_strx2, " 84 "DW_FORM_strx3, DW_FORM_strx4, or DW_FORM_GNU_str_index."); 85 } 86 DataExtractor StrOffsetsData(StrOffsets, true, 0); 87 uint64_t StrOffsetsOffset = 4 * StrIndex; 88 StrOffsetsOffset += debugStrOffsetsHeaderSize(StrOffsetsData, Version); 89 90 uint64_t StrOffset = StrOffsetsData.getU32(&StrOffsetsOffset); 91 DataExtractor StrData(Str, true, 0); 92 return StrData.getCStr(&StrOffset); 93 } 94 95 static Expected<CompileUnitIdentifiers> 96 getCUIdentifiers(InfoSectionUnitHeader &Header, StringRef Abbrev, 97 StringRef Info, StringRef StrOffsets, StringRef Str) { 98 DataExtractor InfoData(Info, true, 0); 99 uint64_t Offset = Header.HeaderSize; 100 if (Header.Version >= 5 && Header.UnitType != dwarf::DW_UT_split_compile) 101 return make_error<DWPError>( 102 std::string("unit type DW_UT_split_compile type not found in " 103 "debug_info header. Unexpected unit type 0x" + 104 utostr(Header.UnitType) + " found")); 105 106 CompileUnitIdentifiers ID; 107 108 uint32_t AbbrCode = InfoData.getULEB128(&Offset); 109 DataExtractor AbbrevData(Abbrev, true, 0); 110 uint64_t AbbrevOffset = getCUAbbrev(Abbrev, AbbrCode); 111 auto Tag = static_cast<dwarf::Tag>(AbbrevData.getULEB128(&AbbrevOffset)); 112 if (Tag != dwarf::DW_TAG_compile_unit) 113 return make_error<DWPError>("top level DIE is not a compile unit"); 114 // DW_CHILDREN 115 AbbrevData.getU8(&AbbrevOffset); 116 uint32_t Name; 117 dwarf::Form Form; 118 while ((Name = AbbrevData.getULEB128(&AbbrevOffset)) | 119 (Form = static_cast<dwarf::Form>( 120 AbbrevData.getULEB128(&AbbrevOffset))) && 121 (Name != 0 || Form != 0)) { 122 switch (Name) { 123 case dwarf::DW_AT_name: { 124 Expected<const char *> EName = getIndexedString( 125 Form, InfoData, Offset, StrOffsets, Str, Header.Version); 126 if (!EName) 127 return EName.takeError(); 128 ID.Name = *EName; 129 break; 130 } 131 case dwarf::DW_AT_GNU_dwo_name: 132 case dwarf::DW_AT_dwo_name: { 133 Expected<const char *> EName = getIndexedString( 134 Form, InfoData, Offset, StrOffsets, Str, Header.Version); 135 if (!EName) 136 return EName.takeError(); 137 ID.DWOName = *EName; 138 break; 139 } 140 case dwarf::DW_AT_GNU_dwo_id: 141 Header.Signature = InfoData.getU64(&Offset); 142 break; 143 default: 144 DWARFFormValue::skipValue( 145 Form, InfoData, &Offset, 146 dwarf::FormParams({Header.Version, Header.AddrSize, Header.Format})); 147 } 148 } 149 if (!Header.Signature) 150 return make_error<DWPError>("compile unit missing dwo_id"); 151 ID.Signature = *Header.Signature; 152 return ID; 153 } 154 155 static bool isSupportedSectionKind(DWARFSectionKind Kind) { 156 return Kind != DW_SECT_EXT_unknown; 157 } 158 159 namespace llvm { 160 // Convert an internal section identifier into the index to use with 161 // UnitIndexEntry::Contributions. 162 unsigned getContributionIndex(DWARFSectionKind Kind, uint32_t IndexVersion) { 163 assert(serializeSectionKind(Kind, IndexVersion) >= DW_SECT_INFO); 164 return serializeSectionKind(Kind, IndexVersion) - DW_SECT_INFO; 165 } 166 } // namespace llvm 167 168 // Convert a UnitIndexEntry::Contributions index to the corresponding on-disk 169 // value of the section identifier. 170 static unsigned getOnDiskSectionId(unsigned Index) { 171 return Index + DW_SECT_INFO; 172 } 173 174 static StringRef getSubsection(StringRef Section, 175 const DWARFUnitIndex::Entry &Entry, 176 DWARFSectionKind Kind) { 177 const auto *Off = Entry.getContribution(Kind); 178 if (!Off) 179 return StringRef(); 180 return Section.substr(Off->getOffset(), Off->getLength()); 181 } 182 183 static Error sectionOverflowErrorOrWarning(uint32_t PrevOffset, 184 uint32_t OverflowedOffset, 185 StringRef SectionName, 186 OnCuIndexOverflow OverflowOptValue, 187 bool &AnySectionOverflow) { 188 std::string Msg = 189 (SectionName + 190 Twine(" Section Contribution Offset overflow 4G. Previous Offset ") + 191 Twine(PrevOffset) + Twine(", After overflow offset ") + 192 Twine(OverflowedOffset) + Twine(".")) 193 .str(); 194 if (OverflowOptValue == OnCuIndexOverflow::Continue) { 195 WithColor::defaultWarningHandler(make_error<DWPError>(Msg)); 196 return Error::success(); 197 } else if (OverflowOptValue == OnCuIndexOverflow::SoftStop) { 198 AnySectionOverflow = true; 199 WithColor::defaultWarningHandler(make_error<DWPError>(Msg)); 200 return Error::success(); 201 } 202 return make_error<DWPError>(Msg); 203 } 204 205 static Error addAllTypesFromDWP( 206 MCStreamer &Out, MapVector<uint64_t, UnitIndexEntry> &TypeIndexEntries, 207 const DWARFUnitIndex &TUIndex, MCSection *OutputTypes, StringRef Types, 208 const UnitIndexEntry &TUEntry, uint32_t &TypesOffset, 209 unsigned TypesContributionIndex, OnCuIndexOverflow OverflowOptValue, 210 bool &AnySectionOverflow) { 211 Out.switchSection(OutputTypes); 212 for (const DWARFUnitIndex::Entry &E : TUIndex.getRows()) { 213 auto *I = E.getContributions(); 214 if (!I) 215 continue; 216 auto P = TypeIndexEntries.insert(std::make_pair(E.getSignature(), TUEntry)); 217 if (!P.second) 218 continue; 219 auto &Entry = P.first->second; 220 // Zero out the debug_info contribution 221 Entry.Contributions[0] = {}; 222 for (auto Kind : TUIndex.getColumnKinds()) { 223 if (!isSupportedSectionKind(Kind)) 224 continue; 225 auto &C = 226 Entry.Contributions[getContributionIndex(Kind, TUIndex.getVersion())]; 227 C.setOffset(C.getOffset() + I->getOffset()); 228 C.setLength(I->getLength()); 229 ++I; 230 } 231 auto &C = Entry.Contributions[TypesContributionIndex]; 232 Out.emitBytes(Types.substr( 233 C.getOffset() - 234 TUEntry.Contributions[TypesContributionIndex].getOffset(), 235 C.getLength())); 236 C.setOffset(TypesOffset); 237 uint32_t OldOffset = TypesOffset; 238 static_assert(sizeof(OldOffset) == sizeof(TypesOffset)); 239 TypesOffset += C.getLength(); 240 if (OldOffset > TypesOffset) { 241 if (Error Err = sectionOverflowErrorOrWarning(OldOffset, TypesOffset, 242 "Types", OverflowOptValue, 243 AnySectionOverflow)) 244 return Err; 245 if (AnySectionOverflow) { 246 TypesOffset = OldOffset; 247 return Error::success(); 248 } 249 } 250 } 251 return Error::success(); 252 } 253 254 static Error addAllTypesFromTypesSection( 255 MCStreamer &Out, MapVector<uint64_t, UnitIndexEntry> &TypeIndexEntries, 256 MCSection *OutputTypes, const std::vector<StringRef> &TypesSections, 257 const UnitIndexEntry &CUEntry, uint32_t &TypesOffset, 258 OnCuIndexOverflow OverflowOptValue, bool &AnySectionOverflow) { 259 for (StringRef Types : TypesSections) { 260 Out.switchSection(OutputTypes); 261 uint64_t Offset = 0; 262 DataExtractor Data(Types, true, 0); 263 while (Data.isValidOffset(Offset)) { 264 UnitIndexEntry Entry = CUEntry; 265 // Zero out the debug_info contribution 266 Entry.Contributions[0] = {}; 267 auto &C = Entry.Contributions[getContributionIndex(DW_SECT_EXT_TYPES, 2)]; 268 C.setOffset(TypesOffset); 269 auto PrevOffset = Offset; 270 // Length of the unit, including the 4 byte length field. 271 C.setLength(Data.getU32(&Offset) + 4); 272 273 Data.getU16(&Offset); // Version 274 Data.getU32(&Offset); // Abbrev offset 275 Data.getU8(&Offset); // Address size 276 auto Signature = Data.getU64(&Offset); 277 Offset = PrevOffset + C.getLength32(); 278 279 auto P = TypeIndexEntries.insert(std::make_pair(Signature, Entry)); 280 if (!P.second) 281 continue; 282 283 Out.emitBytes(Types.substr(PrevOffset, C.getLength32())); 284 uint32_t OldOffset = TypesOffset; 285 TypesOffset += C.getLength32(); 286 if (OldOffset > TypesOffset) { 287 if (Error Err = sectionOverflowErrorOrWarning(OldOffset, TypesOffset, 288 "Types", OverflowOptValue, 289 AnySectionOverflow)) 290 return Err; 291 if (AnySectionOverflow) { 292 TypesOffset = OldOffset; 293 return Error::success(); 294 } 295 } 296 } 297 } 298 return Error::success(); 299 } 300 301 static std::string buildDWODescription(StringRef Name, StringRef DWPName, 302 StringRef DWOName) { 303 std::string Text = "\'"; 304 Text += Name; 305 Text += '\''; 306 bool HasDWO = !DWOName.empty(); 307 bool HasDWP = !DWPName.empty(); 308 if (HasDWO || HasDWP) { 309 Text += " (from "; 310 if (HasDWO) { 311 Text += '\''; 312 Text += DWOName; 313 Text += '\''; 314 } 315 if (HasDWO && HasDWP) 316 Text += " in "; 317 if (!DWPName.empty()) { 318 Text += '\''; 319 Text += DWPName; 320 Text += '\''; 321 } 322 Text += ")"; 323 } 324 return Text; 325 } 326 327 static Error createError(StringRef Name, Error E) { 328 return make_error<DWPError>( 329 ("failure while decompressing compressed section: '" + Name + "', " + 330 llvm::toString(std::move(E))) 331 .str()); 332 } 333 334 static Error 335 handleCompressedSection(std::deque<SmallString<32>> &UncompressedSections, 336 SectionRef Sec, StringRef Name, StringRef &Contents) { 337 auto *Obj = dyn_cast<ELFObjectFileBase>(Sec.getObject()); 338 if (!Obj || 339 !(static_cast<ELFSectionRef>(Sec).getFlags() & ELF::SHF_COMPRESSED)) 340 return Error::success(); 341 bool IsLE = isa<object::ELF32LEObjectFile>(Obj) || 342 isa<object::ELF64LEObjectFile>(Obj); 343 bool Is64 = isa<object::ELF64LEObjectFile>(Obj) || 344 isa<object::ELF64BEObjectFile>(Obj); 345 Expected<Decompressor> Dec = Decompressor::create(Name, Contents, IsLE, Is64); 346 if (!Dec) 347 return createError(Name, Dec.takeError()); 348 349 UncompressedSections.emplace_back(); 350 if (Error E = Dec->resizeAndDecompress(UncompressedSections.back())) 351 return createError(Name, std::move(E)); 352 353 Contents = UncompressedSections.back(); 354 return Error::success(); 355 } 356 357 namespace llvm { 358 // Parse and return the header of an info section compile/type unit. 359 Expected<InfoSectionUnitHeader> parseInfoSectionUnitHeader(StringRef Info) { 360 InfoSectionUnitHeader Header; 361 Error Err = Error::success(); 362 uint64_t Offset = 0; 363 DWARFDataExtractor InfoData(Info, true, 0); 364 std::tie(Header.Length, Header.Format) = 365 InfoData.getInitialLength(&Offset, &Err); 366 if (Err) 367 return make_error<DWPError>("cannot parse compile unit length: " + 368 llvm::toString(std::move(Err))); 369 370 if (!InfoData.isValidOffset(Offset + (Header.Length - 1))) { 371 return make_error<DWPError>( 372 "compile unit exceeds .debug_info section range: " + 373 utostr(Offset + Header.Length) + " >= " + utostr(InfoData.size())); 374 } 375 376 Header.Version = InfoData.getU16(&Offset, &Err); 377 if (Err) 378 return make_error<DWPError>("cannot parse compile unit version: " + 379 llvm::toString(std::move(Err))); 380 381 uint64_t MinHeaderLength; 382 if (Header.Version >= 5) { 383 // Size: Version (2), UnitType (1), AddrSize (1), DebugAbbrevOffset (4), 384 // Signature (8) 385 MinHeaderLength = 16; 386 } else { 387 // Size: Version (2), DebugAbbrevOffset (4), AddrSize (1) 388 MinHeaderLength = 7; 389 } 390 if (Header.Length < MinHeaderLength) { 391 return make_error<DWPError>("unit length is too small: expected at least " + 392 utostr(MinHeaderLength) + " got " + 393 utostr(Header.Length) + "."); 394 } 395 if (Header.Version >= 5) { 396 Header.UnitType = InfoData.getU8(&Offset); 397 Header.AddrSize = InfoData.getU8(&Offset); 398 Header.DebugAbbrevOffset = InfoData.getU32(&Offset); 399 Header.Signature = InfoData.getU64(&Offset); 400 if (Header.UnitType == dwarf::DW_UT_split_type) { 401 // Type offset. 402 MinHeaderLength += 4; 403 if (Header.Length < MinHeaderLength) 404 return make_error<DWPError>("type unit is missing type offset"); 405 InfoData.getU32(&Offset); 406 } 407 } else { 408 // Note that, address_size and debug_abbrev_offset fields have switched 409 // places between dwarf version 4 and 5. 410 Header.DebugAbbrevOffset = InfoData.getU32(&Offset); 411 Header.AddrSize = InfoData.getU8(&Offset); 412 } 413 414 Header.HeaderSize = Offset; 415 return Header; 416 } 417 418 static void writeNewOffsetsTo(MCStreamer &Out, DataExtractor &Data, 419 DenseMap<uint64_t, uint32_t> &OffsetRemapping, 420 uint64_t &Offset, uint64_t &Size) { 421 422 while (Offset < Size) { 423 auto OldOffset = Data.getU32(&Offset); 424 auto NewOffset = OffsetRemapping[OldOffset]; 425 Out.emitIntValue(NewOffset, 4); 426 } 427 } 428 429 void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings, 430 MCSection *StrOffsetSection, 431 StringRef CurStrSection, 432 StringRef CurStrOffsetSection, uint16_t Version) { 433 // Could possibly produce an error or warning if one of these was non-null but 434 // the other was null. 435 if (CurStrSection.empty() || CurStrOffsetSection.empty()) 436 return; 437 438 DenseMap<uint64_t, uint32_t> OffsetRemapping; 439 440 DataExtractor Data(CurStrSection, true, 0); 441 uint64_t LocalOffset = 0; 442 uint64_t PrevOffset = 0; 443 while (const char *S = Data.getCStr(&LocalOffset)) { 444 OffsetRemapping[PrevOffset] = 445 Strings.getOffset(S, LocalOffset - PrevOffset); 446 PrevOffset = LocalOffset; 447 } 448 449 Data = DataExtractor(CurStrOffsetSection, true, 0); 450 451 Out.switchSection(StrOffsetSection); 452 453 uint64_t Offset = 0; 454 uint64_t Size = CurStrOffsetSection.size(); 455 if (Version > 4) { 456 while (Offset < Size) { 457 uint64_t HeaderSize = debugStrOffsetsHeaderSize(Data, Version); 458 assert(HeaderSize <= Size - Offset && 459 "StrOffsetSection size is less than its header"); 460 461 uint64_t ContributionEnd = 0; 462 uint64_t ContributionSize = 0; 463 uint64_t HeaderLengthOffset = Offset; 464 if (HeaderSize == 8) { 465 ContributionSize = Data.getU32(&HeaderLengthOffset); 466 } else if (HeaderSize == 16) { 467 HeaderLengthOffset += 4; // skip the dwarf64 marker 468 ContributionSize = Data.getU64(&HeaderLengthOffset); 469 } 470 ContributionEnd = ContributionSize + HeaderLengthOffset; 471 Out.emitBytes(Data.getBytes(&Offset, HeaderSize)); 472 writeNewOffsetsTo(Out, Data, OffsetRemapping, Offset, ContributionEnd); 473 } 474 475 } else { 476 writeNewOffsetsTo(Out, Data, OffsetRemapping, Offset, Size); 477 } 478 } 479 480 enum AccessField { Offset, Length }; 481 void writeIndexTable(MCStreamer &Out, ArrayRef<unsigned> ContributionOffsets, 482 const MapVector<uint64_t, UnitIndexEntry> &IndexEntries, 483 const AccessField &Field) { 484 for (const auto &E : IndexEntries) 485 for (size_t I = 0; I != std::size(E.second.Contributions); ++I) 486 if (ContributionOffsets[I]) 487 Out.emitIntValue((Field == AccessField::Offset 488 ? E.second.Contributions[I].getOffset32() 489 : E.second.Contributions[I].getLength32()), 490 4); 491 } 492 493 void writeIndex(MCStreamer &Out, MCSection *Section, 494 ArrayRef<unsigned> ContributionOffsets, 495 const MapVector<uint64_t, UnitIndexEntry> &IndexEntries, 496 uint32_t IndexVersion) { 497 if (IndexEntries.empty()) 498 return; 499 500 unsigned Columns = 0; 501 for (auto &C : ContributionOffsets) 502 if (C) 503 ++Columns; 504 505 std::vector<unsigned> Buckets(NextPowerOf2(3 * IndexEntries.size() / 2)); 506 uint64_t Mask = Buckets.size() - 1; 507 size_t I = 0; 508 for (const auto &P : IndexEntries) { 509 auto S = P.first; 510 auto H = S & Mask; 511 auto HP = ((S >> 32) & Mask) | 1; 512 while (Buckets[H]) { 513 assert(S != IndexEntries.begin()[Buckets[H] - 1].first && 514 "Duplicate unit"); 515 H = (H + HP) & Mask; 516 } 517 Buckets[H] = I + 1; 518 ++I; 519 } 520 521 Out.switchSection(Section); 522 Out.emitIntValue(IndexVersion, 4); // Version 523 Out.emitIntValue(Columns, 4); // Columns 524 Out.emitIntValue(IndexEntries.size(), 4); // Num Units 525 Out.emitIntValue(Buckets.size(), 4); // Num Buckets 526 527 // Write the signatures. 528 for (const auto &I : Buckets) 529 Out.emitIntValue(I ? IndexEntries.begin()[I - 1].first : 0, 8); 530 531 // Write the indexes. 532 for (const auto &I : Buckets) 533 Out.emitIntValue(I, 4); 534 535 // Write the column headers (which sections will appear in the table) 536 for (size_t I = 0; I != ContributionOffsets.size(); ++I) 537 if (ContributionOffsets[I]) 538 Out.emitIntValue(getOnDiskSectionId(I), 4); 539 540 // Write the offsets. 541 writeIndexTable(Out, ContributionOffsets, IndexEntries, AccessField::Offset); 542 543 // Write the lengths. 544 writeIndexTable(Out, ContributionOffsets, IndexEntries, AccessField::Length); 545 } 546 547 Error buildDuplicateError(const std::pair<uint64_t, UnitIndexEntry> &PrevE, 548 const CompileUnitIdentifiers &ID, StringRef DWPName) { 549 return make_error<DWPError>( 550 std::string("duplicate DWO ID (") + utohexstr(PrevE.first) + ") in " + 551 buildDWODescription(PrevE.second.Name, PrevE.second.DWPName, 552 PrevE.second.DWOName) + 553 " and " + buildDWODescription(ID.Name, DWPName, ID.DWOName)); 554 } 555 556 Error handleSection( 557 const StringMap<std::pair<MCSection *, DWARFSectionKind>> &KnownSections, 558 const MCSection *StrSection, const MCSection *StrOffsetSection, 559 const MCSection *TypesSection, const MCSection *CUIndexSection, 560 const MCSection *TUIndexSection, const MCSection *InfoSection, 561 const SectionRef &Section, MCStreamer &Out, 562 std::deque<SmallString<32>> &UncompressedSections, 563 uint32_t (&ContributionOffsets)[8], UnitIndexEntry &CurEntry, 564 StringRef &CurStrSection, StringRef &CurStrOffsetSection, 565 std::vector<StringRef> &CurTypesSection, 566 std::vector<StringRef> &CurInfoSection, StringRef &AbbrevSection, 567 StringRef &CurCUIndexSection, StringRef &CurTUIndexSection, 568 std::vector<std::pair<DWARFSectionKind, uint32_t>> &SectionLength) { 569 if (Section.isBSS()) 570 return Error::success(); 571 572 if (Section.isVirtual()) 573 return Error::success(); 574 575 Expected<StringRef> NameOrErr = Section.getName(); 576 if (!NameOrErr) 577 return NameOrErr.takeError(); 578 StringRef Name = *NameOrErr; 579 580 Expected<StringRef> ContentsOrErr = Section.getContents(); 581 if (!ContentsOrErr) 582 return ContentsOrErr.takeError(); 583 StringRef Contents = *ContentsOrErr; 584 585 if (auto Err = handleCompressedSection(UncompressedSections, Section, Name, 586 Contents)) 587 return Err; 588 589 Name = Name.substr(Name.find_first_not_of("._")); 590 591 auto SectionPair = KnownSections.find(Name); 592 if (SectionPair == KnownSections.end()) 593 return Error::success(); 594 595 if (DWARFSectionKind Kind = SectionPair->second.second) { 596 if (Kind != DW_SECT_EXT_TYPES && Kind != DW_SECT_INFO) { 597 SectionLength.push_back(std::make_pair(Kind, Contents.size())); 598 } 599 600 if (Kind == DW_SECT_ABBREV) { 601 AbbrevSection = Contents; 602 } 603 } 604 605 MCSection *OutSection = SectionPair->second.first; 606 if (OutSection == StrOffsetSection) 607 CurStrOffsetSection = Contents; 608 else if (OutSection == StrSection) 609 CurStrSection = Contents; 610 else if (OutSection == TypesSection) 611 CurTypesSection.push_back(Contents); 612 else if (OutSection == CUIndexSection) 613 CurCUIndexSection = Contents; 614 else if (OutSection == TUIndexSection) 615 CurTUIndexSection = Contents; 616 else if (OutSection == InfoSection) 617 CurInfoSection.push_back(Contents); 618 else { 619 Out.switchSection(OutSection); 620 Out.emitBytes(Contents); 621 } 622 return Error::success(); 623 } 624 625 Error write(MCStreamer &Out, ArrayRef<std::string> Inputs, 626 OnCuIndexOverflow OverflowOptValue) { 627 const auto &MCOFI = *Out.getContext().getObjectFileInfo(); 628 MCSection *const StrSection = MCOFI.getDwarfStrDWOSection(); 629 MCSection *const StrOffsetSection = MCOFI.getDwarfStrOffDWOSection(); 630 MCSection *const TypesSection = MCOFI.getDwarfTypesDWOSection(); 631 MCSection *const CUIndexSection = MCOFI.getDwarfCUIndexSection(); 632 MCSection *const TUIndexSection = MCOFI.getDwarfTUIndexSection(); 633 MCSection *const InfoSection = MCOFI.getDwarfInfoDWOSection(); 634 const StringMap<std::pair<MCSection *, DWARFSectionKind>> KnownSections = { 635 {"debug_info.dwo", {InfoSection, DW_SECT_INFO}}, 636 {"debug_types.dwo", {MCOFI.getDwarfTypesDWOSection(), DW_SECT_EXT_TYPES}}, 637 {"debug_str_offsets.dwo", {StrOffsetSection, DW_SECT_STR_OFFSETS}}, 638 {"debug_str.dwo", {StrSection, static_cast<DWARFSectionKind>(0)}}, 639 {"debug_loc.dwo", {MCOFI.getDwarfLocDWOSection(), DW_SECT_EXT_LOC}}, 640 {"debug_line.dwo", {MCOFI.getDwarfLineDWOSection(), DW_SECT_LINE}}, 641 {"debug_macro.dwo", {MCOFI.getDwarfMacroDWOSection(), DW_SECT_MACRO}}, 642 {"debug_abbrev.dwo", {MCOFI.getDwarfAbbrevDWOSection(), DW_SECT_ABBREV}}, 643 {"debug_loclists.dwo", 644 {MCOFI.getDwarfLoclistsDWOSection(), DW_SECT_LOCLISTS}}, 645 {"debug_rnglists.dwo", 646 {MCOFI.getDwarfRnglistsDWOSection(), DW_SECT_RNGLISTS}}, 647 {"debug_cu_index", {CUIndexSection, static_cast<DWARFSectionKind>(0)}}, 648 {"debug_tu_index", {TUIndexSection, static_cast<DWARFSectionKind>(0)}}}; 649 650 MapVector<uint64_t, UnitIndexEntry> IndexEntries; 651 MapVector<uint64_t, UnitIndexEntry> TypeIndexEntries; 652 653 uint32_t ContributionOffsets[8] = {}; 654 uint16_t Version = 0; 655 uint32_t IndexVersion = 0; 656 bool AnySectionOverflow = false; 657 658 DWPStringPool Strings(Out, StrSection); 659 660 SmallVector<OwningBinary<object::ObjectFile>, 128> Objects; 661 Objects.reserve(Inputs.size()); 662 663 std::deque<SmallString<32>> UncompressedSections; 664 665 for (const auto &Input : Inputs) { 666 auto ErrOrObj = object::ObjectFile::createObjectFile(Input); 667 if (!ErrOrObj) { 668 return handleErrors(ErrOrObj.takeError(), 669 [&](std::unique_ptr<ECError> EC) -> Error { 670 return createFileError(Input, Error(std::move(EC))); 671 }); 672 } 673 674 auto &Obj = *ErrOrObj->getBinary(); 675 Objects.push_back(std::move(*ErrOrObj)); 676 677 UnitIndexEntry CurEntry = {}; 678 679 StringRef CurStrSection; 680 StringRef CurStrOffsetSection; 681 std::vector<StringRef> CurTypesSection; 682 std::vector<StringRef> CurInfoSection; 683 StringRef AbbrevSection; 684 StringRef CurCUIndexSection; 685 StringRef CurTUIndexSection; 686 687 // This maps each section contained in this file to its length. 688 // This information is later on used to calculate the contributions, 689 // i.e. offset and length, of each compile/type unit to a section. 690 std::vector<std::pair<DWARFSectionKind, uint32_t>> SectionLength; 691 692 for (const auto &Section : Obj.sections()) 693 if (auto Err = handleSection( 694 KnownSections, StrSection, StrOffsetSection, TypesSection, 695 CUIndexSection, TUIndexSection, InfoSection, Section, Out, 696 UncompressedSections, ContributionOffsets, CurEntry, 697 CurStrSection, CurStrOffsetSection, CurTypesSection, 698 CurInfoSection, AbbrevSection, CurCUIndexSection, 699 CurTUIndexSection, SectionLength)) 700 return Err; 701 702 if (CurInfoSection.empty()) 703 continue; 704 705 Expected<InfoSectionUnitHeader> HeaderOrErr = 706 parseInfoSectionUnitHeader(CurInfoSection.front()); 707 if (!HeaderOrErr) 708 return HeaderOrErr.takeError(); 709 InfoSectionUnitHeader &Header = *HeaderOrErr; 710 711 if (Version == 0) { 712 Version = Header.Version; 713 IndexVersion = Version < 5 ? 2 : 5; 714 } else if (Version != Header.Version) { 715 return make_error<DWPError>("incompatible DWARF compile unit versions."); 716 } 717 718 writeStringsAndOffsets(Out, Strings, StrOffsetSection, CurStrSection, 719 CurStrOffsetSection, Header.Version); 720 721 for (auto Pair : SectionLength) { 722 auto Index = getContributionIndex(Pair.first, IndexVersion); 723 CurEntry.Contributions[Index].setOffset(ContributionOffsets[Index]); 724 CurEntry.Contributions[Index].setLength(Pair.second); 725 uint32_t OldOffset = ContributionOffsets[Index]; 726 ContributionOffsets[Index] += CurEntry.Contributions[Index].getLength32(); 727 if (OldOffset > ContributionOffsets[Index]) { 728 uint32_t SectionIndex = 0; 729 for (auto &Section : Obj.sections()) { 730 if (SectionIndex == Index) { 731 if (Error Err = sectionOverflowErrorOrWarning( 732 OldOffset, ContributionOffsets[Index], *Section.getName(), 733 OverflowOptValue, AnySectionOverflow)) 734 return Err; 735 } 736 ++SectionIndex; 737 } 738 if (AnySectionOverflow) 739 break; 740 } 741 } 742 743 uint32_t &InfoSectionOffset = 744 ContributionOffsets[getContributionIndex(DW_SECT_INFO, IndexVersion)]; 745 if (CurCUIndexSection.empty()) { 746 bool FoundCUUnit = false; 747 Out.switchSection(InfoSection); 748 for (StringRef Info : CurInfoSection) { 749 uint64_t UnitOffset = 0; 750 while (Info.size() > UnitOffset) { 751 Expected<InfoSectionUnitHeader> HeaderOrError = 752 parseInfoSectionUnitHeader(Info.substr(UnitOffset, Info.size())); 753 if (!HeaderOrError) 754 return HeaderOrError.takeError(); 755 InfoSectionUnitHeader &Header = *HeaderOrError; 756 757 UnitIndexEntry Entry = CurEntry; 758 auto &C = Entry.Contributions[getContributionIndex(DW_SECT_INFO, 759 IndexVersion)]; 760 C.setOffset(InfoSectionOffset); 761 C.setLength(Header.Length + 4); 762 763 if (std::numeric_limits<uint32_t>::max() - InfoSectionOffset < 764 C.getLength32()) { 765 if (Error Err = sectionOverflowErrorOrWarning( 766 InfoSectionOffset, InfoSectionOffset + C.getLength32(), 767 "debug_info", OverflowOptValue, AnySectionOverflow)) 768 return Err; 769 if (AnySectionOverflow) { 770 if (Header.Version < 5 || 771 Header.UnitType == dwarf::DW_UT_split_compile) 772 FoundCUUnit = true; 773 break; 774 } 775 } 776 777 UnitOffset += C.getLength32(); 778 if (Header.Version < 5 || 779 Header.UnitType == dwarf::DW_UT_split_compile) { 780 Expected<CompileUnitIdentifiers> EID = getCUIdentifiers( 781 Header, AbbrevSection, 782 Info.substr(UnitOffset - C.getLength32(), C.getLength32()), 783 CurStrOffsetSection, CurStrSection); 784 785 if (!EID) 786 return createFileError(Input, EID.takeError()); 787 const auto &ID = *EID; 788 auto P = IndexEntries.insert(std::make_pair(ID.Signature, Entry)); 789 if (!P.second) 790 return buildDuplicateError(*P.first, ID, ""); 791 P.first->second.Name = ID.Name; 792 P.first->second.DWOName = ID.DWOName; 793 794 FoundCUUnit = true; 795 } else if (Header.UnitType == dwarf::DW_UT_split_type) { 796 auto P = TypeIndexEntries.insert( 797 std::make_pair(*Header.Signature, Entry)); 798 if (!P.second) 799 continue; 800 } 801 Out.emitBytes( 802 Info.substr(UnitOffset - C.getLength32(), C.getLength32())); 803 InfoSectionOffset += C.getLength32(); 804 } 805 if (AnySectionOverflow) 806 break; 807 } 808 809 if (!FoundCUUnit) 810 return make_error<DWPError>("no compile unit found in file: " + Input); 811 812 if (IndexVersion == 2) { 813 // Add types from the .debug_types section from DWARF < 5. 814 if (Error Err = addAllTypesFromTypesSection( 815 Out, TypeIndexEntries, TypesSection, CurTypesSection, CurEntry, 816 ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)], 817 OverflowOptValue, AnySectionOverflow)) 818 return Err; 819 } 820 if (AnySectionOverflow) 821 break; 822 continue; 823 } 824 825 if (CurInfoSection.size() != 1) 826 return make_error<DWPError>("expected exactly one occurrence of a debug " 827 "info section in a .dwp file"); 828 StringRef DwpSingleInfoSection = CurInfoSection.front(); 829 830 DWARFUnitIndex CUIndex(DW_SECT_INFO); 831 DataExtractor CUIndexData(CurCUIndexSection, Obj.isLittleEndian(), 0); 832 if (!CUIndex.parse(CUIndexData)) 833 return make_error<DWPError>("failed to parse cu_index"); 834 if (CUIndex.getVersion() != IndexVersion) 835 return make_error<DWPError>("incompatible cu_index versions, found " + 836 utostr(CUIndex.getVersion()) + 837 " and expecting " + utostr(IndexVersion)); 838 839 Out.switchSection(InfoSection); 840 for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) { 841 auto *I = E.getContributions(); 842 if (!I) 843 continue; 844 auto P = IndexEntries.insert(std::make_pair(E.getSignature(), CurEntry)); 845 StringRef CUInfoSection = 846 getSubsection(DwpSingleInfoSection, E, DW_SECT_INFO); 847 Expected<InfoSectionUnitHeader> HeaderOrError = 848 parseInfoSectionUnitHeader(CUInfoSection); 849 if (!HeaderOrError) 850 return HeaderOrError.takeError(); 851 InfoSectionUnitHeader &Header = *HeaderOrError; 852 853 Expected<CompileUnitIdentifiers> EID = getCUIdentifiers( 854 Header, getSubsection(AbbrevSection, E, DW_SECT_ABBREV), 855 CUInfoSection, 856 getSubsection(CurStrOffsetSection, E, DW_SECT_STR_OFFSETS), 857 CurStrSection); 858 if (!EID) 859 return createFileError(Input, EID.takeError()); 860 const auto &ID = *EID; 861 if (!P.second) 862 return buildDuplicateError(*P.first, ID, Input); 863 auto &NewEntry = P.first->second; 864 NewEntry.Name = ID.Name; 865 NewEntry.DWOName = ID.DWOName; 866 NewEntry.DWPName = Input; 867 for (auto Kind : CUIndex.getColumnKinds()) { 868 if (!isSupportedSectionKind(Kind)) 869 continue; 870 auto &C = 871 NewEntry.Contributions[getContributionIndex(Kind, IndexVersion)]; 872 C.setOffset(C.getOffset() + I->getOffset()); 873 C.setLength(I->getLength()); 874 ++I; 875 } 876 unsigned Index = getContributionIndex(DW_SECT_INFO, IndexVersion); 877 auto &C = NewEntry.Contributions[Index]; 878 Out.emitBytes(CUInfoSection); 879 C.setOffset(InfoSectionOffset); 880 InfoSectionOffset += C.getLength32(); 881 } 882 883 if (!CurTUIndexSection.empty()) { 884 llvm::DWARFSectionKind TUSectionKind; 885 MCSection *OutSection; 886 StringRef TypeInputSection; 887 // Write type units into debug info section for DWARFv5. 888 if (Version >= 5) { 889 TUSectionKind = DW_SECT_INFO; 890 OutSection = InfoSection; 891 TypeInputSection = DwpSingleInfoSection; 892 } else { 893 // Write type units into debug types section for DWARF < 5. 894 if (CurTypesSection.size() != 1) 895 return make_error<DWPError>( 896 "multiple type unit sections in .dwp file"); 897 898 TUSectionKind = DW_SECT_EXT_TYPES; 899 OutSection = TypesSection; 900 TypeInputSection = CurTypesSection.front(); 901 } 902 903 DWARFUnitIndex TUIndex(TUSectionKind); 904 DataExtractor TUIndexData(CurTUIndexSection, Obj.isLittleEndian(), 0); 905 if (!TUIndex.parse(TUIndexData)) 906 return make_error<DWPError>("failed to parse tu_index"); 907 if (TUIndex.getVersion() != IndexVersion) 908 return make_error<DWPError>("incompatible tu_index versions, found " + 909 utostr(TUIndex.getVersion()) + 910 " and expecting " + utostr(IndexVersion)); 911 912 unsigned TypesContributionIndex = 913 getContributionIndex(TUSectionKind, IndexVersion); 914 if (Error Err = addAllTypesFromDWP( 915 Out, TypeIndexEntries, TUIndex, OutSection, TypeInputSection, 916 CurEntry, ContributionOffsets[TypesContributionIndex], 917 TypesContributionIndex, OverflowOptValue, AnySectionOverflow)) 918 return Err; 919 } 920 if (AnySectionOverflow) 921 break; 922 } 923 924 if (Version < 5) { 925 // Lie about there being no info contributions so the TU index only includes 926 // the type unit contribution for DWARF < 5. In DWARFv5 the TU index has a 927 // contribution to the info section, so we do not want to lie about it. 928 ContributionOffsets[0] = 0; 929 } 930 writeIndex(Out, MCOFI.getDwarfTUIndexSection(), ContributionOffsets, 931 TypeIndexEntries, IndexVersion); 932 933 if (Version < 5) { 934 // Lie about the type contribution for DWARF < 5. In DWARFv5 the type 935 // section does not exist, so no need to do anything about this. 936 ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)] = 0; 937 // Unlie about the info contribution 938 ContributionOffsets[0] = 1; 939 } 940 941 writeIndex(Out, MCOFI.getDwarfCUIndexSection(), ContributionOffsets, 942 IndexEntries, IndexVersion); 943 944 return Error::success(); 945 } 946 } // namespace llvm 947