[llvm-objdump] Teach `llvm-objdump` dump dynamic symbols.

[Higuoxing]

Summary

This patch is to teach llvm-objdump dump dynamic symbols (-T and --dynamic-syms). Currently, this patch is not fully compatible with gnu-objdump, but I would like to continue working on this in next few patches. It has two issues.

1. Some symbols shouldn't be marked as global(g). (-t/--syms has same issue as well) (Fixed by D75659)
2. gnu-objdump can dump version information and *dynamically* insert before symbol name field. (I haven't been able to figure out how it works)

objdump -T a.out gives:

DYNAMIC SYMBOL TABLE:
0000000000000000  w   D  *UND*  0000000000000000              _ITM_deregisterTMCloneTable
0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 printf
0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 __libc_start_main
0000000000000000  w   D  *UND*  0000000000000000              __gmon_start__
0000000000000000  w   D  *UND*  0000000000000000              _ITM_registerTMCloneTable
0000000000000000  w   DF *UND*  0000000000000000  GLIBC_2.2.5 __cxa_finalize

llvm-objdump -T a.out gives:

DYNAMIC SYMBOL TABLE:
0000000000000000  w   D  *UND*  0000000000000000 _ITM_deregisterTMCloneTable
0000000000000000 g    DF *UND*  0000000000000000 printf
0000000000000000 g    DF *UND*  0000000000000000 __libc_start_main
0000000000000000  w   D  *UND*  0000000000000000 __gmon_start__
0000000000000000  w   D  *UND*  0000000000000000 _ITM_registerTMCloneTable
0000000000000000  w   DF *UND*  0000000000000000 __cxa_finalize

[MaskRay]

We should reuse printSymbolTable for DYNAMIC SYMBOL TABLE:. D75659 should have fixed the g ll problems.

[Higuoxing]

Addressed @MaskRay 's comment.

• Reuse printSymbolTable function.

[MaskRay]

llvm/test/tools/llvm-objdump/elf-dynamic-symbol.test

1 ↗

(On Diff #248928)

My idea is that after we have the binary format specific directory test/tools/llvm-objdump/ELF/. We can move tests under it.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1930–1931

For .dynsym, char Debug should use 'D' instead of ' '

[Higuoxing]

Addressed @MaskRay 's comments.

• Dump dynamic symbol as 'D'
• Move tests to ELF/ (Shall I wait until D75798 lands?)

[Higuoxing]

Rebase & Update doc.

[grimar]

llvm/test/tools/llvm-objdump/ELF/elf-dynamic-symbol.test

54 ↗

(On Diff #248938)

Add an empty line before --- !ELF please.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1854–1855

DumpDynamicSymbol -> IsDynamic (Used commonly ind shorter).

1856

It is a bit strange when the code assigns a value to a variable and then reassign it right below.

I.e. why not do something like below?

  if (const COFFObjectFile *Coff = dyn_cast<const COFFObjectFile>(O)) {
    outs() << "SYMBOL TABLE:\n";
    printCOFFSymbolTable(Coff);
    return;
  }
.......
llvm::basic_symbol_iterator I, E;
if (!DumpDynamicSymbol) {
   I = O->symbol_begin();
   E = O->symbol_end();
   outs() << "SYMBOL TABLE:\n";
...
} else {
   I = ELF->getDynamicSymbolIterators().begin();
   E = ELF->getDynamicSymbolIterators().end();
   outs() << "DYNAMIC SYMBOL TABLE:\n"
...
}
...

1865

This error is untested. Also, perhaps you could use reportWarning instead.
(Does not seem we want to stop dump here).

1869

dyn_cast will return nullptr when an object is not ELF. Since you know it is always an ELF object at this point, you should use cast.

1873

Non dynamic symbol table also has a null symbol. Why we do not need it for !DumpDynamicSymbol? (Or: why do we need it here?).

1934

It seems that when we are consistent with the code around, it looks a bit simpler:

char Debug = ' ';
if (DumpDynamicSymbol)
 Debug = 'D';
else if (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
 Debug = 'd';

2252

StringRef() -> /*ArchitectureName=*/=""

[jhenderson]

Some thoughts on this, which don't need to be addressed in this patch, but should be in follow-on ones if necessary:

1. Does GNU objdump use the section name or section type to identify the section? What happens if there are multiple SHT_DYNSYM sections? What about if ".dynsym" is not SHT_DYNSYM?
2. What should we do if the section header table is missing (e.g. due to llvm-objcopy --strip-sections)? See llvm-readobj bugs https://bugs.llvm.org/show_bug.cgi?id=45089 and https://bugs.llvm.org/show_bug.cgi?id=45090 for suggestions.

llvm/test/tools/llvm-objdump/ELF/elf-dynamic-symbol.test

1 ↗

(On Diff #249293)

No need for "elf-" in the test file name.

4–5 ↗

(On Diff #249293)

It would be a good idea to use --strict-whitespace and --match-full-lines in the FileCheck calls.

9–12 ↗

(On Diff #249293)

Here and below, remove the excessive spacing, so that the values line up, but with only a single space between Machine: and its value.

14–16 ↗

(On Diff #249293)

Could you line up blocks like this so that the values all line up:

- Name: .data
  Type:  SHT_PROGBITS
  Flags:  [ SHF_ALLOC, SHF_WRITE ]

18–21 ↗

(On Diff #249293)

- Name:    localsym
  Type:    STT_OBJECT
  Section: .data
  Binding: STB_LOCAL

Same below

51 ↗

(On Diff #249293)

I think there are a few different cases here, and I think you need to test them all:

1. No dynamic symbol table at all (i.e. no SHT_DYNSYM section).
2. A truly empty .dynsym section (size == 0)
3. A logically empty .dynsym section (just has the 0-index symbol).

I think this is testing the first one, but I'm not sure.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1854–1855

DumpDynamicSymbol -> DumpDynamic

I think that's sufficient, and also it's the symbol table, not a single symbol.

[Higuoxing]

Addressed @grimar 's comments

• Change DumpDynamicSymbol to DumpDynamic
• I have to use this pattern, due to there doesn't exist a default constructor for basic_symbol_iterator

auto I = O->symbol_begin();
...
if (DumpDynamic) {
  I = ELF->dynamic_symbol_begin();
  ...
}

• Change WithColor::error() to reportWarning()
• Change dyn_cast to cast on an ELF object.
• Modify dynamic_symbol_begin() according to symbol_begin() method.

Addressed @jhenderson 's comments

• Change test file's name
• I didn't apply --strict-whitespace to FileCheck, because there are tabs preventing me doing so (Shall we look into this later?).
• Rearrage yaml file blocks to line up values.
• Add more tests for ELF files with truely empty .dynsym section, logically empty .dynsym section.

[grimar]

llvm/include/llvm/Object/ELFObjectFile.h

1024 ↗

(On Diff #249846)

"Index 0 in any symbol table is used to represent undefined symbols.
This first entry in a symbol table is always completely zeroed." (Oracle ELF spec)
A null symbol is also a symbol, so it is not a correct change.

The change you want to do should not be here, in a higher level library.

Also, did you run llvm tests? I'd expect them should fail with such change.

[grimar]

llvm/tools/llvm-objdump/llvm-objdump.cpp

1872

I wonder if we want to have it here or move it above, out of scope of this if (!DumpDynamic).
Probably we do not want to change the behavior of COFF?

1885

In D75756#1918796, @Higuoxing wrote:

Addressed @grimar 's comments

• I have to use this pattern, due to there doesn't exist a default constructor for basic_symbol_iterator

auto I = O->symbol_begin();
...
if (DumpDynamic) {
  I = ELF->dynamic_symbol_begin();
  ...
}

I think lets create a printSymbol(SymbolRef Sym, ...) helper. It should help.

[Higuoxing]

llvm/include/llvm/Object/ELFObjectFile.h

1024 ↗

(On Diff #249846)

I've run tests locally, and no failure is observed. I also checked function call (getDynamicSymbolIterators()). link

• llvm/tools/llvm-nm/llvm-nm.cpp: There's an attempt to omit NULL symbol in D62148. @MaskRay helps change the behavior of symbol_begin() in D62296. I think dynamic_symbol_begin() should be changed as well.
• For calls in lib/Object/SymbolSize.cpp, I think this is similar to https://reviews.llvm.org/D62296#1514082

[Higuoxing]

llvm/include/llvm/Object/ELFObjectFile.h

1024 ↗

(On Diff #249846)

I have opened a new revision for this change in D76081 : )

[jhenderson]

In D75756#1918796, @Higuoxing wrote:

• I didn't apply --strict-whitespace to FileCheck, because there are tabs preventing me doing so (Shall we look into this later?).

Does GNU objdump use hard tabs too? How practical would it be to write hard tabs in the test check? I believe they should be respected with --strict-whitespace (although you'll need to remove the extra space between the CHECKs' ':' and the start of the string to check).

llvm/test/tools/llvm-objdump/ELF/dynamic-symbol.test

12 ↗

(On Diff #249846)

You need to add a CHECK-EMPTY or similar the line below to show that there are no more symbols printed.

49 ↗

(On Diff #249846)

You don't need the double blank line. It's clear enough that the next bit is a new case with a single one.

Same goes below.

56 ↗

(On Diff #249846)

You need to add a CHECK-EMPTY or similar the line below to show that there are no symbols printed.

64–67 ↗

(On Diff #249846)

You don't need the .data section here or in any of the test cases below..

70 ↗

(On Diff #249846)

Put the brackets before the full stop. Also "have" -> "has".

74 ↗

(On Diff #249846)

I'd change the check prefix to "ONLY-NULL"

You need to add a CHECK-EMPTY or similar the line below to show that there are no symbols printed.

88 ↗

(On Diff #249846)

Same comment as above re. full stop position. Also truely -> truly.

92 ↗

(On Diff #249846)

TRUELY_EMPTY to simply EMPTY is fine.

You need to add a CHECK-EMPTY or similar the line below to show that there are no symbols printed.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1879

Still need a test for this. Also, use lower-case first letter for diagnostics, and no trailing full stop. Finally, do you need the '\n'? I'd expect reportWarning to do that itself.

1971

Unrelated formatting change should not be included.

[Higuoxing]

Addressed comments.

• Move printCOFFSymbol() out of if (!DumpDynamic) scope.
• > @grimar: I think lets create a printSymbol(SymbolRef Sym, ...) helper. It should help.
  
  Can we do this in next few patches? It seems that we have to resolve some continue; and break; statements.

• Correct usage of reportWarning() (e.g. lower-case first letter, remove '\n' and trailing full stop.)
• Add test for reportWarning()
• Add --strict-whitespace option for FileCheck
• Add CHECK-EMPTY to ensure no more symbols are printed.
• Remove useless Section: .data field in YAML.
• Correct some checking prefix (e.g. NOT-NULL, EMPTY).

[Higuoxing]

Break long # RUN: lines.

[grimar]

Can we do this in next few patches? It seems that we have to resolve some continue; and break; statements.

I think we should commit the nice code from start. If we can't because of a minor refactoring needed, this refactoring should be done first.

[Higuoxing]

Fix lint warning.

[Higuoxing]

In D75756#1930888, @grimar wrote:

Can we do this in next few patches? It seems that we have to resolve some continue; and break; statements.

I think we should commit the nice code from start. If we can't because of a minor refactoring needed, this refactoring should be done first.

Sure. Let me have a try, thanks a lot.

[grimar]

In D75756#1930897, @Higuoxing wrote:

In D75756#1930888, @grimar wrote:

Can we do this in next few patches? It seems that we have to resolve some continue; and break; statements.

I think we should commit the nice code from start. If we can't because of a minor refactoring needed, this refactoring should be done first.

Sure. Let me have a try, thanks a lot.

I think you can just do it in this patch: separating the code to a helper function is a normal common thing that is often done.
Probably no need to create a separate revision, since this refactoring is needed for changes you do right here.

[Higuoxing]

Add printSymbol() helper function.

[Higuoxing]

Remove irrevelent format change.

[Higuoxing]

.

[grimar]

llvm/tools/llvm-objdump/llvm-objdump.cpp

1921–1972

The reason to create a printSymbol helper was to address my previous comments.

Now, when you have it you should be able to write the code above cleaner.
Something like:

if (!DumpDynamic) {
  outs() << "SYMBOL TABLE:\n";
  for (auto I = O->symbol_begin(), E = O->symbol_end(); I != E; ++I)
    printSymbol(O, *I, FileName, ArchiveName, ArchitectureName, DumpDynamic)l
  return;
}

outs() << "DYNAMIC SYMBOL TABLE:\n";
...
<the similar code for dynamic>

[Higuoxing]

Great! I didn't get it just now 🤣

Addressed @grimar 's comment.

[grimar]

I have only 2 minor nits and a question to others, otherwise this looks good, thanks!
So I've accepted, but let's wait for one more opinion.

llvm/test/tools/llvm-objdump/X86/elf-dynamic-symbols.test

87

DynamicSymbols: [] is a bit more commonly used in tests for cases when you want to have a .dynsym with a zero symbol only.

108

Size: 0 probably better reflects what you want to achieve.

119

I am not sure about this part.
I am not sure it should be in this test, because it called "elf-*".
And I am concerned that precomiled objects are used a bit, though we could use
a trivial YAMLs instead (anyways the general direction is to remove all committed precompiled objects,
so at least it worth to stop adding new places I think).

At the same time I wonder if we might want to add a test case like all-targets-unimlemented-features.test or alike and put all
temporarily checks like this there.

Or perhaps we can just go with this piece for now and remove it in a follow-up (since you do not add new binaries, I think it is OK)

2All: What do others think?

[grimar]

llvm/test/tools/llvm-objdump/X86/elf-dynamic-symbols.test

119

If we decide to go with this piece for now, please add empty line after "RUN:"

[Higuoxing]

Fix nits.

Thanks a lot for taking time review.

[jhenderson]

llvm/docs/CommandGuide/llvm-objdump.rst

88–91

Lexicographically, 'T' is before 't', so this should probably be before the -t option.

llvm/test/tools/llvm-objdump/X86/elf-dynamic-symbols.test

119

I'd move these into unimplemented-features.test probably. I'd also only have one version for each file format (i.e. just --dynamic-syms, not -T as well). I suspect there should be more versions of this though for other formats (I'm thinking XCOFF off the top of my head, but there may be others). As for using pre-compiled binaries, my preference is to not use them if we can avoid it. yaml2obj support exists for COFF and Mach-O at least, so those can be added even if other formats require existing prebuilt binaries.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1874

This should probably be changed to say "this operation is not currently supported for this file format", removing the "ELF" reference, since the message will need to be updated every time support is added for a new file format.

1885–1887

As this function is now unindented, you need to run clang-format on the whole function. Sorry, if I incorrectly commented incorrectly on something being an unrelated formatting before! Phabricator doesn't show the indentation change as an actual change.

[Higuoxing]

llvm/docs/CommandGuide/llvm-objdump.rst

88–91

It seems that -r, --reloc is before -R, --dynamic-reloc, -d, --disassemble is before -D, --disassemble-all. I'm a little confused .. 🤣

llvm/tools/llvm-objdump/llvm-objdump.cpp

1885–1887

Never mind, I could format this now : )
I was afraid of unwanted format bringing troubles for reviewing.

[jhenderson]

llvm/docs/CommandGuide/llvm-objdump.rst

88–91

Oh okay, leave it as is then. Sorry!

[Higuoxing]

• Move unimplemented features test to unimplemented-features.test.
• Improve warning message.
• Format codes.

[Higuoxing]

Format YAML.

[Higuoxing]

Rename isSTAB to IsSTAB, attampt to make clang-tidy check happy (Fix builds).

[Higuoxing]

• Use [[FILE]] to check file name.

[Higuoxing]

Rebase.

[jhenderson]

llvm/test/tools/llvm-objdump/unimplemented-features.test

1 ↗

(On Diff #252226)

I'd change this to "Test dumping dynamic symbols reports a warning if the operation is unsupported for the file format."

3 ↗

(On Diff #252226)

'##' here and below for all comments.

14 ↗

(On Diff #252226)

No need for the cp. It's okay to reference the binary directly in the llvm-objdump call here.

[Higuoxing]

llvm/test/tools/llvm-objdump/unimplemented-features.test

14 ↗

(On Diff #252226)

I was using cp to shorten the file name as %t3, which is intended to replace [[FILE]]. Is this acceptable?

[jhenderson]

llvm/test/tools/llvm-objdump/unimplemented-features.test

14 ↗

(On Diff #252226)

Personally, I don't think that really gains us anything.

[Higuoxing]

Addressed comment.

[Higuoxing]

Indent for continuous lines.

[jhenderson]

Two minor comments. Otherwise, looks good to me.

llvm/test/tools/llvm-objdump/unimplemented-features.test

4 ↗

(On Diff #252294)

You can get rid of --match-full-lines and --strict-whitespace form here and below. This is only testing a warning, not the output format of an option.

6 ↗

(On Diff #252294)

No need to duplicate this comment throughout this test. The one at the top is sufficient (you can get rid of the extra blank lines then too. You can keep the old comments for "Mach-O/COFF object file" if you like, or just name the output files %t.coff.o, and %t.macho.o to make them self-documenting.

[Higuoxing]

• Remove duplicated comments.
• Get rid of --match-full-lines and --strict-whitespace

[jhenderson]

LGTM.

llvm/docs/CommandGuide/llvm-objdump.rst

 .. option:: -s, --full-contents
 
   Display the contents of each section.
 
 .. option:: -t, --syms
 
   Display the symbol table.
 
+.. option:: -T, --dynamic-syms
+
+  Display the contents of the dynamic symbol table.
+
 .. option:: -u, --unwind-info
 
   Display the unwind info of the input(s).
 
 .. option:: --version
 
   Display the version of the :program:`llvm-objdump` executable. Does not stack
   with other commands.

llvm/test/tools/llvm-objdump/X86/elf-dynamic-symbols.test

+## Test that llvm-objdump can dump dynamic symbols.
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-objdump --dynamic-syms %t1 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace --check-prefix=DYNSYM
+# RUN: llvm-objdump -T %t1 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace --check-prefix=DYNSYM
+
+#      DYNSYM:DYNAMIC SYMBOL TABLE:
+# DYNSYM-NEXT:0000000000000000 l    DO .data  0000000000000000 localsym
+# DYNSYM-NEXT:0000000000000000 g    DO .data  0000000000000000 globalsym
+# DYNSYM-NEXT:0000000000000000 g    DO .data  0000000000000000 uniqueglobalsym
+# DYNSYM-NEXT:0000000000000000  w   DO .data  0000000000000000 weaksym
+# DYNSYM-NEXT:0000000000000000 g    Df .data  0000000000000000 filesym
+# DYNSYM-NEXT:0000000000000000 g    DF .data  0000000000000000 funcsym
+# DYNSYM-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .data
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC, SHF_WRITE ]
+DynamicSymbols:
+  - Name:    localsym
+    Type:    STT_OBJECT
+    Section: .data
+    Binding: STB_LOCAL
+  - Name:    globalsym
+    Type:    STT_OBJECT
+    Section: .data
+    Binding: STB_GLOBAL
+  - Name:    uniqueglobalsym
+    Type:    STT_OBJECT
+    Section: .data
+    Binding: STB_GNU_UNIQUE
+  - Name:    weaksym
+    Type:    STT_OBJECT
+    Section: .data
+    Binding: STB_WEAK
+  - Name:    filesym
+    Type:    STT_FILE
+    Section: .data
+    Binding: STB_GLOBAL
+  - Name:    funcsym
+    Type:    STT_FUNC
+    Section: .data
+    Binding: STB_GLOBAL
+
+## Test dumping ELF files with no .dynsym section.
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-objdump --dynamic-syms %t2 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace --check-prefix=NODYNSYM
+# RUN: llvm-objdump -T %t2 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace --check-prefix=NODYNSYM
+
+# NODYNSYM:DYNAMIC SYMBOL TABLE:
+# NODYNSYM-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+
+## Test dumping ELF files with logically empty .dynsym section (only has a 0-index NULL symbol).
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-objdump --dynamic-syms %t3 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace --check-prefix=ONLY-NULL
+# RUN: llvm-objdump -T %t3 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace --check-prefix=ONLY-NULL
+
+# ONLY-NULL:DYNAMIC SYMBOL TABLE:
+# ONLY-NULL-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+DynamicSymbols:
+
+## Test dumping ELF files with truly empty .dynsym section (size of .dynsym section is 0).
+# RUN: yaml2obj --docnum=4 %s -o %t4
+# RUN: llvm-objdump --dynamic-syms %t4 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace --check-prefix=EMPTY
+# RUN: llvm-objdump -T %t4 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace --check-prefix=EMPTY
+
+# EMPTY:DYNAMIC SYMBOL TABLE:
+# EMPTY-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .dynsym
+    Type:    SHT_DYNSYM
+    Content: ""
+
+## Test dumping non-ELF files will emit warning.
+# RUN: llvm-objdump --dynamic-syms %p/Inputs/hello.obj.macho-x86_64 2>&1 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace
+# RUN: llvm-objdump -T %p/Inputs/hello.obj.macho-x86_64 2>&1 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace
+# RUN: llvm-objdump --dynamic-syms %p/Inputs/internal.exe.coff-x86_64 2>&1 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace
+# RUN: llvm-objdump -T %p/Inputs/internal.exe.coff-x86_64 2>&1 | \
+# RUN: FileCheck %s --match-full-lines --strict-whitespace
+#      CHECK:DYNAMIC SYMBOL TABLE:
+# CHECK-NEXT:{{.*}}/llvm-objdump: warning:{{.*}}: this operation is only currently supported for ELF object files
+# CHECK-EMPTY:

llvm/tools/llvm-objdump/llvm-objdump.h

 void printLazyBindTable(object::ObjectFile *O);
 void printWeakBindTable(object::ObjectFile *O);
 void printRawClangAST(const object::ObjectFile *O);
 void printRelocations(const object::ObjectFile *O);
 void printDynamicRelocations(const object::ObjectFile *O);
 void printSectionHeaders(const object::ObjectFile *O);
 void printSectionContents(const object::ObjectFile *O);
 void printSymbolTable(const object::ObjectFile *O, StringRef ArchiveName,
-                      StringRef ArchitectureName = StringRef());
+                      StringRef ArchitectureName = StringRef(),
+                      bool DumpDynamic = false);
 LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, Twine Message);
 LLVM_ATTRIBUTE_NORETURN void reportError(Error E, StringRef FileName,
                                          StringRef ArchiveName = "",
                                          StringRef ArchitectureName = "");
 void reportWarning(Twine Message, StringRef File);
 
 template <typename T, typename... Ts>
 T unwrapOrError(Expected<T> EO, Ts &&... Args) {

llvm/tools/llvm-objdump/llvm-objdump.cpp

static cl::opt<uint64_t> StopAddress("stop-address",
                                      cl::init(UINT64_MAX), cl::cat(ObjdumpCat));
 
 cl::opt<bool> SymbolTable("syms", cl::desc("Display the symbol table"),
                           cl::cat(ObjdumpCat));
 static cl::alias SymbolTableShort("t", cl::desc("Alias for --syms"),
                                   cl::NotHidden, cl::Grouping,
                                   cl::aliasopt(SymbolTable));
 
+cl::opt<bool> DynamicSymbolTable(
+    "dynamic-syms",
+    cl::desc("Display the contents of the dynamic symbol table"),
+    cl::cat(ObjdumpCat));
+static cl::alias DynamicSymbolTableShort("T",
+                                         cl::desc("Alias for --dynamic-syms"),
+                                         cl::NotHidden, cl::Grouping,
+                                         cl::aliasopt(DynamicSymbolTable));
+
 cl::opt<std::string> TripleName("triple",
                                 cl::desc("Target triple to disassemble for, "
                                          "see -version for available targets"),
                                 cl::cat(ObjdumpCat));
 
 cl::opt<bool> UnwindInfo("unwind-info", cl::desc("Display unwind information"),
                          cl::cat(ObjdumpCat));
 static cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind-info"),
for (std::size_t Addr = 0, End = Contents.size(); Addr < End; Addr += 16) {
         else
           outs() << ".";
       }
       outs() << "\n";
     }
   }
 }
 
 void printSymbolTable(const ObjectFile *O, StringRef ArchiveName,
-                      StringRef ArchitectureName) {
+                      StringRef ArchitectureName, bool DumpDynamic) {
+  if (O->isCOFF() && !DumpDynamic) {
     outs() << "SYMBOL TABLE:\n";
-
-  if (const COFFObjectFile *Coff = dyn_cast<const COFFObjectFile>(O)) {
-    printCOFFSymbolTable(Coff);
+    printCOFFSymbolTable(cast<const COFFObjectFile>(O));
     return;
   }
 
   const StringRef FileName = O->getFileName();
+  auto I = O->symbol_begin();
+  auto E = O->symbol_end();
   const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(O);
-  for (auto I = O->symbol_begin(), E = O->symbol_end(); I != E; ++I) {
+
+  if (!DumpDynamic)
+    outs() << "SYMBOL TABLE:\n";
+  else {
+    outs() << "DYNAMIC SYMBOL TABLE:\n";
+
+    if (!O->isELF()) {
+      reportWarning(
+          "this operation is only currently supported for ELF object files",
+          FileName);
+      return;
+    }
+
+    const ELFObjectFileBase *ELF = cast<const ELFObjectFileBase>(O);
+    I = ELF->getDynamicSymbolIterators().begin();
+    E = ELF->getDynamicSymbolIterators().end();
+  }
+
+  for (; I != E; ++I) {
     const SymbolRef &Symbol = *I;
     uint64_t Address = unwrapOrError(Symbol.getAddress(), FileName, ArchiveName,
                                      ArchitectureName);
     if ((Address < StartAddress) || (Address > StopAddress))
       continue;
     SymbolRef::Type Type = unwrapOrError(Symbol.getType(), FileName,
                                          ArchiveName, ArchitectureName);
     uint32_t Flags = Symbol.getFlags();
 
     // Don't ask a Mach-O STAB symbol for its section unless you know that 
     // STAB symbol's section field refers to a valid section index. Otherwise
if (Type == SymbolRef::ST_Debug && Section != O->section_end()) {
         Name = *NameOrErr;
       else
         consumeError(NameOrErr.takeError());
 
     } else {
       Name = unwrapOrError(Symbol.getName(), FileName, ArchiveName,
                            ArchitectureName);
     }
 
     bool Global = Flags & SymbolRef::SF_Global;
     bool Weak = Flags & SymbolRef::SF_Weak;
     bool Absolute = Flags & SymbolRef::SF_Absolute;
     bool Common = Flags & SymbolRef::SF_Common;
     bool Hidden = Flags & SymbolRef::SF_Hidden;
 
     char GlobLoc = ' ';
     if ((Section != O->section_end() || Absolute) && !Weak)
       GlobLoc = Global ? 'g' : 'l';
-    char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
-                 ? 'd' : ' ';
+    char Debug = ' ';
+    if (DumpDynamic)
+      Debug = 'D';
+    else if (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
+      Debug = 'd';
+
     char FileFunc = ' ';
     if (Type == SymbolRef::ST_File)
       FileFunc = 'f';
     else if (Type == SymbolRef::ST_Function)
       FileFunc = 'F';
     else if (Type == SymbolRef::ST_Data)
       FileFunc = 'O';
 
     const char *Fmt = O->getBytesInAddress() > 4 ? "%016" PRIx64 :
                                                    "%08" PRIx64;
 
     outs() << format(Fmt, Address) << " "
            << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' '
            << (Weak ? 'w' : ' ') // Weak?
            << ' ' // Constructor. Not supported yet.
            << ' ' // Warning. Not supported yet.
            << ' ' // Indirect reference to another symbol.
            << Debug // Debugging (d) or dynamic (D) symbol.
            << FileFunc // Name of function (F), file (f) or object (O).
            << ' ';
     if (Absolute) {
       outs() << "*ABS*";
     } else if (Common) {
       outs() << "*COM*";
     } else if (Section == O->section_end()) {
       outs() << "*UND*";
     } else {
       if (const MachOObjectFile *MachO =
           dyn_cast<const MachOObjectFile>(O)) {
         DataRefImpl DR = Section->getRawDataRefImpl();
         StringRef SegmentName = MachO->getSectionFinalSegmentName(DR);
         outs() << SegmentName << ",";
       }
       StringRef SectionName =
-          unwrapOrError(Section->getName(), O->getFileName());
+          unwrapOrError(Section->getName(), FileName);
       outs() << SectionName;
     }
 
     if (Common || isa<ELFObjectFileBase>(O)) {
       uint64_t Val =
           Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize();
       outs() << '\t' << format(Fmt, Val);
     }
 
static void dumpObject(ObjectFile *O, const Archive *A = nullptr,
   if (FileHeaders)
     printFileHeaders(O);
   if (PrivateHeaders || FirstPrivateHeader)
     printPrivateFileHeaders(O, FirstPrivateHeader);
   if (SectionHeaders)
     printSectionHeaders(O);
   if (SymbolTable)
     printSymbolTable(O, ArchiveName);
+  if (DynamicSymbolTable)
+    printSymbolTable(O, ArchiveName, /*ArchitectureName=*/"",
+                     /*DumpDynamic=*/true);
   if (DwarfDumpType != DIDT_Null) {
     std::unique_ptr<DIContext> DICtx = DWARFContext::create(*O);
     // Dump the complete DWARF structure.
     DIDumpOptions DumpOpts;
     DumpOpts.DumpType = DwarfDumpType;
     DICtx->dump(outs(), DumpOpts);
   }
   if (Relocations && !Disassemble)
int main(int argc, char **argv) {
 
   if (DisassembleAll || PrintSource || PrintLines ||
       (!DisassembleFunctions.empty()))
     Disassemble = true;
 
   if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null &&
       !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST &&
       !Relocations && !SectionHeaders && !SectionContents && !SymbolTable &&
-      !UnwindInfo && !FaultMapSection &&
+      !DynamicSymbolTable && !UnwindInfo && !FaultMapSection &&
       !(MachOOpt &&
         (Bind || DataInCode || DylibId || DylibsUsed || ExportsTrie ||
          FirstPrivateHeader || IndirectSymbols || InfoPlist || LazyBind ||
          LinkOptHints || ObjcMetaData || Rebase || UniversalHeaders ||
          WeakBind || !FilterSections.empty()))) {
     cl::PrintHelpMessage();
     return 2;
   }