[llvm-readelf] Stop suppressing static symbol output when --dyn-symbols is specified with --symbols

[jhenderson]

Summary

In rL287786, a bug was introduced into llvm-readelf where it didn't print the static symbol table if both --symbols and --dyn-symbols was specified, even if there was no dynamic symbol table. This is obviously incorrect.

This patch fixes this issue, by delegating the decision of what static and dynamic symbol tables should be printed to the final dumper, rather than trying to decide in the command-line option handling layer. The decision was made to follow the approach taken in this patch because the LLVM style dumper uses a different order to the original GNU style behaviour (and GNU readelf). Other approaches resulted in behaviour changes for other dumpers which felt wrong. In particular, I wanted to avoid changing the order of the output for --symbols --dyn-symbols for LLVM style, keep what is emitted by --symbols unchanged for all dumpers, and to avoid having different orders of .dynsym and .symtab dumping for GNU --symbols and --symbols --dyn-symbols.

[sbc100]

tools/llvm-readobj/COFFDumper.cpp

1397

Why not keep this as the default implementation rather than duplicating it 3 times? Of the 4 object formats it looks like only ELF needs different behaviour.

[jhenderson]

tools/llvm-readobj/COFFDumper.cpp

1397

The aim was to remove printDynamicSymbols completely from the public interface, but I guess I could put it as a private member in the interface instead.

[jhenderson]

Add default implementation of printSymbols, and rebase following landing of D56910/rL351789.

[rupprecht]

LGTM with just a question

tools/llvm-readobj/ELFDumper.cpp

3180–3181

IIUC, printSymbols(/*PrintSymbols=*/true, /*PrintDynamicSymbols=*/false) will still print dynamic symbols here, is that intentional? I think it is, based on the patch description of rL287786 -- if so, can you leave a comment somewhere, maybe also mention it in command line help string?

[grimar]

LGTM too, with Jordan's comment addressed.

[jhenderson]

tools/llvm-readobj/ELFDumper.cpp

3180–3181

Sure, I can add a comment. It is intentional, since GNU readelf prints both static and dynamic symbol tables in this case. Not sure I can easily mention it in the help string, since it only affects GNU output style and not LLVM style, but I'll see if I can come up with a way.

[jhenderson]

Add comment and update help text.

[grimar]

Still LGTM.

test/tools/llvm-readobj/demangle.test

 # LLVM-COMMON:        Addrsig [
 # LLVM-DEMANGLE-NEXT:   Sym: foo(char){{ }}
 # LLVM-DEMANGLE-NEXT:   Sym: blah(float){{ }}
 # LLVM-MANGLED-NEXT:    Sym: _Z3fooc{{ }}
 # LLVM-MANGLED-NEXT:    Sym: _Z4blahf{{ }}
 # LLVM-COMMON-NEXT:   ]
 
 ## Check GNU output style.
-## FIXME: The extra run for --symbols is because GNU mode only prints the dynamic symbols,
-## if --dyn-symbols is specified, even if --symbols is specified.
-# RUN: llvm-readelf --relocations --dyn-symbols --dyn-relocations \
+# RUN: llvm-readelf --symbols --relocations --dyn-symbols --dyn-relocations \
 # RUN:              --elf-section-groups --demangle %t.so > %t.gnu.long
-# RUN: llvm-readelf --symbols --demangle %t.so >> %t.gnu.long
-# RUN: llvm-readelf --relocations --dyn-symbols --dyn-relocations \
+# RUN: llvm-readelf --symbols --relocations --dyn-symbols --dyn-relocations \
 # RUN:              --elf-section-groups -C %t.so > %t.gnu.short
-# RUN: llvm-readelf --symbols -C %t.so >> %t.gnu.short
 # RUN: FileCheck %s --input-file %t.gnu.long --check-prefixes=GNU-COMMON,GNU-DEMANGLE
 # RUN: diff %t.gnu.long %t.gnu.short
 
 ## Check that default is no demangling.
-# RUN: llvm-readelf --relocations --dyn-symbols --dyn-relocations \
+# RUN: llvm-readelf --symbols --relocations --dyn-symbols --dyn-relocations \
 # RUN:              --elf-section-groups %t.so > %t.gnu.default
-# RUN: llvm-readelf --symbols %t.so >> %t.gnu.default
-# RUN: llvm-readelf --relocations --dyn-symbols --dyn-relocations \
+# RUN: llvm-readelf --symbols --relocations --dyn-symbols --dyn-relocations \
 # RUN:              --elf-section-groups --demangle=false %t.so > %t.gnu.nodemangle
-# RUN: llvm-readelf --symbols --demangle=false %t.so >> %t.gnu.nodemangle
 # RUN: FileCheck %s --input-file %t.gnu.default --check-prefixes=GNU-COMMON,GNU-MANGLED
 # RUN: diff %t.gnu.default %t.gnu.nodemangle
 
 # GNU-COMMON:        Relocation section '.rela.text.foo' at offset {{.*}} contains 1 entries:
 # GNU-COMMON-NEXT:     Offset Info Type Symbol's Value Symbol's Name + Addend
 # GNU-DEMANGLE-NEXT:     foo(char){{ }}
 # GNU-MANGLED-NEXT:      _Z3fooc{{ }}
 
 # GNU-COMMON:        'RELA' relocation section at offset {{.*}} contains 24 bytes:
 # GNU-COMMON-NEXT:     Offset Info Type Symbol's Value Symbol's Name + Addend
 # GNU-DEMANGLE-NEXT:     foo(int){{ }}
 # GNU-MANGLED-NEXT:      _Z3fooi{{ }}
 
 # GNU-COMMON:        Symbol table '.dynsym' contains 2 entries:
 # GNU-COMMON-NEXT:     Num: Value            Size Type   Bind  Vis     Ndx Name
 # GNU-COMMON-NEXT:       0: 0000000000000000    0 NOTYPE LOCAL DEFAULT UND
 # GNU-DEMANGLE-NEXT:       foo(int){{$}}
 # GNU-MANGLED-NEXT:        _Z3fooi{{$}}
 
-# GNU-COMMON:        COMDAT group section [{{.*}}] `.group'
-# GNU-DEMANGLE-SAME: [foo(char)]
-# GNU-MANGLED-SAME:  [_Z3fooc]
-
 # GNU-COMMON:        Symbol table '.symtab' contains 3 entries:
 # GNU-COMMON-NEXT:     Num: Value            Size Type   Bind  Vis     Ndx Name
 # GNU-COMMON-NEXT:       0: 0000000000000000    0 NOTYPE LOCAL DEFAULT UND
 # GNU-DEMANGLE-NEXT:       foo(char){{$}}
 # GNU-DEMANGLE-NEXT:       blah(float){{$}}
 # GNU-MANGLED-NEXT:        _Z3fooc{{$}}
 # GNU-MANGLED-NEXT:        _Z4blahf{{$}}
 
+# GNU-COMMON:        COMDAT group section [{{.*}}] `.group'
+# GNU-DEMANGLE-SAME: [foo(char)]
+# GNU-MANGLED-SAME:  [_Z3fooc]
+
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
   ## TODO:  Replace the raw section contents with more meaningful dynamic

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
-RUN: llvm-readobj -dyn-symbols %p/Inputs/dynamic-table-exe.x86 --elf-output-style=GNU \
-RUN:   | FileCheck %s -check-prefix HASH
+RUN: llvm-readobj -symbols -dyn-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: 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-NOT: .dynsym
+
 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
 
-HASH:     Symbol table of .hash for image:
-HASH-NEXT:   Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
-HASH-NEXT:     9   0: 00000000     0 FUNC    GLOBAL DEFAULT UND __gxx_personality_v0@CXXABI_1.3
-HASH-NEXT:    13   0: 00001b64     0 NOTYPE  GLOBAL DEFAULT ABS _edata{{$}}
-HASH-NEXT:     7   0: 00000000     0 FUNC    GLOBAL DEFAULT UND _ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1EPKcSt13_Ios_Openmode@GLIBCXX_3.4
-HASH-NEXT:     2   0: 00000000     0 NOTYPE  WEAK   DEFAULT UND _Jv_RegisterClasses{{$}}
-HASH-NEXT:     1   0: 00000000     0 NOTYPE  WEAK   DEFAULT UND __gmon_start__{{$}}
-HASH-NEXT:    16   1: 00000850    81 FUNC    GLOBAL DEFAULT  14 main{{$}}
-HASH-NEXT:    10   1: 00000000     0 FUNC    GLOBAL DEFAULT UND _Unwind_Resume@GCC_3.0
-HASH-NEXT:     8   1: 00000000     0 FUNC    GLOBAL DEFAULT UND puts@GLIBC_2.0
-HASH-NEXT:    12   1: 00001b68     0 NOTYPE  GLOBAL DEFAULT ABS _end{{$}}
-HASH-NEXT:     6   1: 00000000     0 FUNC    GLOBAL DEFAULT UND _ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev@GLIBCXX_3.4
-HASH-NEXT:     5   1: 00000000     0 NOTYPE  WEAK   DEFAULT UND _ITM_registerTMCloneTable{{$}}
-HASH-NEXT:     4   1: 00000000     0 NOTYPE  WEAK   DEFAULT UND _ITM_deregisterTMCloneTable{{$}}
-HASH-NEXT:     3   1: 00000000     0 FUNC    GLOBAL DEFAULT UND __libc_start_main@GLIBC_2.0
-HASH-NEXT:    11   2: 00000000     0 FUNC    WEAK   DEFAULT UND __cxa_finalize@GLIBC_2.1.3
-HASH-NEXT:    15   2: 00001b64     0 NOTYPE  GLOBAL DEFAULT ABS __bss_start{{$}}
-HASH-NEXT:    14   2: 0000093c     4 OBJECT  GLOBAL DEFAULT  16 _IO_stdin_used{{$}}
-HASH:     Symbol table of .gnu.hash for image:
-HASH-NEXT:   Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
-HASH-NEXT:    12   0: 00001b68     0 NOTYPE  GLOBAL DEFAULT ABS _end{{$}}
-HASH-NEXT:    13   0: 00001b64     0 NOTYPE  GLOBAL DEFAULT ABS _edata{{$}}
-HASH-NEXT:    14   1: 0000093c     4 OBJECT  GLOBAL DEFAULT  16 _IO_stdin_used{{$}}
-HASH-NEXT:    15   1: 00001b64     0 NOTYPE  GLOBAL DEFAULT ABS __bss_start{{$}}
-HASH-NEXT:    16   1: 00000850    81 FUNC    GLOBAL DEFAULT  14 main{{$}}
+DYN-NOT: .dynsym

tools/llvm-readobj/COFFDumper.cpp

 public:
   friend class COFFObjectDumpDelegate;
   COFFDumper(const llvm::object::COFFObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj), Writer(Writer), Types(100) {}
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
-  void printSymbols() override;
-  void printDynamicSymbols() override;
+  void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printUnwindInfo() override;
 
   void printNeededLibraries() override;
 
   void printCOFFImports() override;
   void printCOFFExports() override;
   void printCOFFDirectives() override;
   void printCOFFBaseReloc() override;
   void printCOFFDebugDirectory() override;
   void printCOFFResources() override;
   void printCOFFLoadConfig() override;
   void printCodeViewDebugInfo() override;
   void
   mergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
                      llvm::codeview::MergingTypeTableBuilder &CVTypes) override;
   void printStackMap() const override;
   void printAddrsig() override;
 private:
+  void printSymbols();
+  void printDynamicSymbols();
   void printSymbol(const SymbolRef &Sym);
   void printRelocation(const SectionRef &Section, const RelocationRef &Reloc,
                        uint64_t Bias = 0);
   void printDataDirectory(uint32_t Index, const std::string &FieldName);
 
   void printDOSHeader(const dos_header *DH);
   template <class PEHeader> void printPEHeader(const PEHeader *Hdr);
   void printBaseOfDataField(const pe32_header *Hdr);
if (opts::ExpandRelocs) {
     OS << W.hex(Offset)
        << " " << RelocName
        << " " << (SymbolName.empty() ? "-" : SymbolName)
        << " (" << SymbolIndex << ")"
        << "\n";
   }
 }
 
+void COFFDumper::printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) {
+  if (PrintSymbols)
+    printSymbols();
+  if (PrintDynamicSymbols)
+    printDynamicSymbols();
+}
+
 void COFFDumper::printSymbols() {
   ListScope Group(W, "Symbols");
 
   for (const SymbolRef &Symbol : Obj->symbols())
     printSymbol(Symbol);
 }
 
 void COFFDumper::printDynamicSymbols() { ListScope Group(W, "DynamicSymbols"); }

tools/llvm-readobj/ELFDumper.cpp

 class ELFDumper : public ObjDumper {
 public:
   ELFDumper(const object::ELFObjectFile<ELFT> *ObjF, ScopedPrinter &Writer);
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
   void printDynamicRelocations() override;
-  void printSymbols() override;
-  void printDynamicSymbols() override;
+  void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printUnwindInfo() override;
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
   void printProgramHeaders() override;
   void printHashTable() override;
   void printGnuHashTable() override;
   void printLoadName() override;
public:
 
   DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {}
   virtual ~DumpStyle() = default;
 
   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 printSectionHeaders(const ELFFile<ELFT> *Obj) = 0;
-  virtual void printSymbols(const ELFFile<ELFT> *Obj) = 0;
-  virtual void printDynamicSymbols(const ELFFile<ELFT> *Obj) = 0;
+  virtual void printSymbols(const ELFFile<ELFT> *Obj, bool PrintSymbols,
+                            bool PrintDynamicSymbols) = 0;
   virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymtabMessage(const ELFFile<ELFT> *obj, StringRef Name,
                                   size_t Offset) {}
   virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
                            const Elf_Sym *FirstSym, StringRef StrTable,
                            bool IsDynamic) = 0;
   virtual void printProgramHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printHashHistogram(const ELFFile<ELFT> *Obj) = 0;
public:
 
   GNUStyle(ScopedPrinter &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 printSectionHeaders(const ELFO *Obj) override;
-  void printSymbols(const ELFO *Obj) override;
-  void printDynamicSymbols(const ELFO *Obj) override;
+  void printSymbols(const ELFO *Obj, bool PrintSymbols,
+                    bool PrintDynamicSymbols) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printSymtabMessage(const ELFO *Obj, StringRef Name,
                           size_t Offset) override;
   void printProgramHeaders(const ELFO *Obj) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
formatted_raw_ostream &printField(struct Field F) {
     OS.flush();
     return OS;
   }
   void printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, uint32_t Sym,
                          StringRef StrTable, uint32_t Bucket);
   void printRelocHeader(unsigned SType);
   void printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
                        const Elf_Rela &R, bool IsRela);
+  void printDynamicSymbols(const ELFO *Obj);
   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);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela);
   bool checkTLSSections(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
 };
 
 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
 
   LLVMStyle(ScopedPrinter &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 printSectionHeaders(const ELFO *Obj) override;
-  void printSymbols(const ELFO *Obj) override;
-  void printDynamicSymbols(const ELFO *Obj) override;
+  void printSymbols(const ELFO *Obj, bool PrintSymbols,
+                    bool PrintDynamicSymbols) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printProgramHeaders(const ELFO *Obj) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
 
 private:
   void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
+  void printSymbols(const ELFO *Obj);
+  void printDynamicSymbols(const ELFO *Obj);
   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
                    StringRef StrTable, bool IsDynamic) override;
 
   ScopedPrinter &W;
 };
 
 } // end anonymous namespace
 

 template <class ELFT> void ELFDumper<ELFT>::printProgramHeaders() {
   ELFDumperStyle->printProgramHeaders(ObjF->getELFFile());
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() {
   ELFDumperStyle->printDynamicRelocations(ObjF->getELFFile());
 }
 
-template<class ELFT>
-void ELFDumper<ELFT>::printSymbols() {
-  ELFDumperStyle->printSymbols(ObjF->getELFFile());
-}
-
-template<class ELFT>
-void ELFDumper<ELFT>::printDynamicSymbols() {
-  ELFDumperStyle->printDynamicSymbols(ObjF->getELFFile());
+template <class ELFT>
+void ELFDumper<ELFT>::printSymbols(bool PrintSymbols,
+                                   bool PrintDynamicSymbols) {
+  ELFDumperStyle->printSymbols(ObjF->getELFFile(), PrintSymbols,
+                               PrintDynamicSymbols);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printHashHistogram() {
   ELFDumperStyle->printHashHistogram(ObjF->getELFFile());
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printCGProfile() {
   ELFDumperStyle->printCGProfile(ObjF->getELFFile());
void GNUStyle<ELFT>::printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym,
   Fields[6].Str = Visibility;
   Fields[7].Str = Section;
   Fields[8].Str = Name;
   for (auto &Entry : Fields)
     printField(Entry);
   OS << "\n";
 }
 
-template <class ELFT> void GNUStyle<ELFT>::printSymbols(const ELFO *Obj) {
-  if (opts::DynamicSymbols)
+template <class ELFT>
+void GNUStyle<ELFT>::printSymbols(const ELFO *Obj, bool PrintSymbols,
+                                  bool PrintDynamicSymbols) {
+  if (!PrintSymbols && !PrintDynamicSymbols)
     return;
   this->dumper()->printSymbolsHelper(true);
+  if (PrintSymbols)
     this->dumper()->printSymbolsHelper(false);
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
   if (this->dumper()->getDynamicStringTable().empty())
     return;
   auto StringTable = this->dumper()->getDynamicStringTable();
   auto DynSyms = this->dumper()->dynamic_symbols();
   auto GnuHash = this->dumper()->getGnuHashTable();
   auto SysVHash = this->dumper()->getHashTable();
 
   // If no hash or .gnu.hash found, try using symbol table
   if (GnuHash == nullptr && SysVHash == nullptr)
if (Obj->getHeader()->e_machine == EM_MIPS) {
                              std::begin(ElfMipsSymOtherFlags),
                              std::end(ElfMipsSymOtherFlags));
     }
     W.printFlags("Other", Symbol->st_other, makeArrayRef(SymOtherFlags), 0x3u);
   }
   W.printHex("Section", SectionName, SectionIndex);
 }
 
+template <class ELFT>
+void LLVMStyle<ELFT>::printSymbols(const ELFO *Obj, bool PrintSymbols,
+                                   bool PrintDynamicSymbols) {
+  if (PrintSymbols)
+    printSymbols(Obj);
+  if (PrintDynamicSymbols)
+    printDynamicSymbols(Obj);
+}
+
 template <class ELFT> void LLVMStyle<ELFT>::printSymbols(const ELFO *Obj) {
   ListScope Group(W, "Symbols");
   this->dumper()->printSymbolsHelper(false);
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
   ListScope Group(W, "DynamicSymbols");

tools/llvm-readobj/MachODumper.cpp

 class MachODumper : public ObjDumper {
 public:
   MachODumper(const MachOObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj) {}
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
-  void printSymbols() override;
-  void printDynamicSymbols() override;
+  void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printUnwindInfo() override;
   void printStackMap() const override;
 
   void printNeededLibraries() override;
 
   // MachO-specific.
   void printMachODataInCode() override;
   void printMachOVersionMin() override;
   void printMachODysymtab() override;
   void printMachOSegment() override;
   void printMachOIndirectSymbols() override;
   void printMachOLinkerOptions () override;
 
 private:
   template<class MachHeader>
   void printFileHeaders(const MachHeader &Header);
 
+  void printSymbols();
+  void printDynamicSymbols();
   void printSymbol(const SymbolRef &Symbol);
 
   void printRelocation(const RelocationRef &Reloc);
 
   void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);
 
   void printSectionHeaders(const MachOObjectFile *Obj);
 
else
       OS << " " << Obj->getPlainRelocationExternal(RE);
     OS << " " << RelocName
        << " " << IsScattered
        << " " << SymbolNameOrOffset
        << "\n";
   }
 }
 
+void MachODumper::printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) {
+  if (PrintSymbols)
+    printSymbols();
+  if (PrintDynamicSymbols)
+    printDynamicSymbols();
+}
+
 void MachODumper::printSymbols() {
   ListScope Group(W, "Symbols");
 
   for (const SymbolRef &Symbol : Obj->symbols()) {
     printSymbol(Symbol);
   }
 }
 

tools/llvm-readobj/ObjDumper.h

 class ObjDumper {
 public:
   ObjDumper(ScopedPrinter &Writer);
   virtual ~ObjDumper();
 
   virtual void printFileHeaders() = 0;
   virtual void printSectionHeaders() = 0;
   virtual void printRelocations() = 0;
-  virtual void printSymbols() = 0;
-  virtual void printDynamicSymbols() = 0;
+  virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) = 0;
   virtual void printUnwindInfo() = 0;
 
   // Only implemented for ELF at this time.
   virtual void printDynamicRelocations() { }
   virtual void printDynamicTable() { }
   virtual void printNeededLibraries() { }
   virtual void printProgramHeaders() { }
   virtual void printSectionAsHex(StringRef SectionName) {}

tools/llvm-readobj/WasmDumper.cpp

 class WasmDumper : public ObjDumper {
 public:
   WasmDumper(const WasmObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj) {}
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
-  void printSymbols() override;
-  void printDynamicSymbols() override { llvm_unreachable("unimplemented"); }
+  void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printUnwindInfo() override { llvm_unreachable("unimplemented"); }
   void printStackMap() const override { llvm_unreachable("unimplemented"); }
 
 protected:
+  void printSymbols();
   void printSymbol(const SymbolRef &Sym);
   void printRelocation(const SectionRef &Section, const RelocationRef &Reloc);
 
 private:
   const WasmObjectFile *Obj;
 };
 
 void WasmDumper::printFileHeaders() {
for (const SectionRef &Section : Obj->sections()) {
 
     if (PrintedGroup) {
       W.unindent();
       W.startLine() << "}\n";
     }
   }
 }
 
+void WasmDumper::printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) {
+  if (PrintSymbols)
+    printSymbols();
+  if (PrintDynamicSymbols)
+    llvm_unreachable("unimplemented");
+}
+
 void WasmDumper::printSymbols() {
   ListScope Group(W, "Symbols");
 
   for (const SymbolRef &Symbol : Obj->symbols())
     printSymbol(Symbol);
 }
 
 void WasmDumper::printSectionHeaders() {

tools/llvm-readobj/llvm-readobj.h

namespace llvm {
   bool relocAddressLess(object::RelocationRef A,
                         object::RelocationRef B);
 } // namespace llvm
 
 namespace opts {
   extern llvm::cl::opt<bool> SectionRelocations;
   extern llvm::cl::opt<bool> SectionSymbols;
   extern llvm::cl::opt<bool> SectionData;
-  extern llvm::cl::opt<bool> DynamicSymbols;
   extern llvm::cl::opt<bool> ExpandRelocs;
   extern llvm::cl::opt<bool> RawRelr;
   extern llvm::cl::opt<bool> CodeViewSubsectionBytes;
   extern llvm::cl::opt<bool> Demangle;
   enum OutputStyleTy { LLVM, GNU };
   extern llvm::cl::opt<OutputStyleTy> Output;
 } // namespace opts
 
 #define LLVM_READOBJ_ENUM_ENT(ns, enum) \
   { #enum, ns::enum }
 
 #define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \
   { #enum, std::underlying_type<enum_class>::type(enum_class::enum) }
 
 #endif

tools/llvm-readobj/llvm-readobj.cpp

static void dumpObject(const ObjectFile *Obj, ScopedPrinter &Writer) {
   if (opts::FileHeaders)
     Dumper->printFileHeaders();
   if (opts::SectionHeaders)
     Dumper->printSectionHeaders();
   if (opts::Relocations)
     Dumper->printRelocations();
   if (opts::DynRelocs)
     Dumper->printDynamicRelocations();
-  if (opts::Symbols)
-    Dumper->printSymbols();
-  if (opts::DynamicSymbols)
-    Dumper->printDynamicSymbols();
+  if (opts::Symbols || opts::DynamicSymbols)
+    Dumper->printSymbols(opts::Symbols, opts::DynamicSymbols);
   if (opts::UnwindInfo)
     Dumper->printUnwindInfo();
   if (opts::DynamicTable)
     Dumper->printDynamicTable();
   if (opts::NeededLibraries)
     Dumper->printNeededLibraries();
   if (opts::ProgramHeaders)
     Dumper->printProgramHeaders();