[llvm-readobj][llvm-readelf] - Refactor parsing of the SHT_GNU_versym section.

[grimar]

Summary

This introduce a new helper which is used to parse the SHT_GNU_versym section.
LLVM/GNU styles implementations now use it to share the logic.

[jhenderson]

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

16

25 -> 255

31

referenc -> reference

32

Delete the extra "table"

72

I'm not asking for a change, but I'm noting that this warning message is getting a bit silly in length! I don't have any better suggestion though without losing context.

95

Nit: missing full stop.

123

Here and elsewhere "... when a SHT_GNU_versym..."

130

What's the trailing "()" for here?

151

in the associated symbol table.

183

dynamic symbols -> dynamic symbol

llvm/tools/llvm-readobj/ELFDumper.cpp

373–374

// Returns the linked symbol table and associated string table for a given section.

378

ExpectedType should be an Elf_Word, I think.

451

symbols table -> symbol table

5924

Should this be for (size_t I = 0, S = Syms.size(); I < S; ++I)?

5928

true /* IsDynamic */ -> /*IsDynamic=*/true

[grimar]

• Addressed review comments.

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

72

Yeah, but this is a result of a multiple messages concatenations. It is kind of by design.

130

It usually contains a section name. E.g.:

Addr: 0000000000000000 Offset: 0x000040 Link: 4 (.dynsym)

Here the sh_link==0 hence we see no name. Doesn't seem to be a bug problem? (since having sh_link==0 is ubnormal).

llvm/tools/llvm-readobj/ELFDumper.cpp

378

Probably not. It is expected to accept an enum value which is unsigned:
(https://github.com/llvm-mirror/llvm/blob/master/include/llvm/BinaryFormat/ELF.h#L815)

enum : unsigned {
...
  SHT_DYNSYM = 11,                      // Symbol table.

5924

Done.

[jhenderson]

LGTM.

llvm/test/Object/invalid.test

FileHeader:
   Machine: EM_X86_64
 Sections:
   - Name: .strtab
     Type: SHT_STRTAB
     Content: ""
 Symbols:
   - Name: foo
 
-## Check that we report an error if SHT_GNU_versym has invalid
+## Check that we report a warning if SHT_GNU_versym has invalid
 ## sh_entsize value (3 instead of 2) when trying to access the entries.
 
 # RUN: yaml2obj %s --docnum=30 -o %t30
-# RUN: not llvm-readobj -V %t30 2>&1 | FileCheck -DFILE=%t30 --check-prefix=INVALID-VER-SHENTSIZE %s
+# RUN: llvm-readobj -V %t30 2>&1 | FileCheck -DFILE=%t30 --check-prefix=INVALID-VER-SHENTSIZE %s
 
-# INVALID-VER-SHENTSIZE: error: '[[FILE]]': section [index 1] has invalid sh_entsize: expected 2, but got 3
+# INVALID-VER-SHENTSIZE: warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has an invalid sh_entsize: 3
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_FREEBSD
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:    .gnu.version
     Type:    SHT_GNU_versym
     EntSize: 0x0000000000000003
     Entries: [ ]
+    Link:    .dynsym
 ## Needed to trigger creation of .dynsym.
 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL
 
 ## Check the case when e_shstrndx == SHN_XINDEX, but null section's sh_link contains
 ## the index of a section header string table that is larger than the number of the sections.
 

llvm/test/Object/multiple-sections.yaml

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -a --elf-cg-profile --addrsig %t.o | FileCheck %s
 
 # Test that multiple sections with the same type does not trigger an error.
 
 # CHECK: ElfHeader {
+# CHECK: VersionSymbols [
 # CHECK: VersionDefinitions [
 # CHECK: VersionRequirements [
 # CHECK: CGProfile [
 # CHECK: Addrsig [
 
 --- !ELF
 FileHeader:      
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:        
   - Name:            .symtab2
     Type:            SHT_SYMTAB
     Link:            .strtab
     Content:         ''
     EntSize:         24
   - Name:            .versym
     Type:            SHT_GNU_versym
-    Entries:         [ ]
+    Entries:         [ 0 ]
+    Link:            .dynsym
   - Name:            .versym2
     Type:            SHT_GNU_versym
-    Entries:         [ ]
+    Entries:         [ 0 ]
+    Link:            .dynsym
   - Name:            .verdef
     Type:            SHT_GNU_verdef
     Info:            0x0000000000000000
     Entries:
   - Name:            .verdef2
     Type:            SHT_GNU_verdef
     Info:            0x0000000000000000
     Entries:
Sections:
   - Name:            .llvm_addrsig
     Type:            SHT_LLVM_ADDRSIG
     Content:         ''
   - Name:            .llvm_addrsig2
     Type:            SHT_LLVM_ADDRSIG
     Content:         ''
 Symbols:         
   - Name:            f
+DynamicSymbols: []
 ...

llvm/test/tools/llvm-readobj/all.test

Sections:
   - Name: .data
     Type: SHT_PROGBITS
   - Name: .rela.data
     Type: SHT_REL
     Relocations:
   - Name:    .gnu.version
     Type:    SHT_GNU_versym
     Entries: [ 0 ]
+    Link:    .dynsym
   - Name:    .gnu.version_d
     Type:    SHT_GNU_verdef
     Info:    0x0
     Entries: []
   - Name: .gnu.version_r
     Type: SHT_GNU_verneed
     Info: 0x0
     Dependencies:
Sections:
       - Section: .dynamic
   - Type: PT_GNU_EH_FRAME
     Sections:
       - Section: .eh_frame_hdr
   - Type: PT_NOTE
     Sections:
       - Section: .note.gnu.build-id
 Symbols: []
+DynamicSymbols: []

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

 # RUN: not 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-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
 

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

 # GNU-NOLINK-NEXT:   0x0010:   Name: <corrupt>  Flags: none Version: 2
 
 # LLVM-NOLINK:      VersionSymbols [
 # LLVM-NOLINK:        Symbol {
 # LLVM-NOLINK-NEXT:     Version: 0
 # LLVM-NOLINK-NEXT:     Name:
 # LLVM-NOLINK-NEXT:   }
 # LLVM-NOLINK-NEXT:   Symbol {
+# LLVM-NOLINK-NEXT:     Version: 2
 # LLVM-NOLINK-EMPTY:
 # LLVM-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
-# LLVM-NOLINK-NEXT:     Version: 2
 # LLVM-NOLINK-NEXT:     Name: foo@<corrupt>
 # LLVM-NOLINK-NEXT:   }
 # LLVM-NOLINK-NEXT: ]
 
 # LLVM-NOLINK:      VersionRequirements [
 # LLVM-NOLINK-NEXT:   Dependency {
 # LLVM-NOLINK-NEXT:     Version: 1
 # LLVM-NOLINK-NEXT:     Count: 1
Sections:
   - Name:         .gnu.version_r
     Type:         SHT_GNU_verneed
     Flags:        [ SHF_ALLOC ]
     Info:         1
     Link:         .dynstr
     AddressAlign: 4
 ## The byte offset to the auxiliary entry is 0x11, i.e. it is not correctly aligned in memory.
     Content: "0100010001000000110000000000000000000000"
-DynamicSymbols:
-  - Name: foo
+DynamicSymbols: []
 
 ## Here we check that we can properly dump the case when a dependency file name
 ## and/or a dependency name string offset is equal to the string table size.
 ##
 ## We set the version dependency vn_file field to the offset of string 'foo' in
 ## the .dynstr, which is 1. We create a custom string table .mystrtab of size 1
 ## and link it with the .gnu.version_r section. For the vna_name we use the same trick.
 

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

+## Test how llvm-readobj/llvm-readelf tools handle invalid SHT_GNU_versym sections.
+
+## Check that we report a warning when sh_link references a non-existent section.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readelf -V %t1 2>&1 | FileCheck -DFILE=%t1 %s --check-prefix=GNU-INVALID-LINK
+# RUN: llvm-readobj -V %t1 2>&1 | FileCheck -DFILE=%t1 %s --check-prefix=LLVM-INVALID-LINK
+
+# GNU-INVALID-LINK:       Version symbols section '.gnu.version' contains 0 entries:
+# GNU-INVALID-LINK-EMPTY:
+# GNU-INVALID-LINK-NEXT:  warning: '[[FILE]]': invalid section linked to SHT_GNU_versym section with index 1: invalid section index: 255
+# GNU-INVALID-LINK-NEXT:   Addr: 0000000000000000  Offset: 0x000040  Link: 255 (<corrupt>)
+
+# LLVM-INVALID-LINK:       VersionSymbols [
+# LLVM-INVALID-LINK-EMPTY:
+# LLVM-INVALID-LINK-NEXT:  warning: '[[FILE]]': invalid section linked to SHT_GNU_versym section with index 1: invalid section index: 25
+# LLVM-INVALID-LINK-NEXT:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Link:    0xFF
+    Entries: [ ]
+
+## Check that we report a warning when the sh_link field of a SHT_GNU_versym section does not referenc
+## a dynamic symbol table table section.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-readelf -V %t2 2>&1 | FileCheck -DFILE=%t2 %s --check-prefix=INVALID-SYMBOL-TABLE-GNU
+# RUN: llvm-readobj -V %t2 2>&1 | FileCheck -DFILE=%t2 %s --check-prefix=INVALID-SYMBOL-TABLE-LLVM
+
+# INVALID-SYMBOL-TABLE-GNU:       Version symbols section '.gnu.version' contains 1 entries:
+# INVALID-SYMBOL-TABLE-GNU-NEXT:   Addr: 0000000000000000  Offset: 0x000040  Link: 0 ()
+# INVALID-SYMBOL-TABLE-GNU-EMPTY:
+# INVALID-SYMBOL-TABLE-GNU-NEXT:   warning: '[[FILE]]': invalid section linked to SHT_GNU_versym section with index 1: expected SHT_DYNSYM, but got SHT_NULL
+# INVALID-SYMBOL-TABLE-GNU-NEXT:   000:   0 (*local*)
+
+# INVALID-SYMBOL-TABLE-LLVM:       VersionSymbols [
+# INVALID-SYMBOL-TABLE-LLVM-EMPTY:
+# INVALID-SYMBOL-TABLE-LLVM-NEXT:  warning: '[[FILE]]': invalid section linked to SHT_GNU_versym section with index 1: expected SHT_DYNSYM, but got SHT_NULL
+# INVALID-SYMBOL-TABLE-LLVM-NEXT:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Link:    0x0
+    Entries: [ 0 ]
+
+## Check we report a warning when something is wrong with a string table linked to a symbol table that
+## is linked with SHT_GNU_versym. In this case we are unable to produce LLVM style output,
+## but GNU style is fine because it does not need that string table.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readelf -V %t3 2>&1 | FileCheck -DFILE=%t3 %s --check-prefix=INVALID-STRING-TABLE-GNU
+# RUN: llvm-readobj -V %t3 2>&1 | FileCheck -DFILE=%t3 %s --check-prefix=INVALID-STRING-TABLE-LLVM
+
+# INVALID-STRING-TABLE-GNU:       Version symbols section '.gnu.version' contains 1 entries:
+# INVALID-STRING-TABLE-GNU-NEXT:   Addr: 0000000000000000  Offset: 0x000040  Link: 5 (.dynsym)
+# INVALID-STRING-TABLE-GNU-EMPTY: 
+# INVALID-STRING-TABLE-GNU-NEXT:   warning: '[[FILE]]': can't get a string table for the symbol table linked to SHT_GNU_versym section with index 1: invalid string table linked to SHT_DYNSYM section with index 5: invalid sh_type for string table section [index 2]: expected SHT_STRTAB, but got SHT_NULL
+# INVALID-STRING-TABLE-GNU-NEXT:   000:   0 (*local*)
+
+# INVALID-STRING-TABLE-LLVM:       VersionSymbols [
+# INVALID-STRING-TABLE-LLVM-EMPTY:
+# INVALID-STRING-TABLE-LLVM-NEXT:  warning: '[[FILE]]': can't get a string table for the symbol table linked to SHT_GNU_versym section with index 1: invalid string table linked to SHT_DYNSYM section with index 5: invalid sh_type for string table section [index 2]: expected SHT_STRTAB, but got SHT_NULL
+# INVALID-STRING-TABLE-LLVM-NEXT:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Link:    .dynsym
+    Entries: [ 0 ]
+  - Name:    .dynstr
+    Type:    SHT_NULL
+DynamicSymbols: []
+
+## Check we report a warning when SHT_GNU_versym section is not correctly aligned in memory
+
+# RUN: yaml2obj --docnum=4 %s -o %t4
+# RUN: llvm-readelf -V %t4 2>&1 | FileCheck -DFILE=%t4 %s --check-prefix=MISALIGNED-GNU
+# RUN: llvm-readobj -V %t4 2>&1 | FileCheck -DFILE=%t4 %s --check-prefix=MISALIGNED-LLVM
+
+# MISALIGNED-GNU:       Version symbols section '.gnu.version' contains 0 entries:
+# MISALIGNED-GNU-NEXT:   Addr: 0000000000000000  Offset: 0x00ffff  Link: 0 ()
+# MISALIGNED-GNU-EMPTY:
+# MISALIGNED-GNU-NEXT:   warning: '[[FILE]]': the SHT_GNU_versym section with index 1 is misaligned
+
+# MISALIGNED-LLVM:       VersionSymbols [
+# MISALIGNED-LLVM-EMPTY:
+# MISALIGNED-LLVM-NEXT:   warning: '[[FILE]]': the SHT_GNU_versym section with index 1 is misaligned
+# MISALIGNED-LLVM-NEXT:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Entries: [ ]
+    ShOffset: 0xffff
+
+## Check we report a warning when SHT_GNU_versym section has an invalid entry size.
+
+# RUN: yaml2obj --docnum=5 %s -o %t5
+# RUN: llvm-readelf -V %t5 2>&1 | FileCheck -DFILE=%t5 %s --check-prefix=INVALID-ENT-SIZE-GNU
+# RUN: llvm-readobj -V %t5 2>&1 | FileCheck -DFILE=%t5 %s --check-prefix=INVALID-ENT-SIZE-LLVM
+
+# INVALID-ENT-SIZE-GNU:       Version symbols section '.gnu.version' contains 1 entries:
+# INVALID-ENT-SIZE-GNU-NEXT:   Addr: 0000000000000000  Offset: 0x000040  Link: 0 ()
+# INVALID-ENT-SIZE-GNU-EMPTY:
+# INVALID-ENT-SIZE-GNU-NEXT:  warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has an invalid sh_entsize: 3
+
+# INVALID-ENT-SIZE-LLVM:       VersionSymbols [
+# INVALID-ENT-SIZE-LLVM-EMPTY:
+# INVALID-ENT-SIZE-LLVM-NEXT:  warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has an invalid sh_entsize: 3
+# INVALID-ENT-SIZE-LLVM-NEXT:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Entries: [ 0 ]
+    EntSize: 3
+
+## Check we report a warning when the number of version entries does not match the number of symbols in the symbols table associated.
+
+# RUN: yaml2obj --docnum=6 %s -o %t6
+# RUN: llvm-readelf -V %t6 2>&1 | FileCheck -DFILE=%t6 %s --check-prefix=SYMBOLS-NUM-MISMATCH-GNU
+# RUN: llvm-readobj -V %t6 2>&1 | FileCheck -DFILE=%t6 %s --check-prefix=SYMBOLS-NUM-MISMATCH-LLVM
+
+# SYMBOLS-NUM-MISMATCH-GNU:       Version symbols section '.gnu.version' contains 2 entries:
+# SYMBOLS-NUM-MISMATCH-GNU-NEXT:   Addr: 0000000000000000  Offset: 0x000040  Link: 4 (.dynsym)
+# SYMBOLS-NUM-MISMATCH-GNU-EMPTY:
+# SYMBOLS-NUM-MISMATCH-GNU-NEXT:   warning: '[[FILE]]': SHT_GNU_versym section with index 1: the number of entries (2) does not match the number of symbols (3) in the symbols table with index 4
+# SYMBOLS-NUM-MISMATCH-GNU-NEXT:    000:   0 (*local*)       1 (*global*)
+
+# SYMBOLS-NUM-MISMATCH-LLVM:       VersionSymbols [
+# SYMBOLS-NUM-MISMATCH-LLVM-EMPTY:
+# SYMBOLS-NUM-MISMATCH-LLVM-NEXT:  warning: '[[FILE]]': SHT_GNU_versym section with index 1: the number of entries (2) does not match the number of symbols (3) in the symbols table with index 4
+# SYMBOLS-NUM-MISMATCH-LLVM-NEXT:  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Entries: [ 0, 1 ]
+    Link:   .dynsym
+DynamicSymbols:
+  - Name: foo
+  - Name: bar
+
+## Check we can dump a SHT_GNU_versym section when it is linked to a custom dynamic symbols
+## table that is not called ".dynsym".
+
+# RUN: yaml2obj --docnum=7 %s -o %t7
+# RUN: llvm-readelf -V %t7 2>&1 | FileCheck -DFILE=%t7 %s --check-prefix=CUSTOM-SYMTAB-GNU
+# RUN: llvm-readobj -V %t7 2>&1 | FileCheck -DFILE=%t7 %s --check-prefix=CUSTOM-SYMTAB-LLVM
+
+# CUSTOM-SYMTAB-GNU:      Version symbols section '.gnu.version' contains 1 entries:
+# CUSTOM-SYMTAB-GNU-NEXT:   Addr: 0000000000000000  Offset: 0x000040  Link: 2 (.foo.dynsym)
+# CUSTOM-SYMTAB-GNU-NEXT:    000:   0 (*local*)
+
+# CUSTOM-SYMTAB-LLVM:      VersionSymbols [
+# CUSTOM-SYMTAB-LLVM-NEXT:  Symbol {
+# CUSTOM-SYMTAB-LLVM-NEXT:    Version: 0
+# CUSTOM-SYMTAB-LLVM-NEXT:    Name:
+# CUSTOM-SYMTAB-LLVM-NEXT:  }
+# CUSTOM-SYMTAB-LLVM-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Link:    .foo.dynsym
+    Entries: [ 0 ]
+## 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

llvm/tools/llvm-readobj/ELFDumper.cpp

public:
   const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; }
   const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; }
   const DynRegionInfo &getDynRelrRegion() const { return DynRelrRegion; }
   const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; }
   const DynRegionInfo &getDynamicTableRegion() const { return DynamicTable; }
   const Elf_Hash *getHashTable() const { return HashTable; }
   const Elf_GnuHash *getGnuHashTable() const { return GnuHashTable; }
 
+  Expected<ArrayRef<Elf_Versym>> getVersionTable(const Elf_Shdr *Sec,
+                                                 ArrayRef<Elf_Sym> *SymTab,
+                                                 StringRef *StrTab) const;
   Expected<std::vector<VerDef>>
   getVersionDefinitions(const Elf_Shdr *Sec) const;
   Expected<std::vector<VerNeed>>
   getVersionDependencies(const Elf_Shdr *Sec) const;
 };
 
 template <class ELFT>
 static Expected<StringRef> getLinkAsStrtab(const ELFFile<ELFT> *Obj,
if (!StrTabOrErr)
     return createError("invalid string table linked to " +
                        object::getELFSectionTypeName(
                            Obj->getHeader()->e_machine, Sec->sh_type) +
                        " section with index " + Twine(SecNdx) + ": " +
                        toString(StrTabOrErr.takeError()));
   return *StrTabOrErr;
 }
 
+// For a given section returns a linked symbol table and
+// a string table associated.
+template <class ELFT>
+static Expected<std::pair<typename ELFT::SymRange, StringRef>>
+getLinkAsSymtab(const ELFFile<ELFT> *Obj, const typename ELFT::Shdr *Sec,
+                   unsigned SecNdx, unsigned ExpectedType) {
+  Expected<const typename ELFT::Shdr *> SymtabOrErr =
+      Obj->getSection(Sec->sh_link);
+  if (!SymtabOrErr)
+    return createError("invalid section linked to " +
+                       object::getELFSectionTypeName(
+                           Obj->getHeader()->e_machine, Sec->sh_type) +
+                       " section with index " + Twine(SecNdx) + ": " +
+                       toString(SymtabOrErr.takeError()));
+
+  if ((*SymtabOrErr)->sh_type != ExpectedType)
+    return createError(
+        "invalid section linked to " +
+        object::getELFSectionTypeName(Obj->getHeader()->e_machine,
+                                      Sec->sh_type) +
+        " section with index " + Twine(SecNdx) + ": expected " +
+        object::getELFSectionTypeName(Obj->getHeader()->e_machine,
+                                      ExpectedType) +
+        ", but got " +
+        object::getELFSectionTypeName(Obj->getHeader()->e_machine,
+                                      (*SymtabOrErr)->sh_type));
+
+  Expected<StringRef> StrTabOrErr =
+      getLinkAsStrtab(Obj, *SymtabOrErr, Sec->sh_link);
+  if (!StrTabOrErr)
+    return createError(
+        "can't get a string table for the symbol table linked to " +
+        object::getELFSectionTypeName(Obj->getHeader()->e_machine,
+                                      Sec->sh_type) +
+        " section with index " + Twine(SecNdx) + ": " +
+        toString(StrTabOrErr.takeError()));
+
+  Expected<typename ELFT::SymRange> SymsOrErr = Obj->symbols(*SymtabOrErr);
+  if (!SymsOrErr)
+    return createError(
+        "unable to read symbols from the symbol table with index " +
+        Twine(Sec->sh_link) + ": " + toString(SymsOrErr.takeError()));
+
+  return std::make_pair(*SymsOrErr, *StrTabOrErr);
+}
+
+template <class ELFT>
+Expected<ArrayRef<typename ELFT::Versym>>
+ELFDumper<ELFT>::getVersionTable(const Elf_Shdr *Sec, ArrayRef<Elf_Sym> *SymTab,
+                                 StringRef *StrTab) const {
+  assert((!SymTab && !StrTab) || (SymTab && StrTab));
+  const ELFFile<ELFT> *Obj = ObjF->getELFFile();
+  unsigned SecNdx = Sec - &cantFail(Obj->sections()).front();
+
+  if (uintptr_t(Obj->base() + Sec->sh_offset) % sizeof(uint16_t) != 0)
+    return createError("the SHT_GNU_versym section with index " +
+                       Twine(SecNdx) + " is misaligned");
+
+  Expected<ArrayRef<Elf_Versym>> VersionsOrErr =
+      Obj->template getSectionContentsAsArray<Elf_Versym>(Sec);
+  if (!VersionsOrErr)
+    return createError(
+        "cannot read content of SHT_GNU_versym section with index " +
+        Twine(SecNdx) + ": " + toString(VersionsOrErr.takeError()));
+
+  Expected<std::pair<ArrayRef<Elf_Sym>, StringRef>> SymTabOrErr =
+      getLinkAsSymtab(Obj, Sec, SecNdx, SHT_DYNSYM);
+  if (!SymTabOrErr) {
+    ELFDumperStyle->reportUniqueWarning(SymTabOrErr.takeError());
+    return *VersionsOrErr;
+  }
+
+  if (SymTabOrErr->first.size() != VersionsOrErr->size())
+    ELFDumperStyle->reportUniqueWarning(createError(
+        "SHT_GNU_versym section with index " + Twine(SecNdx) +
+        ": the number of entries (" + Twine(VersionsOrErr->size()) +
+        ") does not match the number of symbols (" +
+        Twine(SymTabOrErr->first.size()) +
+        ") in the symbols table with index " + Twine(Sec->sh_link)));
+
+  if (SymTab)
+    std::tie(*SymTab, *StrTab) = *SymTabOrErr;
+  return *VersionsOrErr;
+}
+
 template <class ELFT>
 Expected<std::vector<VerDef>>
 ELFDumper<ELFT>::getVersionDefinitions(const Elf_Shdr *Sec) const {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   unsigned SecNdx = Sec - &cantFail(Obj->sections()).front();
 
   Expected<StringRef> StrTabOrErr = getLinkAsStrtab(Obj, Sec, SecNdx);
   if (!StrTabOrErr)

 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printVersionSymbolSection(const ELFFile<ELFT> *Obj,
                                                const Elf_Shdr *Sec) {
   if (!Sec)
     return;
 
-  unsigned Entries = Sec->sh_size / sizeof(Elf_Versym);
-  printGNUVersionSectionProlog(Obj, Sec, "Version symbols", Entries);
-
-  const uint8_t *VersymBuf =
-      reinterpret_cast<const uint8_t *>(Obj->base() + Sec->sh_offset);
-  const ELFDumper<ELFT> *Dumper = this->dumper();
+  printGNUVersionSectionProlog(Obj, Sec, "Version symbols",
+                               Sec->sh_size / sizeof(Elf_Versym));
+  Expected<ArrayRef<Elf_Versym>> VerTableOrErr =
+      this->dumper()->getVersionTable(Sec, /*SymTab=*/nullptr,
+                                      /*StrTab=*/nullptr);
+  if (!VerTableOrErr) {
+    this->reportUniqueWarning(VerTableOrErr.takeError());
+    return;
+  }
 
   // readelf prints 4 entries per line.
+  uint64_t Entries = VerTableOrErr->size();
   for (uint64_t VersymRow = 0; VersymRow < Entries; VersymRow += 4) {
     OS << "  " << format_hex_no_prefix(VersymRow, 3) << ":";
 
-    for (uint64_t VersymIndex = 0;
-         (VersymIndex < 4) && (VersymIndex + VersymRow) < Entries;
-         ++VersymIndex) {
-      const Elf_Versym *Versym =
-          reinterpret_cast<const Elf_Versym *>(VersymBuf);
-      switch (Versym->vs_index) {
+    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 =
-            Dumper->getSymbolVersionByIndex(Versym->vs_index, IsDefault);
+            this->dumper()->getSymbolVersionByIndex(Version, IsDefault);
 
         if (!VersionName.empty())
           VersionName = "(" + VersionName + ")";
         else
           VersionName = "(*invalid*)";
 
-        OS << format("%4x%c", Versym->vs_index & VERSYM_VERSION,
-                     Versym->vs_index & VERSYM_HIDDEN ? 'h' : ' ');
+        OS << format("%4x%c", Version & VERSYM_VERSION,
+                     Version & VERSYM_HIDDEN ? 'h' : ' ');
         OS << left_justify(VersionName, 13);
       }
-      VersymBuf += sizeof(Elf_Versym);
     }
     OS << '\n';
   }
   OS << '\n';
 }
 
 static std::string versionFlagToString(unsigned Flags) {
   if (Flags == 0)

 
 template <class ELFT>
 void LLVMStyle<ELFT>::printVersionSymbolSection(const ELFFile<ELFT> *Obj,
                                                 const Elf_Shdr *Sec) {
   ListScope SS(W, "VersionSymbols");
   if (!Sec)
     return;
 
-  const uint8_t *VersymBuf =
-      reinterpret_cast<const uint8_t *>(Obj->base() + Sec->sh_offset);
-  const ELFDumper<ELFT> *Dumper = this->dumper();
-  StringRef StrTable = Dumper->getDynamicStringTable();
+  StringRef StrTable;
+  ArrayRef<Elf_Sym> Syms;
+  Expected<ArrayRef<Elf_Versym>> VerTableOrErr =
+      this->dumper()->getVersionTable(Sec, &Syms, &StrTable);
+  if (!VerTableOrErr) {
+    this->reportUniqueWarning(VerTableOrErr.takeError());
+    return;
+  }
 
-  // Same number of entries in the dynamic symbol table (DT_SYMTAB).
-  for (const Elf_Sym &Sym : Dumper->dynamic_symbols()) {
+  if (StrTable.empty() || Syms.empty() || Syms.size() != VerTableOrErr->size())
+    return;
+
+  for (size_t I = 0; I < Syms.size(); ++I) {
     DictScope S(W, "Symbol");
-    const Elf_Versym *Versym = reinterpret_cast<const Elf_Versym *>(VersymBuf);
-    std::string FullSymbolName =
-        Dumper->getFullSymbolName(&Sym, StrTable, true /* IsDynamic */);
-    W.printNumber("Version", Versym->vs_index & VERSYM_VERSION);
-    W.printString("Name", FullSymbolName);
-    VersymBuf += sizeof(Elf_Versym);
+    W.printNumber("Version", (*VerTableOrErr)[I].vs_index & VERSYM_VERSION);
+    W.printString("Name", this->dumper()->getFullSymbolName(
+                              &Syms[I], StrTable, true /* IsDynamic */));
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
                                                     const Elf_Shdr *Sec) {
   ListScope SD(W, "VersionDefinitions");
   if (!Sec)