[llvm-objdump][NFC] Improve readability.

[courbet]

Summary

Introduce a struct SectionSymbol instead of
tuple<uint64_t, StringRef, uint8>.

[jhenderson]

LGTM, with two minor comments.

tools/llvm-objdump/llvm-objdump.cpp

282

Remove this blank line.

284

Don't abbreviate these. You can use Address, Name, and Type in the signature.

[courbet]

Address comments

[courbet]

Thanks.

[courbet]

Rebase

tools/llvm-objdump/llvm-objdump.cpp

cl::opt<bool> DisassembleZeroes(
                 "disassemble-zeroes",
                 cl::desc("Do not skip blocks of zeroes when disassembling"));
 cl::alias DisassembleZeroesShort("z",
                                  cl::desc("Alias for --disassemble-zeroes"),
                                  cl::aliasopt(DisassembleZeroes));
 
 static StringRef ToolName;
 
-typedef std::vector<std::tuple<uint64_t, StringRef, uint8_t>> SectionSymbolsTy;
-
 namespace {
+struct SectionSymbol {
+  SectionSymbol(uint64_t Address, StringRef Name, uint8_t Type)
+      : Address(Address), Name(Name), Type(Type) {}
+
+  bool operator<(const SectionSymbol &Other) const {
+    return std::tie(Address, Name, Type) <
+           std::tie(Other.Address, Other.Name, Other.Type);
+  }
+
+  uint64_t Address;
+  StringRef Name;
+  uint8_t Type;
+};
+
+typedef std::vector<SectionSymbol> SectionSymbolsTy;
+
 typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;
 
 class SectionFilterIterator {
 public:
   SectionFilterIterator(FilterPredicate P,
                         llvm::object::section_iterator const &I,
                         llvm::object::section_iterator const &E)
       : Predicate(std::move(P)), Iterator(I), End(E) {
if (!SectSize)
       continue;
 
     // Get the list of all the symbols in this section.
     SectionSymbolsTy &Symbols = AllSymbols[Section];
     std::vector<uint64_t> DataMappingSymsAddr;
     std::vector<uint64_t> TextMappingSymsAddr;
     if (isArmElf(Obj)) {
       for (const auto &Symb : Symbols) {
-        uint64_t Address = std::get<0>(Symb);
-        StringRef Name = std::get<1>(Symb);
+        uint64_t Address = Symb.Address;
+        StringRef Name = Symb.Name;
         if (Name.startswith("$d"))
           DataMappingSymsAddr.push_back(Address - SectionAddr);
         if (Name.startswith("$x"))
           TextMappingSymsAddr.push_back(Address - SectionAddr);
         if (Name.startswith("$a"))
           TextMappingSymsAddr.push_back(Address - SectionAddr);
         if (Name.startswith("$t"))
           TextMappingSymsAddr.push_back(Address - SectionAddr);
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     if (const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj)) {
       DataRefImpl DR = Section.getRawDataRefImpl();
       SegmentName = MachO->getSectionFinalSegmentName(DR);
     }
     StringRef SectionName;
     error(Section.getName(SectionName));
 
     // If the section has no symbol at the start, just insert a dummy one.
-    if (Symbols.empty() || std::get<0>(Symbols[0]) != 0) {
+    if (Symbols.empty() || Symbols[0].Address != 0) {
       Symbols.insert(
           Symbols.begin(),
-          std::make_tuple(SectionAddr, SectionName,
-                          Section.isText() ? ELF::STT_FUNC : ELF::STT_OBJECT));
+          SectionSymbol(SectionAddr, SectionName,
     }
 
     SmallString<40> Comments;
     raw_svector_ostream CommentStream(Comments);
 
     StringRef BytesStr;
     error(Section.getContents(BytesStr));
     ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
                             BytesStr.size());
 
     uint64_t Size;
     uint64_t Index;
     bool PrintedSection = false;
 
     std::vector<RelocationRef>::const_iterator RelCur = Rels.begin();
     std::vector<RelocationRef>::const_iterator RelEnd = Rels.end();
     // Disassemble symbol by symbol.
     for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
-      uint64_t Start = std::get<0>(Symbols[SI]) - SectionAddr;
+      uint64_t Start = Symbols[SI].Address - SectionAddr;
       // The end is either the section end or the beginning of the next
       // symbol.
       uint64_t End = (SI == SE - 1)
                          ? SectSize
-                         : std::get<0>(Symbols[SI + 1]) - SectionAddr;
+                         : Symbols[SI + 1].Address - SectionAddr;
       // Don't try to disassemble beyond the end of section contents.
       if (End > SectSize)
         End = SectSize;
       // If this symbol has the same address as the next symbol, then skip it.
       if (Start >= End)
         continue;
 
       // Check if we need to skip symbol
       // Skip if the symbol's data is not between StartAddress and StopAddress
       if (End + SectionAddr < StartAddress ||
           Start + SectionAddr > StopAddress) {
         continue;
       }
 
       /// Skip if user requested specific symbols and this is not in the list
-      if (!DisasmFuncsSet.empty() &&
-          !DisasmFuncsSet.count(std::get<1>(Symbols[SI])))
+      if (!DisasmFuncsSet.empty() && !DisasmFuncsSet.count(Symbols[SI].Name))
         continue;
 
       if (!PrintedSection) {
         PrintedSection = true;
         outs() << "Disassembly of section ";
         if (!SegmentName.empty())
           outs() << SegmentName << ",";
         outs() << SectionName << ':';
       }
 
       // Stop disassembly at the stop address specified
       if (End + SectionAddr > StopAddress)
         End = StopAddress - SectionAddr;
 
       if (Obj->isELF() && Obj->getArch() == Triple::amdgcn) {
-        if (std::get<2>(Symbols[SI]) == ELF::STT_AMDGPU_HSA_KERNEL) {
+        if (Symbols[SI].Type == ELF::STT_AMDGPU_HSA_KERNEL) {
           // skip amd_kernel_code_t at the begining of kernel symbol (256 bytes)
           Start += 256;
         }
         if (SI == SE - 1 ||
-            std::get<2>(Symbols[SI + 1]) == ELF::STT_AMDGPU_HSA_KERNEL) {
+            Symbols[SI + 1].Type == ELF::STT_AMDGPU_HSA_KERNEL) {
           // cut trailing zeroes at the end of kernel
           // cut up to 256 bytes
           const uint64_t EndAlign = 256;
           const auto Limit = End - (std::min)(EndAlign, End - Start);
           while (End > Limit &&
             *reinterpret_cast<const support::ulittle32_t*>(&Bytes[End - 4]) == 0)
             End -= 4;
         }
       }
 
       outs() << '\n';
       if (!NoLeadingAddr)
         outs() << format("%016" PRIx64 " ", SectionAddr + Start);
 
-      StringRef SymbolName = std::get<1>(Symbols[SI]);
+      StringRef SymbolName = Symbols[SI].Name;
       if (Demangle)
         outs() << demangle(SymbolName) << ":\n";
       else
         outs() << SymbolName << ":\n";
 
       // Don't print raw contents of a virtual section. A virtual section
       // doesn't have any contents in the file.
       if (Section.isVirtual()) {
#endif
           // skip byte by byte till StartAddress is reached
           Size = 1;
           continue;
         }
         // AArch64 ELF binaries can interleave data and text in the
         // same section. We rely on the markers introduced to
         // understand what we need to dump. If the data marker is within a
         // function, it is denoted as a word/short etc
-        if (isArmElf(Obj) && std::get<2>(Symbols[SI]) != ELF::STT_OBJECT &&
+        if (isArmElf(Obj) && Symbols[SI].Type != ELF::STT_OBJECT &&
             !DisassembleAll) {
           uint64_t Stride = 0;
 
           auto DAI = std::lower_bound(DataMappingSymsAddr.begin(),
                                       DataMappingSymsAddr.end(), Index);
           if (DAI != DataMappingSymsAddr.end() && *DAI == Index) {
             // Switch to data.
             while (Index < End) {
#endif
             }
           }
         }
 
         // If there is a data symbol inside an ELF text section and we are only
         // disassembling text (applicable all architectures),
         // we are in a situation where we must print the data and not
         // disassemble it.
-        if (Obj->isELF() && std::get<2>(Symbols[SI]) == ELF::STT_OBJECT &&
+        if (Obj->isELF() && Symbols[SI].Type == ELF::STT_OBJECT &&
             !DisassembleAll && Section.isText()) {
           // print out data up to 8 bytes at a time in hex and ascii
           uint8_t AsciiData[9] = {'\0'};
           uint8_t Byte;
           int NumBytes = 0;
 
           for (Index = Start; Index < End; Index += 1) {
             if (((SectionAddr + Index) < StartAddress) ||
#endif
               }
             }
 
             // Find the first symbol in the section whose offset is less than
             // or equal to the target. If there isn't a section that contains
             // the target, find the nearest preceding absolute symbol.
             auto TargetSym = std::upper_bound(
                 TargetSectionSymbols->begin(), TargetSectionSymbols->end(),
-                Target, [](uint64_t LHS,
-                           const std::tuple<uint64_t, StringRef, uint8_t> &RHS) {
-                  return LHS < std::get<0>(RHS);
+                Target, [](uint64_t LHS, const SectionSymbol &RHS) {
+                  return LHS < RHS.Address;
                 });
             if (TargetSym == TargetSectionSymbols->begin()) {
               TargetSectionSymbols = &AbsoluteSymbols;
               TargetSym = std::upper_bound(
-                  AbsoluteSymbols.begin(), AbsoluteSymbols.end(),
-                  Target, [](uint64_t LHS,
-                             const std::tuple<uint64_t, StringRef, uint8_t> &RHS) {
-                            return LHS < std::get<0>(RHS);
-                          });
+                  AbsoluteSymbols.begin(), AbsoluteSymbols.end(), Target,
+                  [](uint64_t LHS, const SectionSymbol &RHS) {
+                    return LHS < RHS.Address;
             }
             if (TargetSym != TargetSectionSymbols->begin()) {
               --TargetSym;
-              uint64_t TargetAddress = std::get<0>(*TargetSym);
-              StringRef TargetName = std::get<1>(*TargetSym);
-              outs() << " <" << TargetName;
-              uint64_t Disp = Target - TargetAddress;
+              outs() << " <" << TargetSym->Name;
+              uint64_t Disp = Target - TargetSym->Address;
               if (Disp)
                 outs() << "+0x" << Twine::utohexstr(Disp);
               outs() << '>';
             }
           }
         }
         outs() << "\n";