[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

10 ↗

(On Diff #71746)

Any way this could be doxygen-ified?

17 ↗

(On Diff #71746)

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?

28 ↗

(On Diff #71746)

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

59 ↗

(On Diff #71746)

constructing

ELF/SplitDebugInfo.h

58 ↗

(On Diff #71746)

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

[ruiu]

ELF/OutputSections.cpp

81 ↗

(On Diff #71746)

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

114 ↗

(On Diff #71746)

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

ELF/SplitDebugInfo.cpp

10 ↗

(On Diff #71746)

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

ELF/SplitDebugInfo.h

58 ↗

(On Diff #71746)

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 ↗

(On Diff #71746)

Done.

114 ↗

(On Diff #71746)

Done.

ELF/SplitDebugInfo.cpp

10 ↗

(On Diff #71746)

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

17 ↗

(On Diff #71746)

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

28 ↗

(On Diff #71746)

Done.

59 ↗

(On Diff #71746)

Fixed.

[grimar]

• Last minute fix.

[ruiu]

ELF/OutputSections.cpp

65 ↗

(On Diff #71939)

Please include a file name in the error message.

71 ↗

(On Diff #71939)

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 ↗

(On Diff #71939)

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 ↗

(On Diff #71939)

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 ↗

(On Diff #71939)

Rewrote.

86–110 ↗

(On Diff #71939)

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 ↗

(On Diff #72037)

"parcer" -> "parser"

test/ELF/gdb-index.s

2 ↗

(On Diff #72037)

"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 ↗

(On Diff #72037)

Done.

test/ELF/gdb-index.s

2 ↗

(On Diff #72037)

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

21 ↗

(On Diff #74263)

Sort

ELF/Config.h

101–102 ↗

(On Diff #74263)

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

90 ↗

(On Diff #74263)

Write version -> Version for consistency.

90–95 ↗

(On Diff #74263)

Remove . from comments because they are not sentences.

ELF/Writer.cpp

777 ↗

(On Diff #74263)

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

21 ↗

(On Diff #74263)

Done.

ELF/Config.h

101–102 ↗

(On Diff #74263)

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

90 ↗

(On Diff #74263)

Done.

90–95 ↗

(On Diff #74263)

Done.

ELF/Writer.cpp

777 ↗

(On Diff #74263)

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

96–102 ↗

(On Diff #75113)

Sort.

ELF/Writer.cpp

775 ↗

(On Diff #75113)

Remove the blank line and clang-format.

lld/trunk/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
+  GdbIndex.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
   MarkLive.cpp
   Mips.cpp
   OutputSections.cpp

lld/trunk/ELF/Config.h

struct Configuration {
   bool BsymbolicFunctions;
   bool Demangle = true;
   bool DisableVerify;
   bool EhFrameHdr;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool FatalWarnings;
   bool GcSections;
+  bool GdbIndex;
   bool GnuHash = false;
   bool ICF;
   bool Mips64EL = false;
   bool NoGnuUnique;
   bool NoUndefinedVersion;
   bool Nostdlib;
   bool OFormatBinary;
   bool Pic;

lld/trunk/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 = getArg(Args, OPT_pie, OPT_nopie, false);
   Config->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);

lld/trunk/ELF/GdbIndex.h

+//===- GdbIndex.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_GDB_INDEX_H
+#define LLD_ELF_GDB_INDEX_H
+
+#include "InputFiles.h"
+#include "llvm/Object/ELF.h"
+
+namespace lld {
+namespace elf {
+
+template <class ELFT> class InputSection;
+
+template <class ELFT>
+std::vector<std::pair<typename ELFT::uint, typename ELFT::uint>>
+readCuList(InputSection<ELFT> *Sec);
+
+} // namespace elf
+} // namespace lld
+
+#endif

lld/trunk/ELF/GdbIndex.cpp

+//===- GdbIndex.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 "GdbIndex.h"
+
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+template <class ELFT>
+std::vector<std::pair<typename ELFT::uint, typename ELFT::uint>>
+lld::elf::readCuList(InputSection<ELFT> *DebugInfoSec) {
+  typedef typename ELFT::uint uintX_t;
+
+  std::unique_ptr<DWARFContext> Dwarf;
+  if (Expected<std::unique_ptr<object::ObjectFile>> Obj =
+          object::ObjectFile::createObjectFile(DebugInfoSec->getFile()->MB))
+    Dwarf.reset(new DWARFContextInMemory(*Obj.get()));
+
+  if (!Dwarf) {
+    error(getFilename(DebugInfoSec->getFile()) +
+          ": error creating DWARF context");
+    return {};
+  }
+
+  std::vector<std::pair<uintX_t, uintX_t>> Ret;
+  for (std::unique_ptr<DWARFCompileUnit> &CU : Dwarf->compile_units())
+    Ret.push_back(
+        {DebugInfoSec->OutSecOff + CU->getOffset(), CU->getLength() + 4});
+  return Ret;
+}
+
+template std::vector<std::pair<uint32_t, uint32_t>>
+lld::elf::readCuList<ELF32LE>(InputSection<ELF32LE> *);
+template std::vector<std::pair<uint32_t, uint32_t>>
+lld::elf::readCuList<ELF32BE>(InputSection<ELF32BE> *);
+template std::vector<std::pair<uint64_t, uint64_t>>
+lld::elf::readCuList<ELF64LE>(InputSection<ELF64LE> *);
+template std::vector<std::pair<uint64_t, uint64_t>>
+lld::elf::readCuList<ELF64BE>(InputSection<ELF64BE> *);

lld/trunk/ELF/Options.td

def fini: S<"fini">, MetaVarName<"<symbol>">,
   HelpText<"Specify a finalizer function">;
 
 def format: J<"format=">, MetaVarName<"<input-format>">,
   HelpText<"Change the input format of the inputs following this option">;
 
 def gc_sections: F<"gc-sections">,
   HelpText<"Enable garbage collection of unused sections">;
 
+def gdb_index: F<"gdb-index">,
+  HelpText<"Generate .gdb_index section">;
+
 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">;

lld/trunk/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 "GdbIndex.h"
 #include "Relocations.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 ~OutputSectionBase() = default;
 
 protected:
   StringRef Name;
   Elf_Shdr Header;
   uintX_t LMAOffset = 0;
 };
 
+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;
+
+  // 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;
   static uint8_t *OpdBuf;
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;
   static StringTableSection<ELFT> *ShStrTab;
   static StringTableSection<ELFT> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
   static VersionDefinitionSection<ELFT> *VerDef;
   static VersionTableSection<ELFT> *VerSym;
   static VersionNeedSection<ELFT> *VerNeed;
   static Elf_Phdr *TlsPhdr;
+  static OutputSectionBase<ELFT> *DebugInfo;
   static OutputSectionBase<ELFT> *ElfHeader;
   static OutputSectionBase<ELFT> *ProgramHeaders;
 
   static OutputSectionBase<ELFT> *PreinitArray;
   static OutputSectionBase<ELFT> *InitArray;
   static OutputSectionBase<ELFT> *FiniArray;
 
   // This pool owns dynamically-allocated output sections.
if (Config->OFormatBinary)
     return 0;
   return Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
 }
 
 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;
 template <class ELFT> uint8_t *Out<ELFT>::OpdBuf;
 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::DynStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::ShStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::StrTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::DynSymTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::SymTab;
 template <class ELFT> VersionDefinitionSection<ELFT> *Out<ELFT>::VerDef;
 template <class ELFT> VersionTableSection<ELFT> *Out<ELFT>::VerSym;
 template <class ELFT> VersionNeedSection<ELFT> *Out<ELFT>::VerNeed;
 template <class ELFT> typename ELFT::Phdr *Out<ELFT>::TlsPhdr;
+template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::DebugInfo;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::ElfHeader;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::ProgramHeaders;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::PreinitArray;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::InitArray;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::FiniArray;
 
 template <class ELFT>
 std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> Out<ELFT>::Pool;

lld/trunk/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 "GdbIndex.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/RandomNumberGenerator.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> *>(Out<ELFT>::DebugInfo)->Sections;
+
+  for (InputSection<ELFT> *I : IS)
+    readDwarf(I);
+}
+
+template <class ELFT>
+void GdbIndexSection<ELFT>::readDwarf(InputSection<ELFT> *I) {
+  std::vector<std::pair<uintX_t, uintX_t>> CuList = readCuList(I);
+  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 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>;
 }
 }

lld/trunk/ELF/Writer.cpp

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();
while (NonScriptI != E) {
     std::rotate(FirstGreater, NonScriptI, NonScriptI + 1);
     ++NonScriptI;
     ++I;
   }
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::finalizeSections() {
+  Out<ELFT>::DebugInfo = findSection(".debug_info");
   Out<ELFT>::PreinitArray = findSection(".preinit_array");
   Out<ELFT>::InitArray = findSection(".init_array");
   Out<ELFT>::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) {
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 && Out<ELFT>::DebugInfo)
+    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)

lld/trunk/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 this way:
+## test.cpp:
+##  int main() { return 0; }
+## test2.cpp:
+##  int main2() { return 0; }
+## 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:       main:
+# DISASM-CHECK:     11000: 55 pushq %rbp
+# DISASM-CHECK:     11001: 48 89 e5 movq %rsp, %rbp
+# DISASM-CHECK:     11004: b8 00 00 00 00 movl $0, %eax
+# DISASM-CHECK:     11009: 5d popq %rbp
+# DISASM-CHECK:     1100a: c3 retq
+# DISASM:       _Z5main2v:
+# DISASM-CHECK:     1100b: 55 pushq %rbp
+# DISASM-CHECK:     1100c: 48 89 e5  movq %rsp, %rbp
+# DISASM-CHECK:     1100f: b8 00 00 00 00 movl $0, %eax
+# DISASM-CHECK:     11014: 5d popq %rbp
+# DISASM-CHECK:     11015: c3 retq
+
+# 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: