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

[dblaikie]

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

25–26

Test that the length and CU offset were parsed correctly - since this patch changes how those are emitted.

[probinson]

This patch modifies EmitGenDwarfAranges(), which is used only when the assembler is generating DWARF to describe the assembler source.
I can't imagine anyone is really writing large enough assembler that they need to emit DWARF-64 format. What is the motivation here?

[dblaikie]

In D81146#2074627, @probinson wrote:

This patch modifies EmitGenDwarfAranges(), which is used only when the assembler is generating DWARF to describe the assembler source.
I can't imagine anyone is really writing large enough assembler that they need to emit DWARF-64 format. What is the motivation here?

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.

[probinson]

So if we want DWARF-64 .debug_aranges for both asm source and higher-level language source....
This patch only does the asm source path, not the main path. I am not 100% clear where the other path is, but I see code to emit .debug_aranges in lib/DWARFLinker/DWARFStreamer.cpp, is that where the normal path is now?

[dblaikie]

In D81146#2075123, @probinson wrote:

So if we want DWARF-64 .debug_aranges for both asm source and higher-level language source....
This patch only does the asm source path, not the main path. I am not 100% clear where the other path is, but I see code to emit .debug_aranges in lib/DWARFLinker/DWARFStreamer.cpp, is that where the normal path is now?

Yep, adding support for higher level source/LLVM IR will be a separate patch/independent change. It'll be in llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp - llvm::DwarfDebug::emitDebugARanges

[jhenderson]

llvm/lib/MC/MCDwarf.cpp

913–916

As mentioned elsewhere, there are two code paths here, but only one seems to be tested. Do we need another test case?

[ikudrin]

• Extended a test for Mach-O so that all changed code paths are covered.
• Added more checks for the .debug_aranges section to validate that it is not skewed.

[ikudrin]

llvm/lib/MC/MCDwarf.cpp

913–916

MachO/gen-dwarf64.s is extended to cover another code path.

[jhenderson]

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

25

Optionally, you could delete the bit after the cu_offset since it's not important.

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

14

Same comment as above.

[jhenderson]

LGTM, with or without my inline suggestions, I don't mind.

[ikudrin]

• Added --implicit-check-not="R_{{.*}} .debug_" to the test to ensure that all relocations to debug sections are checked.

llvm/lib/MC/MCDwarf.cpp

 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);
 

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
+# 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
+# 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)
 # DUMP:       DW_TAG_label [2]
 # DUMP-NEXT:    DW_AT_name [DW_FORM_string] ("foo")
 
+# 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:  [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:.+]]"

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

 // This checks that llvm-mc is able to produce 64-bit debug info.
 
 // RUN: llvm-mc -g -dwarf64 -triple x86_64-apple-darwin10 %s -filetype=obj -o %t
 // RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 // CHECK:      .debug_info contents:
 // CHECK-NEXT: 0x00000000: Compile Unit: {{.*}} format = DWARF64, version = {{.*}}, abbr_offset = 0x0000, addr_size = 0x08
 // CHECK:      DW_TAG_compile_unit [1] *
 // CHECK-NEXT:   DW_AT_stmt_list [DW_FORM_sec_offset] (0x0000000000000000)
 // CHECK:      DW_TAG_label [2]
 // CHECK-NEXT:   DW_AT_name [DW_FORM_string] ("foo")
 
+// CHECK:      .debug_aranges contents:
+// CHECK-NEXT: Address Range Header: length = 0x0000000000000034, format = DWARF64, version = 0x0002, cu_offset = 0x0000000000000000, addr_size = 0x08, seg_size = 0x00
+// CHECK-NEXT: [0x0000000000000000,  0x0000000000000001)
+// CHECK-EMPTY:
+
 _foo:
     nop