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                                            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 void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings,
 419                             MCSection *StrOffsetSection,
 420                             StringRef CurStrSection,
 421                             StringRef CurStrOffsetSection, uint16_t Version) {
 422   // Could possibly produce an error or warning if one of these was non-null but
 423   // the other was null.
 424   if (CurStrSection.empty() || CurStrOffsetSection.empty())
 425     return;
 426
 427   DenseMap<uint64_t, uint32_t> OffsetRemapping;
 428
 429   DataExtractor Data(CurStrSection, true, 0);
 430   uint64_t LocalOffset = 0;
 431   uint64_t PrevOffset = 0;
 432   while (const char *S = Data.getCStr(&LocalOffset)) {
 433     OffsetRemapping[PrevOffset] =
 434         Strings.getOffset(S, LocalOffset - PrevOffset);
 435     PrevOffset = LocalOffset;
 436   }
 437
 438   Data = DataExtractor(CurStrOffsetSection, true, 0);
 439
 440   Out.switchSection(StrOffsetSection);
 441
 442   uint64_t HeaderSize = debugStrOffsetsHeaderSize(Data, Version);
 443   uint64_t Offset = 0;
 444   uint64_t Size = CurStrOffsetSection.size();
 445   // FIXME: This can be caused by bad input and should be handled as such.
 446   assert(HeaderSize <= Size && "StrOffsetSection size is less than its header");
 447   // Copy the header to the output.
 448   Out.emitBytes(Data.getBytes(&Offset, HeaderSize));
 449   while (Offset < Size) {
 450     auto OldOffset = Data.getU32(&Offset);
 451     auto NewOffset = OffsetRemapping[OldOffset];
 452     Out.emitIntValue(NewOffset, 4);
 453   }
 454 }
 455
 456 enum AccessField { Offset, Length };
 457 void writeIndexTable(MCStreamer &Out, ArrayRef<unsigned> ContributionOffsets,
 458                      const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
 459                      const AccessField &Field) {
 460   for (const auto &E : IndexEntries)
 461     for (size_t I = 0; I != std::size(E.second.Contributions); ++I)
 462       if (ContributionOffsets[I])
 463         Out.emitIntValue((Field == AccessField::Offset
 464                               ? E.second.Contributions[I].getOffset32()
 465                               : E.second.Contributions[I].getLength32()),
 466                          4);
 467 }
 468
 469 void writeIndex(MCStreamer &Out, MCSection *Section,
 470                 ArrayRef<unsigned> ContributionOffsets,
 471                 const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
 472                 uint32_t IndexVersion) {
 473   if (IndexEntries.empty())
 474     return;
 475
 476   unsigned Columns = 0;
 477   for (auto &C : ContributionOffsets)
 478     if (C)
 479       ++Columns;
 480
 481   std::vector<unsigned> Buckets(NextPowerOf2(3 * IndexEntries.size() / 2));
 482   uint64_t Mask = Buckets.size() - 1;
 483   size_t I = 0;
 484   for (const auto &P : IndexEntries) {
 485     auto S = P.first;
 486     auto H = S & Mask;
 487     auto HP = ((S >> 32) & Mask) | 1;
 488     while (Buckets[H]) {
 489       assert(S != IndexEntries.begin()[Buckets[H] - 1].first &&
 490              "Duplicate unit");
 491       H = (H + HP) & Mask;
 492     }
 493     Buckets[H] = I + 1;
 494     ++I;
 495   }
 496
 497   Out.switchSection(Section);
 498   Out.emitIntValue(IndexVersion, 4);        // Version
 499   Out.emitIntValue(Columns, 4);             // Columns
 500   Out.emitIntValue(IndexEntries.size(), 4); // Num Units
 501   Out.emitIntValue(Buckets.size(), 4);      // Num Buckets
 502
 503   // Write the signatures.
 504   for (const auto &I : Buckets)
 505     Out.emitIntValue(I ? IndexEntries.begin()[I - 1].first : 0, 8);
 506
 507   // Write the indexes.
 508   for (const auto &I : Buckets)
 509     Out.emitIntValue(I, 4);
 510
 511   // Write the column headers (which sections will appear in the table)
 512   for (size_t I = 0; I != ContributionOffsets.size(); ++I)
 513     if (ContributionOffsets[I])
 514       Out.emitIntValue(getOnDiskSectionId(I), 4);
 515
 516   // Write the offsets.
 517   writeIndexTable(Out, ContributionOffsets, IndexEntries, AccessField::Offset);
 518
 519   // Write the lengths.
 520   writeIndexTable(Out, ContributionOffsets, IndexEntries, AccessField::Length);
 521 }
 522
 523 Error buildDuplicateError(const std::pair<uint64_t, UnitIndexEntry> &PrevE,
 524                           const CompileUnitIdentifiers &ID, StringRef DWPName) {
 525   return make_error<DWPError>(
 526       std::string("duplicate DWO ID (") + utohexstr(PrevE.first) + ") in " +
 527       buildDWODescription(PrevE.second.Name, PrevE.second.DWPName,
 528                           PrevE.second.DWOName) +
 529       " and " + buildDWODescription(ID.Name, DWPName, ID.DWOName));
 530 }
 531
 532 Error handleSection(
 533     const StringMap<std::pair<MCSection *, DWARFSectionKind>> &KnownSections,
 534     const MCSection *StrSection, const MCSection *StrOffsetSection,
 535     const MCSection *TypesSection, const MCSection *CUIndexSection,
 536     const MCSection *TUIndexSection, const MCSection *InfoSection,
 537     const SectionRef &Section, MCStreamer &Out,
 538     std::deque<SmallString<32>> &UncompressedSections,
 539     uint32_t (&ContributionOffsets)[8], UnitIndexEntry &CurEntry,
 540     StringRef &CurStrSection, StringRef &CurStrOffsetSection,
 541     std::vector<StringRef> &CurTypesSection,
 542     std::vector<StringRef> &CurInfoSection, StringRef &AbbrevSection,
 543     StringRef &CurCUIndexSection, StringRef &CurTUIndexSection,
 544     std::vector<std::pair<DWARFSectionKind, uint32_t>> &SectionLength) {
 545   if (Section.isBSS())
 546     return Error::success();
 547
 548   if (Section.isVirtual())
 549     return Error::success();
 550
 551   Expected<StringRef> NameOrErr = Section.getName();
 552   if (!NameOrErr)
 553     return NameOrErr.takeError();
 554   StringRef Name = *NameOrErr;
 555
 556   Expected<StringRef> ContentsOrErr = Section.getContents();
 557   if (!ContentsOrErr)
 558     return ContentsOrErr.takeError();
 559   StringRef Contents = *ContentsOrErr;
 560
 561   if (auto Err = handleCompressedSection(UncompressedSections, Section, Name,
 562                                          Contents))
 563     return Err;
 564
 565   Name = Name.substr(Name.find_first_not_of("._"));
 566
 567   auto SectionPair = KnownSections.find(Name);
 568   if (SectionPair == KnownSections.end())
 569     return Error::success();
 570
 571   if (DWARFSectionKind Kind = SectionPair->second.second) {
 572     if (Kind != DW_SECT_EXT_TYPES && Kind != DW_SECT_INFO) {
 573       SectionLength.push_back(std::make_pair(Kind, Contents.size()));
 574     }
 575
 576     if (Kind == DW_SECT_ABBREV) {
 577       AbbrevSection = Contents;
 578     }
 579   }
 580
 581   MCSection *OutSection = SectionPair->second.first;
 582   if (OutSection == StrOffsetSection)
 583     CurStrOffsetSection = Contents;
 584   else if (OutSection == StrSection)
 585     CurStrSection = Contents;
 586   else if (OutSection == TypesSection)
 587     CurTypesSection.push_back(Contents);
 588   else if (OutSection == CUIndexSection)
 589     CurCUIndexSection = Contents;
 590   else if (OutSection == TUIndexSection)
 591     CurTUIndexSection = Contents;
 592   else if (OutSection == InfoSection)
 593     CurInfoSection.push_back(Contents);
 594   else {
 595     Out.switchSection(OutSection);
 596     Out.emitBytes(Contents);
 597   }
 598   return Error::success();
 599 }
 600
 601 Error write(MCStreamer &Out, ArrayRef<std::string> Inputs,
 602             OnCuIndexOverflow OverflowOptValue) {
 603   const auto &MCOFI = *Out.getContext().getObjectFileInfo();
 604   MCSection *const StrSection = MCOFI.getDwarfStrDWOSection();
 605   MCSection *const StrOffsetSection = MCOFI.getDwarfStrOffDWOSection();
 606   MCSection *const TypesSection = MCOFI.getDwarfTypesDWOSection();
 607   MCSection *const CUIndexSection = MCOFI.getDwarfCUIndexSection();
 608   MCSection *const TUIndexSection = MCOFI.getDwarfTUIndexSection();
 609   MCSection *const InfoSection = MCOFI.getDwarfInfoDWOSection();
 610   const StringMap<std::pair<MCSection *, DWARFSectionKind>> KnownSections = {
 611       {"debug_info.dwo", {InfoSection, DW_SECT_INFO}},
 612       {"debug_types.dwo", {MCOFI.getDwarfTypesDWOSection(), DW_SECT_EXT_TYPES}},
 613       {"debug_str_offsets.dwo", {StrOffsetSection, DW_SECT_STR_OFFSETS}},
 614       {"debug_str.dwo", {StrSection, static_cast<DWARFSectionKind>(0)}},
 615       {"debug_loc.dwo", {MCOFI.getDwarfLocDWOSection(), DW_SECT_EXT_LOC}},
 616       {"debug_line.dwo", {MCOFI.getDwarfLineDWOSection(), DW_SECT_LINE}},
 617       {"debug_macro.dwo", {MCOFI.getDwarfMacroDWOSection(), DW_SECT_MACRO}},
 618       {"debug_abbrev.dwo", {MCOFI.getDwarfAbbrevDWOSection(), DW_SECT_ABBREV}},
 619       {"debug_loclists.dwo",
 620        {MCOFI.getDwarfLoclistsDWOSection(), DW_SECT_LOCLISTS}},
 621       {"debug_rnglists.dwo",
 622        {MCOFI.getDwarfRnglistsDWOSection(), DW_SECT_RNGLISTS}},
 623       {"debug_cu_index", {CUIndexSection, static_cast<DWARFSectionKind>(0)}},
 624       {"debug_tu_index", {TUIndexSection, static_cast<DWARFSectionKind>(0)}}};
 625
 626   MapVector<uint64_t, UnitIndexEntry> IndexEntries;
 627   MapVector<uint64_t, UnitIndexEntry> TypeIndexEntries;
 628
 629   uint32_t ContributionOffsets[8] = {};
 630   uint16_t Version = 0;
 631   uint32_t IndexVersion = 0;
 632   bool AnySectionOverflow = false;
 633
 634   DWPStringPool Strings(Out, StrSection);
 635
 636   SmallVector<OwningBinary<object::ObjectFile>, 128> Objects;
 637   Objects.reserve(Inputs.size());
 638
 639   std::deque<SmallString<32>> UncompressedSections;
 640
 641   for (const auto &Input : Inputs) {
 642     auto ErrOrObj = object::ObjectFile::createObjectFile(Input);
 643     if (!ErrOrObj) {
 644       return handleErrors(ErrOrObj.takeError(),
 645                           [&](std::unique_ptr<ECError> EC) -> Error {
 646                             return createFileError(Input, Error(std::move(EC)));
 647                           });
 648     }
 649
 650     auto &Obj = *ErrOrObj->getBinary();
 651     Objects.push_back(std::move(*ErrOrObj));
 652
 653     UnitIndexEntry CurEntry = {};
 654
 655     StringRef CurStrSection;
 656     StringRef CurStrOffsetSection;
 657     std::vector<StringRef> CurTypesSection;
 658     std::vector<StringRef> CurInfoSection;
 659     StringRef AbbrevSection;
 660     StringRef CurCUIndexSection;
 661     StringRef CurTUIndexSection;
 662
 663     // This maps each section contained in this file to its length.
 664     // This information is later on used to calculate the contributions,
 665     // i.e. offset and length, of each compile/type unit to a section.
 666     std::vector<std::pair<DWARFSectionKind, uint32_t>> SectionLength;
 667
 668     for (const auto &Section : Obj.sections())
 669       if (auto Err = handleSection(
 670               KnownSections, StrSection, StrOffsetSection, TypesSection,
 671               CUIndexSection, TUIndexSection, InfoSection, Section, Out,
 672               UncompressedSections, ContributionOffsets, CurEntry,
 673               CurStrSection, CurStrOffsetSection, CurTypesSection,
 674               CurInfoSection, AbbrevSection, CurCUIndexSection,
 675               CurTUIndexSection, SectionLength))
 676         return Err;
 677
 678     if (CurInfoSection.empty())
 679       continue;
 680
 681     Expected<InfoSectionUnitHeader> HeaderOrErr =
 682         parseInfoSectionUnitHeader(CurInfoSection.front());
 683     if (!HeaderOrErr)
 684       return HeaderOrErr.takeError();
 685     InfoSectionUnitHeader &Header = *HeaderOrErr;
 686
 687     if (Version == 0) {
 688       Version = Header.Version;
 689       IndexVersion = Version < 5 ? 2 : 5;
 690     } else if (Version != Header.Version) {
 691       return make_error<DWPError>("incompatible DWARF compile unit versions.");
 692     }
 693
 694     writeStringsAndOffsets(Out, Strings, StrOffsetSection, CurStrSection,
 695                            CurStrOffsetSection, Header.Version);
 696
 697     for (auto Pair : SectionLength) {
 698       auto Index = getContributionIndex(Pair.first, IndexVersion);
 699       CurEntry.Contributions[Index].setOffset(ContributionOffsets[Index]);
 700       CurEntry.Contributions[Index].setLength(Pair.second);
 701       uint32_t OldOffset = ContributionOffsets[Index];
 702       ContributionOffsets[Index] += CurEntry.Contributions[Index].getLength32();
 703       if (OldOffset > ContributionOffsets[Index]) {
 704         uint32_t SectionIndex = 0;
 705         for (auto &Section : Obj.sections()) {
 706           if (SectionIndex == Index) {
 707             if (Error Err = sectionOverflowErrorOrWarning(
 708                     OldOffset, ContributionOffsets[Index], *Section.getName(),
 709                     OverflowOptValue, AnySectionOverflow))
 710               return Err;
 711           }
 712           ++SectionIndex;
 713         }
 714         if (AnySectionOverflow)
 715           break;
 716       }
 717     }
 718
 719     uint32_t &InfoSectionOffset =
 720         ContributionOffsets[getContributionIndex(DW_SECT_INFO, IndexVersion)];
 721     if (CurCUIndexSection.empty()) {
 722       bool FoundCUUnit = false;
 723       Out.switchSection(InfoSection);
 724       for (StringRef Info : CurInfoSection) {
 725         uint64_t UnitOffset = 0;
 726         while (Info.size() > UnitOffset) {
 727           Expected<InfoSectionUnitHeader> HeaderOrError =
 728               parseInfoSectionUnitHeader(Info.substr(UnitOffset, Info.size()));
 729           if (!HeaderOrError)
 730             return HeaderOrError.takeError();
 731           InfoSectionUnitHeader &Header = *HeaderOrError;
 732
 733           UnitIndexEntry Entry = CurEntry;
 734           auto &C = Entry.Contributions[getContributionIndex(DW_SECT_INFO,
 735                                                              IndexVersion)];
 736           C.setOffset(InfoSectionOffset);
 737           C.setLength(Header.Length + 4);
 738
 739           if (std::numeric_limits<uint32_t>::max() - InfoSectionOffset <
 740               C.getLength32()) {
 741             if (Error Err = sectionOverflowErrorOrWarning(
 742                     InfoSectionOffset, InfoSectionOffset + C.getLength32(),
 743                     "debug_info", OverflowOptValue, AnySectionOverflow))
 744               return Err;
 745             if (AnySectionOverflow) {
 746               if (Header.Version < 5 ||
 747                   Header.UnitType == dwarf::DW_UT_split_compile)
 748                 FoundCUUnit = true;
 749               break;
 750             }
 751           }
 752
 753           UnitOffset += C.getLength32();
 754           if (Header.Version < 5 ||
 755               Header.UnitType == dwarf::DW_UT_split_compile) {
 756             Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
 757                 Header, AbbrevSection,
 758                 Info.substr(UnitOffset - C.getLength32(), C.getLength32()),
 759                 CurStrOffsetSection, CurStrSection);
 760
 761             if (!EID)
 762               return createFileError(Input, EID.takeError());
 763             const auto &ID = *EID;
 764             auto P = IndexEntries.insert(std::make_pair(ID.Signature, Entry));
 765             if (!P.second)
 766               return buildDuplicateError(*P.first, ID, "");
 767             P.first->second.Name = ID.Name;
 768             P.first->second.DWOName = ID.DWOName;
 769
 770             FoundCUUnit = true;
 771           } else if (Header.UnitType == dwarf::DW_UT_split_type) {
 772             auto P = TypeIndexEntries.insert(
 773                 std::make_pair(*Header.Signature, Entry));
 774             if (!P.second)
 775               continue;
 776           }
 777           Out.emitBytes(
 778               Info.substr(UnitOffset - C.getLength32(), C.getLength32()));
 779           InfoSectionOffset += C.getLength32();
 780         }
 781         if (AnySectionOverflow)
 782           break;
 783       }
 784
 785       if (!FoundCUUnit)
 786         return make_error<DWPError>("no compile unit found in file: " + Input);
 787
 788       if (IndexVersion == 2) {
 789         // Add types from the .debug_types section from DWARF < 5.
 790         if (Error Err = addAllTypesFromTypesSection(
 791                 Out, TypeIndexEntries, TypesSection, CurTypesSection, CurEntry,
 792                 ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)],
 793                 OverflowOptValue, AnySectionOverflow))
 794           return Err;
 795       }
 796       if (AnySectionOverflow)
 797         break;
 798       continue;
 799     }
 800
 801     if (CurInfoSection.size() != 1)
 802       return make_error<DWPError>("expected exactly one occurrence of a debug "
 803                                   "info section in a .dwp file");
 804     StringRef DwpSingleInfoSection = CurInfoSection.front();
 805
 806     DWARFUnitIndex CUIndex(DW_SECT_INFO);
 807     DataExtractor CUIndexData(CurCUIndexSection, Obj.isLittleEndian(), 0);
 808     if (!CUIndex.parse(CUIndexData))
 809       return make_error<DWPError>("failed to parse cu_index");
 810     if (CUIndex.getVersion() != IndexVersion)
 811       return make_error<DWPError>("incompatible cu_index versions, found " +
 812                                   utostr(CUIndex.getVersion()) +
 813                                   " and expecting " + utostr(IndexVersion));
 814
 815     Out.switchSection(InfoSection);
 816     for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) {
 817       auto *I = E.getContributions();
 818       if (!I)
 819         continue;
 820       auto P = IndexEntries.insert(std::make_pair(E.getSignature(), CurEntry));
 821       StringRef CUInfoSection =
 822           getSubsection(DwpSingleInfoSection, E, DW_SECT_INFO);
 823       Expected<InfoSectionUnitHeader> HeaderOrError =
 824           parseInfoSectionUnitHeader(CUInfoSection);
 825       if (!HeaderOrError)
 826         return HeaderOrError.takeError();
 827       InfoSectionUnitHeader &Header = *HeaderOrError;
 828
 829       Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
 830           Header, getSubsection(AbbrevSection, E, DW_SECT_ABBREV),
 831           CUInfoSection,
 832           getSubsection(CurStrOffsetSection, E, DW_SECT_STR_OFFSETS),
 833           CurStrSection);
 834       if (!EID)
 835         return createFileError(Input, EID.takeError());
 836       const auto &ID = *EID;
 837       if (!P.second)
 838         return buildDuplicateError(*P.first, ID, Input);
 839       auto &NewEntry = P.first->second;
 840       NewEntry.Name = ID.Name;
 841       NewEntry.DWOName = ID.DWOName;
 842       NewEntry.DWPName = Input;
 843       for (auto Kind : CUIndex.getColumnKinds()) {
 844         if (!isSupportedSectionKind(Kind))
 845           continue;
 846         auto &C =
 847             NewEntry.Contributions[getContributionIndex(Kind, IndexVersion)];
 848         C.setOffset(C.getOffset() + I->getOffset());
 849         C.setLength(I->getLength());
 850         ++I;
 851       }
 852       unsigned Index = getContributionIndex(DW_SECT_INFO, IndexVersion);
 853       auto &C = NewEntry.Contributions[Index];
 854       Out.emitBytes(CUInfoSection);
 855       C.setOffset(InfoSectionOffset);
 856       InfoSectionOffset += C.getLength32();
 857     }
 858
 859     if (!CurTUIndexSection.empty()) {
 860       llvm::DWARFSectionKind TUSectionKind;
 861       MCSection *OutSection;
 862       StringRef TypeInputSection;
 863       // Write type units into debug info section for DWARFv5.
 864       if (Version >= 5) {
 865         TUSectionKind = DW_SECT_INFO;
 866         OutSection = InfoSection;
 867         TypeInputSection = DwpSingleInfoSection;
 868       } else {
 869         // Write type units into debug types section for DWARF < 5.
 870         if (CurTypesSection.size() != 1)
 871           return make_error<DWPError>(
 872               "multiple type unit sections in .dwp file");
 873
 874         TUSectionKind = DW_SECT_EXT_TYPES;
 875         OutSection = TypesSection;
 876         TypeInputSection = CurTypesSection.front();
 877       }
 878
 879       DWARFUnitIndex TUIndex(TUSectionKind);
 880       DataExtractor TUIndexData(CurTUIndexSection, Obj.isLittleEndian(), 0);
 881       if (!TUIndex.parse(TUIndexData))
 882         return make_error<DWPError>("failed to parse tu_index");
 883       if (TUIndex.getVersion() != IndexVersion)
 884         return make_error<DWPError>("incompatible tu_index versions, found " +
 885                                     utostr(TUIndex.getVersion()) +
 886                                     " and expecting " + utostr(IndexVersion));
 887
 888       unsigned TypesContributionIndex =
 889           getContributionIndex(TUSectionKind, IndexVersion);
 890       if (Error Err = addAllTypesFromDWP(
 891               Out, TypeIndexEntries, TUIndex, OutSection, TypeInputSection,
 892               CurEntry, ContributionOffsets[TypesContributionIndex],
 893               TypesContributionIndex, OverflowOptValue, AnySectionOverflow))
 894         return Err;
 895     }
 896     if (AnySectionOverflow)
 897       break;
 898   }
 899
 900   if (Version < 5) {
 901     // Lie about there being no info contributions so the TU index only includes
 902     // the type unit contribution for DWARF < 5. In DWARFv5 the TU index has a
 903     // contribution to the info section, so we do not want to lie about it.
 904     ContributionOffsets[0] = 0;
 905   }
 906   writeIndex(Out, MCOFI.getDwarfTUIndexSection(), ContributionOffsets,
 907              TypeIndexEntries, IndexVersion);
 908
 909   if (Version < 5) {
 910     // Lie about the type contribution for DWARF < 5. In DWARFv5 the type
 911     // section does not exist, so no need to do anything about this.
 912     ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)] = 0;
 913     // Unlie about the info contribution
 914     ContributionOffsets[0] = 1;
 915   }
 916
 917   writeIndex(Out, MCOFI.getDwarfCUIndexSection(), ContributionOffsets,
 918              IndexEntries, IndexVersion);
 919
 920   return Error::success();
 921 }
 922 } // namespace llvm