[ELF] - Partial support of --gdb-index command line option (Part 1).

[grimar]

Summary

This patch is extracted from D24267 which implements the --gdb-index option.
(aim is to reduce and split review parts)

In this patch partial gdb_index section is created.
For costructing the .gdb_index section 6 steps should be performed (details are in
SplitDebugInfo.cpp file header), this patch do first 3:

1. Creates proper section header.
2. Fills list of compilation units.
3. Types CU list area is not supposed to be supported, so it is ignored and therefore

can be treated as implemented either.

[davide]

+ Adrian/Eric for the debug info side of things, as they're the expert in the area.

[aprantl]

Some minor nitpicks.
Eric, David, can you look at how this fits into the big picture for split debug info. support on ELF platforms?

ELF/SplitDebugInfo.cpp

11

Any way this could be doxygen-ified?

18

Since LLVM already supports split debug info I don't think there is a need to re-explain this here — But there might be a better place to document this: Maybe it makes sense to move the general introuction to SourceLevelDebugging.rst?

29

Maybe better link to the DWARF 5 specification?
http://dwarfstd.org/Issues.php?type=closed4

60

constructing

ELF/SplitDebugInfo.h

59

Please convert all of these top-level class comments to Doxygen comments by using ///

[ruiu]

ELF/OutputSections.cpp

81

According to the comment, CuListOffset can be a compile-time constant rather than computing at runtime here.

114

I think you can just make a copy here (i.e. remove &)

ELF/SplitDebugInfo.cpp

11

Part of this file comment was a copy from other document. You need to add citation.

ELF/SplitDebugInfo.h

59

We do not use doxygen-style comments in any file in this directory. Maybe we should, but we probably should do it all at once in a different patch.

[grimar]

• Addressed review comments.

[grimar]

ELF/OutputSections.cpp

81

Done.

114

Done.

ELF/SplitDebugInfo.cpp

11

As Rui mentioned, we do not use doxygen comments in lld at this moment.
Added quotes and references to source.

18

Ok, I cut off most of information from this header and added just a very short intro for now.

29

Done.

60

Fixed.

[grimar]

• Last minute fix.

[ruiu]

ELF/OutputSections.cpp

65

Please include a file name in the error message.

71

Looks like this can be written in a more functional programming style like this.

CompilationUnits = readDwarf(I);

where readDwarf is a new function that returns a new vector.

Currently, it is not clear what DwarfInfoReader would do to its arguments.

86–110

I'd save lines here.

write32le(Buf, 7);                   // Version
write32le(Buf + 4, CutListOffset);   // [what is this?]
write32le(Buf + 8, CutListOffset);   // Offset of the address area
write32le(Buf + 12, CutListOffset);  // ...
...
Buf += 24;

Or, maybe we should define a struct for the header in libObject/libSupport.

[grimar]

• Addressed review comments.

ELF/OutputSections.cpp

65

Which one ? DebugInfoSec here is an output section:

if (Out<ELFT>::GdbIndex)
  Out<ELFT>::GdbIndex->DebugInfoSec = findSection(".debug_info");

It is used as a container of .debug_info sections to parse. I think generally it is ok that some object may not have it.
But I checked gold and found it just does not emit the .gdb_index instead of showing error if there is no .debug_info input sections at all, so I removed that error either.

71

Rewrote.

86–110

Done. I do not think struct for just a header of some output section worth that. I think we dont have any such for other output sections, and also it looks soon CuTypesOffset can be removed (as types data area is depricated), I expect to see it in version 8, do not think we want to have structs of different versions or something like that.

[grimar]

Ping.

[grimar]

Ping.

[echristo]

I think calling the file SplitDebugInfo.cpp is a bit of a misnomer, there's nothing related to fission/split-dwarf/etc in it other than a couple of references. Also not sure why we need yet another dwarf parser here rather than using the one in llvm?

Looks fine otherwise though.

-eric

ELF/SplitDebugInfo.cpp

290

"parcer" -> "parser"

test/ELF/gdb-index.s

2

"were generated in this way"

[grimar]

• Addressed review comments.
• Reduced testcase.

[grimar]

In D24706#561568, @echristo wrote:

I think calling the file SplitDebugInfo.cpp is a bit of a misnomer, there's nothing related to fission/split-dwarf/etc in it other than a couple of references. Also not sure why we need yet another dwarf parser here rather than using the one in llvm?

Looks fine otherwise though.

-eric

Thanks for comments, Eric !

I called it SplitDebugInfo.cpp initially as this patch is a part of D24267 where this file contains whole functionality needed
by linker for generation --gdb-index, for example implementation of symbol hash table (GdbHashTab). So it is relative to fussion.
I am fine with renaming it to something if you think it is misnomer though. May be GdbIndex.cpp ?

We are trying to keep code minimal and fast in linker, but llvm parsers are generic and generally do more job than we need, short quick example:
Imaging I want to get address ranges and so I want to use DWARFDebugInfoEntryMinimal::getAddressRanges(const DWARFUnit *U).
For doing that I need DWARFUnit, which requires DWARFContext in constructor. Looking at comments that says
"DWARFContextInMemory is the simplest possible implementation of a DWARFContext.", I am opening its constructor and
see that it takes an object and do a scan over all sections uncompresses the compressed ones. But we do not need that as we already have
content of sections available.

D24267 which is full version of this functionality shows that we seems need not that lot of parsing code for --gdb-index option in total,
I think using own inplementation should allow to make it faster.

ELF/SplitDebugInfo.cpp

290

Done.

test/ELF/gdb-index.s

2

Done.

[grimar]

• Reimplemented using llvm dwarf parser.

[grimar]

Ping.

[grimar]

If we land this, I`ll be able to prepare next patch for this functionality and also will suggest few changes for parsers as I found they lack some functionality I need for next steps.

[ruiu]

ELF/CMakeLists.txt

2

Sort

ELF/Config.h

2–3

Sort

ELF/GdbIndex.cpp

12 ↗

(On Diff #74263)

This long comment doesn't match with what you do in this patch. You want to add this later.

ELF/GdbIndex.h

22 ↗

(On Diff #74263)

You can remove this class and replace a non-member function readCuList(InputSection<ELFT> *).

ELF/OutputSections.cpp

81

Write version -> Version for consistency.

81–86

Remove . from comments because they are not sentences.

ELF/Writer.cpp

9–1

I think you want to do the same as the other sections here and remove DebugInfoSec.

Out<ELFT>::DebugInfo = findSection(".debug_info");

[grimar]

• Addressed review comments.

ELF/CMakeLists.txt

2

Done.

ELF/Config.h

2–3

Done.

ELF/GdbIndex.cpp

12 ↗

(On Diff #74263)

I believe it is fine. It describes what is gdb_index and what linker should do to support this feature.
And at the end it contains what we (in this patch) do now:

Current version of implementation has 1, 2, 3 steps. So it writes .gdb_index
header and list of compilation units. Since we so not plan to support types
CU list area, it is also empty and so far is "implemented".
Other data areas are not yet implemented.

So during next patches I plan to modify that last part and finally remove it when all be done.

ELF/GdbIndex.h

22 ↗

(On Diff #74263)

Ok, though I am thinking about this patch as about skeleton which intention is to reduce changes for futher parts.
Removing this class much probably means I`ll need to restore it in next one anyways.

ELF/OutputSections.cpp

81

Done.

81–86

Done.

ELF/Writer.cpp

9–1

Done.

[echristo]

This makes sense to me.

[ruiu]

ELF/GdbIndex.cpp

76 ↗

(On Diff #74970)

Remove llvm::.

76–85 ↗

(On Diff #74970)

78 ↗

(On Diff #74970)

It seems that createObjectFile parses the file again. Can you avoid that?

88 ↗

(On Diff #74970)

Replace auto with its concrete type.

94–101 ↗

(On Diff #74970)

Remove Sec. Use uint32_t and uint64_t instead of ELF????::uint.

[grimar]

• Addressed review comments.

ELF/GdbIndex.cpp

76 ↗

(On Diff #74970)

Done.

78 ↗

(On Diff #74970)

I afraid current parsers API does not allow that yet.

Starting from next patch for this feature, I am planing to suggest changes for DWARF parsers API as it seems not possible to do things I need for next steps without some changes.
An parallel task might be optimization of parsers entrypoints for linker needs then, there is a room for that.

I suggest to land this one first because then it will be easy to justify the need of parsers changes and adding linker specific functionality.

88 ↗

(On Diff #74970)

Done.

94–101 ↗

(On Diff #74970)

Done.

[ruiu]

Please land this patch with the following fixes.

ELF/GdbIndex.h

15 ↗

(On Diff #75113)

Move this to the .cpp file.

ELF/Options.td

3–1

Sort.

ELF/Writer.cpp

11

Remove the blank line and clang-format.

ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 add_lld_library(lldELF
   Driver.cpp
   DriverUtils.cpp
   EhFrame.cpp
   ELFCreator.cpp
   Error.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
   MarkLive.cpp
   Mips.cpp
   OutputSections.cpp
   Relocations.cpp
   ScriptParser.cpp
+  SplitDebugInfo.cpp
   Strings.cpp
   SymbolListFile.cpp
   SymbolTable.cpp
   Symbols.cpp
   Target.cpp
   Thunks.cpp
   Writer.cpp
 

ELF/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_CONFIG_H
 #define LLD_ELF_CONFIG_H
struct Configuration {
   bool Bsymbolic;
   bool BsymbolicFunctions;
   bool Demangle = true;
   bool DisableVerify;
   bool EhFrameHdr;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool FatalWarnings;
+  bool GdbIndex;
   bool GcSections;
   bool GnuHash = false;
   bool ICF;
   bool Mips64EL = false;
   bool NoGnuUnique;
   bool NoUndefinedVersion;
   bool Nostdlib;
   bool OFormatBinary;

ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->Demangle = getArg(Args, OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Discard = getDiscardOption(Args);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->FatalWarnings = Args.hasArg(OPT_fatal_warnings);
   Config->GcSections = getArg(Args, OPT_gc_sections, OPT_no_gc_sections, false);
+  Config->GdbIndex = Args.hasArg(OPT_gdb_index);
   Config->ICF = Args.hasArg(OPT_icf);
   Config->NoGnuUnique = Args.hasArg(OPT_no_gnu_unique);
   Config->NoUndefinedVersion = Args.hasArg(OPT_no_undefined_version);
   Config->Nostdlib = Args.hasArg(OPT_nostdlib);
   Config->Pie = Args.hasArg(OPT_pie);
   Config->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);

ELF/InputFiles.h

public:
   ArrayRef<SymbolBody *> getSymbols();
   ArrayRef<SymbolBody *> getLocalSymbols();
   ArrayRef<SymbolBody *> getNonLocalSymbols();
 
   explicit ObjectFile(MemoryBufferRef M);
   void parse(llvm::DenseSet<StringRef> &ComdatGroups);
 
   ArrayRef<InputSectionBase<ELFT> *> getSections() const { return Sections; }
+  InputSectionBase<ELFT> *getSection(uint32_t Index) const;
   InputSectionBase<ELFT> *getSection(const Elf_Sym &Sym) const;
 
   SymbolBody &getSymbolBody(uint32_t SymbolIndex) const {
     return *SymbolBodies[SymbolIndex];
   }
 
   template <typename RelT> SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);

ELF/InputFiles.cpp

template <class ELFT> void elf::ObjectFile<ELFT>::initializeSymbols() {
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms)
     SymbolBodies.push_back(createSymbolBody(&Sym));
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
-elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
-  uint32_t Index = this->getSectionIndex(Sym);
+elf::ObjectFile<ELFT>::getSection(uint32_t Index) const {
   if (Index == 0)
     return nullptr;
   if (Index >= Sections.size())
     fatal(getFilename(this) + ": invalid section index: " + Twine(Index));
   InputSectionBase<ELFT> *S = Sections[Index];
   // We found that GNU assembler 2.17.50 [FreeBSD] 2007-07-03
   // could generate broken objects. STT_SECTION symbols can be
   // associated with SHT_REL[A]/SHT_SYMTAB/SHT_STRTAB sections.
   // In this case it is fine for section to be null here as we
   // do not allocate sections of these types.
   if (!S || S == &InputSectionBase<ELFT>::Discarded)
     return S;
   return S->Repl;
 }
 
 template <class ELFT>
+InputSectionBase<ELFT> *
+elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
+  return getSection(this->getSectionIndex(Sym));
+}
+
+template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   int Binding = Sym->getBinding();
   InputSectionBase<ELFT> *Sec = getSection(*Sym);
   if (Binding == STB_LOCAL) {
     if (Sym->st_shndx == SHN_UNDEF)
       return new (this->Alloc)
           Undefined(Sym->st_name, Sym->st_other, Sym->getType(), this);
     return new (this->Alloc) DefinedRegular<ELFT>(*Sym, Sec);

ELF/Options.td

 include "llvm/Option/OptParser.td"
 
 // For options whose names are multiple letters, either one dash or
 // two can precede the option name except those that start with 'o'.
 class F<string name>: Flag<["--", "-"], name>;
 class J<string name>: Joined<["--", "-"], name>;
 class S<string name>: Separate<["--", "-"], name>;
 class JS<string name>: JoinedOrSeparate<["--", "-"], name>;
 
def hash_style: S<"hash-style">,
   HelpText<"Specify hash style (sysv, gnu or both)">;
 
 def help: F<"help">, HelpText<"Print option help">;
 
 def icf: F<"icf=all">, HelpText<"Enable identical code folding">;
 
 def image_base : J<"image-base=">, HelpText<"Set the base address">;
 
+def gdb_index: F<"gdb-index">,
+  HelpText<"Generate .gdb_index section">;
+
 def init: S<"init">, MetaVarName<"<symbol>">,
   HelpText<"Specify an initializer function">;
 
 def l: JoinedOrSeparate<["-"], "l">, MetaVarName<"<libName>">,
   HelpText<"Root name of library to use">;
 
 def lto_O: J<"lto-O">, MetaVarName<"<opt-level>">,
   HelpText<"Optimization level for LTO">;

ELF/OutputSections.h

 //===- OutputSections.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_OUTPUT_SECTIONS_H
 #define LLD_ELF_OUTPUT_SECTIONS_H
 
 #include "Config.h"
 #include "Relocations.h"
+#include "SplitDebugInfo.h"
 
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/SHA1.h"
 
public:
   virtual void writeTo(uint8_t *Buf) {}
   virtual ~OutputSectionBase() = default;
 
 protected:
   StringRef Name;
   Elf_Shdr Header;
 };
 
+template <class ELFT>
+class GdbIndexSection final : public OutputSectionBase<ELFT> {
+  typedef typename ELFT::uint uintX_t;
+
+  const unsigned OffsetTypeSize = 4;
+  const unsigned CuListOffset = 6 * OffsetTypeSize;
+  const unsigned CompilationUnitSize = 16;
+  const unsigned AddressEntrySize = 16 + OffsetTypeSize;
+  const unsigned SymTabEntrySize = 2 * OffsetTypeSize;
+
+public:
+  GdbIndexSection();
+  void finalize() override;
+  void writeTo(uint8_t *Buf) override;
+
+  // Stores pointer to .debug_info output section.
+  OutputSectionBase<ELFT> *DebugInfoSec = nullptr;
+
+  // Pairs of [CU Offset, CU length].
+  std::vector<std::pair<uintX_t, uintX_t>> CompilationUnits;
+
+private:
+  void parseDebugSections();
+  void readDwarf(InputSection<ELFT> *I);
+
+  uint32_t CuTypesOffset;
+};
+
 template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;

 // until Writer is initialized.
 template <class ELFT> struct Out {
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Phdr Elf_Phdr;
   static BuildIdSection<ELFT> *BuildId;
   static DynamicSection<ELFT> *Dynamic;
   static EhFrameHeader<ELFT> *EhFrameHdr;
   static EhOutputSection<ELFT> *EhFrame;
+  static GdbIndexSection<ELFT> *GdbIndex;
   static GnuHashTableSection<ELFT> *GnuHashTab;
   static GotPltSection<ELFT> *GotPlt;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
   static InterpSection<ELFT> *Interp;
   static OutputSection<ELFT> *Bss;
   static OutputSection<ELFT> *MipsRldMap;
   static OutputSectionBase<ELFT> *Opd;

 private:
   llvm::SmallDenseMap<Key, OutputSectionBase<ELFT> *> Map;
 };
 
 template <class ELFT> BuildIdSection<ELFT> *Out<ELFT>::BuildId;
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> EhFrameHeader<ELFT> *Out<ELFT>::EhFrameHdr;
 template <class ELFT> EhOutputSection<ELFT> *Out<ELFT>::EhFrame;
+template <class ELFT> GdbIndexSection<ELFT> *Out<ELFT>::GdbIndex;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::MipsRldMap;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;

ELF/OutputSections.cpp

 //===- OutputSections.cpp -------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OutputSections.h"
 #include "Config.h"
 #include "EhFrame.h"
 #include "LinkerScript.h"
+#include "SplitDebugInfo.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "lld/Core/Parallel.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SHA1.h"

 }
 
 template <class ELFT>
 void OutputSectionBase<ELFT>::writeHeaderTo(Elf_Shdr *Shdr) {
   *Shdr = Header;
 }
 
 template <class ELFT>
+GdbIndexSection<ELFT>::GdbIndexSection()
+    : OutputSectionBase<ELFT>(".gdb_index", SHT_PROGBITS, 0) {}
+
+template <class ELFT> void GdbIndexSection<ELFT>::parseDebugSections() {
+  std::vector<InputSection<ELFT> *> &IS =
+      static_cast<OutputSection<ELFT> *>(DebugInfoSec)->Sections;
+  for (InputSection<ELFT> *I : IS)
+    readDwarf(I);
+}
+
+template <class ELFT>
+void GdbIndexSection<ELFT>::readDwarf(InputSection<ELFT> *I) {
+  DwarfInfoReader<ELFT> Reader(I);
+
+  std::vector<std::pair<uintX_t, uintX_t>> CuList = Reader.readCuList();
+  CompilationUnits.insert(CompilationUnits.end(), CuList.begin(), CuList.end());
+}
+
+template <class ELFT> void GdbIndexSection<ELFT>::finalize() {
+  parseDebugSections();
+
+  // GdbIndex header consist from version fields
+  // and 5 more fields with different kinds of offsets.
+  CuTypesOffset = CuListOffset + CompilationUnits.size() * CompilationUnitSize;
+  this->Header.sh_size = CuTypesOffset;
+}
+
+template <class ELFT> void GdbIndexSection<ELFT>::writeTo(uint8_t *Buf) {
+  write32le(Buf, 7);                  // Write version.
+  write32le(Buf + 4, CuListOffset);   // CU list offset.
+  write32le(Buf + 8, CuTypesOffset);  // Types CU list offset.
+  write32le(Buf + 12, CuTypesOffset); // Address area offset.
+  write32le(Buf + 16, CuTypesOffset); // Symbol table offset.
+  write32le(Buf + 20, CuTypesOffset); // Constant pool offset.
+  Buf += 24;
+
+  // Write the CU list.
+  for (std::pair<uintX_t, uintX_t> CU : CompilationUnits) {
+    write64le(Buf, CU.first);
+    write64le(Buf + 8, CU.second);
+    Buf += 16;
+  }
+}
+
+template <class ELFT>
 GotPltSection<ELFT>::GotPltSection()
     : OutputSectionBase<ELFT>(".got.plt", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
   this->Header.sh_addralign = Target->GotPltEntrySize;
 }
 
 template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody &Sym) {
   Sym.GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
   Entries.push_back(&Sym);
 }
 
 template <class ELFT> bool GotPltSection<ELFT>::empty() const {
   return Entries.empty();
 }
 
 template <class ELFT> void GotPltSection<ELFT>::finalize() {
   this->Header.sh_size = (Target->GotPltHeaderEntriesNum + Entries.size()) *
                          Target->GotPltEntrySize;
 }

 template class BuildIdUuid<ELF64LE>;
 template class BuildIdUuid<ELF64BE>;
 
 template class BuildIdHexstring<ELF32LE>;
 template class BuildIdHexstring<ELF32BE>;
 template class BuildIdHexstring<ELF64LE>;
 template class BuildIdHexstring<ELF64BE>;
 
+template class GdbIndexSection<ELF32LE>;
+template class GdbIndexSection<ELF32BE>;
+template class GdbIndexSection<ELF64LE>;
+template class GdbIndexSection<ELF64BE>;
+
 template class OutputSectionFactory<ELF32LE>;
 template class OutputSectionFactory<ELF32BE>;
 template class OutputSectionFactory<ELF64LE>;
 template class OutputSectionFactory<ELF64BE>;
 }
 }

ELF/SplitDebugInfo.h

+//===- SplitDebugInfo.h --------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===-------------------------------------------------------------------===//
+
+#ifndef LLD_ELF_SPLIT_DEBUG_INFO_H
+#define LLD_ELF_SPLIT_DEBUG_INFO_H
+
+#include "InputFiles.h"
+#include "llvm/Object/ELF.h"
+
+namespace lld {
+namespace elf {
+
+template <class ELFT> class DwarfDieParser;
+template <class ELFT> class GdbIndexSection;
+template <class ELFT> class InputSection;
+
+// Helper class for extracting relocations data.
+template <class ELFT> class RelocMapper {
+  typedef typename ELFT::uint uintX_t;
+  typedef typename ELFT::Shdr Elf_Shdr;
+  typedef typename ELFT::Rel Elf_Rel;
+  typedef typename ELFT::Rela Elf_Rela;
+  typedef typename ELFT::Sym Elf_Sym;
+
+  InputSection<ELFT> *Sec;
+
+  const Elf_Shdr &RelSec;
+  const llvm::object::ELFFile<ELFT> &EObj;
+
+  size_t Position = 0;
+
+  uintX_t getNextRelocAddend();
+  uintX_t getNextRelocOffset();
+  uintX_t getNextRelocSymbolIndex();
+
+  template <class RelT> void advance(ArrayRef<RelT> Rel, uintX_t Offset);
+  void advanceToOffset(uintX_t Offset);
+
+public:
+  RelocMapper(InputSection<ELFT> *Sec);
+  uintX_t lookupReloc(uintX_t RelOffset, uintX_t *TargetOffset);
+};
+
+struct AbbreviationCode {
+  AbbreviationCode(uint64_t Tag) : Tag(Tag){};
+  uint64_t Tag;
+  std::vector<std::pair<uint64_t, uint64_t>> Attributes; // [Attr, Form]
+};
+
+// The abbreviations tables for all compilation units are contained in a
+// separate object file section called ".debug_abbrev".
+// Defines the abbreviation codes used by the skeleton .debug_info section.
+template <class ELFT> class DwarfAbbrevTable {
+  typedef typename ELFT::uint uintX_t;
+  typedef typename ELFT::Shdr Elf_Shdr;
+
+public:
+  void read(elf::ObjectFile<ELFT> *File, uintX_t Shndx, uintX_t Offset);
+
+  AbbreviationCode *getEntry(uint32_t Code);
+
+protected:
+  ArrayRef<uint8_t> Data;
+  uint32_t AbbrevOffset = (uint32_t)-1;
+  uintX_t AbbrevShndx = (uint32_t)-1;
+  llvm::DenseMap<uint32_t, std::unique_ptr<AbbreviationCode>> Codes;
+};
+
+// Main class that is used to scan all .debug_info sections.
+template <class ELFT> class DwarfInfoReader {
+  typedef typename ELFT::uint uintX_t;
+
+  ArrayRef<uint8_t> Data;
+
+  elf::ObjectFile<ELFT> *PubObject = nullptr;
+
+public:
+  DwarfInfoReader(InputSection<ELFT> *Sec) : DebugInfoSec(Sec) {}
+  std::vector<std::pair<uintX_t, uintX_t>> readCuList();
+
+  ArrayRef<uint8_t> getDataAtOffset(uintX_t CuOffset, uintX_t Offset);
+
+  DwarfAbbrevTable<ELFT> AbbrevTable;
+  uint8_t AddressSize;
+  InputSection<ELFT> *DebugInfoSec;
+};
+
+// DWARF uses a series of debugging information entries (DIEs) to define a
+// low-level representation of a source program. Each debugging information
+// entry consists of an identifying tag and a series of attributes. This class
+// is used to parce DIEs.
+template <class ELFT> class DwarfDieParser {
+  typedef typename ELFT::uint uintX_t;
+
+  const DwarfInfoReader<ELFT> &Reader;
+  RelocMapper<ELFT> &Mapper;
+
+  uintX_t CuOffset;
+  uintX_t DieOffset;
+
+public:
+  DwarfDieParser(DwarfInfoReader<ELFT> &Reader, RelocMapper<ELFT> &Mapper,
+                 uintX_t CuOffset, uintX_t DieOffset);
+
+  AbbreviationCode *AbbreviationEntry;
+};
+
+} // namespace elf
+} // namespace lld
+
+#endif

ELF/SplitDebugInfo.cpp

+//===- SplitDebugInfo.cpp -------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// File contains classes for implementation of --gdb-index command line option.
+//
+// If that option is used, linker should emit a .gdb_index section that allows
+// debugger to locate and read .dwo files, containing neccessary debug
+// information.
+// More information about implementation can be found in DWARF specification,
+// latest version is available at http://dwarfstd.org.
+//
+// .gdb_index section format:
+//  (Information is based on/taken from
+//  https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html (*))
+//
+// A mapped index consists of several areas, laid out in order:
+// 1) The file header.
+// 2) "The CU (compilation unit) list. This is a sequence of pairs of 64-bit
+//    little-endian values, sorted by the CU offset. The first element in each
+//    pair is the offset of a CU in the .debug_info section. The second element
+//    in each pair is the length of that CU. References to a CU elsewhere in the
+//    map are done using a CU index, which is just the 0-based index into this
+//    table. Note that if there are type CUs, then conceptually CUs and type CUs
+//    form a single list for the purposes of CU indices."(*)
+// 3) The types CU list. Depricated as .debug_types does not appear in the DWARF
+//    v5 specification.
+// 4) The address area. The address area is a sequence of address
+//    entries, where each entrie contains low address, high address and CU
+//    index.
+// 5) "The symbol table. This is an open-addressed hash table. The size of the
+//    hash table is always a power of 2. Each slot in the hash table consists of
+//    a pair of offset_type values. The first value is the offset of the
+//    symbol's name in the constant pool. The second value is the offset of the
+//    CU vector in the constant pool."(*)
+// 6) "The constant pool. This is simply a bunch of bytes. It is organized so
+//    that alignment is correct: CU vectors are stored first, followed by
+//    strings." (*)
+//
+// For constructing the .gdb_index section following steps should be performed:
+// 1) For file header nothing special should be done. It contains the offsets to
+//    the areas below.
+// 2) Scan the compilation unit headers of the .debug_info sections to build a
+//    list of compilation units.
+// 3) CU Types are no longer needed as DWARF skeleton type units never made it
+//    into the standard. lld does nothing to support parsing of .debug_types
+//    and generates empty types CU area in .gdb_index section.
+// 4) Address area entries are extracted from DW_TAG_compile_unit DIEs of
+//   .debug_info sections.
+// 5) For building the symbol table linker extracts the public names from the
+//   .debug_gnu_pubnames and .debug_gnu_pubtypes sections. Then it builds the
+//   hashtable in according to .gdb_index format specification.
+// 6) Constant pool is populated at the same time as symbol table.
+//
+// Current version of implementation has 1, 2, 3 steps. So it writes .gdb_index
+// header and list of compilation units. Since we so not plan to support types
+// CU list area, it is also empty and so far is "implemented".
+// Other data areas are not yet implemented.
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+#include "OutputSections.h"
+#include "SplitDebugInfo.h"
+
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/LEB128.h"
+
+using namespace llvm;
+using namespace llvm::ELF;
+using namespace llvm::object;
+using namespace llvm::support::endian;
+using namespace lld;
+using namespace lld::elf;
+
+template <class ELFT>
+RelocMapper<ELFT>::RelocMapper(InputSection<ELFT> *Sec)
+    : Sec(Sec), RelSec(*Sec->RelocSections[0]), EObj(Sec->getFile()->getObj()) {
+}
+
+template <class ELFT>
+typename ELFT::uint RelocMapper<ELFT>::lookupReloc(uintX_t RelOffset,
+                                                   uintX_t *TargetOffset) {
+  advanceToOffset(RelOffset);
+
+  if (RelOffset != getNextRelocOffset())
+    return 0;
+
+  elf::ObjectFile<ELFT> *File = Sec->getFile();
+  const Elf_Shdr *SymTab = File->getSymbolTable();
+  const Elf_Sym *Sym =
+      File->getObj().getSymbol(SymTab, getNextRelocSymbolIndex());
+
+  *TargetOffset = Sym->st_value + getNextRelocAddend();
+  return Sym->st_shndx;
+}
+
+template <class ELFT>
+typename ELFT::uint RelocMapper<ELFT>::getNextRelocAddend() {
+  if (RelSec.sh_type == SHT_RELA)
+    return EObj.relas(&RelSec)[Position].r_addend;
+  else
+    return 0;
+}
+
+template <class ELFT>
+typename ELFT::uint RelocMapper<ELFT>::getNextRelocOffset() {
+  if (RelSec.sh_type == SHT_RELA) {
+    ArrayRef<Elf_Rela> Relas = EObj.relas(&RelSec);
+    if (Position >= Relas.size())
+      return (uintX_t)-1;
+    return Relas[Position].r_offset;
+  }
+
+  ArrayRef<Elf_Rel> Rels = EObj.rels(&RelSec);
+  if (Position >= Rels.size())
+    return (uintX_t)-1;
+  return Rels[Position].r_offset;
+}
+
+template <class ELFT>
+typename ELFT::uint RelocMapper<ELFT>::getNextRelocSymbolIndex() {
+  if (RelSec.sh_type == SHT_RELA) {
+    ArrayRef<Elf_Rela> Relas = EObj.relas(&RelSec);
+    if (Position >= Relas.size())
+      return (uintX_t)-1;
+    return Relas[Position].getSymbol(Config->Mips64EL);
+  }
+
+  ArrayRef<Elf_Rel> Rels = EObj.rels(&RelSec);
+  if (Position >= Rels.size())
+    return (uintX_t)-1;
+  return Rels[Position].getSymbol(Config->Mips64EL);
+}
+
+template <class ELFT>
+template <class RelT>
+void RelocMapper<ELFT>::advance(ArrayRef<RelT> Rel, uintX_t Offset) {
+  for (size_t E = Rel.size(); Position != E; ++Position)
+    if (Rel[Position].r_offset >= Offset)
+      break;
+}
+
+template <class ELFT> void RelocMapper<ELFT>::advanceToOffset(uintX_t Offset) {
+  if (RelSec.sh_type == SHT_RELA)
+    return advance(EObj.relas(&RelSec), Offset);
+  else
+    return advance(EObj.rels(&RelSec), Offset);
+}
+
+template <class ELFT>
+void DwarfAbbrevTable<ELFT>::read(elf::ObjectFile<ELFT> *File, uintX_t Shndx,
+                                  uintX_t Offset) {
+  // Multiple debugging information entries may share the same abbreviation
+  // table entry. Each compilation unit is associated with a particular
+  // abbreviation table, but multiple compilation units may share the same
+  // table. If we already read this table then just return.
+  if (AbbrevOffset == Offset && this->AbbrevShndx == Shndx)
+    return;
+  AbbrevOffset = Offset;
+  AbbrevShndx = Shndx;
+
+  if (InputSectionBase<ELFT> *Sec = File->getSection(AbbrevShndx))
+    Data = Sec->Data;
+  else
+    fatal("error retriving .debug_abbrev section");
+}
+
+template <class ELFT>
+AbbreviationCode *DwarfAbbrevTable<ELFT>::getEntry(uint32_t Code) {
+  auto It = Codes.find(Code);
+  if (It != Codes.end())
+    return It->second.get();
+
+  // Read and store abbrev code definitions until we find the
+  // one we're looking for.
+  while (true) {
+    // Each declaration begins with an unsigned LEB128 number representing the
+    // abbreviation code itself.
+    unsigned N;
+    uint64_t NextCode = decodeULEB128(Data.data(), &N);
+    if (NextCode == 0)
+      return nullptr;
+    Data = Data.drop_front(N);
+
+    // The abbreviation code is followed by another
+    // unsigned LEB128 number that encodes the entry痴 tag.
+    uint64_t Tag = decodeULEB128(Data.data(), &N);
+    Data = Data.drop_front(N);
+
+    // Following the tag encoding is a 1 byte value that determines whether a
+    // debugging information entry using this abbreviation has child entries.
+    Data = Data.drop_front(1);
+
+    std::unique_ptr<AbbreviationCode> NewCode =
+        std::make_unique<AbbreviationCode>(Tag);
+    while (true) {
+      uint64_t Attr = decodeULEB128(Data.data(), &N);
+      Data = Data.drop_front(N);
+      uint64_t Form = decodeULEB128(Data.data(), &N);
+      Data = Data.drop_front(N);
+
+      // The series of attribute specifications ends with an entry containing 0
+      // for the name and 0 for the form.
+      if (Attr == 0 && Form == 0)
+        break;
+      NewCode->Attributes.push_back(std::make_pair(Attr, Form));
+    }
+
+    AbbreviationCode *Ret = NewCode.get();
+    Codes[Tag].swap(NewCode);
+    if (NextCode == Code)
+      return Ret;
+  }
+
+  return nullptr;
+}
+
+// For each compilation unit compiled with a DWARF producer, a contribution is
+// made to the .debug_info section of the object file. Each such contribution
+// consists of a compilation unit header followed by a single
+// DW_TAG_compile_unit. (Refer to "DWARF Debugging Information Format V4", 7.5
+// Format of Debugging Information).
+// Method is used to parse .debug_info input sections to extract information
+// needed to produce .gdb_index output section.
+template <class ELFT>
+std::vector<std::pair<typename ELFT::uint, typename ELFT::uint>>
+DwarfInfoReader<ELFT>::readCuList() {
+  const endianness E = ELFT::TargetEndianness;
+  std::vector<std::pair<uintX_t, uintX_t>> Ret;
+
+  if (DebugInfoSec->RelocSections.size() != 1) {
+    error(".debug_info should have single relocation section");
+    return {};
+  }
+
+  RelocMapper<ELFT> RelocMapper(DebugInfoSec);
+  Data = DebugInfoSec->Data;
+  const uint8_t *PInfo = Data.begin();
+
+  while (PInfo < Data.end()) {
+    const uint8_t *CuStart = PInfo;
+
+    // A 4-byte or 12-byte unsigned integer representing the length of the
+    // .debug_info contribution for that compilation unit, not including the
+    // length field itself.
+    uint32_t UnitLength = read<uint32_t, E>(PInfo);
+    PInfo += sizeof(uint32_t);
+    if (UnitLength == (uint32_t)-1)
+      fatal("64-bits DWARF is not supported");
+
+    const uint8_t *CuEnd = PInfo + UnitLength;
+
+    // A 2-byte unsigned integer representing the version of the DWARF
+    // information for the compilation unit.
+    uint16_t Version = read<uint16_t, E>(PInfo);
+    if (Version != 4)
+      fatal("unsupported version of .debug_info");
+    PInfo += sizeof(uint16_t);
+
+    // Offset into the.debug_abbrev section.This offset associates the
+    // compilation unit with a particular set of debugging information entry
+    // abbreviations. 4 byte unsigned length for 32-bit DWARF.
+    uint32_t AbbrevOffset = read<uint32_t, E>(PInfo);
+
+    // Obtain a index of .debug_abbrev section. We use current offset
+    // in compilation unit that points to AbbrevOffset to search relocation
+    // and retrive target section index which is index of .debug_abbrev.
+    uintX_t AbbrevShndx = 0;
+    uintX_t RelocOffset = PInfo - Data.begin();
+    AbbrevShndx = RelocMapper.lookupReloc(RelocOffset, &AbbrevShndx);
+    if (!AbbrevShndx)
+      fatal(".debug_abbrev section index not found");
+    PInfo += sizeof(uint32_t);
+
+    AddressSize = *PInfo++;
+
+    // Retrive the .debug_abbrev table data.
+    AbbrevTable.read(DebugInfoSec->getFile(), AbbrevShndx, AbbrevOffset);
+
+    uintX_t CuOffset = CuStart - Data.begin();
+
+    // When using -gsplit-dwarf, .debug_info section contains a single
+    // DW_TAG_compile_unit DIE, with no children. Here we create DIE parcer
+    // that reads abbreviation entry and list of atributes.
+    DwarfDieParser<ELFT> RootDie(*this, RelocMapper, CuOffset, PInfo - CuStart);
+
+    // The abbreviation code 0 is reserved. Debugging information entries
+    // consisting of only the abbreviation code 0 are considered null entries,
+    // skip them.
+    if (RootDie.AbbreviationEntry && RootDie.AbbreviationEntry->Tag != 0)
+      Ret.push_back(
+          std::make_pair(DebugInfoSec->OutSecOff + CuOffset, CuEnd - CuStart));
+
+    PInfo = CuEnd;
+  }
+  return Ret;
+}
+
+template <class ELFT>
+ArrayRef<uint8_t> DwarfInfoReader<ELFT>::getDataAtOffset(uintX_t CuOffset,
+                                                         uintX_t Offset) {
+  return Data.drop_front(CuOffset + Offset);
+}
+
+template <class ELFT>
+DwarfDieParser<ELFT>::DwarfDieParser(DwarfInfoReader<ELFT> &Reader,
+                                     RelocMapper<ELFT> &Mapper,
+                                     uintX_t CuOffset, uintX_t DieOffset)
+    : Reader(Reader), Mapper(Mapper), CuOffset(CuOffset), DieOffset(DieOffset) {
+  ArrayRef<uint8_t> Data = Reader.getDataAtOffset(CuOffset, DieOffset);
+
+  // Each debugging information entry begins with an unsigned LEB128 number
+  // containing the abbreviation code for the entry.
+  // This code represents an entry within the abbreviations table
+  // associated with the compilation unit containing this entry.
+  unsigned N;
+  uint64_t C = decodeULEB128(Data.data(), &N);
+  if (!C)
+    fatal("the abbreviation codes 0 are considered null entries");
+
+  // Now get the entry from abbreviation table.
+  AbbreviationEntry = Reader.AbbrevTable.getEntry(C);
+}
+
+template class elf::DwarfInfoReader<ELF32LE>;
+template class elf::DwarfInfoReader<ELF32BE>;
+template class elf::DwarfInfoReader<ELF64LE>;
+template class elf::DwarfInfoReader<ELF64BE>;

ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "Relocations.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
template <class ELFT> void elf::writeResult() {
   ProgramHeaders.updateAlignment(sizeof(uintX_t));
 
   // Instantiate optional output sections if they are needed.
   std::unique_ptr<InterpSection<ELFT>> Interp;
   std::unique_ptr<BuildIdSection<ELFT>> BuildId;
   std::unique_ptr<StringTableSection<ELFT>> DynStrTab;
   std::unique_ptr<SymbolTableSection<ELFT>> DynSymTab;
   std::unique_ptr<EhFrameHeader<ELFT>> EhFrameHdr;
+  std::unique_ptr<GdbIndexSection<ELFT>> GdbIndex;
   std::unique_ptr<GnuHashTableSection<ELFT>> GnuHashTab;
   std::unique_ptr<GotPltSection<ELFT>> GotPlt;
   std::unique_ptr<HashTableSection<ELFT>> HashTab;
   std::unique_ptr<RelocationSection<ELFT>> RelaPlt;
   std::unique_ptr<StringTableSection<ELFT>> StrTab;
   std::unique_ptr<SymbolTableSection<ELFT>> SymTabSec;
   std::unique_ptr<OutputSection<ELFT>> MipsRldMap;
   std::unique_ptr<VersionDefinitionSection<ELFT>> VerDef;
template <class ELFT> void elf::writeResult() {
 
   if (Config->EhFrameHdr)
     EhFrameHdr.reset(new EhFrameHeader<ELFT>);
 
   if (Config->GnuHash)
     GnuHashTab.reset(new GnuHashTableSection<ELFT>);
   if (Config->SysvHash)
     HashTab.reset(new HashTableSection<ELFT>);
+  if (Config->GdbIndex)
+    GdbIndex.reset(new GdbIndexSection<ELFT>);
   StringRef S = Config->Rela ? ".rela.plt" : ".rel.plt";
   GotPlt.reset(new GotPltSection<ELFT>);
   RelaPlt.reset(new RelocationSection<ELFT>(S, false /*Sort*/));
   if (Config->Strip != StripPolicy::All) {
     StrTab.reset(new StringTableSection<ELFT>(".strtab", false));
     SymTabSec.reset(new SymbolTableSection<ELFT>(*StrTab));
   }
   if (Config->EMachine == EM_MIPS && !Config->Shared) {
template <class ELFT> void elf::writeResult() {
 
   Out<ELFT>::Bss = &Bss;
   Out<ELFT>::BuildId = BuildId.get();
   Out<ELFT>::DynStrTab = DynStrTab.get();
   Out<ELFT>::DynSymTab = DynSymTab.get();
   Out<ELFT>::Dynamic = &Dynamic;
   Out<ELFT>::EhFrame = &EhFrame;
   Out<ELFT>::EhFrameHdr = EhFrameHdr.get();
+  Out<ELFT>::GdbIndex = GdbIndex.get();
   Out<ELFT>::GnuHashTab = GnuHashTab.get();
   Out<ELFT>::Got = &Got;
   Out<ELFT>::GotPlt = GotPlt.get();
   Out<ELFT>::HashTab = HashTab.get();
   Out<ELFT>::Interp = Interp.get();
   Out<ELFT>::Plt = &Plt;
   Out<ELFT>::RelaDyn = &RelaDyn;
   Out<ELFT>::RelaPlt = RelaPlt.get();

 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::finalizeSections() {
   Out<ELFT>::PreinitArray = findSection(".preinit_array");
   Out<ELFT>::InitArray = findSection(".init_array");
   Out<ELFT>::FiniArray = findSection(".fini_array");
 
+  if (Out<ELFT>::GdbIndex)
+    Out<ELFT>::GdbIndex->DebugInfoSec = findSection(".debug_info");
+
   // 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) {
     addStartEndSymbols();
     for (OutputSectionBase<ELFT> *Sec : OutputSections)
       addStartStopSymbols(Sec);
   }
template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
 
   // Add .interp at first because some loaders want to see that section
   // on the first page of the executable file when loaded into memory.
   if (Out<ELFT>::Interp)
     OutputSections.insert(OutputSections.begin(), Out<ELFT>::Interp);
 
   // This order is not the same as the final output order
   // because we sort the sections using their attributes below.
+  if (Out<ELFT>::GdbIndex->DebugInfoSec)
+    Add(Out<ELFT>::GdbIndex);
   Add(Out<ELFT>::SymTab);
   Add(Out<ELFT>::ShStrTab);
   Add(Out<ELFT>::StrTab);
   if (Out<ELFT>::DynSymTab) {
     Add(Out<ELFT>::DynSymTab);
 
     bool HasVerNeed = Out<ELFT>::VerNeed->getNeedNum() != 0;
     if (Out<ELFT>::VerDef || HasVerNeed)

test/ELF/gdb-index.s

+## gdb-index-a.elf and gdb-index-b.elf are a test.o and test2.o renamed,
+## were generated in a next way:
+## test.cpp:
+##  double foo1;
+##  float bar1;
+##  void method1() {}
+##  int main() { return 0; }
+## test2.cpp:
+##  double foo2;
+##  char method2() {}
+## Compiled with:
+## gcc -gsplit-dwarf -c test.cpp test2.cpp
+## gcc version 5.3.1 20160413
+## Info about gdb-index: https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html
+
+# REQUIRES: x86
+# RUN: ld.lld --gdb-index -e main %p/Inputs/gdb-index-a.elf %p/Inputs/gdb-index-b.elf -o %t
+# RUN: llvm-dwarfdump -debug-dump=gdb_index %t | FileCheck %s
+# RUN: llvm-objdump -d %t | FileCheck %s --check-prefix=DISASM
+
+# DISASM:      Disassembly of section .text:
+# DISASM-NEXT:  _Z7method1v:
+# DISASM-NEXT:     11000:
+# DISASM-NEXT:     11001:
+# DISASM-NEXT:     11004:
+# DISASM-NEXT:     11005:
+# DISASM-NEXT:     11006:
+# DISASM:      main:
+# DISASM-NEXT:     11007:
+# DISASM-NEXT:     11008:
+# DISASM-NEXT:     1100b:
+# DISASM-NEXT:     11010:
+# DISASM-NEXT:     11011:
+# DISASM:      _Z7method2v:
+# DISASM-NEXT:     11012:
+# DISASM-NEXT:     11013:
+# DISASM-NEXT:     11016:
+# DISASM-NEXT:     11017:
+# DISASM-NEXT:     11018:
+
+# CHECK:      .gnu_index contents:
+# CHECK-NEXT:    Version = 7
+# CHECK:       CU list offset = 0x18, has 2 entries:
+# CHECK-NEXT:      0: Offset = 0x0, Length = 0x34
+# CHECK-NEXT:      1: Offset = 0x34, Length = 0x34
+# CHECK:         Address area offset = 0x38, has 0 entries:
+# CHECK:         Symbol table offset = 0x38, size = 0, filled slots:
+# CHECK:         Constant pool offset = 0x38, has 0 CU vectors: