[llvm-readobj/ELF] Print GNU Hash section

[ikudrin]

Summary

Add a new command line switch, -gnu-hash-table, to print the content of that section.

[• rafael]

LGTM with nits.

Thanks for doing this!

include/llvm/Object/ELFTypes.h

498 ↗

(On Diff #37247)

This should not be an ArrayRef of uintX_t since that is host endian. You can use Elf_Off.

508 ↗

(On Diff #37247)

values maybe?

There is no official spec for the names, but that is what

https://blogs.oracle.com/ali/entry/gnu_hash_elf_sections

uses which I think is the closest thing to a spec.

tools/llvm-readobj/ELFDumper.cpp

1549 ↗

(On Diff #37247)

"First hashed symbol index " is probably more descriptive.

1554 ↗

(On Diff #37247)

Report an error if we have a hash but not a dynamic symbol table.

[• rafael]

This should not be an ArrayRef of uintX_t since that is host endian. You can use Elf_Off.

Ah, and maybe test that by adding a ppc binary?

Thanks,
Rafael

[ikudrin]

Thank you for the comments!

Finally fixed in r250292.

llvm/trunk/include/llvm/Object/ELF.h

public:
   typedef Elf_Rel_Impl<ELFT, false> Elf_Rel;
   typedef Elf_Rel_Impl<ELFT, true> Elf_Rela;
   typedef Elf_Verdef_Impl<ELFT> Elf_Verdef;
   typedef Elf_Verdaux_Impl<ELFT> Elf_Verdaux;
   typedef Elf_Verneed_Impl<ELFT> Elf_Verneed;
   typedef Elf_Vernaux_Impl<ELFT> Elf_Vernaux;
   typedef Elf_Versym_Impl<ELFT> Elf_Versym;
   typedef Elf_Hash_Impl<ELFT> Elf_Hash;
+  typedef Elf_GnuHash_Impl<ELFT> Elf_GnuHash;
   typedef iterator_range<const Elf_Dyn *> Elf_Dyn_Range;
   typedef iterator_range<const Elf_Shdr *> Elf_Shdr_Range;
   typedef iterator_range<const Elf_Sym *> Elf_Sym_Range;
 
   const uint8_t *base() const {
     return reinterpret_cast<const uint8_t *>(Buf.data());
   }
 

llvm/trunk/include/llvm/Object/ELFTypes.h

struct Elf_Hash_Impl {
   }
 
   ArrayRef<Elf_Word> chains() const {
     return ArrayRef<Elf_Word>(&nbucket + 2 + nbucket,
                               &nbucket + 2 + nbucket + nchain);
   }
 };
 
+// .gnu.hash section
+template <class ELFT>
+struct Elf_GnuHash_Impl {
+  LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
+  Elf_Word nbuckets;
+  Elf_Word symndx;
+  Elf_Word maskwords;
+  Elf_Word shift2;
+
+  ArrayRef<Elf_Off> filter() const {
+    return ArrayRef<Elf_Off>(reinterpret_cast<const Elf_Off *>(&shift2 + 1),
+                             maskwords);
+  }
+
+  ArrayRef<Elf_Word> buckets() const {
+    return ArrayRef<Elf_Word>(
+        reinterpret_cast<const Elf_Word *>(filter().end()), nbuckets);
+  }
+
+  ArrayRef<Elf_Word> values(unsigned DynamicSymCount) const {
+    return ArrayRef<Elf_Word>(buckets().end(), DynamicSymCount - symndx);
+  }
+};
+
 // MIPS .reginfo section
 template <class ELFT>
 struct Elf_Mips_RegInfo;
 
 template <llvm::support::endianness TargetEndianness>
 struct Elf_Mips_RegInfo<ELFType<TargetEndianness, false>> {
   LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
   Elf_Word ri_gprmask;     // bit-mask of used general registers

llvm/trunk/test/tools/llvm-readobj/elf-gnuhash.test

+// Check dumping of the GNU Hash section
+// The input was generated using the following:
+// $ llvm-mc -filetype=obj -triple=i386-pc-linux      -o example-i386.o   example.s
+// $ llvm-mc -filetype=obj -triple=x86_64-pc-linux    -o example-x86_64.o example.s
+// $ llvm-mc -filetype=obj -triple=powerpc-pc-linux   -o example-ppc.o    example.s
+// $ llvm-mc -filetype=obj -triple=powerpc64-pc-linux -o example-ppc64.o  example.s
+// $ ld -shared -m elf_i386   -hash-style=gnu -o gnuhash.so.elf-i386   example-i386.o
+// $ ld -shared -m elf_x86_64 -hash-style=gnu -o gnuhash.so.elf-x86_64 example-x86_64.o
+// $ ld -shared -m elf32ppc   -hash-style=gnu -o gnuhash.so.elf-ppc    example-ppc.o
+// $ ld -shared -m elf64ppc   -hash-style=gnu -o gnuhash.so.elf-ppc64  example-ppc64.o
+// $ cat example.s
+// .globl foo
+// foo:
+
+RUN: llvm-readobj -gnu-hash-table %p/Inputs/gnuhash.so.elf-i386   | FileCheck %s -check-prefix I386
+RUN: llvm-readobj -gnu-hash-table %p/Inputs/gnuhash.so.elf-x86_64 | FileCheck %s -check-prefix X86_64
+RUN: llvm-readobj -gnu-hash-table %p/Inputs/gnuhash.so.elf-ppc    | FileCheck %s -check-prefix PPC
+RUN: llvm-readobj -gnu-hash-table %p/Inputs/gnuhash.so.elf-ppc64  | FileCheck %s -check-prefix PPC64
+
+I386:      Arch: i386
+I386:      GnuHashTable {
+I386-NEXT:   Num Buckets: 3
+I386-NEXT:   First Hashed Symbol Index: 1
+I386-NEXT:   Num Mask Words: 1
+I386-NEXT:   Shift Count: 5
+I386-NEXT:   Bloom Filter: [0x39004608]
+I386-NEXT:   Buckets: [1, 4, 0]
+I386-NEXT:   Values: [0xB887388, 0xECD54542, 0x7C92E3BB, 0x1C5871D9]
+I386-NEXT: }
+
+X86_64:      Arch: x86_64
+X86_64:      GnuHashTable {
+X86_64-NEXT:   Num Buckets: 3
+X86_64-NEXT:   First Hashed Symbol Index: 1
+X86_64-NEXT:   Num Mask Words: 1
+X86_64-NEXT:   Shift Count: 6
+X86_64-NEXT:   Bloom Filter: [0x800000001204288]
+X86_64-NEXT:   Buckets: [1, 4, 0]
+X86_64-NEXT:   Values: [0xB887388, 0xECD54542, 0x7C92E3BB, 0x1C5871D9]
+X86_64-NEXT: }
+
+PPC:      Arch: powerpc
+PPC:      GnuHashTable {
+PPC-NEXT:   Num Buckets: 3
+PPC-NEXT:   First Hashed Symbol Index: 1
+PPC-NEXT:   Num Mask Words: 1
+PPC-NEXT:   Shift Count: 5
+PPC-NEXT:   Bloom Filter: [0x3D00460A]
+PPC-NEXT:   Buckets: [1, 5, 0]
+PPC-NEXT:   Values: [0xEEBEC3A, 0xB887388, 0xECD54542, 0x7C92E3BB, 0x1C5871D9]
+PPC-NEXT: }
+
+PPC64:      Arch: powerpc64
+PPC64:      GnuHashTable {
+PPC64-NEXT:   Num Buckets: 3
+PPC64-NEXT:   First Hashed Symbol Index: 1
+PPC64-NEXT:   Num Mask Words: 1
+PPC64-NEXT:   Shift Count: 6
+PPC64-NEXT:   Bloom Filter: [0x800000001204288]
+PPC64-NEXT:   Buckets: [1, 4, 0]
+PPC64-NEXT:   Values: [0xB887388, 0xECD54542, 0x7C92E3BB, 0x1C5871D9]
+PPC64-NEXT: }
+

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

public:
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
   void printProgramHeaders() override;
   void printHashTable() override;
+  void printGnuHashTable() override;
   void printLoadName() override;
 
   void printAttributes() override;
   void printMipsPLTGOT() override;
   void printMipsABIFlags() override;
   void printMipsReginfo() override;
 
   void printStackMap() const override;
 
 private:
   typedef ELFFile<ELFT> ELFO;
   typedef typename ELFO::Elf_Shdr Elf_Shdr;
   typedef typename ELFO::Elf_Sym Elf_Sym;
   typedef typename ELFO::Elf_Dyn Elf_Dyn;
   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
   typedef typename ELFO::Elf_Rel Elf_Rel;
   typedef typename ELFO::Elf_Rela Elf_Rela;
   typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range;
   typedef typename ELFO::Elf_Phdr Elf_Phdr;
   typedef typename ELFO::Elf_Hash Elf_Hash;
+  typedef typename ELFO::Elf_GnuHash Elf_GnuHash;
   typedef typename ELFO::Elf_Ehdr Elf_Ehdr;
   typedef typename ELFO::Elf_Word Elf_Word;
   typedef typename ELFO::uintX_t uintX_t;
   typedef typename ELFO::Elf_Versym Elf_Versym;
   typedef typename ELFO::Elf_Verneed Elf_Verneed;
   typedef typename ELFO::Elf_Vernaux Elf_Vernaux;
   typedef typename ELFO::Elf_Verdef Elf_Verdef;
 
private:
 
   const ELFO *Obj;
   DynRegionInfo DynRelaRegion;
   const Elf_Phdr *DynamicProgHeader = nullptr;
   StringRef DynamicStringTable;
   const Elf_Sym *DynSymStart = nullptr;
   StringRef SOName;
   const Elf_Hash *HashTable = nullptr;
+  const Elf_GnuHash *GnuHashTable = nullptr;
   const Elf_Shdr *DotDynSymSec = nullptr;
   const Elf_Shdr *DotSymtabSec = nullptr;
   ArrayRef<Elf_Word> ShndxTable;
 
   const Elf_Shdr *dot_gnu_version_sec = nullptr;   // .gnu.version
   const Elf_Shdr *dot_gnu_version_r_sec = nullptr; // .gnu.version_r
   const Elf_Shdr *dot_gnu_version_d_sec = nullptr; // .gnu.version_d
 
ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer)
   const char *StringTableBegin = nullptr;
   uint64_t StringTableSize = 0;
   for (const Elf_Dyn &Dyn : dynamic_table()) {
     switch (Dyn.d_tag) {
     case ELF::DT_HASH:
       HashTable =
           reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr()));
       break;
+    case ELF::DT_GNU_HASH:
+      GnuHashTable =
+          reinterpret_cast<const Elf_GnuHash *>(toMappedAddr(Dyn.getPtr()));
+      break;
     case ELF::DT_RELA:
       DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr());
       break;
     case ELF::DT_RELASZ:
       DynRelaRegion.Size = Dyn.getVal();
       break;
     case ELF::DT_RELAENT:
       DynRelaRegion.EntSize = Dyn.getVal();
void ELFDumper<ELFT>::printHashTable() {
   if (!HashTable)
     return;
   W.printNumber("Num Buckets", HashTable->nbucket);
   W.printNumber("Num Chains", HashTable->nchain);
   W.printList("Buckets", HashTable->buckets());
   W.printList("Chains", HashTable->chains());
 }
 
+template <typename ELFT>
+void ELFDumper<ELFT>::printGnuHashTable() {
+  DictScope D(W, "GnuHashTable");
+  if (!GnuHashTable)
+    return;
+  W.printNumber("Num Buckets", GnuHashTable->nbuckets);
+  W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx);
+  W.printNumber("Num Mask Words", GnuHashTable->maskwords);
+  W.printNumber("Shift Count", GnuHashTable->shift2);
+  W.printHexList("Bloom Filter", GnuHashTable->filter());
+  W.printList("Buckets", GnuHashTable->buckets());
+  if (!DotDynSymSec)
+    reportError("No dynamic symbol section");
+  W.printHexList("Values",
+                 GnuHashTable->values(DotDynSymSec->getEntityCount()));
+}
+
 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
   outs() << "LoadName: " << SOName << '\n';
 }
 
 template <class ELFT>
 void ELFDumper<ELFT>::printAttributes() {
   W.startLine() << "Attributes not implemented.\n";
 }

llvm/trunk/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printUnwindInfo() = 0;
 
   // Only implemented for ELF at this time.
   virtual void printDynamicRelocations() { }
   virtual void printDynamicTable() { }
   virtual void printNeededLibraries() { }
   virtual void printProgramHeaders() { }
   virtual void printHashTable() { }
+  virtual void printGnuHashTable() { }
   virtual void printLoadName() {}
 
   // Only implemented for ARM ELF at this time.
   virtual void printAttributes() { }
 
   // Only implemented for MIPS ELF at this time.
   virtual void printMipsPLTGOT() { }
   virtual void printMipsABIFlags() { }

llvm/trunk/tools/llvm-readobj/StreamWriter.h

for (const auto &Item : List) {
       if (Comma)
         OS << ", ";
       OS << Item;
       Comma = true;
     }
     OS << "]\n";
   }
 
-  template<typename T>
+  template <typename T>
+  void printHexList(StringRef Label, const T &List) {
+    startLine() << Label << ": [";
+    bool Comma = false;
+    for (const auto &Item : List) {
+      if (Comma)
+        OS << ", ";
+      OS << hex(Item);
+      Comma = true;
+    }
+    OS << "]\n";
+  }
+
+  template<typename T>
   void printHex(StringRef Label, T Value) {
     startLine() << Label << ": " << hex(Value) << "\n";
   }
 
   template<typename T>
   void printHex(StringRef Label, StringRef Str, T Value) {
     startLine() << Label << ": " << Str << " (" << hex(Value) << ")\n";
   }

llvm/trunk/tools/llvm-readobj/llvm-readobj.cpp

namespace opts {
   // -program-headers
   cl::opt<bool> ProgramHeaders("program-headers",
     cl::desc("Display ELF program headers"));
 
   // -hash-table
   cl::opt<bool> HashTable("hash-table",
     cl::desc("Display ELF hash table"));
 
+  // -gnu-hash-table
+  cl::opt<bool> GnuHashTable("gnu-hash-table",
+    cl::desc("Display ELF .gnu.hash section"));
+
   // -expand-relocs
   cl::opt<bool> ExpandRelocs("expand-relocs",
     cl::desc("Expand each shown relocation to multiple lines"));
 
   // -codeview
   cl::opt<bool> CodeView("codeview",
                          cl::desc("Display CodeView debug information"));
 
static void dumpObject(const ObjectFile *Obj) {
   if (opts::DynamicTable)
     Dumper->printDynamicTable();
   if (opts::NeededLibraries)
     Dumper->printNeededLibraries();
   if (opts::ProgramHeaders)
     Dumper->printProgramHeaders();
   if (opts::HashTable)
     Dumper->printHashTable();
+  if (opts::GnuHashTable)
+    Dumper->printGnuHashTable();
   if (Obj->getArch() == llvm::Triple::arm && Obj->isELF())
     if (opts::ARMAttributes)
       Dumper->printAttributes();
   if (isMipsArch(Obj->getArch()) && Obj->isELF()) {
     if (opts::MipsPLTGOT)
       Dumper->printMipsPLTGOT();
     if (opts::MipsABIFlags)
       Dumper->printMipsABIFlags();