[DWARF] - Take relocations in account when extracting ranges from .debug_ranges

[grimar]

Summary

I found this when investigated "Bug 32319 - .gdb_index is broken/incomplete" for LLD.

When we have object file with .debug_ranges section it may be filled with zeroes.
Relocations are exist in file to relocate this zeroes into real values later, but until that
a pair of zeroes is treated as terminator. And DWARF parser thinks there is no ranges at all
when I am trying to collect address ranges for building .gdb_index.

Solution implemented in this patch is to take relocations in account when parsing ranges.
FWIW DWARFFormValue::extractValue() already do that for calculating DW_AT_low_pc/DW_AT_high_pc,
when ranges are not involved. So solution seems to be consistent with existent code.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFContext.h

234

I don't think there is a ranges.dwo section, is there? The ranges section is in the .o file, always. (the DWARF5 rnglists can go in the .dwo, though)

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

25–31

Should/can/could this be refactored to use the same code as the case you mentioned was already in place for DW_FORM_addr (high/low pc)?

test/DebugInfo/dwarfdump-ranges-unrelocated.s

13–15

Would 2 functions (also probably simpler for them to be void and empty functions) would suffice to give the CU a DW_AT_ranges rather than high/low pc?

[grimar]

Thanks for review, David ! All comments were addressed.

include/llvm/DebugInfo/DWARF/DWARFContext.h

234

There is no ranges.dwo in my testcase, but I had to change this API too, because I changed DWARFUnitSectionBase::parseImpl (please see DWARFUnit.h) to take const DWARFSection *RS.

I think I can't change return type for getRangeSection() without changing return type for getRangeDWOSection(),
because DWARFUnitSectionBase::parse() pushes getRangeSection(), but DWARFUnitSectionBase::parseDWO() pushes C.getRangeDWOSection() for RS.

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

25–31

Done. There was many places that could use some helper method like getAddress() instead of inlined applying relocations to values. All of them now uses getRelocatedValue() introduced in this patch.

test/DebugInfo/dwarfdump-ranges-unrelocated.s

13–15

Yes, fixed. I added nop by myself to asm code though, thats to show that ranges are different explicitly.
I leaved single empty function to show we can dump ranges [0x0, 0x0] correctly now.
Previous diff was not able to do that, though that was not a real problem probably, LLD anyways supposed to use
LoadedObjectInfo::getSectionLoadAddress, so values would never be [0x0, 0x0] even for empty method, not sure about other possible users though.

[grimar]

I suggest to split refactoring change that introduced getRelocatedValue() to different patch, because it touches many
places and landing it separatelly will allow to reduce amount of changes in this patch (after rebasing) and simplify the review probably.
I'll post it very soon.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFContext.h

234

Looks like a bug in the code - since there is no range.dwo section this probably causes llvm-dwarfdump to be less good than it could be. If parseDWOCompileUnits passed getRangeSection, then at least when dumping an unsplit split-dwarf file (ie: the object file that comes out of the clang frontend before objcopy is run on it to split the .dwo sections) it would dump ranges correctly, I think.

If you like - you could send a separate patch befoer or after this one to clean that up (create a small example object file with ranges in it - show that changing that call in parseDWOCompileUnits does cause the ranges to be correctly dumped - and then also strip out all the ranges.dwo stuff)

Ah, not a bug, because RangeDWOSection is the same as RangeSection... just confusing.

The support for rnglists.dwo (which I'm guessing is what the original comment that setup RangesDWO was referring to)will look very different from all of this anyway, I think.

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

52

Isn't this applying the relocation twice? The entry's Start/EndAddress are already relocated above so there shouldn't be any need to look up relocations again here, should there?

This is to handle the case where a function wasn't selected (comdat, etc) & so its base address resolves to zero by the linker - and specifically when such a function was empty anyway? (eg: "int f()" - absolutely no instructions, so begin/end are the same address)? /maybe/ that's correct/useful, but I doubt it. I'm not sure how important it is to support zero-length ranges in a range list... maybe for debugging weird DWARF output, etc.

[grimar]

• Rebased.
• Addressed review comments.

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

52

Isn't this applying the relocation twice? The entry's Start/EndAddress are already relocated above so there shouldn't be >any need to look up relocations again here, should there?

That not always enough, I tried to resolve corner case here. If we have asm code like one from testcase:

.section .text.foo1,"ax",@progbits
.Lfunc_begin0:
.Lfunc_end0:

Then if I dump result object file with llvm-dwarfdump, start/end address are [0x0, 0x0] both before and after relocations applied above. Because address of section is zero and relocation just adds zero size of range to end address, what leaves is as zero.
So dumping prints end marker for a entry. I think the only way to handle that is check that we do not have relocations that points to end marker [0x0, 0x0].

This is to handle the case where a function wasn't selected (comdat, etc) & so its base address resolves to zero by the >linker - and specifically when such a function was empty anyway? (eg: "int f()" - absolutely no instructions, so begin/end >are the same address)? /maybe/ that's correct/useful, but I doubt it.

So linker is not involved, I just noticed this when dumped testcase object. I am not sure how much is it useful in general.
(its not what I need for LLD and not intention of this patch).
Just supposed that would be more correct for llvm-dwarfdump than report <end of list> in output for a "valid" range.

I'm not sure how important it is to support zero->length ranges in a range list... maybe for debugging weird DWARF >output, etc.

Yeah, I am not sure also. I removed that change from patch and modified testcase to have no zero length ranges for now.

[dblaikie]

Looks good - check if the test case would be simpler with -gmlt rather than -gsplit-dwarf, and use that if so, otherwise commit whenever you're ready.

test/DebugInfo/dwarfdump-ranges-unrelocated.s

11

I'd probably not use -gsplit-dwarf in this test case, it doesn't seem to be important/relevant (though I suppose it'll make the DWARF longer as it'll now include all the subprogram DIEs, etc) - maybe -gmlt would suffice?

[grimar]

test/DebugInfo/dwarfdump-ranges-unrelocated.s

11

Yes, you right, -gmlt is suffice. And it makes output easier for reducing into current testcase.
Thanks !

include/llvm/DebugInfo/DWARF/DWARFCompileUnit.h

 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 
 namespace llvm {
 
 class DWARFCompileUnit : public DWARFUnit {
 public:
   DWARFCompileUnit(DWARFContext &Context, const DWARFSection &Section,
-                   const DWARFDebugAbbrev *DA, StringRef RS, StringRef SS,
-                   StringRef SOS, StringRef AOS, StringRef LS, bool LE,
-                   bool IsDWO, const DWARFUnitSectionBase &UnitSection,
+                   const DWARFDebugAbbrev *DA, const DWARFSection *RS,
+                   StringRef SS, StringRef SOS, StringRef AOS, StringRef LS,
+                   bool LE, bool IsDWO, const DWARFUnitSectionBase &UnitSection,
                    const DWARFUnitIndex::Entry *Entry)
       : DWARFUnit(Context, Section, DA, RS, SS, SOS, AOS, LS, LE, IsDWO,
                   UnitSection, Entry) {}
 
   // VTable anchor.
   ~DWARFCompileUnit() override;
 
   void dump(raw_ostream &OS);
 
   static const DWARFSectionKind Section = DW_SECT_INFO;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFCOMPILEUNIT_H

include/llvm/DebugInfo/DWARF/DWARFContext.h

public:
   virtual const TypeSectionMap &getTypesSections() = 0;
   virtual StringRef getAbbrevSection() = 0;
   virtual const DWARFSection &getLocSection() = 0;
   virtual StringRef getARangeSection() = 0;
   virtual StringRef getDebugFrameSection() = 0;
   virtual StringRef getEHFrameSection() = 0;
   virtual const DWARFSection &getLineSection() = 0;
   virtual StringRef getStringSection() = 0;
-  virtual StringRef getRangeSection() = 0;
+  virtual const DWARFSection& getRangeSection() = 0;
   virtual StringRef getMacinfoSection() = 0;
   virtual StringRef getPubNamesSection() = 0;
   virtual StringRef getPubTypesSection() = 0;
   virtual StringRef getGnuPubNamesSection() = 0;
   virtual StringRef getGnuPubTypesSection() = 0;
 
   // Sections for DWARF5 split dwarf proposal.
   virtual const DWARFSection &getInfoDWOSection() = 0;
   virtual const TypeSectionMap &getTypesDWOSections() = 0;
   virtual StringRef getAbbrevDWOSection() = 0;
   virtual const DWARFSection &getLineDWOSection() = 0;
   virtual const DWARFSection &getLocDWOSection() = 0;
   virtual StringRef getStringDWOSection() = 0;
   virtual StringRef getStringOffsetDWOSection() = 0;
-  virtual StringRef getRangeDWOSection() = 0;
+  virtual const DWARFSection &getRangeDWOSection() = 0;
   virtual StringRef getAddrSection() = 0;
   virtual const DWARFSection& getAppleNamesSection() = 0;
   virtual const DWARFSection& getAppleTypesSection() = 0;
   virtual const DWARFSection& getAppleNamespacesSection() = 0;
   virtual const DWARFSection& getAppleObjCSection() = 0;
   virtual StringRef getCUIndexSection() = 0;
   virtual StringRef getGdbIndexSection() = 0;
   virtual StringRef getTUIndexSection() = 0;
class DWARFContextInMemory : public DWARFContext {
   TypeSectionMap TypesSections;
   StringRef AbbrevSection;
   DWARFSection LocSection;
   StringRef ARangeSection;
   StringRef DebugFrameSection;
   StringRef EHFrameSection;
   DWARFSection LineSection;
   StringRef StringSection;
-  StringRef RangeSection;
+  DWARFSection RangeSection;
   StringRef MacinfoSection;
   StringRef PubNamesSection;
   StringRef PubTypesSection;
   StringRef GnuPubNamesSection;
   StringRef GnuPubTypesSection;
 
   // Sections for DWARF5 split dwarf proposal.
   DWARFSection InfoDWOSection;
   TypeSectionMap TypesDWOSections;
   StringRef AbbrevDWOSection;
   DWARFSection LineDWOSection;
   DWARFSection LocDWOSection;
   StringRef StringDWOSection;
   StringRef StringOffsetDWOSection;
-  StringRef RangeDWOSection;
+  DWARFSection RangeDWOSection;
   StringRef AddrSection;
   DWARFSection AppleNamesSection;
   DWARFSection AppleTypesSection;
   DWARFSection AppleNamespacesSection;
   DWARFSection AppleObjCSection;
   StringRef CUIndexSection;
   StringRef GdbIndexSection;
   StringRef TUIndexSection;
public:
   const TypeSectionMap &getTypesSections() override { return TypesSections; }
   StringRef getAbbrevSection() override { return AbbrevSection; }
   const DWARFSection &getLocSection() override { return LocSection; }
   StringRef getARangeSection() override { return ARangeSection; }
   StringRef getDebugFrameSection() override { return DebugFrameSection; }
   StringRef getEHFrameSection() override { return EHFrameSection; }
   const DWARFSection &getLineSection() override { return LineSection; }
   StringRef getStringSection() override { return StringSection; }
-  StringRef getRangeSection() override { return RangeSection; }
+  const DWARFSection &getRangeSection() override { return RangeSection; }
   StringRef getMacinfoSection() override { return MacinfoSection; }
   StringRef getPubNamesSection() override { return PubNamesSection; }
   StringRef getPubTypesSection() override { return PubTypesSection; }
   StringRef getGnuPubNamesSection() override { return GnuPubNamesSection; }
   StringRef getGnuPubTypesSection() override { return GnuPubTypesSection; }
   const DWARFSection& getAppleNamesSection() override { return AppleNamesSection; }
   const DWARFSection& getAppleTypesSection() override { return AppleTypesSection; }
   const DWARFSection& getAppleNamespacesSection() override { return AppleNamespacesSection; }
public:
   const DWARFSection &getLineDWOSection() override { return LineDWOSection; }
   const DWARFSection &getLocDWOSection() override { return LocDWOSection; }
   StringRef getStringDWOSection() override { return StringDWOSection; }
 
   StringRef getStringOffsetDWOSection() override {
     return StringOffsetDWOSection;
   }
 
-  StringRef getRangeDWOSection() override { return RangeDWOSection; }
+  const DWARFSection &getRangeDWOSection() override { return RangeDWOSection; }
 
   StringRef getAddrSection() override {
     return AddrSection;
   }
 
   StringRef getCUIndexSection() override { return CUIndexSection; }
   StringRef getGdbIndexSection() override { return GdbIndexSection; }
   StringRef getTUIndexSection() override { return TUIndexSection; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H

include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

 //===- DWARFDebugRangeList.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H
 #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H
 
 #include "llvm/Support/DataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
+
 #include <cassert>
 #include <cstdint>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
private:
   uint8_t AddressSize;
   std::vector<RangeListEntry> Entries;
 
 public:
   DWARFDebugRangeList() { clear(); }
 
   void clear();
   void dump(raw_ostream &OS) const;
-  bool extract(DataExtractor data, uint32_t *offset_ptr);
+  bool extract(DataExtractor data, uint32_t *offset_ptr, const RelocAddrMap& Relocs);
   const std::vector<RangeListEntry> &getEntries() { return Entries; }
 
   /// getAbsoluteRanges - Returns absolute address ranges defined by this range
   /// list. Has to be passed base address of the compile unit referencing this
   /// range list.
   DWARFAddressRangesVector getAbsoluteRanges(uint64_t BaseAddress) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H

include/llvm/DebugInfo/DWARF/DWARFTypeUnit.h

 
 class DWARFTypeUnit : public DWARFUnit {
 private:
   uint64_t TypeHash;
   uint32_t TypeOffset;
 
 public:
   DWARFTypeUnit(DWARFContext &Context, const DWARFSection &Section,
-                const DWARFDebugAbbrev *DA, StringRef RS, StringRef SS,
-                StringRef SOS, StringRef AOS, StringRef LS, bool LE, bool IsDWO,
-                const DWARFUnitSectionBase &UnitSection,
+                const DWARFDebugAbbrev *DA, const DWARFSection *RS,
+                StringRef SS, StringRef SOS, StringRef AOS, StringRef LS,
+                bool LE, bool IsDWO, const DWARFUnitSectionBase &UnitSection,
                 const DWARFUnitIndex::Entry *Entry)
       : DWARFUnit(Context, Section, DA, RS, SS, SOS, AOS, LS, LE, IsDWO,
                   UnitSection, Entry) {}
 
   uint32_t getHeaderSize() const override {
     return DWARFUnit::getHeaderSize() + 12;
   }
 

include/llvm/DebugInfo/DWARF/DWARFUnit.h

public:
   void parse(DWARFContext &C, const DWARFSection &Section);
   void parseDWO(DWARFContext &C, const DWARFSection &DWOSection,
                 DWARFUnitIndex *Index = nullptr);
 
 protected:
   ~DWARFUnitSectionBase() = default;
 
   virtual void parseImpl(DWARFContext &Context, const DWARFSection &Section,
-                         const DWARFDebugAbbrev *DA, StringRef RS, StringRef SS,
-                         StringRef SOS, StringRef AOS, StringRef LS,
-                         bool isLittleEndian, bool isDWO) = 0;
+                         const DWARFDebugAbbrev *DA, const DWARFSection *RS,
+                         StringRef SS, StringRef SOS, StringRef AOS,
+                         StringRef LS, bool isLittleEndian, bool isDWO) = 0;
 };
 
 const DWARFUnitIndex &getDWARFUnitIndex(DWARFContext &Context,
                                         DWARFSectionKind Kind);
 
 /// Concrete instance of DWARFUnitSection, specialized for one Unit type.
 template<typename UnitType>
 class DWARFUnitSection final : public SmallVector<std::unique_ptr<UnitType>, 1>,
auto *CU = std::upper_bound(
         });
     if (CU != this->end())
       return CU->get();
     return nullptr;
   }
 
 private:
   void parseImpl(DWARFContext &Context, const DWARFSection &Section,
-                 const DWARFDebugAbbrev *DA, StringRef RS, StringRef SS,
-                 StringRef SOS, StringRef AOS, StringRef LS, bool LE,
-                 bool IsDWO) override {
+                 const DWARFDebugAbbrev *DA, const DWARFSection *RS,
+                 StringRef SS, StringRef SOS, StringRef AOS, StringRef LS,
+                 bool LE, bool IsDWO) override {
     if (Parsed)
       return;
     const auto &Index = getDWARFUnitIndex(Context, UnitType::Section);
     DataExtractor Data(Section.Data, LE, 0);
     uint32_t Offset = 0;
     while (Data.isValidOffset(Offset)) {
       auto U = llvm::make_unique<UnitType>(Context, Section, DA, RS, SS, SOS,
                                            AOS, LS, LE, IsDWO, *this,
                                            Index.getFromOffset(Offset));
       if (!U->extract(Data, &Offset))
         break;
       this->push_back(std::move(U));
       Offset = this->back()->getNextUnitOffset();
     }
     Parsed = true;
   }
 };
 
 class DWARFUnit {
   DWARFContext &Context;
   // Section containing this DWARFUnit.
   const DWARFSection &InfoSection;
 
   const DWARFDebugAbbrev *Abbrev;
-  StringRef RangeSection;
+  const DWARFSection *RangeSection;
   uint32_t RangeSectionBase;
   StringRef LineSection;
   StringRef StringSection;
   StringRef StringOffsetSection;
   StringRef AddrOffsetSection;
   uint32_t AddrOffsetSectionBase;
   bool isLittleEndian;
   bool isDWO;

 protected:
   virtual bool extractImpl(DataExtractor debug_info, uint32_t *offset_ptr);
 
   /// Size in bytes of the unit header.
   virtual uint32_t getHeaderSize() const { return Version <= 4 ? 11 : 12; }
 
 public:
   DWARFUnit(DWARFContext &Context, const DWARFSection &Section,
-            const DWARFDebugAbbrev *DA, StringRef RS, StringRef SS,
+            const DWARFDebugAbbrev *DA, const DWARFSection *RS, StringRef SS,
             StringRef SOS, StringRef AOS, StringRef LS, bool LE, bool IsDWO,
             const DWARFUnitSectionBase &UnitSection,
             const DWARFUnitIndex::Entry *IndexEntry = nullptr);
 
   virtual ~DWARFUnit();
 
   DWARFContext& getContext() const { return Context; }
 
   StringRef getLineSection() const { return LineSection; }
   StringRef getStringSection() const { return StringSection; }
   StringRef getStringOffsetSection() const { return StringOffsetSection; }
 
   void setAddrOffsetSection(StringRef AOS, uint32_t Base) {
     AddrOffsetSection = AOS;
     AddrOffsetSectionBase = Base;
   }
 
-  void setRangesSection(StringRef RS, uint32_t Base) {
+  void setRangesSection(const DWARFSection *RS, uint32_t Base) {
     RangeSection = RS;
     RangeSectionBase = Base;
   }
 
   bool getAddrOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
   // FIXME: Result should be uint64_t in DWARF64.
   bool getStringOffsetSectionItem(uint32_t Index, uint32_t &Result) const;
 

lib/DebugInfo/DWARF/DWARFContext.cpp

void DWARFContext::dump(raw_ostream &OS, DIDumpType DumpType, bool DumpEH,
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Ranges) {
     OS << "\n.debug_ranges contents:\n";
     // In fact, different compile units may have different address byte
     // sizes, but for simplicity we just use the address byte size of the last
     // compile unit (there is no easy and fast way to associate address range
     // list and the compile unit it describes).
-    DataExtractor rangesData(getRangeSection(), isLittleEndian(),
+    DataExtractor rangesData(getRangeSection().Data, isLittleEndian(),
                              savedAddressByteSize);
     offset = 0;
     DWARFDebugRangeList rangeList;
-    while (rangeList.extract(rangesData, &offset))
+    while (rangeList.extract(rangesData, &offset, getRangeSection().Relocs))
       rangeList.dump(OS);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Pubnames)
     DWARFDebugPubTable(getPubNamesSection(), isLittleEndian(), false)
         .dump("debug_pubnames", OS);
 
   if (DumpType == DIDT_All || DumpType == DIDT_Pubtypes)
for (const SectionRef &Section : Obj.sections()) {
     // at this point section is decompressed and we drop compression prefix.
     name = name.substr(
         name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes.
 
     if (StringRef *SectionData = MapSectionToMember(name)) {
       *SectionData = data;
       if (name == "debug_ranges") {
         // FIXME: Use the other dwo range section when we emit it.
-        RangeDWOSection = data;
+        RangeDWOSection.Data = data;
       }
     } else if (name == "debug_types") {
       // Find debug_types data by section rather than name as there are
       // multiple, comdat grouped, debug_types sections.
       TypesSections[Section].Data = data;
     } else if (name == "debug_types.dwo") {
       TypesDWOSections[Section].Data = data;
     }
for (const SectionRef &Section : Obj.sections()) {
 
     // TODO: Add support for relocations in other sections as needed.
     // Record relocations for the debug_info and debug_line sections.
     RelocAddrMap *Map = StringSwitch<RelocAddrMap*>(RelSecName)
         .Case("debug_info", &InfoSection.Relocs)
         .Case("debug_loc", &LocSection.Relocs)
         .Case("debug_info.dwo", &InfoDWOSection.Relocs)
         .Case("debug_line", &LineSection.Relocs)
+        .Case("debug_ranges", &RangeSection.Relocs)
         .Case("apple_names", &AppleNamesSection.Relocs)
         .Case("apple_types", &AppleTypesSection.Relocs)
         .Case("apple_namespaces", &AppleNamespacesSection.Relocs)
         .Case("apple_namespac", &AppleNamespacesSection.Relocs)
         .Case("apple_objc", &AppleObjCSection.Relocs)
         .Default(nullptr);
     if (!Map) {
       // Find debug_types relocs by section rather than name as there are
return StringSwitch<StringRef *>(Name)
       .Case("debug_info", &InfoSection.Data)
       .Case("debug_abbrev", &AbbrevSection)
       .Case("debug_loc", &LocSection.Data)
       .Case("debug_line", &LineSection.Data)
       .Case("debug_aranges", &ARangeSection)
       .Case("debug_frame", &DebugFrameSection)
       .Case("eh_frame", &EHFrameSection)
       .Case("debug_str", &StringSection)
-      .Case("debug_ranges", &RangeSection)
+      .Case("debug_ranges", &RangeSection.Data)
       .Case("debug_macinfo", &MacinfoSection)
       .Case("debug_pubnames", &PubNamesSection)
       .Case("debug_pubtypes", &PubTypesSection)
       .Case("debug_gnu_pubnames", &GnuPubNamesSection)
       .Case("debug_gnu_pubtypes", &GnuPubTypesSection)
       .Case("debug_info.dwo", &InfoDWOSection.Data)
       .Case("debug_abbrev.dwo", &AbbrevDWOSection)
       .Case("debug_loc.dwo", &LocDWOSection.Data)

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

 using namespace llvm;
 
 void DWARFDebugRangeList::clear() {
   Offset = -1U;
   AddressSize = 0;
   Entries.clear();
 }
 
-bool DWARFDebugRangeList::extract(DataExtractor data, uint32_t *offset_ptr) {
+static uint64_t getAddress(DataExtractor &Data, uint32_t *Off,
+                           const RelocAddrMap &Relocs) {
+  RelocAddrMap::const_iterator AI = Relocs.find(*Off);
+  if (AI != Relocs.end())
+    return Data.getAddress(Off) + AI->second.second;
+  return Data.getAddress(Off);
+}
+
+bool DWARFDebugRangeList::extract(DataExtractor data, uint32_t *offset_ptr,
+                                  const RelocAddrMap &Relocs) {
   clear();
   if (!data.isValidOffset(*offset_ptr))
     return false;
   AddressSize = data.getAddressSize();
   if (AddressSize != 4 && AddressSize != 8)
     return false;
   Offset = *offset_ptr;
   while (true) {
     RangeListEntry entry;
     uint32_t prev_offset = *offset_ptr;
-    entry.StartAddress = data.getAddress(offset_ptr);
-    entry.EndAddress = data.getAddress(offset_ptr);
+    entry.StartAddress = getAddress(data, offset_ptr, Relocs);
+    entry.EndAddress = getAddress(data, offset_ptr, Relocs);
     // Check that both values were extracted correctly.
     if (*offset_ptr != prev_offset + 2 * AddressSize) {
       clear();
       return false;
     }
     if (entry.isEndOfListEntry())
       break;
     Entries.push_back(entry);
   }
   return true;
 }
 
 void DWARFDebugRangeList::dump(raw_ostream &OS) const {
   for (const RangeListEntry &RLE : Entries) {

lib/DebugInfo/DWARF/DWARFUnit.cpp

 #include <cstdint>
 #include <cstdio>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 
 void DWARFUnitSectionBase::parse(DWARFContext &C, const DWARFSection &Section) {
-  parseImpl(C, Section, C.getDebugAbbrev(), C.getRangeSection(),
+  parseImpl(C, Section, C.getDebugAbbrev(), &C.getRangeSection(),
             C.getStringSection(), StringRef(), C.getAddrSection(),
             C.getLineSection().Data, C.isLittleEndian(), false);
 }
 
 void DWARFUnitSectionBase::parseDWO(DWARFContext &C,
                                     const DWARFSection &DWOSection,
                                     DWARFUnitIndex *Index) {
-  parseImpl(C, DWOSection, C.getDebugAbbrevDWO(), C.getRangeDWOSection(),
+  parseImpl(C, DWOSection, C.getDebugAbbrevDWO(), &C.getRangeDWOSection(),
             C.getStringDWOSection(), C.getStringOffsetDWOSection(),
             C.getAddrSection(), C.getLineDWOSection().Data, C.isLittleEndian(),
             true);
 }
 
 DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
-                     const DWARFDebugAbbrev *DA, StringRef RS, StringRef SS,
-                     StringRef SOS, StringRef AOS, StringRef LS, bool LE,
-                     bool IsDWO, const DWARFUnitSectionBase &UnitSection,
+                     const DWARFDebugAbbrev *DA, const DWARFSection *RS,
+                     StringRef SS, StringRef SOS, StringRef AOS, StringRef LS,
+                     bool LE, bool IsDWO,
+                     const DWARFUnitSectionBase &UnitSection,
                      const DWARFUnitIndex::Entry *IndexEntry)
     : Context(DC), InfoSection(Section), Abbrev(DA), RangeSection(RS),
       LineSection(LS), StringSection(SS), StringOffsetSection([&]() {
         if (IndexEntry)
           if (const auto *C = IndexEntry->getOffset(DW_SECT_STR_OFFSETS))
             return SOS.slice(C->Offset, C->Offset + C->Length);
         return SOS;
       }()),
bool DWARFUnit::extract(DataExtractor debug_info, uint32_t *offset_ptr) {
 
   return false;
 }
 
 bool DWARFUnit::extractRangeList(uint32_t RangeListOffset,
                                         DWARFDebugRangeList &RangeList) const {
   // Require that compile unit is extracted.
   assert(!DieArray.empty());
-  DataExtractor RangesData(RangeSection, isLittleEndian, AddrSize);
+  DataExtractor RangesData(RangeSection->Data, isLittleEndian, AddrSize);
   uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
-  return RangeList.extract(RangesData, &ActualRangeListOffset);
+  return RangeList.extract(RangesData, &ActualRangeListOffset,
+                           RangeSection->Relocs);
 }
 
 void DWARFUnit::clear() {
   Offset = 0;
   Length = 0;
   Version = 0;
   Abbrevs = nullptr;
   AddrSize = 0;

test/DebugInfo/dwarfdump-ranges-unrelocated.s

+# RUN: llvm-mc -triple x86_64-pc-linux -filetype=obj %s -o %t
+# RUN: llvm-dwarfdump %t | FileCheck %s
+
+# CHECK: .debug_ranges contents:
+# CHECK:   00000000 0000000000000000 0000000000000001
+# CHECK:   00000000 0000000000000000 0000000000000002
+# CHECK:   00000000 0000000000000000 0000000000000003
+# CHECK:   00000000 <End of list>
+
+## Asm code for testcase is a reduced output from next invocation and source:
+# clang test.cpp -S -o test.s -g -gsplit-dwarf -ffunction-sections
+# test.cpp:
+#   int foo1() { return 1; }  
+#   int foo2() { return 1; }  
+#   int foo3() { return 1; }  
+
+.section .text._Z4foo1v,"ax",@progbits
+_Z4foo1v:
+.Lfunc_begin0:
+ nop
+.Lfunc_end0:
+
+.section .text._Z4foo2v,"ax",@progbits
+_Z4foo2v:
+.Lfunc_begin1:
+ nop
+ nop
+.Lfunc_end1:
+
+.section .text._Z4foo3v,"ax",@progbits
+_Z4foo3v:
+.Lfunc_begin2:
+ nop
+ nop
+ nop
+.Lfunc_end2:
+
+.section .debug_abbrev,"",@progbits
+.byte 1                       # Abbreviation Code
+.byte 17                      # DW_TAG_compile_unit
+.byte 0                       # DW_CHILDREN_no
+.byte 16                      # DW_AT_stmt_list
+.byte 23                      # DW_FORM_sec_offset
+.ascii "\260B"                # DW_AT_GNU_dwo_name
+.byte 14                      # DW_FORM_strp
+.byte 27                      # DW_AT_comp_dir
+.byte 14                      # DW_FORM_strp
+.ascii "\261B"                # DW_AT_GNU_dwo_id
+.byte 7                       # DW_FORM_data8
+.ascii "\263B"                # DW_AT_GNU_addr_base
+.byte 23                      # DW_FORM_sec_offset
+.byte 17                      # DW_AT_low_pc
+.byte 1                       # DW_FORM_addr
+.byte 85                      # DW_AT_ranges
+.byte 23                      # DW_FORM_sec_offset
+.byte 0                       # EOM(1)
+.byte 0                       # EOM(2)
+.byte 0                       # EOM(3)
+
+.section .debug_info,"",@progbits
+.Lcu_begin0:
+.long 44                       # Length of Unit
+.short 4                       # DWARF version number
+
+.long .debug_abbrev           # Offset Into Abbrev. Section
+.byte 8                       # Address Size (in bytes)
+.byte 1                       # Abbrev [1] 0xb:0x25 DW_TAG_compile_unit
+.long 0                       # DW_AT_stmt_list
+.long 0                       # DW_AT_GNU_dwo_name
+.long 0                       # DW_AT_comp_dir
+.quad 0                       # DW_AT_GNU_dwo_id
+.long 0                       # DW_AT_GNU_addr_base
+.quad 0                       # DW_AT_low_pc
+.long .Ldebug_ranges0         # DW_AT_ranges
+
+.section .debug_ranges,"",@progbits
+.Ldebug_ranges0:
+.quad .Lfunc_begin0
+.quad .Lfunc_end0
+.quad .Lfunc_begin1
+.quad .Lfunc_end1
+.quad .Lfunc_begin2
+.quad .Lfunc_end2
+.quad 0
+.quad 0

tools/dsymutil/DwarfLinker.cpp

 /// \brief Patch the input object file relevant debug_ranges entries
 /// and emit them in the output file. Update the relevant attributes
 /// to point at the new entries.
 void DwarfLinker::patchRangesForUnit(const CompileUnit &Unit,
                                      DWARFContext &OrigDwarf) const {
   DWARFDebugRangeList RangeList;
   const auto &FunctionRanges = Unit.getFunctionRanges();
   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
-  DataExtractor RangeExtractor(OrigDwarf.getRangeSection(),
+  DataExtractor RangeExtractor(OrigDwarf.getRangeSection().Data,
                                OrigDwarf.isLittleEndian(), AddressSize);
   auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   auto OrigUnitDie = OrigUnit.getUnitDIE(false);
   uint64_t OrigLowPc = dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc), -1ULL);
   // Ranges addresses are based on the unit's low_pc. Compute the
   // offset we need to apply to adapt to the new unit's low_pc.
   int64_t UnitPcOffset = 0;
   if (OrigLowPc != -1ULL)
     UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
 
   for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
     uint32_t Offset = RangeAttribute.get();
     RangeAttribute.set(Streamer->getRangesSectionSize());
-    RangeList.extract(RangeExtractor, &Offset);
+    RangeList.extract(RangeExtractor, &Offset, OrigDwarf.getRangeSection().Relocs);
     const auto &Entries = RangeList.getEntries();
     if (!Entries.empty()) {
       const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
 
       if (CurrRange == InvalidRange ||
           First.StartAddress + OrigLowPc < CurrRange.start() ||
           First.StartAddress + OrigLowPc >= CurrRange.stop()) {
         CurrRange = FunctionRanges.find(First.StartAddress + OrigLowPc);