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