[llvm-objdump] -T: print symbol versions

[MaskRay]

Summary

Similar to D94907 (llvm-nm -D).

The output will match GNU objdump 2.37.
Older versions don't use (version) for undefined symbols.

[MaskRay]

improve test - add a visibility test

[MaskRay]

test warning

[jhenderson]

I assume this is compatible with whatever GNU objdump does (I've not checked myself)?

llvm/test/tools/llvm-objdump/ELF/dynsym-version.test

16

Probably worth a comment here pointing out the difference with the previous case.

[MaskRay]

add one more space to match GNU objdump.
improve tests

[MaskRay]

In D108097#2946545, @jhenderson wrote:

I assume this is compatible with whatever GNU objdump does (I've not checked myself)?

It matches the latest GNU objdump.

% ~/Dev/binutils-gdb/out/debug/binutils/objdump -T =cat > /tmp/0
% fob -T =cat > /tmp/1  # llvm-objdump with this patch
% diff -u /tmp/0 /tmp/1
--- /tmp/0      2021-08-16 10:59:21.938459199 -0700
+++ /tmp/1      2021-08-16 10:55:47.165812330 -0700
@@ -1,5 +1,5 @@
 
-/usr/bin/cat:     file format elf64-x86-64
+/usr/bin/cat:  file format elf64-x86-64
 
 DYNAMIC SYMBOL TABLE:
 0000000000000000      DF *UND* 0000000000000000 (GLIBC_2.2.5) free
@@ -64,5 +64,3 @@
 000000000000b280  w   DO .bss  0000000000000008 (GLIBC_2.2.5) program_invocation_short_name
 000000000000b2a0 g    DO .bss  0000000000000008 (GLIBC_2.2.5) stderr
 000000000000b290 g    DO .bss  0000000000000004 (GLIBC_2.2.5) optind
-
-

[jhenderson]

llvm/test/tools/llvm-objdump/ELF/dynsym-version.test

102

Up to you whether you do this, but I see no harm in folding it in with the main case. This helps reduce the number of individual test cases.

103

If you choose not to merge things, I think you can drop the -DINDEX=1 right?

[MaskRay]

simplify test

llvm/test/tools/llvm-objdump/ELF/dynsym-version.test

102

If in the future we ever compute the max width of the section & the version name, having separate tests can test the case when all version names are not greater than 12 bytes.

Using [[VERSION_NAME=v5hidden]] is an alternative, but that may make the test a bit complex.

[jhenderson]

LGTM, thanks!

llvm/test/tools/llvm-objdump/ELF/dynsym-version.test

+## Check we print symbol versions, when they are available.
+
+## Test undefined symbols.
+# RUN: yaml2obj %s -o %t-undef.o
+# RUN: llvm-objdump -T %t-undef.o 2>&1 | tr '\t' '|' | FileCheck %s \
+# RUN:   -DFILE=%t-undef.o --check-prefix=UNDEF --match-full-lines --strict-whitespace
+
+## version2sym and version3sym are invalid: undefined symbols cannot refer to .gnu.version_d.
+## We still check their behaviors.
+#      UNDEF:DYNAMIC SYMBOL TABLE:
+# UNDEF-NEXT:0000000000000000      D  *UND*|0000000000000000              localversym
+# UNDEF-NEXT:0000000000000000      D  *UND*|0000000000000000              globalversym
+# UNDEF-NEXT:0000000000000000      D  *UND*|0000000000000000 (v2)         version2sym
+# UNDEF-NEXT:0000000000000000      D  *UND*|0000000000000000 (v3hidden)   version3sym
+# UNDEF-NEXT:0000000000000000      D  *UND*|0000000000000000 (v4)         version4sym
+# UNDEF-NEXT:0000000000000000      D  *UND*|0000000000000000 (v5hidden)   .hidden version5sym
+
+## Test defined symbols.
+# RUN: yaml2obj -DINDEX=0x1 %s -o %t-def.o
+# RUN: llvm-objdump -T %t-def.o 2>&1 | tr '\t' '|' | FileCheck %s \
+# RUN:   -DFILE=%t-def.o --check-prefix=DEF --match-full-lines --strict-whitespace
+
+#      DEF:DYNAMIC SYMBOL TABLE:
+# DEF-NEXT:0000000000000000 g    D  .gnu.version|0000000000000000              localversym
+# DEF-NEXT:0000000000000000 g    D  .gnu.version|0000000000000000              globalversym
+# DEF-NEXT:0000000000000000 g    D  .gnu.version|0000000000000000  v2          version2sym
+# DEF-NEXT:0000000000000000 g    D  .gnu.version|0000000000000000 (v3hidden)   version3sym
+# DEF-NEXT:0000000000000000 g    D  .gnu.version|0000000000000000 (v4)         version4sym
+# DEF-NEXT:0000000000000000 g    D  .gnu.version|0000000000000000 (v5hidden)   .hidden version5sym
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Flags:   [ SHF_ALLOC ]
+## 0x8000 is a special VERSYM_HIDDEN bit.
+    Entries: [ 0, 0, 1, 2, 0x8003, 4, 0x8005 ]
+    ShSize:  [[VERSYMSIZE=<none>]]
+  - Name:         .gnu.version_d
+    Type:         SHT_GNU_verdef
+    Flags:        [ SHF_ALLOC ]
+    Link:         .dynstr
+    AddressAlign: 0x4
+    Info:         0x2
+    ShOffset:     [[VERDEFOFFSET=<none>]]
+    Entries:
+      - VersionNdx: 2
+        Names:
+          - v2
+      - VersionNdx: 3
+        Names:
+          - v3hidden
+  - Name:  .gnu.version_r
+    Type:  SHT_GNU_verneed
+    Flags: [ SHF_ALLOC ]
+    Link:  .dynstr
+    Info:  0x2
+    Dependencies:
+      - Version: 1
+        File:    file1.so
+        Entries:
+          - Name:  v4
+            Hash:  0
+            Flags: 0
+            Other: 4
+      - Version: 1
+        File:    file2.0
+        Entries:
+          - Name:  v5hidden
+            Hash:  0
+            Flags: 0
+            Other: 5
+  - Name:    .dynsym
+    Type:    SHT_DYNSYM
+    EntSize: [[ENTSIZE=<none>]]
+DynamicSymbols:
+  - Name:  localversym
+    Index: [[INDEX=<none>]]
+    Binding: STB_GLOBAL
+  - Name:  globalversym
+    Index: [[INDEX=<none>]]
+    Binding: STB_GLOBAL
+  - Name:  version2sym
+    Index: [[INDEX=<none>]]
+    Binding: STB_GLOBAL
+  - Name:  version3sym
+    Index: [[INDEX=<none>]]
+    Binding: STB_GLOBAL
+  - Name:  version4sym
+    Index: [[INDEX=<none>]]
+    Binding: STB_GLOBAL
+  - Name:  version5sym
+    Index: [[INDEX=<none>]]
+    Other: [ STV_HIDDEN ]
+    Binding: STB_GLOBAL
+
+## Test the output with a long version name.
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-objdump -T %t2 2>&1 | tr '\t' '|' | FileCheck %s \
+# RUN:   --check-prefix=LONGNAME --match-full-lines --strict-whitespace
+
+#      LONGNAME:DYNAMIC SYMBOL TABLE:
+# LONGNAME-NEXT:0000000000000000 g    D  .gnu.version|0000000000000000  v2          sym1
+# LONGNAME-NEXT:0000000000000000 g    D  .gnu.version|0000000000000000  v3withverylongname sym2
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Flags:   [ SHF_ALLOC ]
+    Entries: [ 1, 2, 3 ]
+  - Name:         .gnu.version_d
+    Type:         SHT_GNU_verdef
+    Flags:        [ SHF_ALLOC ]
+    Link:         .dynstr
+    AddressAlign: 0x4
+    Info:         0x2
+    Entries:
+      - VersionNdx: 2
+        Names:
+          - v2
+      - VersionNdx: 3
+        Names:
+          - v3withverylongname
+  - Name:    .dynsym
+    Type:    SHT_DYNSYM
+DynamicSymbols:
+  - Name:  sym1
+    Index: 1
+    Binding: STB_GLOBAL
+  - Name:  sym2
+    Index: 1
+    Binding: STB_GLOBAL
+
+## Check we report a warning when we are unable to read a SHT_GNU_versym section entry.
+## In this case, the section has a size that is not a multiple of its sh_entsize.
+
+# RUN: yaml2obj -DVERSYMSIZE=0xff %s -o %t2-broken-versym.o
+# RUN: llvm-objdump -T %t2-broken-versym.o 2>&1 | FileCheck %s --check-prefixes=VERSION-ERR1,NOVER
+
+# VERSION-ERR1:warning: {{.*}}: unable to read an entry with index 1 from SHT_GNU_versym section
+# NOVER-NEXT:0000000000000000      D  *UND*  0000000000000000 localversym
+# NOVER-NEXT:0000000000000000      D  *UND*  0000000000000000 globalversym
+# NOVER-NEXT:0000000000000000      D  *UND*  0000000000000000 version2sym
+# NOVER-NEXT:0000000000000000      D  *UND*  0000000000000000 version3sym
+# NOVER-NEXT:0000000000000000      D  *UND*  0000000000000000 version4sym
+# NOVER-NEXT:0000000000000000      D  *UND*  0000000000000000 .hidden version5sym

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

 class Twine;
 
 namespace object {
 class ELFObjectFileBase;
 class ELFSectionRef;
 class MachOObjectFile;
 class MachOUniversalBinary;
 class RelocationRef;
+struct VersionEntry;
 } // namespace object
 
 namespace objdump {
 
 enum DebugVarsFormat {
   DVDisabled,
   DVUnicode,
   DVASCII,

 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(),
                       bool DumpDynamic = false);
 void printSymbol(const object::ObjectFile *O, const object::SymbolRef &Symbol,
+                 ArrayRef<object::VersionEntry> SymbolVersions,
                  StringRef FileName, StringRef ArchiveName,
                  StringRef ArchitectureName, bool DumpDynamic);
 [[noreturn]] void reportError(StringRef File, const Twine &Message);
 [[noreturn]] void reportError(Error E, StringRef FileName,
                               StringRef ArchiveName = "",
                               StringRef ArchitectureName = "");
 void reportWarning(const Twine &Message, StringRef File);
 

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

if (O->isCOFF() && !DumpDynamic) {
     return;
   }
 
   const StringRef FileName = O->getFileName();
 
   if (!DumpDynamic) {
     outs() << "\nSYMBOL TABLE:\n";
     for (auto I = O->symbol_begin(); I != O->symbol_end(); ++I)
-      printSymbol(O, *I, FileName, ArchiveName, ArchitectureName, DumpDynamic);
+      printSymbol(O, *I, {}, FileName, ArchiveName, ArchitectureName,
+                  DumpDynamic);
     return;
   }
 
   outs() << "\nDYNAMIC SYMBOL TABLE:\n";
   if (!O->isELF()) {
     reportWarning(
         "this operation is not currently supported for this file format",
         FileName);
     return;
   }
 
   const ELFObjectFileBase *ELF = cast<const ELFObjectFileBase>(O);
-  for (auto I = ELF->getDynamicSymbolIterators().begin();
-       I != ELF->getDynamicSymbolIterators().end(); ++I)
-    printSymbol(O, *I, FileName, ArchiveName, ArchitectureName, DumpDynamic);
+  auto Symbols = ELF->getDynamicSymbolIterators();
+  Expected<std::vector<VersionEntry>> SymbolVersionsOrErr =
+      ELF->readDynsymVersions();
+  if (!SymbolVersionsOrErr) {
+    reportWarning(toString(SymbolVersionsOrErr.takeError()), FileName);
+    SymbolVersionsOrErr = std::vector<VersionEntry>();
+    (void)!SymbolVersionsOrErr;
+  }
+  for (auto &Sym : Symbols)
+    printSymbol(O, Sym, *SymbolVersionsOrErr, FileName, ArchiveName,
+                ArchitectureName, DumpDynamic);
 }
 
 void objdump::printSymbol(const ObjectFile *O, const SymbolRef &Symbol,
+                          ArrayRef<VersionEntry> SymbolVersions,
                           StringRef FileName, StringRef ArchiveName,
                           StringRef ArchitectureName, bool DumpDynamic) {
   const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(O);
   uint64_t Address = unwrapOrError(Symbol.getAddress(), FileName, ArchiveName,
                                    ArchitectureName);
   if ((Address < StartAddress) || (Address > StopAddress))
     return;
   SymbolRef::Type Type =
void objdump::printSymbol(const ObjectFile *O, const SymbolRef &Symbol,
 
   if (Common || O->isELF()) {
     uint64_t Val =
         Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize();
     outs() << '\t' << format(Fmt, Val);
   }
 
   if (O->isELF()) {
+    if (!SymbolVersions.empty()) {
+      const VersionEntry &Ver =
+          SymbolVersions[Symbol.getRawDataRefImpl().d.b - 1];
+      std::string Str;
+      if (!Ver.Name.empty())
+        Str = Ver.IsVerDef ? ' ' + Ver.Name : '(' + Ver.Name + ')';
+      outs() << ' ' << left_justify(Str, 12);
+    }
+
     uint8_t Other = ELFSymbolRef(Symbol).getOther();
     switch (Other) {
     case ELF::STV_DEFAULT:
       break;
     case ELF::STV_INTERNAL:
       outs() << " .internal";
       break;
     case ELF::STV_HIDDEN: