Index: ELF/SyntheticSections.cpp
===================================================================
--- ELF/SyntheticSections.cpp
+++ ELF/SyntheticSections.cpp
@@ -1802,6 +1802,104 @@
   }
 }
 
+namespace {
+template <class ELFT> class ObjectInfo final : public LoadedObjectInfo {
+public:
+  uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override {
+    return 0;
+  }
+  std::unique_ptr<LoadedObjectInfo> clone() const override { return {}; }
+
+  ObjectInfo(const object::ObjectFile &Obj)
+      : ElfObj(cast<ELFObjectFile<ELFT>>(Obj)) {}
+
+  bool relocate(const object::SectionRef &RelSec,
+                RelocAddrMap *Map) const override {
+    StringRef S;
+    if (std::error_code EC = RelSec.getName(S))
+      return false;
+    if (S == ".rela.debug_ranges" || S == ".rel.debug_ranges")
+      return relocateDebugRanges(RelSec, Map);
+    return false;
+  }
+
+private:
+  typedef typename ELFT::Shdr Elf_Shdr;
+  typedef typename ELFT::Sym Elf_Sym;
+
+  const ELFObjectFile<ELFT> &ElfObj;
+
+  bool relocateDebugRanges(const object::SectionRef &RelSec,
+                           RelocAddrMap *Map) const {
+    const ELFFile<ELFT> *ElfFile = ElfObj.getELFFile();
+    const Elf_Shdr *RelSecShdr = ElfObj.getSection(RelSec.getRawDataRefImpl());
+    const Elf_Shdr *SymTabShdr =
+        check(ElfFile->getSection(RelSecShdr->sh_link));
+
+    if (RelSecShdr->sh_type == SHT_RELA) {
+      ArrayRef<typename ELFT::Rela> Entries = check(
+          ElfFile->template getSectionContentsAsArray<typename ELFT::Rela>(
+              RelSecShdr));
+      scanDebugRangesRelocations(SymTabShdr, Entries, Map);
+    } else {
+      ArrayRef<typename ELFT::Rel> Entries =
+          check(ElfFile->template getSectionContentsAsArray<typename ELFT::Rel>(
+              RelSecShdr));
+      scanDebugRangesRelocations(SymTabShdr, Entries, Map);
+    }
+
+    return true;
+  }
+
+  uint64_t getAddend(const Elf_Shdr *Sec, const typename ELFT::Rel &Rel) const {
+    const ELFFile<ELFT> *ElfFile = ElfObj.getELFFile();
+    ArrayRef<uint8_t> Data =
+        check(ElfFile->template getSectionContentsAsArray<uint8_t>(Sec));
+    return Target->getImplicitAddend(Data.begin() + Rel.r_offset,
+                                     Rel.getType(Config->IsMips64EL));
+  }
+
+  uint64_t getAddend(const Elf_Shdr *Sec,
+                     const typename ELFT::Rela &Rel) const {
+    return Rel.r_addend;
+  }
+
+  template <class RelTy>
+  void scanDebugRangesRelocations(const Elf_Shdr *SymTab, ArrayRef<RelTy> Rels,
+                                  RelocAddrMap *Map) const {
+    const ELFFile<ELFT> *ElfFile = ElfObj.getELFFile();
+
+    ArrayRef<Elf_Sym> Symbols = check(ElfFile->symbols(SymTab));
+    ArrayRef<Elf_Shdr> Sections = check(ElfFile->sections());
+
+    for (const RelTy &Rel : Rels) {
+      uint32_t SymId = Rel.getSymbol(Config->IsMips64EL);
+      uint64_t SecIndex = Symbols[SymId].st_shndx;
+      uint64_t A = getAddend(&Sections[SecIndex], Rel);
+      RelocAddrEntry RelEntry = {SecIndex, A};
+      Map->insert({Rel.r_offset, RelEntry});
+    }
+  }
+};
+
+std::unique_ptr<LoadedObjectInfo>
+createObjectInfo(const object::ObjectFile &Obj) {
+  switch (Config->EKind) {
+  case ELF32LEKind:
+    return llvm::make_unique<ObjectInfo<ELF32LE>>(Obj);
+  case ELF32BEKind:
+    return llvm::make_unique<ObjectInfo<ELF32BE>>(Obj);
+  case ELF64LEKind:
+    return llvm::make_unique<ObjectInfo<ELF64LE>>(Obj);
+  case ELF64BEKind:
+    return llvm::make_unique<ObjectInfo<ELF64BE>>(Obj);
+  default:
+    llvm_unreachable("unknown Config->EKind");
+  }
+}
+
+} // namespace
+
 GdbIndexChunk GdbIndexSection::readDwarf(InputSection *Sec) {
   Expected<std::unique_ptr<object::ObjectFile>> Obj =
       object::ObjectFile::createObjectFile(Sec->File->MB);
@@ -1810,7 +1908,8 @@
     return {};
   }
 
-  DWARFContextInMemory Dwarf(*Obj.get());
+  std::unique_ptr<LoadedObjectInfo> ObjInfo = createObjectInfo(*Obj.get());
+  DWARFContextInMemory Dwarf(*Obj.get(), ObjInfo.get());
 
   GdbIndexChunk Ret;
   Ret.CompilationUnits = readCuList(Dwarf, Sec);