[MC] Generate .debug_frame in the 64-bit DWARF format [7/7]

[ikudrin]

Summary

Note that .eh_frame sections are generated in the 32-bit format even when debug sections are 64-bit, for compatibility reasons. They use relative references between entries, so they hardly benefit from the 64-bit format.

[MaskRay]

llvm/lib/MC/MCDwarf.cpp

1621

Your other patches don't seem to mention DWARF64 mark. You may drop a comment

[jhenderson]

llvm/lib/MC/MCDwarf.cpp

1760–1766

There are three cases here that have been modified, but I don't see three test cases?

[ikudrin]

• Updated the test for Mach-O to cover the remaining changed code paths.

llvm/lib/MC/MCDwarf.cpp

1621

Hmm, I checked and found similar comments before each line where I added emitting DW_LENGTH_DWARF64. Do you think it is better to remove all such comments or keep all of them?

1760–1766

The case in the middle was for the Mach-O target, so I've updated the corresponding test to cover it. The other two paths are already covered by ELF/gen-dwarf64.s.

[jhenderson]

LGTM, thanks.

[ikudrin]

• Updated to reflect changes in parent revisions.

llvm/lib/MC/MCDwarf.cpp

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();
 
+  dwarf::DwarfFormat Format = IsEH ? dwarf::DWARF32 : context.getDwarfFormat();
+  unsigned UnitLengthBytes = dwarf::getUnitLengthFieldByteSize(Format);
+  unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(Format);
+  bool IsDwarf64 = Format == dwarf::DWARF64;
+
+  if (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;
 
+  dwarf::DwarfFormat Format = IsEH ? dwarf::DWARF32 : context.getDwarfFormat();
+  unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(Format);
+
+  if (Format == 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/test/MC/ELF/gen-dwarf64.s

 ## This checks that llvm-mc is able to produce 64-bit debug info.
 
 # RUN: llvm-mc -g -dwarf-version 3 -dwarf64 -triple x86_64 %s -filetype=obj -o %t3.o
 # RUN: llvm-readobj -r %t3.o | FileCheck --check-prefixes=REL %s
 # RUN: llvm-dwarfdump -v %t3.o | FileCheck --check-prefixes=DUMP,DUMP3 %s
 
 # RUN: llvm-mc -g -dwarf-version 5 -dwarf64 -triple x86_64 %s -filetype=obj -o %t5.o
 # RUN: llvm-readobj -r %t5.o | FileCheck --check-prefixes=REL,REL5 %s
 # RUN: llvm-dwarfdump -v %t5.o | FileCheck --check-prefixes=DUMP,DUMP5 %s
 
 ## The references to other debug info sections are 64-bit, as required for DWARF64.
 # REL:       Relocations [
+# REL:         Section ({{[0-9]+}}) .rela.debug_frame {
+# REL-NEXT:      R_X86_64_64 .debug_frame 0x0
 # REL:         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:         Section ({{[0-9]+}}) .rela.debug_aranges {
 # REL-NEXT:      R_X86_64_64 .debug_info 0x0
 # REL5:        Section ({{[0-9]+}}) .rela.debug_line {

 # DUMP:       DW_TAG_compile_unit [1] *
 # DUMP3-NEXT:   DW_AT_stmt_list [DW_FORM_data8] (0x0000000000000000)
 # DUMP5-NEXT:   DW_AT_stmt_list [DW_FORM_sec_offset] (0x0000000000000000)
 # DUMP3-NEXT:   DW_AT_ranges [DW_FORM_data8] (0x0000000000000000
 # DUMP5-NEXT:   DW_AT_ranges [DW_FORM_sec_offset] (0x0000000000000014
 # DUMP-NEXT:      [0x0000000000000000, 0x0000000000000001) ".foo"
 # DUMP-NEXT:      [0x0000000000000000, 0x0000000000000001) ".bar")
 
+# DUMP:       .debug_frame contents:
+# DUMP:       00000000 {{([[:xdigit:]]{16})}} ffffffffffffffff CIE
+# DUMP-NEXT:    Format: DWARF64
+# DUMP:       {{([[:xdigit:]]{8})}} {{([[:xdigit:]]{16})}} 0000000000000000 FDE cie=00000000 pc=00000000...00000001
+# DUMP-NEXT:    Format: DWARF64
+
+## Even though the debug info sections are in the 64-bit format,
+## .eh_frame is still generated as 32-bit.
+# DUMP:       .eh_frame contents:
+# DUMP:       00000000 {{([[:xdigit:]]{8})}} 00000000 CIE
+# DUMP-NEXT:    Format: DWARF32
+# DUMP:       {{([[:xdigit:]]{8})}} {{([[:xdigit:]]{8})}} {{([[:xdigit:]]{8})}} FDE cie=00000000 pc=00000000...00000001
+# DUMP-NEXT:    Format: DWARF32
+
 # DUMP:       .debug_aranges contents:
 # DUMP-NEXT:  Address Range Header: 
 # DUMP-SAME:    format = DWARF64
 # DUMP-NEXT:  [0x0000000000000000,  0x0000000000000001)
 # DUMP-NEXT:  [0x0000000000000000,  0x0000000000000001)
 # DUMP-EMPTY:
 
 # DUMP:       .debug_line contents:

 # DUMP5:      .debug_rnglists contents:
 # DUMP5-NEXT: 0x00000000: range list header:
 # DUMP5-SAME:   format = DWARF64
 # DUMP5-NEXT: ranges:
 # DUMP5-NEXT: 0x00000014: [DW_RLE_start_length]: 0x0000000000000000, 0x0000000000000001 => [0x0000000000000000, 0x0000000000000001)
 # DUMP5-NEXT: 0x0000001e: [DW_RLE_start_length]: 0x0000000000000000, 0x0000000000000001 => [0x0000000000000000, 0x0000000000000001)
 # DUMP5-NEXT: 0x00000028: [DW_RLE_end_of_list ]
 
+    .cfi_sections .eh_frame, .debug_frame
+
     .section .foo, "ax", @progbits
 foo:
     nop
 
     .section .bar, "ax", @progbits
 bar:
+    .cfi_startproc
     nop
+    .cfi_endproc