[ELF] - Use relocated content when generating .gdb_index

[grimar]

Summary

Previously LLVM DWARF parsers were responsible to resolve some of
relocations when .gdb_index was generated. That was extremly slow.
Also requires some additional code from LLD side, which was not fast
either (like D31330 showed).

One of solutions would be to feed parser with relocated sections content,
current parsers API allows to pass sections directly. That is what patch do.

First, it performs parsing using non-relocated content as usual. That works for everything, except
.debug_ranges section. Patch does not ask DWARF parser to parse ranges on this step,
I just count the amount of ranges in total. That allows to know the .gdb_index section size
early.

Later .gdb_index section is processed in writeTo(). Since it is synthetic, it is added after all .debug_* sections
to the output sections list. So relocations for debug sections which performed in writeTo are
done before writeTo() call for .gdb_index.
During GdbIndexSection::writeTo() I use DWARF parsers just to retrive address ranges list.
It uses relocated .debug_range section content on this step. And that allows to get correct
relocated ranges.

That also helped to resolve issue mentioned in last comments for PR32319. Testcase is provided.

Note, that even with that patch output is still broken. Example:

// GOLD:

 Low address = 0x121beb3, High address = 0x121becd, CU index = 0 (0x121becd - 0x121beb3 == 0x1A)
...
  Low address = 0x121befa, High address = 0x121f132, CU index = 1 (0x121f132 - 0x121befa == 0x3238)
  Low address = 0x121f132, High address = 0x121f160, CU index = 1 (0x121f160 - 0x0x121f132 == 0x2E)
  Low address = 0x121f160, High address = 0x121f1fb, CU index = 1 (0x121f1fb - 0x121f160 == 0x9B)

//LLD:

Low address = 0x31b68a3, High address = 0x31b68bd, CU index = 0 (0x31b68bd - 0x31b68a3 == 0x1A)
 ...
 Low address = 0x31b68ea, High address = 0x31b9b22, CU index = 1 (0x31b9b22 - 0x31b68ea == 0x3238)
 Low address = 0x0, High address = 0x12, CU index = 1             <--- BROKEN EXCESSIVE ENTRY
 Low address = 0x31b9b22, High address = 0x31b9b50, CU index = 1 (0x31b9b50 - 0x31b9b22 == 0x2E)
 Low address = 0x31b9b50, High address = 0x31b9beb, CU index = 1 (0x31b9beb - 0x31b9b50 = 0x9B)

LLD section contains broken excessive entries. That happens because there are some amount of relocations in
.debug_ranges which are against discarded sections. In that case the value we write to section is an relocation
addend. I think that can be fixed if we would skip such entries somehow when work with .debug_ranges section (may be we should regenerate it to dismiss
all entries that are against discarded sections ? That usefull optimization itself).
Or we probably can put 2 similiar values instead of address range in that case, DWARF manual says that: "A range list entry (but not a base address selection or end of list entry) whose beginning and ending addresses are equal has no effect because the size of the range covered by such an entry is zero."
So it may probably work. That issue requires additional investigating still and not relative to this patch directly.

[dblaikie]

ELF/SyntheticSections.cpp

1739–1740

I don't understand what assumption you're describing.

Oh, because relocations haven't been performed, nor handled at all - it's not possible to tell where the address ranges end, so you're providing an overestimate here? That's a bit subtle and the function name should at least mention that I would think (& the function that calls this one too)

Is there any penalty to this overestimate in how the gdb_index is created? Does a larger sized record need to be used to handle a maximum that may never be needed?

[looking at the implementation, it seems there is a penalty for overestimate - a table is reserved for that many address ranges, right? so much of that table may go unused if this is a significant overestimate (though that probably only happens if someone uses ld -r or, perhaps more likely: LTO)]

I wouldn't imagine it'd be too hard to look at enough relocation data (essentially parse the relocations applicable to debug_ranges and look for holes (bytes that don't have relocations for them) - those are the ends of range lists - you wouldn't need to apply any relocations or examine their addends, etc, only their offsets)

[grimar]

ELF/SyntheticSections.cpp

1739–1740

I don't understand what assumption you're describing.

Oh, because relocations haven't been performed, nor handled at all - it's not possible to tell where the address ranges end, so you're providing >an overestimate here? That's a bit subtle and the function name should at least mention that I would think (& the function that calls this one >too)

Right. Its straightforward and fastest way to do things I believe. It is possible to tell where is address ranges end only after handling or some parsing of relocations. I think we can find the relocation with largest offset in .debug_range section and that be enough to know that next offset is the end here. (but that would not solve everything, please see below)
I can probably rename getDieRangesCount to estimateDieRangesCount and getAddressRangesCount to estimateAddressRangesCount ?

Is there any penalty to this overestimate in how the gdb_index is created? Does a larger sized record need to be used to handle a maximum >that may never be needed?

[looking at the implementation, it seems there is a penalty for overestimate - a table is reserved for that many address ranges, right? so much >of that table may go unused if this is a significant overestimate (though that probably only happens if someone uses ld -r or, perhaps more >likely: LTO)]

Yes, penalty is size. I am not aware about LTO, I knew about ld -r here only. I think perfomance is preferable over possible size penalty in general. And this patch just a first step in direction to use relocated data, so we can think about how to solve that after this change probably.

I wouldn't imagine it'd be too hard to look at enough relocation data (essentially parse the relocations applicable to debug_ranges and look for >holes (bytes that don't have relocations for them) - those are the ends of range lists - you wouldn't need to apply any relocations or examine >their addends, etc, only their offsets)

There is one more issue I mentioned in description - is when address range belongs to discarded section. This case can not be catched until relocations are scanned at later stages, because we cant just scan relocations early when we do not know which sections were discarded.
So since these issues are related, I would fix them in a separate patch(es). Scanning of relocations also will probably affect perfomance, and should be done in a some smart way.

[grimar]

Abandoning for now, because different approach (D33122) looks more promising direction.

ELF/GdbIndex.h

 #include "llvm/Object/ELF.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 
 namespace lld {
 namespace elf {
 
 class InputSection;
 
-// Struct represents single entry of address area of gdb index.
-struct AddressEntry {
-  InputSectionBase *Section;
-  uint64_t LowAddress;
-  uint64_t HighAddress;
-  size_t CuIndex;
-};
-
 // Element of GdbHashTab hash table.
 struct GdbSymbol {
   GdbSymbol(uint32_t Hash, size_t Offset)
       : NameHash(Hash), NameOffset(Offset) {}
   uint32_t NameHash;
   size_t NameOffset;
   size_t CuVectorIndex;
 };

ELF/OutputSections.h

 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 struct Out {
   static uint8_t First;
   static OutputSection *Opd;
   static uint8_t *OpdBuf;
   static PhdrEntry *TlsPhdr;
   static OutputSection *DebugInfo;
+  static OutputSection *DebugAbbrev;
+  static OutputSection *DebugGnuPubNames;
+  static OutputSection *DebugGnuPubTypes;
+  static OutputSection *DebugRanges;
   static OutputSection *ElfHeader;
   static OutputSection *ProgramHeaders;
   static OutputSection *PreinitArray;
   static OutputSection *InitArray;
   static OutputSection *FiniArray;
 };
 
 struct SectionKey {

ELF/OutputSections.cpp

 using namespace lld;
 using namespace lld::elf;
 
 uint8_t Out::First;
 OutputSection *Out::Opd;
 uint8_t *Out::OpdBuf;
 PhdrEntry *Out::TlsPhdr;
 OutputSection *Out::DebugInfo;
+OutputSection *Out::DebugAbbrev;
+OutputSection *Out::DebugGnuPubNames;
+OutputSection *Out::DebugGnuPubTypes;
+OutputSection *Out::DebugRanges;
 OutputSection *Out::ElfHeader;
 OutputSection *Out::ProgramHeaders;
 OutputSection *Out::PreinitArray;
 OutputSection *Out::InitArray;
 OutputSection *Out::FiniArray;
 
 uint32_t OutputSection::getPhdrFlags() const {
   uint32_t Ret = PF_R;

ELF/SyntheticSections.h

public:
 
   llvm::StringTableBuilder StringPool;
 
   GdbHashTab SymbolTable;
 
   // The CU vector portion of the constant pool.
   std::vector<std::vector<std::pair<uint32_t, uint8_t>>> CuVectors;
 
-  std::vector<AddressEntry> AddressArea;
+  uint64_t AddressRangesAmount = 0;
 
 private:
   void readDwarf(InputSection *Sec);
 
   uint32_t CuTypesOffset;
   uint32_t SymTabOffset;
   uint32_t ConstantPoolOffset;
   uint32_t StringPoolOffset;

ELF/SyntheticSections.cpp

 static std::vector<std::pair<uint64_t, uint64_t>>
 readCuList(DWARFContext &Dwarf, InputSection *Sec) {
   std::vector<std::pair<uint64_t, uint64_t>> Ret;
   for (std::unique_ptr<DWARFCompileUnit> &CU : Dwarf.compile_units())
     Ret.push_back({Sec->OutSecOff + CU->getOffset(), CU->getLength() + 4});
   return Ret;
 }
 
-static InputSectionBase *findSection(ArrayRef<InputSectionBase *> Arr,
-                                     uint64_t Offset) {
-  for (InputSectionBase *S : Arr)
-    if (S && S != &InputSection::Discarded)
-      if (Offset >= S->getOffsetInFile() &&
-          Offset < S->getOffsetInFile() + S->getSize())
-        return S;
-  return nullptr;
-}
-
-static std::vector<AddressEntry>
-readAddressArea(DWARFContext &Dwarf, InputSection *Sec, size_t CurrentCU) {
-  std::vector<AddressEntry> Ret;
-
+static std::vector<DWARFAddressRangesVector> readRanges(DWARFContext &Dwarf) {
+  std::vector<DWARFAddressRangesVector> Ret;
   for (std::unique_ptr<DWARFCompileUnit> &CU : Dwarf.compile_units()) {
     DWARFAddressRangesVector Ranges;
     CU->collectAddressRanges(Ranges);
-
-    ArrayRef<InputSectionBase *> Sections = Sec->File->getSections();
-    for (std::pair<uint64_t, uint64_t> &R : Ranges)
-      if (InputSectionBase *S = findSection(Sections, R.first))
-        Ret.push_back({S, R.first - S->getOffsetInFile(),
-                       R.second - S->getOffsetInFile(), CurrentCU});
-    ++CurrentCU;
+    Ret.push_back(std::move(Ranges));
   }
   return Ret;
 }
 
 static std::vector<std::pair<StringRef, uint8_t>>
 readPubNamesAndTypes(DWARFContext &Dwarf, bool IsLE) {
   StringRef Data[] = {Dwarf.getGnuPubNamesSection(),
                       Dwarf.getGnuPubTypesSection()};
 
   std::vector<std::pair<StringRef, uint8_t>> Ret;
   for (StringRef D : Data) {
     DWARFDebugPubTable PubTable(D, IsLE, true);
     for (const DWARFDebugPubTable::Set &Set : PubTable.getData())
       for (const DWARFDebugPubTable::Entry &Ent : Set.Entries)
         Ret.push_back({Ent.Name, Ent.Descriptor.toBits()});
   }
   return Ret;
 }
 
-class ObjInfoTy : public llvm::LoadedObjectInfo {
-  uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override {
-    auto &S = static_cast<const object::ELFSectionRef &>(Sec);
-    if (S.getFlags() & ELF::SHF_ALLOC)
-      return S.getOffset();
-    return 0;
-  }
+// Returns amount of address ranges in a DIE.
+static uint64_t getDieRangesCount(DWARFContext &Dwarf, DWARFCompileUnit *CU,
+                                  const DWARFDie &Die) {
+  if (!Die || Die.isNULL())
+    return 0;
+  // DIE may have DW_AT_low_pc and DW_AT_high_pc pair of attributes for a single
+  // contiguous range of addresses.
+  if (Die.find(DW_AT_low_pc) && Die.find(DW_AT_high_pc))
+    return 1;
+  // Range list is indecated by DW_AT_ranges attribute. Whose value is
+  // represented as an offset from the beginning of the .debug_ranges section to
+  // the beginning of the range list.
+  // The end of any given range list is marked by an end of list entry, which
+  // consists of a 0 for the beginning address offset and a 0 for the ending
+  // address offset. We assume here that whole section data starting from offset
+  // is a range, terminated with null entry.
+  if (Optional<uint64_t> Offset = toSectionOffset(Die.find(DW_AT_ranges))) {
+    uint8_t AddrSize = CU->getAddressByteSize();
+    return (Dwarf.getRangeSection().size() - *Offset) / (2 * AddrSize) - 1;
+  }
 
-  std::unique_ptr<llvm::LoadedObjectInfo> clone() const override { return {}; }
-};
+// Returns amount of address ranges for all compilation units in a DWARF
+// context.
+static uint64_t getAddressRangesCount(DWARFContext &Dwarf) {
+  uint64_t Ret = 0;
+  for (std::unique_ptr<DWARFCompileUnit> &CU : Dwarf.compile_units())
+    Ret += getDieRangesCount(Dwarf, CU.get(), CU->getUnitDIE());
+  return Ret;
+}
 
-void GdbIndexSection::readDwarf(InputSection *Sec) {
-  Expected<std::unique_ptr<object::ObjectFile>> Obj =
-      object::ObjectFile::createObjectFile(Sec->File->MB);
-  if (!Obj) {
-    error(toString(Sec->File) + ": error creating DWARF context");
-    return;
-  }
+// Returns vector of debug sections in a file. Vector contains
+// only sections that are required for building .gdb_index section.
+static std::vector<InputSectionBase *> getDebugSections(InputFile *File) {
+  std::vector<InputSectionBase *> Ret;
+  for (InputSectionBase *Sec : File->getSections()) {
+    if (!Sec || Sec == &InputSection::Discarded)
+      continue;
+    if (StringSwitch<bool>(Sec->Name)
+            .Case(".debug_info", true)
+            .Case(".debug_abbrev", true)
+            .Case(".debug_gnu_pubnames", true)
+            .Case(".debug_gnu_pubtypes", true)
+            .Case(".debug_ranges", true)
+            .Default(false))
+      Ret.push_back(Sec);
+  }
+  return Ret;
 
-  ObjInfoTy ObjInfo;
-  DWARFContextInMemory Dwarf(*Obj.get(), &ObjInfo);
+// Given the array of debug sections for a file, created the
+// DWARF context for parsing and futher generating of .gdb_index.
+static DWARFContextInMemory *
+createDwarfContext(ArrayRef<InputSectionBase *> V) {
+  StringMap<std::unique_ptr<MemoryBuffer>> *Map =
+      make<StringMap<std::unique_ptr<MemoryBuffer>>>();
+
+  for (InputSectionBase *Sec : V) {
+    StringRef Name = Sec->Name.drop_front();
+    StringRef Data((const char *)Sec->Data.begin(), Sec->getSize());
+    Map->insert({Name, llvm::MemoryBuffer::getMemBuffer(Data, Name, false)});
+  }
+  return make<DWARFContextInMemory>(*Map, Config->Wordsize, Config->IsLE);
+}
+
+// Function uses relocated output sections content to create DWARF parser
+// instance. We use it to retrive the correct values for address ranges.
+static DWARFContextInMemory *createRelocatedDwarfContext() {
+  StringMap<std::unique_ptr<MemoryBuffer>> *Map =
+      make<StringMap<std::unique_ptr<MemoryBuffer>>>();
+
+  OutputSection *Sections[] = {Out::DebugInfo, Out::DebugAbbrev,
+                               Out::DebugGnuPubNames, Out::DebugGnuPubTypes,
+                               Out::DebugRanges};
+  for (OutputSection *Sec : Sections) {
+    if (!Sec)
+      continue;
+
+    StringRef Key = Sec->Name.drop_front();
+    std::unique_ptr<MemoryBuffer> Buf = llvm::MemoryBuffer::getMemBuffer(
+        {(const char *)Sec->Loc, Sec->Size}, Key, false);
+    Map->insert({Key, std::move(Buf)});
+  }
+  return make<DWARFContextInMemory>(*Map, Config->Wordsize, Config->IsLE);
+}
+
+void GdbIndexSection::readDwarf(InputSection *DebugInfo) {
+  DWARFContextInMemory *Dwarf =
+      createDwarfContext(getDebugSections(DebugInfo->File));
 
   size_t CuId = CompilationUnits.size();
-  for (std::pair<uint64_t, uint64_t> &P : readCuList(Dwarf, Sec))
+  for (std::pair<uint64_t, uint64_t> &P : readCuList(*Dwarf, DebugInfo))
     CompilationUnits.push_back(P);
 
-  for (AddressEntry &Ent : readAddressArea(Dwarf, Sec, CuId))
-    AddressArea.push_back(Ent);
+  // We do not scan and remember address ranges here because .debug_ranges
+  // section is not relocated yet. We calculate the amount of ranges only here.
+  // That gives us enough information to calculate .gdb_index section size
+  // early. We will parse ranges later, after performing the relocations.
+  AddressRangesAmount += getAddressRangesCount(*Dwarf);
 
   std::vector<std::pair<StringRef, uint8_t>> NamesAndTypes =
-      readPubNamesAndTypes(Dwarf, Config->IsLE);
+      readPubNamesAndTypes(*Dwarf, Config->IsLE);
 
   for (std::pair<StringRef, uint8_t> &Pair : NamesAndTypes) {
     uint32_t Hash = hash(Pair.first);
     size_t Offset = StringPool.add(Pair.first);
 
     bool IsNew;
     GdbSymbol *Sym;
     std::tie(IsNew, Sym) = SymbolTable.add(Hash, Offset);
if (InputSection *IS = dyn_cast<InputSection>(S))
       if (IS->OutSec && IS->Name == ".debug_info")
         readDwarf(IS);
 
   SymbolTable.finalizeContents();
 
   // GdbIndex header consist from version fields
   // and 5 more fields with different kinds of offsets.
   CuTypesOffset = CuListOffset + CompilationUnits.size() * CompilationUnitSize;
-  SymTabOffset = CuTypesOffset + AddressArea.size() * AddressEntrySize;
+  SymTabOffset = CuTypesOffset + AddressRangesAmount * AddressEntrySize;
 
   ConstantPoolOffset =
       SymTabOffset + SymbolTable.getCapacity() * SymTabEntrySize;
 
   for (std::vector<std::pair<uint32_t, uint8_t>> &CuVec : CuVectors) {
     CuVectorsOffset.push_back(CuVectorsSize);
     CuVectorsSize += OffsetTypeSize * (CuVec.size() + 1);
   }
void GdbIndexSection::writeTo(uint8_t *Buf) {
 
   // Write the CU list.
   for (std::pair<uint64_t, uint64_t> CU : CompilationUnits) {
     write64le(Buf, CU.first);
     write64le(Buf + 8, CU.second);
     Buf += 16;
   }
 
-  // Write the address area.
-  for (AddressEntry &E : AddressArea) {
-    uint64_t BaseAddr = E.Section->OutSec->Addr + E.Section->getOffset(0);
-    write64le(Buf, BaseAddr + E.LowAddress);
-    write64le(Buf + 8, BaseAddr + E.HighAddress);
-    write32le(Buf + 16, E.CuIndex);
+  // Write the address area. Here we use relocated data written
+  // to output file. We feed this data to DWARF parser, it
+  // uses relocated .debug_ranges section content to
+  // obtain correct (relocated) address ranges.
+  size_t CuID = 0;
+  DWARFContextInMemory *Dwarf = createRelocatedDwarfContext();
+  std::vector<DWARFAddressRangesVector> V = readRanges(*Dwarf);
+  for (DWARFAddressRangesVector &Ranges : V) {
+    for (std::pair<uint64_t, uint64_t> &R : Ranges) {
+      write64le(Buf, R.first);
+      write64le(Buf + 8, R.second);
+      write32le(Buf + 16, CuID);
       Buf += 20;
     }
+    ++CuID;
+  }
 
   // Write the symbol table.
   for (size_t I = 0; I < SymbolTable.getCapacity(); ++I) {
     GdbSymbol *Sym = SymbolTable.getSymbol(I);
     if (Sym) {
       size_t NameOffset =
           Sym->NameOffset + StringPoolOffset - ConstantPoolOffset;
       size_t CuVectorOffset = CuVectorsOffset[Sym->CuVectorIndex];

ELF/Writer.cpp

for (InputSectionBase *S : llvm::reverse(InputSections)) {
     if (OutSec->Sections.empty())
       V.erase(std::find(V.begin(), V.end(), OutSec));
   }
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::finalizeSections() {
   Out::DebugInfo = findSection(".debug_info");
+  Out::DebugAbbrev = findSection(".debug_abbrev");
+  Out::DebugGnuPubNames = findSection(".debug_gnu_pubnames");
+  Out::DebugGnuPubTypes = findSection(".debug_gnu_pubtypes");
+  Out::DebugRanges = findSection(".debug_ranges");
+
   Out::PreinitArray = findSection(".preinit_array");
   Out::InitArray = findSection(".init_array");
   Out::FiniArray = findSection(".fini_array");
 
   // The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop
   // symbols for sections, so that the runtime can get the start and end
   // addresses of each section by section name. Add such symbols.
   if (!Config->Relocatable) {

test/ELF/Inputs/gdb-index-ranges.s

+## Code below is a simplified output from next invocation:
+## clang temp.cpp -ffunction-sections -gsplit-dwarf -S -o out.s
+##
+## Where temp.cpp is:
+## void ccc() { }
+## float ddd() { return 0.0f; }
+##
+
+.text
+.section .text._Z3cccv,"ax",@progbits
+.globl _Z3cccv
+.type _Z3cccv,@function
+_Z3cccv:
+.Lfunc_begin0:
+nop
+.Lfunc_end0:
+
+.section .text._Z3dddv,"ax",@progbits
+.globl _Z3dddv
+.type _Z3dddv,@function
+_Z3dddv:
+.Lfunc_begin1:
+nop
+.Lfunc_end1:
+
+
+.section .debug_str,"MS",@progbits,1
+.Lskel_string0:
+ .asciz "1.dwo"
+.Lskel_string1:
+ .asciz "testcase2"
+
+.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 .Lline_table_start0     # DW_AT_stmt_list
+ .long .Lskel_string0          # DW_AT_GNU_dwo_name
+ .long .Lskel_string1          # DW_AT_comp_dir
+ .quad -943190174132613613     # DW_AT_GNU_dwo_id
+ .long .debug_addr             # 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 0
+ .quad 0
+
+.section .debug_addr,"",@progbits
+ .quad .Lfunc_begin0
+ .quad .Lfunc_begin1
+
+.Lline_table_start0:

test/ELF/gdb-index-ranges.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/gdb-index-ranges.s -o %t2.o
+
+# RUN: ld.lld --gdb-index %t1.o %t2.o -o %t
+# RUN: llvm-dwarfdump -debug-dump=gdb_index %t | FileCheck %s
+# RUN: llvm-objdump -d %t | FileCheck %s --check-prefix=DISASM
+
+# CHECK:      CU list offset = 0x18, has 2 entries:
+# CHECK-NEXT:   0: Offset = 0x0, Length = 0x30
+# CHECK-NEXT:   1: Offset = 0x30, Length = 0x30
+# CHECK:      Address area offset = 0x38, has 4 entries:
+# CHECK-NEXT:   Low address = 0x201000, High address = 0x201001, CU index = 0
+# CHECK-NEXT:   Low address = 0x201001, High address = 0x201002, CU index = 0
+# CHECK-NEXT:   Low address = 0x201004, High address = 0x201005, CU index = 1
+# CHECK-NEXT:   Low address = 0x201005, High address = 0x201006, CU index = 1
+
+# DISASM:     Disassembly of section .text:
+# DISASM-NEXT:  _Z3aaav:
+# DISASM-NEXT:    201000
+# DISASM:       _Z3bbbv:
+# DISASM-NEXT:    201001
+# DISASM:       _Z3cccv:
+# DISASM-NEXT:    201004
+# DISASM:       _Z3dddv:
+# DISASM-NEXT:    201005
+
+## Code below is a simplified output from next invocation:
+## clang temp.cpp -ffunction-sections -gsplit-dwarf -S -o out.s
+##
+## Where temp.cpp is:
+## void aaa() { }
+## float bbb() { return 0.0f; }
+##
+
+.text
+.section .text._Z3aaav,"ax",@progbits
+.globl _Z3aaav
+.type _Z3aaav,@function
+_Z3aaav:                 
+.Lfunc_begin0:
+nop
+.Lfunc_end0:
+
+.section .text._Z3bbbv,"ax",@progbits
+.globl _Z3bbbv
+.type _Z3bbbv,@function
+_Z3bbbv:
+.Lfunc_begin1:
+nop
+.Lfunc_end1:
+
+
+.section .debug_str,"MS",@progbits,1
+.Lskel_string0:
+ .asciz "1.dwo"
+.Lskel_string1:
+ .asciz "testcase"
+
+.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 .Lline_table_start0     # DW_AT_stmt_list
+ .long .Lskel_string0          # DW_AT_GNU_dwo_name
+ .long .Lskel_string1          # DW_AT_comp_dir
+ .quad -943190174132613613     # DW_AT_GNU_dwo_id
+ .long .debug_addr             # 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 0
+ .quad 0
+
+.section .debug_addr,"",@progbits
+ .quad .Lfunc_begin0
+ .quad .Lfunc_begin1
+
+.Lline_table_start0: