[DWARF v5] emit DWARF v5 range lists (no support for fission yet)

[wolfgangp]

Summary

This is a first cut at generating DWARF v5 range lists into the .debug_rnglists section. We are generating the range lists table specified by the standard, using the range list entry kinds DW_RLE_offset_pair and DW_RLE_start_length.

We do not support split DWARF yet, because as far as I can tell it requires support for .debug_addr to be able to refer back to locations in the executable.
Also, we don't yet use DW_FORM_rnglistx, so there is no offset table yet.

One of the modified test cases is fission-ranges.ll, which is a bit misleading as we don't support fission yet, but it already had a nice usable module, which avoids duplication.

[aprantl]

Thanks, I think this looks good!

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

651 ↗

(On Diff #155100)

perhaps add a getSkeletonOrInfoHolder() accessor?

lib/MC/MCObjectFileInfo.cpp

271 ↗

(On Diff #155100)

Looks like that fits exactly into the 16 available characters :-)

[wolfgangp]

Thanks for the quick review.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

651 ↗

(On Diff #155100)

That would require a few more changes in unrelated places (this stanza is used a few times elsewhere). I'll do that in a separate commit.

[dblaikie]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

424

It looks like this would end up adding a range list base address to the CU for every range emitted - wouldn't it?

Yeah, looks like it does:

DW_AT_rnglists_base       (0x0000000c)
DW_AT_low_pc      (0x0000000000000000)
DW_AT_ranges      (0x0000002b
   [0x0000000000000000, 0x0000000000000033)
   [0x0000000000000040, 0x0000000000000046)
   [0x0000000000000000, 0x0000000000000006))
DW_AT_rnglists_base       (0x0000000c)

using this input:

bool x;
void f1() {
  f1();
  if (bool b = x) {
    f1();
    f1();
  }
}
__attribute__((section(".text.foo"))) void f2() { }
void f3() { }

Compile with dwarf5 to LLVM IR, reorder the 3 calls to f1 (inserting the first call between the second and third) to cause the scope of 'b' to have a hole in the middle (for that first call to f1) & so to be described by a range list rather than high/low pc.

Looks like the range list base attribute should be added in the same place DW_AT_GNU_ranges_base is set, I think?

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2016–2021

I suspect this section doesn't make sense for DWARFv5 style range lists - there would never be a need to reset the base address to zero, because the forms themselves encode whether they are base address relative or not.

(in the old style range lists, you'd have to reset the base address to zero because the address pairs didn't describe whether they were absolute or relative - so setting it to zero would make the following address pairs absolute (relative to zero). It'd look more like "<base address> <relative pair> <relative pair> <base address 0> <abs pair> <abs pair>" in the new form it's "base address, relative pair, absolute pair, relative pair, etc" - absolute and relative pairs can be interleaved and each is self-descriptive about its absolute or relativeness)

Maybe there are some missing test cases too? Though they should be/probably can be covered by the original testing for UseDwarfRangesBaseAddressSpecifier - but so you might be able to reuse the test input for that ( test/DebugInfo/X86/range_reloc.ll ), but use DWARFv5 instead of UseDwarfRangesBaseAddressSpecfier.

2060–2068

Is it the best tradeoff to produce one shared range list, rather than a separate range list per CU? (I ask/think about that here, because then you wouldn't need a scan through all the CUs to see if any are non-empty)

Looks like the tradeoff is whether the bytes spent in the header are saved by reduced bytes in the debug_info section of being able to use smaller indexes, encoded with shorter encodings. I would imagine in practice for builds with multiple CUs (optimized/LTO situations) there are many ranges and the tradeoff tips in favor of using multiple separate range list lists - one for each CU?

2092–2095

To be honest, I'm not sure why the standard added this offset table - it seems to add extra bytes without any savings I can see (shorter encodings in the debug_info section - using indexes instead of offsets, but it doesn't save relocations or bytes overall, unless I'm missing something?). Meh. (@probinson - any ideas on what the purpose of this indirection is?)

2109–2110

I might rephrase this as "into the .debug_ranges section or, in DWARFv5 the .debug_rnglists section" - the current phrasing sounds like there are two different kinds of things "address ranges" and "rangelists" - to me they're the same thing, encoded differently (depending on the section).

Perhaps others have a different opinion on how this reads, etc?

2115–2123

Looks like the precondition that there are some ranges is already tested here - so no need to check it in emitDebugRnglists? the check there could be another assert, perhaps?

2130–2144

Might be worth splitting this out into a separate function so it's symmetric with emitDebugRnglists?

2222

Missing oxford comma between 'DW_AT_ranges_base' and 'or'. Though it also reads a little ambiguously - in English 'or' can often be read as 'exclusive or' (why some people put 'and/or').

Maybe "This DIE can have any/all of the following attributes: x, y, and z"? No big deal, just some thoughts.

llvm/trunk/test/DebugInfo/X86/rnglists-nobase.ll

11–19

This example might obscure what's really going on by having implicit functions from the global static initializer - it may be more illustrative to provide a more explicit example using section attributes to show which functions are in which sections, etc.

The existence of 3 functions wouldn't itself create ranges (if they were all in a single .text section they'd be covered by a single high/low pc), it's the fact that the static initializer for 'glob' creates functions in a .text.startup section. And that those two static initializer functions aren't emitted together - one, then 'foo', then the other (splitting them up - otherwise there'd be only two ranges, instead of 3)

__attribute__((section(".text.foo"))) void f1() {}
__attribute__((section(".text.bar"))) void f2() {}
__attribute__((section(".text.foo"))) void f3() {}

and I'd expect the optimal range list (in the absence of a debug_addr section) for this source to be:

DW_RLE_base_address (.text.foo+0)
DW_RLE_offset_pair (f1 begin/end relative to .text.foo+0)
DW_RLE_offset_pair (f3 begin/end relative to .text.foo+0)
DW_RLE_start_length (f2 begin, f2 length)

(aside: shorter encodings might be achievable (though maybe not sufficiently worthwhile/only a small improvement) if RLE_start_length implicitly set the base address, and if offset_pair was offset_length instead - but at least there's room to improve this over versions (there's versioning in the header, there's space in the RLE_* enum space, etc))

I think the reason this is missing the base_address+offset_pair opportunity is because the code is predicated on UseDwarfRangesBaseAddressSpecifier - which defaults to off, because I found some DWARF consumers couldn't handle it, I think. But that property isn't relevant to DWARFv5 - so the implementation should be modified to do the same thing no matter the value of 'UseDwarfRangesBaseAddressSpecifier'.

[wolfgangp]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

424

Ah, thanks for finding this. I guess I missed that duplicates are not eliminated when attributes are added to a DIE. AT_rnglists_base should only be added if there is any use of the AT_ranges attribute and it seemed simpler to do this here but it's just driven by the number of ranges in the unit anyway. I'll fix this in a separate review since this one is already closed.

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2060–2068

If we use DW_FORM_rnglistx with DW_AT_ranges, we would definitely save space in .debug_info when the number of ranges gets large, which is where it matters most. Perhaps I will add a FIXME comment effectively saying that when we support DW_FORM_rnglistx (along with the offset table), we'll switch to one rnglist table per CU.

2092–2095

My understanding is that DW_AT_ranges has to either use FORM_sec_offset (which needs to be relocated) or FORM_rnglistx, which is an index into the offset table. So with the offset table and FORM_rnglistx we'd be saving the relocations in .debug_info.

2115–2123

I thought the check here was only used in case the -no-dwarf-ranges-section option was on, so we still need the check for the normal case.

2130–2144

Ok, sounds good.

2222

Seems like this comment needs to be reworked for DWARF 5 anyway with some information on what is DWARF 5 specific and what's not. It also should go into the header, no? Let me take a stab at that in another review.

llvm/trunk/test/DebugInfo/X86/rnglists-nobase.ll

11–19

I'll rework the example in a separate review.

[probinson]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2092–2095

Right, the benefit is eliminating one relocation per DW_AT_ranges (all collapsed into a single relocation per CU for DW_AT_rnglists_base). Overall it would be a slight size increase in the linked file, as each reference would cost an extra byte or two total. Reducing the linker's effort (and what, 24 bytes in the .o per relocation?) seemed like the right tradeoff.

2109–2110

Maybe just "Emit address ranges into the .debug_ranges or .debug_rnglists section." Someday there will be a DWARF 6 and mostly likely it will use the same layout as v5.

2222

Replace all the commas with semicolons, then it reads correctly (the 'or' here is an exclusive or).

[dblaikie]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2092–2095

Right, this certainly saves relocations - but it's not the only way that could've saved relocations.

Rather than introducing FORM_rnglistx, it could've been specified that a DW_AT_ranges value with a data (not section-relative) form is considered as a byte offset relative to the DW_AT_ranges_base value. That way there would be no need for relocations, and no need for the extra indirection table I think... unless I'm missing something.

(@probinson - any ideas why this is the way it is, with the indirection table?)

2092–2095

Right - I get the desire to remove a reloc per range list reference. But I don't understand why that solution created the indirection table in debug_rnglist to go from range list indexes to range list offsets? What problem did that indirection solve compared to having range list offsets (relative to DW_AT_ranges_base or whatnot) directly in the DW_AT_ranges attributes?

2115–2123

Ah, right - good point.

Might still be nice to refactor to have this somewhat complicated expression in one place rather than two. Could skip the old-school pre-v5 ranges emission (even though it's a no-op) when the list is empty? Dunno - no big deal either way, just a thought.

[probinson]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2092–2095

OK I understand the question now.
If you want to encode the range list offset directly into DW_AT_ranges, then you must build the encoded range-list table incrementally so you know what offset to use for DW_AT_ranges. If instead you have an index in DW_AT_ranges, you can allocate a slot in the offset table immediately and build the encoded range-list table later, and fill in the offset table when you do that. This gives the producer more flexibility.

Now, if you as a producer are in fact building the encoded range-list table incrementally already, then your suggestion makes sense, and we can say that (for example) a constant form such as DW_FORM_data means the value is directly an offset from ranges_base. This saves relocations and also the offset table in .debug_rnglists. File it as a proposal on dwarfstd.org if it seems like a worthwhile benefit.

[dblaikie]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2092–2095

Thanks for explaining/your perspective there, Paul!

Yeah - for LLVM at least, we use assembler expressions computing label differences in many places to compute these sort of region-relative offsets, so it doesn't require incremental emission, as such... (sort of does, sort of doesn't - underlying assembly emission logic already has to handle these sort of temporarily unresolved expressions (use them, for example, for high_pc constants (end of function minus start of function), actually, maybe that's the only place we use it currently))

Once this is all implemented, perhaps we can see how much the indirection table takes up - but, yeah, I doubt it'll be a pressing issue/top of anyone's list. Just seemed like a strange inefficiency to me. I wonder if any implementation would actually need it/couldn't use the label difference approach (guess it could be a tradeoff even if they could use it - maybe it'd be slower or more memory intensive to use it, even if it did result in marginally smaller output)

[probinson]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2092–2095

Even after all this time I still don't intuitively think of compilers as effectively emitting assembler first, and that it can do useful stuff like that. Right, we can emit a difference expression to a uleb directive and it all works out.

It's quite possible we just had "index into table" on the brain when we were doing the new encoding for range/location lists, what with debug_str_offsets and debug_addr already in place. but the rationale I described above is what occurred to me, even if compilers can actually be smarter than that. :-)

[probinson]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2016–2021

I suspect this section doesn't make sense for DWARFv5 style range lists - there would never be a need to reset the base address to zero, because the forms themselves encode whether they are base address relative or not.

While I don't dispute any of this, is it okay if we defer this work until after location lists are in? We really want to have a syntactically conforming DWARF 5 before LLVM 7.0 branches, which is just a couple of weeks away. I think what Wolfgang has done meets that criterion (conforming) even if it isn't taking best advantage of the v5 possibilities.

[dblaikie]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2016–2021

Didn't seem like too much work/worth waiting - so I've fixed it (& improved the testing and assembly text (adding helpful comments)) in r337411

llvm/trunk/include/llvm/MC/MCObjectFileInfo.h

protected:
   MCSection *DwarfStrDWOSection;
   MCSection *DwarfLineDWOSection;
   MCSection *DwarfLocDWOSection;
   MCSection *DwarfStrOffDWOSection;
 
   /// The DWARF v5 string offset and address table sections.
   MCSection *DwarfStrOffSection;
   MCSection *DwarfAddrSection;
+  /// The DWARF v5 range list section.
+  MCSection *DwarfRnglistsSection;
+
+  /// The DWARF v5 range list section for fission.
+  MCSection *DwarfRnglistsDWOSection;
 
   // These are for Fission DWP files.
   MCSection *DwarfCUIndexSection;
   MCSection *DwarfTUIndexSection;
 
   /// Section for newer gnu pubnames.
   MCSection *DwarfGnuPubNamesSection;
   /// Section for newer gnu pubtypes.
public:
   }
   const MCSection *getDwarfDebugInlineSection() const {
     return DwarfDebugInlineSection;
   }
   MCSection *getDwarfStrSection() const { return DwarfStrSection; }
   MCSection *getDwarfLocSection() const { return DwarfLocSection; }
   MCSection *getDwarfARangesSection() const { return DwarfARangesSection; }
   MCSection *getDwarfRangesSection() const { return DwarfRangesSection; }
+  MCSection *getDwarfRnglistsSection() const { return DwarfRnglistsSection; }
   MCSection *getDwarfMacinfoSection() const { return DwarfMacinfoSection; }
 
   MCSection *getDwarfDebugNamesSection() const {
     return DwarfDebugNamesSection;
   }
   MCSection *getDwarfAccelNamesSection() const {
     return DwarfAccelNamesSection;
   }
public:
   MCSection *getDwarfTypesDWOSection() const { return DwarfTypesDWOSection; }
   MCSection *getDwarfAbbrevDWOSection() const { return DwarfAbbrevDWOSection; }
   MCSection *getDwarfStrDWOSection() const { return DwarfStrDWOSection; }
   MCSection *getDwarfLineDWOSection() const { return DwarfLineDWOSection; }
   MCSection *getDwarfLocDWOSection() const { return DwarfLocDWOSection; }
   MCSection *getDwarfStrOffDWOSection() const { return DwarfStrOffDWOSection; }
   MCSection *getDwarfStrOffSection() const { return DwarfStrOffSection; }
   MCSection *getDwarfAddrSection() const { return DwarfAddrSection; }
+  MCSection *getDwarfRnglistsDWOSection() const {
+    return DwarfRnglistsDWOSection;
+  }
   MCSection *getDwarfCUIndexSection() const { return DwarfCUIndexSection; }
   MCSection *getDwarfTUIndexSection() const { return DwarfTUIndexSection; }
   MCSection *getDwarfSwiftASTSection() const { return DwarfSwiftASTSection; }
 
   MCSection *getCOFFDebugSymbolsSection() const {
     return COFFDebugSymbolsSection;
   }
   MCSection *getCOFFDebugTypesSection() const {

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::constructScopeDIE(
 
   FinalChildren.push_back(std::move(ScopeDIE));
 }
 
 void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
                                          SmallVector<RangeSpan, 2> Range) {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
 
-  // Emit offset in .debug_range as a relocatable label. emitDIE will handle
-  // emitting it appropriately.
+  // Emit the offset into .debug_ranges or .debug_rnglists as a relocatable
+  // label. emitDIE() will handle emitting it appropriately.
   const MCSymbol *RangeSectionSym =
-      TLOF.getDwarfRangesSection()->getBeginSymbol();
+      DD->getDwarfVersion() >= 5
+          ? TLOF.getDwarfRnglistsSection()->getBeginSymbol()
+          : TLOF.getDwarfRangesSection()->getBeginSymbol();
 
   RangeSpanList List(Asm->createTempSymbol("debug_ranges"), std::move(Range));
 
   // Under fission, ranges are specified by constant offsets relative to the
   // CU's DW_AT_GNU_ranges_base.
-  if (isDwoUnit())
+  // FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under
+  // fission until we support the forms using the .debug_addr section
+  // (DW_RLE_startx_endx etc.).
+  if (isDwoUnit()) {
+    if (DD->getDwarfVersion() < 5)
       addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                       RangeSectionSym);
-  else
+  } else {
     addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                     RangeSectionSym);
+    if (DD->getDwarfVersion() >= 5)
+      addRnglistsBase();
+  }
 
   // Add the range list to the set of ranges to be emitted.
   (Skeleton ? Skeleton : this)->CURangeLists.push_back(std::move(List));
 }
 
 void DwarfCompileUnit::attachRangesOrLowHighPC(
     DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
   if (Ranges.size() == 1 || !DD->useRangesSection()) {

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   void emitDebugLocDWO();
 
   /// Emit address ranges into a debug aranges section.
   void emitDebugARanges();
 
   /// Emit address ranges into a debug ranges section.
   void emitDebugRanges();
 
+  /// Emit range lists into a DWARF v5 debug rnglists section.
+  void emitDebugRnglists();
+
   /// Emit macros into a debug macinfo section.
   void emitDebugMacinfo();
   void emitMacro(DIMacro &M);
   void emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U);
   void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U);
 
   /// DWARF 5 Experimental Split Dwarf Emitters
 

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::beginModule() {
 
   // Create the symbol that designates the start of the unit's contribution
   // to the string offsets table. In a split DWARF scenario, only the skeleton
   // unit has the DW_AT_str_offsets_base attribute (and hence needs the symbol).
   if (useSegmentedStringOffsetsTable())
     (useSplitDwarf() ? SkeletonHolder : InfoHolder)
         .setStringOffsetsStartSym(Asm->createTempSymbol("str_offsets_base"));
 
+  // Create the symbol that designates the start of the DWARF v5 range list
+  // table. It is located past the header and before the offsets table.
+  if (getDwarfVersion() >= 5)
+    (useSplitDwarf() ? SkeletonHolder : InfoHolder)
+        .setRnglistsTableBaseSym(Asm->createTempSymbol("rnglists_table_base"));
+
   for (DICompileUnit *CUNode : M->debug_compile_units()) {
     // FIXME: Move local imported entities into a list attached to the
     // subprogram, then this search won't be needed and a
     // getImportedEntities().empty() test should go below with the rest.
     bool HasNonLocalImportedEntities = llvm::any_of(
         CUNode->getImportedEntities(), [](const DIImportedEntity *IE) {
           return !isa<DILocalScope>(IE->getScope());
         });
if (useSplitDwarf()) {
       }
       // We don't keep track of which addresses are used in which CU so this
       // is a bit pessimistic under LTO.
       if (!AddrPool.isEmpty()) {
         const MCSymbol *Sym = TLOF.getDwarfAddrSection()->getBeginSymbol();
         SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_addr_base,
                               Sym, Sym);
       }
-      if (!SkCU->getRangeLists().empty()) {
+      if (getDwarfVersion() < 5 && !SkCU->getRangeLists().empty()) {
         const MCSymbol *Sym = TLOF.getDwarfRangesSection()->getBeginSymbol();
         SkCU->addSectionLabel(SkCU->getUnitDie(), dwarf::DW_AT_GNU_ranges_base,
                               Sym, Sym);
       }
     }
 
     // If we have code split among multiple sections or non-contiguous
     // ranges of code then emit a DW_AT_ranges attribute on the unit that will
for (DwarfCompileUnit *CU : CUs) {
     }
 
     Asm->OutStreamer->AddComment("ARange terminator");
     Asm->OutStreamer->EmitIntValue(0, PtrSize);
     Asm->OutStreamer->EmitIntValue(0, PtrSize);
   }
 }
 
-/// Emit a single range list.
+/// Emit a single range list. We handle both DWARF v5 and earlier.
 static void emitRangeList(AsmPrinter *Asm, DwarfCompileUnit *CU,
                           const RangeSpanList &List) {
+
+  auto DwarfVersion = CU->getDwarfVersion();
   // Emit our symbol so we can find the beginning of the range.
   Asm->OutStreamer->EmitLabel(List.getSym());
   // Gather all the ranges that apply to the same section so they can share
   // a base address entry.
   MapVector<const MCSection *, std::vector<const RangeSpan *>> SectionRanges;
   // Size for our labels.
   auto Size = Asm->MAI->getCodePointerSize();
 
   for (const RangeSpan &Range : List.getRanges())
     SectionRanges[&Range.getStart()->getSection()].push_back(&Range);
 
   auto *CUBase = CU->getBaseAddress();
   bool BaseIsSet = false;
   for (const auto &P : SectionRanges) {
     // Don't bother with a base address entry if there's only one range in
     // this section in this range list - for example ranges for a CU will
     // usually consist of single regions from each of many sections
     // (-ffunction-sections, or just C++ inline functions) except under LTO
     // or optnone where there may be holes in a single CU's section
-    // contrubutions.
+    // contributions.
     auto *Base = CUBase;
     if (!Base && P.second.size() > 1 && UseDwarfRangesBaseAddressSpecifier) {
       BaseIsSet = true;
       // FIXME/use care: This may not be a useful base address if it's not
       // the lowest address/range in this object.
       Base = P.second.front()->getStart();
+      if (DwarfVersion >= 5)
+        Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_base_address, 1);
+      else
         Asm->OutStreamer->EmitIntValue(-1, Size);
       Asm->OutStreamer->EmitSymbolValue(Base, Size);
     } else if (BaseIsSet) {
       BaseIsSet = false;
+      if (DwarfVersion >= 5)
+        Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_base_address, 1);
+      else
         Asm->OutStreamer->EmitIntValue(-1, Size);
       Asm->OutStreamer->EmitIntValue(0, Size);
     }
 
     for (const auto *RS : P.second) {
       const MCSymbol *Begin = RS->getStart();
       const MCSymbol *End = RS->getEnd();
       assert(Begin && "Range without a begin symbol?");
       assert(End && "Range without an end symbol?");
       if (Base) {
+        if (DwarfVersion >= 5) {
+          // Emit DW_RLE_offset_pair when we have a base.
+          Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_offset_pair, 1);
+          Asm->EmitLabelDifferenceAsULEB128(Begin, Base);
+          Asm->EmitLabelDifferenceAsULEB128(End, Base);
+        } else {
           Asm->EmitLabelDifference(Begin, Base, Size);
           Asm->EmitLabelDifference(End, Base, Size);
+        }
+      } else if (DwarfVersion >= 5) {
+        Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_start_length, 1);
+        Asm->OutStreamer->EmitSymbolValue(Begin, Size);
+        Asm->EmitLabelDifferenceAsULEB128(End, Begin);
       } else {
         Asm->OutStreamer->EmitSymbolValue(Begin, Size);
         Asm->OutStreamer->EmitSymbolValue(End, Size);
       }
     }
   }
-
-  // And terminate the list with two 0 values.
+  if (DwarfVersion >= 5)
+    Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_end_of_list, 1);
+  else {
+    // Terminate the list with two 0 values.
     Asm->OutStreamer->EmitIntValue(0, Size);
     Asm->OutStreamer->EmitIntValue(0, Size);
   }
+}
+
+void DwarfDebug::emitDebugRnglists() {
+
+  // Don't emit a rangelist table if there are no ranges.
+  if (llvm::all_of(CUMap,
+                   [](const decltype(CUMap)::const_iterator::value_type &Pair) {
+                     DwarfCompileUnit *TheCU = Pair.second;
+                     if (auto *Skel = TheCU->getSkeleton())
+                       TheCU = Skel;
+                     return TheCU->getRangeLists().empty();
+                   }))
+    return;
+
+  assert(getDwarfVersion() >= 5 && "Dwarf version must be 5 or greater");
+  // FIXME: As long as we don't support DW_RLE_base_addrx, we cannot generate
+  // any tables in the .debug_rnglists.dwo section.
+  Asm->OutStreamer->SwitchSection(
+      Asm->getObjFileLowering().getDwarfRnglistsSection());
+  // The length is described by a starting label right after the length field
+  // and an end label.
+  MCSymbol *TableStart = Asm->createTempSymbol("debug_rnglist_table_start");
+  MCSymbol *TableEnd = Asm->createTempSymbol("debug_rnglist_table_end");
+  // Build the range table header, which starts with the length field.
+  Asm->EmitLabelDifference(TableEnd, TableStart, 4);
+  Asm->OutStreamer->EmitLabel(TableStart);
+  // Version number (DWARF v5 and later).
+  Asm->emitInt16(getDwarfVersion());
+  // Address size.
+  Asm->emitInt8(Asm->MAI->getCodePointerSize());
+  // Segment selector size.
+  Asm->emitInt8(0);
+
+  MCSymbol *RnglistTableBaseSym =
+      (useSplitDwarf() ? SkeletonHolder : InfoHolder).getRnglistsTableBaseSym();
+
+  // FIXME: Generate the offsets table and use DW_FORM_rnglistx with the
+  // DW_AT_ranges attribute. Until then set the number of offsets to 0.
+  Asm->emitInt32(0);
+  Asm->OutStreamer->EmitLabel(RnglistTableBaseSym);
+
+  // Emit the individual range lists.
+  for (const auto &I : CUMap) {
+    DwarfCompileUnit *TheCU = I.second;
+    if (auto *Skel = TheCU->getSkeleton())
+      TheCU = Skel;
+    for (const RangeSpanList &List : TheCU->getRangeLists())
+      emitRangeList(Asm, TheCU, List);
+  }
+
+  Asm->OutStreamer->EmitLabel(TableEnd);
+}
 
-/// Emit address ranges into a debug ranges section.
+/// Emit address ranges into the .debug_ranges section or DWARF v5 rangelists
+/// into the .debug_rnglists section.
 void DwarfDebug::emitDebugRanges() {
   if (CUMap.empty())
     return;
 
   if (!useRangesSection()) {
     assert(llvm::all_of(
                CUMap,
                [](const decltype(CUMap)::const_iterator::value_type &Pair) {
                  return Pair.second->getRangeLists().empty();
                }) &&
            "No debug ranges expected.");
     return;
   }
 
+  if (getDwarfVersion() >= 5) {
+    emitDebugRnglists();
+    return;
+  }
+
   // Start the dwarf ranges section.
   Asm->OutStreamer->SwitchSection(
       Asm->getObjFileLowering().getDwarfRangesSection());
 
   // Grab the specific ranges for the compile units in the module.
   for (const auto &I : CUMap) {
     DwarfCompileUnit *TheCU = I.second;
 
     if (auto *Skel = TheCU->getSkeleton())
       TheCU = Skel;
 
     // Iterate over the misc ranges for the compile units in the module.
     for (const RangeSpanList &List : TheCU->getRangeLists())
       emitRangeList(Asm, TheCU, List);
   }
 }
 
 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
   for (auto *MN : Nodes) {
     if (auto *M = dyn_cast<DIMacro>(MN))
       emitMacro(*M);
     else if (auto *F = dyn_cast<DIMacroFile>(MN))
       emitMacroFile(*F, U);
void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
 
   addGnuPubAttributes(*NewU, Die);
 
   SkeletonHolder.addUnit(std::move(NewU));
 }
 
 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
-// DW_AT_addr_base, DW_AT_ranges_base.
+// DW_AT_addr_base, DW_AT_ranges_base or DW_AT_rnglists_base.
 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
 
   auto OwnedUnit = llvm::make_unique<DwarfCompileUnit>(
       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
   DwarfCompileUnit &NewCU = *OwnedUnit;
   NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
 
   NewCU.initStmtList();

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfFile.h

class DwarfFile {
   SmallVector<std::unique_ptr<DwarfCompileUnit>, 1> CUs;
 
   DwarfStringPool StrPool;
 
   /// DWARF v5: The symbol that designates the start of the contribution to
   /// the string offsets table. The contribution is shared by all units.
   MCSymbol *StringOffsetsStartSym = nullptr;
 
+  /// DWARF v5: The symbol that designates the base of the range list table.
+  /// The table is shared by all units.
+  MCSymbol *RnglistsTableBaseSym = nullptr;
+
   /// The variables of a lexical scope.
   struct ScopeVars {
     /// We need to sort Args by ArgNo and check for duplicates. This could also
     /// be implemented as a list or vector + std::lower_bound().
     std::map<unsigned, DbgVariable *> Args;
     SmallVector<DbgVariable *, 8> Locals;
   };
   /// Collection of DbgVariables of each lexical scope.
public:
 
   /// Returns the string pool.
   DwarfStringPool &getStringPool() { return StrPool; }
 
   MCSymbol *getStringOffsetsStartSym() const { return StringOffsetsStartSym; }
 
   void setStringOffsetsStartSym(MCSymbol *Sym) { StringOffsetsStartSym = Sym; }
 
+  MCSymbol *getRnglistsTableBaseSym() const { return RnglistsTableBaseSym; }
+
+  void setRnglistsTableBaseSym(MCSymbol *Sym) { RnglistsTableBaseSym = Sym; }
+
   /// \returns false if the variable was merged with a previous one.
   bool addScopeVariable(LexicalScope *LS, DbgVariable *Var);
 
   DenseMap<LexicalScope *, ScopeVars> &getScopeVariables() {
     return ScopeVariables;
   }
 
   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfUnit.h

protected:
   bool isShareableAcrossCUs(const DINode *D) const;
 
 public:
   // Accessors.
   AsmPrinter* getAsmPrinter() const { return Asm; }
   uint16_t getLanguage() const { return CUNode->getSourceLanguage(); }
   const DICompileUnit *getCUNode() const { return CUNode; }
 
+  uint16_t getDwarfVersion() const { return DD->getDwarfVersion(); }
+
   /// Return true if this compile unit has something to write out.
   bool hasContent() const { return getUnitDie().hasChildren(); }
 
   /// Get string containing language specific context for a global name.
   ///
   /// Walks the metadata parent chain in a language specific manner (using the
   /// compile unit language) and returns it as a string. This is done at the
   /// metadata level because DIEs may not currently have been added to the
public:
   }
 
   /// Emit the header for this unit, not including the initial length field.
   virtual void emitHeader(bool UseOffsets) = 0;
 
   /// Add the DW_AT_str_offsets_base attribute to the unit DIE.
   void addStringOffsetsStart();
 
+  /// Add the DW_AT_rnglists_base attribute to the unit DIE.
+  void addRnglistsBase();
+
   virtual DwarfCompileUnit &getCU() = 0;
 
   void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy);
 
   /// addSectionDelta - Add a label delta attribute data and value.
   DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                                       const MCSymbol *Hi, const MCSymbol *Lo);
 

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 }
 
 void DwarfUnit::addStringOffsetsStart() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
                   DU->getStringOffsetsStartSym(),
                   TLOF.getDwarfStrOffSection()->getBeginSymbol());
 }
+
+void DwarfUnit::addRnglistsBase() {
+  assert(DD->getDwarfVersion() >= 5 &&
+         "DW_AT_rnglists_base requires DWARF version 5 or later");
+  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
+  addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base,
+                  DU->getRnglistsTableBaseSym(),
+                  TLOF.getDwarfRnglistsSection()->getBeginSymbol());
+}

llvm/trunk/lib/MC/MCObjectFileInfo.cpp

DwarfLocSection =
       Ctx->getMachOSection("__DWARF", "__debug_loc", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "section_debug_loc");
   DwarfARangesSection =
       Ctx->getMachOSection("__DWARF", "__debug_aranges", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfRangesSection =
       Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "debug_range");
+  DwarfRnglistsSection =
+      Ctx->getMachOSection("__DWARF", "__debug_rnglists", MachO::S_ATTR_DEBUG,
+                           SectionKind::getMetadata(), "debug_range");
   DwarfMacinfoSection =
       Ctx->getMachOSection("__DWARF", "__debug_macinfo", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "debug_macinfo");
   DwarfDebugInlineSection =
       Ctx->getMachOSection("__DWARF", "__debug_inlined", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfCUIndexSection =
       Ctx->getMachOSection("__DWARF", "__debug_cu_index", MachO::S_ATTR_DEBUG,
DwarfAccelNamespaceSection =
       Ctx->getELFSection(".apple_namespaces", ELF::SHT_PROGBITS, 0);
   DwarfAccelTypesSection =
       Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0);
 
   // String Offset and Address Sections
   DwarfStrOffSection =
       Ctx->getELFSection(".debug_str_offsets", DebugSecType, 0);
   DwarfAddrSection = Ctx->getELFSection(".debug_addr", DebugSecType, 0);
+  DwarfRnglistsSection = Ctx->getELFSection(".debug_rnglists", DebugSecType, 0);
 
   // Fission Sections
   DwarfInfoDWOSection =
       Ctx->getELFSection(".debug_info.dwo", DebugSecType, 0);
   DwarfTypesDWOSection =
       Ctx->getELFSection(".debug_types.dwo", DebugSecType, 0);
   DwarfAbbrevDWOSection =
       Ctx->getELFSection(".debug_abbrev.dwo", DebugSecType, 0);
   DwarfStrDWOSection =
       Ctx->getELFSection(".debug_str.dwo", DebugSecType,
                          ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
   DwarfLineDWOSection =
       Ctx->getELFSection(".debug_line.dwo", DebugSecType, 0);
   DwarfLocDWOSection =
       Ctx->getELFSection(".debug_loc.dwo", DebugSecType, 0);
   DwarfStrOffDWOSection =
       Ctx->getELFSection(".debug_str_offsets.dwo", DebugSecType, 0);
+  DwarfRnglistsDWOSection =
+      Ctx->getELFSection(".debug_rnglists.dwo", DebugSecType, 0);
 
   // DWP Sections
   DwarfCUIndexSection =
       Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
   DwarfTUIndexSection =
       Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
 
   StackMapSection =

llvm/trunk/test/DebugInfo/X86/fission-ranges.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 ; RUN: llvm-objdump -h %t | FileCheck --check-prefix=HDR %s
 
+; RUN: llc -dwarf-version=5 -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
+; RUN: llvm-dwarfdump -v %t | FileCheck --check-prefix=V5RNGLISTS %s
+
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NEXT: DW_AT_stmt_list
 ; CHECK-NEXT: DW_AT_GNU_dwo_name
 ; CHECK-NEXT: DW_AT_comp_dir
 ; CHECK-NEXT: DW_AT_GNU_dwo_id
 ; CHECK-NEXT: DW_AT_GNU_addr_base [DW_FORM_sec_offset]                   (0x00000000)
 
-
 ; CHECK: .debug_info.dwo contents:
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[A:0x[0-9a-z]*]]
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[E:0x[0-9a-z]*]]
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[B:0x[0-9a-z]*]]
 ; CHECK: DW_AT_location [DW_FORM_sec_offset]   ([[D:0x[0-9a-z]*]]
 ; CHECK: DW_AT_ranges [DW_FORM_sec_offset]   (0x00000000
 ; CHECK-NOT: .debug_loc contents:
 ; CHECK-NOT: Beginning address offset
 ; CHECK: .debug_loc.dwo contents:
 
 ; Don't assume these locations are entirely correct - feel free to update them
 ; if they've changed due to a bugfix, change in register allocation, etc.
 
 ; CHECK:      [[A]]:
 ; CHECK-NEXT:   Addr idx 2 (w/ length 169): DW_OP_consts +0, DW_OP_stack_value
 ; CHECK-NEXT:   Addr idx 3 (w/ length 25): DW_OP_reg0 RAX
 ; CHECK:      [[E]]:
 ; CHECK-NEXT:   Addr idx 4 (w/ length 19): DW_OP_reg0 RAX
 ; CHECK:      [[B]]:
 ; CHECK-NEXT:   Addr idx 5 (w/ length 17): DW_OP_reg0 RAX
 ; CHECK:      [[D]]:
 ; CHECK-NEXT:   Addr idx 6 (w/ length 17): DW_OP_reg0 RAX
 
-
 ; Make sure we don't produce any relocations in any .dwo section (though in particular, debug_info.dwo)
 ; HDR-NOT: .rela.{{.*}}.dwo
 
 ; Make sure we have enough stuff in the debug_addr to cover the address indexes
 ; (6 is the last index in debug_loc.dwo, making 7 entries of 8 bytes each, 7 * 8
 ; == 56 base 10 == 38 base 16)
 
 ; HDR: .debug_addr 00000038
 ; HDR-NOT: .rela.{{.*}}.dwo
 
+; Check for the existence of a DWARF v5-style range list table in the .debug_rnglists
+; section and that the compile unit has a DW_AT_rnglists_base attribute.
+; The table should contain at least one rangelist with at least 2 individual ranges.
+
+; V5RNGLISTS:      .debug_info contents:
+; V5RNGLISTS:      DW_TAG_compile_unit
+; V5RNGLISTS-NOT:  DW_TAG
+; V5RNGLISTS:      DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x0000000c)
+; V5RNGLISTS:      .debug_rnglists contents:
+; V5RNGLISTS-NEXT: 0x00000000: Range List Header: length = 0x00000014, version = 0x0005,
+; V5RNGLISTS-SAME: addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+; V5RNGLISTS-NEXT: Ranges:
+; V5RNGLISTS-NEXT: 0x0000000c: [DW_RLE_offset_pair]:
+; V5RNGLISTS-NEXT: 0x0000000f: [DW_RLE_offset_pair]:
+; V5RNGLISTS:      0x{{[0-9a-f]+}}: [DW_RLE_end_of_list]
+
 ; From the code:
 
 ; extern int c;
 ; static void foo (int p)
 ; {
 ;   int a, b; 
 ;   unsigned int d, e;
 

llvm/trunk/test/DebugInfo/X86/rnglists-nobase.ll

+; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t < %s
+; RUN: llvm-dwarfdump -v %t | FileCheck %s
+
+; We make sure that we generate DW_RLE_start_length range list entries when 
+; we do not have a base, which is the case when functions go into different
+; sections. We should have 3 individual range list entries because there are
+; 3 functions.
+; 
+; From the following source:
+;
+; class A
+; {
+; public:
+;   A();
+; };
+; 
+; static A glob;
+; void foo() {
+; }
+;
+; Compile with clang -O1 -gdwarf-5 -S -emit-llvm
+;
+; CHECK:      .debug_rnglists contents:
+; CHECK-NEXT: 0x00000000: Range List Header: length = 0x00000027, version = 0x0005,
+; CHECK-SAME: addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+; CHECK-NEXT: Ranges:
+; CHECK-NEXT: 0x0000000c: [DW_RLE_start_length]:
+; CHECK-NEXT: 0x00000016: [DW_RLE_start_length]:
+; CHECK-NEXT: 0x00000020: [DW_RLE_start_length]:
+; CHECK-NEXT: 0x0000002a: [DW_RLE_end_of_list ]
+
+%class.A = type { i8 }
+
+@_ZL4glob = internal global %class.A zeroinitializer, align 1, !dbg !0
[e-mail]_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_xx.cpp, i8* null }]
+
+; Function Attrs: uwtable
+define internal fastcc void @__cxx_global_var_init() unnamed_addr section ".text.startup" !dbg !16 {
+entry:
+  tail call void @_ZN1AC1Ev(%class.A* nonnull @_ZL4glob), !dbg !19
+  ret void, !dbg !19
+}
+
+declare dso_local void @_ZN1AC1Ev(%class.A*) unnamed_addr
+
+; Function Attrs: norecurse nounwind readnone uwtable
+define dso_local void @_Z3foov() local_unnamed_addr !dbg !20 {
+entry:
+  ret void, !dbg !21
+}
+
+; Function Attrs: uwtable
+define internal void @_GLOBAL__sub_I_xx.cpp() section ".text.startup" !dbg !22 {
+entry:
+  tail call fastcc void @__cxx_global_var_init(), !dbg !24
+  ret void
+}
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!12, !13, !14}
+!llvm.ident = !{!15}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "glob", linkageName: "_ZL4glob", scope: !2, file: !3, line: 7, type: !6, isLocal: true, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 (trunk 335191)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "test.cpp", directory: "/home/test", checksumkind: CSK_MD5, checksum: "535784cf49522e3a6d1166f6c4e482ba")
+!4 = !{}
+!5 = !{!0}
+!6 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "A", file: !3, line: 1, size: 8, flags: DIFlagTypePassByValue, elements: !7, identifier: "_ZTS1A")
+!7 = !{!8}
+!8 = !DISubprogram(name: "A", scope: !6, file: !3, line: 4, type: !9, isLocal: false, isDefinition: false, scopeLine: 4, flags: DIFlagPublic | DIFlagPrototyped, isOptimized: true)
+!9 = !DISubroutineType(types: !10)
+!10 = !{null, !11}
+!11 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!12 = !{i32 2, !"Dwarf Version", i32 5}
+!13 = !{i32 2, !"Debug Info Version", i32 3}
+!14 = !{i32 1, !"wchar_size", i32 4}
+!15 = !{!"clang version 7.0.0 (trunk 335191)"}
+!16 = distinct !DISubprogram(name: "__cxx_global_var_init", scope: !3, file: !3, line: 7, type: !17, isLocal: true, isDefinition: true, scopeLine: 7, flags: DIFlagPrototyped, isOptimized: true, unit: !2, retainedNodes: !4)
+!17 = !DISubroutineType(types: !18)
+!18 = !{null}
+!19 = !DILocation(line: 7, column: 10, scope: !16)
+!20 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !3, file: !3, line: 9, type: !17, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: true, unit: !2, retainedNodes: !4)
+!21 = !DILocation(line: 10, column: 1, scope: !20)
+!22 = distinct !DISubprogram(linkageName: "_GLOBAL__sub_I_xx.cpp", scope: !3, file: !3, type: !23, isLocal: true, isDefinition: true, flags: DIFlagArtificial, isOptimized: true, unit: !2, retainedNodes: !4)
+!23 = !DISubroutineType(types: !4)
+!24 = !DILocation(line: 0, scope: !22)