[llvm-readelf/llvm-readobj] - Improved the error reporting in a few method related to versioning.

[grimar]

Summary

I was investigating a change previously discussed that eliminates an excessive
empty lines from the output when we report warnings and errors
(https://reviews.llvm.org/D70826#inline-639055) and found
that we need this refactoring or alike to achieve that.

The problem is that some of our functions that finds symbol versions just
fail instead of returning errors or printing warnings. Another problem
is that they might print a warning on the same line with the regular output.
In this patch I've splitted getting of the version information and dumping of it
for GNU printVersionSymbolSection(). I had to change a few methods to return
Error or Expected<> to do that properly.

[jhenderson]

llvm/test/tools/llvm-readobj/elf-verdef-invalid.test

266 ↗

(On Diff #232558)

"we report when..."

This line is quite long. Maybe it should be split.

llvm/test/tools/llvm-readobj/elf-versym-invalid.test

222 ↗

(On Diff #232558)

sections -> section

226 ↗

(On Diff #232558)

I'd use --dyn-syms here instead of -dt, since there's no reason for it to be inconsistent with the line below.

256 ↗

(On Diff #232558)

Would it be worth an extra 0xFF entry to show that the warning gets uniqued?

llvm/tools/llvm-readobj/ELFDumper.cpp

4126

for (size_t I = 0, S = VerTable.size(); I < S; ++I)

4136

I'm not sure it's right to say that an empty name is corrupt?

[grimar]

llvm/tools/llvm-readobj/ELFDumper.cpp

4136

That what original code did (the test was introduced in D59877) and I think it is
probably reasonable to assume that.
Normally we probably never want to have an empty version name for a symbol that has version?
Having such an empty version intentionally seems looks highly unlikely.

Spec says: "All other values are used to identify version strings located in one of the other Symbol
Version sections. The value itself is not the version associated with the symbol.
The string identified by the value defines the version of the symbol."
(https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA.junk/symversion.html)
It says nothing about the case when the version string is empty, though
it sounds like it is assumed that a version exists, i.e is non-empty?

it is also just a bit strange to me to see the output for such case (below is what GNU readelf prints):

Symbol table '.dynsym' contains 6 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
....
     2: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@ (2)
....
Version symbols section '.gnu.version' contains 6 entries:
 Addr: 000000000000043e  Offset: 0x00043e  Link: 5 (.dynsym)
  000:   0 (*local*)       0 (*local*)       2 ()              0 (*local*)    
  004:   0 (*local*)       2 ()

It looks like something is just wrong with the symbol __libc_start_main@ and version 2?

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

4136

But shouldn't we just allow it? It simplifies the code and brings us closer to GNU compatibility. Whilst I think it a bit odd, I don't see a strong motivation for handling the empty string differently to other strings. I don't feel strongly about this however.

[grimar]

• Addressed review comments.

llvm/test/tools/llvm-readobj/elf-versym-invalid.test

256 ↗

(On Diff #232558)

Done.

llvm/tools/llvm-readobj/ELFDumper.cpp

4136

I do not mind to suggest a follow-up patch to change this behavior if we do not really want it.
(I'd not change this existent behavior in this patch, as it is probably unrelated).

[jhenderson]

llvm/test/tools/llvm-readobj/elf-versym-invalid.test

256 ↗

(On Diff #232558)

Will you need an --implicit-check-not="warning:" or equivalent somewhere to actually detect that the warning has actually been uniqued?

llvm/tools/llvm-readobj/ELFDumper.cpp

4136

Sounds reasonable.

[grimar]

• Rebased.
• Addressed review comments.

[grimar]

llvm/test/tools/llvm-readobj/elf-versym-invalid.test

256 ↗

(On Diff #232558)

Oh, I missed we do not have it.
And also actually we need one more dynamic symbol to trigger a warning too..
I've updated the test.

[jhenderson]

LGTM, with one minor comment.

llvm/test/tools/llvm-readobj/ELF/verdef-invalid.test

266–267

Actually, on re-read, I realise that this should be "Check we report a warning when..."

llvm/test/Object/invalid.test

- Name: .strtab
     Size: 1
 Symbols:
   - Name: foo
 
 ## Version index in .gnu.version overflows the version map.
 ## Check llvm-readobj reports it.
 
 # RUN: yaml2obj %s --docnum=20 -o %t20
-# RUN: not llvm-readobj -dt %t20 2>&1 | FileCheck -DFILE=%t20 --check-prefix=INVALID-VERSION %s
+# RUN: llvm-readobj -dt %t20 2>&1 | FileCheck -DFILE=%t20 --check-prefix=INVALID-VERSION %s
 
-# INVALID-VERSION: error: '[[FILE]]': Invalid version entry
+# INVALID-VERSION: warning: '[[FILE]]': SHT_GNU_versym section refers to a version index 255 which is missing
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:

llvm/test/tools/llvm-readobj/ELF/verdef-invalid.test

Entries:
       - Version:    0xfefe
         Flags:      0
         VersionNdx: 0
         Hash:       0
         Names: []
 DynamicSymbols:
   - Name: foo
 
-## Check we error out when trying to print version symbols, but SHT_GNU_verdef is invalid due to any reason.
+## Check we report a warning when trying to print version symbols, but SHT_GNU_verdef
+## is invalid due to any reason.
 
 # RUN: yaml2obj %s --docnum=10 -o %t10
-# RUN: not llvm-readobj -V %t10 2>&1 | FileCheck %s --check-prefix=INVALID-VERDEF-LLVM -DFILE=%t10
-# RUN: not llvm-readelf -V %t10 2>&1 | FileCheck %s --check-prefix=INVALID-VERDEF-GNU -DFILE=%t10
+# RUN: llvm-readobj -V %t10 2>&1 | FileCheck %s --check-prefix=INVALID-VERDEF-LLVM -DFILE=%t10
+# RUN: llvm-readelf -V %t10 2>&1 | FileCheck %s --check-prefix=INVALID-VERDEF-GNU -DFILE=%t10
 
 # INVALID-VERDEF-LLVM:      VersionSymbols [
 # INVALID-VERDEF-LLVM-NEXT:    Symbol {
 # INVALID-VERDEF-LLVM-NEXT:      Version: 0
 # INVALID-VERDEF-LLVM-NEXT:      Name:
 # INVALID-VERDEF-LLVM-NEXT:    }
 # INVALID-VERDEF-LLVM-NEXT:    Symbol {
 # INVALID-VERDEF-LLVM-NEXT:    Version: 2
 # INVALID-VERDEF-LLVM-EMPTY:
-# INVALID-VERDEF-LLVM-NEXT:  error: '[[FILE]]': invalid SHT_GNU_verdef section with index 2: version definition 1 goes past the end of the section
+# INVALID-VERDEF-LLVM-NEXT:  warning: '[[FILE]]': invalid SHT_GNU_verdef section with index 2: version definition 1 goes past the end of the section
+# INVALID-VERDEF-LLVM-NEXT:    Name: foo@<corrupt>
 
 # INVALID-VERDEF-GNU:      Version symbols section '.gnu.version' contains 2 entries:
 # INVALID-VERDEF-GNU-NEXT:  Addr: 0000000000000000  Offset: 0x000040  Link: 5 (.dynsym)
-# INVALID-VERDEF-GNU-NEXT:   000:   0 (*local*)
-# INVALID-VERDEF-GNU-NEXT: error: '[[FILE]]': invalid SHT_GNU_verdef section with index 2: version definition 1 goes past the end of the section
+# INVALID-VERDEF-GNU-EMPTY:
+# INVALID-VERDEF-GNU-NEXT: warning: '[[FILE]]': unable to get a version for entry 1 of SHT_GNU_versym section with index 1: invalid SHT_GNU_verdef section with index 2: version definition 1 goes past the end of the section
+# INVALID-VERDEF-GNU-NEXT:   000: 0 (*local*) 2 (<corrupt>)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:

llvm/test/tools/llvm-readobj/ELF/verneed-invalid.test

 ## Test how llvm-readobj/llvm-readelf tools handle invalid SHT_GNU_verneed sections.
 
 ## In the first case we have a SHT_GNU_versym section that refers to
 ## a version listed in a SHT_GNU_verneed section. That version has an
 ## empty name, making it invalid.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf -V %t1 | FileCheck %s --check-prefix=GNU-VERNEED-NAME
 # RUN: llvm-readobj -V %t1 | FileCheck %s --check-prefix=LLVM-VERNEED-NAME
 
 # GNU-VERNEED-NAME:      Version symbols section '.gnu.version' contains 2 entries:
 # GNU-VERNEED-NAME-NEXT:  Addr: 0000000000200210  Offset: 0x000040  Link: 5 (.dynsym)
-# GNU-VERNEED-NAME-NEXT:   000:   0 (*local*)       2 (*invalid*)
+# GNU-VERNEED-NAME-NEXT:   000:   0 (*local*)       2 (<corrupt>)
 
 # GNU-VERNEED-NAME:      Version needs section '.gnu.version_r' contains 1 entries:
 # GNU-VERNEED-NAME-NEXT:  Addr: 0000000000000000  Offset: 0x000044  Link: 6 (.dynstr)
 # GNU-VERNEED-NAME-NEXT:   0x0000: Version: 1  File: somefile  Cnt: 1
 # GNU-VERNEED-NAME-NEXT:   0x0010:   Name:   Flags: none  Version: 2
 
 # LLVM-VERNEED-NAME:      VersionSymbols [
 # LLVM-VERNEED-NAME:        Symbol {

 ## this situation properly.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readelf -V %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=GNU-NOLINK
 # RUN: llvm-readobj -V %t2 2>&1 | FileCheck %s -DFILE=%t2 --check-prefix=LLVM-NOLINK
 
 # GNU-NOLINK:      Version symbols section '.gnu.version' contains 2 entries:
 # GNU-NOLINK-NEXT:  Addr: 0000000000000000  Offset: 0x000040  Link: 5 (.dynsym)
-# GNU-NOLINK-NEXT:   000:   0 (*local*)
+# GNU-NOLINK-EMPTY:
 # GNU-NOLINK-NEXT: warning: '[[FILE]]': invalid string table linked to SHT_GNU_verneed section with index 2: invalid sh_type for string table section [index 0]: expected SHT_STRTAB, but got SHT_NULL
-# GNU-NOLINK-NEXT:   2 (<corrupt>)
+# GNU-NOLINK-NEXT:   000:   0 (*local*) 2 (<corrupt>)
 # GNU-NOLINK-EMPTY:
 # GNU-NOLINK:      Version needs section '.gnu.version_r' contains 1 entries:
 # GNU-NOLINK-NEXT:  Addr: 0000000000000000  Offset: 0x000044  Link: 0 ()
 # GNU-NOLINK-NEXT:   0x0000: Version: 1  File: <corrupt vn_file: 9>  Cnt: 1
 # GNU-NOLINK-NEXT:   0x0010:   Name: <corrupt>  Flags: none Version: 2
 
 # LLVM-NOLINK:      VersionSymbols [
 # LLVM-NOLINK:        Symbol {
Dependencies:
             Other: 2
 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL
 
 ## We can't parse misaligned auxiliary version records.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
-# RUN: not llvm-readelf -V %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=BROKEN-AUX
-# RUN: not llvm-readobj -V %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=BROKEN-AUX
+# RUN: llvm-readelf -V %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=BROKEN-AUX-GNU
+# RUN: llvm-readobj -V %t3 2>&1 | FileCheck %s -DFILE=%t3 --check-prefix=BROKEN-AUX-LLVM
 
-# BROKEN-AUX: error: '[[FILE]]': invalid SHT_GNU_verneed section with index 2: found a misaligned auxiliary entry at offset 0x11
+# BROKEN-AUX-GNU:       Version symbols section '.gnu.version' contains 1 entries:
+# BROKEN-AUX-GNU-NEXT:   Addr: 0000000000000000  Offset: 0x000040  Link: 5 (.dynsym)
+# BROKEN-AUX-GNU-EMPTY:
+# BROKEN-AUX-GNU-NEXT:  warning: '[[FILE]]': unable to get a version for entry 0 of SHT_GNU_versym section with index 1: invalid SHT_GNU_verneed section with index 2: found a misaligned auxiliary entry at offset 0x11
+# BROKEN-AUX-GNU-NEXT:   000:   2 (<corrupt>)
+
+# BROKEN-AUX-LLVM:       VersionSymbols [
+# BROKEN-AUX-LLVM-NEXT:    Symbol {
+# BROKEN-AUX-LLVM-NEXT:      Version: 2
+# BROKEN-AUX-LLVM-EMPTY:
+# BROKEN-AUX-LLVM-NEXT:  warning: '[[FILE]]': invalid SHT_GNU_verneed section with index 2: found a misaligned auxiliary entry at offset 0x11
+# BROKEN-AUX-LLVM-NEXT:      Name: @<corrupt>
+# BROKEN-AUX-LLVM-NEXT:    }
+# BROKEN-AUX-LLVM-NEXT:  ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

llvm/test/tools/llvm-readobj/ELF/versym-invalid.test

## A custom empty dynamic symbol table with a null entry.
   - Name:    .foo.dynsym
     Type:    SHT_DYNSYM
     Link:    .dynstr
     EntSize: 24
     Size:    24
 DynamicSymbols:
   - Name: foo
   - Name: bar
+
+## Version index in a SHT_GNU_versym section overflows the version map.
+## Check we report it when trying to dump dynamic symbols.
+
+# RUN: yaml2obj %s --docnum=8 -o %t8
+# RUN: llvm-readobj --dyn-syms %t8 2>&1 \
+# RUN:   | FileCheck -DFILE=%t8 --implicit-check-not=warning --check-prefix=VERSION-OVERFLOW-LLVM %s
+# RUN: llvm-readelf --dyn-syms %t8 2>&1 \
+# RUN:   | FileCheck -DFILE=%t8 --implicit-check-not=warning --check-prefix=VERSION-OVERFLOW-GNU %s
+
+# VERSION-OVERFLOW-LLVM:       DynamicSymbols [
+# VERSION-OVERFLOW-LLVM-EMPTY:
+# VERSION-OVERFLOW-LLVM-NEXT:  warning: '[[FILE]]': SHT_GNU_versym section refers to a version index 255 which is missing
+# VERSION-OVERFLOW-LLVM-NEXT:    Symbol {
+# VERSION-OVERFLOW-LLVM-NEXT:      Name: @<corrupt> (0)
+# VERSION-OVERFLOW-LLVM:       warning: '[[FILE]]': SHT_GNU_versym section refers to a version index 254 which is missing
+# VERSION-OVERFLOW-LLVM-NEXT:    Symbol {
+# VERSION-OVERFLOW-LLVM-NEXT:      Name: foo@<corrupt> (5)
+# VERSION-OVERFLOW-LLVM:         Symbol {
+# VERSION-OVERFLOW-LLVM-NEXT:      Name: bar@<corrupt> (1)
+
+# VERSION-OVERFLOW-GNU:       Symbol table '.dynsym' contains 3 entries:
+# VERSION-OVERFLOW-GNU-NEXT:   Num:    Value          Size Type    Bind   Vis       Ndx Name
+# VERSION-OVERFLOW-GNU-EMPTY:
+# VERSION-OVERFLOW-GNU-NEXT:  warning: '[[FILE]]': SHT_GNU_versym section refers to a version index 255 which is missing
+# VERSION-OVERFLOW-GNU-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND @<corrupt>
+# VERSION-OVERFLOW-GNU-EMPTY:
+# VERSION-OVERFLOW-GNU-NEXT:  warning: '[[FILE]]': SHT_GNU_versym section refers to a version index 254 which is missing
+# VERSION-OVERFLOW-GNU-NEXT:      1: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND foo@<corrupt>
+# VERSION-OVERFLOW-GNU-NEXT:      2: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND bar@<corrupt
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Entries: [ 0xFF, 0xFE, 0xFF ]
+DynamicSymbols:
+  - Name: foo
+  - Name: bar

llvm/tools/llvm-readobj/ELFDumper.cpp

private:
   void printMipsReginfo();
   void printMipsOptions();
 
   std::pair<const Elf_Phdr *, const Elf_Shdr *>
   findDynamic(const ELFFile<ELFT> *Obj);
   void loadDynamicTable(const ELFFile<ELFT> *Obj);
   void parseDynamicTable();
 
-  StringRef getSymbolVersion(const Elf_Sym *symb, bool &IsDefault) const;
-  void LoadVersionMap() const;
+  Expected<StringRef> getSymbolVersion(const Elf_Sym *symb,
+                                       bool &IsDefault) const;
+  Error LoadVersionMap() const;
 
   const object::ELFObjectFile<ELFT> *ObjF;
   DynRegionInfo DynRelRegion;
   DynRegionInfo DynRelaRegion;
   DynRegionInfo DynRelrRegion;
   DynRegionInfo DynPLTRelRegion;
   DynRegionInfo DynSymRegion;
   DynRegionInfo DynamicTable;
public:
   std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable,
                                 bool IsDynamic) const;
   Expected<unsigned> getSymbolSectionIndex(const Elf_Sym *Symbol,
                                            const Elf_Sym *FirstSym) const;
   Expected<StringRef> getSymbolSectionName(const Elf_Sym *Symbol,
                                            unsigned SectionIndex) const;
   Expected<std::string> getStaticSymbolName(uint32_t Index) const;
   std::string getDynamicString(uint64_t Value) const;
-  StringRef getSymbolVersionByIndex(uint32_t VersionSymbolIndex,
+  Expected<StringRef> getSymbolVersionByIndex(uint32_t VersionSymbolIndex,
                                               bool &IsDefault) const;
 
   void printSymbolsHelper(bool IsDynamic) const;
   void printDynamicEntry(raw_ostream &OS, uint64_t Type, uint64_t Value) const;
 
   const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
   const Elf_Shdr *getDotCGProfileSec() const { return DotCGProfileSec; }
   const Elf_Shdr *getDotAddrsigSec() const { return DotAddrsigSec; }
   ArrayRef<Elf_Word> getShndxTable() const { return ShndxTable; }
std::error_code createELFDumper(const object::ObjectFile *Obj,
   if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
     return createELFDumper(ELFObj, Writer, Result);
 
   return readobj_error::unsupported_obj_file_format;
 }
 
 } // end namespace llvm
 
-template <class ELFT> void ELFDumper<ELFT>::LoadVersionMap() const {
+template <class ELFT> Error ELFDumper<ELFT>::LoadVersionMap() const {
   // If there is no dynamic symtab or version table, there is nothing to do.
   if (!DynSymRegion.Addr || !SymbolVersionSection)
-    return;
+    return Error::success();
 
   // Has the VersionMap already been loaded?
   if (!VersionMap.empty())
-    return;
+    return Error::success();
 
   // The first two version indexes are reserved.
   // Index 0 is LOCAL, index 1 is GLOBAL.
   VersionMap.push_back(VersionEntry());
   VersionMap.push_back(VersionEntry());
 
   auto InsertEntry = [this](unsigned N, StringRef Version, bool IsVerdef) {
     if (N >= VersionMap.size())
       VersionMap.resize(N + 1);
     VersionMap[N] = {Version, IsVerdef};
   };
 
   if (SymbolVersionDefSection) {
     Expected<std::vector<VerDef>> Defs =
         this->getVersionDefinitions(SymbolVersionDefSection);
     if (!Defs)
-      reportError(Defs.takeError(), ObjF->getFileName());
+      return Defs.takeError();
     for (const VerDef &Def : *Defs)
       InsertEntry(Def.Ndx & ELF::VERSYM_VERSION, Def.Name, true);
   }
 
   if (SymbolVersionNeedSection) {
     Expected<std::vector<VerNeed>> Deps =
         this->getVersionDependencies(SymbolVersionNeedSection);
     if (!Deps)
-      reportError(Deps.takeError(), ObjF->getFileName());
+      return Deps.takeError();
     for (const VerNeed &Dep : *Deps)
       for (const VernAux &Aux : Dep.AuxV)
         InsertEntry(Aux.Other & ELF::VERSYM_VERSION, Aux.Name, false);
   }
+
+  return Error::success();
 }
 
 template <typename ELFT>
-StringRef ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym *Sym,
+Expected<StringRef> ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym *Sym,
                                                       bool &IsDefault) const {
   // This is a dynamic symbol. Look in the GNU symbol version table.
   if (!SymbolVersionSection) {
     // No version table.
     IsDefault = false;
     return "";
   }
 
   // Determine the position in the symbol table of this entry.
ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
 
   Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr);
   if (!NameOrErr)
     return NameOrErr.takeError();
   return maybeDemangle(*NameOrErr);
 }
 
 template <typename ELFT>
-StringRef ELFDumper<ELFT>::getSymbolVersionByIndex(uint32_t SymbolVersionIndex,
-                                                   bool &IsDefault) const {
+Expected<StringRef>
+ELFDumper<ELFT>::getSymbolVersionByIndex(uint32_t SymbolVersionIndex,
   size_t VersionIndex = SymbolVersionIndex & VERSYM_VERSION;
 
   // Special markers for unversioned symbols.
   if (VersionIndex == VER_NDX_LOCAL || VersionIndex == VER_NDX_GLOBAL) {
     IsDefault = false;
     return "";
   }
 
   // Lookup this symbol in the version table.
-  LoadVersionMap();
+  if (Error E = LoadVersionMap())
+    return std::move(E);
   if (VersionIndex >= VersionMap.size() || !VersionMap[VersionIndex])
-    reportError(createError("Invalid version entry"), ObjF->getFileName());
+    return createError("SHT_GNU_versym section refers to a version index " +
+                       Twine(VersionIndex) + " which is missing");
 
   const VersionEntry &Entry = *VersionMap[VersionIndex];
   if (Entry.IsVerDef)
     IsDefault = !(SymbolVersionIndex & VERSYM_HIDDEN);
   else
     IsDefault = false;
   return Entry.Name.c_str();
 }
if (SymbolName.empty() && Symbol->getType() == ELF::STT_SECTION) {
     }
     return *NameOrErr;
   }
 
   if (!IsDynamic)
     return SymbolName;
 
   bool IsDefault;
-  StringRef Version = getSymbolVersion(&*Symbol, IsDefault);
-  if (!Version.empty()) {
+  Expected<StringRef> VersionOrErr = getSymbolVersion(&*Symbol, IsDefault);
+  if (!VersionOrErr) {
+    ELFDumperStyle->reportUniqueWarning(VersionOrErr.takeError());
+    return SymbolName + "@<corrupt>";
+  }
+
+  if (!VersionOrErr->empty()) {
     SymbolName += (IsDefault ? "@@" : "@");
-    SymbolName += Version;
+    SymbolName += *VersionOrErr;
   }
   return SymbolName;
 }
 
 template <typename ELFT>
 Expected<unsigned>
 ELFDumper<ELFT>::getSymbolSectionIndex(const Elf_Sym *Symbol,
                                        const Elf_Sym *FirstSym) const {
void GNUStyle<ELFT>::printVersionSymbolSection(const ELFFile<ELFT> *Obj,
   Expected<ArrayRef<Elf_Versym>> VerTableOrErr =
       this->dumper()->getVersionTable(Sec, /*SymTab=*/nullptr,
                                       /*StrTab=*/nullptr);
   if (!VerTableOrErr) {
     this->reportUniqueWarning(VerTableOrErr.takeError());
     return;
   }
 
+  ArrayRef<Elf_Versym> VerTable = *VerTableOrErr;
+  std::vector<StringRef> Versions;
+  for (size_t I = 0, E = VerTable.size(); I < E; ++I) {
+    unsigned Ndx = VerTable[I].vs_index;
+    if (Ndx == VER_NDX_LOCAL || Ndx == VER_NDX_GLOBAL) {
+      Versions.emplace_back(Ndx == VER_NDX_LOCAL ? "*local*" : "*global*");
+      continue;
+    }
+
+    bool IsDefault;
+    Expected<StringRef> NameOrErr =
+        this->dumper()->getSymbolVersionByIndex(Ndx, IsDefault);
+    if (!NameOrErr || NameOrErr->empty()) {
+      if (!NameOrErr) {
+        unsigned SecNdx = Sec - &cantFail(Obj->sections()).front();
+        this->reportUniqueWarning(createError(
+            "unable to get a version for entry " + Twine(I) +
+            " of SHT_GNU_versym section with index " + Twine(SecNdx) + ": " +
+            toString(NameOrErr.takeError())));
+      }
+      Versions.emplace_back("<corrupt>");
+      continue;
+    }
+    Versions.emplace_back(*NameOrErr);
+  }
+
   // readelf prints 4 entries per line.
-  uint64_t Entries = VerTableOrErr->size();
+  uint64_t Entries = VerTable.size();
   for (uint64_t VersymRow = 0; VersymRow < Entries; VersymRow += 4) {
     OS << "  " << format_hex_no_prefix(VersymRow, 3) << ":";
-
     for (uint64_t I = 0; (I < 4) && (I + VersymRow) < Entries; ++I) {
-      unsigned Version = (*VerTableOrErr)[VersymRow + I].vs_index;
-      switch (Version) {
-      case 0:
-        OS << "   0 (*local*)    ";
-        break;
-      case 1:
-        OS << "   1 (*global*)   ";
-        break;
-      default:
-        bool IsDefault = true;
-        std::string VersionName =
-            this->dumper()->getSymbolVersionByIndex(Version, IsDefault);
-
-        if (!VersionName.empty())
-          VersionName = "(" + VersionName + ")";
-        else
-          VersionName = "(*invalid*)";
-
-        OS << format("%4x%c", Version & VERSYM_VERSION,
-                     Version & VERSYM_HIDDEN ? 'h' : ' ');
-        OS << left_justify(VersionName, 13);
-      }
+      unsigned Ndx = VerTable[VersymRow + I].vs_index;
+      OS << format("%4x%c", Ndx & VERSYM_VERSION,
+                   Ndx & VERSYM_HIDDEN ? 'h' : ' ');
+      OS << left_justify("(" + std::string(Versions[VersymRow + I]) + ")", 13);
     }
     OS << '\n';
   }
   OS << '\n';
 }
 
 static std::string versionFlagToString(unsigned Flags) {
   if (Flags == 0)