[llvm-readobj][NFC] Replace size_t in HashHistogram with uint32_t

[paulkirth]

Summary

Someone ran into an issue with a size_t interface on Darwin.
see (https://reviews.llvm.org/D146492).

Given the use case for HashHistograms, a 32bit unsigned integer should
be sufficient to represent all computed values without overflow.

[junhee-yoo]

llvm/tools/llvm-readobj/ELFDumper.cpp

7181

I guess if the type of I is changed from size_t to uint32_t, static_cast<uint64_t> is no longer needed here and on Count[I] because virtual void printNumber(StringRef Label, uint32_t Value) is exist. How do you think?

[jhenderson]

I've got nothing against this change, but see my comment in D146492.

[paulkirth]

I think this has become obsolete now that we handle fundamental C++ types.

llvm/tools/llvm-readobj/ELFDumper.cpp

protected:
   virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;
 
   virtual void printMemtag(
       const ArrayRef<std::pair<std::string, std::string>> DynamicEntries,
       const ArrayRef<uint8_t> AndroidNoteDesc) = 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, 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>>
   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();
public:
   void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
   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:
   void printHashTableSymbols(const Elf_Hash &HashTable);
   void printGnuHashTableSymbols(const Elf_GnuHash &GnuHashTable);
 
   struct Field {
     std::string Str;
public:
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
   void printMemtag(
       const ArrayRef<std::pair<std::string, std::string>> DynamicEntries,
       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:
   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,
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;
+  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]) {
           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);
+  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.
   printHashHistogramStats(NBucket, MaxChain, TotalSyms, Count, /*IsGnu=*/false);
 }
 
 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;
+  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;
     ChainLen[B] = Len;
     TotalSyms += Len;
   }
   ++MaxChain;
 
   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.
   printHashHistogramStats(NBucket, MaxChain, TotalSyms, Count, /*IsGnu=*/true);
 }
 
 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
   StringRef SOName = "<Not found>";
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>::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,
                  (CumulativeNonZero * 100.0) / TotalSyms);
   }
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printCGProfile() {
for (const VernAux &Aux : VN.AuxV) {
       W.printFlags("Flags", Aux.Flags, ArrayRef(SymVersionFlags));
       W.printNumber("Index", Aux.Other);
       W.printString("Name", Aux.Name.c_str());
     }
   }
 }
 
 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";
   StringRef ListName = IsGnu ? "Buckets" : "Chains";
   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));
     W.printNumber("Count", static_cast<uint64_t>(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.