llvm-readobj: GNU style symbols printing

[khemant]

Summary

Implements symbols printing similar to
readelf -sW

[khemant]

Looks like I forgot to add the test case. Will update the diff.

[khemant]

Added test case.

[• rafael]

Can symbols-proc-specific.elf-hexagon be created with llvm-mc?

tools/llvm-readobj/ELFDumper.cpp

47

There is a getVisibility in Elf_Sym.

182

Please avoid adding this.

You can use dynamic_symbols.

[khemant]

The patch to upstream the processor specific flags for small area is not yet in the Hexagon backend. That is why I made a binary. I do not know of other backends that can get me this flag.

tools/llvm-readobj/ELFDumper.cpp

47

Got it. Will use it

182

I need a way to get the name of the symbol table (both static and dynamic) when the section is present. Any ideas how do I do it?

[khemant]

tools/llvm-readobj/ELFDumper.cpp

182

Perhaps storing section name as a StringRef (if found in symbol table) is acceptable?

[khemant]

Incorporated the comments.

Removed storing the section header. Instead if section header present for DT_DYNSYM, save the name.

[• rafael]

LGTM with nits.

tools/llvm-readobj/ELFDumper.cpp

2549

Add a fallthrough comment.

2588

Start variable name with uppper case.

test/tools/llvm-readobj/gnu-symbols.test

+RUN: llvm-readobj -symbols %p/Inputs/symbols-proc-specific.elf-hexagon \
+RUN:  --elf-output-style=GNU | FileCheck %s -check-prefix ELF32
+RUN: llvm-readobj -symbols %p/Inputs/relocs.obj.elf-x86_64 --elf-output-style=GNU \
+RUN:   | FileCheck %s -check-prefix ELF64
+RUN: llvm-readobj -symbols %p/Inputs/gnuhash.so.elf-x86_64 --elf-output-style=GNU \
+RUN:   | FileCheck %s -check-prefix DYN
+
+ELF32: Symbol table '.symtab' contains 5 entries:
+ELF32-NEXT:    Num:    Value  Size Type    Bind   Vis      Ndx Name
+ELF32-NEXT:      0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+ELF32-NEXT:      1: 00000000     0 FILE    LOCAL  DEFAULT  ABS a.c
+ELF32-NEXT:      2: 00000000    20 FUNC    GLOBAL DEFAULT    2 main
+ELF32-NEXT:      3: 00000004     4 OBJECT  GLOBAL DEFAULT PRC[0xff03] x
+ELF32-NEXT:      4: 00000000     4 OBJECT  GLOBAL DEFAULT    3 y
+
+ELF64: Symbol table '.symtab' contains 6 entries:
+ELF64-NEXT:   Num:    Value          Size Type    Bind   Vis      Ndx Name
+ELF64-NEXT:     0:  0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+ELF64-NEXT:     1:  0000000000000000     0 SECTION LOCAL  DEFAULT    1 
+ELF64-NEXT:     2:  0000000000000000     0 SECTION LOCAL  DEFAULT    3 
+ELF64-NEXT:     3:  0000000000000000     0 SECTION LOCAL  DEFAULT    4 
+ELF64-NEXT:     4:  0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _GLOBAL_OFFSET_TABLE_
+ELF64-NEXT:     5:  0000000000000000     0 TLS     GLOBAL DEFAULT  UND sym
+
+DYN:Symbol table '.dynsym' contains 5 entries:
+DYN-NEXT:   Num:    Value          Size Type    Bind   Vis      Ndx Name
+DYN-NEXT:     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+DYN-NEXT:     1: 00000000000001b8     0 NOTYPE  GLOBAL DEFAULT    4 foo
+DYN-NEXT:     2: 0000000000200268     0 NOTYPE  GLOBAL DEFAULT    5 _edata
+DYN-NEXT:     3: 0000000000200268     0 NOTYPE  GLOBAL DEFAULT    5 _end
+DYN-NEXT:     4: 0000000000200268     0 NOTYPE  GLOBAL DEFAULT    5 __bss_start
+
+DYN: Symbol table '.symtab' contains 12 entries:
+DYN-NEXT:   Num:    Value          Size Type    Bind   Vis      Ndx Name
+DYN-NEXT:     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+DYN-NEXT:     1: 00000000000000e8     0 SECTION LOCAL  DEFAULT    1 
+DYN-NEXT:     2: 0000000000000120     0 SECTION LOCAL  DEFAULT    2 
+DYN-NEXT:     3: 0000000000000198     0 SECTION LOCAL  DEFAULT    3 
+DYN-NEXT:     4: 00000000000001b8     0 SECTION LOCAL  DEFAULT    4 
+DYN-NEXT:     5: 00000000002001b8     0 SECTION LOCAL  DEFAULT    5 
+DYN-NEXT:     6: 00000000002001b8     0 OBJECT  LOCAL  DEFAULT    5 _DYNAMIC
+DYN-NEXT:     7: 0000000000200268     0 OBJECT  LOCAL  DEFAULT    5 _GLOBAL_OFFSET_TABLE_
+DYN-NEXT:     8: 0000000000200268     0 NOTYPE  GLOBAL DEFAULT    5 __bss_start
+DYN-NEXT:     9: 00000000000001b8     0 NOTYPE  GLOBAL DEFAULT    4 foo
+DYN-NEXT:    10: 0000000000200268     0 NOTYPE  GLOBAL DEFAULT    5 _edata
+DYN-NEXT:    11: 0000000000200268     0 NOTYPE  GLOBAL DEFAULT    5 _end

tools/llvm-readobj/ELFDumper.cpp

#define LLVM_READOBJ_ENUM_CASE(ns, enum) \
   case ns::enum: return #enum;
 
 #define ENUM_ENT(enum, altName) \
   { #enum, altName, ELF::enum }
 
 #define ENUM_ENT_1(enum) \
   { #enum, #enum, ELF::enum }
 
 #define TYPEDEF_ELF_TYPES(ELFT)                                                \
   typedef ELFFile<ELFT> ELFO;                                                  \
   typedef typename ELFO::Elf_Shdr Elf_Shdr;                                    \
   typedef typename ELFO::Elf_Sym Elf_Sym;                                      \
   typedef typename ELFO::Elf_Dyn Elf_Dyn;                                      \
   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;                          \
   typedef typename ELFO::Elf_Rel Elf_Rel;                                      \
   typedef typename ELFO::Elf_Rela Elf_Rela;                                    \
   typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range;                        \
private:
   }
 
   DynRegionInfo createDRIFrom(const Elf_Shdr *S) {
     return checkDRI({Obj->base() + S->sh_offset, S->sh_size, S->sh_entsize});
   }
 
   void parseDynamicTable(ArrayRef<const Elf_Phdr *> LoadSegments);
 
-  void printSymbol(const Elf_Sym *Symbol, const Elf_Sym *FirstSym,
-                   StringRef StrTable, bool IsDynamic);
-
   void printValue(uint64_t Type, uint64_t Value);
 
   StringRef getDynamicString(uint64_t Offset) const;
   StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb,
                              bool &IsDefault) const;
   void LoadVersionMap() const;
   void LoadVersionNeeds(const Elf_Shdr *ec) const;
   void LoadVersionDefs(const Elf_Shdr *sec) const;
 
   const ELFO *Obj;
   DynRegionInfo DynRelRegion;
   DynRegionInfo DynRelaRegion;
   DynRegionInfo DynPLTRelRegion;
   DynRegionInfo DynSymRegion;
   DynRegionInfo DynamicTable;
   StringRef DynamicStringTable;
   StringRef SOName;
   const Elf_Hash *HashTable = nullptr;
   const Elf_GnuHash *GnuHashTable = nullptr;
   const Elf_Shdr *DotSymtabSec = nullptr;
+  StringRef DynSymtabName;
   ArrayRef<Elf_Word> ShndxTable;
 
   const Elf_Shdr *dot_gnu_version_sec = nullptr;   // .gnu.version
   const Elf_Shdr *dot_gnu_version_r_sec = nullptr; // .gnu.version_r
   const Elf_Shdr *dot_gnu_version_d_sec = nullptr; // .gnu.version_d
 
   // Records for each version index the corresponding Verdef or Vernaux entry.
   // This is filled the first time LoadVersionMap() is called.
public:
   Elf_Sym_Range dynamic_symbols() const {
     return DynSymRegion.getAsRange<Elf_Sym>();
   }
 
   Elf_Rel_Range dyn_rels() const;
   Elf_Rela_Range dyn_relas() const;
   std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable,
                                 bool IsDynamic) const;
+
+  void printSymbolsHelper(bool IsDynamic) const;
   const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
   ArrayRef<Elf_Word> getShndxTable() const { return ShndxTable; }
   StringRef getDynamicStringTable() const { return DynamicStringTable; }
   const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; }
   const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; }
   const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; }
 };
 
+template <class ELFT>
+void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const {
+  StringRef StrTable, SymtabName;
+  size_t Entries = 0;
+  Elf_Sym_Range Syms(nullptr, nullptr);
+  if (IsDynamic) {
+    StrTable = DynamicStringTable;
+    Syms = dynamic_symbols();
+    SymtabName = DynSymtabName;
+    if (DynSymRegion.Addr)
+      Entries = DynSymRegion.Size / DynSymRegion.EntSize;
+  } else {
+    if (!DotSymtabSec)
+      return;
+    StrTable = unwrapOrError(Obj->getStringTableForSymtab(*DotSymtabSec));
+    Syms = Obj->symbols(DotSymtabSec);
+    SymtabName = unwrapOrError(Obj->getSectionName(DotSymtabSec));
+    Entries = DotSymtabSec->getEntityCount();
+  }
+  if (Syms.begin() == Syms.end())
+    return;
+  ELFDumperStyle->printSymtabMessage(Obj, SymtabName, Entries);
+  for (const auto &Sym : Syms)
+    ELFDumperStyle->printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic);
+}
+
 template <typename ELFT> class DumpStyle {
 public:
-  virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
-  virtual ~DumpStyle() { }
+  using Elf_Shdr = typename ELFFile<ELFT>::Elf_Shdr;
+  using Elf_Sym =  typename ELFFile<ELFT>::Elf_Sym;
+
   DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {}
+  virtual ~DumpStyle() {}
+  virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0;
   virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSections(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymbols(const ELFFile<ELFT> *Obj) = 0;
   virtual void printDynamicSymbols(const ELFFile<ELFT> *Obj) = 0;
   virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
+  virtual void printSymtabMessage(const ELFFile<ELFT> *obj, StringRef Name,
+                                  size_t Offset) {
+    return;
+  }
+  virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
+                           const Elf_Sym *FirstSym, StringRef StrTable,
+                           bool IsDynamic) = 0;
   const ELFDumper<ELFT> *dumper() const { return Dumper; }
-
 private:
   const ELFDumper<ELFT> *Dumper;
 };
 
 template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> {
   formatted_raw_ostream OS;
 public:
   TYPEDEF_ELF_TYPES(ELFT)
   GNUStyle(StreamWriter &W, ELFDumper<ELFT> *Dumper)
       : DumpStyle<ELFT>(Dumper), OS(W.getOStream()) {}
   void printFileHeaders(const ELFO *Obj) override;
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
   void printSections(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj) override;
   void printDynamicSymbols(const ELFO *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
+  virtual void printSymtabMessage(const ELFO *Obj, StringRef Name,
+                                  size_t Offset) override;
 
 private:
   struct Field {
     StringRef Str;
     unsigned Column;
     Field(StringRef S, unsigned Col) : Str(S), Column(Col) {}
     Field(unsigned Col) : Str(""), Column(Col) {}
   };
 
   template <typename T, typename TEnum>
   std::string printEnum(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) {
     for (const auto &EnumItem : EnumValues)
       if (EnumItem.Value == Value)
         return EnumItem.AltName;
     return to_hexString(Value, false);
   }
+
   formatted_raw_ostream &printField(struct Field F) {
     if (F.Column != 0)
       OS.PadToColumn(F.Column);
     OS << F.Str;
     OS.flush();
     return OS;
   }
   void printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
                        const Elf_Rela &R, bool IsRela);
+  void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
+                   StringRef StrTable, bool IsDynamic) override;
+  std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol,
+                                  const Elf_Sym *FirstSym);
 };
 
 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
   LLVMStyle(StreamWriter &W, ELFDumper<ELFT> *Dumper)
       : DumpStyle<ELFT>(Dumper), W(W) {}
 
   void printFileHeaders(const ELFO *Obj) override;
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
   void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj);
   void printSections(const ELFO *Obj) override;
-  void printSymbolsHelper(const ELFO *Obj, bool IsDynamic);
   void printSymbols(const ELFO *Obj) override;
   void printDynamicSymbols(const ELFO *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
 
 private:
   void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
-  void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
-                   StringRef StrTable, bool IsDynamic);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
-
+  void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
+                   StringRef StrTable, bool IsDynamic) override;
   StreamWriter &W;
 };
 
 } // namespace
 
 namespace llvm {
 
 template <class ELFT>

 };
 
 static const EnumEntry<unsigned> ElfSymbolBindings[] = {
     {"Local",  "LOCAL",  ELF::STB_LOCAL},
     {"Global", "GLOBAL", ELF::STB_GLOBAL},
     {"Weak",   "WEAK",   ELF::STB_WEAK},
     {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}};
 
+static const EnumEntry<unsigned> ElfSymbolVisibilities[] = {
+    {"DEFAULT",   "DEFAULT",   ELF::STV_DEFAULT},
+    {"INTERNAL",  "INTERNAL",  ELF::STV_INTERNAL},
+    {"HIDDEN",    "HIDDEN",    ELF::STV_HIDDEN},
+    {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}};
+
 static const EnumEntry<unsigned> ElfSymbolTypes[] = {
-    {"None",      "NOTYPE",   ELF::STT_NOTYPE},
-    {"Object",    "OBJECT",   ELF::STT_OBJECT},
-    {"Function",  "FUNCTION", ELF::STT_FUNC},
-    {"Section",   "SECTION",  ELF::STT_SECTION},
-    {"File",      "FILE",     ELF::STT_FILE},
-    {"Common",    "COMMON",   ELF::STT_COMMON},
-    {"TLS",       "TLS",      ELF::STT_TLS},
-    {"GNU_IFunc", "IFUNC",    ELF::STT_GNU_IFUNC}};
+    {"None",      "NOTYPE",  ELF::STT_NOTYPE},
+    {"Object",    "OBJECT",  ELF::STT_OBJECT},
+    {"Function",  "FUNC",    ELF::STT_FUNC},
+    {"Section",   "SECTION", ELF::STT_SECTION},
+    {"File",      "FILE",    ELF::STT_FILE},
+    {"Common",    "COMMON",  ELF::STT_COMMON},
+    {"TLS",       "TLS",     ELF::STT_TLS},
+    {"GNU_IFunc", "IFUNC",   ELF::STT_GNU_IFUNC}};
 
 static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = {
   { "AMDGPU_HSA_KERNEL",            ELF::STT_AMDGPU_HSA_KERNEL },
   { "AMDGPU_HSA_INDIRECT_FUNCTION", ELF::STT_AMDGPU_HSA_INDIRECT_FUNCTION },
   { "AMDGPU_HSA_METADATA",          ELF::STT_AMDGPU_HSA_METADATA }
 };
 
 static const char *getElfSectionType(unsigned Arch, unsigned Type) {
case ELF::SHT_SYMTAB:
       if (DotSymtabSec != nullptr)
         reportError("Multilpe SHT_SYMTAB");
       DotSymtabSec = &Sec;
       break;
     case ELF::SHT_DYNSYM:
       if (DynSymRegion.Size)
         reportError("Multilpe SHT_DYNSYM");
       DynSymRegion = createDRIFrom(&Sec);
+      // This is only used (if Elf_Shdr present)for naming section in GNU style
+      DynSymtabName = unwrapOrError(Obj->getSectionName(&Sec));
       break;
     case ELF::SHT_SYMTAB_SHNDX:
       ShndxTable = unwrapOrError(Obj->getSHNDXTable(Sec));
       break;
     case ELF::SHT_GNU_versym:
       if (dot_gnu_version_sec != nullptr)
         reportError("Multiple SHT_GNU_versym");
       dot_gnu_version_sec = &Sec;
OS << "Key to Flags:\n"
      << "  W (write), A (alloc), X (execute), M (merge), S (strings), l "
         "(large)\n"
      << "  I (info), L (link order), G (group), T (TLS), E (exclude),\
  x (unknown)\n"
      << "  O (extra OS processing required) o (OS specific),\
  p (processor specific)\n";
 }
 
+template <class ELFT>
+void GNUStyle<ELFT>::printSymtabMessage(const ELFO *Obj, StringRef Name,
+                                        size_t Entries) {
+  if (Name.size())
+    OS << "\nSymbol table '" << Name << "' contains " << Entries
+       << " entries:\n";
+  else
+    OS << "\n Symbol table for image:\n";
+
+  if (ELFT::Is64Bits)
+    OS << "   Num:    Value          Size Type    Bind   Vis      Ndx Name\n";
+  else
+    OS << "   Num:    Value  Size Type    Bind   Vis      Ndx Name\n";
+}
+
+template <class ELFT>
+std::string GNUStyle<ELFT>::getSymbolSectionNdx(const ELFO *Obj,
+                                                const Elf_Sym *Symbol,
+                                                const Elf_Sym *FirstSym) {
+  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:
+    SectionIndex = Obj->getExtendedSymbolTableIndex(
+        Symbol, FirstSym, this->dumper()->getShndxTable());
+  default:
+    if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC)
+      return std::string("PRC[0x") +
+             to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
+    if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS)
+      return std::string("OS[0x") +
+             to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
+    if (SectionIndex >= ELF::SHN_LORESERVE &&
+        SectionIndex <= ELF::SHN_HIRESERVE)
+      return std::string("RSV[0x") +
+             to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
+    return to_string(format_decimal(SectionIndex, 3));
+  }
+}
+
+template <class ELFT>
+void GNUStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol,
+                                 const Elf_Sym *FirstSym, StringRef StrTable,
+                                 bool IsDynamic) {
+  static int Idx = 0;
+  static bool Dynamic = true;
+  size_t Width;
+
+  // If this function was called with a different value from IsDynamic
+  // from last call, happens when we move from dynamic to static symbol
+  // table, "Num" field should be reset.
+  if (!Dynamic != !IsDynamic) {
+    Idx = 0;
+    Dynamic = false;
+  }
+  std::string Num, Name, Value, Size, Binding, Type, Visibility, Section;
+  unsigned Bias = 0;
+  if (ELFT::Is64Bits) {
+    Bias = 8;
+    Width = 16;
+  } else {
+    Bias = 0;
+    Width = 8;
+  }
+  Field fields[8] = {0,         8,         17 + Bias, 23 + Bias,
+                     31 + Bias, 38 + Bias, 47 + Bias, 51 + Bias};
+  Num = to_string(format_decimal(Idx++, 6)) + ":";
+  Value = to_string(format_hex_no_prefix(Symbol->st_value, Width));
+  Size = to_string(format_decimal(Symbol->st_size, 5));
+  unsigned char SymbolType = Symbol->getType();
+  if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
+      SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
+    Type = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
+  else
+    Type = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
+  unsigned Vis = Symbol->getVisibility();
+  Binding = printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
+  Visibility = printEnum(Vis, makeArrayRef(ElfSymbolVisibilities));
+  Section = getSymbolSectionNdx(Obj, Symbol, FirstSym);
+  Name = this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
+  fields[0].Str = Num;
+  fields[1].Str = Value;
+  fields[2].Str = Size;
+  fields[3].Str = Type;
+  fields[4].Str = Binding;
+  fields[5].Str = Visibility;
+  fields[6].Str = Section;
+  fields[7].Str = Name;
+  for (auto &entry : fields)
+    printField(entry);
+  OS << "\n";
+}
+
 template <class ELFT> void GNUStyle<ELFT>::printSymbols(const ELFO *Obj) {
-  OS << "GNU style symbols not implemented!\n";
+  this->dumper()->printSymbolsHelper(true);
+  this->dumper()->printSymbolsHelper(false);
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
-  OS << "GNU style dynamic symbols not implemented!\n";
+  this->dumper()->printSymbolsHelper(true);
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
   OS << "GNU style dynamic relocations not implemented!\n";
 }
 
 template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
       SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
     W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes));
   else
     W.printEnum("Type", SymbolType, makeArrayRef(ElfSymbolTypes));
   W.printNumber("Other", Symbol->st_other);
   W.printHex("Section", SectionName, SectionIndex);
 }
 
-template <class ELFT>
-void LLVMStyle<ELFT>::printSymbolsHelper(const ELFO *Obj, bool IsDynamic) {
-  StringRef StrTable;
-  typename ELFO::Elf_Sym_Range Syms(nullptr, nullptr);
-  if (IsDynamic) {
-    StrTable = this->dumper()->getDynamicStringTable();
-    Syms = this->dumper()->dynamic_symbols();
-  } else {
-    if (!this->dumper()->getDotSymtabSec())
-      return;
-    const auto DotSymtabSec = this->dumper()->getDotSymtabSec();
-    StrTable = unwrapOrError(Obj->getStringTableForSymtab(*DotSymtabSec));
-    Syms = Obj->symbols(DotSymtabSec);
-  }
-  for (const Elf_Sym &Sym : Syms)
-    printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic);
-}
-
 template <class ELFT> void LLVMStyle<ELFT>::printSymbols(const ELFO *Obj) {
   ListScope Group(W, "Symbols");
-  printSymbolsHelper(Obj, false);
+  this->dumper()->printSymbolsHelper(false);
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
   ListScope Group(W, "DynamicSymbols");
-  printSymbolsHelper(Obj, true);
+  this->dumper()->printSymbolsHelper(true);
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
   const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion();
   const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
   const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
   if (DynRelRegion.Size && DynRelaRegion.Size)