[llvm-objdump] Add `Version References` dumper

[Higuoxing]

Summary

Add symbol version dumper for #30241

[Higuoxing]

[llvm-objdump] Add Version References dumper (PR30241)

formatted

[Higuoxing]

tools/llvm-objdump/ELFDump.cpp

294–314

Seems that these codes are redundant, can we simplify this?

[Higuoxing]

Updating D54697: [llvm-objdump] Add Version References dumper (PR30241)

Rename some variables

[Higuoxing]

Updating D54697: [llvm-objdump] Add Version References dumper (PR30241)

[jhenderson]

Could you add tests for the cases where a) there is no DT_VERNEEDNUM tag, and b) where it has a value of 0, please.

Could you also point me at some documentation describing the VerNeed structs etc.

test/tools/llvm-objdump/private-headers-symbol-version.test

9

Nit: Spurious blank line?

tools/llvm-objdump/ELFDump.cpp

162

printSymbolVersionRef -> printSymbolVersionRefs or printSymbolVersionReferences

164

Why not use using here?

171

d_val's type is different in 32 bit and 64-bit ELF, so this should be a type large enough to hold either version (i.e. uin64_t).

179–181

Does GNU objdump print the header if there is a DT_VERNEEDNUM tag with a value of 0? I feel like it would be reasonable to do so in our case.

187

You can use ELFT::Elf_Shdr here and elsewhere directly, and avoid the need for the typename.

I'm also not sure what "GNUVerDepSec" means, so that probably needs expanding a bit more (especially the "Dep" part).

195

Rather than having this big if statement, do

if (GnuVerDepSec != nullptr)
  return;

197–198

I'm trying to understand the structure of the VerNeed stuff. Is it a variable size block, and hence the need to iterate over bytes rather than struct instances?

Also, prefer reinterpret_cast instead of C-style, here and elsewhere in this function.

202

unsigned -> uint64_t to match my earlier comment.

Maybe worth replacing I with VerNeedIndex or something, and J below similarly, just to disambiguate them a bit more.

208

unsigned is probably the wrong type. Use the type of vn_cnt or just the largest uint*_t type needed.

294–314

I'm not sure I follow what you mean?

tools/llvm-objdump/llvm-objdump.cpp

2224

put the return on a new line, since printELFSymbolVersionRef doesn't return anything.

[Higuoxing]

In D54697#1304044, @jhenderson wrote:

Could you add tests for the cases where a) there is no DT_VERNEEDNUM tag, and b) where it has a value of 0, please.

Sure, I will add them

Could you also point me at some documentation describing the VerNeed structs etc.

https://refspecs.linuxfoundation.org/LSB_2.1.0/LSB-Core-generic/LSB-Core-generic/symverdefs.html
https://refspecs.linuxfoundation.org/LSB_2.1.0/LSB-Core-generic/LSB-Core-generic/symverrqmts.html

PS. Thanks for your kind reviewing, I will cover them one by one :)

[Higuoxing]

Updating D54697: [llvm-objdump] Add Version References dumper (PR30241)
Partially refactored some codes

[Higuoxing]

Updating D54697: [llvm-objdump] Add Version References dumper (PR30241)

delete #include "llvm/Object/ELFTypes.h"

[Higuoxing]

tools/llvm-objdump/ELFDump.cpp

164

I use typedef here, just like what they do in other functions.

294–314

I mean, these functions are similar (they all cast ELF<32|64><BE|LE> to ElfObj), can we simplify these functions?

printELFFileHeader
printELFDynamicSection
printELFSymbolVersionRefs

[Higuoxing]

tools/llvm-objdump/ELFDump.cpp

187

I change it to VerNeedSec

[Higuoxing]

I want to use YAML2Obj to generate the test files, but there are something wrong with that tool. So, I have to write a patch for that. This patch have to be suspended for some time, until that one landed ...

[Higuoxing]

Add dumper for symbol version definitions.

[jhenderson]

Hi @Higuoxing. Is this ready for review again? It is currently marked as WIP/changes planned.

[Higuoxing]

In D54697#1332797, @jhenderson wrote:

Hi @Higuoxing. Is this ready for review again? It is currently marked as WIP/changes planned.

This works, but there are some little refactors needed. Besides, I cannot give enough test cases right now ...

[Higuoxing]

(WIP) This is a backup.

[Higuoxing]

Sorry for not responding on this patch for 2 months. Could anyone review this? Thanks a lot.

[Higuoxing]

update

[Higuoxing]

Updating D54697: [llvm-objdump] Add Version References dumper

[jhenderson]

I'll take a look at this next week, if nobody else does in the meantime.

[Higuoxing]

Updating D54697: [llvm-objdump] Add Version References dumper

[grimar]

I did not see this patch earlier and so worked on something very close to this for some time. I stopped my work
and shared the ideas/code I have in the comments here :)

tools/llvm-objdump/ELFDump.cpp

179

If you move this loop to printSymbolVersionInfo and change the printSymbolVersionDependency signature
to printSymbolVersionDependency(const typename ELFT::Shdr &Shdr, ArrayRef<uint8_t> Contents)
that probably will be better, because for printSymbolVersionDefinition implementation you would also
need to iterate over all sections and take the content. That can be done in a single place.

I mean the code in printSymbolVersionInfo can be like:

template <class ELFT>
static void printSymbolVersionInfo(const ELFFile<ELFT> *Elf) {
  typedef typename ELFT::Shdr Elf_Shdr;

  auto SecOrErr = Elf->sections();
  if (!SecOrErr)
    report_fatal_error(errorToErrorCode(SecOrErr.takeError()).message());

  for (const Elf_Shdr &Shdr : *SecOrErr) {
    if (Shdr.sh_type != ELF::SHT_GNU_verdef &&
        Shdr.sh_type != ELF::SHT_GNU_verneed)
      continue;

    auto ContentsOrErr = Elf->getSectionContents(&Shdr);
    if (!ContentsOrErr)
      report_fatal_error(errorToErrorCode(ContentsOrErr.takeError()).message());

    if (Shdr.sh_type == ELF::SHT_GNU_verdef)
      printSymbolVersionDefinition<ELFT>(Shdr, *ContentsOrErr);
    else if (Shdr.sh_type == ELF::SHT_GNU_verneed)
      printSymbolVersionDependency<ELFT>(Shdr, *ContentsOrErr);
  }
}

185

Actually, you do not need this I think.
You can simply iterate over Elf_Verneed entries until vn_next != 0.

191

I would use getSectionContents (see sample above), because it does more checks.

207

The same, I think, you can simply iterate until vna_next != 0.

[grimar]

test/tools/llvm-objdump/verneed-wrong-info.test

5 ↗

(On Diff #187942)

The case looks simple, so I would remove the link and just describe it.
i.e. something like:

"We have a SHT_GNU_verneed section with a broken sh_info field that says the section
contains more entries that it actually have"

[Higuoxing]

tools/llvm-objdump/ELFDump.cpp

179

Oh, thank you @grimar , I am wandering that whether the dumping order of verneed and verdef sections is important? Sometimes, the verneed section is before verdef and sometimes verneed is after verdef.

[Higuoxing]

I found that elf2yaml codes could be used here, so I just do some copy and paste work.

I don't know if we need some checks on sh_info field and DT_VERNEED, just like what gnu-objdump do.

[grimar]

test/tools/llvm-objdump/verneed-wrong-info.test

5 ↗

(On Diff #188074)

that->than, have->has (sorry, did these mistakes/mistypes when suggested it).

I hope @jhenderson will re-check it though :)

tools/llvm-objdump/ELFDump.cpp

179

I did not notice that, but if so then I guess GNU objdump just print them in the same order as they are in a section table probably.
i.e. the same is done in this patch.

194

Shouldn't you be able to get Filename from Elf?

204

If you're not going to implement SHT_GNU_verneed in this patch then I think you should
get rid of Shdr.sh_type != ELF::SHT_GNU_verneed.

[grimar]

tools/llvm-objdump/ELFDump.cpp

204

I meant "if you're not going to implement ELF::SHT_GNU_verdef" of course..

[Higuoxing]

Updating D54697: [llvm-objdump] Add Version References dumper

[Higuoxing]

tools/llvm-objdump/ELFDump.cpp

194

Sorry, I cannot find a getFileName() method in Elf or something else like that.

204

Thanks for reviewing, I would like to implement it in next patch :)

[grimar]

This looks fine, thanks! (with a minor nit addressed)
Let's see if anyone else has comments.

tools/llvm-objdump/ELFDump.cpp

194

Yeah, I see now. Nevermind, I looked at the wrong class I think.

217

You do not need this if, this condition is always true now.

[jhenderson]

test/tools/llvm-objdump/verneed-wrong-info.test

5 ↗

(On Diff #188074)

Looks good to me here :)

tools/llvm-objdump/ELFDump.cpp

183

Use PRIu16, not "u" here.

217

You don't need this if as the early continue above means that this if will always be true.

294–314

You're welcome to try some sort of refactor, but do it in another patch.

[Higuoxing]

Updating D54697: [llvm-objdump] Add Version References dumper

[Higuoxing]

Thanks a lot!

[jhenderson]

LGTM, but please wait for @grimar to confirm he is happy.

[grimar]

LGTM.

include/llvm/ObjectYAML/ELFYAML.h

 };
 
 struct Section {
   enum class SectionKind {
     Group,
     RawContent,
     Relocation,
     NoBits,
+    VersionDef,
+    VersionNeed,
     MipsABIFlags
   };
   SectionKind Kind;
   StringRef Name;
   ELF_SHT Type;
   ELF_SHF Flags;
   llvm::yaml::Hex64 Address;
   StringRef Link;
   StringRef Info;
   llvm::yaml::Hex64 AddressAlign;
   Optional<llvm::yaml::Hex64> EntSize;
 
   Section(SectionKind Kind) : Kind(Kind) {}
   virtual ~Section();
 };
+
 struct RawContentSection : Section {
   yaml::BinaryRef Content;
   llvm::yaml::Hex64 Size;
 
   RawContentSection() : Section(SectionKind::RawContent) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::RawContent;
struct RelocationSection : Section {
 
   RelocationSection() : Section(SectionKind::Relocation) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::Relocation;
   }
 };
 
+struct VersionDefParent {
+  llvm::yaml::Hex64 Name;
+};
+
+struct VersionDef {
+  int32_t Revision;
+  llvm::yaml::Hex32 Flags;
+  llvm::yaml::Hex32 Index;
+  llvm::yaml::Hex64 Hash;
+  llvm::yaml::Hex64 Name;
+  std::vector<VersionDefParent> Parents;
+};
+
+// Represents .gnu.version_d
+struct VersionDefSection : Section {
+  std::vector<VersionDef> VersionDefs;
+
+  VersionDefSection() : Section(SectionKind::VersionDef) {}
+
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::VersionDef;
+  }
+};
+
+struct VersionNeedAux {
+  llvm::yaml::Hex64 Hash;
+  llvm::yaml::Hex32 Flags;
+  llvm::yaml::Hex32 Other;
+  llvm::yaml::Hex64 Name;
+};
+
+struct VersionNeed {
+  int32_t Version;
+  llvm::yaml::Hex64 File;
+  std::vector<VersionNeedAux> Auxiliaries;
+};
+
+// Represents .gnu.version_r section
+struct VersionNeedSection : Section {
+  std::vector<VersionNeed> VersionNeeds;
+
+  VersionNeedSection() : Section(SectionKind::VersionNeed) {}
+
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::VersionNeed;
+  }
+};
+
 // Represents .MIPS.abiflags section
 struct MipsABIFlags : Section {
   llvm::yaml::Hex16 Version;
   MIPS_ISA ISALevel;
   llvm::yaml::Hex8 ISARevision;
   MIPS_AFL_REG GPRSize;
   MIPS_AFL_REG CPR1Size;
   MIPS_AFL_REG CPR2Size;

 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VersionDef)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VersionDefParent)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VersionNeed)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VersionNeedAux)
 
 namespace llvm {
 namespace yaml {
 
 template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
   static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
 };

 template <> struct MappingTraits<ELFYAML::SectionOrType> {
   static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
 };
 
 template <> struct MappingTraits<ELFYAML::SectionName> {
   static void mapping(IO &IO, ELFYAML::SectionName &sectionName);
 };
 
+template <>
+struct MappingTraits<ELFYAML::VersionDef> {
+  static void mapping(IO &IO, ELFYAML::VersionDef &VDef);
+};
+
+template <>
+struct MappingTraits<ELFYAML::VersionDefParent> {
+  static void mapping(IO &IO, ELFYAML::VersionDefParent &VDefParent);
+};
+
+template <>
+struct MappingTraits<ELFYAML::VersionNeed> {
+  static void mapping(IO &IO, ELFYAML::VersionNeed &VNeed);
+};
+
+template <>
+struct MappingTraits<ELFYAML::VersionNeedAux> {
+  static void mapping(IO &IO, ELFYAML::VersionNeedAux &VNeedAux);
+};
+
 } // end namespace yaml
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_ELFYAML_H

lib/ObjectYAML/ELFYAML.cpp

void MappingTraits<ELFYAML::SectionOrType>::mapping(
   IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
 }
 
 void MappingTraits<ELFYAML::SectionName>::mapping(
     IO &IO, ELFYAML::SectionName &sectionName) {
   IO.mapRequired("Section", sectionName.Section);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::VersionDefSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapRequired("VersionDefs", Section.VersionDefs);
+}
+
+static void sectionMapping(IO &IO, ELFYAML::VersionNeedSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapRequired("VersionNeeds", Section.VersionNeeds);
+}
+
 static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Version", Section.Version, Hex16(0));
   IO.mapRequired("ISA", Section.ISALevel);
   IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
   IO.mapOptional("ISAExtension", Section.ISAExtension,
                  ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
   IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
if (!IO.outputting())
       Section.reset(new ELFYAML::Group());
     groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
     break;
   case ELF::SHT_NOBITS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::NoBitsSection());
     sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
     break;
+  case ELF::SHT_GNU_verdef:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::VersionDefSection());
+    sectionMapping(IO, *cast<ELFYAML::VersionDefSection>(Section.get()));
+    break;
+  case ELF::SHT_GNU_verneed:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::VersionNeedSection());
+    sectionMapping(IO, *cast<ELFYAML::VersionNeedSection>(Section.get()));
+    break;
   case ELF::SHT_MIPS_ABIFLAGS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::MipsABIFlags());
     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
     break;
   default:
     if (!IO.outputting())
       Section.reset(new ELFYAML::RawContentSection());
if (Object->Header.Machine == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
     IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
     IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
   } else
     IO.mapRequired("Type", Rel.Type);
 
   IO.mapOptional("Addend", Rel.Addend, (int64_t)0);
 }
 
+void MappingTraits<ELFYAML::VersionDef>::mapping(IO &IO,
+                                                 ELFYAML::VersionDef &VDef) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapRequired("Revision", VDef.Revision);
+  IO.mapRequired("Flags", VDef.Flags);
+  IO.mapRequired("Index", VDef.Index);
+  IO.mapRequired("Hash", VDef.Hash);
+  IO.mapRequired("Name", VDef.Name);
+  IO.mapOptional("Parents", VDef.Parents);
+}
+
+void MappingTraits<ELFYAML::VersionDefParent>::mapping(
+    IO &IO, ELFYAML::VersionDefParent &VDefParent) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapRequired("Name", VDefParent.Name);
+}
+
+void MappingTraits<ELFYAML::VersionNeed>::mapping(IO &IO,
+                                                  ELFYAML::VersionNeed &VNeed) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapRequired("Version", VNeed.Version);
+  IO.mapRequired("File", VNeed.File);
+  IO.mapRequired("Auxiliaries", VNeed.Auxiliaries);
+}
+
+void MappingTraits<ELFYAML::VersionNeedAux>::mapping(
+    IO &IO, ELFYAML::VersionNeedAux &VNeedAux) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapRequired("Hash", VNeedAux.Hash);
+  IO.mapRequired("Flags", VNeedAux.Flags);
+  IO.mapRequired("Other", VNeedAux.Other);
+  IO.mapRequired("Name", VNeedAux.Name);
+}
+
 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   assert(!IO.getContext() && "The IO context is initialized already");
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Sections);
   IO.mapOptional("Symbols", Object.Symbols);

test/tools/llvm-objdump/private-headers-symbol-version.test

+# RUN: llvm-objdump -p %p/Inputs/private-headers-x86_64.elf | FileCheck %s
+
+CHECK:      Version References:
+CHECK-NEXT:   required from libstdc++.so.6:
+CHECK-NEXT:     0x08922974 0x00 0x03 GLIBCXX_3.4
+CHECK-NEXT:   required from libc.so.6:
+CHECK-NEXT:     0x09691a75 0x00 0x02 GLIBC_2.2.5

test/tools/yaml2obj/symbol-version-section.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj -V %t | FileCheck %s
+
+# CHECK:       SHT_GNU_verdef {
+# CHECK-NEXT:    Definition {
+# CHECK-NEXT:      Version: 2
+# CHECK-NEXT:      Flags: Base (0x1)
+# CHECK-NEXT:      Index: 2
+# CHECK-NEXT:      Hash: 4660
+# CHECK-NEXT:      Name: foo
+# CHECK-NEXT:      Predecessor: VERSION1
+# CHECK-NEXT:    }
+# CHECK-NEXT:    Definition {
+# CHECK-NEXT:      Version: 1
+# CHECK-NEXT:      Flags: 0x0
+# CHECK-NEXT:      Index: 3
+# CHECK-NEXT:      Hash: 17185
+# CHECK-NEXT:      Name: bar
+# CHECK-NEXT:    }
+# CHECK-NEXT:  }
+
+# CHECK:       SHT_GNU_verneed {
+# CHECK-NEXT:    Dependency {
+# CHECK-NEXT:      Version: 2
+# CHECK-NEXT:      Count: 1
+# CHECK-NEXT:      FileName: libfoo.so.0
+# CHECK-NEXT:      Entry {
+# CHECK-NEXT:        Hash: 6
+# CHECK-NEXT:        Flags: 0x0
+# CHECK-NEXT:        Index: 0
+# CHECK-NEXT:        Name: GLIBFOO_0.0.0
+# CHECK-NEXT:      }
+# CHECK-NEXT:    }
+# CHECK-NEXT:    Dependency {
+# CHECK-NEXT:      Version: 1
+# CHECK-NEXT:      Count: 2
+# CHECK-NEXT:      FileName: libbar.so.0
+# CHECK-NEXT:      Entry {
+# CHECK-NEXT:        Hash: 74565
+# CHECK-NEXT:        Flags: Base (0x1)
+# CHECK-NEXT:        Index: 1
+# CHECK-NEXT:        Name: GLIBBAR_0.0.0
+# CHECK-NEXT:      }
+# CHECK-NEXT:      Entry {
+# CHECK-NEXT:        Hash: 344865
+# CHECK-NEXT:        Flags: Weak (0x2)
+# CHECK-NEXT:        Index: 2
+# CHECK-NEXT:        Name: GLIBFOO_0.0.0
+# CHECK-NEXT:      }
+# CHECK-NEXT:    }
+# CHECK-NEXT:  }
+
+!ELF
+FileHeader:
+  Class:             ELFCLASS64
+  Data:              ELFDATA2LSB
+  Type:              ET_REL
+  Machine:           EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Content:         006c6962666f6f2e736f2e30006c69626261722e736f2e3000474c4942464f4f5f302e302e3000474c49424241525f302e302e300056455253494f4e3100666f6f0062617200
+    # Content:       "libfoo.so.0 libbar.so.0 GLIBFOO_0.0.0 GLIBBAR_0.0.0 VERSION1 foo  bar"
+    # Offset:         0x01        0x0d        0x19          0x27          0x35     0x3e 0x42
+  - Name:            .gnu.version_d
+    Type:            SHT_GNU_verdef
+    Flags:           [ SHF_ALLOC ]
+    Link:            .dynstr
+    VersionDefs:
+      - Revision:    2
+        Flags:       0x01
+        Index:       0x02
+        Hash:        0x1234
+        Name:        0x3e
+        Parents:
+          - Name:    0x35
+      - Revision:    1
+        Flags:       0x00
+        Index:       0x03
+        Hash:        0x4321
+        Name:        0x42
+  - Name:            .gnu.version_r
+    Type:            SHT_GNU_verneed
+    Flags:           [ SHF_ALLOC ]
+    Link:            .dynstr
+    AddressAlign:    0x0510
+    VersionNeeds:
+      - Version:     2
+        File:        0x01       # libfoo.so.0
+        Auxiliaries:
+          - Hash:    0x06
+            Name:    0x19       # GLIBFOO_0.0.0
+            Flags:   0x00
+            Other:   0x00
+      - Version:     1
+        File:        0x0d       # libbar.so.0
+        Auxiliaries:
+          - Hash:    0x012345
+            Name:    0x27       # GLIBBAR_0.0.0
+            Flags:   0x01
+            Other:   0x01
+          - Hash:    0x054321
+            Name:    0x19       # GLIBFOO_0.0.0
+            Flags:   0x02
+            Other:   0x02
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    Link:            .dynstr
+    Content:         0100000000000000010000000000000001000000000000000d000000000000000C00000000000000A0060000000000000D000000000000002409000000000000FDFFFF6F000000000200000000000000FFFFFF6F000000000200000000000000FEFFFF6F0000000010050000000000000000000000000000000000000000000000000000000000000000000000000000
+ProgramHeaders:
+  - Type: PT_DYNAMIC
+    Flags: [ PF_W, PF_R ]
+    VAddr: 0xAAAA1000
+    PAddr: 0xFFFF1000
+    Sections:
+      - Section: .dynamic

tools/llvm-objdump/ELFDump.cpp

if (Dyn.d_tag == ELF::DT_NEEDED) {
         outs() << (Data + Dyn.d_un.d_val) << "\n";
         continue;
       }
       warn(errorToErrorCode(StrTabOrErr.takeError()).message());
       consumeError(StrTabOrErr.takeError());
     }
     outs() << format(Fmt, (uint64_t)Dyn.d_un.d_val);
   }
+  outs() << "\n";
 }
 
 template <class ELFT> void printProgramHeaders(const ELFFile<ELFT> *o) {
   typedef ELFFile<ELFT> ELFO;
   outs() << "Program Header:\n";
   auto ProgramHeaderOrError = o->program_headers();
   if (!ProgramHeaderOrError)
     report_fatal_error(
outs() << "off    " << format(Fmt, (uint64_t)Phdr.p_offset) << "vaddr "
            << "memsz " << format(Fmt, (uint64_t)Phdr.p_memsz) << "flags "
            << ((Phdr.p_flags & ELF::PF_R) ? "r" : "-")
            << ((Phdr.p_flags & ELF::PF_W) ? "w" : "-")
            << ((Phdr.p_flags & ELF::PF_X) ? "x" : "-") << "\n";
   }
   outs() << "\n";
 }
 
+template <class ELFT>
+void printSymbolVersionDefinition(const ELFFile<ELFT> *Elf,
+                                  StringRef Filename) {
+  typedef ELFFile<ELFT> ELFO;
+  typedef typename ELFO::Elf_Shdr Elf_Shdr;
+  typedef typename ELFO::Elf_Verdef Elf_Verdef;
+  typedef typename ELFO::Elf_Verdaux Elf_Verdaux;
+
+  auto SectionsOrError = Elf->sections();
+  if (!SectionsOrError)
+    report_error(Filename, SectionsOrError.takeError());
+
+  const Elf_Shdr *VDefSec = nullptr;
+  for (const Elf_Shdr &Sec : *SectionsOrError) {
+    if (Sec.sh_type == ELF::SHT_GNU_verdef) {
+      VDefSec = &Sec;
+      break;
+    }
+  }
+
+  if (VDefSec == nullptr)
+    return;
+
+  outs() << "Version definitions:\n";
+
+  // we use sh_info to determine the entry of SHT_GNU_verdef.
+  if (VDefSec->sh_info == 0)
+    report_error(Filename, createError(".gnu.version_d invalid entry"));
+
+  const auto *VDef = reinterpret_cast<const char *>(Elf->base() + VDefSec->sh_offset);
+
+  auto StrTabOrError = Elf->getSection(VDefSec->sh_link);
+  if (!StrTabOrError)
+    report_error(Filename, StrTabOrError.takeError());
+  const Elf_Shdr *StrTab = *StrTabOrError;
+
+  for (uint64_t VDefIndex = 0; VDefIndex < VDefSec->sh_info; ++VDefIndex) {
+    const auto *Def = reinterpret_cast<const Elf_Verdef *>(VDef);
+    outs() << VDefIndex + 1 << ' '
+           << format("0x%02" PRIx32 " ", (uint32_t)Def->vd_flags)
+           << format("0x%08" PRIx64 " ", (uint64_t)Def->vd_hash);
+    const auto *VDefAux = VDef + Def->vd_aux;
+    for (uint32_t VDefAuxIndex = 0; VDefAuxIndex < Def->vd_cnt; ++ VDefAuxIndex) {
+      const auto *Aux = reinterpret_cast<const Elf_Verdaux *>(VDefAux);
+      // Head of the Elf_Verdaux array is the name of the symbol defined in Elf_Verdef
+      outs() << ((VDefAuxIndex == 0) ? "" : "        ");
+      outs() << StringRef((const char *)Elf->base() + StrTab->sh_offset + Aux->vda_name)
+             << '\n';
+      VDefAux += Aux->vda_next;
+    }
+    VDef += Def->vd_next;
+  }
+  outs() << '\n';
+}
+
+template <class ELFT>
+void printSymbolVersionDependency(const ELFFile<ELFT> *Elf,
+                                  StringRef Filename) {
+  typedef ELFFile<ELFT> ELFO;
+  typedef typename ELFO::Elf_Shdr Elf_Shdr;
+  typedef typename ELFO::Elf_Verneed Elf_Verneed;
+  typedef typename ELFO::Elf_Vernaux Elf_Vernaux;
+
+  auto SectionsOrError = Elf->sections();
+  if (!SectionsOrError)
+    report_error(Filename, SectionsOrError.takeError());
+
+  const Elf_Shdr *VNeedSec = nullptr;
+  for (const Elf_Shdr &Sec : *SectionsOrError) {
+    if (Sec.sh_type == ELF::SHT_GNU_verneed) {
+      VNeedSec = &Sec;
+      break;
+    }
+  }
+
+  if (VNeedSec == nullptr)
+    return;
+
+  outs() << "Version References:\n";
+
+  // we use sh_info to determine the entry of SHT_GNU_verneed.
+  if (VNeedSec->sh_info == 0)
+    report_error(Filename, createError(".gnu.version_r invalid entry"));
+
+  const auto *VNeed =
+      reinterpret_cast<const uint8_t *>(Elf->base() + VNeedSec->sh_offset);
+
+  auto StrTabOrError = Elf->getSection(VNeedSec->sh_link);
+  if (!StrTabOrError)
+    report_error(Filename, StrTabOrError.takeError());
+  const Elf_Shdr *StrTab = *StrTabOrError;
+
+  for (uint64_t VNeedIndex = 0; VNeedIndex < VNeedSec->sh_info; ++VNeedIndex) {
+    const auto *Need = reinterpret_cast<const Elf_Verneed *>(VNeed);
+    outs() << "  required from "
+           << StringRef((const char *)Elf->base() + StrTab->sh_offset +
+                        Need->vn_file)
+           << ":\n";
+    const auto *VNeedAux = VNeed + Need->vn_aux;
+    for (uint32_t VNeedAuxIndex = 0; VNeedAuxIndex < Need->vn_cnt;
+         ++VNeedAuxIndex) {
+      const auto *Aux = reinterpret_cast<const Elf_Vernaux *>(VNeedAux);
+      outs() << "    "
+             << format("0x%08" PRIx64 " ", (uint64_t)Aux->vna_hash)
+             << format("0x%02" PRIx32 " ", (uint32_t)Aux->vna_flags)
+             << format("0x%02" PRIx32 " ", (uint32_t)Aux->vna_other)
+             << StringRef((const char *)(Elf->base() + StrTab->sh_offset +
+                                         Aux->vna_name))
+             << "\n";
+      VNeedAux += Aux->vna_next;
+    }
+    VNeed += Need->vn_next;
+  }
+  outs() << "\n";
+}
+
+template <class ELFT>
+void printSymbolVersionInfo(const ELFFile<ELFT> *Elf, StringRef Filename) {
+  printSymbolVersionDefinition(Elf, Filename);
+  printSymbolVersionDependency(Elf, Filename);
+}
+
 void llvm::printELFFileHeader(const object::ObjectFile *Obj) {
   if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
     printProgramHeaders(ELFObj->getELFFile());
   else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
     printProgramHeaders(ELFObj->getELFFile());
   else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
     printProgramHeaders(ELFObj->getELFFile());
   else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
     printProgramHeaders(ELFObj->getELFFile());
 }
 
 void llvm::printELFDynamicSection(const object::ObjectFile *Obj) {
   if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
     printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
   else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
     printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
   else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
     printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
   else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
     printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
 }
+
+void llvm::printELFSymbolVersionInfo(const object::ObjectFile *Obj) {
+  if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
+    printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+  else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
+    printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+  else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
+    printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+  else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
+    printSymbolVersionInfo(ELFObj->getELFFile(), Obj->getFileName());
+}

tools/llvm-objdump/llvm-objdump.h

 void printMachOUnwindInfo(const object::MachOObjectFile* o);
 void printMachOExportsTrie(const object::MachOObjectFile* o);
 void printMachORebaseTable(object::MachOObjectFile* o);
 void printMachOBindTable(object::MachOObjectFile* o);
 void printMachOLazyBindTable(object::MachOObjectFile* o);
 void printMachOWeakBindTable(object::MachOObjectFile* o);
 void printELFFileHeader(const object::ObjectFile *o);
 void printELFDynamicSection(const object::ObjectFile *Obj);
+void printELFSymbolVersionInfo(const object::ObjectFile *Obj);
 void printCOFFFileHeader(const object::ObjectFile *o);
 void printCOFFSymbolTable(const object::COFFImportFile *i);
 void printCOFFSymbolTable(const object::COFFObjectFile *o);
 void printMachOFileHeader(const object::ObjectFile *o);
 void printMachOLoadCommands(const object::ObjectFile *o);
 void printWasmFileHeader(const object::ObjectFile *o);
 void printExportsTrie(const object::ObjectFile *o);
 void printRebaseTable(object::ObjectFile *o);

tools/llvm-objdump/llvm-objdump.cpp

FaultMapParser FMP(FaultMapContents.bytes_begin(),
                      FaultMapContents.bytes_end());
 
   outs() << FMP;
 }
 
 static void printPrivateFileHeaders(const ObjectFile *o, bool onlyFirst) {
   if (o->isELF()) {
     printELFFileHeader(o);
-    return printELFDynamicSection(o);
+    printELFDynamicSection(o);
+    printELFSymbolVersionInfo(o);
+    return;
   }
   if (o->isCOFF())
     return printCOFFFileHeader(o);
   if (o->isWasm())
     return printWasmFileHeader(o);
   if (o->isMachO()) {
     printMachOFileHeader(o);
     if (!onlyFirst)

tools/yaml2obj/yaml2elf.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RawContentSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RelocationSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader, const ELFYAML::Group &Group,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::VersionDefSection &Section,
+                           ContiguousBlobAccumulator &CBA);
+  bool writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::VersionNeedSection &Section,
+                           ContiguousBlobAccumulator &CBA);
+  bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::MipsABIFlags &Section,
                            ContiguousBlobAccumulator &CBA);
   bool hasDynamicSymbols() const;
   SmallVector<const char *, 5> implicitSectionNames() const;
 
   // - SHT_NULL entry (placed first, i.e. 0'th entry)
   // - symbol table (.symtab) (defaults to after last yaml section)
   // - string table (.strtab) (defaults to after .symtab)
for (const auto &YamlPhdr : Doc.ProgramHeaders) {
     Phdr.p_type = YamlPhdr.Type;
     Phdr.p_flags = YamlPhdr.Flags;
     Phdr.p_vaddr = YamlPhdr.VAddr;
     Phdr.p_paddr = YamlPhdr.PAddr;
     PHeaders.push_back(Phdr);
   }
 }
 
+static bool checkSectionIndex(NameToIdxMap &SX2I, StringRef SecName,
+                              StringRef SecField, unsigned &Index) {
+  if (SX2I.lookup(SecField, Index) && !to_integer(SecField, Index)) {
+    WithColor::error() << "Unknown section referenced: '" << SecField
+                       << "' at YAML section '" << SecName << "'.\n";
+    return false;
+  }
+  return true;
+}
+
 template <class ELFT>
 bool ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                                         ContiguousBlobAccumulator &CBA) {
   // Ensure SHN_UNDEF entry is present. An all-zero section header is a
   // valid SHN_UNDEF entry since SHT_NULL == 0.
   Elf_Shdr SHeader;
   zero(SHeader);
   SHeaders.push_back(SHeader);
 
   for (const auto &Sec : Doc.Sections) {
     zero(SHeader);
     SHeader.sh_name = DotShStrtab.getOffset(Sec->Name);
     SHeader.sh_type = Sec->Type;
     SHeader.sh_flags = Sec->Flags;
     SHeader.sh_addr = Sec->Address;
     SHeader.sh_addralign = Sec->AddressAlign;
 
     if (!Sec->Link.empty()) {
       unsigned Index;
-      if (SN2I.lookup(Sec->Link, Index) && !to_integer(Sec->Link, Index)) {
-        WithColor::error() << "Unknown section referenced: '" << Sec->Link
-                           << "' at YAML section '" << Sec->Name << "'.\n";
+      if (!checkSectionIndex(SN2I, Sec->Name, Sec->Link, Index))
         return false;
-      }
       SHeader.sh_link = Index;
     }
 
-    if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec.get()))
+    if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec.get())) {
       writeSectionContent(SHeader, *S, CBA);
-    else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec.get())) {
+    } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec.get())) {
       if (S->Link.empty())
         // For relocation section set link to .symtab by default.
         SHeader.sh_link = getDotSymTabSecNo();
-
       unsigned Index;
-      if (SN2I.lookup(S->Info, Index) && !to_integer(S->Info, Index)) {
-        WithColor::error() << "Unknown section referenced: '" << S->Info
-                           << "' at YAML section '" << S->Name << "'.\n";
+      if (!checkSectionIndex(SN2I, S->Name, S->Info, Index))
         return false;
-      }
       SHeader.sh_info = Index;
-
       if (!writeSectionContent(SHeader, *S, CBA))
         return false;
     } else if (auto S = dyn_cast<ELFYAML::Group>(Sec.get())) {
       unsigned SymIdx;
-      if (SymN2I.lookup(S->Info, SymIdx) && !to_integer(S->Info, SymIdx)) {
-        WithColor::error() << "Unknown symbol referenced: '" << S->Info
-                           << "' at YAML section '" << S->Name << "'.\n";
+      if (!checkSectionIndex(SymN2I, S->Name, S->Info, SymIdx))
         return false;
-      }
       SHeader.sh_info = SymIdx;
       if (!writeSectionContent(SHeader, *S, CBA))
         return false;
     } else if (auto S = dyn_cast<ELFYAML::MipsABIFlags>(Sec.get())) {
       if (!writeSectionContent(SHeader, *S, CBA))
         return false;
     } else if (auto S = dyn_cast<ELFYAML::NoBitsSection>(Sec.get())) {
       SHeader.sh_entsize = 0;
       SHeader.sh_size = S->Size;
       // SHT_NOBITS section does not have content
       // so just to setup the section offset.
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+    } else if (auto S = dyn_cast<ELFYAML::VersionDefSection>(Sec.get())) {
+      if (!writeSectionContent(SHeader, *S, CBA))
+        return false;
+    } else if (auto S = dyn_cast<ELFYAML::VersionNeedSection>(Sec.get())) {
+      if (!writeSectionContent(SHeader, *S, CBA))
+        return false;
     } else
       llvm_unreachable("Unknown section type");
 
     SHeaders.push_back(SHeader);
   }
   return true;
 }
 
bool ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
 
   auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
 
   for (auto member : Section.Members) {
     Elf_Word SIdx;
     unsigned int sectionIndex = 0;
     if (member.sectionNameOrType == "GRP_COMDAT")
       sectionIndex = llvm::ELF::GRP_COMDAT;
-    else if (SN2I.lookup(member.sectionNameOrType, sectionIndex) &&
-             !to_integer(member.sectionNameOrType, sectionIndex)) {
-      WithColor::error() << "Unknown section referenced: '"
-                         << member.sectionNameOrType << "' at YAML section' "
-                         << Section.Name << "\n";
+    else if (!checkSectionIndex(SN2I, Section.Name, member.sectionNameOrType,
+                                sectionIndex))
       return false;
-    }
     SIdx = sectionIndex;
+
     OS.write((const char *)&SIdx, sizeof(SIdx));
   }
   return true;
 }
 
 template <class ELFT>
+bool ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::VersionDefSection &Section,
+    ContiguousBlobAccumulator &CBA) {
+  assert(Section.Type == llvm::ELF::SHT_GNU_verdef &&
+         "Section type is not SHT_GNU_verdef");
+
+  typedef typename ELFT::Verdef Elf_Verdef;
+  typedef typename ELFT::Verdaux Elf_Verdaux;
+
+  uint64_t BlobSize = 0;
+  SHeader.sh_info = Section.VersionDefs.size();
+  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+  for (auto VDefIt = Section.VersionDefs.begin();
+       VDefIt != Section.VersionDefs.end(); ++VDefIt) {
+    Elf_Verdef VDef;
+    zero(VDef);
+
+    VDef.vd_version = VDefIt->Revision;
+    VDef.vd_flags = VDefIt->Flags;
+    VDef.vd_ndx = VDefIt->Index;
+    VDef.vd_hash = VDefIt->Hash;
+    VDef.vd_aux = sizeof(Elf_Verdef);
+    VDef.vd_cnt = 1 + VDefIt->Parents.size();
+    VDef.vd_next = (VDefIt != Section.VersionDefs.end() - 1)
+                       ? sizeof(Elf_Verdef) + VDef.vd_cnt * sizeof(Elf_Verdaux)
+                       : 0;
+    BlobSize += sizeof(Elf_Verdef);
+    OS.write((const char *)&VDef, sizeof(Elf_Verdef));
+
+    Elf_Verdaux VDefName;
+    zero(VDefName);
+    VDefName.vda_name = VDefIt->Name;
+    VDefName.vda_next = (VDefIt->Parents.size() != 0) ? sizeof(Elf_Verdaux) : 0;
+    BlobSize += sizeof(Elf_Verdaux);
+    OS.write((const char *)&VDefName, sizeof(Elf_Verdaux));
+
+    for (auto VDefAuxIt = VDefIt->Parents.begin();
+         VDefAuxIt != VDefIt->Parents.end(); ++VDefAuxIt) {
+      Elf_Verdaux VDefAux;
+      zero(VDefAux);
+      VDefAux.vda_name = VDefAuxIt->Name;
+      VDefAux.vda_next =
+          (VDefAuxIt != VDefIt->Parents.end() - 1) ? sizeof(Elf_Verdaux) : 0;
+      BlobSize += sizeof(Elf_Verdaux);
+      OS.write((const char *)&VDefAux, sizeof(Elf_Verdaux));
+    }
+  }
+  SHeader.sh_size = BlobSize;
+  return true;
+}
+
+template <class ELFT>
+bool ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::VersionNeedSection &Section,
+    ContiguousBlobAccumulator &CBA) {
+  assert(Section.Type == llvm::ELF::SHT_GNU_verneed &&
+         "Section type is not SHT_GNU_verneed");
+
+  typedef typename ELFT::Verneed Elf_Verneed;
+  typedef typename ELFT::Vernaux Elf_Vernaux;
+
+  uint64_t BlobSize = 0;
+  SHeader.sh_info = Section.VersionNeeds.size();
+  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+  for (auto VNeedIt = Section.VersionNeeds.begin();
+       VNeedIt != Section.VersionNeeds.end(); ++VNeedIt) {
+    Elf_Verneed VNeed;
+    zero(VNeed);
+
+    VNeed.vn_version = VNeedIt->Version;
+    VNeed.vn_cnt = VNeedIt->Auxiliaries.size();
+    VNeed.vn_file = VNeedIt->File;
+    VNeed.vn_aux = sizeof(Elf_Verneed);
+    VNeed.vn_next =
+        (VNeedIt != Section.VersionNeeds.end() - 1)
+            ? sizeof(Elf_Verneed) + VNeed.vn_cnt * sizeof(Elf_Vernaux)
+            : 0;
+    BlobSize += sizeof(Elf_Verneed);
+    OS.write((const char *)&VNeed, sizeof(VNeed));
+
+    for (auto VNeedAuxIt = VNeedIt->Auxiliaries.begin();
+         VNeedAuxIt != VNeedIt->Auxiliaries.end(); ++VNeedAuxIt) {
+      Elf_Vernaux VNeedAux;
+      zero(VNeedAux);
+      VNeedAux.vna_hash = VNeedAuxIt->Hash;
+      VNeedAux.vna_flags = VNeedAuxIt->Flags;
+      VNeedAux.vna_other = VNeedAuxIt->Other;
+      VNeedAux.vna_name = VNeedAuxIt->Name;
+      VNeedAux.vna_next = (VNeedAuxIt != VNeedIt->Auxiliaries.end() - 1)
+                              ? sizeof(Elf_Vernaux)
+                              : 0;
+      BlobSize += sizeof(Elf_Vernaux);
+      OS.write((const char *)&VNeedAux, sizeof(Elf_Vernaux));
+    }
+  }
+  SHeader.sh_size = BlobSize;
+  return true;
+}
+
+template<class ELFT>
 bool ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::MipsABIFlags &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_MIPS_ABIFLAGS &&
          "Section type is not SHT_MIPS_ABIFLAGS");
 
   object::Elf_Mips_ABIFlags<ELFT> Flags;
   zero(Flags);