LLVM 19.0.0git
DWARFStreamer.cpp
Go to the documentation of this file.
1//===- DwarfStreamer.cpp --------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
16#include "llvm/MC/MCDwarf.h"
18#include "llvm/MC/MCSection.h"
19#include "llvm/MC/MCStreamer.h"
25#include "llvm/Support/LEB128.h"
28
29using namespace llvm;
30using namespace dwarf_linker;
31using namespace dwarf_linker::classic;
32
34 const Triple &TheTriple, DWARFLinkerBase::OutputFileType FileType,
37 std::unique_ptr<DwarfStreamer> Streamer =
38 std::make_unique<DwarfStreamer>(FileType, OutFile, Translator, Warning);
39 if (Error Err = Streamer->init(TheTriple, "__DWARF"))
40 return std::move(Err);
41
42 return std::move(Streamer);
43}
44
46 StringRef Swift5ReflectionSegmentName) {
47 std::string ErrorStr;
48 std::string TripleName;
49
50 // Get the target.
51 const Target *TheTarget =
52 TargetRegistry::lookupTarget(TripleName, TheTriple, ErrorStr);
53 if (!TheTarget)
54 return createStringError(std::errc::invalid_argument, ErrorStr.c_str());
55
56 TripleName = TheTriple.getTriple();
57
58 // Create all the MC Objects.
59 MRI.reset(TheTarget->createMCRegInfo(TripleName));
60 if (!MRI)
61 return createStringError(std::errc::invalid_argument,
62 "no register info for target %s",
63 TripleName.c_str());
64
66 MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
67 if (!MAI)
68 return createStringError(std::errc::invalid_argument,
69 "no asm info for target %s", TripleName.c_str());
70
71 MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
72 if (!MSTI)
73 return createStringError(std::errc::invalid_argument,
74 "no subtarget info for target %s",
75 TripleName.c_str());
76
77 MC.reset(new MCContext(TheTriple, MAI.get(), MRI.get(), MSTI.get(), nullptr,
78 nullptr, true, Swift5ReflectionSegmentName));
79 MOFI.reset(TheTarget->createMCObjectFileInfo(*MC, /*PIC=*/false, false));
80 MC->setObjectFileInfo(MOFI.get());
81
82 MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, MCOptions);
83 if (!MAB)
84 return createStringError(std::errc::invalid_argument,
85 "no asm backend for target %s",
86 TripleName.c_str());
87
88 MII.reset(TheTarget->createMCInstrInfo());
89 if (!MII)
90 return createStringError(std::errc::invalid_argument,
91 "no instr info info for target %s",
92 TripleName.c_str());
93
94 MCE = TheTarget->createMCCodeEmitter(*MII, *MC);
95 if (!MCE)
96 return createStringError(std::errc::invalid_argument,
97 "no code emitter for target %s",
98 TripleName.c_str());
99
100 switch (OutFileType) {
102 MIP = TheTarget->createMCInstPrinter(TheTriple, MAI->getAssemblerDialect(),
103 *MAI, *MII, *MRI);
104 MS = TheTarget->createAsmStreamer(
105 *MC, std::make_unique<formatted_raw_ostream>(OutFile), true, true, MIP,
106 std::unique_ptr<MCCodeEmitter>(MCE), std::unique_ptr<MCAsmBackend>(MAB),
107 true);
108 break;
109 }
111 MS = TheTarget->createMCObjectStreamer(
112 TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB),
113 MAB->createObjectWriter(OutFile), std::unique_ptr<MCCodeEmitter>(MCE),
114 *MSTI, MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
115 /*DWARFMustBeAtTheEnd*/ false);
116 break;
117 }
118 }
119
120 if (!MS)
121 return createStringError(std::errc::invalid_argument,
122 "no object streamer for target %s",
123 TripleName.c_str());
124
125 // Finally create the AsmPrinter we'll use to emit the DIEs.
126 TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
127 std::nullopt));
128 if (!TM)
129 return createStringError(std::errc::invalid_argument,
130 "no target machine for target %s",
131 TripleName.c_str());
132
133 Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
134 if (!Asm)
135 return createStringError(std::errc::invalid_argument,
136 "no asm printer for target %s",
137 TripleName.c_str());
138 Asm->setDwarfUsesRelocationsAcrossSections(false);
139
140 RangesSectionSize = 0;
141 RngListsSectionSize = 0;
142 LocSectionSize = 0;
143 LocListsSectionSize = 0;
144 LineSectionSize = 0;
145 FrameSectionSize = 0;
146 DebugInfoSectionSize = 0;
147 MacInfoSectionSize = 0;
148 MacroSectionSize = 0;
149
150 return Error::success();
151}
152
154
155void DwarfStreamer::switchToDebugInfoSection(unsigned DwarfVersion) {
156 MS->switchSection(MOFI->getDwarfInfoSection());
157 MC->setDwarfVersion(DwarfVersion);
158}
159
160/// Emit the compilation unit header for \p Unit in the debug_info section.
161///
162/// A Dwarf 4 section header is encoded as:
163/// uint32_t Unit length (omitting this field)
164/// uint16_t Version
165/// uint32_t Abbreviation table offset
166/// uint8_t Address size
167/// Leading to a total of 11 bytes.
168///
169/// A Dwarf 5 section header is encoded as:
170/// uint32_t Unit length (omitting this field)
171/// uint16_t Version
172/// uint8_t Unit type
173/// uint8_t Address size
174/// uint32_t Abbreviation table offset
175/// Leading to a total of 12 bytes.
177 unsigned DwarfVersion) {
178 switchToDebugInfoSection(DwarfVersion);
179
180 /// The start of the unit within its section.
181 Unit.setLabelBegin(Asm->createTempSymbol("cu_begin"));
182 Asm->OutStreamer->emitLabel(Unit.getLabelBegin());
183
184 // Emit size of content not including length itself. The size has already
185 // been computed in CompileUnit::computeOffsets(). Subtract 4 to that size to
186 // account for the length field.
187 Asm->emitInt32(Unit.getNextUnitOffset() - Unit.getStartOffset() - 4);
188 Asm->emitInt16(DwarfVersion);
189
190 if (DwarfVersion >= 5) {
191 Asm->emitInt8(dwarf::DW_UT_compile);
192 Asm->emitInt8(Unit.getOrigUnit().getAddressByteSize());
193 // We share one abbreviations table across all units so it's always at the
194 // start of the section.
195 Asm->emitInt32(0);
196 DebugInfoSectionSize += 12;
197 } else {
198 // We share one abbreviations table across all units so it's always at the
199 // start of the section.
200 Asm->emitInt32(0);
201 Asm->emitInt8(Unit.getOrigUnit().getAddressByteSize());
202 DebugInfoSectionSize += 11;
203 }
204
205 // Remember this CU.
206 EmittedUnits.push_back({Unit.getUniqueID(), Unit.getLabelBegin()});
207}
208
209/// Emit the \p Abbrevs array as the shared abbreviation table
210/// for the linked Dwarf file.
212 const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
213 unsigned DwarfVersion) {
214 MS->switchSection(MOFI->getDwarfAbbrevSection());
215 MC->setDwarfVersion(DwarfVersion);
216 Asm->emitDwarfAbbrevs(Abbrevs);
217}
218
219/// Recursively emit the DIE tree rooted at \p Die.
221 MS->switchSection(MOFI->getDwarfInfoSection());
222 Asm->emitDwarfDIE(Die);
223 DebugInfoSectionSize += Die.getSize();
224}
225
226/// Emit contents of section SecName From Obj.
228 DebugSectionKind SecKind) {
229 if (SecData.empty())
230 return;
231
232 if (MCSection *Section = getMCSection(SecKind)) {
233 MS->switchSection(Section);
234
235 MS->emitBytes(SecData);
236 }
237}
238
239MCSection *DwarfStreamer::getMCSection(DebugSectionKind SecKind) {
240 switch (SecKind) {
242 return MC->getObjectFileInfo()->getDwarfInfoSection();
244 return MC->getObjectFileInfo()->getDwarfLineSection();
246 return MC->getObjectFileInfo()->getDwarfFrameSection();
248 return MC->getObjectFileInfo()->getDwarfRangesSection();
250 return MC->getObjectFileInfo()->getDwarfRnglistsSection();
252 return MC->getObjectFileInfo()->getDwarfLocSection();
254 return MC->getObjectFileInfo()->getDwarfLoclistsSection();
256 return MC->getObjectFileInfo()->getDwarfARangesSection();
258 return MC->getObjectFileInfo()->getDwarfAbbrevSection();
260 return MC->getObjectFileInfo()->getDwarfMacinfoSection();
262 return MC->getObjectFileInfo()->getDwarfMacroSection();
264 return MC->getObjectFileInfo()->getDwarfAddrSection();
266 return MC->getObjectFileInfo()->getDwarfStrSection();
268 return MC->getObjectFileInfo()->getDwarfLineStrSection();
270 return MC->getObjectFileInfo()->getDwarfStrOffSection();
272 return MC->getObjectFileInfo()->getDwarfPubNamesSection();
274 return MC->getObjectFileInfo()->getDwarfPubTypesSection();
276 return MC->getObjectFileInfo()->getDwarfDebugNamesSection();
278 return MC->getObjectFileInfo()->getDwarfAccelNamesSection();
280 return MC->getObjectFileInfo()->getDwarfAccelNamespaceSection();
282 return MC->getObjectFileInfo()->getDwarfAccelObjCSection();
284 return MC->getObjectFileInfo()->getDwarfAccelTypesSection();
286 llvm_unreachable("Unknown DebugSectionKind value");
287 break;
288 }
289
290 return nullptr;
291}
292
293/// Emit the debug_str section stored in \p Pool.
295 Asm->OutStreamer->switchSection(MOFI->getDwarfStrSection());
296 std::vector<DwarfStringPoolEntryRef> Entries = Pool.getEntriesForEmission();
297 for (auto Entry : Entries) {
298 // Emit the string itself.
299 Asm->OutStreamer->emitBytes(Entry.getString());
300 // Emit a null terminator.
301 Asm->emitInt8(0);
302 }
303}
304
305/// Emit the debug string offset table described by \p StringOffsets into the
306/// .debug_str_offsets table.
308 const SmallVector<uint64_t> &StringOffsets, uint16_t TargetDWARFVersion) {
309
310 if (TargetDWARFVersion < 5 || StringOffsets.empty())
311 return;
312
313 Asm->OutStreamer->switchSection(MOFI->getDwarfStrOffSection());
314
315 MCSymbol *BeginLabel = Asm->createTempSymbol("Bdebugstroff");
316 MCSymbol *EndLabel = Asm->createTempSymbol("Edebugstroff");
317
318 // Length.
319 Asm->emitLabelDifference(EndLabel, BeginLabel, sizeof(uint32_t));
320 Asm->OutStreamer->emitLabel(BeginLabel);
321 StrOffsetSectionSize += sizeof(uint32_t);
322
323 // Version.
324 MS->emitInt16(5);
325 StrOffsetSectionSize += sizeof(uint16_t);
326
327 // Padding.
328 MS->emitInt16(0);
329 StrOffsetSectionSize += sizeof(uint16_t);
330
331 for (auto Off : StringOffsets) {
332 Asm->OutStreamer->emitInt32(Off);
333 StrOffsetSectionSize += sizeof(uint32_t);
334 }
335 Asm->OutStreamer->emitLabel(EndLabel);
336}
337
338/// Emit the debug_line_str section stored in \p Pool.
340 Asm->OutStreamer->switchSection(MOFI->getDwarfLineStrSection());
341 std::vector<DwarfStringPoolEntryRef> Entries = Pool.getEntriesForEmission();
342 for (auto Entry : Entries) {
343 // Emit the string itself.
344 Asm->OutStreamer->emitBytes(Entry.getString());
345 // Emit a null terminator.
346 Asm->emitInt8(0);
347 }
348}
349
351 if (EmittedUnits.empty())
352 return;
353
354 // Build up data structures needed to emit this section.
355 std::vector<std::variant<MCSymbol *, uint64_t>> CompUnits;
356 DenseMap<unsigned, unsigned> UniqueIdToCuMap;
357 unsigned Id = 0;
358 for (auto &CU : EmittedUnits) {
359 CompUnits.push_back(CU.LabelBegin);
360 // We might be omitting CUs, so we need to remap them.
361 UniqueIdToCuMap[CU.ID] = Id++;
362 }
363
364 Asm->OutStreamer->switchSection(MOFI->getDwarfDebugNamesSection());
365 dwarf::Form Form = DIEInteger::BestForm(/*IsSigned*/ false,
366 (uint64_t)UniqueIdToCuMap.size() - 1);
367 /// llvm-dwarfutil doesn't support type units + .debug_names right now.
368 // FIXME: add support for type units + .debug_names. For now the behavior is
369 // unsuported.
371 Asm.get(), Table, CompUnits,
372 [&](const DWARF5AccelTableData &Entry)
373 -> std::optional<DWARF5AccelTable::UnitIndexAndEncoding> {
374 if (UniqueIdToCuMap.size() > 1)
375 return {{UniqueIdToCuMap[Entry.getUnitID()],
376 {dwarf::DW_IDX_compile_unit, Form}}};
377 return std::nullopt;
378 });
379}
380
383 Asm->OutStreamer->switchSection(MOFI->getDwarfAccelNamespaceSection());
384 auto *SectionBegin = Asm->createTempSymbol("namespac_begin");
385 Asm->OutStreamer->emitLabel(SectionBegin);
386 emitAppleAccelTable(Asm.get(), Table, "namespac", SectionBegin);
387}
388
391 Asm->OutStreamer->switchSection(MOFI->getDwarfAccelNamesSection());
392 auto *SectionBegin = Asm->createTempSymbol("names_begin");
393 Asm->OutStreamer->emitLabel(SectionBegin);
394 emitAppleAccelTable(Asm.get(), Table, "names", SectionBegin);
395}
396
399 Asm->OutStreamer->switchSection(MOFI->getDwarfAccelObjCSection());
400 auto *SectionBegin = Asm->createTempSymbol("objc_begin");
401 Asm->OutStreamer->emitLabel(SectionBegin);
402 emitAppleAccelTable(Asm.get(), Table, "objc", SectionBegin);
403}
404
407 Asm->OutStreamer->switchSection(MOFI->getDwarfAccelTypesSection());
408 auto *SectionBegin = Asm->createTempSymbol("types_begin");
409 Asm->OutStreamer->emitLabel(SectionBegin);
410 emitAppleAccelTable(Asm.get(), Table, "types", SectionBegin);
411}
412
413/// Emit the swift_ast section stored in \p Buffers.
415 MCSection *SwiftASTSection = MOFI->getDwarfSwiftASTSection();
416 SwiftASTSection->setAlignment(Align(32));
417 MS->switchSection(SwiftASTSection);
418 MS->emitBytes(Buffer);
419}
420
423 StringRef Buffer, uint32_t Alignment, uint32_t Size) {
424 MCSection *ReflectionSection =
425 MOFI->getSwift5ReflectionSection(ReflSectionKind);
426 if (ReflectionSection == nullptr)
427 return;
428 ReflectionSection->setAlignment(Align(Alignment));
429 MS->switchSection(ReflectionSection);
430 MS->emitBytes(Buffer);
431}
432
434 const CompileUnit &Unit, const AddressRanges &LinkedRanges) {
435 unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
436
437 // Make .debug_aranges to be current section.
438 MS->switchSection(MC->getObjectFileInfo()->getDwarfARangesSection());
439
440 // Emit Header.
441 MCSymbol *BeginLabel = Asm->createTempSymbol("Barange");
442 MCSymbol *EndLabel = Asm->createTempSymbol("Earange");
443
444 unsigned HeaderSize =
445 sizeof(int32_t) + // Size of contents (w/o this field
446 sizeof(int16_t) + // DWARF ARange version number
447 sizeof(int32_t) + // Offset of CU in the .debug_info section
448 sizeof(int8_t) + // Pointer Size (in bytes)
449 sizeof(int8_t); // Segment Size (in bytes)
450
451 unsigned TupleSize = AddressSize * 2;
452 unsigned Padding = offsetToAlignment(HeaderSize, Align(TupleSize));
453
454 Asm->emitLabelDifference(EndLabel, BeginLabel, 4); // Arange length
455 Asm->OutStreamer->emitLabel(BeginLabel);
456 Asm->emitInt16(dwarf::DW_ARANGES_VERSION); // Version number
457 Asm->emitInt32(Unit.getStartOffset()); // Corresponding unit's offset
458 Asm->emitInt8(AddressSize); // Address size
459 Asm->emitInt8(0); // Segment size
460
461 Asm->OutStreamer->emitFill(Padding, 0x0);
462
463 // Emit linked ranges.
464 for (const AddressRange &Range : LinkedRanges) {
465 MS->emitIntValue(Range.start(), AddressSize);
466 MS->emitIntValue(Range.end() - Range.start(), AddressSize);
467 }
468
469 // Emit terminator.
470 Asm->OutStreamer->emitIntValue(0, AddressSize);
471 Asm->OutStreamer->emitIntValue(0, AddressSize);
472 Asm->OutStreamer->emitLabel(EndLabel);
473}
474
475void DwarfStreamer::emitDwarfDebugRangesTableFragment(
476 const CompileUnit &Unit, const AddressRanges &LinkedRanges,
477 PatchLocation Patch) {
478 Patch.set(RangesSectionSize);
479
480 // Make .debug_ranges to be current section.
481 MS->switchSection(MC->getObjectFileInfo()->getDwarfRangesSection());
482 unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
483
484 // Emit ranges.
485 uint64_t BaseAddress = 0;
486 if (std::optional<uint64_t> LowPC = Unit.getLowPc())
487 BaseAddress = *LowPC;
488
489 for (const AddressRange &Range : LinkedRanges) {
490 MS->emitIntValue(Range.start() - BaseAddress, AddressSize);
491 MS->emitIntValue(Range.end() - BaseAddress, AddressSize);
492
493 RangesSectionSize += AddressSize;
494 RangesSectionSize += AddressSize;
495 }
496
497 // Add the terminator entry.
498 MS->emitIntValue(0, AddressSize);
499 MS->emitIntValue(0, AddressSize);
500
501 RangesSectionSize += AddressSize;
502 RangesSectionSize += AddressSize;
503}
504
505MCSymbol *
507 if (Unit.getOrigUnit().getVersion() < 5)
508 return nullptr;
509
510 // Make .debug_rnglists to be current section.
511 MS->switchSection(MC->getObjectFileInfo()->getDwarfRnglistsSection());
512
513 MCSymbol *BeginLabel = Asm->createTempSymbol("Brnglists");
514 MCSymbol *EndLabel = Asm->createTempSymbol("Ernglists");
515 unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
516
517 // Length
518 Asm->emitLabelDifference(EndLabel, BeginLabel, sizeof(uint32_t));
519 Asm->OutStreamer->emitLabel(BeginLabel);
520 RngListsSectionSize += sizeof(uint32_t);
521
522 // Version.
523 MS->emitInt16(5);
524 RngListsSectionSize += sizeof(uint16_t);
525
526 // Address size.
527 MS->emitInt8(AddressSize);
528 RngListsSectionSize++;
529
530 // Seg_size
531 MS->emitInt8(0);
532 RngListsSectionSize++;
533
534 // Offset entry count
535 MS->emitInt32(0);
536 RngListsSectionSize += sizeof(uint32_t);
537
538 return EndLabel;
539}
540
542 const CompileUnit &Unit, const AddressRanges &LinkedRanges,
543 PatchLocation Patch, DebugDieValuePool &AddrPool) {
544 if (Unit.getOrigUnit().getVersion() < 5) {
545 emitDwarfDebugRangesTableFragment(Unit, LinkedRanges, Patch);
546 return;
547 }
548
549 emitDwarfDebugRngListsTableFragment(Unit, LinkedRanges, Patch, AddrPool);
550}
551
553 MCSymbol *EndLabel) {
554 if (Unit.getOrigUnit().getVersion() < 5)
555 return;
556
557 // Make .debug_rnglists to be current section.
558 MS->switchSection(MC->getObjectFileInfo()->getDwarfRnglistsSection());
559
560 if (EndLabel != nullptr)
561 Asm->OutStreamer->emitLabel(EndLabel);
562}
563
564void DwarfStreamer::emitDwarfDebugRngListsTableFragment(
565 const CompileUnit &Unit, const AddressRanges &LinkedRanges,
566 PatchLocation Patch, DebugDieValuePool &AddrPool) {
567 Patch.set(RngListsSectionSize);
568
569 // Make .debug_rnglists to be current section.
570 MS->switchSection(MC->getObjectFileInfo()->getDwarfRnglistsSection());
571 std::optional<uint64_t> BaseAddress;
572
573 for (const AddressRange &Range : LinkedRanges) {
574
575 if (!BaseAddress) {
576 BaseAddress = Range.start();
577
578 // Emit base address.
579 MS->emitInt8(dwarf::DW_RLE_base_addressx);
580 RngListsSectionSize += 1;
581 RngListsSectionSize +=
582 MS->emitULEB128IntValue(AddrPool.getValueIndex(*BaseAddress));
583 }
584
585 // Emit type of entry.
586 MS->emitInt8(dwarf::DW_RLE_offset_pair);
587 RngListsSectionSize += 1;
588
589 // Emit start offset relative to base address.
590 RngListsSectionSize +=
591 MS->emitULEB128IntValue(Range.start() - *BaseAddress);
592
593 // Emit end offset relative to base address.
594 RngListsSectionSize += MS->emitULEB128IntValue(Range.end() - *BaseAddress);
595 }
596
597 // Emit the terminator entry.
598 MS->emitInt8(dwarf::DW_RLE_end_of_list);
599 RngListsSectionSize += 1;
600}
601
602/// Emit debug locations(.debug_loc, .debug_loclists) header.
604 if (Unit.getOrigUnit().getVersion() < 5)
605 return nullptr;
606
607 // Make .debug_loclists the current section.
608 MS->switchSection(MC->getObjectFileInfo()->getDwarfLoclistsSection());
609
610 MCSymbol *BeginLabel = Asm->createTempSymbol("Bloclists");
611 MCSymbol *EndLabel = Asm->createTempSymbol("Eloclists");
612 unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
613
614 // Length
615 Asm->emitLabelDifference(EndLabel, BeginLabel, sizeof(uint32_t));
616 Asm->OutStreamer->emitLabel(BeginLabel);
617 LocListsSectionSize += sizeof(uint32_t);
618
619 // Version.
620 MS->emitInt16(5);
621 LocListsSectionSize += sizeof(uint16_t);
622
623 // Address size.
624 MS->emitInt8(AddressSize);
625 LocListsSectionSize++;
626
627 // Seg_size
628 MS->emitInt8(0);
629 LocListsSectionSize++;
630
631 // Offset entry count
632 MS->emitInt32(0);
633 LocListsSectionSize += sizeof(uint32_t);
634
635 return EndLabel;
636}
637
638/// Emit debug locations(.debug_loc, .debug_loclists) fragment.
640 const CompileUnit &Unit,
641 const DWARFLocationExpressionsVector &LinkedLocationExpression,
642 PatchLocation Patch, DebugDieValuePool &AddrPool) {
643 if (Unit.getOrigUnit().getVersion() < 5) {
644 emitDwarfDebugLocTableFragment(Unit, LinkedLocationExpression, Patch);
645 return;
646 }
647
648 emitDwarfDebugLocListsTableFragment(Unit, LinkedLocationExpression, Patch,
649 AddrPool);
650}
651
652/// Emit debug locations(.debug_loc, .debug_loclists) footer.
654 MCSymbol *EndLabel) {
655 if (Unit.getOrigUnit().getVersion() < 5)
656 return;
657
658 // Make .debug_loclists the current section.
659 MS->switchSection(MC->getObjectFileInfo()->getDwarfLoclistsSection());
660
661 if (EndLabel != nullptr)
662 Asm->OutStreamer->emitLabel(EndLabel);
663}
664
665/// Emit piece of .debug_loc for \p LinkedLocationExpression.
666void DwarfStreamer::emitDwarfDebugLocTableFragment(
667 const CompileUnit &Unit,
668 const DWARFLocationExpressionsVector &LinkedLocationExpression,
669 PatchLocation Patch) {
670 Patch.set(LocSectionSize);
671
672 // Make .debug_loc to be current section.
673 MS->switchSection(MC->getObjectFileInfo()->getDwarfLocSection());
674 unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
675
676 // Emit ranges.
677 uint64_t BaseAddress = 0;
678 if (std::optional<uint64_t> LowPC = Unit.getLowPc())
679 BaseAddress = *LowPC;
680
681 for (const DWARFLocationExpression &LocExpression :
682 LinkedLocationExpression) {
683 if (LocExpression.Range) {
684 MS->emitIntValue(LocExpression.Range->LowPC - BaseAddress, AddressSize);
685 MS->emitIntValue(LocExpression.Range->HighPC - BaseAddress, AddressSize);
686
687 LocSectionSize += AddressSize;
688 LocSectionSize += AddressSize;
689 }
690
691 Asm->OutStreamer->emitIntValue(LocExpression.Expr.size(), 2);
692 Asm->OutStreamer->emitBytes(StringRef(
693 (const char *)LocExpression.Expr.data(), LocExpression.Expr.size()));
694 LocSectionSize += LocExpression.Expr.size() + 2;
695 }
696
697 // Add the terminator entry.
698 MS->emitIntValue(0, AddressSize);
699 MS->emitIntValue(0, AddressSize);
700
701 LocSectionSize += AddressSize;
702 LocSectionSize += AddressSize;
703}
704
705/// Emit .debug_addr header.
707
708 // Make .debug_addr the current section.
709 MS->switchSection(MC->getObjectFileInfo()->getDwarfAddrSection());
710
711 MCSymbol *BeginLabel = Asm->createTempSymbol("Bdebugaddr");
712 MCSymbol *EndLabel = Asm->createTempSymbol("Edebugaddr");
713 unsigned AddrSize = Unit.getOrigUnit().getAddressByteSize();
714
715 // Emit length.
716 Asm->emitLabelDifference(EndLabel, BeginLabel, sizeof(uint32_t));
717 Asm->OutStreamer->emitLabel(BeginLabel);
718 AddrSectionSize += sizeof(uint32_t);
719
720 // Emit version.
721 Asm->emitInt16(5);
722 AddrSectionSize += 2;
723
724 // Emit address size.
725 Asm->emitInt8(AddrSize);
726 AddrSectionSize += 1;
727
728 // Emit segment size.
729 Asm->emitInt8(0);
730 AddrSectionSize += 1;
731
732 return EndLabel;
733}
734
735/// Emit the .debug_addr addresses stored in \p Addrs.
737 uint8_t AddrSize) {
738 Asm->OutStreamer->switchSection(MOFI->getDwarfAddrSection());
739 for (auto Addr : Addrs) {
740 Asm->OutStreamer->emitIntValue(Addr, AddrSize);
741 AddrSectionSize += AddrSize;
742 }
743}
744
745/// Emit .debug_addr footer.
747 MCSymbol *EndLabel) {
748
749 // Make .debug_addr the current section.
750 MS->switchSection(MC->getObjectFileInfo()->getDwarfAddrSection());
751
752 if (EndLabel != nullptr)
753 Asm->OutStreamer->emitLabel(EndLabel);
754}
755
756/// Emit piece of .debug_loclists for \p LinkedLocationExpression.
757void DwarfStreamer::emitDwarfDebugLocListsTableFragment(
758 const CompileUnit &Unit,
759 const DWARFLocationExpressionsVector &LinkedLocationExpression,
760 PatchLocation Patch, DebugDieValuePool &AddrPool) {
761 Patch.set(LocListsSectionSize);
762
763 // Make .debug_loclists the current section.
764 MS->switchSection(MC->getObjectFileInfo()->getDwarfLoclistsSection());
765 std::optional<uint64_t> BaseAddress;
766
767 for (const DWARFLocationExpression &LocExpression :
768 LinkedLocationExpression) {
769 if (LocExpression.Range) {
770
771 if (!BaseAddress) {
772
773 BaseAddress = LocExpression.Range->LowPC;
774
775 // Emit base address.
776 MS->emitInt8(dwarf::DW_LLE_base_addressx);
777 LocListsSectionSize += 1;
778 LocListsSectionSize +=
779 MS->emitULEB128IntValue(AddrPool.getValueIndex(*BaseAddress));
780 }
781
782 // Emit type of entry.
783 MS->emitInt8(dwarf::DW_LLE_offset_pair);
784 LocListsSectionSize += 1;
785
786 // Emit start offset relative to base address.
787 LocListsSectionSize +=
788 MS->emitULEB128IntValue(LocExpression.Range->LowPC - *BaseAddress);
789
790 // Emit end offset relative to base address.
791 LocListsSectionSize +=
792 MS->emitULEB128IntValue(LocExpression.Range->HighPC - *BaseAddress);
793 } else {
794 // Emit type of entry.
795 MS->emitInt8(dwarf::DW_LLE_default_location);
796 LocListsSectionSize += 1;
797 }
798
799 LocListsSectionSize += MS->emitULEB128IntValue(LocExpression.Expr.size());
800 Asm->OutStreamer->emitBytes(StringRef(
801 (const char *)LocExpression.Expr.data(), LocExpression.Expr.size()));
802 LocListsSectionSize += LocExpression.Expr.size();
803 }
804
805 // Emit the terminator entry.
806 MS->emitInt8(dwarf::DW_LLE_end_of_list);
807 LocListsSectionSize += 1;
808}
809
811 const DWARFDebugLine::LineTable &LineTable, const CompileUnit &Unit,
812 OffsetsStringPool &DebugStrPool, OffsetsStringPool &DebugLineStrPool) {
813 // Switch to the section where the table will be emitted into.
814 MS->switchSection(MC->getObjectFileInfo()->getDwarfLineSection());
815
816 MCSymbol *LineStartSym = MC->createTempSymbol();
817 MCSymbol *LineEndSym = MC->createTempSymbol();
818
819 // unit_length.
822 LineSectionSize += 4;
823 }
824 emitLabelDifference(LineEndSym, LineStartSym,
825 LineTable.Prologue.FormParams.Format, LineSectionSize);
826 Asm->OutStreamer->emitLabel(LineStartSym);
827
828 // Emit prologue.
829 emitLineTablePrologue(LineTable.Prologue, DebugStrPool, DebugLineStrPool);
830
831 // Emit rows.
832 emitLineTableRows(LineTable, LineEndSym,
833 Unit.getOrigUnit().getAddressByteSize());
834}
835
836void DwarfStreamer::emitLineTablePrologue(const DWARFDebugLine::Prologue &P,
837 OffsetsStringPool &DebugStrPool,
838 OffsetsStringPool &DebugLineStrPool) {
839 MCSymbol *PrologueStartSym = MC->createTempSymbol();
840 MCSymbol *PrologueEndSym = MC->createTempSymbol();
841
842 // version (uhalf).
843 MS->emitInt16(P.getVersion());
844 LineSectionSize += 2;
845 if (P.getVersion() == 5) {
846 // address_size (ubyte).
847 MS->emitInt8(P.getAddressSize());
848 LineSectionSize += 1;
849
850 // segment_selector_size (ubyte).
851 MS->emitInt8(P.SegSelectorSize);
852 LineSectionSize += 1;
853 }
854
855 // header_length.
856 emitLabelDifference(PrologueEndSym, PrologueStartSym, P.FormParams.Format,
857 LineSectionSize);
858
859 Asm->OutStreamer->emitLabel(PrologueStartSym);
860 emitLineTableProloguePayload(P, DebugStrPool, DebugLineStrPool);
861 Asm->OutStreamer->emitLabel(PrologueEndSym);
862}
863
864void DwarfStreamer::emitLineTablePrologueV2IncludeAndFileTable(
865 const DWARFDebugLine::Prologue &P, OffsetsStringPool &DebugStrPool,
866 OffsetsStringPool &DebugLineStrPool) {
867 // include_directories (sequence of path names).
868 for (const DWARFFormValue &Include : P.IncludeDirectories)
869 emitLineTableString(P, Include, DebugStrPool, DebugLineStrPool);
870 // The last entry is followed by a single null byte.
871 MS->emitInt8(0);
872 LineSectionSize += 1;
873
874 // file_names (sequence of file entries).
875 for (const DWARFDebugLine::FileNameEntry &File : P.FileNames) {
876 // A null-terminated string containing the full or relative path name of a
877 // source file.
878 emitLineTableString(P, File.Name, DebugStrPool, DebugLineStrPool);
879 // An unsigned LEB128 number representing the directory index of a directory
880 // in the include_directories section.
881 LineSectionSize += MS->emitULEB128IntValue(File.DirIdx);
882 // An unsigned LEB128 number representing the (implementation-defined) time
883 // of last modification for the file, or 0 if not available.
884 LineSectionSize += MS->emitULEB128IntValue(File.ModTime);
885 // An unsigned LEB128 number representing the length in bytes of the file,
886 // or 0 if not available.
887 LineSectionSize += MS->emitULEB128IntValue(File.Length);
888 }
889 // The last entry is followed by a single null byte.
890 MS->emitInt8(0);
891 LineSectionSize += 1;
892}
893
894void DwarfStreamer::emitLineTablePrologueV5IncludeAndFileTable(
895 const DWARFDebugLine::Prologue &P, OffsetsStringPool &DebugStrPool,
896 OffsetsStringPool &DebugLineStrPool) {
897 if (P.IncludeDirectories.empty()) {
898 // directory_entry_format_count(ubyte).
899 MS->emitInt8(0);
900 LineSectionSize += 1;
901 } else {
902 // directory_entry_format_count(ubyte).
903 MS->emitInt8(1);
904 LineSectionSize += 1;
905
906 // directory_entry_format (sequence of ULEB128 pairs).
907 LineSectionSize += MS->emitULEB128IntValue(dwarf::DW_LNCT_path);
908 LineSectionSize +=
909 MS->emitULEB128IntValue(P.IncludeDirectories[0].getForm());
910 }
911
912 // directories_count (ULEB128).
913 LineSectionSize += MS->emitULEB128IntValue(P.IncludeDirectories.size());
914 // directories (sequence of directory names).
915 for (auto Include : P.IncludeDirectories)
916 emitLineTableString(P, Include, DebugStrPool, DebugLineStrPool);
917
918 bool HasChecksums = P.ContentTypes.HasMD5;
919 bool HasInlineSources = P.ContentTypes.HasSource;
920
921 if (P.FileNames.empty()) {
922 // file_name_entry_format_count (ubyte).
923 MS->emitInt8(0);
924 LineSectionSize += 1;
925 } else {
926 // file_name_entry_format_count (ubyte).
927 MS->emitInt8(2 + (HasChecksums ? 1 : 0) + (HasInlineSources ? 1 : 0));
928 LineSectionSize += 1;
929
930 // file_name_entry_format (sequence of ULEB128 pairs).
931 auto StrForm = P.FileNames[0].Name.getForm();
932 LineSectionSize += MS->emitULEB128IntValue(dwarf::DW_LNCT_path);
933 LineSectionSize += MS->emitULEB128IntValue(StrForm);
934
935 LineSectionSize += MS->emitULEB128IntValue(dwarf::DW_LNCT_directory_index);
936 LineSectionSize += MS->emitULEB128IntValue(dwarf::DW_FORM_data1);
937
938 if (HasChecksums) {
939 LineSectionSize += MS->emitULEB128IntValue(dwarf::DW_LNCT_MD5);
940 LineSectionSize += MS->emitULEB128IntValue(dwarf::DW_FORM_data16);
941 }
942
943 if (HasInlineSources) {
944 LineSectionSize += MS->emitULEB128IntValue(dwarf::DW_LNCT_LLVM_source);
945 LineSectionSize += MS->emitULEB128IntValue(StrForm);
946 }
947 }
948
949 // file_names_count (ULEB128).
950 LineSectionSize += MS->emitULEB128IntValue(P.FileNames.size());
951
952 // file_names (sequence of file name entries).
953 for (auto File : P.FileNames) {
954 emitLineTableString(P, File.Name, DebugStrPool, DebugLineStrPool);
955 MS->emitInt8(File.DirIdx);
956 LineSectionSize += 1;
957 if (HasChecksums) {
958 MS->emitBinaryData(
959 StringRef(reinterpret_cast<const char *>(File.Checksum.data()),
960 File.Checksum.size()));
961 LineSectionSize += File.Checksum.size();
962 }
963 if (HasInlineSources)
964 emitLineTableString(P, File.Source, DebugStrPool, DebugLineStrPool);
965 }
966}
967
968void DwarfStreamer::emitLineTableString(const DWARFDebugLine::Prologue &P,
969 const DWARFFormValue &String,
970 OffsetsStringPool &DebugStrPool,
971 OffsetsStringPool &DebugLineStrPool) {
972 std::optional<const char *> StringVal = dwarf::toString(String);
973 if (!StringVal) {
974 warn("Cann't read string from line table.");
975 return;
976 }
977
978 switch (String.getForm()) {
979 case dwarf::DW_FORM_string: {
980 StringRef TranslatedString =
981 (Translator) ? Translator(*StringVal) : *StringVal;
982 Asm->OutStreamer->emitBytes(TranslatedString.data());
983 Asm->emitInt8(0);
984 LineSectionSize += TranslatedString.size() + 1;
985 } break;
986 case dwarf::DW_FORM_strp:
987 case dwarf::DW_FORM_line_strp: {
989 String.getForm() == dwarf::DW_FORM_strp
990 ? DebugStrPool.getEntry(*StringVal)
991 : DebugLineStrPool.getEntry(*StringVal);
992
993 emitIntOffset(StringRef.getOffset(), P.FormParams.Format, LineSectionSize);
994 } break;
995 default:
996 warn("Unsupported string form inside line table.");
997 break;
998 };
999}
1000
1001void DwarfStreamer::emitLineTableProloguePayload(
1002 const DWARFDebugLine::Prologue &P, OffsetsStringPool &DebugStrPool,
1003 OffsetsStringPool &DebugLineStrPool) {
1004 // minimum_instruction_length (ubyte).
1005 MS->emitInt8(P.MinInstLength);
1006 LineSectionSize += 1;
1007 if (P.FormParams.Version >= 4) {
1008 // maximum_operations_per_instruction (ubyte).
1009 MS->emitInt8(P.MaxOpsPerInst);
1010 LineSectionSize += 1;
1011 }
1012 // default_is_stmt (ubyte).
1013 MS->emitInt8(P.DefaultIsStmt);
1014 LineSectionSize += 1;
1015 // line_base (sbyte).
1016 MS->emitInt8(P.LineBase);
1017 LineSectionSize += 1;
1018 // line_range (ubyte).
1019 MS->emitInt8(P.LineRange);
1020 LineSectionSize += 1;
1021 // opcode_base (ubyte).
1022 MS->emitInt8(P.OpcodeBase);
1023 LineSectionSize += 1;
1024
1025 // standard_opcode_lengths (array of ubyte).
1026 for (auto Length : P.StandardOpcodeLengths) {
1027 MS->emitInt8(Length);
1028 LineSectionSize += 1;
1029 }
1030
1031 if (P.FormParams.Version < 5)
1032 emitLineTablePrologueV2IncludeAndFileTable(P, DebugStrPool,
1033 DebugLineStrPool);
1034 else
1035 emitLineTablePrologueV5IncludeAndFileTable(P, DebugStrPool,
1036 DebugLineStrPool);
1037}
1038
1039void DwarfStreamer::emitLineTableRows(
1040 const DWARFDebugLine::LineTable &LineTable, MCSymbol *LineEndSym,
1041 unsigned AddressByteSize) {
1042
1044 Params.DWARF2LineOpcodeBase = LineTable.Prologue.OpcodeBase;
1045 Params.DWARF2LineBase = LineTable.Prologue.LineBase;
1046 Params.DWARF2LineRange = LineTable.Prologue.LineRange;
1047
1048 SmallString<128> EncodingBuffer;
1049
1050 if (LineTable.Rows.empty()) {
1051 // We only have the dummy entry, dsymutil emits an entry with a 0
1052 // address in that case.
1053 MCDwarfLineAddr::encode(*MC, Params, std::numeric_limits<int64_t>::max(), 0,
1054 EncodingBuffer);
1055 MS->emitBytes(EncodingBuffer);
1056 LineSectionSize += EncodingBuffer.size();
1057 MS->emitLabel(LineEndSym);
1058 return;
1059 }
1060
1061 // Line table state machine fields
1062 unsigned FileNum = 1;
1063 unsigned LastLine = 1;
1064 unsigned Column = 0;
1065 unsigned IsStatement = 1;
1066 unsigned Isa = 0;
1067 uint64_t Address = -1ULL;
1068
1069 unsigned RowsSinceLastSequence = 0;
1070
1071 for (const DWARFDebugLine::Row &Row : LineTable.Rows) {
1072 int64_t AddressDelta;
1073 if (Address == -1ULL) {
1074 MS->emitIntValue(dwarf::DW_LNS_extended_op, 1);
1075 MS->emitULEB128IntValue(AddressByteSize + 1);
1076 MS->emitIntValue(dwarf::DW_LNE_set_address, 1);
1077 MS->emitIntValue(Row.Address.Address, AddressByteSize);
1078 LineSectionSize +=
1079 2 + AddressByteSize + getULEB128Size(AddressByteSize + 1);
1080 AddressDelta = 0;
1081 } else {
1082 AddressDelta =
1083 (Row.Address.Address - Address) / LineTable.Prologue.MinInstLength;
1084 }
1085
1086 // FIXME: code copied and transformed from MCDwarf.cpp::EmitDwarfLineTable.
1087 // We should find a way to share this code, but the current compatibility
1088 // requirement with classic dsymutil makes it hard. Revisit that once this
1089 // requirement is dropped.
1090
1091 if (FileNum != Row.File) {
1092 FileNum = Row.File;
1093 MS->emitIntValue(dwarf::DW_LNS_set_file, 1);
1094 MS->emitULEB128IntValue(FileNum);
1095 LineSectionSize += 1 + getULEB128Size(FileNum);
1096 }
1097 if (Column != Row.Column) {
1098 Column = Row.Column;
1099 MS->emitIntValue(dwarf::DW_LNS_set_column, 1);
1100 MS->emitULEB128IntValue(Column);
1101 LineSectionSize += 1 + getULEB128Size(Column);
1102 }
1103
1104 // FIXME: We should handle the discriminator here, but dsymutil doesn't
1105 // consider it, thus ignore it for now.
1106
1107 if (Isa != Row.Isa) {
1108 Isa = Row.Isa;
1109 MS->emitIntValue(dwarf::DW_LNS_set_isa, 1);
1110 MS->emitULEB128IntValue(Isa);
1111 LineSectionSize += 1 + getULEB128Size(Isa);
1112 }
1113 if (IsStatement != Row.IsStmt) {
1114 IsStatement = Row.IsStmt;
1115 MS->emitIntValue(dwarf::DW_LNS_negate_stmt, 1);
1116 LineSectionSize += 1;
1117 }
1118 if (Row.BasicBlock) {
1119 MS->emitIntValue(dwarf::DW_LNS_set_basic_block, 1);
1120 LineSectionSize += 1;
1121 }
1122
1123 if (Row.PrologueEnd) {
1124 MS->emitIntValue(dwarf::DW_LNS_set_prologue_end, 1);
1125 LineSectionSize += 1;
1126 }
1127
1128 if (Row.EpilogueBegin) {
1129 MS->emitIntValue(dwarf::DW_LNS_set_epilogue_begin, 1);
1130 LineSectionSize += 1;
1131 }
1132
1133 int64_t LineDelta = int64_t(Row.Line) - LastLine;
1134 if (!Row.EndSequence) {
1135 MCDwarfLineAddr::encode(*MC, Params, LineDelta, AddressDelta,
1136 EncodingBuffer);
1137 MS->emitBytes(EncodingBuffer);
1138 LineSectionSize += EncodingBuffer.size();
1139 EncodingBuffer.resize(0);
1140 Address = Row.Address.Address;
1141 LastLine = Row.Line;
1142 RowsSinceLastSequence++;
1143 } else {
1144 if (LineDelta) {
1145 MS->emitIntValue(dwarf::DW_LNS_advance_line, 1);
1146 MS->emitSLEB128IntValue(LineDelta);
1147 LineSectionSize += 1 + getSLEB128Size(LineDelta);
1148 }
1149 if (AddressDelta) {
1150 MS->emitIntValue(dwarf::DW_LNS_advance_pc, 1);
1152 LineSectionSize += 1 + getULEB128Size(AddressDelta);
1153 }
1154 MCDwarfLineAddr::encode(*MC, Params, std::numeric_limits<int64_t>::max(),
1155 0, EncodingBuffer);
1156 MS->emitBytes(EncodingBuffer);
1157 LineSectionSize += EncodingBuffer.size();
1158 EncodingBuffer.resize(0);
1159 Address = -1ULL;
1160 LastLine = FileNum = IsStatement = 1;
1161 RowsSinceLastSequence = Column = Isa = 0;
1162 }
1163 }
1164
1165 if (RowsSinceLastSequence) {
1166 MCDwarfLineAddr::encode(*MC, Params, std::numeric_limits<int64_t>::max(), 0,
1167 EncodingBuffer);
1168 MS->emitBytes(EncodingBuffer);
1169 LineSectionSize += EncodingBuffer.size();
1170 EncodingBuffer.resize(0);
1171 }
1172
1173 MS->emitLabel(LineEndSym);
1174}
1175
1176void DwarfStreamer::emitIntOffset(uint64_t Offset, dwarf::DwarfFormat Format,
1177 uint64_t &SectionSize) {
1179 MS->emitIntValue(Offset, Size);
1180 SectionSize += Size;
1181}
1182
1183void DwarfStreamer::emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
1185 uint64_t &SectionSize) {
1187 Asm->emitLabelDifference(Hi, Lo, Size);
1188 SectionSize += Size;
1189}
1190
1191/// Emit the pubnames or pubtypes section contribution for \p
1192/// Unit into \p Sec. The data is provided in \p Names.
1193void DwarfStreamer::emitPubSectionForUnit(
1194 MCSection *Sec, StringRef SecName, const CompileUnit &Unit,
1195 const std::vector<CompileUnit::AccelInfo> &Names) {
1196 if (Names.empty())
1197 return;
1198
1199 // Start the dwarf pubnames section.
1200 Asm->OutStreamer->switchSection(Sec);
1201 MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + SecName + "_begin");
1202 MCSymbol *EndLabel = Asm->createTempSymbol("pub" + SecName + "_end");
1203
1204 bool HeaderEmitted = false;
1205 // Emit the pubnames for this compilation unit.
1206 for (const auto &Name : Names) {
1207 if (Name.SkipPubSection)
1208 continue;
1209
1210 if (!HeaderEmitted) {
1211 // Emit the header.
1212 Asm->emitLabelDifference(EndLabel, BeginLabel, 4); // Length
1213 Asm->OutStreamer->emitLabel(BeginLabel);
1214 Asm->emitInt16(dwarf::DW_PUBNAMES_VERSION); // Version
1215 Asm->emitInt32(Unit.getStartOffset()); // Unit offset
1216 Asm->emitInt32(Unit.getNextUnitOffset() - Unit.getStartOffset()); // Size
1217 HeaderEmitted = true;
1218 }
1219 Asm->emitInt32(Name.Die->getOffset());
1220
1221 // Emit the string itself.
1222 Asm->OutStreamer->emitBytes(Name.Name.getString());
1223 // Emit a null terminator.
1224 Asm->emitInt8(0);
1225 }
1226
1227 if (!HeaderEmitted)
1228 return;
1229 Asm->emitInt32(0); // End marker.
1230 Asm->OutStreamer->emitLabel(EndLabel);
1231}
1232
1233/// Emit .debug_pubnames for \p Unit.
1235 emitPubSectionForUnit(MC->getObjectFileInfo()->getDwarfPubNamesSection(),
1236 "names", Unit, Unit.getPubnames());
1237}
1238
1239/// Emit .debug_pubtypes for \p Unit.
1241 emitPubSectionForUnit(MC->getObjectFileInfo()->getDwarfPubTypesSection(),
1242 "types", Unit, Unit.getPubtypes());
1243}
1244
1245/// Emit a CIE into the debug_frame section.
1247 MS->switchSection(MC->getObjectFileInfo()->getDwarfFrameSection());
1248
1249 MS->emitBytes(CIEBytes);
1250 FrameSectionSize += CIEBytes.size();
1251}
1252
1253/// Emit a FDE into the debug_frame section. \p FDEBytes
1254/// contains the FDE data without the length, CIE offset and address
1255/// which will be replaced with the parameter values.
1257 uint64_t Address, StringRef FDEBytes) {
1258 MS->switchSection(MC->getObjectFileInfo()->getDwarfFrameSection());
1259
1260 MS->emitIntValue(FDEBytes.size() + 4 + AddrSize, 4);
1261 MS->emitIntValue(CIEOffset, 4);
1262 MS->emitIntValue(Address, AddrSize);
1263 MS->emitBytes(FDEBytes);
1264 FrameSectionSize += FDEBytes.size() + 8 + AddrSize;
1265}
1266
1268 const Offset2UnitMap &UnitMacroMap,
1270 assert(Context != nullptr && "Empty DWARF context");
1271
1272 // Check for .debug_macinfo table.
1273 if (const DWARFDebugMacro *Table = Context->getDebugMacinfo()) {
1274 MS->switchSection(MC->getObjectFileInfo()->getDwarfMacinfoSection());
1275 emitMacroTableImpl(Table, UnitMacroMap, StringPool, MacInfoSectionSize);
1276 }
1277
1278 // Check for .debug_macro table.
1279 if (const DWARFDebugMacro *Table = Context->getDebugMacro()) {
1280 MS->switchSection(MC->getObjectFileInfo()->getDwarfMacroSection());
1281 emitMacroTableImpl(Table, UnitMacroMap, StringPool, MacroSectionSize);
1282 }
1283}
1284
1285void DwarfStreamer::emitMacroTableImpl(const DWARFDebugMacro *MacroTable,
1286 const Offset2UnitMap &UnitMacroMap,
1288 uint64_t &OutOffset) {
1289 bool DefAttributeIsReported = false;
1290 bool UndefAttributeIsReported = false;
1291 bool ImportAttributeIsReported = false;
1292 for (const DWARFDebugMacro::MacroList &List : MacroTable->MacroLists) {
1293 Offset2UnitMap::const_iterator UnitIt = UnitMacroMap.find(List.Offset);
1294 if (UnitIt == UnitMacroMap.end()) {
1295 warn(formatv(
1296 "couldn`t find compile unit for the macro table with offset = {0:x}",
1297 List.Offset));
1298 continue;
1299 }
1300
1301 // Skip macro table if the unit was not cloned.
1302 DIE *OutputUnitDIE = UnitIt->second->getOutputUnitDIE();
1303 if (OutputUnitDIE == nullptr)
1304 continue;
1305
1306 // Update macro attribute of cloned compile unit with the proper offset to
1307 // the macro table.
1308 bool hasDWARFv5Header = false;
1309 for (auto &V : OutputUnitDIE->values()) {
1310 if (V.getAttribute() == dwarf::DW_AT_macro_info) {
1311 V = DIEValue(V.getAttribute(), V.getForm(), DIEInteger(OutOffset));
1312 break;
1313 } else if (V.getAttribute() == dwarf::DW_AT_macros) {
1314 hasDWARFv5Header = true;
1315 V = DIEValue(V.getAttribute(), V.getForm(), DIEInteger(OutOffset));
1316 break;
1317 }
1318 }
1319
1320 // Write DWARFv5 header.
1321 if (hasDWARFv5Header) {
1322 // Write header version.
1323 MS->emitIntValue(List.Header.Version, sizeof(List.Header.Version));
1324 OutOffset += sizeof(List.Header.Version);
1325
1326 uint8_t Flags = List.Header.Flags;
1327
1328 // Check for OPCODE_OPERANDS_TABLE.
1329 if (Flags &
1330 DWARFDebugMacro::HeaderFlagMask::MACRO_OPCODE_OPERANDS_TABLE) {
1331 Flags &= ~DWARFDebugMacro::HeaderFlagMask::MACRO_OPCODE_OPERANDS_TABLE;
1332 warn("opcode_operands_table is not supported yet.");
1333 }
1334
1335 // Check for DEBUG_LINE_OFFSET.
1336 std::optional<uint64_t> StmtListOffset;
1337 if (Flags & DWARFDebugMacro::HeaderFlagMask::MACRO_DEBUG_LINE_OFFSET) {
1338 // Get offset to the line table from the cloned compile unit.
1339 for (auto &V : OutputUnitDIE->values()) {
1340 if (V.getAttribute() == dwarf::DW_AT_stmt_list) {
1341 StmtListOffset = V.getDIEInteger().getValue();
1342 break;
1343 }
1344 }
1345
1346 if (!StmtListOffset) {
1347 Flags &= ~DWARFDebugMacro::HeaderFlagMask::MACRO_DEBUG_LINE_OFFSET;
1348 warn("couldn`t find line table for macro table.");
1349 }
1350 }
1351
1352 // Write flags.
1353 MS->emitIntValue(Flags, sizeof(Flags));
1354 OutOffset += sizeof(Flags);
1355
1356 // Write offset to line table.
1357 if (StmtListOffset) {
1358 MS->emitIntValue(*StmtListOffset, List.Header.getOffsetByteSize());
1359 OutOffset += List.Header.getOffsetByteSize();
1360 }
1361 }
1362
1363 // Write macro entries.
1364 for (const DWARFDebugMacro::Entry &MacroEntry : List.Macros) {
1365 if (MacroEntry.Type == 0) {
1366 OutOffset += MS->emitULEB128IntValue(MacroEntry.Type);
1367 continue;
1368 }
1369
1370 uint8_t MacroType = MacroEntry.Type;
1371 switch (MacroType) {
1372 default: {
1373 bool HasVendorSpecificExtension =
1374 (!hasDWARFv5Header && MacroType == dwarf::DW_MACINFO_vendor_ext) ||
1375 (hasDWARFv5Header && (MacroType >= dwarf::DW_MACRO_lo_user &&
1376 MacroType <= dwarf::DW_MACRO_hi_user));
1377
1378 if (HasVendorSpecificExtension) {
1379 // Write macinfo type.
1380 MS->emitIntValue(MacroType, 1);
1381 OutOffset++;
1382
1383 // Write vendor extension constant.
1384 OutOffset += MS->emitULEB128IntValue(MacroEntry.ExtConstant);
1385
1386 // Write vendor extension string.
1387 StringRef String = MacroEntry.ExtStr;
1388 MS->emitBytes(String);
1389 MS->emitIntValue(0, 1);
1390 OutOffset += String.size() + 1;
1391 } else
1392 warn("unknown macro type. skip.");
1393 } break;
1394 // debug_macro and debug_macinfo share some common encodings.
1395 // DW_MACRO_define == DW_MACINFO_define
1396 // DW_MACRO_undef == DW_MACINFO_undef
1397 // DW_MACRO_start_file == DW_MACINFO_start_file
1398 // DW_MACRO_end_file == DW_MACINFO_end_file
1399 // For readibility/uniformity we are using DW_MACRO_*.
1400 case dwarf::DW_MACRO_define:
1401 case dwarf::DW_MACRO_undef: {
1402 // Write macinfo type.
1403 MS->emitIntValue(MacroType, 1);
1404 OutOffset++;
1405
1406 // Write source line.
1407 OutOffset += MS->emitULEB128IntValue(MacroEntry.Line);
1408
1409 // Write macro string.
1410 StringRef String = MacroEntry.MacroStr;
1411 MS->emitBytes(String);
1412 MS->emitIntValue(0, 1);
1413 OutOffset += String.size() + 1;
1414 } break;
1415 case dwarf::DW_MACRO_define_strp:
1416 case dwarf::DW_MACRO_undef_strp:
1417 case dwarf::DW_MACRO_define_strx:
1418 case dwarf::DW_MACRO_undef_strx: {
1419 assert(UnitIt->second->getOrigUnit().getVersion() >= 5);
1420
1421 // DW_MACRO_*_strx forms are not supported currently.
1422 // Convert to *_strp.
1423 switch (MacroType) {
1424 case dwarf::DW_MACRO_define_strx: {
1425 MacroType = dwarf::DW_MACRO_define_strp;
1426 if (!DefAttributeIsReported) {
1427 warn("DW_MACRO_define_strx unsupported yet. Convert to "
1428 "DW_MACRO_define_strp.");
1429 DefAttributeIsReported = true;
1430 }
1431 } break;
1432 case dwarf::DW_MACRO_undef_strx: {
1433 MacroType = dwarf::DW_MACRO_undef_strp;
1434 if (!UndefAttributeIsReported) {
1435 warn("DW_MACRO_undef_strx unsupported yet. Convert to "
1436 "DW_MACRO_undef_strp.");
1437 UndefAttributeIsReported = true;
1438 }
1439 } break;
1440 default:
1441 // Nothing to do.
1442 break;
1443 }
1444
1445 // Write macinfo type.
1446 MS->emitIntValue(MacroType, 1);
1447 OutOffset++;
1448
1449 // Write source line.
1450 OutOffset += MS->emitULEB128IntValue(MacroEntry.Line);
1451
1452 // Write macro string.
1453 DwarfStringPoolEntryRef EntryRef =
1454 StringPool.getEntry(MacroEntry.MacroStr);
1455 MS->emitIntValue(EntryRef.getOffset(), List.Header.getOffsetByteSize());
1456 OutOffset += List.Header.getOffsetByteSize();
1457 break;
1458 }
1459 case dwarf::DW_MACRO_start_file: {
1460 // Write macinfo type.
1461 MS->emitIntValue(MacroType, 1);
1462 OutOffset++;
1463 // Write source line.
1464 OutOffset += MS->emitULEB128IntValue(MacroEntry.Line);
1465 // Write source file id.
1466 OutOffset += MS->emitULEB128IntValue(MacroEntry.File);
1467 } break;
1468 case dwarf::DW_MACRO_end_file: {
1469 // Write macinfo type.
1470 MS->emitIntValue(MacroType, 1);
1471 OutOffset++;
1472 } break;
1473 case dwarf::DW_MACRO_import:
1474 case dwarf::DW_MACRO_import_sup: {
1475 if (!ImportAttributeIsReported) {
1476 warn("DW_MACRO_import and DW_MACRO_import_sup are unsupported yet. "
1477 "remove.");
1478 ImportAttributeIsReported = true;
1479 }
1480 } break;
1481 }
1482 }
1483 }
1484}
uint64_t Addr
std::string Name
uint64_t Size
LLVMContext & Context
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition: AccelTable.h:202
A class that represents an address range.
Definition: AddressRanges.h:22
The AddressRanges class helps normalize address range collections.
An integer value DIE.
Definition: DIE.h:168
static dwarf::Form BestForm(bool IsSigned, uint64_t Int)
Choose the best form for integer.
Definition: DIE.h:175
value_range values()
Definition: DIE.h:807
A structured debug information entry.
Definition: DIE.h:819
unsigned getSize() const
Definition: DIE.h:862
The Data class implementation for DWARF v5 accelerator table.
Definition: AccelTable.h:276
DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...
Definition: DWARFContext.h:48
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
unsigned size() const
Definition: DenseMap.h:99
iterator end()
Definition: DenseMap.h:84
DwarfStringPoolEntryRef: Dwarf string pool entry reference.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
std::unique_ptr< MCObjectWriter > createObjectWriter(raw_pwrite_stream &OS) const
Create a new MCObjectWriter instance for use by the assembler backend to emit the final object file.
Context object for machine code objects.
Definition: MCContext.h:76
static void encode(MCContext &Context, MCDwarfLineTableParams Params, int64_t LineDelta, uint64_t AddrDelta, SmallVectorImpl< char > &OS)
Utility function to encode a Dwarf pair of LineDelta and AddrDeltas.
Definition: MCDwarf.cpp:683
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
void setAlignment(Align Value)
Definition: MCSection.h:141
virtual void emitBinaryData(StringRef Data)
Functionally identical to EmitBytes.
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:424
virtual void emitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers.
Definition: MCStreamer.cpp:134
void emitInt16(uint64_t Value)
Definition: MCStreamer.h:753
unsigned emitULEB128IntValue(uint64_t Value, unsigned PadTo=0)
Special case of EmitULEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:162
virtual void switchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
void emitInt32(uint64_t Value)
Definition: MCStreamer.h:754
unsigned emitSLEB128IntValue(int64_t Value)
Special case of EmitSLEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:172
void emitInt8(uint64_t Value)
Definition: MCStreamer.h:752
virtual void emitBytes(StringRef Data)
Emit the bytes in Data into the output.
void finish(SMLoc EndLoc=SMLoc())
Finish emission of machine code.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
A string table that doesn't need relocations.
std::vector< DwarfStringPoolEntryRef > getEntriesForEmission() const
Return the list of strings to be emitted.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
void resize(size_type N)
Definition: SmallVector.h:651
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
Helper for making strong types.
Target - Wrapper for Target specific information.
MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, MCContext &Ctx) const
createMCCodeEmitter - Create a target specific code emitter.
MCObjectFileInfo * createMCObjectFileInfo(MCContext &Ctx, bool PIC, bool LargeCodeModel=false) const
Create a MCObjectFileInfo implementation for the specified target triple.
MCSubtargetInfo * createMCSubtargetInfo(StringRef TheTriple, StringRef CPU, StringRef Features) const
createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, bool IsVerboseAsm, bool UseDwarfDirectory, MCInstPrinter *InstPrint, std::unique_ptr< MCCodeEmitter > &&CE, std::unique_ptr< MCAsmBackend > &&TAB, bool ShowInst) const
MCAsmBackend * createMCAsmBackend(const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) const
createMCAsmBackend - Create a target specific assembly parser.
MCRegisterInfo * createMCRegInfo(StringRef TT) const
createMCRegInfo - Create a MCRegisterInfo implementation.
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM=std::nullopt, CodeGenOptLevel OL=CodeGenOptLevel::Default, bool JIT=false) const
createTargetMachine - Create a target specific machine implementation for the specified Triple.
MCAsmInfo * createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple, const MCTargetOptions &Options) const
createMCAsmInfo - Create a MCAsmInfo implementation for the specified target triple.
MCInstPrinter * createMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) const
MCStreamer * createMCObjectStreamer(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, const MCSubtargetInfo &STI, bool RelaxAll, bool IncrementalLinkerCompatible, bool DWARFMustBeAtTheEnd) const
Create a target specific MCStreamer.
AsmPrinter * createAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) const
createAsmPrinter - Create a target specific assembly printer pass.
MCInstrInfo * createMCInstrInfo() const
createMCInstrInfo - Create a MCInstrInfo implementation.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
const std::string & getTriple() const
Definition: Triple.h:426
std::function< StringRef(StringRef)> TranslatorFuncTy
std::function< void(const Twine &Warning, StringRef Context, const DWARFDie *DIE)> MessageHandlerTy
Stores all information relating to a compile unit, be it in its original instance in the object file ...
void emitDwarfDebugAddrsFooter(const CompileUnit &Unit, MCSymbol *EndLabel) override
Emit .debug_addr footer.
void emitDwarfDebugArangesTable(const CompileUnit &Unit, const AddressRanges &LinkedRanges) override
Emit .debug_aranges entries for Unit.
void emitAppleTypes(AccelTable< AppleAccelTableStaticTypeData > &Table) override
Emit Apple type accelerator table.
void emitDIE(DIE &Die) override
Recursively emit the DIE tree rooted at Die.
void emitDwarfDebugLocListFragment(const CompileUnit &Unit, const DWARFLocationExpressionsVector &LinkedLocationExpression, PatchLocation Patch, DebugDieValuePool &AddrPool) override
Emit debug ranges(.debug_loc, .debug_loclists) fragment.
void emitStrings(const NonRelocatableStringpool &Pool) override
Emit the string table described by Pool into .debug_str table.
void emitDebugNames(DWARF5AccelTable &Table) override
Emit DWARF debug names.
void emitDwarfDebugLocListFooter(const CompileUnit &Unit, MCSymbol *EndLabel) override
Emit debug ranges(.debug_loc, .debug_loclists) footer.
MCSymbol * emitDwarfDebugAddrsHeader(const CompileUnit &Unit) override
Emit .debug_addr header.
void emitStringOffsets(const SmallVector< uint64_t > &StringOffset, uint16_t TargetDWARFVersion) override
Emit the debug string offset table described by StringOffsets into the .debug_str_offsets table.
void emitLineStrings(const NonRelocatableStringpool &Pool) override
Emit the string table described by Pool into .debug_line_str table.
static Expected< std::unique_ptr< DwarfStreamer > > createStreamer(const Triple &TheTriple, DWARFLinkerBase::OutputFileType FileType, raw_pwrite_stream &OutFile, DWARFLinkerBase::TranslatorFuncTy Translator, DWARFLinkerBase::MessageHandlerTy Warning)
Error init(Triple TheTriple, StringRef Swift5ReflectionSegmentName)
void emitSwiftReflectionSection(llvm::binaryformat::Swift5ReflectionSectionKind ReflSectionKind, StringRef Buffer, uint32_t Alignment, uint32_t Size)
Emit the swift reflection section stored in Buffer.
MCSymbol * emitDwarfDebugRangeListHeader(const CompileUnit &Unit) override
Emit debug ranges(.debug_ranges, .debug_rnglists) header.
void emitCIE(StringRef CIEBytes) override
Emit a CIE.
void emitSectionContents(StringRef SecData, DebugSectionKind SecKind) override
Emit contents of section SecName From Obj.
void emitAppleNames(AccelTable< AppleAccelTableStaticOffsetData > &Table) override
Emit Apple names accelerator table.
void finish() override
Dump the file to the disk.
void emitAbbrevs(const std::vector< std::unique_ptr< DIEAbbrev > > &Abbrevs, unsigned DwarfVersion) override
Emit the abbreviation table Abbrevs to the debug_abbrev section.
MCSymbol * emitDwarfDebugLocListHeader(const CompileUnit &Unit) override
Emit debug locations(.debug_loc, .debug_loclists) header.
void emitFDE(uint32_t CIEOffset, uint32_t AddreSize, uint64_t Address, StringRef Bytes) override
Emit an FDE with data Bytes.
void emitPubNamesForUnit(const CompileUnit &Unit) override
Emit the .debug_pubnames contribution for Unit.
void emitDwarfDebugRangeListFragment(const CompileUnit &Unit, const AddressRanges &LinkedRanges, PatchLocation Patch, DebugDieValuePool &AddrPool) override
Emit debug ranges(.debug_ranges, .debug_rnglists) fragment.
void emitPubTypesForUnit(const CompileUnit &Unit) override
Emit the .debug_pubtypes contribution for Unit.
void emitLineTableForUnit(const DWARFDebugLine::LineTable &LineTable, const CompileUnit &Unit, OffsetsStringPool &DebugStrPool, OffsetsStringPool &DebugLineStrPool) override
Emit .debug_line table entry for specified LineTable.
void emitDwarfDebugAddrs(const SmallVector< uint64_t > &Addrs, uint8_t AddrSize) override
Emit the addresses described by Addrs into .debug_addr table.
void emitAppleObjc(AccelTable< AppleAccelTableStaticOffsetData > &Table) override
Emit Apple Objective-C accelerator table.
void emitAppleNamespaces(AccelTable< AppleAccelTableStaticOffsetData > &Table) override
Emit Apple namespaces accelerator table.
void emitMacroTables(DWARFContext *Context, const Offset2UnitMap &UnitMacroMap, OffsetsStringPool &StringPool) override
Emit all available macro tables(DWARFv4 and DWARFv5).
void switchToDebugInfoSection(unsigned DwarfVersion)
Set the current output section to debug_info and change the MC Dwarf version to DwarfVersion.
void emitCompileUnitHeader(CompileUnit &Unit, unsigned DwarfVersion) override
Emit the compilation unit header for Unit in the debug_info section.
void emitSwiftAST(StringRef Buffer)
Emit the swift_ast section stored in Buffer.
void emitDwarfDebugRangeListFooter(const CompileUnit &Unit, MCSymbol *EndLabel) override
Emit debug ranges(.debug_ranges, .debug_rnglists) footer.
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:444
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ SectionSize
Definition: COFF.h:60
Swift5ReflectionSectionKind
Definition: Swift.h:14
DebugSectionKind
List of tracked debug tables.
@ DW_MACRO_lo_user
Definition: Dwarf.h:483
@ DW_MACRO_hi_user
Definition: Dwarf.h:484
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
DwarfFormat
Constants that define the DWARF format as 32 or 64 bit.
Definition: Dwarf.h:91
@ DWARF64
Definition: Dwarf.h:91
@ DW_MACINFO_vendor_ext
Definition: Dwarf.h:476
uint8_t getDwarfOffsetByteSize(DwarfFormat Format)
The size of a reference determined by the DWARF 32/64-bit format.
Definition: Dwarf.h:749
@ DW_ARANGES_VERSION
Section version number for .debug_aranges.
Definition: Dwarf.h:64
@ DW_PUBNAMES_VERSION
Section version number for .debug_pubnames.
Definition: Dwarf.h:63
@ DW_LENGTH_DWARF64
Indicator of 64-bit DWARF format.
Definition: Dwarf.h:55
MCTargetOptions InitMCTargetOptionsFromFlags()
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
@ Length
Definition: DWP.cpp:456
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1244
std::vector< DWARFLocationExpression > DWARFLocationExpressionsVector
Represents a set of absolute location expressions.
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition: Alignment.h:197
unsigned getULEB128Size(uint64_t Value)
Utility function to get the size of the ULEB128-encoded value.
Definition: LEB128.cpp:19
void emitAppleAccelTable(AsmPrinter *Asm, AccelTable< DataT > &Contents, StringRef Prefix, const MCSymbol *SecBegin)
Emit an Apple Accelerator Table consisting of entries in the specified AccelTable.
Definition: AccelTable.h:433
void emitDWARF5AccelTable(AsmPrinter *Asm, DWARF5AccelTable &Contents, const DwarfDebug &DD, ArrayRef< std::unique_ptr< DwarfCompileUnit > > CUs)
Definition: AccelTable.cpp:644
unsigned getSLEB128Size(int64_t Value)
Utility function to get the size of the SLEB128-encoded value.
Definition: LEB128.cpp:29
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
uint8_t MinInstLength
The size in bytes of the smallest target machine instruction.
int8_t LineBase
This parameter affects the meaning of the special opcodes. See below.
uint8_t LineRange
This parameter affects the meaning of the special opcodes. See below.
uint8_t OpcodeBase
The number assigned to the first special opcode.
dwarf::FormParams FormParams
Version, address size (starting in v5), and DWARF32/64 format; these parameters affect interpretation...
Standard .debug_line state machine structure.
Represents a single DWARF expression, whose value is location-dependent.
uint8_t DWARF2LineOpcodeBase
First special line opcode - leave room for the standard opcodes.
Definition: MCDwarf.h:253
uint8_t DWARF2LineRange
Range of line offsets in a special line info. opcode.
Definition: MCDwarf.h:258
int8_t DWARF2LineBase
Minimum line offset in a special line info.
Definition: MCDwarf.h:256
static const Target * lookupTarget(StringRef Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
DwarfFormat Format
Definition: Dwarf.h:765