[llvm-readobj/libObject] - Get rid of `FirstSym` argument. NFCI.

[grimar]

Summary

We use FirstSym argument in getExtendedSymbolTableIndex to calculate
a symbol index:

&Sym - &FirstSym

Instead, we could pass the symbol index directly.
This is what this patch does, it allows to simplify another llvm-readobj API.

[jhenderson]

LGTM, assuming I'm not mistaken in thinking there's another patch related to this one.

llvm/tools/llvm-readobj/ELFDumper.cpp

1190–1193

This is assuming the symbol is from the .symtab symbol table. I seem to remember you are fixing that elsewhere?

[grimar]

llvm/tools/llvm-readobj/ELFDumper.cpp

1190–1193

Yep. Here: D87899

llvm/include/llvm/Object/ELF.h

 getSection(typename ELFT::ShdrRange Sections, uint32_t Index) {
   if (Index >= Sections.size())
     return createError("invalid section index: " + Twine(Index));
   return &Sections[Index];
 }
 
 template <class ELFT>
 inline Expected<uint32_t>
-getExtendedSymbolTableIndex(const typename ELFT::Sym &Sym,
-                            const typename ELFT::Sym &FirstSym,
+getExtendedSymbolTableIndex(const typename ELFT::Sym &Sym, unsigned SymIndex,
                             ArrayRef<typename ELFT::Word> ShndxTable) {
   assert(Sym.st_shndx == ELF::SHN_XINDEX);
-  unsigned Index = &Sym - &FirstSym;
-  if (Index >= ShndxTable.size())
+  if (SymIndex >= ShndxTable.size())
     return createError(
-        "extended symbol index (" + Twine(Index) +
+        "extended symbol index (" + Twine(SymIndex) +
         ") is past the end of the SHT_SYMTAB_SHNDX section of size " +
         Twine(ShndxTable.size()));
 
   // The size of the table was checked in getSHNDXTable.
-  return ShndxTable[Index];
+  return ShndxTable[SymIndex];
 }
 
 template <class ELFT>
 Expected<uint32_t>
 ELFFile<ELFT>::getSectionIndex(const Elf_Sym &Sym, Elf_Sym_Range Syms,
                                ArrayRef<Elf_Word> ShndxTable) const {
   uint32_t Index = Sym.st_shndx;
   if (Index == ELF::SHN_XINDEX) {
     Expected<uint32_t> ErrorOrIndex =
-        getExtendedSymbolTableIndex<ELFT>(Sym, *Syms.begin(), ShndxTable);
+        getExtendedSymbolTableIndex<ELFT>(Sym, &Sym - Syms.begin(), ShndxTable);
     if (!ErrorOrIndex)
       return ErrorOrIndex.takeError();
     return *ErrorOrIndex;
   }
   if (Index == ELF::SHN_UNDEF || Index >= ELF::SHN_LORESERVE)
     return 0;
   return Index;
 }

llvm/tools/llvm-readobj/ELFDumper.cpp

public:
 
   Elf_Rel_Range dyn_rels() const;
   Elf_Rela_Range dyn_relas() const;
   Elf_Relr_Range dyn_relrs() const;
   std::string getFullSymbolName(const Elf_Sym *Symbol,
                                 Optional<StringRef> StrTable,
                                 bool IsDynamic) const;
   Expected<unsigned> getSymbolSectionIndex(const Elf_Sym *Symbol,
-                                           const Elf_Sym *FirstSym) const;
+                                           unsigned SymIndex) const;
   Expected<StringRef> getSymbolSectionName(const Elf_Sym *Symbol,
                                            unsigned SectionIndex) const;
   std::string getStaticSymbolName(uint32_t Index) const;
   StringRef getDynamicString(uint64_t Value) const;
   Expected<StringRef> getSymbolVersionByIndex(uint32_t VersionSymbolIndex,
                                               bool &IsDefault) const;
 
   void printSymbolsHelper(bool IsDynamic) const;
void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const {
   // The st_other field has 2 logical parts. The first two bits hold the symbol
   // visibility (STV_*) and the remainder hold other platform-specific values.
   bool NonVisibilityBitsUsed = llvm::find_if(Syms, [](const Elf_Sym &S) {
                                  return S.st_other & ~0x3;
                                }) != Syms.end();
 
   ELFDumperStyle->printSymtabMessage(SymtabSec, Entries, NonVisibilityBitsUsed);
   for (const auto &Sym : Syms)
-    ELFDumperStyle->printSymbol(&Sym, Syms.begin(), StrTable, IsDynamic,
+    ELFDumperStyle->printSymbol(&Sym, &Sym - Syms.begin(), StrTable, IsDynamic,
                                 NonVisibilityBitsUsed);
 }
 
 template <class ELFT> class MipsGOTParser;
 
 template <typename ELFT> class DumpStyle {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
public:
   virtual void printSectionHeaders() = 0;
   virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) = 0;
   virtual void printHashSymbols() {}
   virtual void printDependentLibs() = 0;
   virtual void printDynamic() {}
   virtual void printDynamicRelocations() = 0;
   virtual void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset,
                                   bool NonVisibilityBitsUsed) {}
-  virtual void printSymbol(const Elf_Sym *Symbol, const Elf_Sym *FirstSym,
+  virtual void printSymbol(const Elf_Sym *Symbol, unsigned SymIndex,
                            Optional<StringRef> StrTable, bool IsDynamic,
                            bool NonVisibilityBitsUsed) = 0;
   virtual void printProgramHeaders(bool PrintProgramHeaders,
                                    cl::boolOrDefault PrintSectionMapping) = 0;
   virtual void printVersionSymbolSection(const Elf_Shdr *Sec) = 0;
   virtual void printVersionDefinitionSection(const Elf_Shdr *Sec) = 0;
   virtual void printVersionDependencySection(const Elf_Shdr *Sec) = 0;
   virtual void printHashHistograms() = 0;
private:
 
   formatted_raw_ostream &printField(struct Field F) {
     if (F.Column != 0)
       OS.PadToColumn(F.Column);
     OS << F.Str;
     OS.flush();
     return OS;
   }
-  void printHashedSymbol(const Elf_Sym *FirstSym, uint32_t Sym,
+  void printHashedSymbol(const Elf_Sym *Sym, unsigned SymIndex,
                          StringRef StrTable, uint32_t Bucket);
   void printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
                   const Elf_Shdr &Sec, const Elf_Shdr *SymTab) override;
   void printRelrReloc(const Elf_Relr &R) override;
 
   void printRelRelaReloc(const Relocation<ELFT> &R,
                          const RelSymbol<ELFT> &RelSym);
-  void printSymbol(const Elf_Sym *Symbol, const Elf_Sym *First,
+  void printSymbol(const Elf_Sym *Symbol, unsigned SymIndex,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool NonVisibilityBitsUsed) override;
   void printDynamicRelocHeader(unsigned Type, StringRef Name,
                                const DynRegionInfo &Reg) override;
   void printDynamicReloc(const Relocation<ELFT> &R) override;
 
-  std::string getSymbolSectionNdx(const Elf_Sym *Symbol,
-                                  const Elf_Sym *FirstSym);
+  std::string getSymbolSectionNdx(const Elf_Sym *Symbol, unsigned SymIndex);
   void printProgramHeaders();
   void printSectionMapping();
   void printGNUVersionSectionProlog(const typename ELFT::Shdr *Sec,
                                     const Twine &Label, unsigned EntriesNum);
 };
 
 template <class ELFT>
 void ELFDumper<ELFT>::reportUniqueWarning(Error Err) const {
private:
   void printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
                   const Elf_Shdr &Sec, const Elf_Shdr *SymTab) override;
   void printRelrReloc(const Elf_Relr &R) override;
   void printDynamicReloc(const Relocation<ELFT> &R) override;
 
   void printRelRelaReloc(const Relocation<ELFT> &R, StringRef SymbolName);
   void printSymbols();
   void printDynamicSymbols();
-  void printSymbolSection(const Elf_Sym *Symbol, const Elf_Sym *First);
-  void printSymbol(const Elf_Sym *Symbol, const Elf_Sym *First,
+  void printSymbolSection(const Elf_Sym *Symbol, unsigned SymIndex);
+  void printSymbol(const Elf_Sym *Symbol, unsigned SymIndex,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool /*NonVisibilityBitsUsed*/) override;
   void printProgramHeaders();
   void printSectionMapping() {}
 
   ScopedPrinter &W;
 };
 
std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol,
   if (Expected<StringRef> NameOrErr = Symbol->getName(*StrTable)) {
     SymbolName = maybeDemangle(*NameOrErr);
   } else {
     reportUniqueWarning(NameOrErr.takeError());
     return "<?>";
   }
 
   if (SymbolName.empty() && Symbol->getType() == ELF::STT_SECTION) {
     Elf_Sym_Range Syms = unwrapOrError(
         ObjF->getFileName(), ObjF->getELFFile()->symbols(DotSymtabSec));
     Expected<unsigned> SectionIndex =
-        getSymbolSectionIndex(Symbol, Syms.begin());
+        getSymbolSectionIndex(Symbol, Symbol - Syms.begin());
     if (!SectionIndex) {
       reportUniqueWarning(SectionIndex.takeError());
       return "<?>";
     }
     Expected<StringRef> NameOrErr = getSymbolSectionName(Symbol, *SectionIndex);
     if (!NameOrErr) {
       reportUniqueWarning(NameOrErr.takeError());
       return ("<section " + Twine(*SectionIndex) + ">").str();
if (!VersionOrErr->empty()) {
     SymbolName += *VersionOrErr;
   }
   return SymbolName;
 }
 
 template <typename ELFT>
 Expected<unsigned>
 ELFDumper<ELFT>::getSymbolSectionIndex(const Elf_Sym *Symbol,
-                                       const Elf_Sym *FirstSym) const {
+                                       unsigned SymIndex) const {
   unsigned Ndx = Symbol->st_shndx;
   if (Ndx == SHN_XINDEX)
-    return object::getExtendedSymbolTableIndex<ELFT>(*Symbol, *FirstSym,
+    return object::getExtendedSymbolTableIndex<ELFT>(*Symbol, SymIndex,
                                                      ShndxTable);
   if (Ndx != SHN_UNDEF && Ndx < SHN_LORESERVE)
     return Ndx;
 
   auto CreateErr = [&](const Twine &Name, Optional<unsigned> Offset = None) {
     std::string Desc;
     if (Offset)
       Desc = (Name + "+0x" + Twine::utohexstr(*Offset)).str();
void GNUStyle<ELFT>::printSymtabMessage(const Elf_Shdr *Symtab, size_t Entries,
 
   if (NonVisibilityBitsUsed)
     OS << "             ";
   OS << "       Ndx Name\n";
 }
 
 template <class ELFT>
 std::string GNUStyle<ELFT>::getSymbolSectionNdx(const Elf_Sym *Symbol,
-                                                const Elf_Sym *FirstSym) {
+                                                unsigned SymIndex) {
   unsigned SectionIndex = Symbol->st_shndx;
   switch (SectionIndex) {
   case ELF::SHN_UNDEF:
     return "UND";
   case ELF::SHN_ABS:
     return "ABS";
   case ELF::SHN_COMMON:
     return "COM";
   case ELF::SHN_XINDEX: {
     Expected<uint32_t> IndexOrErr = object::getExtendedSymbolTableIndex<ELFT>(
-        *Symbol, *FirstSym, this->dumper()->getShndxTable());
+        *Symbol, SymIndex, this->dumper()->getShndxTable());
     if (!IndexOrErr) {
       assert(Symbol->st_shndx == SHN_XINDEX &&
              "getExtendedSymbolTableIndex should only fail due to an invalid "
              "SHT_SYMTAB_SHNDX table/reference");
       this->reportUniqueWarning(IndexOrErr.takeError());
       return "RSV[0xffff]";
     }
     return to_string(format_decimal(*IndexOrErr, 3));
if (SectionIndex >= ELF::SHN_LORESERVE &&
       return std::string("RSV[0x") +
              to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
     // A normal section with an index
     return to_string(format_decimal(SectionIndex, 3));
   }
 }
 
 template <class ELFT>
-void GNUStyle<ELFT>::printSymbol(const Elf_Sym *Symbol, const Elf_Sym *FirstSym,
+void GNUStyle<ELFT>::printSymbol(const Elf_Sym *Symbol, unsigned SymIndex,
                                  Optional<StringRef> StrTable, bool IsDynamic,
                                  bool NonVisibilityBitsUsed) {
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
   Field Fields[8] = {0,         8,         17 + Bias, 23 + Bias,
                      31 + Bias, 38 + Bias, 48 + Bias, 51 + Bias};
-  Fields[0].Str = to_string(format_decimal(Symbol - FirstSym, 6)) + ":";
+  Fields[0].Str = to_string(format_decimal(SymIndex, 6)) + ":";
   Fields[1].Str = to_string(
       format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8));
   Fields[2].Str = to_string(format_decimal(Symbol->st_size, 5));
 
   unsigned char SymbolType = Symbol->getType();
   if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
       SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
     Fields[3].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
   else
     Fields[3].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
 
   Fields[4].Str =
       printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
   Fields[5].Str =
       printEnum(Symbol->getVisibility(), makeArrayRef(ElfSymbolVisibilities));
   if (Symbol->st_other & ~0x3)
     Fields[5].Str +=
         " [<other: " + to_string(format_hex(Symbol->st_other, 2)) + ">]";
 
   Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0;
-  Fields[6].Str = getSymbolSectionNdx(Symbol, FirstSym);
+  Fields[6].Str = getSymbolSectionNdx(Symbol, SymIndex);
 
   Fields[7].Str =
       this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
   for (auto &Entry : Fields)
     printField(Entry);
   OS << "\n";
 }
 
 template <class ELFT>
-void GNUStyle<ELFT>::printHashedSymbol(const Elf_Sym *FirstSym, uint32_t Sym,
+void GNUStyle<ELFT>::printHashedSymbol(const Elf_Sym *Symbol, unsigned SymIndex,
                                        StringRef StrTable, uint32_t Bucket) {
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
   Field Fields[9] = {0,         6,         11,        20 + Bias, 25 + Bias,
                      34 + Bias, 41 + Bias, 49 + Bias, 53 + Bias};
-  Fields[0].Str = to_string(format_decimal(Sym, 5));
+  Fields[0].Str = to_string(format_decimal(SymIndex, 5));
   Fields[1].Str = to_string(format_decimal(Bucket, 3)) + ":";
 
-  const auto Symbol = FirstSym + Sym;
   Fields[2].Str = to_string(
       format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8));
   Fields[3].Str = to_string(format_decimal(Symbol->st_size, 5));
 
   unsigned char SymbolType = Symbol->getType();
   if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
       SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
     Fields[4].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
   else
     Fields[4].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
 
   Fields[5].Str =
       printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
   Fields[6].Str =
       printEnum(Symbol->getVisibility(), makeArrayRef(ElfSymbolVisibilities));
-  Fields[7].Str = getSymbolSectionNdx(Symbol, FirstSym);
+  Fields[7].Str = getSymbolSectionNdx(Symbol, SymIndex);
   Fields[8].Str = this->dumper()->getFullSymbolName(Symbol, StrTable, true);
 
   for (auto &Entry : Fields)
     printField(Entry);
   OS << "\n";
 }
 
 template <class ELFT>
for (uint32_t Ch = Buckets[Buc]; Ch < SysVHash.nchain; Ch = Chains[Ch]) {
       if (Visited[Ch]) {
         reportWarning(createError(".hash section is invalid: bucket " +
                                   Twine(Ch) +
                                   ": a cycle was detected in the linked chain"),
                       this->FileName);
         break;
       }
 
-      printHashedSymbol(FirstSym, Ch, StringTable, Buc);
+      printHashedSymbol(FirstSym + Ch, Ch, StringTable, Buc);
       Visited[Ch] = true;
     }
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printGnuHashTableSymbols(const Elf_GnuHash &GnuHash) {
   StringRef StringTable = this->dumper()->getDynamicStringTable();
void GNUStyle<ELFT>::printGnuHashTableSymbols(const Elf_GnuHash &GnuHash) {
   ArrayRef<Elf_Word> Buckets = GnuHash.buckets();
   for (uint32_t Buc = 0; Buc < GnuHash.nbuckets; Buc++) {
     if (Buckets[Buc] == ELF::STN_UNDEF)
       continue;
     uint32_t Index = Buckets[Buc];
     uint32_t GnuHashable = Index - GnuHash.symndx;
     // Print whole chain
     while (true) {
-      printHashedSymbol(FirstSym, Index++, StringTable, Buc);
+      uint32_t SymIndex = Index++;
+      printHashedSymbol(FirstSym + SymIndex, SymIndex, StringTable, Buc);
       // Chain ends at symbol with stopper bit
       if ((GnuHash.values(DynSyms.size())[GnuHashable++] & 1) == 1)
         break;
     }
   }
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printHashSymbols() {
for (auto &E : Parser.getGlobalEntries()) {
       OS << to_string(format_decimal(Parser.getGotOffset(&E), 6)) + "(gp)";
       OS.PadToColumn(22 + Bias);
       OS << to_string(format_hex_no_prefix(E, 8 + Bias));
       OS.PadToColumn(31 + 2 * Bias);
       OS << to_string(format_hex_no_prefix(Sym->st_value, 8 + Bias));
       OS.PadToColumn(40 + 3 * Bias);
       OS << printEnum(Sym->getType(), makeArrayRef(ElfSymbolTypes));
       OS.PadToColumn(48 + 3 * Bias);
-      OS << getSymbolSectionNdx(Sym, this->dumper()->dynamic_symbols().begin());
+      OS << getSymbolSectionNdx(
+          Sym, Sym - this->dumper()->dynamic_symbols().begin());
       OS.PadToColumn(52 + 3 * Bias);
       OS << SymName << "\n";
     }
   }
 
   if (!Parser.getOtherEntries().empty())
     OS << "\n Number of TLS and multi-GOT entries "
        << Parser.getOtherEntries().size() << "\n";
for (auto &E : Parser.getPltEntries()) {
       OS << to_string(format_hex_no_prefix(Parser.getPltAddress(&E), 8 + Bias));
       OS.PadToColumn(11 + Bias);
       OS << to_string(format_hex_no_prefix(E, 8 + Bias));
       OS.PadToColumn(20 + 2 * Bias);
       OS << to_string(format_hex_no_prefix(Sym->st_value, 8 + Bias));
       OS.PadToColumn(29 + 3 * Bias);
       OS << printEnum(Sym->getType(), makeArrayRef(ElfSymbolTypes));
       OS.PadToColumn(37 + 3 * Bias);
-      OS << getSymbolSectionNdx(Sym, this->dumper()->dynamic_symbols().begin());
+      OS << getSymbolSectionNdx(
+          Sym, Sym - this->dumper()->dynamic_symbols().begin());
       OS.PadToColumn(41 + 3 * Bias);
       OS << SymName << "\n";
     }
   }
 }
 
 template <class ELFT>
 Expected<const Elf_Mips_ABIFlags<ELFT> *>
for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
     }
 
     if (opts::SectionSymbols) {
       ListScope D(W, "Symbols");
       if (const Elf_Shdr *Symtab = this->dumper()->getDotSymtabSec()) {
         StringRef StrTable = unwrapOrError(
             this->FileName, this->Obj.getStringTableForSymtab(*Symtab));
 
-        for (const Elf_Sym &Sym :
-             unwrapOrError(this->FileName, this->Obj.symbols(Symtab))) {
+        typename ELFT::SymRange Symbols =
+            unwrapOrError(this->FileName, this->Obj.symbols(Symtab));
+        for (const Elf_Sym &Sym : Symbols) {
           const Elf_Shdr *SymSec =
               unwrapOrError(this->FileName,
                             this->Obj.getSection(
                                 Sym, Symtab, this->dumper()->getShndxTable()));
           if (SymSec == &Sec)
-            printSymbol(&Sym,
-                        unwrapOrError(this->FileName, this->Obj.symbols(Symtab))
-                            .begin(),
-                        StrTable, false, false);
+            printSymbol(&Sym, &Sym - &Symbols[0], StrTable, false, false);
         }
       }
     }
 
     if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
       ArrayRef<uint8_t> Data =
           unwrapOrError(this->FileName, this->Obj.getSectionContents(Sec));
       W.printBinaryBlock(
           "SectionData",
           StringRef(reinterpret_cast<const char *>(Data.data()), Data.size()));
     }
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printSymbolSection(const Elf_Sym *Symbol,
-                                         const Elf_Sym *First) {
+                                         unsigned SymIndex) {
   auto GetSectionSpecialType = [&]() -> Optional<StringRef> {
     if (Symbol->isUndefined())
       return StringRef("Undefined");
     if (Symbol->isProcessorSpecific())
       return StringRef("Processor Specific");
     if (Symbol->isOSSpecific())
       return StringRef("Operating System Specific");
     if (Symbol->isAbsolute())
       return StringRef("Absolute");
     if (Symbol->isCommon())
       return StringRef("Common");
     if (Symbol->isReserved() && Symbol->st_shndx != SHN_XINDEX)
       return StringRef("Reserved");
     return None;
   };
 
   if (Optional<StringRef> Type = GetSectionSpecialType()) {
     W.printHex("Section", *Type, Symbol->st_shndx);
     return;
   }
 
   Expected<unsigned> SectionIndex =
-      this->dumper()->getSymbolSectionIndex(Symbol, First);
+      this->dumper()->getSymbolSectionIndex(Symbol, SymIndex);
   if (!SectionIndex) {
     assert(Symbol->st_shndx == SHN_XINDEX &&
            "getSymbolSectionIndex should only fail due to an invalid "
            "SHT_SYMTAB_SHNDX table/reference");
     this->reportUniqueWarning(SectionIndex.takeError());
     W.printHex("Section", "Reserved", SHN_XINDEX);
     return;
   }
else
       consumeError(SectionName.takeError());
     W.printHex("Section", "<?>", *SectionIndex);
   } else {
     W.printHex("Section", *SectionName, *SectionIndex);
   }
 }
 
 template <class ELFT>
-void LLVMStyle<ELFT>::printSymbol(const Elf_Sym *Symbol, const Elf_Sym *First,
+void LLVMStyle<ELFT>::printSymbol(const Elf_Sym *Symbol, unsigned SymIndex,
                                   Optional<StringRef> StrTable, bool IsDynamic,
                                   bool /*NonVisibilityBitsUsed*/) {
   std::string FullSymbolName =
       this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
   unsigned char SymbolType = Symbol->getType();
 
   DictScope D(W, "Symbol");
   W.printNumber("Name", FullSymbolName, Symbol->st_name);
if (this->Obj.getHeader().e_machine == EM_MIPS) {
                              std::end(ElfMips16SymOtherFlags));
       else
         SymOtherFlags.insert(SymOtherFlags.end(),
                              std::begin(ElfMipsSymOtherFlags),
                              std::end(ElfMipsSymOtherFlags));
     }
     W.printFlags("Other", Symbol->st_other, makeArrayRef(SymOtherFlags), 0x3u);
   }
-  printSymbolSection(Symbol, First);
+  printSymbolSection(Symbol, SymIndex);
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printSymbols(bool PrintSymbols,
                                    bool PrintDynamicSymbols) {
   if (PrintSymbols)
     printSymbols();
   if (PrintDynamicSymbols)
if (Parser.IsStatic)
     for (auto &E : Parser.getGlobalEntries()) {
       DictScope D(W, "Entry");
 
       PrintEntry(&E);
 
       const Elf_Sym *Sym = Parser.getGotSym(&E);
       W.printHex("Value", Sym->st_value);
       W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
-      printSymbolSection(Sym, this->dumper()->dynamic_symbols().begin());
+      printSymbolSection(Sym, Sym - this->dumper()->dynamic_symbols().begin());
 
       std::string SymName = this->dumper()->getFullSymbolName(
           Sym, this->dumper()->getDynamicStringTable(), true);
       W.printNumber("Name", SymName, Sym->st_name);
     }
   }
 
   W.printNumber("Number of TLS and multi-GOT entries",
DictScope GS(W, "PLT GOT");
     ListScope LS(W, "Entries");
     for (auto &E : Parser.getPltEntries()) {
       DictScope D(W, "Entry");
       PrintEntry(&E);
 
       const Elf_Sym *Sym = Parser.getPltSym(&E);
       W.printHex("Value", Sym->st_value);
       W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
-      printSymbolSection(Sym, this->dumper()->dynamic_symbols().begin());
+      printSymbolSection(Sym, Sym - this->dumper()->dynamic_symbols().begin());
 
       std::string SymName =
           this->dumper()->getFullSymbolName(Sym, Parser.getPltStrTable(), true);
       W.printNumber("Name", SymName, Sym->st_name);
     }
   }
 }