llvm/lib/DWP/DWP.cpp

   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                                            bool ContinueOnCuIndexOverflow) {
 187   std::string Msg =
 188       (SectionName +
 189        Twine(" Section Contribution Offset overflow 4G. Previous Offset ") +
 190        Twine(PrevOffset) + Twine(", After overflow offset ") +
 191        Twine(OverflowedOffset) + Twine("."))
 192           .str();
 193   if (ContinueOnCuIndexOverflow) {
 194     WithColor::defaultWarningHandler(make_error<DWPError>(Msg));
 195     return Error::success();
 196   }
 197   return make_error<DWPError>(Msg);
 198 }
 199
 200 static Error addAllTypesFromDWP(
 201     MCStreamer &Out, MapVector<uint64_t, UnitIndexEntry> &TypeIndexEntries,
 202     const DWARFUnitIndex &TUIndex, MCSection *OutputTypes, StringRef Types,
 203     const UnitIndexEntry &TUEntry, uint32_t &TypesOffset,
 204     unsigned TypesContributionIndex, bool ContinueOnCuIndexOverflow) {
 205   Out.switchSection(OutputTypes);
 206   for (const DWARFUnitIndex::Entry &E : TUIndex.getRows()) {
 207     auto *I = E.getContributions();
 208     if (!I)
 209       continue;
 210     auto P = TypeIndexEntries.insert(std::make_pair(E.getSignature(), TUEntry));
 211     if (!P.second)
 212       continue;
 213     auto &Entry = P.first->second;
 214     // Zero out the debug_info contribution
 215     Entry.Contributions[0] = {};
 216     for (auto Kind : TUIndex.getColumnKinds()) {
 217       if (!isSupportedSectionKind(Kind))
 218         continue;
 219       auto &C =
 220           Entry.Contributions[getContributionIndex(Kind, TUIndex.getVersion())];
 221       C.setOffset(C.getOffset() + I->getOffset());
 222       C.setLength(I->getLength());
 223       ++I;
 224     }
 225     auto &C = Entry.Contributions[TypesContributionIndex];
 226     Out.emitBytes(Types.substr(
 227         C.getOffset() -
 228             TUEntry.Contributions[TypesContributionIndex].getOffset(),
 229         C.getLength()));
 230     C.setOffset(TypesOffset);
 231     uint32_t OldOffset = TypesOffset;
 232     static_assert(sizeof(OldOffset) == sizeof(TypesOffset));
 233     TypesOffset += C.getLength();
 234     if (OldOffset > TypesOffset) {
 235       if (Error Err = sectionOverflowErrorOrWarning(
 236               OldOffset, TypesOffset, "Types", ContinueOnCuIndexOverflow))
 237         return Err;
 238     }
 239   }
 240   return Error::success();
 241 }
 242
 243 static Error addAllTypesFromTypesSection(
 244     MCStreamer &Out, MapVector<uint64_t, UnitIndexEntry> &TypeIndexEntries,
 245     MCSection *OutputTypes, const std::vector<StringRef> &TypesSections,
 246     const UnitIndexEntry &CUEntry, uint32_t &TypesOffset,
 247     bool ContinueOnCuIndexOverflow) {
 248   for (StringRef Types : TypesSections) {
 249     Out.switchSection(OutputTypes);
 250     uint64_t Offset = 0;
 251     DataExtractor Data(Types, true, 0);
 252     while (Data.isValidOffset(Offset)) {
 253       UnitIndexEntry Entry = CUEntry;
 254       // Zero out the debug_info contribution
 255       Entry.Contributions[0] = {};
 256       auto &C = Entry.Contributions[getContributionIndex(DW_SECT_EXT_TYPES, 2)];
 257       C.setOffset(TypesOffset);
 258       auto PrevOffset = Offset;
 259       // Length of the unit, including the 4 byte length field.
 260       C.setLength(Data.getU32(&Offset) + 4);
 261
 262       Data.getU16(&Offset); // Version
 263       Data.getU32(&Offset); // Abbrev offset
 264       Data.getU8(&Offset);  // Address size
 265       auto Signature = Data.getU64(&Offset);
 266       Offset = PrevOffset + C.getLength32();
 267
 268       auto P = TypeIndexEntries.insert(std::make_pair(Signature, Entry));
 269       if (!P.second)
 270         continue;
 271
 272       Out.emitBytes(Types.substr(PrevOffset, C.getLength32()));
 273       uint32_t OldOffset = TypesOffset;
 274       TypesOffset += C.getLength32();
 275       if (OldOffset > TypesOffset) {
 276         if (Error Err = sectionOverflowErrorOrWarning(
 277                 OldOffset, TypesOffset, "types", ContinueOnCuIndexOverflow))
 278           return Err;
 279       }
 280     }
 281   }
 282   return Error::success();
 283 }
 284
 285 static std::string buildDWODescription(StringRef Name, StringRef DWPName,
 286                                        StringRef DWOName) {
 287   std::string Text = "\'";
 288   Text += Name;
 289   Text += '\'';
 290   bool HasDWO = !DWOName.empty();
 291   bool HasDWP = !DWPName.empty();
 292   if (HasDWO || HasDWP) {
 293     Text += " (from ";
 294     if (HasDWO) {
 295       Text += '\'';
 296       Text += DWOName;
 297       Text += '\'';
 298     }
 299     if (HasDWO && HasDWP)
 300       Text += " in ";
 301     if (!DWPName.empty()) {
 302       Text += '\'';
 303       Text += DWPName;
 304       Text += '\'';
 305     }
 306     Text += ")";
 307   }
 308   return Text;
 309 }
 310
 311 static Error createError(StringRef Name, Error E) {
 312   return make_error<DWPError>(
 313       ("failure while decompressing compressed section: '" + Name + "', " +
 314        llvm::toString(std::move(E)))
 315           .str());
 316 }
 317
 318 static Error
 319 handleCompressedSection(std::deque<SmallString<32>> &UncompressedSections,
 320                         SectionRef Sec, StringRef Name, StringRef &Contents) {
 321   auto *Obj = dyn_cast<ELFObjectFileBase>(Sec.getObject());
 322   if (!Obj ||
 323       !(static_cast<ELFSectionRef>(Sec).getFlags() & ELF::SHF_COMPRESSED))
 324     return Error::success();
 325   bool IsLE = isa<object::ELF32LEObjectFile>(Obj) ||
 326               isa<object::ELF64LEObjectFile>(Obj);
 327   bool Is64 = isa<object::ELF64LEObjectFile>(Obj) ||
 328               isa<object::ELF64BEObjectFile>(Obj);
 329   Expected<Decompressor> Dec = Decompressor::create(Name, Contents, IsLE, Is64);
 330   if (!Dec)
 331     return createError(Name, Dec.takeError());
 332
 333   UncompressedSections.emplace_back();
 334   if (Error E = Dec->resizeAndDecompress(UncompressedSections.back()))
 335     return createError(Name, std::move(E));
 336
 337   Contents = UncompressedSections.back();
 338   return Error::success();
 339 }
 340
 341 namespace llvm {
 342 // Parse and return the header of an info section compile/type unit.
 343 Expected<InfoSectionUnitHeader> parseInfoSectionUnitHeader(StringRef Info) {
 344   InfoSectionUnitHeader Header;
 345   Error Err = Error::success();
 346   uint64_t Offset = 0;
 347   DWARFDataExtractor InfoData(Info, true, 0);
 348   std::tie(Header.Length, Header.Format) =
 349       InfoData.getInitialLength(&Offset, &Err);
 350   if (Err)
 351     return make_error<DWPError>("cannot parse compile unit length: " +
 352                                 llvm::toString(std::move(Err)));
 353
 354   if (!InfoData.isValidOffset(Offset + (Header.Length - 1))) {
 355     return make_error<DWPError>(
 356         "compile unit exceeds .debug_info section range: " +
 357         utostr(Offset + Header.Length) + " >= " + utostr(InfoData.size()));
 358   }
 359
 360   Header.Version = InfoData.getU16(&Offset, &Err);
 361   if (Err)
 362     return make_error<DWPError>("cannot parse compile unit version: " +
 363                                 llvm::toString(std::move(Err)));
 364
 365   uint64_t MinHeaderLength;
 366   if (Header.Version >= 5) {
 367     // Size: Version (2), UnitType (1), AddrSize (1), DebugAbbrevOffset (4),
 368     // Signature (8)
 369     MinHeaderLength = 16;
 370   } else {
 371     // Size: Version (2), DebugAbbrevOffset (4), AddrSize (1)
 372     MinHeaderLength = 7;
 373   }
 374   if (Header.Length < MinHeaderLength) {
 375     return make_error<DWPError>("unit length is too small: expected at least " +
 376                                 utostr(MinHeaderLength) + " got " +
 377                                 utostr(Header.Length) + ".");
 378   }
 379   if (Header.Version >= 5) {
 380     Header.UnitType = InfoData.getU8(&Offset);
 381     Header.AddrSize = InfoData.getU8(&Offset);
 382     Header.DebugAbbrevOffset = InfoData.getU32(&Offset);
 383     Header.Signature = InfoData.getU64(&Offset);
 384     if (Header.UnitType == dwarf::DW_UT_split_type) {
 385       // Type offset.
 386       MinHeaderLength += 4;
 387       if (Header.Length < MinHeaderLength)
 388         return make_error<DWPError>("type unit is missing type offset");
 389       InfoData.getU32(&Offset);
 390     }
 391   } else {
 392     // Note that, address_size and debug_abbrev_offset fields have switched
 393     // places between dwarf version 4 and 5.
 394     Header.DebugAbbrevOffset = InfoData.getU32(&Offset);
 395     Header.AddrSize = InfoData.getU8(&Offset);
 396   }
 397
 398   Header.HeaderSize = Offset;
 399   return Header;
 400 }
 401
 402 void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings,
 403                             MCSection *StrOffsetSection,
 404                             StringRef CurStrSection,
 405                             StringRef CurStrOffsetSection, uint16_t Version) {
 406   // Could possibly produce an error or warning if one of these was non-null but
 407   // the other was null.
 408   if (CurStrSection.empty() || CurStrOffsetSection.empty())
 409     return;
 410
 411   DenseMap<uint64_t, uint32_t> OffsetRemapping;
 412
 413   DataExtractor Data(CurStrSection, true, 0);
 414   uint64_t LocalOffset = 0;
 415   uint64_t PrevOffset = 0;
 416   while (const char *S = Data.getCStr(&LocalOffset)) {
 417     OffsetRemapping[PrevOffset] =
 418         Strings.getOffset(S, LocalOffset - PrevOffset);
 419     PrevOffset = LocalOffset;
 420   }
 421
 422   Data = DataExtractor(CurStrOffsetSection, true, 0);
 423
 424   Out.switchSection(StrOffsetSection);
 425
 426   uint64_t HeaderSize = debugStrOffsetsHeaderSize(Data, Version);
 427   uint64_t Offset = 0;
 428   uint64_t Size = CurStrOffsetSection.size();
 429   // FIXME: This can be caused by bad input and should be handled as such.
 430   assert(HeaderSize <= Size && "StrOffsetSection size is less than its header");
 431   // Copy the header to the output.
 432   Out.emitBytes(Data.getBytes(&Offset, HeaderSize));
 433   while (Offset < Size) {
 434     auto OldOffset = Data.getU32(&Offset);
 435     auto NewOffset = OffsetRemapping[OldOffset];
 436     Out.emitIntValue(NewOffset, 4);
 437   }
 438 }
 439
 440 enum AccessField { Offset, Length };
 441 void writeIndexTable(MCStreamer &Out, ArrayRef<unsigned> ContributionOffsets,
 442                      const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
 443                      const AccessField &Field) {
 444   for (const auto &E : IndexEntries)
 445     for (size_t I = 0; I != std::size(E.second.Contributions); ++I)
 446       if (ContributionOffsets[I])
 447         Out.emitIntValue((Field == AccessField::Offset
 448                               ? E.second.Contributions[I].getOffset32()
 449                               : E.second.Contributions[I].getLength32()),
 450                          4);
 451 }
 452
 453 void writeIndex(MCStreamer &Out, MCSection *Section,
 454                 ArrayRef<unsigned> ContributionOffsets,
 455                 const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
 456                 uint32_t IndexVersion) {
 457   if (IndexEntries.empty())
 458     return;
 459
 460   unsigned Columns = 0;
 461   for (auto &C : ContributionOffsets)
 462     if (C)
 463       ++Columns;
 464
 465   std::vector<unsigned> Buckets(NextPowerOf2(3 * IndexEntries.size() / 2));
 466   uint64_t Mask = Buckets.size() - 1;
 467   size_t I = 0;
 468   for (const auto &P : IndexEntries) {
 469     auto S = P.first;
 470     auto H = S & Mask;
 471     auto HP = ((S >> 32) & Mask) | 1;
 472     while (Buckets[H]) {
 473       assert(S != IndexEntries.begin()[Buckets[H] - 1].first &&
 474              "Duplicate unit");
 475       H = (H + HP) & Mask;
 476     }
 477     Buckets[H] = I + 1;
 478     ++I;
 479   }
 480
 481   Out.switchSection(Section);
 482   Out.emitIntValue(IndexVersion, 4);        // Version
 483   Out.emitIntValue(Columns, 4);             // Columns
 484   Out.emitIntValue(IndexEntries.size(), 4); // Num Units
 485   Out.emitIntValue(Buckets.size(), 4);      // Num Buckets
 486
 487   // Write the signatures.
 488   for (const auto &I : Buckets)
 489     Out.emitIntValue(I ? IndexEntries.begin()[I - 1].first : 0, 8);
 490
 491   // Write the indexes.
 492   for (const auto &I : Buckets)
 493     Out.emitIntValue(I, 4);
 494
 495   // Write the column headers (which sections will appear in the table)
 496   for (size_t I = 0; I != ContributionOffsets.size(); ++I)
 497     if (ContributionOffsets[I])
 498       Out.emitIntValue(getOnDiskSectionId(I), 4);
 499
 500   // Write the offsets.
 501   writeIndexTable(Out, ContributionOffsets, IndexEntries, AccessField::Offset);
 502
 503   // Write the lengths.
 504   writeIndexTable(Out, ContributionOffsets, IndexEntries, AccessField::Length);
 505 }
 506
 507 Error buildDuplicateError(const std::pair<uint64_t, UnitIndexEntry> &PrevE,
 508                           const CompileUnitIdentifiers &ID, StringRef DWPName) {
 509   return make_error<DWPError>(
 510       std::string("duplicate DWO ID (") + utohexstr(PrevE.first) + ") in " +
 511       buildDWODescription(PrevE.second.Name, PrevE.second.DWPName,
 512                           PrevE.second.DWOName) +
 513       " and " + buildDWODescription(ID.Name, DWPName, ID.DWOName));
 514 }
 515
 516 Error handleSection(
 517     const StringMap<std::pair<MCSection *, DWARFSectionKind>> &KnownSections,
 518     const MCSection *StrSection, const MCSection *StrOffsetSection,
 519     const MCSection *TypesSection, const MCSection *CUIndexSection,
 520     const MCSection *TUIndexSection, const MCSection *InfoSection,
 521     const SectionRef &Section, MCStreamer &Out,
 522     std::deque<SmallString<32>> &UncompressedSections,
 523     uint32_t (&ContributionOffsets)[8], UnitIndexEntry &CurEntry,
 524     StringRef &CurStrSection, StringRef &CurStrOffsetSection,
 525     std::vector<StringRef> &CurTypesSection,
 526     std::vector<StringRef> &CurInfoSection, StringRef &AbbrevSection,
 527     StringRef &CurCUIndexSection, StringRef &CurTUIndexSection,
 528     std::vector<std::pair<DWARFSectionKind, uint32_t>> &SectionLength) {
 529   if (Section.isBSS())
 530     return Error::success();
 531
 532   if (Section.isVirtual())
 533     return Error::success();
 534
 535   Expected<StringRef> NameOrErr = Section.getName();
 536   if (!NameOrErr)
 537     return NameOrErr.takeError();
 538   StringRef Name = *NameOrErr;
 539
 540   Expected<StringRef> ContentsOrErr = Section.getContents();
 541   if (!ContentsOrErr)
 542     return ContentsOrErr.takeError();
 543   StringRef Contents = *ContentsOrErr;
 544
 545   if (auto Err = handleCompressedSection(UncompressedSections, Section, Name,
 546                                          Contents))
 547     return Err;
 548
 549   Name = Name.substr(Name.find_first_not_of("._"));
 550
 551   auto SectionPair = KnownSections.find(Name);
 552   if (SectionPair == KnownSections.end())
 553     return Error::success();
 554
 555   if (DWARFSectionKind Kind = SectionPair->second.second) {
 556     if (Kind != DW_SECT_EXT_TYPES && Kind != DW_SECT_INFO) {
 557       SectionLength.push_back(std::make_pair(Kind, Contents.size()));
 558     }
 559
 560     if (Kind == DW_SECT_ABBREV) {
 561       AbbrevSection = Contents;
 562     }
 563   }
 564
 565   MCSection *OutSection = SectionPair->second.first;
 566   if (OutSection == StrOffsetSection)
 567     CurStrOffsetSection = Contents;
 568   else if (OutSection == StrSection)
 569     CurStrSection = Contents;
 570   else if (OutSection == TypesSection)
 571     CurTypesSection.push_back(Contents);
 572   else if (OutSection == CUIndexSection)
 573     CurCUIndexSection = Contents;
 574   else if (OutSection == TUIndexSection)
 575     CurTUIndexSection = Contents;
 576   else if (OutSection == InfoSection)
 577     CurInfoSection.push_back(Contents);
 578   else {
 579     Out.switchSection(OutSection);
 580     Out.emitBytes(Contents);
 581   }
 582   return Error::success();
 583 }
 584
 585 Error write(MCStreamer &Out, ArrayRef<std::string> Inputs,
 586             bool ContinueOnCuIndexOverflow) {
 587   const auto &MCOFI = *Out.getContext().getObjectFileInfo();
 588   MCSection *const StrSection = MCOFI.getDwarfStrDWOSection();
 589   MCSection *const StrOffsetSection = MCOFI.getDwarfStrOffDWOSection();
 590   MCSection *const TypesSection = MCOFI.getDwarfTypesDWOSection();
 591   MCSection *const CUIndexSection = MCOFI.getDwarfCUIndexSection();
 592   MCSection *const TUIndexSection = MCOFI.getDwarfTUIndexSection();
 593   MCSection *const InfoSection = MCOFI.getDwarfInfoDWOSection();
 594   const StringMap<std::pair<MCSection *, DWARFSectionKind>> KnownSections = {
 595       {"debug_info.dwo", {InfoSection, DW_SECT_INFO}},
 596       {"debug_types.dwo", {MCOFI.getDwarfTypesDWOSection(), DW_SECT_EXT_TYPES}},
 597       {"debug_str_offsets.dwo", {StrOffsetSection, DW_SECT_STR_OFFSETS}},
 598       {"debug_str.dwo", {StrSection, static_cast<DWARFSectionKind>(0)}},
 599       {"debug_loc.dwo", {MCOFI.getDwarfLocDWOSection(), DW_SECT_EXT_LOC}},
 600       {"debug_line.dwo", {MCOFI.getDwarfLineDWOSection(), DW_SECT_LINE}},
 601       {"debug_macro.dwo", {MCOFI.getDwarfMacroDWOSection(), DW_SECT_MACRO}},
 602       {"debug_abbrev.dwo", {MCOFI.getDwarfAbbrevDWOSection(), DW_SECT_ABBREV}},
 603       {"debug_loclists.dwo",
 604        {MCOFI.getDwarfLoclistsDWOSection(), DW_SECT_LOCLISTS}},
 605       {"debug_rnglists.dwo",
 606        {MCOFI.getDwarfRnglistsDWOSection(), DW_SECT_RNGLISTS}},
 607       {"debug_cu_index", {CUIndexSection, static_cast<DWARFSectionKind>(0)}},
 608       {"debug_tu_index", {TUIndexSection, static_cast<DWARFSectionKind>(0)}}};
 609
 610   MapVector<uint64_t, UnitIndexEntry> IndexEntries;
 611   MapVector<uint64_t, UnitIndexEntry> TypeIndexEntries;
 612
 613   uint32_t ContributionOffsets[8] = {};
 614   uint16_t Version = 0;
 615   uint32_t IndexVersion = 0;
 616
 617   DWPStringPool Strings(Out, StrSection);
 618
 619   SmallVector<OwningBinary<object::ObjectFile>, 128> Objects;
 620   Objects.reserve(Inputs.size());
 621
 622   std::deque<SmallString<32>> UncompressedSections;
 623
 624   for (const auto &Input : Inputs) {
 625     auto ErrOrObj = object::ObjectFile::createObjectFile(Input);
 626     if (!ErrOrObj) {
 627       return handleErrors(ErrOrObj.takeError(),
 628                           [&](std::unique_ptr<ECError> EC) -> Error {
 629                             return createFileError(Input, Error(std::move(EC)));
 630                           });
 631     }
 632
 633     auto &Obj = *ErrOrObj->getBinary();
 634     Objects.push_back(std::move(*ErrOrObj));
 635
 636     UnitIndexEntry CurEntry = {};
 637
 638     StringRef CurStrSection;
 639     StringRef CurStrOffsetSection;
 640     std::vector<StringRef> CurTypesSection;
 641     std::vector<StringRef> CurInfoSection;
 642     StringRef AbbrevSection;
 643     StringRef CurCUIndexSection;
 644     StringRef CurTUIndexSection;
 645
 646     // This maps each section contained in this file to its length.
 647     // This information is later on used to calculate the contributions,
 648     // i.e. offset and length, of each compile/type unit to a section.
 649     std::vector<std::pair<DWARFSectionKind, uint32_t>> SectionLength;
 650
 651     for (const auto &Section : Obj.sections())
 652       if (auto Err = handleSection(
 653               KnownSections, StrSection, StrOffsetSection, TypesSection,
 654               CUIndexSection, TUIndexSection, InfoSection, Section, Out,
 655               UncompressedSections, ContributionOffsets, CurEntry,
 656               CurStrSection, CurStrOffsetSection, CurTypesSection,
 657               CurInfoSection, AbbrevSection, CurCUIndexSection,
 658               CurTUIndexSection, SectionLength))
 659         return Err;
 660
 661     if (CurInfoSection.empty())
 662       continue;
 663
 664     Expected<InfoSectionUnitHeader> HeaderOrErr =
 665         parseInfoSectionUnitHeader(CurInfoSection.front());
 666     if (!HeaderOrErr)
 667       return HeaderOrErr.takeError();
 668     InfoSectionUnitHeader &Header = *HeaderOrErr;
 669
 670     if (Version == 0) {
 671       Version = Header.Version;
 672       IndexVersion = Version < 5 ? 2 : 5;
 673     } else if (Version != Header.Version) {
 674       return make_error<DWPError>("incompatible DWARF compile unit versions.");
 675     }
 676
 677     writeStringsAndOffsets(Out, Strings, StrOffsetSection, CurStrSection,
 678                            CurStrOffsetSection, Header.Version);
 679
 680     for (auto Pair : SectionLength) {
 681       auto Index = getContributionIndex(Pair.first, IndexVersion);
 682       CurEntry.Contributions[Index].setOffset(ContributionOffsets[Index]);
 683       CurEntry.Contributions[Index].setLength(Pair.second);
 684       uint32_t OldOffset = ContributionOffsets[Index];
 685       ContributionOffsets[Index] += CurEntry.Contributions[Index].getLength32();
 686       if (OldOffset > ContributionOffsets[Index]) {
 687         uint32_t SectionIndex = 0;
 688         for (auto &Section : Obj.sections()) {
 689           if (SectionIndex == Index) {
 690             return sectionOverflowErrorOrWarning(
 691                 OldOffset, ContributionOffsets[Index], *Section.getName(),
 692                 ContinueOnCuIndexOverflow);
 693           }
 694           ++SectionIndex;
 695         }
 696       }
 697     }
 698
 699     uint32_t &InfoSectionOffset =
 700         ContributionOffsets[getContributionIndex(DW_SECT_INFO, IndexVersion)];
 701     if (CurCUIndexSection.empty()) {
 702       bool FoundCUUnit = false;
 703       Out.switchSection(InfoSection);
 704       for (StringRef Info : CurInfoSection) {
 705         uint64_t UnitOffset = 0;
 706         while (Info.size() > UnitOffset) {
 707           Expected<InfoSectionUnitHeader> HeaderOrError =
 708               parseInfoSectionUnitHeader(Info.substr(UnitOffset, Info.size()));
 709           if (!HeaderOrError)
 710             return HeaderOrError.takeError();
 711           InfoSectionUnitHeader &Header = *HeaderOrError;
 712
 713           UnitIndexEntry Entry = CurEntry;
 714           auto &C = Entry.Contributions[getContributionIndex(DW_SECT_INFO,
 715                                                              IndexVersion)];
 716           C.setOffset(InfoSectionOffset);
 717           C.setLength(Header.Length + 4);
 718
 719           if (std::numeric_limits<uint32_t>::max() - InfoSectionOffset <
 720               C.getLength32()) {
 721             if (Error Err = sectionOverflowErrorOrWarning(
 722                     InfoSectionOffset, InfoSectionOffset + C.getLength32(),
 723                     "debug_info", ContinueOnCuIndexOverflow))
 724               return Err;
 725           }
 726
 727           UnitOffset += C.getLength32();
 728           if (Header.Version < 5 ||
 729               Header.UnitType == dwarf::DW_UT_split_compile) {
 730             Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
 731                 Header, AbbrevSection,
 732                 Info.substr(UnitOffset - C.getLength32(), C.getLength32()),
 733                 CurStrOffsetSection, CurStrSection);
 734
 735             if (!EID)
 736               return createFileError(Input, EID.takeError());
 737             const auto &ID = *EID;
 738             auto P = IndexEntries.insert(std::make_pair(ID.Signature, Entry));
 739             if (!P.second)
 740               return buildDuplicateError(*P.first, ID, "");
 741             P.first->second.Name = ID.Name;
 742             P.first->second.DWOName = ID.DWOName;
 743
 744             FoundCUUnit = true;
 745           } else if (Header.UnitType == dwarf::DW_UT_split_type) {
 746             auto P = TypeIndexEntries.insert(
 747                 std::make_pair(*Header.Signature, Entry));
 748             if (!P.second)
 749               continue;
 750           }
 751           Out.emitBytes(
 752               Info.substr(UnitOffset - C.getLength32(), C.getLength32()));
 753           InfoSectionOffset += C.getLength32();
 754         }
 755       }
 756
 757       if (!FoundCUUnit)
 758         return make_error<DWPError>("no compile unit found in file: " + Input);
 759
 760       if (IndexVersion == 2) {
 761         // Add types from the .debug_types section from DWARF < 5.
 762         if (Error Err = addAllTypesFromTypesSection(
 763                 Out, TypeIndexEntries, TypesSection, CurTypesSection, CurEntry,
 764                 ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)],
 765                 ContinueOnCuIndexOverflow))
 766           return Err;
 767       }
 768       continue;
 769     }
 770
 771     if (CurInfoSection.size() != 1)
 772       return make_error<DWPError>("expected exactly one occurrence of a debug "
 773                                   "info section in a .dwp file");
 774     StringRef DwpSingleInfoSection = CurInfoSection.front();
 775
 776     DWARFUnitIndex CUIndex(DW_SECT_INFO);
 777     DataExtractor CUIndexData(CurCUIndexSection, Obj.isLittleEndian(), 0);
 778     if (!CUIndex.parse(CUIndexData))
 779       return make_error<DWPError>("failed to parse cu_index");
 780     if (CUIndex.getVersion() != IndexVersion)
 781       return make_error<DWPError>("incompatible cu_index versions, found " +
 782                                   utostr(CUIndex.getVersion()) +
 783                                   " and expecting " + utostr(IndexVersion));
 784
 785     Out.switchSection(InfoSection);
 786     for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) {
 787       auto *I = E.getContributions();
 788       if (!I)
 789         continue;
 790       auto P = IndexEntries.insert(std::make_pair(E.getSignature(), CurEntry));
 791       StringRef CUInfoSection =
 792           getSubsection(DwpSingleInfoSection, E, DW_SECT_INFO);
 793       Expected<InfoSectionUnitHeader> HeaderOrError =
 794           parseInfoSectionUnitHeader(CUInfoSection);
 795       if (!HeaderOrError)
 796         return HeaderOrError.takeError();
 797       InfoSectionUnitHeader &Header = *HeaderOrError;
 798
 799       Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
 800           Header, getSubsection(AbbrevSection, E, DW_SECT_ABBREV),
 801           CUInfoSection,
 802           getSubsection(CurStrOffsetSection, E, DW_SECT_STR_OFFSETS),
 803           CurStrSection);
 804       if (!EID)
 805         return createFileError(Input, EID.takeError());
 806       const auto &ID = *EID;
 807       if (!P.second)
 808         return buildDuplicateError(*P.first, ID, Input);
 809       auto &NewEntry = P.first->second;
 810       NewEntry.Name = ID.Name;
 811       NewEntry.DWOName = ID.DWOName;
 812       NewEntry.DWPName = Input;
 813       for (auto Kind : CUIndex.getColumnKinds()) {
 814         if (!isSupportedSectionKind(Kind))
 815           continue;
 816         auto &C =
 817             NewEntry.Contributions[getContributionIndex(Kind, IndexVersion)];
 818         C.setOffset(C.getOffset() + I->getOffset());
 819         C.setLength(I->getLength());
 820         ++I;
 821       }
 822       unsigned Index = getContributionIndex(DW_SECT_INFO, IndexVersion);
 823       auto &C = NewEntry.Contributions[Index];
 824       Out.emitBytes(CUInfoSection);
 825       C.setOffset(InfoSectionOffset);
 826       InfoSectionOffset += C.getLength32();
 827     }
 828
 829     if (!CurTUIndexSection.empty()) {
 830       llvm::DWARFSectionKind TUSectionKind;
 831       MCSection *OutSection;
 832       StringRef TypeInputSection;
 833       // Write type units into debug info section for DWARFv5.
 834       if (Version >= 5) {
 835         TUSectionKind = DW_SECT_INFO;
 836         OutSection = InfoSection;
 837         TypeInputSection = DwpSingleInfoSection;
 838       } else {
 839         // Write type units into debug types section for DWARF < 5.
 840         if (CurTypesSection.size() != 1)
 841           return make_error<DWPError>(
 842               "multiple type unit sections in .dwp file");
 843
 844         TUSectionKind = DW_SECT_EXT_TYPES;
 845         OutSection = TypesSection;
 846         TypeInputSection = CurTypesSection.front();
 847       }
 848
 849       DWARFUnitIndex TUIndex(TUSectionKind);
 850       DataExtractor TUIndexData(CurTUIndexSection, Obj.isLittleEndian(), 0);
 851       if (!TUIndex.parse(TUIndexData))
 852         return make_error<DWPError>("failed to parse tu_index");
 853       if (TUIndex.getVersion() != IndexVersion)
 854         return make_error<DWPError>("incompatible tu_index versions, found " +
 855                                     utostr(TUIndex.getVersion()) +
 856                                     " and expecting " + utostr(IndexVersion));
 857
 858       unsigned TypesContributionIndex =
 859           getContributionIndex(TUSectionKind, IndexVersion);
 860       if (Error Err = addAllTypesFromDWP(
 861               Out, TypeIndexEntries, TUIndex, OutSection, TypeInputSection,
 862               CurEntry, ContributionOffsets[TypesContributionIndex],
 863               TypesContributionIndex, ContinueOnCuIndexOverflow))
 864         return Err;
 865     }
 866   }
 867
 868   if (Version < 5) {
 869     // Lie about there being no info contributions so the TU index only includes
 870     // the type unit contribution for DWARF < 5. In DWARFv5 the TU index has a
 871     // contribution to the info section, so we do not want to lie about it.
 872     ContributionOffsets[0] = 0;
 873   }
 874   writeIndex(Out, MCOFI.getDwarfTUIndexSection(), ContributionOffsets,
 875              TypeIndexEntries, IndexVersion);
 876
 877   if (Version < 5) {
 878     // Lie about the type contribution for DWARF < 5. In DWARFv5 the type
 879     // section does not exist, so no need to do anything about this.
 880     ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)] = 0;
 881     // Unlie about the info contribution
 882     ContributionOffsets[0] = 1;
 883   }
 884
 885   writeIndex(Out, MCOFI.getDwarfCUIndexSection(), ContributionOffsets,
 886              IndexEntries, IndexVersion);
 887
 888   return Error::success();
 889 }
 890 } // namespace llvm