tools/dsymutil/DwarfStreamer.cpp

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