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