[llvm-readobj] Provide Hash Histogram for all ELFDumper implementations

[paulkirth]

Summary

Previously, the GNUELFDumper was the only implementer for Hash Histograms.
This patch moves the implementation for printHashHistogram and
printGnuHashHistogram into the ELFDumper base class, and allows each
derived class to specialize how it outputs that information.

This change also prevents the JSONELFDumper from emitting invalid JSON,
since the shared implementation in LLVMELFDumper no longer emits a
warning message to the output stream.

[jhenderson]

I'd rather not do this, and would strongly prefer we simply do it right the first time.

[paulkirth]

Rebase

• Replace empty implementation with a shared impl in the ELFDumper base class and printing APIs for derived classes to specialize.
• Add test to check the formatting for the LLVM style output

[paulkirth]

Rebase to fix patch application

[paulkirth]

Fix formatting

[paulkirth]

Rebase

[paulkirth]

Rebase

[paulkirth]

Rebase.

[paulkirth]

Rebase.

[paulkirth]

Rebase.

[paulkirth]

Rebase.

[jhenderson]

So this patch appears to add support for the hash histogram printing for both GNU and non-GNU hash sections, but the testing only appears to test one of these two cases. I think you need tests for both cases.

llvm/include/llvm/Support/ScopedPrinter.h

233

This should probably be spun off into a separate patch and have testing in the unit tests.

llvm/test/tools/llvm-readobj/ELF/hash-histogram.test

15

llvm/tools/llvm-readobj/ELFDumper.cpp

2702

Whilst moving, please add the missing "." to this comment.

2733

Ditto.

2737

Ditto.

2783

Ditto.

7121–7123

Any particular reason you've made the Count member const in these two methods?

7128

7146

https://llvm.org/docs/CodingStandards.html#prefer-preincrement

[paulkirth]

Rebase.

• split out ScopedPrinter changes.
• remove const from ArrayRef parameters
• fix typos in comments
• use preincrement in loops
• add test for both types of HashHistogram

[paulkirth]

llvm/tools/llvm-readobj/ELFDumper.cpp

7121–7123

Thanks for pointing that out. I think it was just habit from writing const Foo& forever, but that doesn't make sense in this case.

7146

This loop is taken directly from the GNUELFDumper, should I update this in the existing implementations too?

[paulkirth]

Rebase

[paulkirth]

Rebase

[paulkirth]

Fix formatting

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/hash-histogram.test

16–17

There's no need for these two extra cases: they are there for the earlier llvm-readelf check to ensure the --histogram and -I aliases are equivalent to --elf-hash-histogram.

llvm/tools/llvm-readobj/ELFDumper.cpp

7124

Looking at this again, this and the GNU hash histogram version immediately below are practically identical. Can you try sharing the code rather than duplicating it, please?

Whilst you're at it, you might want to do the same for the GNU output format versions of these two functions.

7146

I wouldn't change code that isn't already changing/moving, but if it is, you can make the tidy-up at the same time.

[paulkirth]

Address comments.

• Use preincrement in moved code.
• Share more code between Gnu and non-Gnu versions
• Remove redundant test cases

[jhenderson]

Two minor points, otherwise LGTM.

llvm/tools/llvm-readobj/ELFDumper.cpp

2738

4954

I have a marginal preference to make this argument StringRef TableDescription (with values of "" and `.gnu.hash' respectively, since there's only one place the behaviour is different between the two output styles, as far as I can tell.

[paulkirth]

llvm/tools/llvm-readobj/ELFDumper.cpp

4954

Sure, but if they have the same interface, then they can be overrides from the base class, as they are now.

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

4954

Okay, that's fair.

[paulkirth]

Rebase.

• fix comment string for /*IsGnu=*/

llvm/include/llvm/Support/ScopedPrinter.h

public:
   virtual void printNumber(StringRef Label, int16_t Value) {
     startLine() << Label << ": " << Value << "\n";
   }
 
   virtual void printNumber(StringRef Label, int8_t Value) {
     startLine() << Label << ": " << int(Value) << "\n";
   }
 
+  virtual void printNumber(StringRef Label, float Value) {
+    startLine() << Label << ": " << format("%5.1f", Value) << "\n";
+  }
+
   virtual void printNumber(StringRef Label, const APSInt &Value) {
     startLine() << Label << ": " << Value << "\n";
   }
 
   template <typename T>
   void printNumber(StringRef Label, StringRef Str, T Value) {
     printNumberImpl(Label, Str, to_string(Value));
   }

llvm/test/tools/llvm-readobj/ELF/hash-histogram.test

 ## Here we test the --elf-hash-histogram command line option.
 
 ## This test case checks how we built histograms for hash sections.
 
 # RUN: yaml2obj --docnum=1 -D BITS=32 %s -o %t1-32.o
 # RUN: llvm-readelf --elf-hash-histogram %t1-32.o | FileCheck %s --check-prefix=HIST
 
 ## Test --histogram and -I aliases.
 # RUN: llvm-readelf --histogram %t1-32.o | FileCheck %s --check-prefix=HIST
 # RUN: llvm-readelf -I %t1-32.o | FileCheck %s --check-prefix=HIST
 
 # RUN: yaml2obj --docnum=1 -D BITS=64 %s -o %t1-64.o
 # RUN: llvm-readelf --elf-hash-histogram %t1-64.o | FileCheck %s --check-prefix=HIST
 
+## Check that LLVM output has the expected format
+# RUN: llvm-readobj --elf-hash-histogram %t1-32.o | FileCheck %s --check-prefix=LLVM-HIST
+# RUN: llvm-readobj --elf-hash-histogram %t1-64.o | FileCheck %s --check-prefix=LLVM-HIST
+
 # HIST:      Histogram for bucket list length (total of 3 buckets)
 # HIST-NEXT:  Length  Number     % of total  Coverage
 # HIST-NEXT:       0  2          ( 66.7%)       0.0%
 # HIST-NEXT:       1  0          (  0.0%)       0.0%
 # HIST-NEXT:       2  0          (  0.0%)       0.0%
 # HIST-NEXT:       3  1          ( 33.3%)     100.0%
 # HIST-NEXT: Histogram for `.gnu.hash' bucket list length (total of 3 buckets)
 # HIST-NEXT:  Length  Number     % of total  Coverage
 # HIST-NEXT:       0  1          ( 33.3%)       0.0%
 # HIST-NEXT:       1  1          ( 33.3%)      25.0%
 # HIST-NEXT:       2  0          (  0.0%)      25.0%
 # HIST-NEXT:       3  1          ( 33.3%)     100.0%
 # HIST-NOT:  {{.}}
 
+#      LLVM-HIST: HashHistogram {
+# LLVM-HIST-NEXT:   TotalBuckets: 3
+# LLVM-HIST-NEXT:   Chains [
+# LLVM-HIST-NEXT:     Chain {
+# LLVM-HIST-NEXT:       Length: 0
+# LLVM-HIST-NEXT:       Count: 2
+# LLVM-HIST-NEXT:       Percentage:  66.7
+# LLVM-HIST-NEXT:       Coverage:   0.0
+# LLVM-HIST-NEXT:     }
+# LLVM-HIST-NEXT:     Chain {
+# LLVM-HIST-NEXT:       Length: 1
+# LLVM-HIST-NEXT:       Count: 0
+# LLVM-HIST-NEXT:       Percentage:   0.0
+# LLVM-HIST-NEXT:       Coverage:   0.0
+# LLVM-HIST-NEXT:     }
+# LLVM-HIST-NEXT:     Chain {
+# LLVM-HIST-NEXT:       Length: 2
+# LLVM-HIST-NEXT:       Count: 0
+# LLVM-HIST-NEXT:       Percentage:   0.0
+# LLVM-HIST-NEXT:       Coverage:   0.0
+# LLVM-HIST-NEXT:     }
+# LLVM-HIST-NEXT:     Chain {
+# LLVM-HIST-NEXT:       Length: 3
+# LLVM-HIST-NEXT:       Count: 1
+# LLVM-HIST-NEXT:       Percentage:  33.3
+# LLVM-HIST-NEXT:       Coverage: 100.0
+# LLVM-HIST-NEXT:     }
+# LLVM-HIST-NEXT:   ]
+# LLVM-HIST-NEXT: }
+# LLVM-HIST-NEXT: GnuHashHistogram {
+# LLVM-HIST-NEXT:   TotalBuckets: 3
+# LLVM-HIST-NEXT:   Buckets [
+# LLVM-HIST-NEXT:     Bucket {
+# LLVM-HIST-NEXT:       Length: 0
+# LLVM-HIST-NEXT:       Count: 1
+# LLVM-HIST-NEXT:       Percentage:  33.3
+# LLVM-HIST-NEXT:       Coverage:   0.0
+# LLVM-HIST-NEXT:     }
+# LLVM-HIST-NEXT:     Bucket {
+# LLVM-HIST-NEXT:       Length: 1
+# LLVM-HIST-NEXT:       Count: 1
+# LLVM-HIST-NEXT:       Percentage:  33.3
+# LLVM-HIST-NEXT:       Coverage:  25.0
+# LLVM-HIST-NEXT:     }
+# LLVM-HIST-NEXT:     Bucket {
+# LLVM-HIST-NEXT:       Length: 2
+# LLVM-HIST-NEXT:       Count: 0
+# LLVM-HIST-NEXT:       Percentage:   0.0
+# LLVM-HIST-NEXT:       Coverage:  25.0
+# LLVM-HIST-NEXT:     }
+# LLVM-HIST-NEXT:     Bucket {
+# LLVM-HIST-NEXT:       Length: 3
+# LLVM-HIST-NEXT:       Count: 1
+# LLVM-HIST-NEXT:       Percentage:  33.3
+# LLVM-HIST-NEXT:       Coverage: 100.0
+# LLVM-HIST-NEXT:     }
+# LLVM-HIST-NEXT:   ]
+# LLVM-HIST-NEXT: }
+
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:   .hash
     Type:   SHT_HASH

llvm/tools/llvm-readobj/ELFDumper.cpp

public:
   void printNeededLibraries() override;
   void printHashTable() override;
   void printGnuHashTable() override;
   void printLoadName() override;
   void printVersionInfo() override;
   void printArchSpecificInfo() override;
   void printStackMap() const override;
 
+  // Hash histogram shows statistics of how efficient the hash was for the
+  // dynamic symbol table. The table shows the number of hash buckets for
+  // different lengths of chains as an absolute number and percentage of the
+  // total buckets, and the cumulative coverage of symbols for each set of
+  // buckets.
+  void printHashHistograms() override;
+
   const object::ELFObjectFile<ELFT> &getElfObject() const { return ObjF; };
 
   std::string describe(const Elf_Shdr &Sec) const;
 
   unsigned getHashTableEntSize() const {
     // EM_S390 and ELF::EM_ALPHA platforms use 8-bytes entries in SHT_HASH
     // sections. This violates the ELF specification.
     if (Obj.getHeader().e_machine == ELF::EM_S390 ||
virtual void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                            DataRegion<Elf_Word> ShndxTable,
                            std::optional<StringRef> StrTable, bool IsDynamic,
                            bool NonVisibilityBitsUsed) const = 0;
 
   virtual void printMipsABIFlags() = 0;
   virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0;
   virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;
 
+  virtual void printHashHistogram(const Elf_Hash &HashTable) const;
+  virtual void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable) const;
+  virtual void printHashHistogramStats(size_t NBucket, size_t MaxChain,
+                                       size_t TotalSyms,
+                                       const ArrayRef<size_t> Count) const = 0;
+  virtual void
+  printGnuHashHistogramStats(size_t NBucket, size_t MaxChain, size_t TotalSyms,
+                             const ArrayRef<size_t> Count) const = 0;
+
   Expected<ArrayRef<Elf_Versym>>
   getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab,
                   StringRef *StrTab, const Elf_Shdr **SymTabSec) const;
   StringRef getPrintableSectionName(const Elf_Shdr &Sec) const;
 
   std::vector<GroupSection> getGroups();
 
   // Returns the function symbol index for the given address. Matches the
public:
   void printDynamicRelocations() override;
   void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset,
                           bool NonVisibilityBitsUsed) const override;
   void printProgramHeaders(bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const Elf_Shdr *Sec) override;
   void printVersionDefinitionSection(const Elf_Shdr *Sec) override;
   void printVersionDependencySection(const Elf_Shdr *Sec) override;
-  void printHashHistograms() override;
   void printCGProfile() override;
   void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
+  void printHashHistogramStats(size_t NBucket, size_t MaxChain,
+                               size_t TotalSyms,
+                               const ArrayRef<size_t> Count) const override;
+  void printGnuHashHistogramStats(size_t NBucket, size_t MaxChain,
+                                  size_t TotalSyms,
+                                  const ArrayRef<size_t> Count) const override;
 
 private:
-  void printHashHistogram(const Elf_Hash &HashTable);
-  void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable);
   void printHashTableSymbols(const Elf_Hash &HashTable);
   void printGnuHashTableSymbols(const Elf_GnuHash &GnuHashTable);
 
   struct Field {
     std::string Str;
     unsigned Column;
 
     Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {}
public:
   void printDependentLibs() override;
   void printDynamicTable() override;
   void printDynamicRelocations() override;
   void printProgramHeaders(bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const Elf_Shdr *Sec) override;
   void printVersionDefinitionSection(const Elf_Shdr *Sec) override;
   void printVersionDependencySection(const Elf_Shdr *Sec) override;
-  void printHashHistograms() override;
   void printCGProfile() override;
   void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
   void printSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex,
                           DataRegion<Elf_Word> ShndxTable) const;
+  void printHashHistogramStats(size_t NBucket, size_t MaxChain,
+                               size_t TotalSyms,
+                               const ArrayRef<size_t> Count) const override;
+  void printGnuHashHistogramStats(size_t NBucket, size_t MaxChain,
+                                  size_t TotalSyms,
+                                  const ArrayRef<size_t> Count) const override;
 
 private:
   void printRelrReloc(const Elf_Relr &R) override;
   void printRelRelaReloc(const Relocation<ELFT> &R,
                          const RelSymbol<ELFT> &RelSym) override;
 
   void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                    DataRegion<Elf_Word> ShndxTable,
reportUniqueWarning("unable to dump 'Values' for the SHT_GNU_HASH "
                         "section: " +
                         toString(Chains.takeError()));
     return;
   }
 
   W.printHexList("Values", *Chains);
 }
 
+template <typename ELFT> void ELFDumper<ELFT>::printHashHistograms() {
+  // Print histogram for the .hash section.
+  if (this->HashTable) {
+    if (Error E = checkHashTable<ELFT>(*this, this->HashTable))
+      this->reportUniqueWarning(std::move(E));
+    else
+      printHashHistogram(*this->HashTable);
+  }
+
+  // Print histogram for the .gnu.hash section.
+  if (this->GnuHashTable) {
+    if (Error E = checkGNUHashTable<ELFT>(this->Obj, this->GnuHashTable))
+      this->reportUniqueWarning(std::move(E));
+    else
+      printGnuHashHistogram(*this->GnuHashTable);
+  }
+}
+
+template <typename ELFT>
+void ELFDumper<ELFT>::printHashHistogram(const Elf_Hash &HashTable) const {
+  size_t NBucket = HashTable.nbucket;
+  size_t NChain = HashTable.nchain;
+  ArrayRef<Elf_Word> Buckets = HashTable.buckets();
+  ArrayRef<Elf_Word> Chains = HashTable.chains();
+  size_t TotalSyms = 0;
+  // If hash table is correct, we have at least chains with 0 length
+  size_t MaxChain = 1;
+
+  if (NChain == 0 || NBucket == 0)
+    return;
+
+  std::vector<size_t> ChainLen(NBucket, 0);
+  // Go over all buckets and and note chain lengths of each bucket (total
+  // unique chain lengths).
+  for (size_t B = 0; B < NBucket; B++) {
+    BitVector Visited(NChain);
+    for (size_t C = Buckets[B]; C < NChain; C = Chains[C]) {
+      if (C == ELF::STN_UNDEF)
+        break;
+      if (Visited[C]) {
+        this->reportUniqueWarning(".hash section is invalid: bucket " +
+                                  Twine(C) +
+                                  ": a cycle was detected in the linked chain");
+        break;
+      }
+      Visited[C] = true;
+      if (MaxChain <= ++ChainLen[B])
+        MaxChain++;
+    }
+    TotalSyms += ChainLen[B];
+  }
+
+  if (!TotalSyms)
+    return;
+
+  std::vector<size_t> Count(MaxChain, 0);
+  // Count how long is the chain for each bucket
+  for (size_t B = 0; B < NBucket; B++)
+    ++Count[ChainLen[B]];
+  // Print Number of buckets with each chain lengths and their cumulative
+  // coverage of the symbols
+  printHashHistogramStats(NBucket, MaxChain, TotalSyms, Count);
+}
+
+template <class ELFT>
+void ELFDumper<ELFT>::printGnuHashHistogram(
+    const Elf_GnuHash &GnuHashTable) const {
+  Expected<ArrayRef<Elf_Word>> ChainsOrErr =
+      getGnuHashTableChains<ELFT>(this->DynSymRegion, &GnuHashTable);
+  if (!ChainsOrErr) {
+    this->reportUniqueWarning("unable to print the GNU hash table histogram: " +
+                              toString(ChainsOrErr.takeError()));
+    return;
+  }
+
+  ArrayRef<Elf_Word> Chains = *ChainsOrErr;
+  size_t Symndx = GnuHashTable.symndx;
+  size_t TotalSyms = 0;
+  size_t MaxChain = 1;
+
+  size_t NBucket = GnuHashTable.nbuckets;
+  if (Chains.empty() || NBucket == 0)
+    return;
+
+  ArrayRef<Elf_Word> Buckets = GnuHashTable.buckets();
+  std::vector<size_t> ChainLen(NBucket, 0);
+  for (size_t B = 0; B < NBucket; B++) {
+    if (!Buckets[B])
+      continue;
+    size_t Len = 1;
+    for (size_t C = Buckets[B] - Symndx;
+         C < Chains.size() && (Chains[C] & 1) == 0; C++)
+      if (MaxChain < ++Len)
+        MaxChain++;
+    ChainLen[B] = Len;
+    TotalSyms += Len;
+  }
+  MaxChain++;
+
+  if (!TotalSyms)
+    return;
+
+  std::vector<size_t> Count(MaxChain, 0);
+  for (size_t B = 0; B < NBucket; B++)
+    ++Count[ChainLen[B]];
+  // Print Number of buckets with each chain lengths and their cumulative
+  // coverage of the symbols
+  printGnuHashHistogramStats(NBucket, MaxChain, TotalSyms, Count);
+}
+
 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
   StringRef SOName = "<Not found>";
   if (SONameOffset)
     SOName = getDynamicString(*SONameOffset);
   W.printString("LoadName", SOName);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() {
for (const VernAux &Aux : VN.AuxV)
       OS << format("  0x%04x:   Name: %s  Flags: %s  Version: %u\n", Aux.Offset,
                    Aux.Name.data(), versionFlagToString(Aux.Flags).c_str(),
                    Aux.Other);
   }
   OS << '\n';
 }
 
 template <class ELFT>
-void GNUELFDumper<ELFT>::printHashHistogram(const Elf_Hash &HashTable) {
-  size_t NBucket = HashTable.nbucket;
-  size_t NChain = HashTable.nchain;
-  ArrayRef<Elf_Word> Buckets = HashTable.buckets();
-  ArrayRef<Elf_Word> Chains = HashTable.chains();
-  size_t TotalSyms = 0;
-  // If hash table is correct, we have at least chains with 0 length
-  size_t MaxChain = 1;
+void GNUELFDumper<ELFT>::printHashHistogramStats(
+    size_t NBucket, size_t MaxChain, size_t TotalSyms,
+    const ArrayRef<size_t> Count) const {
   size_t CumulativeNonZero = 0;
-
-  if (NChain == 0 || NBucket == 0)
-    return;
-
-  std::vector<size_t> ChainLen(NBucket, 0);
-  // Go over all buckets and and note chain lengths of each bucket (total
-  // unique chain lengths).
-  for (size_t B = 0; B < NBucket; B++) {
-    BitVector Visited(NChain);
-    for (size_t C = Buckets[B]; C < NChain; C = Chains[C]) {
-      if (C == ELF::STN_UNDEF)
-        break;
-      if (Visited[C]) {
-        this->reportUniqueWarning(".hash section is invalid: bucket " +
-                                  Twine(C) +
-                                  ": a cycle was detected in the linked chain");
-        break;
-      }
-      Visited[C] = true;
-      if (MaxChain <= ++ChainLen[B])
-        MaxChain++;
-    }
-    TotalSyms += ChainLen[B];
-  }
-
-  if (!TotalSyms)
-    return;
-
-  std::vector<size_t> Count(MaxChain, 0);
-  // Count how long is the chain for each bucket
-  for (size_t B = 0; B < NBucket; B++)
-    ++Count[ChainLen[B]];
-  // Print Number of buckets with each chain lengths and their cumulative
-  // coverage of the symbols
   OS << "Histogram for bucket list length (total of " << NBucket
      << " buckets)\n"
      << " Length  Number     % of total  Coverage\n";
   for (size_t I = 0; I < MaxChain; I++) {
     CumulativeNonZero += Count[I] * I;
     OS << format("%7lu  %-10lu (%5.1f%%)     %5.1f%%\n", I, Count[I],
                  (Count[I] * 100.0) / NBucket,
                  (CumulativeNonZero * 100.0) / TotalSyms);
   }
 }
 
 template <class ELFT>
-void GNUELFDumper<ELFT>::printGnuHashHistogram(
-    const Elf_GnuHash &GnuHashTable) {
-  Expected<ArrayRef<Elf_Word>> ChainsOrErr =
-      getGnuHashTableChains<ELFT>(this->DynSymRegion, &GnuHashTable);
-  if (!ChainsOrErr) {
-    this->reportUniqueWarning("unable to print the GNU hash table histogram: " +
-                              toString(ChainsOrErr.takeError()));
-    return;
-  }
-
-  ArrayRef<Elf_Word> Chains = *ChainsOrErr;
-  size_t Symndx = GnuHashTable.symndx;
-  size_t TotalSyms = 0;
-  size_t MaxChain = 1;
+void GNUELFDumper<ELFT>::printGnuHashHistogramStats(
+    size_t NBucket, size_t MaxChain, size_t TotalSyms,
+    const ArrayRef<size_t> Count) const {
   size_t CumulativeNonZero = 0;
-
-  size_t NBucket = GnuHashTable.nbuckets;
-  if (Chains.empty() || NBucket == 0)
-    return;
-
-  ArrayRef<Elf_Word> Buckets = GnuHashTable.buckets();
-  std::vector<size_t> ChainLen(NBucket, 0);
-  for (size_t B = 0; B < NBucket; B++) {
-    if (!Buckets[B])
-      continue;
-    size_t Len = 1;
-    for (size_t C = Buckets[B] - Symndx;
-         C < Chains.size() && (Chains[C] & 1) == 0; C++)
-      if (MaxChain < ++Len)
-        MaxChain++;
-    ChainLen[B] = Len;
-    TotalSyms += Len;
-  }
-  MaxChain++;
-
-  if (!TotalSyms)
-    return;
-
-  std::vector<size_t> Count(MaxChain, 0);
-  for (size_t B = 0; B < NBucket; B++)
-    ++Count[ChainLen[B]];
-  // Print Number of buckets with each chain lengths and their cumulative
-  // coverage of the symbols
   OS << "Histogram for `.gnu.hash' bucket list length (total of " << NBucket
      << " buckets)\n"
      << " Length  Number     % of total  Coverage\n";
   for (size_t I = 0; I < MaxChain; I++) {
     CumulativeNonZero += Count[I] * I;
     OS << format("%7lu  %-10lu (%5.1f%%)     %5.1f%%\n", I, Count[I],
                  (Count[I] * 100.0) / NBucket,
                  (CumulativeNonZero * 100.0) / TotalSyms);
   }
 }
 
-// Hash histogram shows statistics of how efficient the hash was for the
-// dynamic symbol table. The table shows the number of hash buckets for
-// different lengths of chains as an absolute number and percentage of the total
-// buckets, and the cumulative coverage of symbols for each set of buckets.
-template <class ELFT> void GNUELFDumper<ELFT>::printHashHistograms() {
-  // Print histogram for the .hash section.
-  if (this->HashTable) {
-    if (Error E = checkHashTable<ELFT>(*this, this->HashTable))
-      this->reportUniqueWarning(std::move(E));
-    else
-      printHashHistogram(*this->HashTable);
-  }
-
-  // Print histogram for the .gnu.hash section.
-  if (this->GnuHashTable) {
-    if (Error E = checkGNUHashTable<ELFT>(this->Obj, this->GnuHashTable))
-      this->reportUniqueWarning(std::move(E));
-    else
-      printGnuHashHistogram(*this->GnuHashTable);
-  }
-}
-
 template <class ELFT> void GNUELFDumper<ELFT>::printCGProfile() {
   OS << "GNUStyle::printCGProfile not implemented\n";
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printBBAddrMaps() {
   OS << "GNUStyle::printBBAddrMaps not implemented\n";
 }
 
for (const VernAux &Aux : VN.AuxV) {
       W.printNumber("Hash", Aux.Hash);
       W.printFlags("Flags", Aux.Flags, makeArrayRef(SymVersionFlags));
       W.printNumber("Index", Aux.Other);
       W.printString("Name", Aux.Name.c_str());
     }
   }
 }
 
-template <class ELFT> void LLVMELFDumper<ELFT>::printHashHistograms() {
-  W.startLine() << "Hash Histogram not implemented!\n";
+template <class ELFT>
+void LLVMELFDumper<ELFT>::printHashHistogramStats(
+    size_t NBucket, size_t MaxChain, size_t TotalSyms,
+    const ArrayRef<size_t> Count) const {
+  DictScope Outer(W, "HashHistogram");
+  W.printNumber("TotalBuckets", NBucket);
+  ListScope Buckets(W, "Chains");
+  size_t CumulativeNonZero = 0;
+  for (size_t I = 0; I < MaxChain; I++) {
+    CumulativeNonZero += Count[I] * I;
+    DictScope Bucket(W, "Chain");
+    W.printNumber("Length", I);
+    W.printNumber("Count", Count[I]);
+    W.printNumber("Percentage", (float)(Count[I] * 100.0) / NBucket);
+    W.printNumber("Coverage", (float)(CumulativeNonZero * 100.0) / TotalSyms);
+  }
+}
+
+template <class ELFT>
+void LLVMELFDumper<ELFT>::printGnuHashHistogramStats(
+    size_t NBucket, size_t MaxChain, size_t TotalSyms,
+    const ArrayRef<size_t> Count) const {
+  DictScope Outer(W, "GnuHashHistogram");
+  W.printNumber("TotalBuckets", NBucket);
+  ListScope Buckets(W, "Buckets");
+  size_t CumulativeNonZero = 0;
+  for (size_t I = 0; I < MaxChain; I++) {
+    CumulativeNonZero += Count[I] * I;
+    DictScope Bucket(W, "Bucket");
+    W.printNumber("Length", I);
+    W.printNumber("Count", Count[I]);
+    W.printNumber("Percentage", (float)(Count[I] * 100.0) / NBucket);
+    W.printNumber("Coverage", (float)(CumulativeNonZero * 100.0) / TotalSyms);
+  }
 }
 
 // Returns true if rel/rela section exists, and populates SymbolIndices.
 // Otherwise returns false.
 template <class ELFT>
 static bool getSymbolIndices(const typename ELFT::Shdr *CGRelSection,
                              const ELFFile<ELFT> &Obj,
                              const LLVMELFDumper<ELFT> *Dumper,