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

[grimar]

Summary

Patch continues work started in D24706 and D25821.

in this patch symbol table and constant pool areas were
added to .gdb_index section output.

Together with D25821 it should finish
the --gdb-index implementation in LLD.
(it is independent and can be committed/reviewed separatelly).

[grimar]

Ping.

[grimar]

Ping.

• Rebased.

[clayborg]

Seems like the GdbIndex isn't specific to ELF. I know the file started off here and that some of the template classes you use are using ELF defines, but they don't really need to be in the ELF plug-in.

Would we want to move this functionality to the lib/DebugInfo/Dwarf/DWARFGdbIndex.cpp file so that other file formats like mach-o and COFF could create the gdb index section and be able to emit it? This code accesses existing DWARF sections and then creates the .gdb-index section contents.

ELF/GdbIndex.cpp

63

Since we "do" not plan

ELF/SyntheticSections.cpp

1441 ↗

(On Diff #80402)

use std::tie here with appropriate var names since you did it below?

1442 ↗

(On Diff #80402)

I am guessing we can guarantee that the StringRef is NULL terminated here since the string probably originated from a string table.

1522 ↗

(On Diff #80402)

use std::tie?

[grimar]

In D26283#615115, @clayborg wrote:

Seems like the GdbIndex isn't specific to ELF. I know the file started off here and that some of the template classes you use are using ELF defines, but they don't really need to be in the ELF plug-in.

Would we want to move this functionality to the lib/DebugInfo/Dwarf/DWARFGdbIndex.cpp file so that other file formats like mach-o and COFF could create the gdb index section and be able to emit it? This code accesses existing DWARF sections and then creates the .gdb-index section contents.

If so I am not sure what is better ?

1. Do that before landing this+D25821.
2. Continue with landing above for ELF, complete and test functionality and then move it to lib/Debuginfo/Dwarf/* ?.

I would also create separate file for this like lib/DebugInfo/Dwarf/DWARFGdbIndexBuilder.cpp as DWARFGdbIndex.cpp is a parser and probably
better not to mix them.

[clayborg]

In D26283#615621, @grimar wrote:

In D26283#615115, @clayborg wrote:

Seems like the GdbIndex isn't specific to ELF. I know the file started off here and that some of the template classes you use are using ELF defines, but they don't really need to be in the ELF plug-in.

Would we want to move this functionality to the lib/DebugInfo/Dwarf/DWARFGdbIndex.cpp file so that other file formats like mach-o and COFF could create the gdb index section and be able to emit it? This code accesses existing DWARF sections and then creates the .gdb-index section contents.

If so I am not sure what is better ?

1. Do that before landing this+D25821.
2. Continue with landing above for ELF, complete and test functionality and then move it to lib/Debuginfo/Dwarf/* ?.

Not sure either. Probably fine to land it here with this change then migrate it.

I would also create separate file for this like lib/DebugInfo/Dwarf/DWARFGdbIndexBuilder.cpp as DWARFGdbIndex.cpp is a parser and probably
better not to mix them.

If it is the same stuff, I don't see a problem with the class being able to parse and generate the gdb index. You would probably share a lot of the same data structures and it would be a shame to duplicate those.

ELF/GdbIndex.cpp

101–102

What happens if there is no pubnames or pubtypes? Do we want a separate path that actually manually goes through the DWARF and generates the correct info when these sections are missing?

Does the GDB index really live only on the pubnames and pubtypes? How useful is the GDB index if it doesn't include static functions and private types?

[clayborg]

Ah, I missed the extra "gnu" in the pubnames and pubtypes. If these sections don't exist, can we generate them on the fly using common code and then use the generated data?

[grimar]

ELF/SyntheticSections.cpp

1441 ↗

(On Diff #80402)

I am not sure what you mean, sorry. Do you meant next form ?

for (auto& p : someInitializingFunction()) {
  std::tie(a, b) = p;
  // do stuff;
}

If so I am probably missing for what.

1442 ↗

(On Diff #80402)

Yes, and hash() relies on that. Do you want to change hash() signature ?

[clayborg]

See inlined comments.

ELF/GdbIndex.cpp

106–119

Might be worth putting this pubnames/pubtypes parser into the llvm/lib/DebugInfo/DWARF. We don't currently have a parser for this there. The more we duplicate code that is manually parsing DWARF sections outside of the DWARF parser the more fixes we need to make if the format gets updated.

ELF/SyntheticSections.cpp

1417 ↗

(On Diff #80402)

Use StringRef here instead of "const char *"?

1420 ↗

(On Diff #80402)

Use the StringRef iteration here?

1429 ↗

(On Diff #80402)

Maybe add a:

if (Finalized)
  return;

So that this code works if asserts are not enabled? I would be great to reduce the amounts of places that use assert unconditionally in the llvm codebase.

1441 ↗

(On Diff #80402)

Never mind, I was thinking you can use std::tie in the for loop:

for (std::tie(Name, Type) : NamesAndTypes) {

but you can't.

1442 ↗

(On Diff #80402)

Might be safer to change the hash() signature if the only way we use it is with an llvm::StringRef.

1522 ↗

(On Diff #80402)

Never mind, can't use std::tie in for loop

[grimar]

• Addressed review comments.
• Make StringPool to be Kind of llvm::StringTableBuilder::ELF, that is correct I think and after that output for testcase is equal to gold.

ELF/GdbIndex.cpp

63

Done.

106–119

I wonder if that can be done in the following patch then ?
As far I understand that requires changing void dumpPubSection() from DebugInfo\DWARF\DWARFContext.cpp to something,
it should not be a big problem, I just suppose it is easier to do if we have at least one user of new functionality, so we can discuss the design of that change separatelly when see needs.
What do you think ? (I am ok to do take task of doing that change either before or after anyways, have no major preference here except that landing changes of this patch first makes things a bit easier to maintain).

ELF/SyntheticSections.cpp

1417 ↗

(On Diff #80402)

Done.

1420 ↗

(On Diff #80402)

Done.

1429 ↗

(On Diff #80402)

I removed this assert. readDwarf() is now called only from parseDebugSections, which is already protected by

if (Finalized)
  return;
parseDebugSections();

So actually it was bit excessive assert. If for some reason this method will be called when Finalized, we should catch it in testcase anyways I think.

1442 ↗

(On Diff #80402)

Done.

[grimar]

• Addressed comment not included by mistake in prev diff.

[clayborg]

So it looks like it is down to wether we need to actually do the pubnames parsing stuff in lib/DebugInfo/DWARF or not. I'll let other make that call.

ELF/GdbIndex.cpp

119

I'll let others comment on what is right to do as I am just starting out reviewing things in LLVM and don't know all the ropes. David?

[dblaikie]

ELF/GdbIndex.cpp

119

Yeah, we go back and forth on stuff like this - in this case I think the code is short (granted, that also means the work to do it ahead of time isn't that big either) & George has been pretty responsive/quick on feedback/changes like this, so I'm OK with it going in after this patch.

[clayborg]

I am good with the patch but I'll let others actually mark as accepted.

[grimar]

David, Greg, thanks !

[grimar]

Sorry, I am pinging this again because I am just not sure who is that person for approving this then ? I just see no objections from reviewers currently and looks all comments are addressed. I am also will be happy to prepare a discussed patch for LLVM parsers right after this one landed.
Landing this one + D25821 looks allows us to include gdb-index functionality into upcoming release planned early in 2017 afaik.

[aprantl]

I have a few more stylistic issues, but after fixing that, feel free to commit.

ELF/GdbIndex.cpp

158

Coding guidelines want this to be a doxygen comment on the declaration in the header.
Is it possible to paraphrase the contents of the links in the comment? We don't usually put links into comments.

ELF/SyntheticSections.cpp

1416 ↗

(On Diff #80894)

same here.

[grimar]

Thank you for review Adrian !
I'll address all comments for this and D25821 with little general change:
we do not use Doxygen comments in tools/lld/ELF/* yet.

So I'll add regular ones for each place where it was requested. I am not sure why we do not use
Doxygen, but that moment already was discussed for these gdb_index patches before, so I hope it is still fine.

[grimar]

r289810

ELF/GdbIndex.cpp

158

In LLD we often use the links in comments. Though in that case code itself just implements the formulas described in documentation. I replaced the link with short sentence about how it works in general.
And as I mentioned earlier, we do not use oxygen style comments in that lld folder yet, so that also was not changed.

ELF/SyntheticSections.cpp

1416 ↗

(On Diff #80894)

I removed the link and added a short comment. We still have link in the file header, this comment refers to it.

[aprantl]

In D26283#623354, @grimar wrote:

Thank you for review Adrian !
I'll address all comments for this and D25821 with little general change:
we do not use Doxygen comments in tools/lld/ELF/* yet.

Now that's a really strange deviation from the LLVM coding guidelines! Why would we not want to use Doxygen comments there? Can someone explain the motivation behind this?

• adrian

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"
+#include "llvm/DebugInfo/DWARF/DWARFContext.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);
+template <class ELFT> class GdbIndexBuilder {
+  typedef typename ELFT::uint uintX_t;
+
+  InputSection<ELFT> *DebugInfoSec;
+
+  std::unique_ptr<llvm::DWARFContext> Dwarf;
+
+public:
+  GdbIndexBuilder(InputSection<ELFT> *DebugInfoSec);
+
+  std::vector<std::pair<uintX_t, uintX_t>> readCuList();
+
+  std::vector<std::pair<StringRef, uint8_t>> readPubNamesAndTypes();
+};
+
+// 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;
+};
+
+// This class manages the hashed symbol table for the .gdb_index section.
+// The hash value for a table entry is computed by applying an iterative hash
+// function to the symbol's name.
+class GdbHashTab final {
+public:
+  std::pair<bool, GdbSymbol *> add(uint32_t Hash, size_t Offset);
+
+  size_t getCapacity() { return Table.size(); }
+  GdbSymbol *getSymbol(size_t I) { return Table[I]; }
+
+private:
+  void expand();
+
+  GdbSymbol **findSlot(uint32_t Hash, size_t Offset);
+
+  llvm::BumpPtrAllocator Alloc;
+  std::vector<GdbSymbol *> Table;
+
+  // Size keeps the amount of filled entries in Table.
+  size_t Size = 0;
+
+  // Initial size must be a power of 2.
+  static const int32_t InitialSize = 1024;
+};
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/GdbIndex.cpp

 //    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.
+// Current version of implementation has 1, 2, 3, 5, 6 steps. So it writes
+// .gdb_index header and list of compilation units. Also it builds and writes
+// symbol table and constant pool.
+// Since we so not plan to support types CU list area, it is also empty and
+// so far is "implemented". Address area is the only not implemented part.
 //===----------------------------------------------------------------------===//
 
 #include "GdbIndex.h"
 
-#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/Object/ELFObjectFile.h"
 
 using namespace llvm;
+using namespace llvm::dwarf;
 using namespace llvm::object;
+using namespace lld::elf;
 
 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;
+GdbIndexBuilder<ELFT>::GdbIndexBuilder(InputSection<ELFT> *DebugInfoSec)
+    : DebugInfoSec(DebugInfoSec) {
   if (Expected<std::unique_ptr<object::ObjectFile>> Obj =
           object::ObjectFile::createObjectFile(DebugInfoSec->getFile()->MB))
     Dwarf.reset(new DWARFContextInMemory(*Obj.get()));
-
-  if (!Dwarf) {
+  else
     error(getFilename(DebugInfoSec->getFile()) +
           ": error creating DWARF context");
-    return {};
-  }
 
+template <class ELFT>
+std::vector<std::pair<typename ELFT::uint, typename ELFT::uint>>
+GdbIndexBuilder<ELFT>::readCuList() {
   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> *);
+template <class ELFT>
+std::vector<std::pair<StringRef, uint8_t>>
+GdbIndexBuilder<ELFT>::readPubNamesAndTypes() {
+  const bool IsLE = ELFT::TargetEndianness == llvm::support::little;
+  StringRef Data[] = {Dwarf->getGnuPubNamesSection(),
+                      Dwarf->getGnuPubTypesSection()};
+
+  std::vector<std::pair<StringRef, uint8_t>> Ret;
+  for (StringRef D : Data) {
+    DataExtractor PubNames(D, IsLE, 0);
+    uint32_t Offset = 0;
+    while (PubNames.isValidOffset(Offset)) {
+      // Skip length, version, unit offset and size.
+      Offset += 14;
+      while (Offset < D.size()) {
+        uint32_t DieRef = PubNames.getU32(&Offset);
+        if (DieRef == 0)
+          break;
+        uint8_t Flags = PubNames.getU8(&Offset);
+        const char *Name = PubNames.getCStr(&Offset);
+        Ret.push_back({{Name, strlen(Name) + 1}, Flags});
+      }
+    }
+  }
+
+  return Ret;
+}
+
+std::pair<bool, GdbSymbol *> GdbHashTab::add(uint32_t Hash, size_t Offset) {
+  if (Size * 4 / 3 >= Table.size())
+    expand();
+
+  GdbSymbol **Slot = findSlot(Hash, Offset);
+  bool New = false;
+  if (*Slot == nullptr) {
+    ++Size;
+    *Slot = new (Alloc) GdbSymbol(Hash, Offset);
+    New = true;
+  }
+  return {New, *Slot};
+}
+
+void GdbHashTab::expand() {
+  if (Table.empty()) {
+    Table.resize(InitialSize);
+    return;
+  }
+  std::vector<GdbSymbol *> NewTable(Table.size() * 2);
+  NewTable.swap(Table);
+
+  for (GdbSymbol *Sym : NewTable) {
+    if (!Sym)
+      continue;
+    GdbSymbol **Slot = findSlot(Sym->NameHash, Sym->NameOffset);
+    *Slot = Sym;
+  }
+}
+
+// Methods finds a slot for symbol with given hash.
+// The step size used to find the next candidate
+// slot when handling a hash collision is specified in .gdb_index section format
+// (https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html)
+GdbSymbol **GdbHashTab::findSlot(uint32_t Hash, size_t Offset) {
+  uint32_t Index = Hash & (Table.size() - 1);
+  uint32_t Step = ((Hash * 17) & (Table.size() - 1)) | 1;
+
+  for (;;) {
+    GdbSymbol *S = Table[Index];
+    if (!S || ((S->NameOffset == Offset) && (S->NameHash == Hash)))
+      return &Table[Index];
+    Index = (Index + Step) & (Table.size() - 1);
+  }
+}
+
+namespace lld {
+namespace elf {
+template class GdbIndexBuilder<ELF32LE>;
+template class GdbIndexBuilder<ELF32BE>;
+template class GdbIndexBuilder<ELF64LE>;
+template class GdbIndexBuilder<ELF64BE>;
+}
+}

ELF/OutputSections.h

 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;
 
+  llvm::StringTableBuilder StringPool;
+
+  GdbHashTab SymbolTable;
+
+  // The CU vector portion of the constant pool.
+  std::vector<std::vector<std::pair<uint32_t, uint8_t>>> CuVectors;
+
 private:
   void parseDebugSections();
   void readDwarf(InputSection<ELFT> *I);
 
   uint32_t CuTypesOffset;
+  uint32_t SymTabOffset;
+  uint32_t ConstantPoolOffset;
+  uint32_t StringPoolOffset;
+
+  size_t CuVectorsSize = 0;
+  std::vector<size_t> CuVectorsOffset;
 };
 
 template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotSection();

ELF/OutputSections.cpp

 
 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) {}
+    : OutputSectionBase<ELFT>(".gdb_index", SHT_PROGBITS, 0),
+      StringPool(llvm::StringTableBuilder::RAW) {}
 
 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);
 }
 
+// Iterative hash function for symbol's name is described at
+// https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html
+static uint32_t hash(const char *Str) {
+  uint32_t R = 0;
+  uint8_t C;
+  while ((C = *Str++) != 0) {
+    C = tolower(C);
+    R = R * 67 + C - 113;
+  }
+  return R;
+}
+
 template <class ELFT>
 void GdbIndexSection<ELFT>::readDwarf(InputSection<ELFT> *I) {
-  std::vector<std::pair<uintX_t, uintX_t>> CuList = readCuList(I);
+  GdbIndexBuilder<ELFT> Builder(I);
+  if (HasError)
+    return;
+
+  size_t CuId = CompilationUnits.size();
+  std::vector<std::pair<uintX_t, uintX_t>> CuList = Builder.readCuList();
   CompilationUnits.insert(CompilationUnits.end(), CuList.begin(), CuList.end());
+
+  std::vector<std::pair<StringRef, uint8_t>> NamesAndTypes =
+      Builder.readPubNamesAndTypes();
+  for (std::pair<StringRef, uint8_t> &Pair : NamesAndTypes) {
+    uint32_t Hash = hash(Pair.first.data());
+    size_t Offset = StringPool.add(Pair.first);
+
+    bool IsNew;
+    GdbSymbol *Sym;
+    std::tie(IsNew, Sym) = SymbolTable.add(Hash, Offset);
+    if (IsNew) {
+      Sym->CuVectorIndex = CuVectors.size();
+      CuVectors.push_back({{CuId, Pair.second}});
+      continue;
+    }
+
+    std::vector<std::pair<uint32_t, uint8_t>> &CuVec =
+        CuVectors[Sym->CuVectorIndex];
+    CuVec.push_back({CuId, Pair.second});
+  }
 }
 
 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;
+
+  SymTabOffset = CuTypesOffset;
+  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);
+  }
+  StringPoolOffset = ConstantPoolOffset + CuVectorsSize;
+
+  StringPool.finalizeInOrder();
+  this->Header.sh_size = StringPoolOffset + StringPool.getSize();
 }
 
 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
+  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, SymTabOffset);       // Symbol table offset
+  write32le(Buf + 20, ConstantPoolOffset); // 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;
   }
+
+  // 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];
+      write32le(Buf, NameOffset);
+      write32le(Buf + 4, CuVectorOffset);
+    }
+    Buf += 8;
+  }
+
+  // Write the CU vectors into the constant pool.
+  for (std::vector<std::pair<uint32_t, uint8_t>> &CuVec : CuVectors) {
+    write32le(Buf, CuVec.size());
+    Buf += 4;
+    for (std::pair<uint32_t, uint8_t> &P : CuVec) {
+      uint32_t Index = P.first;
+      uint8_t Flags = P.second;
+      Index |= Flags << 24;
+      write32le(Buf, Index);
+      Buf += 4;
+    }
+  }
+
+  StringPool.write(Buf);
 }
 
 template <class ELFT>
 GotPltSection<ELFT>::GotPltSection()
     : OutputSectionBase<ELFT>(".got.plt", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
   this->Header.sh_addralign = Target->GotPltEntrySize;
 }
 

test/ELF/gdb-index.s

 # 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:
+# 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 = 1024, filled slots:
+# CHECK-NEXT:   489: Name offset = 0x1c, CU vector offset = 0x0
+# CHECK-NEXT:     String name: main, CU vector index: 0
+# CHECK-NEXT:   754: Name offset = 0x21, CU vector offset = 0x8
+# CHECK-NEXT:     String name: int, CU vector index: 1
+# CHECK-NEXT:   956: Name offset = 0x25, CU vector offset = 0x14
+# CHECK-NEXT:     String name: main2, CU vector index: 2
+# CHECK:      Constant pool offset = 0x2038, has 3 CU vectors:
+# CHECK-NEXT:   0(0x0): 0x30000000
+# CHECK-NEXT:   1(0x8): 0x90000000 0x90000001
+# CHECK-NEXT:   2(0x14): 0x30000001