[MC] Implement generating 64-bit debug info.

[ikudrin]

Summary

The patch adds a new command-line switch --dwarf64 to llvm-mc, which selects the format of debug info generated by the tool. The support is limited to 64-bit targets because the format requires using 64-bit relocations. COFF targets are not supported for the same reason.

[aprantl]

Nice! This looks reasonable to me.

[dblaikie]

So this is DWARF64 support for debug_line in LLVM? And the first support for DWARF64 emission in LLVM in general?

Probably good to include that in the title - something like "Add initial (debug_line only) support for DWARF64" perhaps.

[dblaikie]

llvm/test/MC/ELF/gen-dwarf64.s

81–83

This concerns me slightly - looks like there was some latent/hidden/untested DWARF64 support in the rnglists that's just now become testable? So it might need some more testing if it's been so far untested? (similarly with any other sections with latent support - debug_info, debug_aranges, abbrev(? not sure if abbrev is different in 32/64))

llvm/tools/llvm-mc/llvm-mc.cpp

405–414

Perhaps this should have a FIXME? and/or the code where the 4-byte only support is should have a FIXME? Are you planning to do that in a follow-up patch?

And is this error-path tested?

[MaskRay]

llvm/test/MC/ELF/gen-dwarf64.s

1

ELF can use # as well. If you want to add comments, you may use ##

llvm/tools/llvm-mc/llvm-mc.cpp

400

cc/ld/binutils usually don't append a dot in a diagnostic.

They do not exist -> 32-bit targets don't support DWARF64, which requires 64-bit relocations.

405

Does it make sense to explicitly check for COFF?

[echristo]

llvm/test/MC/ELF/gen-dwarf64.s

2

I'd probably prefer the error cases to be in a separate test.

[ikudrin]

In D80382#2050252, @dblaikie wrote:

So this is DWARF64 support for debug_line in LLVM?

Not exactly. The patch supports all tables that llvm-mc can generate if I have not missed anything. And the support, for now, is enabled only in the tool itself.

And the first support for DWARF64 emission in LLVM in general?

That is probably true, though I do not have deep knowledge of all LLVM tree to say for sure.

Probably good to include that in the title - something like "Add initial (debug_line only) support for DWARF64" perhaps.

The patch aims to support all tables llvm-mc can generate in one shot, so that comment would not be exactly correct. Or maybe I am not following you.

llvm/test/MC/ELF/gen-dwarf64.s

81–83

There was no support for DWARF64 before this patch. As for .debug_rnglists, there are not many changes concerning this format, because we do not emit offsets for range lists, see emitGenDwarfRanges().

I've extended the test adding some additional fields, but in general, I suppose that the produced tables are correct as long as llvm-dwarfdump can successfully parse them and report the format.

llvm/tools/llvm-mc/llvm-mc.cpp

405

This setting affects the emitting of 64-bit info directly, as it is directly passed to MCStreamer::emitSymbolValue(). Checking for targeting COFF would be an indirect condition, which potentially might become incorrect without noticing. I prefer a more robust condition.

405–414

Not sure if anyone would struggle to support DWARF64 on 32-bit targets. That would be tricky without 64-bit relocations. Personally, I do not have such plans.

All three cases have tests, see COFF/dwarf64-err.s and ELF/dwarf64-err.s.

[ikudrin]

• Extended checks in the main test.
• Moved checks for error cases into a separate test.
• Addressed other comments.

[ikudrin]

Ping.

[dblaikie]

I know this wouldn't be DWARF compliant - but could you separate this into one patch per section. (the first patch could add a test case & just check the debug_abbrev section has correct DWARF64, the next one testing the debug_info, etc. (that is assuming llvm-dwarfdump can handle mixid DWARF32/DWARF64 sections) - it'd be easier to validate all the changes to each sections emission are being tested appropriately that way

[jhenderson]

Thanks for this. Looks pretty good, but I haven't given it enough of an in-depth read, nor is my MC knowledge in this area up-to-date enough to be confident enough to approve.

llvm/tools/llvm-mc/llvm-mc.cpp

391

Nit: either "the 64-bit DWARF format" or simply "64-bit DWARF".

400

cc/ld/binutils usually don't append a dot in a diagnostic.

For reference, this is now in the LLVM style guide too (along with no upper-case letter for the start of diagnostics).

[ikudrin]

In D80382#2069346, @dblaikie wrote:

I know this wouldn't be DWARF compliant - but could you separate this into one patch per section. (the first patch could add a test case & just check the debug_abbrev section has correct DWARF64, the next one testing the debug_info, etc. (that is assuming llvm-dwarfdump can handle mixid DWARF32/DWARF64 sections) - it'd be easier to validate all the changes to each sections emission are being tested appropriately that way

I've prepared a series of patches starting with D81143. Please, take a look. So, I am abandoning this revision in favor of the new set.

llvm/tools/llvm-mc/llvm-mc.cpp

391

Thanks! Fixed in D81143.

[probinson]

Some of these changes are specific to cases where we are emitting DWARF describing assembler source; I don't see any reason to support DWARF-64 for those cases. (In general, any functions with GenDwarf in the name are for this case.) Also in most cases the DWARF version for sections describing assembler source are hard-coded to DWARF version 2, which did not define the DWARF-64 format.

[probinson]

Ah sorry hadn't noticed this one was abandoned. Never mind.

llvm/include/llvm/MC/MCContext.h

private:
 
     /// The string to embed in as the dwarf AT_producer for the compile unit, if
     /// non-empty.
     StringRef DwarfDebugProducer;
 
     /// The maximum version of dwarf that we should emit.
     uint16_t DwarfVersion = 4;
 
+    /// The format of dwarf that we emit.
+    dwarf::DwarfFormat DwarfFormat = dwarf::DWARF32;
+
     /// Honor temporary labels, this is useful for debugging semantic
     /// differences between temporary and non-temporary labels (primarily on
     /// Darwin).
     bool AllowTemporaryLabels = true;
     bool UseNamesOnTempLabels = false;
 
     /// The Compile Unit ID that we are currently processing.
     unsigned DwarfCompileUnitID = 0;
public:
     }
 
     void setDwarfDebugFlags(StringRef S) { DwarfDebugFlags = S; }
     StringRef getDwarfDebugFlags() { return DwarfDebugFlags; }
 
     void setDwarfDebugProducer(StringRef S) { DwarfDebugProducer = S; }
     StringRef getDwarfDebugProducer() { return DwarfDebugProducer; }
 
-    dwarf::DwarfFormat getDwarfFormat() const {
-      // TODO: Support DWARF64
-      return dwarf::DWARF32;
-    }
+    void setDwarfFormat(dwarf::DwarfFormat f) { DwarfFormat = f; }
+    dwarf::DwarfFormat getDwarfFormat() const { return DwarfFormat; }
 
     void setDwarfVersion(uint16_t v) { DwarfVersion = v; }
     uint16_t getDwarfVersion() const { return DwarfVersion; }
 
     /// @}
 
     char *getSecureLogFile() { return SecureLogFile; }
     raw_fd_ostream *getSecureLog() { return SecureLog.get(); }

llvm/include/llvm/MC/MCTargetOptions.h

public:
   bool MCIncrementalLinkerCompatible : 1;
   bool ShowMCEncoding : 1;
   bool ShowMCInst : 1;
   bool AsmVerbose : 1;
 
   /// Preserve Comments in Assembly.
   bool PreserveAsmComments : 1;
 
+  bool Dwarf64 : 1;
   int DwarfVersion = 0;
 
   std::string ABIName;
   std::string AssemblyLanguage;
   std::string SplitDwarfFile;
 
   /// Additional paths to search for `.include` directives when using the
   /// integrated assembler.

llvm/include/llvm/MC/MCTargetOptionsCommandFlags.h

 
 bool getRelaxAll();
 Optional<bool> getExplicitRelaxAll();
 
 bool getIncrementalLinkerCompatible();
 
 int getDwarfVersion();
 
+bool getDwarf64();
+
 bool getShowMCInst();
 
 bool getFatalWarnings();
 
 bool getNoWarn();
 
 bool getNoDeprecatedWarn();
 

llvm/lib/MC/MCDwarf.cpp

 
 using namespace llvm;
 
 MCSymbol *mcdwarf::emitListsTableHeaderStart(MCStreamer &S) {
   MCSymbol *Start =
       S.getContext().createTempSymbol("debug_list_header_start", true, true);
   MCSymbol *End =
       S.getContext().createTempSymbol("debug_list_header_end", true, true);
+  auto DwarfFormat = S.getContext().getDwarfFormat();
+  if (DwarfFormat == dwarf::DWARF64) {
+    S.AddComment("DWARF64 mark");
+    S.emitInt32(dwarf::DW_LENGTH_DWARF64);
+  }
   S.AddComment("Length");
-  S.emitAbsoluteSymbolDiff(End, Start, 4);
+  S.emitAbsoluteSymbolDiff(End, Start,
+                           dwarf::getDwarfOffsetByteSize(DwarfFormat));
   S.emitLabel(Start);
   S.AddComment("Version");
   S.emitInt16(S.getContext().getDwarfVersion());
   S.AddComment("Address size");
   S.emitInt8(S.getContext().getAsmInfo()->getCodePointerSize());
   S.AddComment("Segment selector size");
   S.emitInt8(0);
   return End;
void MCDwarfLineStr::emitSection(MCStreamer *MCOS) {
   LineStrings.finalizeInOrder();
   SmallString<0> Data;
   Data.resize(LineStrings.getSize());
   LineStrings.write((uint8_t *)Data.data());
   MCOS->emitBinaryData(Data.str());
 }
 
 void MCDwarfLineStr::emitRef(MCStreamer *MCOS, StringRef Path) {
-  int RefSize = 4; // FIXME: Support DWARF-64
+  int RefSize =
+      dwarf::getDwarfOffsetByteSize(MCOS->getContext().getDwarfFormat());
   size_t Offset = LineStrings.add(Path);
   if (UseRelocs) {
     MCContext &Ctx = MCOS->getContext();
     MCOS->emitValue(makeStartPlusIntExpr(Ctx, *LineStrLabel, Offset), RefSize);
   } else
     MCOS->emitIntValue(Offset, RefSize);
 }
 
MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
   if (!LineStartSym)
     LineStartSym = context.createTempSymbol();
   // Set the value of the symbol, as we are at the start of the line table.
   MCOS->emitLabel(LineStartSym);
 
   // Create a symbol for the end of the section (to be set when we get there).
   MCSymbol *LineEndSym = context.createTempSymbol();
 
-  // The first 4 bytes is the total length of the information for this
-  // compilation unit (not including these 4 bytes for the length).
-  emitAbsValue(
-      *MCOS, MakeStartMinusEndExpr(context, *LineStartSym, *LineEndSym, 4), 4);
+  unsigned UnitLengthBytes =
+      dwarf::getUnitLengthFieldByteSize(context.getDwarfFormat());
+  unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(context.getDwarfFormat());
+
+  if (context.getDwarfFormat() == dwarf::DWARF64)
+    // Emit DWARF64 mark.
+    MCOS->emitInt32(dwarf::DW_LENGTH_DWARF64);
+
+  // The length field does not include itself and, in case of the 64-bit DWARF
+  // format, the DWARF64 mark.
+  emitAbsValue(*MCOS,
+               MakeStartMinusEndExpr(context, *LineStartSym, *LineEndSym,
+                                     UnitLengthBytes),
+               OffsetSize);
 
   // Next 2 bytes is the Version.
   unsigned LineTableVersion = context.getDwarfVersion();
   MCOS->emitInt16(LineTableVersion);
 
   // Keep track of the bytes between the very start and where the header length
   // comes out.
-  unsigned PreHeaderLengthBytes = 4 + 2;
+  unsigned PreHeaderLengthBytes = UnitLengthBytes + 2;
 
   // In v5, we get address info next.
   if (LineTableVersion >= 5) {
     MCOS->emitInt8(context.getAsmInfo()->getCodePointerSize());
     MCOS->emitInt8(0); // Segment selector; same as EmitGenDwarfAranges.
     PreHeaderLengthBytes += 2;
   }
 
   // Create a symbol for the end of the prologue (to be set when we get there).
   MCSymbol *ProEndSym = context.createTempSymbol(); // Lprologue_end
 
-  // Length of the prologue, is the next 4 bytes.  This is actually the length
-  // from after the length word, to the end of the prologue.
+  // Length of the prologue, is the next 4 bytes (8 bytes for DWARF64). This is
+  // actually the length from after the length word, to the end of the prologue.
   emitAbsValue(*MCOS,
                MakeStartMinusEndExpr(context, *LineStartSym, *ProEndSym,
-                                     (PreHeaderLengthBytes + 4)),
-               4);
+                                     (PreHeaderLengthBytes + OffsetSize)),
+               OffsetSize);
 
   // Parameters of the state machine, are next.
   MCOS->emitInt8(context.getAsmInfo()->getMinInstAlignment());
   // maximum_operations_per_instruction
   // For non-VLIW architectures this field is always 1.
   // FIXME: VLIW architectures need to update this field accordingly.
   if (LineTableVersion >= 4)
     MCOS->emitInt8(1);

 static void EmitGenDwarfAbbrev(MCStreamer *MCOS) {
   MCContext &context = MCOS->getContext();
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection());
 
   // DW_TAG_compile_unit DIE abbrev (1).
   MCOS->emitULEB128IntValue(1);
   MCOS->emitULEB128IntValue(dwarf::DW_TAG_compile_unit);
   MCOS->emitInt8(dwarf::DW_CHILDREN_yes);
-  EmitAbbrev(MCOS, dwarf::DW_AT_stmt_list, context.getDwarfVersion() >= 4
-                                               ? dwarf::DW_FORM_sec_offset
+  dwarf::Form SecOffsetForm =
+      context.getDwarfVersion() >= 4
+          : (context.getDwarfFormat() == dwarf::DWARF64 ? dwarf::DW_FORM_data8
                                                         : dwarf::DW_FORM_data4);
+  EmitAbbrev(MCOS, dwarf::DW_AT_stmt_list, SecOffsetForm);
   if (context.getGenDwarfSectionSyms().size() > 1 &&
       context.getDwarfVersion() >= 3) {
-    EmitAbbrev(MCOS, dwarf::DW_AT_ranges, context.getDwarfVersion() >= 4
-                                              ? dwarf::DW_FORM_sec_offset
-                                              : dwarf::DW_FORM_data4);
+    EmitAbbrev(MCOS, dwarf::DW_AT_ranges, SecOffsetForm);
   } else {
     EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr);
     EmitAbbrev(MCOS, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr);
   }
   EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string);
   if (!context.getCompilationDir().empty())
     EmitAbbrev(MCOS, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string);
   StringRef DwarfDebugFlags = context.getDwarfDebugFlags();

 static void EmitGenDwarfAranges(MCStreamer *MCOS,
                                 const MCSymbol *InfoSectionSymbol) {
   MCContext &context = MCOS->getContext();
 
   auto &Sections = context.getGenDwarfSectionSyms();
 
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
 
+  unsigned UnitLengthBytes =
+      dwarf::getUnitLengthFieldByteSize(context.getDwarfFormat());
+  unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(context.getDwarfFormat());
+
   // This will be the length of the .debug_aranges section, first account for
   // the size of each item in the header (see below where we emit these items).
-  int Length = 4 + 2 + 4 + 1 + 1;
+  int Length = UnitLengthBytes + 2 + OffsetSize + 1 + 1;
 
   // Figure the padding after the header before the table of address and size
   // pairs who's values are PointerSize'ed.
   const MCAsmInfo *asmInfo = context.getAsmInfo();
   int AddrSize = asmInfo->getCodePointerSize();
   int Pad = 2 * AddrSize - (Length & (2 * AddrSize - 1));
   if (Pad == 2 * AddrSize)
     Pad = 0;
   Length += Pad;
 
   // Add the size of the pair of PointerSize'ed values for the address and size
   // of each section we have in the table.
   Length += 2 * AddrSize * Sections.size();
   // And the pair of terminating zeros.
   Length += 2 * AddrSize;
 
   // Emit the header for this section.
-  // The 4 byte length not including the 4 byte value for the length.
-  MCOS->emitInt32(Length - 4);
+  if (context.getDwarfFormat() == dwarf::DWARF64)
+    // The DWARF64 mark.
+    MCOS->emitInt32(dwarf::DW_LENGTH_DWARF64);
+  // The 4 (8 for DWARF64) byte length not including the length of the unit
+  // length field itself.
+  MCOS->emitIntValue(Length - UnitLengthBytes, OffsetSize);
   // The 2 byte version, which is 2.
   MCOS->emitInt16(2);
-  // The 4 byte offset to the compile unit in the .debug_info from the start
-  // of the .debug_info.
+  // The 4 (8 for DWARF64) byte offset to the compile unit in the .debug_info
+  // from the start of the .debug_info.
   if (InfoSectionSymbol)
-    MCOS->emitSymbolValue(InfoSectionSymbol, 4,
+    MCOS->emitSymbolValue(InfoSectionSymbol, OffsetSize,
                           asmInfo->needsDwarfSectionOffsetDirective());
   else
-    MCOS->emitInt32(0);
+    MCOS->emitIntValue(0, OffsetSize);
   // The 1 byte size of an address.
   MCOS->emitInt8(AddrSize);
   // The 1 byte size of a segment descriptor, we use a value of zero.
   MCOS->emitInt8(0);
   // Align the header with the padding if needed, before we put out the table.
   for(int i = 0; i < Pad; i++)
     MCOS->emitInt8(0);
 
static void EmitGenDwarfInfo(MCStreamer *MCOS,
   // Create a symbol at the start and end of this section used in here for the
   // expression to calculate the length in the header.
   MCSymbol *InfoStart = context.createTempSymbol();
   MCOS->emitLabel(InfoStart);
   MCSymbol *InfoEnd = context.createTempSymbol();
 
   // First part: the header.
 
-  // The 4 byte total length of the information for this compilation unit, not
-  // including these 4 bytes.
+  unsigned UnitLengthBytes =
+      dwarf::getUnitLengthFieldByteSize(context.getDwarfFormat());
+  unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(context.getDwarfFormat());
+
+  if (context.getDwarfFormat() == dwarf::DWARF64)
+    // Emit DWARF64 mark.
+    MCOS->emitInt32(dwarf::DW_LENGTH_DWARF64);
+
+  // The 4 (8 for DWARF64) byte total length of the information for this
+  // compilation unit, not including the unit length field itself.
   const MCExpr *Length =
-      MakeStartMinusEndExpr(context, *InfoStart, *InfoEnd, 4);
-  emitAbsValue(*MCOS, Length, 4);
+      MakeStartMinusEndExpr(context, *InfoStart, *InfoEnd, UnitLengthBytes);
+  emitAbsValue(*MCOS, Length, OffsetSize);
 
   // The 2 byte DWARF version.
   MCOS->emitInt16(context.getDwarfVersion());
 
   // The DWARF v5 header has unit type, address size, abbrev offset.
   // Earlier versions have abbrev offset, address size.
   const MCAsmInfo &AsmInfo = *context.getAsmInfo();
   int AddrSize = AsmInfo.getCodePointerSize();
   if (context.getDwarfVersion() >= 5) {
     MCOS->emitInt8(dwarf::DW_UT_compile);
     MCOS->emitInt8(AddrSize);
   }
-  // The 4 byte offset to the debug abbrevs from the start of the .debug_abbrev,
-  // it is at the start of that section so this is zero.
+  // The 4 (8 for DWARF64) byte offset to the debug abbrevs from the start of
+  // the .debug_abbrev, it is at the start of that section so this is zero.
   if (AbbrevSectionSymbol == nullptr)
-    MCOS->emitInt32(0);
+    MCOS->emitIntValue(0, OffsetSize);
   else
-    MCOS->emitSymbolValue(AbbrevSectionSymbol, 4,
+    MCOS->emitSymbolValue(AbbrevSectionSymbol, OffsetSize,
                           AsmInfo.needsDwarfSectionOffsetDirective());
   if (context.getDwarfVersion() <= 4)
     MCOS->emitInt8(AddrSize);
 
   // Second part: the compile_unit DIE.
 
   // The DW_TAG_compile_unit DIE abbrev (1).
   MCOS->emitULEB128IntValue(1);
 
-  // DW_AT_stmt_list, a 4 byte offset from the start of the .debug_line section,
-  // which is at the start of that section so this is zero.
+  // DW_AT_stmt_list, a 4 (8 for DWARF64) byte offset from the start of the
+  // .debug_line section, which is at the start of that section so this is zero.
   if (LineSectionSymbol)
-    MCOS->emitSymbolValue(LineSectionSymbol, 4,
+    MCOS->emitSymbolValue(LineSectionSymbol, OffsetSize,
                           AsmInfo.needsDwarfSectionOffsetDirective());
   else
-    MCOS->emitInt32(0);
+    MCOS->emitIntValue(0, OffsetSize);
 
   if (RangesSymbol) {
     // There are multiple sections containing code, so we must use
-    // .debug_ranges/.debug_rnglists. AT_ranges, the 4 byte offset from the
+    // .debug_ranges/.debug_rnglists. AT_ranges, the 4/8 byte offset from the
     // start of the .debug_ranges/.debug_rnglists.
-    MCOS->emitSymbolValue(RangesSymbol, 4);
+    MCOS->emitSymbolValue(RangesSymbol, OffsetSize);
   } else {
     // If we only have one non-empty code section, we can use the simpler
     // AT_low_pc and AT_high_pc attributes.
 
     // Find the first (and only) non-empty text section
     auto &Sections = context.getGenDwarfSectionSyms();
     const auto TextSection = Sections.begin();
     assert(TextSection != Sections.end() && "No text section found");
const MCSymbol &FrameEmitterImpl::EmitCIE(const MCDwarfFrameInfo &Frame) {
   const MCRegisterInfo *MRI = context.getRegisterInfo();
   const MCObjectFileInfo *MOFI = context.getObjectFileInfo();
 
   MCSymbol *sectionStart = context.createTempSymbol();
   Streamer.emitLabel(sectionStart);
 
   MCSymbol *sectionEnd = context.createTempSymbol();
 
+  unsigned UnitLengthBytes =
+      IsEH ? 4 : dwarf::getUnitLengthFieldByteSize(context.getDwarfFormat());
+  unsigned OffsetSize =
+      IsEH ? 4 : dwarf::getDwarfOffsetByteSize(context.getDwarfFormat());
+  bool IsDwarf64 = context.getDwarfFormat() == dwarf::DWARF64;
+
+  if (!IsEH && IsDwarf64)
+    // DWARF64 mark
+    Streamer.emitInt32(dwarf::DW_LENGTH_DWARF64);
+
   // Length
-  const MCExpr *Length =
-      MakeStartMinusEndExpr(context, *sectionStart, *sectionEnd, 4);
-  emitAbsValue(Streamer, Length, 4);
+  const MCExpr *Length = MakeStartMinusEndExpr(context, *sectionStart,
+                                               *sectionEnd, UnitLengthBytes);
+  emitAbsValue(Streamer, Length, OffsetSize);
 
   // CIE ID
-  unsigned CIE_ID = IsEH ? 0 : -1;
-  Streamer.emitInt32(CIE_ID);
+  uint64_t CIE_ID =
+      IsEH ? 0 : (IsDwarf64 ? dwarf::DW64_CIE_ID : dwarf::DW_CIE_ID);
+  Streamer.emitIntValue(CIE_ID, OffsetSize);
 
   // Version
   uint8_t CIEVersion = getCIEVersion(IsEH, context.getDwarfVersion());
   Streamer.emitInt8(CIEVersion);
 
   if (IsEH) {
     SmallString<8> Augmentation;
     Augmentation += "z";
void FrameEmitterImpl::EmitFDE(const MCSymbol &cieStart,
                                const MCSymbol &SectionStart) {
   MCContext &context = Streamer.getContext();
   MCSymbol *fdeStart = context.createTempSymbol();
   MCSymbol *fdeEnd = context.createTempSymbol();
   const MCObjectFileInfo *MOFI = context.getObjectFileInfo();
 
   CFAOffset = InitialCFAOffset;
 
+  unsigned OffsetSize =
+      IsEH ? 4 : dwarf::getDwarfOffsetByteSize(context.getDwarfFormat());
+
+  if (!IsEH && context.getDwarfFormat() == dwarf::DWARF64)
+    // DWARF64 mark
+    Streamer.emitInt32(dwarf::DW_LENGTH_DWARF64);
+
   // Length
   const MCExpr *Length = MakeStartMinusEndExpr(context, *fdeStart, *fdeEnd, 0);
-  emitAbsValue(Streamer, Length, 4);
+  emitAbsValue(Streamer, Length, OffsetSize);
 
   Streamer.emitLabel(fdeStart);
 
   // CIE Pointer
   const MCAsmInfo *asmInfo = context.getAsmInfo();
   if (IsEH) {
     const MCExpr *offset =
         MakeStartMinusEndExpr(context, cieStart, *fdeStart, 0);
-    emitAbsValue(Streamer, offset, 4);
+    emitAbsValue(Streamer, offset, OffsetSize);
   } else if (!asmInfo->doesDwarfUseRelocationsAcrossSections()) {
     const MCExpr *offset =
         MakeStartMinusEndExpr(context, SectionStart, cieStart, 0);
-    emitAbsValue(Streamer, offset, 4);
+    emitAbsValue(Streamer, offset, OffsetSize);
   } else {
-    Streamer.emitSymbolValue(&cieStart, 4,
+    Streamer.emitSymbolValue(&cieStart, OffsetSize,
                              asmInfo->needsDwarfSectionOffsetDirective());
   }
 
   // PC Begin
   unsigned PCEncoding =
       IsEH ? MOFI->getFDEEncoding() : (unsigned)dwarf::DW_EH_PE_absptr;
   unsigned PCSize = getSizeForEncoding(Streamer, PCEncoding);
   emitFDESymbol(Streamer, *frame.Begin, PCEncoding, IsEH);

llvm/lib/MC/MCTargetOptions.cpp

 
 using namespace llvm;
 
 MCTargetOptions::MCTargetOptions()
     : MCRelaxAll(false), MCNoExecStack(false), MCFatalWarnings(false),
       MCNoWarn(false), MCNoDeprecatedWarn(false), MCSaveTempLabels(false),
       MCUseDwarfDirectory(false), MCIncrementalLinkerCompatible(false),
       ShowMCEncoding(false), ShowMCInst(false), AsmVerbose(false),
-      PreserveAsmComments(true) {}
+      PreserveAsmComments(true), Dwarf64(false) {}
 
 StringRef MCTargetOptions::getABIName() const {
   return ABIName;
 }
 
 StringRef MCTargetOptions::getAssemblyLanguage() const {
   return AssemblyLanguage;
 }

llvm/lib/MC/MCTargetOptionsCommandFlags.cpp

if (NAME##View->getNumOccurrences()) {                                     \
       return res;                                                              \
     }                                                                          \
     return None;                                                               \
   }
 
 MCOPT_EXP(bool, RelaxAll)
 MCOPT(bool, IncrementalLinkerCompatible)
 MCOPT(int, DwarfVersion)
+MCOPT(bool, Dwarf64)
 MCOPT(bool, ShowMCInst)
 MCOPT(bool, FatalWarnings)
 MCOPT(bool, NoWarn)
 MCOPT(bool, NoDeprecatedWarn)
 MCOPT(std::string, ABIName)
 
 llvm::mc::RegisterMCTargetOptionsFlags::RegisterMCTargetOptionsFlags() {
 #define MCBINDOPT(NAME)                                                        \
static cl::opt<bool> IncrementalLinkerCompatible(
           "When used with filetype=obj, "
           "emit an object file which can be used with an incremental linker"));
   MCBINDOPT(IncrementalLinkerCompatible);
 
   static cl::opt<int> DwarfVersion("dwarf-version", cl::desc("Dwarf version"),
                                    cl::init(0));
   MCBINDOPT(DwarfVersion);
 
+  static cl::opt<bool> Dwarf64(
+      "dwarf64",
+      cl::desc("Generate debugging info in the 64-bit DWARF format"));
+  MCBINDOPT(Dwarf64);
+
   static cl::opt<bool> ShowMCInst(
       "asm-show-inst",
       cl::desc("Emit internal instruction representation to assembly file"));
   MCBINDOPT(ShowMCInst);
 
   static cl::opt<bool> FatalWarnings("fatal-warnings",
                                      cl::desc("Treat warnings as errors"));
   MCBINDOPT(FatalWarnings);

 
 #undef MCBINDOPT
 }
 
 MCTargetOptions llvm::mc::InitMCTargetOptionsFromFlags() {
   MCTargetOptions Options;
   Options.MCRelaxAll = getRelaxAll();
   Options.MCIncrementalLinkerCompatible = getIncrementalLinkerCompatible();
+  Options.Dwarf64 = getDwarf64();
   Options.DwarfVersion = getDwarfVersion();
   Options.ShowMCInst = getShowMCInst();
   Options.ABIName = getABIName();
   Options.MCFatalWarnings = getFatalWarnings();
   Options.MCNoWarn = getNoWarn();
   Options.MCNoDeprecatedWarn = getNoDeprecatedWarn();
   return Options;
 }

llvm/test/MC/COFF/dwarf64-err.s

+# RUN: not llvm-mc -dwarf64 -triple x86_64-unknown-windows-gnu %s -o - 2>&1 | FileCheck %s
+
+# CHECK: the 64-bit DWARF format is not supported for x86_64-unknown-windows-gnu.

llvm/test/MC/ELF/gen-dwarf64.s

+// RUN: not llvm-mc -g -dwarf-version 5 -dwarf64 -triple i686 %s -filetype=asm -o - 2>&1 | FileCheck --check-prefix=I686 %s
+// RUN: not llvm-mc -g -dwarf-version 2 -dwarf64 -triple x86_64 %s -filetype=asm -o - 2>&1 | FileCheck --check-prefix=DWARF2 %s
+
+// RUN: llvm-mc -g -dwarf-version 3 -dwarf64 -triple x86_64 %s -filetype=obj -o %t3.o
+// RUN: llvm-mc -g -dwarf-version 5 -dwarf64 -triple x86_64 %s -filetype=obj -o %t5.o
+
+// RUN: llvm-readobj -r %t3.o | FileCheck --check-prefixes=REL,REL3 %s
+// RUN: llvm-readobj -r %t5.o | FileCheck --check-prefixes=REL,REL5 %s
+
+// RUN: llvm-dwarfdump -v %t3.o | FileCheck --check-prefixes=DUMP,DUMP3 %s
+// RUN: llvm-dwarfdump -v %t5.o | FileCheck --check-prefixes=DUMP,DUMP5 %s
+
+// DWARF2: the 64-bit DWARF format is not supported for DWARF versions prior to 3.
+// I686: the 64-bit DWARF format is only supported for 64-bit targets.
+
+// REL:       Relocations [
+// REL:         Section ({{[0-9]+}}) .rela.debug_frame {
+// REL-NEXT:      R_X86_64_64 .debug_frame 0x0
+// REL-NEXT:      R_X86_64_64 .bar 0x0
+// REL-NEXT:    }
+// REL-NEXT:    Section ({{[0-9]+}}) .rela.debug_info {
+// REL-NEXT:      R_X86_64_64 .debug_abbrev 0x0
+// REL-NEXT:      R_X86_64_64 .debug_line 0x0
+// REL3-NEXT:     R_X86_64_64 .debug_ranges 0x0
+// REL5-NEXT:     R_X86_64_64 .debug_rnglists 0x14
+// REL-NEXT:      R_X86_64_64 .foo 0x0
+// REL-NEXT:      R_X86_64_64 .bar 0x0
+// REL-NEXT:    }
+// REL-NEXT:    Section ({{[0-9]+}}) .rela.debug_aranges {
+// REL-NEXT:      R_X86_64_64 .debug_info 0x0
+// REL-NEXT:      R_X86_64_64 .foo 0x0
+// REL-NEXT:      R_X86_64_64 .bar 0x0
+// REL-NEXT:    }
+// REL3-NEXT:   Section ({{[0-9]+}}) .rela.debug_ranges {
+// REL5-NEXT:   Section ({{[0-9]+}}) .rela.debug_rnglists {
+// REL-NEXT:      R_X86_64_64 .foo 0x0
+// REL-NEXT:      R_X86_64_64 .bar 0x0
+// REL-NEXT:    }
+// REL-NEXT:    Section ({{[0-9]+}}) .rela.debug_line {
+// REL5-NEXT:     R_X86_64_64 .debug_line_str 0x0
+// REL5-NEXT:     R_X86_64_64 .debug_line_str 0x
+// REL-NEXT:      R_X86_64_64 .foo 0x0
+// REL-NEXT:      R_X86_64_64 .bar 0x0
+// REL-NEXT:    }
+// REL-NEXT:  ]
+
+// DUMP:        .debug_abbrev contents:
+// DUMP3:           DW_AT_stmt_list DW_FORM_data8
+// DUMP3-NEXT:      DW_AT_ranges    DW_FORM_data8
+// DUMP5:           DW_AT_stmt_list DW_FORM_sec_offset
+// DUMP5-NEXT:      DW_AT_ranges    DW_FORM_sec_offset
+
+// DUMP:        .debug_info contents:
+// DUMP-NEXT:   0x00000000: Compile Unit:
+// DUMP-SAME:       format = DWARF64
+
+// DUMP:        .debug_frame contents:
+// DUMP:            ffffffffffffffff CIE
+// DUMP-NEXT:       Format: DWARF64
+// DUMP:            0000000000000000 FDE cie=00000000
+// DUMP-NEXT:       Format: DWARF64
+
+// DUMP:        .debug_aranges contents:
+// DUMP-NEXT:   Address Range Header: 
+// DUMP-SAME:       format = DWARF64
+
+// DUMP:        .debug_line contents:
+// DUMP-NEXT:   debug_line[0x00000000]
+// DUMP-NEXT:   Line table prologue:
+// DUMP-NEXT:       total_length:
+// DUMP-NEXT:       format: DWARF64
+// DUMP5:       include_directories[  0] = .debug_line_str[0x0000000000000000] = "[[DIR:[^"]+]]"
+// DUMP5-NEXT:  file_names[  0]:
+// DUMP5-NEXT:             name: .debug_line_str[0x00000000[[FILEOFF:[0-9a-f]+]]] = "[[FILE:[^"]+]]"
+// DUMP5-NEXT:        dir_index: 0
+
+// DUMP5:       .debug_line_str contents:
+// DUMP5-NEXT:  0x00000000: "[[DIR]]"
+// DUMP5-NEXT:  0x[[FILEOFF]]: "[[FILE]]"
+
+// DUMP5:       .debug_rnglists contents:
+// DUMP5-NEXT:  0x00000000: range list header:
+// DUMP5-SAME:      format = DWARF64
+
+    .cfi_sections .debug_frame
+
+    .section .foo, "ax", @progbits
+foo:
+    nop
+
+    .section .bar, "ax", @progbits
+bar:
+    .cfi_startproc
+    nop
+    .cfi_endproc

llvm/tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
   // Default to 4 for dwarf version.
   unsigned DwarfVersion = MCOptions.DwarfVersion ? MCOptions.DwarfVersion : 4;
   if (DwarfVersion < 2 || DwarfVersion > 5) {
     errs() << ProgName << ": Dwarf version " << DwarfVersion
            << " is not supported." << '\n';
     return 1;
   }
   Ctx.setDwarfVersion(DwarfVersion);
+  if (MCOptions.Dwarf64) {
+    // DWARFv3 was the first standard where the 64-bit DWARF was described.
+    if (DwarfVersion < 3) {
+      errs() << ProgName
+             << ": the 64-bit DWARF format is not supported for DWARF versions "
+                "prior to 3.\n";
+      return 1;
+    }
+    // DWARF64 requires 64-bit relocations. They do not exist in 32-bit targets.
+    if (MAI->getCodePointerSize() < 8) {
+      errs() << ProgName
+             << ": the 64-bit DWARF format is only supported for 64-bit "
+                "targets.\n";
+      return 1;
+    }
+    // If needsDwarfSectionOffsetDirective is true, we would eventually call
+    // MCStreamer::emitSymbolValue() with IsSectionRelative = true, but that
+    // is supported only for 4-byte long references.
+    if (MAI->needsDwarfSectionOffsetDirective()) {
+      errs() << ProgName << ": the 64-bit DWARF format is not supported for "
+             << TheTriple.normalize() << ".\n";
+      return 1;
+    }
+    Ctx.setDwarfFormat(dwarf::DWARF64);
+  }
   if (!DwarfDebugFlags.empty())
     Ctx.setDwarfDebugFlags(StringRef(DwarfDebugFlags));
   if (!DwarfDebugProducer.empty())
     Ctx.setDwarfDebugProducer(StringRef(DwarfDebugProducer));
   if (!DebugCompilationDir.empty())
     Ctx.setCompilationDir(DebugCompilationDir);
   else {
     // If no compilation dir is set, try to use the current directory.