[yaml2obj] Introduce symbol version section to yaml2obj

[Higuoxing]

Summary

I am working on D54697, which needs creating .gnu.version_r section. Its entries are defined in sh_info field. So, I think it's reasonable to make sh_info field editable in raw content section.

[Higuoxing]

format codes

[jhenderson]

Whilst I'm not opposed to this in principle, I do wonder if the more correct thing to do is to make .gnu.version_r sections (which I assume have a distinctive ELF type) another kind of ELFYAML section (e.g. like RelocationSection).

I also think a refactor of the error handling is in order. Specifically, basically the same four lines of code exist any time Info or Link can be set. This should probably be pulled out into a separate function. Something like checkSectionIndex or similar.

[grimar]

I think this should be fine for now, with the refactoring change mentioned.

tools/yaml2obj/yaml2elf.cpp

277

I agree with James that this ideally should be refactored to a static helper probably.

[Higuoxing]

Thank you @jhenderson and @grimar for reviewing

Updating D54867: [yaml2obj] Introduce symbol version section to yaml2obj

I add .gnu.version_r section into yaml2obj, I don't know if this patch with such size is acceptable ... If needed, I could implement .gnu.version_d as well. Because they are similar ...

Here is my reference
https://akkadia.org/drepper/symbol-versioning

PS: I think we need a yaml2obj doc ... If this is on the todo list, I could help

[Higuoxing]

format code

[Higuoxing]

Updating D54867: [yaml2obj] Introduce symbol version section to yaml2obj

I implemented .gnu.version_d and .gnu.version_r section

[Higuoxing]

Updating D54867: [yaml2obj] Introduce symbol version section to yaml2obj

I implemented .gnu.version_d and .gnu.version_r section

[jhenderson]

Sorry, I've been a bit busy over the last couple of days. Where can I find documentation on these two sections you are adding support for?

[Higuoxing]

In D54867#1312797, @jhenderson wrote:

Sorry, I've been a bit busy over the last couple of days. Where can I find documentation on these two sections you are adding support for?

Thank you for taking time reviewing!

References:

[1] https://akkadia.org/drepper/symbol-versioning
[2] https://refspecs.linuxfoundation.org/LSB_2.1.0/LSB-Core-generic/LSB-Core-generic/symverdefs.html
[3] https://refspecs.linuxfoundation.org/LSB_2.1.0/LSB-Core-generic/LSB-Core-generic/symverrqmts.html

[Higuoxing]

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

75

According to https://www.akkadia.org/drepper/symbol-versioning

vda_next: byte offset to the next Elfxx_Verdaux entry. The first entry (pointed to by the Elfxx_Verdef entry, contains the actual defined name. The second and all later entries name predecessor versions.

What if change Auxiliaries to

Name <Required>
Predecessor/Parent <Optional> (Parent is used by `gnu-readelf` and `gnu-objdump`)

[Higuoxing]

This comment was removed by Higuoxing.

[Higuoxing]

Refactor some codes

[jhenderson]

I'm still not particularly familiar with yaml2obj, so my comments might not always make sense, so feel free to correct me.

On the two flag fields, it might be nice if the user can explicitly specify the flags they want setting (e.g. VER_FLG_BASE), as well as an arbitrary value.

I've not yet reviewed the writeSectionContent functions. I'll do those later.

include/llvm/ObjectYAML/ELFYAML.h

184

Is this supposed to be the Elfxx_Verdaux struct? If so, it should probably be renamed to VersionDefAux, or similar.

185

This should probably be a string, rather than a hex number, since it is just a name. yaml2obj should then automatically add it to a string table, referenced by the sh_link in the VerDef header.

189

Revision is an Elfxx_Half, so should be a uint16_t, right?

190–191

Ditto for these two fields. They should be Hex16.

192

The is an Elfxx_Word, which is always 32-bits, so should be Hex32.

193

What's the purpose of this field? It doesn't seem to map to any of the struct's fields.

197

Maybe also worth mentioning the section type here, since technically SHT_GNU_verdef sections could be called other things.

209–211

These are all twice the size I'd expect them to be, like in the VersionDef struct above. Why?

212

Similar to the VersionDefParent, this name should be a string.

216–217

Similar to above, these are the wrong types.

221

Similar to above, mention the section type here.

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

57

Nit: This should be ET_DYN or ET_EXEC, since it's got dynamic information.

75

Sorry, I'm not sure I understand this comment.

tools/yaml2obj/yaml2elf.cpp

235–243

Thanks for the refactor. Given the growing size of this change, would you mind doing it in a separate change and first, please, to reduce the complexity of this change?

[Higuoxing]

Abandon this patch, since @grimar has implemented .gnu.version_d section (https://reviews.llvm.org/rG623ae72ad46d378d6a2e40abf67d3c5e627bef7c)

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/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/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);