[llvm-readobj] fix unit test failure on 32bit machines

[antmo]

Summary

Several bots are failing on 32-bit since https://reviews.llvm.org/D145761 was merged

https://lab.llvm.org/buildbot/#/builders/178/builds/4384

It seems due to the use of uintptr_t (32bit here) for storing 64 bit values.

Issue is fixed by replacing to uint64_t (as suggested by DavidSpickett).

[jhenderson]

My inline suggestion could be tested by using a section with e.g. size 1 and a size tag value of 0x100000001, since on a 32-bit machine, that should not trigger the error (since 0x100000001 is truncated to 1), when an error is expected.

llvm/tools/llvm-readobj/ELFDumper.cpp

6007

The size_t here should probably be changed too, since in theory the dynamic entry value could be greater than the max value of size_t on a 32-bit machine. Using fixed-sized types is generally the approach taken elsewhere in the code, so uint64_t for both seems appropriate to me.

[antmo]

also change size_t as suggested by jhenderson

[jhenderson]

LGTM, with one suggestion.

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag.test

309 ↗

(On Diff #513160)

Can you confirm tha this test case fails if using a 32-bit machine without your fix?

Also, please add a small comment explaining that this is to show that the GLOBALSSZ tag is stored in a 64-bit integer even on 32-bit machines.

[antmo]

update test

[antmo]

Thanks for the review @jhenderson .
I confirm that the test fails on a 32-bit machine without the fix.
Also, if everything is OK, could someone merge this patch for me please?

[jhenderson]

@hctim - it was your patch originally, so I'll leave you to commit the fix if you're happy with it.

[DavidSpickett]

I'll land this for you.

You'll be needing commit access the more you do buildbot duty, https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access :)

llvm/tools/llvm-readobj/ELFDumper.cpp

 //===- ELFDumper.cpp - ELF-specific dumper --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
public:
   void printNeededLibraries() override;
   void printHashTable() override;
   void printGnuHashTable() override;
   void printLoadName() override;
   void printVersionInfo() override;
   void printArchSpecificInfo() override;
   void printStackMap() const override;
   void printMemtag() override;
-  ArrayRef<uint8_t> getMemtagGlobalsSectionContents(uintptr_t ExpectedAddr);
+  ArrayRef<uint8_t> getMemtagGlobalsSectionContents(uint64_t ExpectedAddr);
 
   // 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;
 
template <class ELFT> void GNUELFDumper<ELFT>::printNotes() {
   };
 
   processNotesHelper(*this, /*StartNotesFn=*/PrintHeader,
                      /*ProcessNoteFn=*/ProcessNote, /*FinishNotesFn=*/[]() {});
 }
 
 template <class ELFT>
 ArrayRef<uint8_t>
-ELFDumper<ELFT>::getMemtagGlobalsSectionContents(uintptr_t ExpectedAddr) {
+ELFDumper<ELFT>::getMemtagGlobalsSectionContents(uint64_t ExpectedAddr) {
   for (const typename ELFT::Shdr &Sec : cantFail(Obj.sections())) {
     if (Sec.sh_type != SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC)
       continue;
     if (Sec.sh_addr != ExpectedAddr) {
       reportUniqueWarning(
           "SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section was unexpectedly at 0x" +
           Twine::utohexstr(Sec.sh_addr) +
           ", when DT_AARCH64_MEMTAG_GLOBALS says it should be at 0x" +

 // encoding the memtag descriptors. Found to be the best overall size tradeoff
 // when compiling Android T with full MTE globals enabled.
 constexpr uint64_t MemtagStepVarintReservedBits = 3;
 constexpr uint64_t MemtagGranuleSize = 16;
 
 template <typename ELFT> void ELFDumper<ELFT>::printMemtag() {
   if (Obj.getHeader().e_machine != EM_AARCH64) return;
   std::vector<std::pair<std::string, std::string>> DynamicEntries;
   size_t MemtagGlobalsSz = 0;
-  uintptr_t MemtagGlobals = 0;
+  uint64_t MemtagGlobals = 0;
   for (const typename ELFT::Dyn &Entry : dynamic_table()) {
     uintX_t Tag = Entry.getTag();
     switch (Tag) {
     case DT_AARCH64_MEMTAG_GLOBALSSZ:
       MemtagGlobalsSz = Entry.getVal();
       DynamicEntries.emplace_back(Obj.getDynamicTagAsString(Tag),
                                   getDynamicEntry(Tag, Entry.getVal()));
       break;