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
25using namespace llvm;
26using namespace llvm::object;
27
28static mc::RegisterMCTargetOptionsFlags MCTargetOptionsFlags;
29
30// Returns the size of debug_str_offsets section headers in bytes.
31static 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_ptr: &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
42static uint64_t getCUAbbrev(StringRef Abbrev, uint64_t AbbrCode) {
43 uint64_t Offset = 0;
44 DataExtractor AbbrevData(Abbrev, true, 0);
45 while (AbbrevData.getULEB128(offset_ptr: &Offset) != AbbrCode) {
46 // Tag
47 AbbrevData.getULEB128(offset_ptr: &Offset);
48 // DW_CHILDREN
49 AbbrevData.getU8(offset_ptr: &Offset);
50 // Attributes
51 while (AbbrevData.getULEB128(offset_ptr: &Offset) | AbbrevData.getULEB128(offset_ptr: &Offset))
52 ;
53 }
54 return Offset;
55}
56
57static Expected<const char *>
58getIndexedString(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(OffsetPtr: &InfoOffset);
62 uint64_t StrIndex;
63 switch (Form) {
64 case dwarf::DW_FORM_strx1:
65 StrIndex = InfoData.getU8(offset_ptr: &InfoOffset);
66 break;
67 case dwarf::DW_FORM_strx2:
68 StrIndex = InfoData.getU16(offset_ptr: &InfoOffset);
69 break;
70 case dwarf::DW_FORM_strx3:
71 StrIndex = InfoData.getU24(OffsetPtr: &InfoOffset);
72 break;
73 case dwarf::DW_FORM_strx4:
74 StrIndex = InfoData.getU32(offset_ptr: &InfoOffset);
75 break;
76 case dwarf::DW_FORM_strx:
77 case dwarf::DW_FORM_GNU_str_index:
78 StrIndex = InfoData.getULEB128(offset_ptr: &InfoOffset);
79 break;
80 default:
81 return make_error<DWPError>(
82 Args: "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, DwarfVersion: Version);
89
90 uint64_t StrOffset = StrOffsetsData.getU32(offset_ptr: &StrOffsetsOffset);
91 DataExtractor StrData(Str, true, 0);
92 return StrData.getCStr(OffsetPtr: &StrOffset);
93}
94
95static Expected<CompileUnitIdentifiers>
96getCUIdentifiers(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 Args: std::string("unit type DW_UT_split_compile type not found in "
103 "debug_info header. Unexpected unit type 0x" +
104 utostr(X: Header.UnitType) + " found"));
105
106 CompileUnitIdentifiers ID;
107
108 uint32_t AbbrCode = InfoData.getULEB128(offset_ptr: &Offset);
109 DataExtractor AbbrevData(Abbrev, true, 0);
110 uint64_t AbbrevOffset = getCUAbbrev(Abbrev, AbbrCode);
111 auto Tag = static_cast<dwarf::Tag>(AbbrevData.getULEB128(offset_ptr: &AbbrevOffset));
112 if (Tag != dwarf::DW_TAG_compile_unit)
113 return make_error<DWPError>(Args: "top level DIE is not a compile unit");
114 // DW_CHILDREN
115 AbbrevData.getU8(offset_ptr: &AbbrevOffset);
116 uint32_t Name;
117 dwarf::Form Form;
118 while ((Name = AbbrevData.getULEB128(offset_ptr: &AbbrevOffset)) |
119 (Form = static_cast<dwarf::Form>(
120 AbbrevData.getULEB128(offset_ptr: &AbbrevOffset))) &&
121 (Name != 0 || Form != 0)) {
122 switch (Name) {
123 case dwarf::DW_AT_name: {
124 Expected<const char *> EName = getIndexedString(
125 Form, InfoData, InfoOffset&: Offset, StrOffsets, Str, Version: 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, InfoOffset&: Offset, StrOffsets, Str, Version: 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_ptr: &Offset);
142 break;
143 default:
144 DWARFFormValue::skipValue(
145 Form, DebugInfoData: InfoData, OffsetPtr: &Offset,
146 FormParams: dwarf::FormParams({.Version: Header.Version, .AddrSize: Header.AddrSize, .Format: Header.Format}));
147 }
148 }
149 if (!Header.Signature)
150 return make_error<DWPError>(Args: "compile unit missing dwo_id");
151 ID.Signature = *Header.Signature;
152 return ID;
153}
154
155static bool isSupportedSectionKind(DWARFSectionKind Kind) {
156 return Kind != DW_SECT_EXT_unknown;
157}
158
159namespace llvm {
160// Convert an internal section identifier into the index to use with
161// UnitIndexEntry::Contributions.
162unsigned 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.
170static unsigned getOnDiskSectionId(unsigned Index) {
171 return Index + DW_SECT_INFO;
172}
173
174static StringRef getSubsection(StringRef Section,
175 const DWARFUnitIndex::Entry &Entry,
176 DWARFSectionKind Kind) {
177 const auto *Off = Entry.getContribution(Sec: Kind);
178 if (!Off)
179 return StringRef();
180 return Section.substr(Start: Off->getOffset(), N: Off->getLength());
181}
182
183static 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(Warning: make_error<DWPError>(Args&: Msg));
196 return Error::success();
197 } else if (OverflowOptValue == OnCuIndexOverflow::SoftStop) {
198 AnySectionOverflow = true;
199 WithColor::defaultWarningHandler(Warning: make_error<DWPError>(Args&: Msg));
200 return Error::success();
201 }
202 return make_error<DWPError>(Args&: Msg);
203}
204
205static 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(Section: OutputTypes);
212 for (const DWARFUnitIndex::Entry &E : TUIndex.getRows()) {
213 auto *I = E.getContributions();
214 if (!I)
215 continue;
216 auto P = TypeIndexEntries.insert(KV: std::make_pair(x: E.getSignature(), y: 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, IndexVersion: 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(Data: Types.substr(
233 Start: C.getOffset() -
234 TUEntry.Contributions[TypesContributionIndex].getOffset(),
235 N: 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(PrevOffset: OldOffset, OverflowedOffset: TypesOffset,
242 SectionName: "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
254static 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(Section: OutputTypes);
261 uint64_t Offset = 0;
262 DataExtractor Data(Types, true, 0);
263 while (Data.isValidOffset(offset: Offset)) {
264 UnitIndexEntry Entry = CUEntry;
265 // Zero out the debug_info contribution
266 Entry.Contributions[0] = {};
267 auto &C = Entry.Contributions[getContributionIndex(Kind: DW_SECT_EXT_TYPES, IndexVersion: 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_ptr: &Offset) + 4);
272
273 Data.getU16(offset_ptr: &Offset); // Version
274 Data.getU32(offset_ptr: &Offset); // Abbrev offset
275 Data.getU8(offset_ptr: &Offset); // Address size
276 auto Signature = Data.getU64(offset_ptr: &Offset);
277 Offset = PrevOffset + C.getLength32();
278
279 auto P = TypeIndexEntries.insert(KV: std::make_pair(x&: Signature, y&: Entry));
280 if (!P.second)
281 continue;
282
283 Out.emitBytes(Data: Types.substr(Start: PrevOffset, N: C.getLength32()));
284 uint32_t OldOffset = TypesOffset;
285 TypesOffset += C.getLength32();
286 if (OldOffset > TypesOffset) {
287 if (Error Err = sectionOverflowErrorOrWarning(PrevOffset: OldOffset, OverflowedOffset: TypesOffset,
288 SectionName: "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
301static 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
327static Error createError(StringRef Name, Error E) {
328 return make_error<DWPError>(
329 Args: ("failure while decompressing compressed section: '" + Name + "', " +
330 llvm::toString(E: std::move(E)))
331 .str());
332}
333
334static Error
335handleCompressedSection(std::deque<SmallString<32>> &UncompressedSections,
336 SectionRef Sec, StringRef Name, StringRef &Contents) {
337 auto *Obj = dyn_cast<ELFObjectFileBase>(Val: Sec.getObject());
338 if (!Obj ||
339 !(static_cast<ELFSectionRef>(Sec).getFlags() & ELF::SHF_COMPRESSED))
340 return Error::success();
341 bool IsLE = isa<object::ELF32LEObjectFile>(Val: Obj) ||
342 isa<object::ELF64LEObjectFile>(Val: Obj);
343 bool Is64 = isa<object::ELF64LEObjectFile>(Val: Obj) ||
344 isa<object::ELF64BEObjectFile>(Val: Obj);
345 Expected<Decompressor> Dec = Decompressor::create(Name, Data: Contents, IsLE, Is64Bit: Is64);
346 if (!Dec)
347 return createError(Name, E: Dec.takeError());
348
349 UncompressedSections.emplace_back();
350 if (Error E = Dec->resizeAndDecompress(Out&: UncompressedSections.back()))
351 return createError(Name, E: std::move(E));
352
353 Contents = UncompressedSections.back();
354 return Error::success();
355}
356
357namespace llvm {
358// Parse and return the header of an info section compile/type unit.
359Expected<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(args&: Header.Length, args&: Header.Format) =
365 InfoData.getInitialLength(Off: &Offset, Err: &Err);
366 if (Err)
367 return make_error<DWPError>(Args: "cannot parse compile unit length: " +
368 llvm::toString(E: std::move(Err)));
369
370 if (!InfoData.isValidOffset(offset: Offset + (Header.Length - 1))) {
371 return make_error<DWPError>(
372 Args: "compile unit exceeds .debug_info section range: " +
373 utostr(X: Offset + Header.Length) + " >= " + utostr(X: InfoData.size()));
374 }
375
376 Header.Version = InfoData.getU16(offset_ptr: &Offset, Err: &Err);
377 if (Err)
378 return make_error<DWPError>(Args: "cannot parse compile unit version: " +
379 llvm::toString(E: 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>(Args: "unit length is too small: expected at least " +
392 utostr(X: MinHeaderLength) + " got " +
393 utostr(X: Header.Length) + ".");
394 }
395 if (Header.Version >= 5) {
396 Header.UnitType = InfoData.getU8(offset_ptr: &Offset);
397 Header.AddrSize = InfoData.getU8(offset_ptr: &Offset);
398 Header.DebugAbbrevOffset = InfoData.getU32(offset_ptr: &Offset);
399 Header.Signature = InfoData.getU64(offset_ptr: &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>(Args: "type unit is missing type offset");
405 InfoData.getU32(offset_ptr: &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_ptr: &Offset);
411 Header.AddrSize = InfoData.getU8(offset_ptr: &Offset);
412 }
413
414 Header.HeaderSize = Offset;
415 return Header;
416}
417
418void 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(OffsetPtr: &LocalOffset)) {
433 OffsetRemapping[PrevOffset] =
434 Strings.getOffset(Str: S, Length: LocalOffset - PrevOffset);
435 PrevOffset = LocalOffset;
436 }
437
438 Data = DataExtractor(CurStrOffsetSection, true, 0);
439
440 Out.switchSection(Section: StrOffsetSection);
441
442 uint64_t HeaderSize = debugStrOffsetsHeaderSize(StrOffsetsData: Data, DwarfVersion: 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: Data.getBytes(OffsetPtr: &Offset, Length: HeaderSize));
449 while (Offset < Size) {
450 auto OldOffset = Data.getU32(offset_ptr: &Offset);
451 auto NewOffset = OffsetRemapping[OldOffset];
452 Out.emitIntValue(Value: NewOffset, Size: 4);
453 }
454}
455
456enum AccessField { Offset, Length };
457void 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(Value: (Field == AccessField::Offset
464 ? E.second.Contributions[I].getOffset32()
465 : E.second.Contributions[I].getLength32()),
466 Size: 4);
467}
468
469void 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(A: 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(Value: IndexVersion, Size: 4); // Version
499 Out.emitIntValue(Value: Columns, Size: 4); // Columns
500 Out.emitIntValue(Value: IndexEntries.size(), Size: 4); // Num Units
501 Out.emitIntValue(Value: Buckets.size(), Size: 4); // Num Buckets
502
503 // Write the signatures.
504 for (const auto &I : Buckets)
505 Out.emitIntValue(Value: I ? IndexEntries.begin()[I - 1].first : 0, Size: 8);
506
507 // Write the indexes.
508 for (const auto &I : Buckets)
509 Out.emitIntValue(Value: I, Size: 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(Value: getOnDiskSectionId(Index: I), Size: 4);
515
516 // Write the offsets.
517 writeIndexTable(Out, ContributionOffsets, IndexEntries, Field: AccessField::Offset);
518
519 // Write the lengths.
520 writeIndexTable(Out, ContributionOffsets, IndexEntries, Field: AccessField::Length);
521}
522
523Error buildDuplicateError(const std::pair<uint64_t, UnitIndexEntry> &PrevE,
524 const CompileUnitIdentifiers &ID, StringRef DWPName) {
525 return make_error<DWPError>(
526 Args: std::string("duplicate DWO ID (") + utohexstr(X: PrevE.first) + ") in " +
527 buildDWODescription(Name: PrevE.second.Name, DWPName: PrevE.second.DWPName,
528 DWOName: PrevE.second.DWOName) +
529 " and " + buildDWODescription(Name: ID.Name, DWPName, DWOName: ID.DWOName));
530}
531
532Error 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, Sec: Section, Name,
562 Contents))
563 return Err;
564
565 Name = Name.substr(Start: Name.find_first_not_of(Chars: "._"));
566
567 auto SectionPair = KnownSections.find(Key: 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(x: std::make_pair(x&: Kind, y: 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(x: 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(x: Contents);
594 else {
595 Out.switchSection(Section: OutSection);
596 Out.emitBytes(Data: Contents);
597 }
598 return Error::success();
599}
600
601Error 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(N: Inputs.size());
638
639 std::deque<SmallString<32>> UncompressedSections;
640
641 for (const auto &Input : Inputs) {
642 auto ErrOrObj = object::ObjectFile::createObjectFile(ObjectPath: Input);
643 if (!ErrOrObj) {
644 return handleErrors(E: ErrOrObj.takeError(),
645 Hs: [&](std::unique_ptr<ECError> EC) -> Error {
646 return createFileError(F: Input, E: Error(std::move(EC)));
647 });
648 }
649
650 auto &Obj = *ErrOrObj->getBinary();
651 Objects.push_back(Elt: 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(Info: 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>(Args: "incompatible DWARF compile unit versions.");
692 }
693
694 writeStringsAndOffsets(Out, Strings, StrOffsetSection, CurStrSection,
695 CurStrOffsetSection, Version: Header.Version);
696
697 for (auto Pair : SectionLength) {
698 auto Index = getContributionIndex(Kind: 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 PrevOffset: OldOffset, OverflowedOffset: ContributionOffsets[Index], SectionName: *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(Kind: DW_SECT_INFO, IndexVersion)];
721 if (CurCUIndexSection.empty()) {
722 bool FoundCUUnit = false;
723 Out.switchSection(Section: InfoSection);
724 for (StringRef Info : CurInfoSection) {
725 uint64_t UnitOffset = 0;
726 while (Info.size() > UnitOffset) {
727 Expected<InfoSectionUnitHeader> HeaderOrError =
728 parseInfoSectionUnitHeader(Info: Info.substr(Start: UnitOffset, N: Info.size()));
729 if (!HeaderOrError)
730 return HeaderOrError.takeError();
731 InfoSectionUnitHeader &Header = *HeaderOrError;
732
733 UnitIndexEntry Entry = CurEntry;
734 auto &C = Entry.Contributions[getContributionIndex(Kind: 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 PrevOffset: InfoSectionOffset, OverflowedOffset: InfoSectionOffset + C.getLength32(),
743 SectionName: "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, Abbrev: AbbrevSection,
758 Info: Info.substr(Start: UnitOffset - C.getLength32(), N: C.getLength32()),
759 StrOffsets: CurStrOffsetSection, Str: CurStrSection);
760
761 if (!EID)
762 return createFileError(F: Input, E: EID.takeError());
763 const auto &ID = *EID;
764 auto P = IndexEntries.insert(KV: std::make_pair(x: ID.Signature, y&: Entry));
765 if (!P.second)
766 return buildDuplicateError(PrevE: *P.first, ID, DWPName: "");
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 KV: std::make_pair(x&: *Header.Signature, y&: Entry));
774 if (!P.second)
775 continue;
776 }
777 Out.emitBytes(
778 Data: Info.substr(Start: UnitOffset - C.getLength32(), N: C.getLength32()));
779 InfoSectionOffset += C.getLength32();
780 }
781 if (AnySectionOverflow)
782 break;
783 }
784
785 if (!FoundCUUnit)
786 return make_error<DWPError>(Args: "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, OutputTypes: TypesSection, TypesSections: CurTypesSection, CUEntry: CurEntry,
792 TypesOffset&: ContributionOffsets[getContributionIndex(Kind: DW_SECT_EXT_TYPES, IndexVersion: 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>(Args: "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(IndexData: CUIndexData))
809 return make_error<DWPError>(Args: "failed to parse cu_index");
810 if (CUIndex.getVersion() != IndexVersion)
811 return make_error<DWPError>(Args: "incompatible cu_index versions, found " +
812 utostr(X: CUIndex.getVersion()) +
813 " and expecting " + utostr(X: IndexVersion));
814
815 Out.switchSection(Section: InfoSection);
816 for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) {
817 auto *I = E.getContributions();
818 if (!I)
819 continue;
820 auto P = IndexEntries.insert(KV: std::make_pair(x: E.getSignature(), y&: CurEntry));
821 StringRef CUInfoSection =
822 getSubsection(Section: DwpSingleInfoSection, Entry: E, Kind: DW_SECT_INFO);
823 Expected<InfoSectionUnitHeader> HeaderOrError =
824 parseInfoSectionUnitHeader(Info: CUInfoSection);
825 if (!HeaderOrError)
826 return HeaderOrError.takeError();
827 InfoSectionUnitHeader &Header = *HeaderOrError;
828
829 Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
830 Header, Abbrev: getSubsection(Section: AbbrevSection, Entry: E, Kind: DW_SECT_ABBREV),
831 Info: CUInfoSection,
832 StrOffsets: getSubsection(Section: CurStrOffsetSection, Entry: E, Kind: DW_SECT_STR_OFFSETS),
833 Str: CurStrSection);
834 if (!EID)
835 return createFileError(F: Input, E: EID.takeError());
836 const auto &ID = *EID;
837 if (!P.second)
838 return buildDuplicateError(PrevE: *P.first, ID, DWPName: 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(Kind: DW_SECT_INFO, IndexVersion);
853 auto &C = NewEntry.Contributions[Index];
854 Out.emitBytes(Data: 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 Args: "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(IndexData: TUIndexData))
882 return make_error<DWPError>(Args: "failed to parse tu_index");
883 if (TUIndex.getVersion() != IndexVersion)
884 return make_error<DWPError>(Args: "incompatible tu_index versions, found " +
885 utostr(X: TUIndex.getVersion()) +
886 " and expecting " + utostr(X: IndexVersion));
887
888 unsigned TypesContributionIndex =
889 getContributionIndex(Kind: TUSectionKind, IndexVersion);
890 if (Error Err = addAllTypesFromDWP(
891 Out, TypeIndexEntries, TUIndex, OutputTypes: OutSection, Types: TypeInputSection,
892 TUEntry: CurEntry, TypesOffset&: 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, Section: MCOFI.getDwarfTUIndexSection(), ContributionOffsets,
907 IndexEntries: 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(Kind: DW_SECT_EXT_TYPES, IndexVersion: 2)] = 0;
913 // Unlie about the info contribution
914 ContributionOffsets[0] = 1;
915 }
916
917 writeIndex(Out, Section: MCOFI.getDwarfCUIndexSection(), ContributionOffsets,
918 IndexEntries, IndexVersion);
919
920 return Error::success();
921}
922} // namespace llvm
923

source code of llvm/lib/DWP/DWP.cpp