[llvm-dwarfdump] - Teach dwarfdump to dump gdb-index section.

[grimar]

Summary

gold linker's --gdb-index option currently is able to create the .gdb_index section that allows GDB to locate and read the .dwo files as it needs them,
this helps reduce the total size of the object files processed by the linker.

More info about that:
https://gcc.gnu.org/wiki/DebugFission
https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html

Patch teaches dwarfdump tool to dump this section.

[davide]

include/llvm/DebugInfo/DIContext.h

130

Unsorted?

include/llvm/DebugInfo/DWARF/DWARFContext.h

47

Ditto.

157

You can probably group with the other get*Index()

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

13

This include is dead (I think).

23

I may be wrong, but this seems formatted weirdly. Did you clang-format the patch?

138

Space after dot. Also, open addressed (without the --) maybe?

[grimar]

• Addressed review comments.

[grimar]

Thanks for review, Davide ! My comments below.

include/llvm/DebugInfo/DIContext.h

130

Fixed.

include/llvm/DebugInfo/DWARF/DWARFContext.h

47

Fixed.

157

Fixed.

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

13

You right. Removed.

23

Yes, this file is formatted. What I noticed that clang-formatting is uncommon for this tool. But I guess we want it for new code.

138

Fixed. "open - addressed" was taken from documentation (https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html), I do not know is better.

[davide]

include/llvm/DebugInfo/DWARF/DWARFContext.h

228

Still unsorted.

281

Still unsorted.

328

Still unsorted.

[grimar]

• Addressed Davide's review comments.

include/llvm/DebugInfo/DWARF/DWARFContext.h

228

Fixed.

281

Fixed.

328

Fixed.

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

76

Also fixed here. Though in this place I would sort all options alphabetically probably. Without trying to group them.

[davide]

include/llvm/DebugInfo/DWARF/DWARFGdbIndex.h

65

Missing // LLVM_LIB_DEBUGINFO_DWARFGDBINDEX_H

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

100

Same, "only dumping of version 7 is supported"

124

A better error message would be "Dumping of CU types list is not supported"

[grimar]

• Addressed review comments.

[grimar]

include/llvm/DebugInfo/DWARF/DWARFGdbIndex.h

65

Added. Though only one more header from 19 in the same folder has that, so it does not look common :)

[davide]

I don't have additional comments on this one. Please wait for Rafael before submitting.

[dblaikie]

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

70

consider 'auto' here?

80

Rather than using this ErrMessage string, could the parse function return an llvm::Error? (I can't remember if I've plumbed through any of that in such places yet)

147

I'd suggest writing this (& other similar) loop as a normal for loop - more obvious what it's doing, and that there's no intended/needed side effect of changing the value of SymTableSize.

[grimar]

• Review comments addressed.

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

70

Done.

80

Looks it a bit more common to use report_fatal_error in dwarfdump tool. So I used that instead.

147

Done.

[grimar]

Used in D24267. Ping.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFGdbIndex.h

27

Rather than having another variation of the name 'dwarf compile unit', perhaps this name should have something that makes it clear it's an entyr in the index/table - maybe add 'Entry' as a suffix as with the other entry types defined below?

31

SmallVector? (similarly for the others)

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

94–95

Rather than a fatal error, might be better to be able to continue. (check out how error handling is done for invalid DWARF DIEs, etc - though I think that might be /too/ silent (I think it just quietly fails to parse and then does nothing), so may not be the best model/motivation)

I think some of the parse functions return a boolean about whether they succeeded - you could have it return an llvm::Error that's more descriptive and handle that in the dumper.

103

Rather than asserting, this should be a conditional check (& another error path/return) - the input may be bogus and we shouldn't assert just because we're given a mangled input file.

112–114

Might be worth including the bit from the spec that says what this is, otherwise the description seems to be a bit context-free ("what are these triplets for?" "something to do with CUs and types, but I have to squint to guess that from the end of the description")

117

Not being able to dump it seems different from halting execution if you /see/ it? Should it be ignored or a rendered in a "simplified" format ("10 CU type records found but dumping them is not currently supported" or something)? Is there a reason not to support it?

test/DebugInfo/dwarfdump-dump-gdbindex.test

4–11

What particular things is this test case exercising? It seems like it has a lot of entries in the index, when I would expect fewer/that the test could be a bit narrower in scope, but I may not be understanding what's different about each of the entities you've got in these files.

Do you need multiple different functions? multiple different basic types? (I assume it doesn't really need a 'main', but if you need a function, main could be that function (if you don't need a function, you could link it as a shared library, rather than an executable program - so it'd still get an index, but wouldn't need main))

[grimar]

• Addressed review comments.

[grimar]

First of all, thank you for review, David ! My comments are below.

include/llvm/DebugInfo/DWARF/DWARFGdbIndex.h

27

Done.

31

Done.

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

94–95

Ok, I see. Actually I reviewed files in the same folder and I think dump() is always a void(). At the same time I probably agree that fatal error is far from the best solution. So I reworked it to store a error and report about it later. I think it is a bit more natural way of handling errors in such tools. I mean just storing error state of sub-component and revealing it later during printing look fine for me.

103

Agree, done.

112–114

Please see my comment below.

117

Yes there is a reason, sorry that did not mention it when wrote this patch initially, I updated the comments.

test/DebugInfo/dwarfdump-dump-gdbindex.test

4–11

I see what you mean, I find my solution to be reasonable, sorry.

If you take a look on D24267 which adds support of .gdb_index to lld or even if we talk about format itself: https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html
We can notice that format is not just simple.

I mean I really want to see a few function names and few type names, and want to see some shared type, like "double" I have. At least I want it because we have symbol table, that has own rules for filling. For example I would like to check symbol table filling hash formula and even do not sure that amount of values I have in this test is enough for that. It allows to test few multiple names and few multiple types. It allows to test "double" which is shared type. Generally I do not find this test to be excessive. I think testing of few hash calculated slots is at least good to have.
Probably my words above would work more in case we would talk about generation and not about parsing index, but I think parsing is also worth to check, so I am really do not see reasons to reduce something here at least while testcase is simple like we have now.

[grimar]

• Addressed comments
• Reduced testcase

[davide]

I think this is OK to land. David?

[dblaikie]

Looks alright - some basic cleanup to do before committing.

(we might consider the format changing over time to make it a bit more terse/legible about what it's meant to be describing rather than the mechanical format that it's using to represent that (eg: dumping the string offsets might not be generically useful, just printing the strings might suffice))

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

115

Prefer 'i' (lowercase) for loop indexes

129

Prefer 'i' for loop indexes.

147

Prefer 'i' for loop indexes

158

Generally we use 'i' for loop indexes.

159–160

Maybe just emplace_back()?

161–162

Maybe auto?

[grimar]

In D21503#550217, @dblaikie wrote:

Looks alright - some basic cleanup to do before committing.

Thanks ! I'll commit soon.

(we might consider the format changing over time to make it a bit more terse/legible about what it's meant to be describing rather than the mechanical format that it's using to represent that (eg: dumping the string offsets might not be generically useful, just printing the strings might suffice))

I think if format will change, we should add the testcases, but not remove/modify old ones. I think that offsets dumping is not just usefull but it is the main aim of that testcase because it is the only information we extract from binary, when the string values is what we calculate by ourselves in this dumper. So I would prefer not to print the strings values rather than ignoring offsets dumping, but I think it is useful to look at them either, that works like a proof for fact that we dumped everything correctly.

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

115

Hmm, I`ll do that change, but it looks to be violation of LLVM codestyle for me.

include/llvm/DebugInfo/DIContext.h

enum DIDumpType {
   DIDT_Str,
   DIDT_StrDwo,
   DIDT_StrOffsetsDwo,
   DIDT_AppleNames,
   DIDT_AppleTypes,
   DIDT_AppleNamespaces,
   DIDT_AppleObjC,
   DIDT_CUIndex,
+  DIDT_GdbIndex,
   DIDT_TUIndex,
 };
 
 class DIContext {
 public:
   enum DIContextKind {
     CK_DWARF,
     CK_PDB
   };
   DIContextKind getKind() const { return Kind; }

include/llvm/DebugInfo/DWARF/DWARFContext.h

 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
 
 namespace llvm {
 
 // In place of applying the relocations to the data we've read from disk we use
 // a separate mapping table to the side and checking that at locations in the
 // dwarf where we expect relocated values. This adds a bit of complexity to the
 // dwarf parsing/extraction at the benefit of not allocating memory for the
 // entire size of the debug info sections.
 typedef DenseMap<uint64_t, std::pair<uint8_t, int64_t> > RelocAddrMap;
 
 /// DWARFContext
 /// This data structure is the top level entity that deals with dwarf debug
 /// information parsing. The actual data is supplied through pure virtual
 /// methods that a concrete implementation provides.
 class DWARFContext : public DIContext {
 
   DWARFUnitSection<DWARFCompileUnit> CUs;
   std::deque<DWARFUnitSection<DWARFTypeUnit>> TUs;
   std::unique_ptr<DWARFUnitIndex> CUIndex;
+  std::unique_ptr<DWARFGdbIndex> GdbIndex;
   std::unique_ptr<DWARFUnitIndex> TUIndex;
   std::unique_ptr<DWARFDebugAbbrev> Abbrev;
   std::unique_ptr<DWARFDebugLoc> Loc;
   std::unique_ptr<DWARFDebugAranges> Aranges;
   std::unique_ptr<DWARFDebugLine> Line;
   std::unique_ptr<DWARFDebugFrame> DebugFrame;
   std::unique_ptr<DWARFDebugFrame> EHFrame;
   std::unique_ptr<DWARFDebugMacro> Macro;
 
   DWARFUnitSection<DWARFCompileUnit> DWOCUs;
public:
 
   /// Get the compile unit at the specified index for the DWO compile units.
   DWARFCompileUnit *getDWOCompileUnitAtIndex(unsigned index) {
     parseDWOCompileUnits();
     return DWOCUs[index].get();
   }
 
   const DWARFUnitIndex &getCUIndex();
+  const DWARFGdbIndex &getGdbIndex();
   const DWARFUnitIndex &getTUIndex();
 
   /// Get a pointer to the parsed DebugAbbrev object.
   const DWARFDebugAbbrev *getDebugAbbrev();
 
   /// Get a pointer to the parsed DebugLoc object.
   const DWARFDebugLoc *getDebugLoc();
 
   /// Get a pointer to the parsed dwo abbreviations object.
   const DWARFDebugAbbrev *getDebugAbbrevDWO();
 
public:
   virtual StringRef getStringOffsetDWOSection() = 0;
   virtual StringRef getRangeDWOSection() = 0;
   virtual StringRef getAddrSection() = 0;
   virtual const DWARFSection& getAppleNamesSection() = 0;
   virtual const DWARFSection& getAppleTypesSection() = 0;
   virtual const DWARFSection& getAppleNamespacesSection() = 0;
   virtual const DWARFSection& getAppleObjCSection() = 0;
   virtual StringRef getCUIndexSection() = 0;
+  virtual StringRef getGdbIndexSection() = 0;
   virtual StringRef getTUIndexSection() = 0;
 
   static bool isSupportedVersion(unsigned version) {
     return version == 2 || version == 3 || version == 4 || version == 5;
   }
 private:
   /// Return the compile unit that includes an offset (relative to .debug_info).
   DWARFCompileUnit *getCompileUnitForOffset(uint32_t Offset);
 
   /// Return the compile unit which contains instruction with provided
class DWARFContextInMemory : public DWARFContext {
   StringRef StringOffsetDWOSection;
   StringRef RangeDWOSection;
   StringRef AddrSection;
   DWARFSection AppleNamesSection;
   DWARFSection AppleTypesSection;
   DWARFSection AppleNamespacesSection;
   DWARFSection AppleObjCSection;
   StringRef CUIndexSection;
+  StringRef GdbIndexSection;
   StringRef TUIndexSection;
 
   SmallVector<SmallString<32>, 4> UncompressedSections;
 
 public:
   DWARFContextInMemory(const object::ObjectFile &Obj,
     const LoadedObjectInfo *L = nullptr);
   bool isLittleEndian() const override { return IsLittleEndian; }
   uint8_t getAddressSize() const override { return AddressSize; }
   const DWARFSection &getInfoSection() override { return InfoSection; }
public:
   StringRef getStringOffsetDWOSection() override {
     return StringOffsetDWOSection;
   }
   StringRef getRangeDWOSection() override { return RangeDWOSection; }
   StringRef getAddrSection() override {
     return AddrSection;
   }
   StringRef getCUIndexSection() override { return CUIndexSection; }
+  StringRef getGdbIndexSection() override { return GdbIndexSection; }
   StringRef getTUIndexSection() override { return TUIndexSection; }
 };
 
 }
 
 #endif

include/llvm/DebugInfo/DWARF/DWARFGdbIndex.h

+//===-- DWARFGdbIndex.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_DEBUGINFO_DWARFGDBINDEX_H
+#define LLVM_LIB_DEBUGINFO_DWARFGDBINDEX_H
+
+#include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/raw_ostream.h"
+#include <vector>
+
+namespace llvm {
+class DWARFGdbIndex {
+  uint32_t Version;
+
+  uint32_t CuListOffset;
+  uint32_t AddressAreaOffset;
+  uint32_t SymbolTableOffset;
+  uint32_t ConstantPoolOffset;
+
+  struct CompUnit {
+    uint64_t Offset; // Offset of a CU in the .debug_info section
+    uint64_t Length; // Length of that CU
+  };
+  std::vector<CompUnit> CuList;
+
+  struct AddressEntry {
+    uint64_t LowAddress;  // The low address
+    uint64_t HighAddress; // The high address
+    uint32_t CuIndex;     // The CU index
+  };
+  std::vector<AddressEntry> AddressArea;
+
+  struct SymTableEntry {
+    uint32_t NameOffset; // Offset of the symbol's name in the constant pool
+    uint32_t VecOffset;  // Offset of the CU vector in the constant pool
+  };
+  std::vector<SymTableEntry> SymbolTable;
+
+  // Each value is CU index + attributes
+  std::vector<std::pair<uint32_t, std::vector<uint32_t>>> ConstantPoolVectors;
+
+  StringRef ConstantPoolStrings;
+  uint32_t StringPoolOffset;
+
+  StringRef ErrMessage;
+
+  void dumpCUList(raw_ostream &OS) const;
+  void dumpAddressArea(raw_ostream &OS) const;
+  void dumpSymbolTable(raw_ostream &OS) const;
+  void dumpConstantPool(raw_ostream &OS) const;
+
+public:
+  void dump(raw_ostream &OS) const;
+  void parse(DataExtractor Data);
+};
+}
+
+#endif // LLVM_LIB_DEBUGINFO_DWARFGDBINDEX_H

lib/DebugInfo/DWARF/CMakeLists.txt

 add_llvm_library(LLVMDebugInfoDWARF
   DWARFAbbreviationDeclaration.cpp
   DWARFAcceleratorTable.cpp
   DWARFCompileUnit.cpp
   DWARFContext.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugAranges.cpp
   DWARFDebugFrame.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp
   DWARFDebugLoc.cpp
   DWARFDebugMacro.cpp
   DWARFDebugRangeList.cpp
   DWARFFormValue.cpp
+  DWARFGdbIndex.cpp
   DWARFTypeUnit.cpp
   DWARFUnitIndex.cpp
   DWARFUnit.cpp
   SyntaxHighlighting.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/DWARF
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo
   )

lib/DebugInfo/DWARF/DWARFContext.cpp

if ((DumpType == DIDT_All || DumpType == DIDT_StrOffsetsDwo) &&
     offset = 0;
     uint64_t size = getStringOffsetDWOSection().size();
     while (offset < size) {
       OS << format("0x%8.8x: ", offset);
       OS << format("%8.8x\n", strOffsetExt.getU32(&offset));
     }
   }
 
+  if (DumpType == DIDT_All || DumpType == DIDT_GdbIndex) {
+    OS << "\n.gnu_index contents:\n";
+    getGdbIndex().dump(OS);
+  }
+
   if (DumpType == DIDT_All || DumpType == DIDT_AppleNames)
     dumpAccelSection(OS, "apple_names", getAppleNamesSection(),
                      getStringSection(), isLittleEndian());
 
   if (DumpType == DIDT_All || DumpType == DIDT_AppleTypes)
     dumpAccelSection(OS, "apple_types", getAppleTypesSection(),
                      getStringSection(), isLittleEndian());
 
const DWARFUnitIndex &DWARFContext::getTUIndex() {
 
   DataExtractor TUIndexData(getTUIndexSection(), isLittleEndian(), 0);
 
   TUIndex = llvm::make_unique<DWARFUnitIndex>(DW_SECT_TYPES);
   TUIndex->parse(TUIndexData);
   return *TUIndex;
 }
 
+const DWARFGdbIndex &DWARFContext::getGdbIndex() {
+  if (GdbIndex)
+    return *GdbIndex;
+
+  DataExtractor GdbIndexData(getGdbIndexSection(), true /*LE*/, 0);
+  GdbIndex = llvm::make_unique<DWARFGdbIndex>();
+  GdbIndex->parse(GdbIndexData);
+  return *GdbIndex;
+}
+
 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
   if (Abbrev)
     return Abbrev.get();
 
   DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0);
 
   Abbrev.reset(new DWARFDebugAbbrev());
   Abbrev->extract(abbrData);
StringRef *SectionData =
             .Case("debug_addr", &AddrSection)
             .Case("apple_names", &AppleNamesSection.Data)
             .Case("apple_types", &AppleTypesSection.Data)
             .Case("apple_namespaces", &AppleNamespacesSection.Data)
             .Case("apple_namespac", &AppleNamespacesSection.Data)
             .Case("apple_objc", &AppleObjCSection.Data)
             .Case("debug_cu_index", &CUIndexSection)
             .Case("debug_tu_index", &TUIndexSection)
+            .Case("gdb_index", &GdbIndexSection)
             // Any more debug info sections go here.
             .Default(nullptr);
     if (SectionData) {
       *SectionData = data;
       if (name == "debug_ranges") {
         // FIXME: Use the other dwo range section when we emit it.
         RangeDWOSection = data;
       }

lib/DebugInfo/DWARF/DWARFGdbIndex.cpp

+//===-- DWARFGdbIndex.cpp -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
+#include "llvm/Support/Format.h"
+
+using namespace llvm;
+
+// .gdb_index section format reference:
+// https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html
+
+void DWARFGdbIndex::dumpCUList(raw_ostream &OS) const {
+  OS << format("\n  CU list offset = 0x%x, has %zu entries:", CuListOffset,
+               CuList.size())
+     << '\n';
+  uint32_t I = 0;
+  for (const CompUnit &CU : CuList)
+    OS << format("    %d: Offset = 0x%llx, Length = 0x%llx\n", I++, CU.Offset,
+                 CU.Length);
+}
+
+void DWARFGdbIndex::dumpAddressArea(raw_ostream &OS) const {
+  OS << format("\n  Address area offset = 0x%x, has %zu entries:",
+               AddressAreaOffset, AddressArea.size())
+     << '\n';
+  for (const AddressEntry &Addr : AddressArea)
+    OS << format(
+        "    Low address = 0x%llx, High address = 0x%llx, CU index = %d\n",
+        Addr.LowAddress, Addr.HighAddress, Addr.CuIndex);
+}
+
+void DWARFGdbIndex::dumpSymbolTable(raw_ostream &OS) const {
+  OS << format("\n  Symbol table offset = 0x%x, size = %zu, filled slots:",
+               SymbolTableOffset, SymbolTable.size())
+     << '\n';
+  uint32_t I = -1;
+  for (const SymTableEntry &E : SymbolTable) {
+    ++I;
+    if (!E.NameOffset && !E.VecOffset)
+      continue;
+
+    OS << format("    %d: Name offset = 0x%x, CU vector offset = 0x%x\n", I,
+                 E.NameOffset, E.VecOffset);
+
+    StringRef Name = ConstantPoolStrings.substr(
+        ConstantPoolOffset - StringPoolOffset + E.NameOffset);
+
+    auto CuVector =
+        std::find_if(ConstantPoolVectors.begin(), ConstantPoolVectors.end(),
+                     [&](const std::pair<uint32_t, std::vector<uint32_t>> &V) {
+                       return V.first == E.VecOffset;
+                     });
+    assert(CuVector != ConstantPoolVectors.end() && "Invalid symbol table");
+    uint32_t CuVectorId = CuVector - ConstantPoolVectors.begin();
+    OS << format("      String name: %s, CU vector index: %d\n", Name.data(),
+                 CuVectorId);
+  }
+}
+
+void DWARFGdbIndex::dumpConstantPool(raw_ostream &OS) const {
+  OS << format("\n  Constant pool offset = 0x%x, has %zu CU vectors:",
+               ConstantPoolOffset, ConstantPoolVectors.size());
+  uint32_t I = 0;
+  for (const std::pair<uint32_t, std::vector<uint32_t>> &V :
+       ConstantPoolVectors) {
+    OS << format("\n    %d(0x%x): ", I++, V.first);
+    for (uint32_t Val : V.second)
+      OS << format("0x%x ", Val);
+  }
+  OS << '\n';
+}
+
+void DWARFGdbIndex::dump(raw_ostream &OS) const {
+  if (!ErrMessage.empty()) {
+    OS << ErrMessage;
+    return;
+  }
+
+  OS << "  Version = " << Version << '\n';
+
+  dumpCUList(OS);
+  dumpAddressArea(OS);
+  dumpSymbolTable(OS);
+  dumpConstantPool(OS);
+}
+
+void DWARFGdbIndex::parse(DataExtractor Data) {
+  uint32_t Offset = 0;
+
+  // Only version 7 is supported at this moment.
+  Version = Data.getU32(&Offset);
+  if (Version != 7) {
+    ErrMessage = "only dumping of version 7 is supported";
+    return;
+  }
+
+  CuListOffset = Data.getU32(&Offset);
+  uint32_t CuTypesOffset = Data.getU32(&Offset);
+  AddressAreaOffset = Data.getU32(&Offset);
+  SymbolTableOffset = Data.getU32(&Offset);
+  ConstantPoolOffset = Data.getU32(&Offset);
+
+  assert(Offset == CuListOffset);
+  uint32_t CuListSize = (CuTypesOffset - CuListOffset) / 16;
+  CuList.reserve(CuListSize);
+  while (CuListSize--) {
+    uint64_t CuOffset = Data.getU64(&Offset);
+    uint64_t CuLength = Data.getU64(&Offset);
+    CuList.push_back({CuOffset, CuLength});
+  }
+
+  // This is a sequence of triplets of 64-bit little-endian values. In a
+  // triplet, the first value is the CU offset, the second value is the type
+  // offset in the CU, and the third value is the type signature.
+  uint32_t CuTypesListSize = (AddressAreaOffset - CuTypesOffset) / 24;
+  if (CuTypesListSize != 0) {
+    ErrMessage = "dumping of CU types list is not supported";
+    return;
+  }
+
+  uint32_t AddressAreaSize = (SymbolTableOffset - AddressAreaOffset) / 20;
+  AddressArea.reserve(AddressAreaSize);
+  while (AddressAreaSize--) {
+    uint64_t LowAddress = Data.getU64(&Offset);
+    uint64_t HighAddress = Data.getU64(&Offset);
+    uint32_t CuIndex = Data.getU32(&Offset);
+    AddressArea.push_back({LowAddress, HighAddress, CuIndex});
+  }
+
+  // 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.
+  // If both values are 0, then this slot in the hash table is empty. This is ok
+  // because while 0 is a valid constant pool index, it cannot be a valid index
+  // for both a string and a CU vector.
+  uint32_t SymTableSize = (ConstantPoolOffset - SymbolTableOffset) / 8;
+  SymbolTable.reserve(SymTableSize);
+  uint32_t CuVectorsTotal = 0;
+  while (SymTableSize--) {
+    uint32_t NameOffset = Data.getU32(&Offset);
+    uint32_t CuVecOffset = Data.getU32(&Offset);
+    SymbolTable.push_back({NameOffset, CuVecOffset});
+    if (NameOffset || CuVecOffset)
+      ++CuVectorsTotal;
+  }
+
+  // The constant pool. CU vectors are stored first, followed by strings.
+  // The first value is the number of CU indices in the vector. Each subsequent
+  // value is the index and symbol attributes of a CU in the CU list.
+  while (CuVectorsTotal--) {
+    ConstantPoolVectors.push_back(std::pair<uint32_t, std::vector<uint32_t>>());
+    std::pair<uint32_t, std::vector<uint32_t>> &Vec =
+        ConstantPoolVectors.back();
+    Vec.first = Offset - ConstantPoolOffset;
+
+    uint32_t Num = Data.getU32(&Offset);
+    while (Num--)
+      Vec.second.push_back(Data.getU32(&Offset));
+  }
+
+  ConstantPoolStrings = Data.getData().drop_front(Offset);
+  StringPoolOffset = Offset;
+}

test/DebugInfo/dwarfdump-dump-gdbindex.test

+RUN: llvm-dwarfdump -debug-dump=gdb_index %p/Inputs/dwarfdump-gdbindex-v7.elf-x86-64 | FileCheck %s
+
+; 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
+; gold --gdb-index test.o test2.o -o dwarfdump-gdbindex-v7.elf-x86-64
+; gcc version 5.3.1 20160413, GNU gold (GNU Binutils for Ubuntu 2.26) 1.11
+; Info about gdb-index: https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html
+
+; CHECK-LABEL: .gnu_index contents:
+; CHECK: 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 2 entries:
+; CHECK-NEXT:   Low address = 0x4000e8, High address = 0x4000fa, CU index = 0
+; CHECK-NEXT:   Low address = 0x4000fa, High address = 0x400101, CU index = 1
+
+; CHECK:      Symbol table offset = 0x60, size = 1024, filled slots:
+; CHECK-NEXT:   158: Name offset = 0x67, CU vector offset = 0x18
+; CHECK-NEXT:     String name: bar1, CU vector index: 3
+; CHECK-NEXT:   191: Name offset = 0x62, CU vector offset = 0x10
+; CHECK-NEXT:     String name: foo1, CU vector index: 2
+; CHECK-NEXT:   192: Name offset = 0x85, CU vector offset = 0x44
+; CHECK-NEXT:     String name: foo2, CU vector index: 8
+; CHECK-NEXT:   447: Name offset = 0x55, CU vector offset = 0x0
+; CHECK-NEXT:     String name: method1, CU vector index: 0
+; CHECK-NEXT:   448: Name offset = 0x7d, CU vector offset = 0x3c
+; CHECK-NEXT:     String name: method2, CU vector index: 7
+; CHECK-NEXT:   489: Name offset = 0x5d, CU vector offset = 0x8
+; CHECK-NEXT:     String name: main, CU vector index: 1
+; CHECK-NEXT:   511: Name offset = 0x77, CU vector offset = 0x34
+; CHECK-NEXT:     String name: float, CU vector index: 6
+; CHECK-NEXT:   518: Name offset = 0x8a, CU vector offset = 0x4c
+; CHECK-NEXT:     String name: char, CU vector index: 9
+; CHECK-NEXT:   754: Name offset = 0x6c, CU vector offset = 0x20
+; CHECK-NEXT:     String name: int, CU vector index: 4
+; CHECK-NEXT:   977: Name offset = 0x70, CU vector offset = 0x28
+; CHECK-NEXT:     String name: double, CU vector index: 5
+
+; CHECK:      Constant pool offset = 0x2060, has 10 CU vectors:
+; CHECK-NEXT:   0(0x0): 0x30000000 
+; CHECK-NEXT:   1(0x8): 0x30000000 
+; CHECK-NEXT:   2(0x10): 0x20000000 
+; CHECK-NEXT:   3(0x18): 0x20000000 
+; CHECK-NEXT:   4(0x20): 0x90000000 
+; CHECK-NEXT:   5(0x28): 0x90000000 0x90000001 
+; CHECK-NEXT:   6(0x34): 0x90000000 
+; CHECK-NEXT:   7(0x3c): 0x30000001 
+; CHECK-NEXT:   8(0x44): 0x20000001 
+; CHECK-NEXT:   9(0x4c): 0x90000001 

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

cl::values(
         clEnumValN(DIDT_Pubtypes, "pubtypes", ".debug_pubtypes"),
         clEnumValN(DIDT_GnuPubnames, "gnu_pubnames", ".debug_gnu_pubnames"),
         clEnumValN(DIDT_GnuPubtypes, "gnu_pubtypes", ".debug_gnu_pubtypes"),
         clEnumValN(DIDT_Str, "str", ".debug_str"),
         clEnumValN(DIDT_StrDwo, "str.dwo", ".debug_str.dwo"),
         clEnumValN(DIDT_StrOffsetsDwo, "str_offsets.dwo",
                    ".debug_str_offsets.dwo"),
         clEnumValN(DIDT_CUIndex, "cu_index", ".debug_cu_index"),
+        clEnumValN(DIDT_GdbIndex, "gdb_index", ".gdb_index"),
         clEnumValN(DIDT_TUIndex, "tu_index", ".debug_tu_index"), clEnumValEnd));
 
 static void error(StringRef Filename, std::error_code EC) {
   if (!EC)
     return;
   errs() << Filename << ": " << EC.message() << "\n";
   exit(1);
 }
 
 static void DumpObjectFile(ObjectFile &Obj, Twine Filename) {