diff --git a/llvm/tools/llvm-readobj/ELFDumper.cpp b/llvm/tools/llvm-readobj/ELFDumper.cpp
--- a/llvm/tools/llvm-readobj/ELFDumper.cpp
+++ b/llvm/tools/llvm-readobj/ELFDumper.cpp
@@ -313,8 +313,8 @@
 
   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, ArrayRef<size_t> Count,
+  virtual void printHashHistogramStats(uint32_t NBucket, uint32_t MaxChain,
+                                       uint32_t TotalSyms, ArrayRef<uint32_t> Count,
                                        bool IsGnu) const = 0;
 
   Expected<ArrayRef<Elf_Versym>>
@@ -594,8 +594,8 @@
   void printMemtag(
       const ArrayRef<std::pair<std::string, std::string>> DynamicEntries,
       const ArrayRef<uint8_t> AndroidNoteDesc) override;
-  void printHashHistogramStats(size_t NBucket, size_t MaxChain,
-                               size_t TotalSyms, ArrayRef<size_t> Count,
+  void printHashHistogramStats(uint32_t NBucket, uint32_t MaxChain,
+                               uint32_t TotalSyms, ArrayRef<uint32_t> Count,
                                bool IsGnu) const override;
 
 private:
@@ -703,8 +703,8 @@
       const ArrayRef<uint8_t> AndroidNoteDesc) 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, ArrayRef<size_t> Count,
+  void printHashHistogramStats(uint32_t NBucket, uint32_t MaxChain,
+                               uint32_t TotalSyms, ArrayRef<uint32_t> Count,
                                bool IsGnu) const override;
 
 private:
@@ -2717,23 +2717,23 @@
 
 template <typename ELFT>
 void ELFDumper<ELFT>::printHashHistogram(const Elf_Hash &HashTable) const {
-  size_t NBucket = HashTable.nbucket;
-  size_t NChain = HashTable.nchain;
+  uint32_t NBucket = HashTable.nbucket;
+  uint32_t NChain = HashTable.nchain;
   ArrayRef<Elf_Word> Buckets = HashTable.buckets();
   ArrayRef<Elf_Word> Chains = HashTable.chains();
-  size_t TotalSyms = 0;
+  uint32_t TotalSyms = 0;
   // If hash table is correct, we have at least chains with 0 length.
-  size_t MaxChain = 1;
+  uint32_t MaxChain = 1;
 
   if (NChain == 0 || NBucket == 0)
     return;
 
-  std::vector<size_t> ChainLen(NBucket, 0);
+  std::vector<uint32_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) {
+  for (uint32_t B = 0; B < NBucket; ++B) {
     BitVector Visited(NChain);
-    for (size_t C = Buckets[B]; C < NChain; C = Chains[C]) {
+    for (uint32_t C = Buckets[B]; C < NChain; C = Chains[C]) {
       if (C == ELF::STN_UNDEF)
           break;
       if (Visited[C]) {
@@ -2752,9 +2752,9 @@
   if (!TotalSyms)
     return;
 
-  std::vector<size_t> Count(MaxChain, 0);
+  std::vector<uint32_t> Count(MaxChain, 0);
   // Count how long is the chain for each bucket.
-  for (size_t B = 0; B < NBucket; B++)
+  for (uint32_t B = 0; B < NBucket; B++)
     ++Count[ChainLen[B]];
   // Print Number of buckets with each chain lengths and their cumulative
   // coverage of the symbols.
@@ -2773,21 +2773,21 @@
   }
 
   ArrayRef<Elf_Word> Chains = *ChainsOrErr;
-  size_t Symndx = GnuHashTable.symndx;
-  size_t TotalSyms = 0;
-  size_t MaxChain = 1;
+  uint32_t Symndx = GnuHashTable.symndx;
+  uint32_t TotalSyms = 0;
+  uint32_t MaxChain = 1;
 
-  size_t NBucket = GnuHashTable.nbuckets;
+  uint32_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) {
+  std::vector<uint32_t> ChainLen(NBucket, 0);
+  for (uint32_t B = 0; B < NBucket; ++B) {
     if (!Buckets[B])
       continue;
-    size_t Len = 1;
-    for (size_t C = Buckets[B] - Symndx;
+    uint32_t Len = 1;
+    for (uint32_t C = Buckets[B] - Symndx;
          C < Chains.size() && (Chains[C] & 1) == 0; ++C)
       if (MaxChain < ++Len)
           ++MaxChain;
@@ -2799,8 +2799,8 @@
   if (!TotalSyms)
     return;
 
-  std::vector<size_t> Count(MaxChain, 0);
-  for (size_t B = 0; B < NBucket; ++B)
+  std::vector<uint32_t> Count(MaxChain, 0);
+  for (uint32_t B = 0; B < NBucket; ++B)
     ++Count[ChainLen[B]];
   // Print Number of buckets with each chain lengths and their cumulative
   // coverage of the symbols.
@@ -4956,16 +4956,16 @@
 }
 
 template <class ELFT>
-void GNUELFDumper<ELFT>::printHashHistogramStats(size_t NBucket,
-                                                 size_t MaxChain,
-                                                 size_t TotalSyms,
-                                                 ArrayRef<size_t> Count,
+void GNUELFDumper<ELFT>::printHashHistogramStats(uint32_t NBucket,
+                                                 uint32_t MaxChain,
+                                                 uint32_t TotalSyms,
+                                                 ArrayRef<uint32_t> Count,
                                                  bool IsGnu) const {
-  size_t CumulativeNonZero = 0;
+  uint32_t CumulativeNonZero = 0;
   OS << "Histogram for" << (IsGnu ? " `.gnu.hash'" : "")
      << " bucket list length (total of " << NBucket << " buckets)\n"
      << " Length  Number     % of total  Coverage\n";
-  for (size_t I = 0; I < MaxChain; ++I) {
+  for (uint32_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,
@@ -7163,10 +7163,10 @@
 }
 
 template <class ELFT>
-void LLVMELFDumper<ELFT>::printHashHistogramStats(size_t NBucket,
-                                                  size_t MaxChain,
-                                                  size_t TotalSyms,
-                                                  ArrayRef<size_t> Count,
+void LLVMELFDumper<ELFT>::printHashHistogramStats(uint32_t NBucket,
+                                                  uint32_t MaxChain,
+                                                  uint32_t TotalSyms,
+                                                  ArrayRef<uint32_t> Count,
                                                   bool IsGnu) const {
   StringRef HistName = IsGnu ? "GnuHashHistogram" : "HashHistogram";
   StringRef BucketName = IsGnu ? "Bucket" : "Chain";
@@ -7174,8 +7174,8 @@
   DictScope Outer(W, HistName);
   W.printNumber("TotalBuckets", static_cast<uint64_t>(NBucket));
   ListScope Buckets(W, ListName);
-  size_t CumulativeNonZero = 0;
-  for (size_t I = 0; I < MaxChain; ++I) {
+  uint32_t CumulativeNonZero = 0;
+  for (uint32_t I = 0; I < MaxChain; ++I) {
     CumulativeNonZero += Count[I] * I;
     DictScope Bucket(W, BucketName);
     W.printNumber("Length", static_cast<uint64_t>(I));