xref: /netbsd-src/external/apache2/llvm/dist/llvm/lib/DWARFLinker/DWARFStreamer.cpp (revision 82d56013d7b633d116a93943de88e08335357a7c)
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 
9 #include "llvm/DWARFLinker/DWARFStreamer.h"
10 #include "llvm/ADT/Triple.h"
11 #include "llvm/CodeGen/NonRelocatableStringpool.h"
12 #include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
13 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
14 #include "llvm/MC/MCAsmBackend.h"
15 #include "llvm/MC/MCCodeEmitter.h"
16 #include "llvm/MC/MCDwarf.h"
17 #include "llvm/MC/MCObjectWriter.h"
18 #include "llvm/MC/MCSection.h"
19 #include "llvm/MC/MCStreamer.h"
20 #include "llvm/MC/MCSubtargetInfo.h"
21 #include "llvm/MC/MCSymbol.h"
22 #include "llvm/MC/MCTargetOptions.h"
23 #include "llvm/MC/MCTargetOptionsCommandFlags.h"
24 #include "llvm/Support/LEB128.h"
25 #include "llvm/Support/TargetRegistry.h"
26 #include "llvm/Target/TargetOptions.h"
27 
28 namespace llvm {
29 
init(Triple TheTriple)30 bool DwarfStreamer::init(Triple TheTriple) {
31   std::string ErrorStr;
32   std::string TripleName;
33   StringRef Context = "dwarf streamer init";
34 
35   // Get the target.
36   const Target *TheTarget =
37       TargetRegistry::lookupTarget(TripleName, TheTriple, ErrorStr);
38   if (!TheTarget)
39     return error(ErrorStr, Context), false;
40   TripleName = TheTriple.getTriple();
41 
42   // Create all the MC Objects.
43   MRI.reset(TheTarget->createMCRegInfo(TripleName));
44   if (!MRI)
45     return error(Twine("no register info for target ") + TripleName, Context),
46            false;
47 
48   MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
49   MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
50   if (!MAI)
51     return error("no asm info for target " + TripleName, Context), false;
52 
53   MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
54   if (!MSTI)
55     return error("no subtarget info for target " + TripleName, Context), false;
56 
57   MC.reset(new MCContext(TheTriple, MAI.get(), MRI.get(), MSTI.get()));
58   MOFI.reset(TheTarget->createMCObjectFileInfo(*MC, /*PIC=*/false));
59   MC->setObjectFileInfo(MOFI.get());
60 
61   MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, MCOptions);
62   if (!MAB)
63     return error("no asm backend for target " + TripleName, Context), false;
64 
65   MII.reset(TheTarget->createMCInstrInfo());
66   if (!MII)
67     return error("no instr info info for target " + TripleName, Context), false;
68 
69   MCE = TheTarget->createMCCodeEmitter(*MII, *MRI, *MC);
70   if (!MCE)
71     return error("no code emitter for target " + TripleName, Context), false;
72 
73   switch (OutFileType) {
74   case OutputFileType::Assembly: {
75     MIP = TheTarget->createMCInstPrinter(TheTriple, MAI->getAssemblerDialect(),
76                                          *MAI, *MII, *MRI);
77     MS = TheTarget->createAsmStreamer(
78         *MC, std::make_unique<formatted_raw_ostream>(OutFile), true, true, MIP,
79         std::unique_ptr<MCCodeEmitter>(MCE), std::unique_ptr<MCAsmBackend>(MAB),
80         true);
81     break;
82   }
83   case OutputFileType::Object: {
84     MS = TheTarget->createMCObjectStreamer(
85         TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB),
86         MAB->createObjectWriter(OutFile), std::unique_ptr<MCCodeEmitter>(MCE),
87         *MSTI, MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
88         /*DWARFMustBeAtTheEnd*/ false);
89     break;
90   }
91   }
92 
93   if (!MS)
94     return error("no object streamer for target " + TripleName, Context), false;
95 
96   // Finally create the AsmPrinter we'll use to emit the DIEs.
97   TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
98                                           None));
99   if (!TM)
100     return error("no target machine for target " + TripleName, Context), false;
101 
102   Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
103   if (!Asm)
104     return error("no asm printer for target " + TripleName, Context), false;
105 
106   RangesSectionSize = 0;
107   LocSectionSize = 0;
108   LineSectionSize = 0;
109   FrameSectionSize = 0;
110   DebugInfoSectionSize = 0;
111 
112   return true;
113 }
114 
finish()115 void DwarfStreamer::finish() { MS->Finish(); }
116 
switchToDebugInfoSection(unsigned DwarfVersion)117 void DwarfStreamer::switchToDebugInfoSection(unsigned DwarfVersion) {
118   MS->SwitchSection(MOFI->getDwarfInfoSection());
119   MC->setDwarfVersion(DwarfVersion);
120 }
121 
122 /// Emit the compilation unit header for \p Unit in the debug_info section.
123 ///
124 /// A Dwarf 4 section header is encoded as:
125 ///  uint32_t   Unit length (omitting this field)
126 ///  uint16_t   Version
127 ///  uint32_t   Abbreviation table offset
128 ///  uint8_t    Address size
129 /// Leading to a total of 11 bytes.
130 ///
131 /// A Dwarf 5 section header is encoded as:
132 ///  uint32_t   Unit length (omitting this field)
133 ///  uint16_t   Version
134 ///  uint8_t    Unit type
135 ///  uint8_t    Address size
136 ///  uint32_t   Abbreviation table offset
137 /// Leading to a total of 12 bytes.
emitCompileUnitHeader(CompileUnit & Unit,unsigned DwarfVersion)138 void DwarfStreamer::emitCompileUnitHeader(CompileUnit &Unit,
139                                           unsigned DwarfVersion) {
140   switchToDebugInfoSection(DwarfVersion);
141 
142   /// The start of the unit within its section.
143   Unit.setLabelBegin(Asm->createTempSymbol("cu_begin"));
144   Asm->OutStreamer->emitLabel(Unit.getLabelBegin());
145 
146   // Emit size of content not including length itself. The size has already
147   // been computed in CompileUnit::computeOffsets(). Subtract 4 to that size to
148   // account for the length field.
149   Asm->emitInt32(Unit.getNextUnitOffset() - Unit.getStartOffset() - 4);
150   Asm->emitInt16(DwarfVersion);
151 
152   if (DwarfVersion >= 5) {
153     Asm->emitInt8(dwarf::DW_UT_compile);
154     Asm->emitInt8(Unit.getOrigUnit().getAddressByteSize());
155     // We share one abbreviations table across all units so it's always at the
156     // start of the section.
157     Asm->emitInt32(0);
158     DebugInfoSectionSize += 12;
159   } else {
160     // We share one abbreviations table across all units so it's always at the
161     // start of the section.
162     Asm->emitInt32(0);
163     Asm->emitInt8(Unit.getOrigUnit().getAddressByteSize());
164     DebugInfoSectionSize += 11;
165   }
166 
167   // Remember this CU.
168   EmittedUnits.push_back({Unit.getUniqueID(), Unit.getLabelBegin()});
169 }
170 
171 /// Emit the \p Abbrevs array as the shared abbreviation table
172 /// for the linked Dwarf file.
emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> & Abbrevs,unsigned DwarfVersion)173 void DwarfStreamer::emitAbbrevs(
174     const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
175     unsigned DwarfVersion) {
176   MS->SwitchSection(MOFI->getDwarfAbbrevSection());
177   MC->setDwarfVersion(DwarfVersion);
178   Asm->emitDwarfAbbrevs(Abbrevs);
179 }
180 
181 /// Recursively emit the DIE tree rooted at \p Die.
emitDIE(DIE & Die)182 void DwarfStreamer::emitDIE(DIE &Die) {
183   MS->SwitchSection(MOFI->getDwarfInfoSection());
184   Asm->emitDwarfDIE(Die);
185   DebugInfoSectionSize += Die.getSize();
186 }
187 
188 /// Emit contents of section SecName From Obj.
emitSectionContents(StringRef SecData,StringRef SecName)189 void DwarfStreamer::emitSectionContents(StringRef SecData, StringRef SecName) {
190   MCSection *Section =
191       StringSwitch<MCSection *>(SecName)
192           .Case("debug_line", MC->getObjectFileInfo()->getDwarfLineSection())
193           .Case("debug_loc", MC->getObjectFileInfo()->getDwarfLocSection())
194           .Case("debug_ranges",
195                 MC->getObjectFileInfo()->getDwarfRangesSection())
196           .Case("debug_frame", MC->getObjectFileInfo()->getDwarfFrameSection())
197           .Case("debug_aranges",
198                 MC->getObjectFileInfo()->getDwarfARangesSection())
199           .Default(nullptr);
200 
201   if (Section) {
202     MS->SwitchSection(Section);
203 
204     MS->emitBytes(SecData);
205   }
206 }
207 
208 /// Emit DIE containing warnings.
emitPaperTrailWarningsDie(DIE & Die)209 void DwarfStreamer::emitPaperTrailWarningsDie(DIE &Die) {
210   switchToDebugInfoSection(/* Version */ 2);
211   auto &Asm = getAsmPrinter();
212   Asm.emitInt32(11 + Die.getSize() - 4);
213   Asm.emitInt16(2);
214   Asm.emitInt32(0);
215   Asm.emitInt8(MC->getTargetTriple().isArch64Bit() ? 8 : 4);
216   DebugInfoSectionSize += 11;
217   emitDIE(Die);
218 }
219 
220 /// Emit the debug_str section stored in \p Pool.
emitStrings(const NonRelocatableStringpool & Pool)221 void DwarfStreamer::emitStrings(const NonRelocatableStringpool &Pool) {
222   Asm->OutStreamer->SwitchSection(MOFI->getDwarfStrSection());
223   std::vector<DwarfStringPoolEntryRef> Entries = Pool.getEntriesForEmission();
224   for (auto Entry : Entries) {
225     // Emit the string itself.
226     Asm->OutStreamer->emitBytes(Entry.getString());
227     // Emit a null terminator.
228     Asm->emitInt8(0);
229   }
230 
231 #if 0
232   if (DwarfVersion >= 5) {
233     // Emit an empty string offset section.
234     Asm->OutStreamer->SwitchSection(MOFI->getDwarfStrOffSection());
235     Asm->emitDwarfUnitLength(4, "Length of String Offsets Set");
236     Asm->emitInt16(DwarfVersion);
237     Asm->emitInt16(0);
238   }
239 #endif
240 }
241 
emitDebugNames(AccelTable<DWARF5AccelTableStaticData> & Table)242 void DwarfStreamer::emitDebugNames(
243     AccelTable<DWARF5AccelTableStaticData> &Table) {
244   if (EmittedUnits.empty())
245     return;
246 
247   // Build up data structures needed to emit this section.
248   std::vector<MCSymbol *> CompUnits;
249   DenseMap<unsigned, size_t> UniqueIdToCuMap;
250   unsigned Id = 0;
251   for (auto &CU : EmittedUnits) {
252     CompUnits.push_back(CU.LabelBegin);
253     // We might be omitting CUs, so we need to remap them.
254     UniqueIdToCuMap[CU.ID] = Id++;
255   }
256 
257   Asm->OutStreamer->SwitchSection(MOFI->getDwarfDebugNamesSection());
258   emitDWARF5AccelTable(
259       Asm.get(), Table, CompUnits,
260       [&UniqueIdToCuMap](const DWARF5AccelTableStaticData &Entry) {
261         return UniqueIdToCuMap[Entry.getCUIndex()];
262       });
263 }
264 
emitAppleNamespaces(AccelTable<AppleAccelTableStaticOffsetData> & Table)265 void DwarfStreamer::emitAppleNamespaces(
266     AccelTable<AppleAccelTableStaticOffsetData> &Table) {
267   Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelNamespaceSection());
268   auto *SectionBegin = Asm->createTempSymbol("namespac_begin");
269   Asm->OutStreamer->emitLabel(SectionBegin);
270   emitAppleAccelTable(Asm.get(), Table, "namespac", SectionBegin);
271 }
272 
emitAppleNames(AccelTable<AppleAccelTableStaticOffsetData> & Table)273 void DwarfStreamer::emitAppleNames(
274     AccelTable<AppleAccelTableStaticOffsetData> &Table) {
275   Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelNamesSection());
276   auto *SectionBegin = Asm->createTempSymbol("names_begin");
277   Asm->OutStreamer->emitLabel(SectionBegin);
278   emitAppleAccelTable(Asm.get(), Table, "names", SectionBegin);
279 }
280 
emitAppleObjc(AccelTable<AppleAccelTableStaticOffsetData> & Table)281 void DwarfStreamer::emitAppleObjc(
282     AccelTable<AppleAccelTableStaticOffsetData> &Table) {
283   Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelObjCSection());
284   auto *SectionBegin = Asm->createTempSymbol("objc_begin");
285   Asm->OutStreamer->emitLabel(SectionBegin);
286   emitAppleAccelTable(Asm.get(), Table, "objc", SectionBegin);
287 }
288 
emitAppleTypes(AccelTable<AppleAccelTableStaticTypeData> & Table)289 void DwarfStreamer::emitAppleTypes(
290     AccelTable<AppleAccelTableStaticTypeData> &Table) {
291   Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelTypesSection());
292   auto *SectionBegin = Asm->createTempSymbol("types_begin");
293   Asm->OutStreamer->emitLabel(SectionBegin);
294   emitAppleAccelTable(Asm.get(), Table, "types", SectionBegin);
295 }
296 
297 /// Emit the swift_ast section stored in \p Buffers.
emitSwiftAST(StringRef Buffer)298 void DwarfStreamer::emitSwiftAST(StringRef Buffer) {
299   MCSection *SwiftASTSection = MOFI->getDwarfSwiftASTSection();
300   SwiftASTSection->setAlignment(Align(32));
301   MS->SwitchSection(SwiftASTSection);
302   MS->emitBytes(Buffer);
303 }
304 
305 /// Emit the debug_range section contents for \p FuncRange by
306 /// translating the original \p Entries. The debug_range section
307 /// format is totally trivial, consisting just of pairs of address
308 /// sized addresses describing the ranges.
emitRangesEntries(int64_t UnitPcOffset,uint64_t OrigLowPc,const FunctionIntervals::const_iterator & FuncRange,const std::vector<DWARFDebugRangeList::RangeListEntry> & Entries,unsigned AddressSize)309 void DwarfStreamer::emitRangesEntries(
310     int64_t UnitPcOffset, uint64_t OrigLowPc,
311     const FunctionIntervals::const_iterator &FuncRange,
312     const std::vector<DWARFDebugRangeList::RangeListEntry> &Entries,
313     unsigned AddressSize) {
314   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfRangesSection());
315 
316   // Offset each range by the right amount.
317   int64_t PcOffset = Entries.empty() ? 0 : FuncRange.value() + UnitPcOffset;
318   for (const auto &Range : Entries) {
319     if (Range.isBaseAddressSelectionEntry(AddressSize)) {
320       warn("unsupported base address selection operation",
321            "emitting debug_ranges");
322       break;
323     }
324     // Do not emit empty ranges.
325     if (Range.StartAddress == Range.EndAddress)
326       continue;
327 
328     // All range entries should lie in the function range.
329     if (!(Range.StartAddress + OrigLowPc >= FuncRange.start() &&
330           Range.EndAddress + OrigLowPc <= FuncRange.stop()))
331       warn("inconsistent range data.", "emitting debug_ranges");
332     MS->emitIntValue(Range.StartAddress + PcOffset, AddressSize);
333     MS->emitIntValue(Range.EndAddress + PcOffset, AddressSize);
334     RangesSectionSize += 2 * AddressSize;
335   }
336 
337   // Add the terminator entry.
338   MS->emitIntValue(0, AddressSize);
339   MS->emitIntValue(0, AddressSize);
340   RangesSectionSize += 2 * AddressSize;
341 }
342 
343 /// Emit the debug_aranges contribution of a unit and
344 /// if \p DoDebugRanges is true the debug_range contents for a
345 /// compile_unit level DW_AT_ranges attribute (Which are basically the
346 /// same thing with a different base address).
347 /// Just aggregate all the ranges gathered inside that unit.
emitUnitRangesEntries(CompileUnit & Unit,bool DoDebugRanges)348 void DwarfStreamer::emitUnitRangesEntries(CompileUnit &Unit,
349                                           bool DoDebugRanges) {
350   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
351   // Gather the ranges in a vector, so that we can simplify them. The
352   // IntervalMap will have coalesced the non-linked ranges, but here
353   // we want to coalesce the linked addresses.
354   std::vector<std::pair<uint64_t, uint64_t>> Ranges;
355   const auto &FunctionRanges = Unit.getFunctionRanges();
356   for (auto Range = FunctionRanges.begin(), End = FunctionRanges.end();
357        Range != End; ++Range)
358     Ranges.push_back(std::make_pair(Range.start() + Range.value(),
359                                     Range.stop() + Range.value()));
360 
361   // The object addresses where sorted, but again, the linked
362   // addresses might end up in a different order.
363   llvm::sort(Ranges);
364 
365   if (!Ranges.empty()) {
366     MS->SwitchSection(MC->getObjectFileInfo()->getDwarfARangesSection());
367 
368     MCSymbol *BeginLabel = Asm->createTempSymbol("Barange");
369     MCSymbol *EndLabel = Asm->createTempSymbol("Earange");
370 
371     unsigned HeaderSize =
372         sizeof(int32_t) + // Size of contents (w/o this field
373         sizeof(int16_t) + // DWARF ARange version number
374         sizeof(int32_t) + // Offset of CU in the .debug_info section
375         sizeof(int8_t) +  // Pointer Size (in bytes)
376         sizeof(int8_t);   // Segment Size (in bytes)
377 
378     unsigned TupleSize = AddressSize * 2;
379     unsigned Padding = offsetToAlignment(HeaderSize, Align(TupleSize));
380 
381     Asm->emitLabelDifference(EndLabel, BeginLabel, 4); // Arange length
382     Asm->OutStreamer->emitLabel(BeginLabel);
383     Asm->emitInt16(dwarf::DW_ARANGES_VERSION); // Version number
384     Asm->emitInt32(Unit.getStartOffset());     // Corresponding unit's offset
385     Asm->emitInt8(AddressSize);                // Address size
386     Asm->emitInt8(0);                          // Segment size
387 
388     Asm->OutStreamer->emitFill(Padding, 0x0);
389 
390     for (auto Range = Ranges.begin(), End = Ranges.end(); Range != End;
391          ++Range) {
392       uint64_t RangeStart = Range->first;
393       MS->emitIntValue(RangeStart, AddressSize);
394       while ((Range + 1) != End && Range->second == (Range + 1)->first)
395         ++Range;
396       MS->emitIntValue(Range->second - RangeStart, AddressSize);
397     }
398 
399     // Emit terminator
400     Asm->OutStreamer->emitIntValue(0, AddressSize);
401     Asm->OutStreamer->emitIntValue(0, AddressSize);
402     Asm->OutStreamer->emitLabel(EndLabel);
403   }
404 
405   if (!DoDebugRanges)
406     return;
407 
408   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfRangesSection());
409   // Offset each range by the right amount.
410   int64_t PcOffset = -Unit.getLowPc();
411   // Emit coalesced ranges.
412   for (auto Range = Ranges.begin(), End = Ranges.end(); Range != End; ++Range) {
413     MS->emitIntValue(Range->first + PcOffset, AddressSize);
414     while (Range + 1 != End && Range->second == (Range + 1)->first)
415       ++Range;
416     MS->emitIntValue(Range->second + PcOffset, AddressSize);
417     RangesSectionSize += 2 * AddressSize;
418   }
419 
420   // Add the terminator entry.
421   MS->emitIntValue(0, AddressSize);
422   MS->emitIntValue(0, AddressSize);
423   RangesSectionSize += 2 * AddressSize;
424 }
425 
426 /// Emit location lists for \p Unit and update attributes to point to the new
427 /// entries.
emitLocationsForUnit(const CompileUnit & Unit,DWARFContext & Dwarf,std::function<void (StringRef,SmallVectorImpl<uint8_t> &)> ProcessExpr)428 void DwarfStreamer::emitLocationsForUnit(
429     const CompileUnit &Unit, DWARFContext &Dwarf,
430     std::function<void(StringRef, SmallVectorImpl<uint8_t> &)> ProcessExpr) {
431   const auto &Attributes = Unit.getLocationAttributes();
432 
433   if (Attributes.empty())
434     return;
435 
436   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfLocSection());
437 
438   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
439   uint64_t BaseAddressMarker = (AddressSize == 8)
440                                    ? std::numeric_limits<uint64_t>::max()
441                                    : std::numeric_limits<uint32_t>::max();
442   const DWARFSection &InputSec = Dwarf.getDWARFObj().getLocSection();
443   DataExtractor Data(InputSec.Data, Dwarf.isLittleEndian(), AddressSize);
444   DWARFUnit &OrigUnit = Unit.getOrigUnit();
445   auto OrigUnitDie = OrigUnit.getUnitDIE(false);
446   int64_t UnitPcOffset = 0;
447   if (auto OrigLowPc = dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc)))
448     UnitPcOffset = int64_t(*OrigLowPc) - Unit.getLowPc();
449 
450   SmallVector<uint8_t, 32> Buffer;
451   for (const auto &Attr : Attributes) {
452     uint64_t Offset = Attr.first.get();
453     Attr.first.set(LocSectionSize);
454     // This is the quantity to add to the old location address to get
455     // the correct address for the new one.
456     int64_t LocPcOffset = Attr.second + UnitPcOffset;
457     while (Data.isValidOffset(Offset)) {
458       uint64_t Low = Data.getUnsigned(&Offset, AddressSize);
459       uint64_t High = Data.getUnsigned(&Offset, AddressSize);
460       LocSectionSize += 2 * AddressSize;
461       // End of list entry.
462       if (Low == 0 && High == 0) {
463         Asm->OutStreamer->emitIntValue(0, AddressSize);
464         Asm->OutStreamer->emitIntValue(0, AddressSize);
465         break;
466       }
467       // Base address selection entry.
468       if (Low == BaseAddressMarker) {
469         Asm->OutStreamer->emitIntValue(BaseAddressMarker, AddressSize);
470         Asm->OutStreamer->emitIntValue(High + Attr.second, AddressSize);
471         LocPcOffset = 0;
472         continue;
473       }
474       // Location list entry.
475       Asm->OutStreamer->emitIntValue(Low + LocPcOffset, AddressSize);
476       Asm->OutStreamer->emitIntValue(High + LocPcOffset, AddressSize);
477       uint64_t Length = Data.getU16(&Offset);
478       Asm->OutStreamer->emitIntValue(Length, 2);
479       // Copy the bytes into to the buffer, process them, emit them.
480       Buffer.reserve(Length);
481       Buffer.resize(0);
482       StringRef Input = InputSec.Data.substr(Offset, Length);
483       ProcessExpr(Input, Buffer);
484       Asm->OutStreamer->emitBytes(
485           StringRef((const char *)Buffer.data(), Length));
486       Offset += Length;
487       LocSectionSize += Length + 2;
488     }
489   }
490 }
491 
emitLineTableForUnit(MCDwarfLineTableParams Params,StringRef PrologueBytes,unsigned MinInstLength,std::vector<DWARFDebugLine::Row> & Rows,unsigned PointerSize)492 void DwarfStreamer::emitLineTableForUnit(MCDwarfLineTableParams Params,
493                                          StringRef PrologueBytes,
494                                          unsigned MinInstLength,
495                                          std::vector<DWARFDebugLine::Row> &Rows,
496                                          unsigned PointerSize) {
497   // Switch to the section where the table will be emitted into.
498   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfLineSection());
499   MCSymbol *LineStartSym = MC->createTempSymbol();
500   MCSymbol *LineEndSym = MC->createTempSymbol();
501 
502   // The first 4 bytes is the total length of the information for this
503   // compilation unit (not including these 4 bytes for the length).
504   Asm->emitLabelDifference(LineEndSym, LineStartSym, 4);
505   Asm->OutStreamer->emitLabel(LineStartSym);
506   // Copy Prologue.
507   MS->emitBytes(PrologueBytes);
508   LineSectionSize += PrologueBytes.size() + 4;
509 
510   SmallString<128> EncodingBuffer;
511   raw_svector_ostream EncodingOS(EncodingBuffer);
512 
513   if (Rows.empty()) {
514     // We only have the dummy entry, dsymutil emits an entry with a 0
515     // address in that case.
516     MCDwarfLineAddr::Encode(*MC, Params, std::numeric_limits<int64_t>::max(), 0,
517                             EncodingOS);
518     MS->emitBytes(EncodingOS.str());
519     LineSectionSize += EncodingBuffer.size();
520     MS->emitLabel(LineEndSym);
521     return;
522   }
523 
524   // Line table state machine fields
525   unsigned FileNum = 1;
526   unsigned LastLine = 1;
527   unsigned Column = 0;
528   unsigned IsStatement = 1;
529   unsigned Isa = 0;
530   uint64_t Address = -1ULL;
531 
532   unsigned RowsSinceLastSequence = 0;
533 
534   for (unsigned Idx = 0; Idx < Rows.size(); ++Idx) {
535     auto &Row = Rows[Idx];
536 
537     int64_t AddressDelta;
538     if (Address == -1ULL) {
539       MS->emitIntValue(dwarf::DW_LNS_extended_op, 1);
540       MS->emitULEB128IntValue(PointerSize + 1);
541       MS->emitIntValue(dwarf::DW_LNE_set_address, 1);
542       MS->emitIntValue(Row.Address.Address, PointerSize);
543       LineSectionSize += 2 + PointerSize + getULEB128Size(PointerSize + 1);
544       AddressDelta = 0;
545     } else {
546       AddressDelta = (Row.Address.Address - Address) / MinInstLength;
547     }
548 
549     // FIXME: code copied and transformed from MCDwarf.cpp::EmitDwarfLineTable.
550     // We should find a way to share this code, but the current compatibility
551     // requirement with classic dsymutil makes it hard. Revisit that once this
552     // requirement is dropped.
553 
554     if (FileNum != Row.File) {
555       FileNum = Row.File;
556       MS->emitIntValue(dwarf::DW_LNS_set_file, 1);
557       MS->emitULEB128IntValue(FileNum);
558       LineSectionSize += 1 + getULEB128Size(FileNum);
559     }
560     if (Column != Row.Column) {
561       Column = Row.Column;
562       MS->emitIntValue(dwarf::DW_LNS_set_column, 1);
563       MS->emitULEB128IntValue(Column);
564       LineSectionSize += 1 + getULEB128Size(Column);
565     }
566 
567     // FIXME: We should handle the discriminator here, but dsymutil doesn't
568     // consider it, thus ignore it for now.
569 
570     if (Isa != Row.Isa) {
571       Isa = Row.Isa;
572       MS->emitIntValue(dwarf::DW_LNS_set_isa, 1);
573       MS->emitULEB128IntValue(Isa);
574       LineSectionSize += 1 + getULEB128Size(Isa);
575     }
576     if (IsStatement != Row.IsStmt) {
577       IsStatement = Row.IsStmt;
578       MS->emitIntValue(dwarf::DW_LNS_negate_stmt, 1);
579       LineSectionSize += 1;
580     }
581     if (Row.BasicBlock) {
582       MS->emitIntValue(dwarf::DW_LNS_set_basic_block, 1);
583       LineSectionSize += 1;
584     }
585 
586     if (Row.PrologueEnd) {
587       MS->emitIntValue(dwarf::DW_LNS_set_prologue_end, 1);
588       LineSectionSize += 1;
589     }
590 
591     if (Row.EpilogueBegin) {
592       MS->emitIntValue(dwarf::DW_LNS_set_epilogue_begin, 1);
593       LineSectionSize += 1;
594     }
595 
596     int64_t LineDelta = int64_t(Row.Line) - LastLine;
597     if (!Row.EndSequence) {
598       MCDwarfLineAddr::Encode(*MC, Params, LineDelta, AddressDelta, EncodingOS);
599       MS->emitBytes(EncodingOS.str());
600       LineSectionSize += EncodingBuffer.size();
601       EncodingBuffer.resize(0);
602       Address = Row.Address.Address;
603       LastLine = Row.Line;
604       RowsSinceLastSequence++;
605     } else {
606       if (LineDelta) {
607         MS->emitIntValue(dwarf::DW_LNS_advance_line, 1);
608         MS->emitSLEB128IntValue(LineDelta);
609         LineSectionSize += 1 + getSLEB128Size(LineDelta);
610       }
611       if (AddressDelta) {
612         MS->emitIntValue(dwarf::DW_LNS_advance_pc, 1);
613         MS->emitULEB128IntValue(AddressDelta);
614         LineSectionSize += 1 + getULEB128Size(AddressDelta);
615       }
616       MCDwarfLineAddr::Encode(*MC, Params, std::numeric_limits<int64_t>::max(),
617                               0, EncodingOS);
618       MS->emitBytes(EncodingOS.str());
619       LineSectionSize += EncodingBuffer.size();
620       EncodingBuffer.resize(0);
621       Address = -1ULL;
622       LastLine = FileNum = IsStatement = 1;
623       RowsSinceLastSequence = Column = Isa = 0;
624     }
625   }
626 
627   if (RowsSinceLastSequence) {
628     MCDwarfLineAddr::Encode(*MC, Params, std::numeric_limits<int64_t>::max(), 0,
629                             EncodingOS);
630     MS->emitBytes(EncodingOS.str());
631     LineSectionSize += EncodingBuffer.size();
632     EncodingBuffer.resize(0);
633   }
634 
635   MS->emitLabel(LineEndSym);
636 }
637 
638 /// Copy the debug_line over to the updated binary while unobfuscating the file
639 /// names and directories.
translateLineTable(DataExtractor Data,uint64_t Offset)640 void DwarfStreamer::translateLineTable(DataExtractor Data, uint64_t Offset) {
641   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfLineSection());
642   StringRef Contents = Data.getData();
643 
644   // We have to deconstruct the line table header, because it contains to
645   // length fields that will need to be updated when we change the length of
646   // the files and directories in there.
647   unsigned UnitLength = Data.getU32(&Offset);
648   uint64_t UnitEnd = Offset + UnitLength;
649   MCSymbol *BeginLabel = MC->createTempSymbol();
650   MCSymbol *EndLabel = MC->createTempSymbol();
651   unsigned Version = Data.getU16(&Offset);
652 
653   if (Version > 5) {
654     warn("Unsupported line table version: dropping contents and not "
655          "unobfsucating line table.");
656     return;
657   }
658 
659   Asm->emitLabelDifference(EndLabel, BeginLabel, 4);
660   Asm->OutStreamer->emitLabel(BeginLabel);
661   Asm->emitInt16(Version);
662   LineSectionSize += 6;
663 
664   MCSymbol *HeaderBeginLabel = MC->createTempSymbol();
665   MCSymbol *HeaderEndLabel = MC->createTempSymbol();
666   Asm->emitLabelDifference(HeaderEndLabel, HeaderBeginLabel, 4);
667   Asm->OutStreamer->emitLabel(HeaderBeginLabel);
668   Offset += 4;
669   LineSectionSize += 4;
670 
671   uint64_t AfterHeaderLengthOffset = Offset;
672   // Skip to the directories.
673   Offset += (Version >= 4) ? 5 : 4;
674   unsigned OpcodeBase = Data.getU8(&Offset);
675   Offset += OpcodeBase - 1;
676   Asm->OutStreamer->emitBytes(Contents.slice(AfterHeaderLengthOffset, Offset));
677   LineSectionSize += Offset - AfterHeaderLengthOffset;
678 
679   // Offset points to the first directory.
680   while (const char *Dir = Data.getCStr(&Offset)) {
681     if (Dir[0] == 0)
682       break;
683 
684     StringRef Translated = Translator(Dir);
685     Asm->OutStreamer->emitBytes(Translated);
686     Asm->emitInt8(0);
687     LineSectionSize += Translated.size() + 1;
688   }
689   Asm->emitInt8(0);
690   LineSectionSize += 1;
691 
692   while (const char *File = Data.getCStr(&Offset)) {
693     if (File[0] == 0)
694       break;
695 
696     StringRef Translated = Translator(File);
697     Asm->OutStreamer->emitBytes(Translated);
698     Asm->emitInt8(0);
699     LineSectionSize += Translated.size() + 1;
700 
701     uint64_t OffsetBeforeLEBs = Offset;
702     Asm->emitULEB128(Data.getULEB128(&Offset));
703     Asm->emitULEB128(Data.getULEB128(&Offset));
704     Asm->emitULEB128(Data.getULEB128(&Offset));
705     LineSectionSize += Offset - OffsetBeforeLEBs;
706   }
707   Asm->emitInt8(0);
708   LineSectionSize += 1;
709 
710   Asm->OutStreamer->emitLabel(HeaderEndLabel);
711 
712   // Copy the actual line table program over.
713   Asm->OutStreamer->emitBytes(Contents.slice(Offset, UnitEnd));
714   LineSectionSize += UnitEnd - Offset;
715 
716   Asm->OutStreamer->emitLabel(EndLabel);
717   Offset = UnitEnd;
718 }
719 
720 /// Emit the pubnames or pubtypes section contribution for \p
721 /// Unit into \p Sec. The data is provided in \p Names.
emitPubSectionForUnit(MCSection * Sec,StringRef SecName,const CompileUnit & Unit,const std::vector<CompileUnit::AccelInfo> & Names)722 void DwarfStreamer::emitPubSectionForUnit(
723     MCSection *Sec, StringRef SecName, const CompileUnit &Unit,
724     const std::vector<CompileUnit::AccelInfo> &Names) {
725   if (Names.empty())
726     return;
727 
728   // Start the dwarf pubnames section.
729   Asm->OutStreamer->SwitchSection(Sec);
730   MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + SecName + "_begin");
731   MCSymbol *EndLabel = Asm->createTempSymbol("pub" + SecName + "_end");
732 
733   bool HeaderEmitted = false;
734   // Emit the pubnames for this compilation unit.
735   for (const auto &Name : Names) {
736     if (Name.SkipPubSection)
737       continue;
738 
739     if (!HeaderEmitted) {
740       // Emit the header.
741       Asm->emitLabelDifference(EndLabel, BeginLabel, 4); // Length
742       Asm->OutStreamer->emitLabel(BeginLabel);
743       Asm->emitInt16(dwarf::DW_PUBNAMES_VERSION); // Version
744       Asm->emitInt32(Unit.getStartOffset());      // Unit offset
745       Asm->emitInt32(Unit.getNextUnitOffset() - Unit.getStartOffset()); // Size
746       HeaderEmitted = true;
747     }
748     Asm->emitInt32(Name.Die->getOffset());
749 
750     // Emit the string itself.
751     Asm->OutStreamer->emitBytes(Name.Name.getString());
752     // Emit a null terminator.
753     Asm->emitInt8(0);
754   }
755 
756   if (!HeaderEmitted)
757     return;
758   Asm->emitInt32(0); // End marker.
759   Asm->OutStreamer->emitLabel(EndLabel);
760 }
761 
762 /// Emit .debug_pubnames for \p Unit.
emitPubNamesForUnit(const CompileUnit & Unit)763 void DwarfStreamer::emitPubNamesForUnit(const CompileUnit &Unit) {
764   emitPubSectionForUnit(MC->getObjectFileInfo()->getDwarfPubNamesSection(),
765                         "names", Unit, Unit.getPubnames());
766 }
767 
768 /// Emit .debug_pubtypes for \p Unit.
emitPubTypesForUnit(const CompileUnit & Unit)769 void DwarfStreamer::emitPubTypesForUnit(const CompileUnit &Unit) {
770   emitPubSectionForUnit(MC->getObjectFileInfo()->getDwarfPubTypesSection(),
771                         "types", Unit, Unit.getPubtypes());
772 }
773 
774 /// Emit a CIE into the debug_frame section.
emitCIE(StringRef CIEBytes)775 void DwarfStreamer::emitCIE(StringRef CIEBytes) {
776   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfFrameSection());
777 
778   MS->emitBytes(CIEBytes);
779   FrameSectionSize += CIEBytes.size();
780 }
781 
782 /// Emit a FDE into the debug_frame section. \p FDEBytes
783 /// contains the FDE data without the length, CIE offset and address
784 /// which will be replaced with the parameter values.
emitFDE(uint32_t CIEOffset,uint32_t AddrSize,uint32_t Address,StringRef FDEBytes)785 void DwarfStreamer::emitFDE(uint32_t CIEOffset, uint32_t AddrSize,
786                             uint32_t Address, StringRef FDEBytes) {
787   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfFrameSection());
788 
789   MS->emitIntValue(FDEBytes.size() + 4 + AddrSize, 4);
790   MS->emitIntValue(CIEOffset, 4);
791   MS->emitIntValue(Address, AddrSize);
792   MS->emitBytes(FDEBytes);
793   FrameSectionSize += FDEBytes.size() + 8 + AddrSize;
794 }
795 
796 } // namespace llvm
797