[MCDwarf] Generate DWARF v5 .debug_rnglists for assembly files

[MaskRay]

Summary

// clang -c -gdwarf-5 a.s -o a.o
.section .init; ret
.text; ret

.debug_info contains DW_AT_ranges and llvm-dwarfdump will report
a verification error because .debug_rnglists does not exist.

This patch generates .debug_rnglists for assembly files.
emitListsTableHeaderStart() in DwarfDebug.cpp can be shared with
MCDwarf.cpp. Because CodeGen depends on MC, I move the function to
MCDwarf.cpp

[probinson]

The general direction is fine, but some details need to be tidied up and I'd like to undo a few unnecessary changes.

llvm/include/llvm/MC/MCDwarf.h

48

I think it would be more usual to use a namespace here (which would be lowercase, mcdwarf).

llvm/lib/MC/MCDwarf.cpp

941

This name change seems inappropriate. This symbol is not paired with an End symbol, and for the GenDwarf case there is only one range list.

966

isDWARF5

1166

AFAICT changing these lines has no functional effect, and IMO the result is less readable.

1166

This change also appears to make the code less readable.

1187

This seems like a gratuitous name change. There is only one range list, and it has its own section, so the old name seems fine.

1190

Why remove the asserts?

1220–1223

Lost another assertion here. You could move it inside emitGenDwarfRanges() if you wish, but I would rather not remove assertions.

llvm/test/MC/ARM/dwarf-asm-multiple-sections.s

2

I'd prefer to have this check both DWARF and DWARF5 prefixes. The generic checks provide context.

4

Keep this using both RELOC and RELOC5 here.

73–78

The above checks (for .debug_ranges) should all become DWARF4 checks.

110

The .debug_ranges checks should all be using RELOC4.

[MaskRay]

Address comments

[MaskRay]

llvm/lib/MC/MCDwarf.cpp

941

Rename to RangesSymbol?

1187

For .debug_rnglists, It is no longer at the start of the section, so the old name is not appropriate.

1190

MCSymbolRefExpr::create asserts the non-nullness.

[MaskRay]

Revert one unneeded test line change.

[MaskRay]

Post-weekend ping :) (Sorry if that was too frequent..)

[probinson]

LGTM, thanks!

llvm/lib/MC/MCDwarf.cpp

1187

Ah, right, I'd forgotten it points to the table not the header, in v5.

[probinson]

In D75375#1902291, @MaskRay wrote:

Post-weekend ping :) (Sorry if that was too frequent..)

Our usual guidance is a week between pings.

[dblaikie]

llvm/lib/MC/MCDwarf.cpp

48–59

Please pass "S" by reference here, since it's unconditionally dereferenced (so the null state isn't needed) - this will simplify some of the callers too (x.get() -> *x)

TableStart and TableEnd can remain pointers since their underlying APIs use them/they're more "tokens" to pass around.

1120–1124

Might be worth considering rolling the start/end label creation into this utility function & having this function return the EndSymbol for later use?

(some of the other "emit a header with the usual length field" implementations in AsmPrinter use this idiom - the function creates both labels, returns the end label for the outer code to emit at the end of the contents)

[MaskRay]

llvm/lib/MC/MCDwarf.cpp

48–59

Agreed with the analysis.

It also makes sense for MCStreamer::emitAbsoluteSymbolDiff to take references as parameters. However, MCSymbol * typed parameters are much more common than MCSymbol &.

1120–1124

// https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp#L2425
static MCSymbol *emitLoclistsTableHeader(AsmPrinter *Asm,
                                         const DwarfDebug &DD) {
  MCSymbol *TableStart = Asm->createTempSymbol("debug_loclist_table_start");
  MCSymbol *TableEnd = Asm->createTempSymbol("debug_loclist_table_end");
  mcdwarf::emitListsTableHeaderStart(*Asm->OutStreamer, TableStart, TableEnd);

The temporary labels may have a different name (loclist). Shall I add another parameter SymbolName accepting either debug_loclists_header or debug_rnglists_header?

[MaskRay]

llvm/lib/MC/MCDwarf.cpp

48–59

https://reviews.llvm.org/D75568

[dblaikie]

llvm/lib/MC/MCDwarf.cpp

1120–1124

I'm undecided/your choice - I wonder if it might be reasonable to not worry about giving them such distinct names? let them be debug_list_header0, debug_list_header1, etc? I don't mind too much either way. Adding the list type string, or not. I guess it's probably nice to add it.

[MaskRay]

llvm/lib/MC/MCDwarf.cpp

1120–1124

In D75568, I moved TableStart/TableEnd generation into emitListsTableHeaderStart(). PTAL~

It seems we don't have a test checking -filetype=asm output, so the name is not significant.

[dblaikie]

llvm/lib/MC/MCDwarf.cpp

1120–1124

Yeah, I wouldn't expect we'd test the asm output - but we still like to keep it readable and editable (eg: the names of labels, the text of comments, the use of labels rather than precalculating offsets (sometimes - we haven't done that completely, but it might be worthwhile to make for highly editable DWARF)). Having the more specific names /could/ be nice - but like I said above, I don't think it's super important & should still be quite legible/editable as-is. Thanks!

llvm/include/llvm/MC/MCDwarf.h

 class MCDwarfLineStr;
 class MCObjectStreamer;
 class MCStreamer;
 class MCSymbol;
 class raw_ostream;
 class SMLoc;
 class SourceMgr;
 
+namespace mcdwarf {
+// Emit the common part of the DWARF 5 range/locations list tables header.
+void emitListsTableHeaderStart(MCStreamer *S, MCSymbol *TableStart,
+                               MCSymbol *TableEnd);
+} // namespace mcdwarf
+
 /// Instances of this class represent the name of the dwarf .file directive and
 /// its associated dwarf file number in the MC file. MCDwarfFile's are created
 /// and uniqued by the MCContext class. In Dwarf 4 file numbers start from 1;
 /// i.e. the entry with file number 1 is the first element in the vector of
 /// DwarfFiles and there is no MCDwarfFile with file number 0. In Dwarf 5 file
 /// numbers start from 0, with the MCDwarfFile with file number 0 being the
 /// primary source file, and file numbers correspond to their index in the
 /// vector.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

else {
     Asm->emitInt16(0);
     return;
   }
   // Emit the entry.
   APByteStreamer Streamer(*Asm);
   emitDebugLocEntry(Streamer, Entry, CU);
 }
 
-// Emit the common part of the DWARF 5 range/locations list tables header.
-static void emitListsTableHeaderStart(AsmPrinter *Asm,
-                                      MCSymbol *TableStart,
-                                      MCSymbol *TableEnd) {
-  // Build the table header, which starts with the length field.
-  Asm->OutStreamer->AddComment("Length");
-  Asm->emitLabelDifference(TableEnd, TableStart, 4);
-  Asm->OutStreamer->emitLabel(TableStart);
-  // Version number (DWARF v5 and later).
-  Asm->OutStreamer->AddComment("Version");
-  Asm->emitInt16(Asm->OutStreamer->getContext().getDwarfVersion());
-  // Address size.
-  Asm->OutStreamer->AddComment("Address size");
-  Asm->emitInt8(Asm->MAI->getCodePointerSize());
-  // Segment selector size.
-  Asm->OutStreamer->AddComment("Segment selector size");
-  Asm->emitInt8(0);
-}
-
 // Emit the header of a DWARF 5 range list table list table. Returns the symbol
 // that designates the end of the table for the caller to emit when the table is
 // complete.
 static MCSymbol *emitRnglistsTableHeader(AsmPrinter *Asm,
                                          const DwarfFile &Holder) {
   MCSymbol *TableStart = Asm->createTempSymbol("debug_rnglist_table_start");
   MCSymbol *TableEnd = Asm->createTempSymbol("debug_rnglist_table_end");
-  emitListsTableHeaderStart(Asm, TableStart, TableEnd);
+  mcdwarf::emitListsTableHeaderStart(Asm->OutStreamer.get(), TableStart,
+                                     TableEnd);
 
   Asm->OutStreamer->AddComment("Offset entry count");
   Asm->emitInt32(Holder.getRangeLists().size());
   Asm->OutStreamer->emitLabel(Holder.getRnglistsTableBaseSym());
 
   for (const RangeSpanList &List : Holder.getRangeLists())
     Asm->emitLabelDifference(List.Label, Holder.getRnglistsTableBaseSym(), 4);
 
   return TableEnd;
 }
 
 // Emit the header of a DWARF 5 locations list table. Returns the symbol that
 // designates the end of the table for the caller to emit when the table is
 // complete.
 static MCSymbol *emitLoclistsTableHeader(AsmPrinter *Asm,
                                          const DwarfDebug &DD) {
   MCSymbol *TableStart = Asm->createTempSymbol("debug_loclist_table_start");
   MCSymbol *TableEnd = Asm->createTempSymbol("debug_loclist_table_end");
-  emitListsTableHeaderStart(Asm, TableStart, TableEnd);
+  mcdwarf::emitListsTableHeaderStart(Asm->OutStreamer.get(), TableStart,
+                                     TableEnd);
 
   const auto &DebugLocs = DD.getDebugLocs();
 
   Asm->OutStreamer->AddComment("Offset entry count");
   Asm->emitInt32(DebugLocs.getLists().size());
   Asm->OutStreamer->emitLabel(DebugLocs.getSym());
 
   for (const auto &List : DebugLocs.getLists())

llvm/lib/MC/MCDwarf.cpp

 #include <cassert>
 #include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
+void mcdwarf::emitListsTableHeaderStart(MCStreamer *S, MCSymbol *TableStart,
+                                        MCSymbol *TableEnd) {
+  S->AddComment("Length");
+  S->emitAbsoluteSymbolDiff(TableEnd, TableStart, 4);
+  S->emitLabel(TableStart);
+  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);
+}
+
 /// Manage the .debug_line_str section contents, if we use it.
 class llvm::MCDwarfLineStr {
   MCSymbol *LineStrLabel = nullptr;
   StringTableBuilder LineStrings{StringTableBuilder::DWARF};
   bool UseRelocs = false;
 
 public:
   /// Construct an instance that can emit .debug_line_str (for use in a normal

 }
 
 // When generating dwarf for assembly source files this emits the data for
 // .debug_info section which contains three parts.  The header, the compile_unit
 // DIE and a list of label DIEs.
 static void EmitGenDwarfInfo(MCStreamer *MCOS,
                              const MCSymbol *AbbrevSectionSymbol,
                              const MCSymbol *LineSectionSymbol,
-                             const MCSymbol *RangesSectionSymbol) {
+                             const MCSymbol *RangesSymbol) {
   MCContext &context = MCOS->getContext();
 
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection());
 
   // 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.
   const MCExpr *Length = MakeStartMinusEndExpr(*MCOS, *InfoStart, *InfoEnd, 4);
   emitAbsValue(*MCOS, Length, 4);
 
   // 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.
   if (AbbrevSectionSymbol == nullptr)
     MCOS->emitInt32(0);
   else
static void EmitGenDwarfInfo(MCStreamer *MCOS,
   // 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.
   if (LineSectionSymbol)
     MCOS->emitSymbolValue(LineSectionSymbol, 4,
                           AsmInfo.needsDwarfSectionOffsetDirective());
   else
     MCOS->emitInt32(0);
 
-  if (RangesSectionSymbol) {
-    // There are multiple sections containing code, so we must use the
-    // .debug_ranges sections.
-
-    // AT_ranges, the 4 byte offset from the start of the .debug_ranges section
-    // to the address range list for this compilation unit.
-    MCOS->emitSymbolValue(RangesSectionSymbol, 4);
+  if (RangesSymbol) {
+    // There are multiple sections containing code, so we must use
+    // .debug_ranges/.debug_rnglists. AT_ranges, the 4 byte offset from the
+    // start of the .debug_ranges/.debug_rnglists.
+    MCOS->emitSymbolValue(RangesSymbol, 4);
   } 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");
static void EmitGenDwarfInfo(MCStreamer *MCOS,
 
   // Now set the value of the symbol at the end of the info section.
   MCOS->emitLabel(InfoEnd);
 }
 
 // When generating dwarf for assembly source files this emits the data for
 // .debug_ranges section. We only emit one range list, which spans all of the
 // executable sections of this file.
-static void EmitGenDwarfRanges(MCStreamer *MCOS) {
+static MCSymbol *emitGenDwarfRanges(MCStreamer *MCOS) {
   MCContext &context = MCOS->getContext();
   auto &Sections = context.getGenDwarfSectionSyms();
 
   const MCAsmInfo *AsmInfo = context.getAsmInfo();
   int AddrSize = AsmInfo->getCodePointerSize();
+  MCSymbol *RangesSymbol;
 
+  if (MCOS->getContext().getDwarfVersion() >= 5) {
+    MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRnglistsSection());
+    MCSymbol *StartSymbol =
+        context.createTempSymbol("debug_rnglists_start", true, true);
+    MCSymbol *EndSymbol =
+        context.createTempSymbol("debug_rnglists_end", true, true);
+    mcdwarf::emitListsTableHeaderStart(MCOS, StartSymbol, EndSymbol);
+    MCOS->AddComment("Offset entry count");
+    MCOS->emitInt32(0);
+    RangesSymbol = context.createTempSymbol("debug_rnglist0_start", true, true);
+    MCOS->emitLabel(RangesSymbol);
+    for (MCSection *Sec : Sections) {
+      const MCSymbol *StartSymbol = Sec->getBeginSymbol();
+      const MCSymbol *EndSymbol = Sec->getEndSymbol(context);
+      const MCExpr *SectionStartAddr = MCSymbolRefExpr::create(
+          StartSymbol, MCSymbolRefExpr::VK_None, context);
+      const MCExpr *SectionSize =
+          MakeStartMinusEndExpr(*MCOS, *StartSymbol, *EndSymbol, 0);
+      MCOS->emitInt8(dwarf::DW_RLE_start_length);
+      MCOS->emitValue(SectionStartAddr, AddrSize);
+      MCOS->emitULEB128Value(SectionSize);
+    }
+    MCOS->emitInt8(dwarf::DW_RLE_end_of_list);
+    MCOS->emitLabel(EndSymbol);
+  } else {
     MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
-
+    RangesSymbol = context.createTempSymbol("debug_ranges_start", true, true);
+    MCOS->emitLabel(RangesSymbol);
     for (MCSection *Sec : Sections) {
       const MCSymbol *StartSymbol = Sec->getBeginSymbol();
-    MCSymbol *EndSymbol = Sec->getEndSymbol(context);
-    assert(StartSymbol && "StartSymbol must not be NULL");
-    assert(EndSymbol && "EndSymbol must not be NULL");
+      const MCSymbol *EndSymbol = Sec->getEndSymbol(context);
 
-    // Emit a base address selection entry for the start of this section
+      // Emit a base address selection entry for the section start.
       const MCExpr *SectionStartAddr = MCSymbolRefExpr::create(
           StartSymbol, MCSymbolRefExpr::VK_None, context);
       MCOS->emitFill(AddrSize, 0xFF);
       MCOS->emitValue(SectionStartAddr, AddrSize);
 
-    // Emit a range list entry spanning this section
-    const MCExpr *SectionSize = MakeStartMinusEndExpr(*MCOS,
-      *StartSymbol, *EndSymbol, 0);
+      // Emit a range list entry spanning this section.
+      const MCExpr *SectionSize =
+          MakeStartMinusEndExpr(*MCOS, *StartSymbol, *EndSymbol, 0);
       MCOS->emitIntValue(0, AddrSize);
       emitAbsValue(*MCOS, SectionSize, AddrSize);
     }
 
     // Emit end of list entry
     MCOS->emitIntValue(0, AddrSize);
     MCOS->emitIntValue(0, AddrSize);
   }
 
+  return RangesSymbol;
+}
+
 //
 // When generating dwarf for assembly source files this emits the Dwarf
 // sections.
 //
 void MCGenDwarfInfo::Emit(MCStreamer *MCOS) {
   MCContext &context = MCOS->getContext();
 
   // Create the dwarf sections in this order (.debug_line already created).
   const MCAsmInfo *AsmInfo = context.getAsmInfo();
   bool CreateDwarfSectionSymbols =
       AsmInfo->doesDwarfUseRelocationsAcrossSections();
   MCSymbol *LineSectionSymbol = nullptr;
   if (CreateDwarfSectionSymbols)
     LineSectionSymbol = MCOS->getDwarfLineTableSymbol(0);
   MCSymbol *AbbrevSectionSymbol = nullptr;
   MCSymbol *InfoSectionSymbol = nullptr;
-  MCSymbol *RangesSectionSymbol = nullptr;
+  MCSymbol *RangesSymbol = nullptr;
 
   // Create end symbols for each section, and remove empty sections
   MCOS->getContext().finalizeDwarfSections(*MCOS);
 
   // If there are no sections to generate debug info for, we don't need
   // to do anything
   if (MCOS->getContext().getGenDwarfSectionSyms().empty())
     return;
 
   // We only use the .debug_ranges section if we have multiple code sections,
   // and we are emitting a DWARF version which supports it.
   const bool UseRangesSection =
       MCOS->getContext().getGenDwarfSectionSyms().size() > 1 &&
       MCOS->getContext().getDwarfVersion() >= 3;
   CreateDwarfSectionSymbols |= UseRangesSection;
 
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection());
   if (CreateDwarfSectionSymbols) {
     InfoSectionSymbol = context.createTempSymbol();
     MCOS->emitLabel(InfoSectionSymbol);
   }
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection());
   if (CreateDwarfSectionSymbols) {
     AbbrevSectionSymbol = context.createTempSymbol();
     MCOS->emitLabel(AbbrevSectionSymbol);
   }
-  if (UseRangesSection) {
-    MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
-    if (CreateDwarfSectionSymbols) {
-      RangesSectionSymbol = context.createTempSymbol();
-      MCOS->emitLabel(RangesSectionSymbol);
-    }
-  }
-
-  assert((RangesSectionSymbol != nullptr) || !UseRangesSection);
 
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
 
   // Output the data for .debug_aranges section.
   EmitGenDwarfAranges(MCOS, InfoSectionSymbol);
 
-  if (UseRangesSection)
-    EmitGenDwarfRanges(MCOS);
+  if (UseRangesSection) {
+    RangesSymbol = emitGenDwarfRanges(MCOS);
+    assert(RangesSymbol);
+  }
 
   // Output the data for .debug_abbrev section.
   EmitGenDwarfAbbrev(MCOS);
 
   // Output the data for .debug_info section.
-  EmitGenDwarfInfo(MCOS, AbbrevSectionSymbol, LineSectionSymbol,
-                   RangesSectionSymbol);
+  EmitGenDwarfInfo(MCOS, AbbrevSectionSymbol, LineSectionSymbol, RangesSymbol);
 }
 
 //
 // When generating dwarf for assembly source files this is called when symbol
 // for a label is created.  If this symbol is not a temporary and is in the
 // section that dwarf is being generated for, save the needed info to create
 // a dwarf label.
 //

llvm/test/MC/ARM/dwarf-asm-multiple-sections.s

 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 5 -fdebug-compilation-dir=/tmp
-// RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF -check-prefix DWARF45 %s
+// RUN: llvm-dwarfdump -v %t | FileCheck --check-prefixes=DWARF,DWARF5 %s
 // RUN: llvm-dwarfdump --debug-line %t | FileCheck -check-prefix DWARF-DL -check-prefix DWARF-DL-5 -DDWVER=5 -DDWFILE=0 %s
-// RUN: llvm-objdump -r %t | FileCheck -check-prefix RELOC -check-prefix RELOC5 %s
+// RUN: llvm-objdump -r %t | FileCheck --check-prefixes=RELOC,RELOC5 %s
 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 4 -fdebug-compilation-dir=/tmp
-// RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF -check-prefix DWARF45 %s
+// RUN: llvm-dwarfdump -v %t | FileCheck -check-prefixes=DWARF,DWARF34,DWARF4 %s
 // RUN: llvm-dwarfdump --debug-line %t | FileCheck -check-prefix DWARF-DL -check-prefix DWARF-DL-4 -DDWVER=4 -DDWFILE=1 %s
-// RUN: llvm-objdump -r %t | FileCheck -check-prefix RELOC -check-prefix RELOC4 %s
+// RUN: llvm-objdump -r %t | FileCheck --check-prefixes=RELOC,RELOC34,RELOC4 %s
 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 3 -fdebug-compilation-dir=/tmp
-// RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF -check-prefix DWARF3 %s
+// RUN: llvm-dwarfdump -v %t | FileCheck --check-prefixes=DWARF,DWARF34,DWARF3 %s
 // RUN: llvm-dwarfdump --debug-line %t | FileCheck -check-prefix DWARF-DL -DDWVER=3 -DDWFILE=1 %s
 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 2 2>&1 | FileCheck -check-prefix VERSION %s
 // RUN: not llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 1 2>&1 | FileCheck -check-prefix DWARF1 %s
 // RUN: not llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 6 2>&1 | FileCheck -check-prefix DWARF6 %s
   .section .text, "ax"
 a:
   mov r0, r0
 
   .section foo, "ax"
 b:
   mov r1, r1
 
 // DWARF: .debug_abbrev contents:
 // DWARF: Abbrev table for offset: 0x00000000
 // DWARF: [1] DW_TAG_compile_unit DW_CHILDREN_yes
 // DWARF3:        DW_AT_stmt_list DW_FORM_data4
-// DWARF45:       DW_AT_stmt_list DW_FORM_sec_offset
+// DWARF4:        DW_AT_stmt_list DW_FORM_sec_offset
+// DWARF5:        DW_AT_stmt_list DW_FORM_sec_offset
 // DWARF3:        DW_AT_ranges    DW_FORM_data4
-// DWARF45:       DW_AT_ranges    DW_FORM_sec_offset
+// DWARF4:        DW_AT_ranges    DW_FORM_sec_offset
+// DWARF5:        DW_AT_ranges    DW_FORM_sec_offset
 // DWARF:         DW_AT_name      DW_FORM_string
 // DWARF:         DW_AT_comp_dir  DW_FORM_string
 // DWARF:         DW_AT_producer  DW_FORM_string
 // DWARF:         DW_AT_language  DW_FORM_data2
 
 // DWARF: .debug_info contents:
 // DWARF: 0x{{[0-9a-f]+}}: DW_TAG_compile_unit [1]
 // DWARF-NOT: DW_TAG_
 // DWARF3:  DW_AT_ranges [DW_FORM_data4]           (0x00000000
-// DWARF45: DW_AT_ranges [DW_FORM_sec_offset]      (0x00000000
+// DWARF4:  DW_AT_ranges [DW_FORM_sec_offset]      (0x00000000
+// DWARF5:  DW_AT_ranges [DW_FORM_sec_offset]      (0x0000000c
 
 // DWARF: 0x{{[0-9a-f]+}}:   DW_TAG_label [2] *
 // DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("a")
 
 // DWARF: 0x{{[0-9a-f]+}}:   DW_TAG_label [2] *
 // DWARF-NEXT: DW_AT_name [DW_FORM_string]     ("b")
 
 

 // DWARF-DL-5-NEXT: 0x0000000000000000     21      0      0   0   0  is_stmt
 // DWARF-DL-5-NEXT: 0x0000000000000004     21      0      0   0   0  is_stmt end_sequence
 // DWARF-DL-4:      0x0000000000000000     17      0      1   0   0  is_stmt
 // DWARF-DL-4-NEXT: 0x0000000000000004     17      0      1   0   0  is_stmt end_sequence
 // DWARF-DL-4-NEXT: 0x0000000000000000     21      0      1   0   0  is_stmt
 // DWARF-DL-4-NEXT: 0x0000000000000004     21      0      1   0   0  is_stmt end_sequence
 
 
-// DWARF: .debug_ranges contents:
-// DWARF: 00000000 ffffffff 00000000
-// DWARF: 00000000 00000000 00000004
-// DWARF: 00000000 ffffffff 00000000
-// DWARF: 00000000 00000000 00000004
-// DWARF: 00000000 <End of list>
-
+// DWARF34:      .debug_ranges contents:
+// DWARF34-NEXT: 00000000 ffffffff 00000000
+// DWARF34-NEXT: 00000000 00000000 00000004
+// DWARF34-NEXT: 00000000 ffffffff 00000000
+// DWARF34-NEXT: 00000000 00000000 00000004
+// DWARF34-NEXT: 00000000 <End of list>
+
+// DWARF5:      .debug_rnglists contents:
+// DWARF5-NEXT: 0x00000000: range list header: length = 0x00000015, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000000
+// DWARF5-NEXT: ranges:
+// DWARF5-NEXT: 0x0000000c: [DW_RLE_start_length]: 0x00000000, 0x00000004 => [0x00000000, 0x00000004)
+// DWARF5-NEXT: 0x00000012: [DW_RLE_start_length]: 0x00000000, 0x00000004 => [0x00000000, 0x00000004)
+// DWARF5-NEXT: 0x00000018: [DW_RLE_end_of_list ]
 
 
 // Offsets are different in DWARF v5 due to different header layout.
 // RELOC: RELOCATION RECORDS FOR [.debug_info]:
 // RELOC4-NEXT: OFFSET TYPE VALUE
 // RELOC4-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC4-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC4-NEXT: 00000010 R_ARM_ABS32 .debug_ranges
 // RELOC5-NEXT: OFFSET TYPE VALUE
 // RELOC5-NEXT: 00000008 R_ARM_ABS32 .debug_abbrev
 // RELOC5-NEXT: 0000000d R_ARM_ABS32 .debug_line
-// RELOC5-NEXT: 00000011 R_ARM_ABS32 .debug_ranges
+// RELOC5-NEXT: 00000011 R_ARM_ABS32 .debug_rnglists
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 foo
 
-// RELOC: RELOCATION RECORDS FOR [.debug_ranges]:
-// RELOC-NEXT: OFFSET TYPE VALUE
-// RELOC-NEXT: 00000004 R_ARM_ABS32 .text
-// RELOC-NEXT: 00000014 R_ARM_ABS32 foo
-
 // RELOC: RELOCATION RECORDS FOR [.debug_aranges]:
 // RELOC-NEXT: OFFSET TYPE VALUE
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_info
 // RELOC-NEXT: 00000010 R_ARM_ABS32 .text
 // RELOC-NEXT: 00000018 R_ARM_ABS32 foo
 
+// RELOC34: RELOCATION RECORDS FOR [.debug_ranges]:
+// RELOC34-NEXT: OFFSET TYPE VALUE
+// RELOC34-NEXT: 00000004 R_ARM_ABS32 .text
+// RELOC34-NEXT: 00000014 R_ARM_ABS32 foo
+
+// RELOC5: RELOCATION RECORDS FOR [.debug_rnglists]:
+// RELOC5-NEXT: OFFSET TYPE VALUE
+// RELOC5-NEXT: 0000000d R_ARM_ABS32 .text
+// RELOC5-NEXT: 00000013 R_ARM_ABS32 foo
+
 
 // VERSION: {{.*}} warning: DWARF2 only supports one section per compilation unit
 
 // DWARF1: Dwarf version 1 is not supported.
 // DWARF6: Dwarf version 6 is not supported.