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

[ikudrin]

Summary

In addition, the patch fixes referencing the section within a compilation unit.

[MaskRay]

Looks great!

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

51

The SAME directive can be joined to the previous line: {{.*}}, format = DWARF64

[probinson]

llvm/lib/MC/MCDwarf.cpp

1025

This function (EmitGenDwarfInfo) is for emitting DWARF to describe raw assembler source, which I believe is not really the interesting case.

[dblaikie]

llvm/lib/MC/MCDwarf.cpp

1025

Might be best to keep the fundamental design direction/question here in one thread ( https://reviews.llvm.org/D81144 ) rather than in all of them. Patches are in a series, so if that one ends up going another direction I don't think there's a risk these later ones will be reviewed/approved/committed in spite of that fundamental question.

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

51–52

Test the length is correct, since this patch changes how it's emitted.

[jhenderson]

Looks good to me, once @MaskRay's and @dblaikie's comments have been addressed.

[ikudrin]

• Updated the test.

[dblaikie]

Looks good, thanks!

[jhenderson]

LGTM again.

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

31–32

Up to you, but you could probably simplify this line, by deleting everything after format = DWARF64

51

Same comment as above.

[ikudrin]

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

31–32

That was my initial variant, but later I decided to extend the check to avoid potential cases when the format is DWARF64, but the data is malformed, e.g. if the emitting of cu_offset was not fixed.

[ikudrin]

• Updated to reflect changes in parent revisions.

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;
if (LineSectionSymbol)
     MCOS->emitSymbolValue(LineSectionSymbol, OffsetSize,
                           AsmInfo.needsDwarfSectionOffsetDirective());
   else
     // The line table is at the start of the section, so the offset is zero.
     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");

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 5 -dwarf64 -triple x86_64 %s -filetype=obj -o %t5.o
 # RUN: llvm-readobj -r %t5.o | FileCheck --check-prefixes=REL,REL5 %s --implicit-check-not="R_{{.*}} .debug_"
 # 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:         Section ({{[0-9]+}}) .rela.debug_info {
 # REL-NEXT:      R_X86_64_64 .debug_abbrev 0x0
 # REL-NEXT:      R_X86_64_64 .debug_line 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 {
 # REL5-NEXT:     R_X86_64_64 .debug_line_str 0x0
 # REL5-NEXT:     R_X86_64_64 .debug_line_str 0x
 
 # DUMP:       .debug_info contents:
 # DUMP-NEXT:  0x00000000: Compile Unit: {{.*}} format = DWARF64
 # DUMP:       DW_TAG_compile_unit [1] *
 # DUMP5-NEXT:   DW_AT_stmt_list [DW_FORM_sec_offset] (0x0000000000000000)
+# DUMP5-NEXT:   DW_AT_ranges [DW_FORM_sec_offset] (0x0000000000000014
+# DUMP-NEXT:      [0x0000000000000000, 0x0000000000000001) ".foo"
+# DUMP-NEXT:      [0x0000000000000000, 0x0000000000000001) ".bar")
 # DUMP:       DW_TAG_label [2]
 # DUMP-NEXT:    DW_AT_name [DW_FORM_string] ("foo")
+# DUMP:       DW_TAG_label [2]
+# DUMP-NEXT:    DW_AT_name [DW_FORM_string] ("bar")
 
 # DUMP:       .debug_aranges contents:
-# DUMP-NEXT:  Address Range Header: length = 0x0000000000000034, format = DWARF64, version = 0x0002, cu_offset = 0x0000000000000000, addr_size = 0x08, seg_size = 0x00
+# DUMP-NEXT:  Address Range Header: length = 0x0000000000000044, format = DWARF64, version = 0x0002, cu_offset = 0x0000000000000000, addr_size = 0x08, seg_size = 0x00
+# DUMP-NEXT:  [0x0000000000000000,  0x0000000000000001)
 # DUMP-NEXT:  [0x0000000000000000,  0x0000000000000001)
 # DUMP-EMPTY:
 
 # 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:[[:xdigit:]]{8}]]] = "[[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: length = 0x000000000000001d, format = DWARF64, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# 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 ]
+
     .section .foo, "ax", @progbits
 foo:
     nop
+
+    .section .bar, "ax", @progbits
+bar:
+    nop