[obj2yaml][yaml2obj] - Add support of parsing/dumping of the .gnu.version_r section.

[grimar]

Summary

The section is described here:
https://refspecs.linuxfoundation.org/LSB_1.3.0/gLSB/gLSB/symverrqmts.html

Patch just teaches obj2yaml/yaml2obj to dump and parse such sections.

We did the finalization of string tables very late,
and I had to move the logic to make it a bit earlier.
That was needed in this patch since .gnu.version_r adds strings to .dynstr.
This also probably might be useful for implementing other special sections.

Everything else changed in this patch seems to be straightforward.

[grimar]

• Renamed the test cases, rebased.

[grimar]

• Corrected the types in VernauxEntry/VerneedEntry structs.

[jhenderson]

That was needed in this patch since .gnu.version_r adds strings to .dynsym.

I hope you're not adding any strings to .dynsym ;-) Also, your link in the description points to verdef sections, rather than verneed.

include/llvm/ObjectYAML/ELFYAML.h

186

Info? This section doesn't have anything to do with sh_info according to the specification (it uses sh_link to point at its string table).

417

Need blank line after this one.

test/tools/obj2yaml/verneed-section.yaml

61

I'm not sure we should be testing version 2, because the structure will change between versions (otherwise it would still be version 1). Indeed, this could cause the whole yaml2obj design to fall apart! I think a second Version 1 dependency would be better.

test/tools/yaml2obj/verneed-section.yaml

65

Same comments as the other test.

tools/obj2yaml/elf2yaml.cpp

481

Rather than resizing to default construct an entry, then fetching and updating it, could you not simply make a new local variable, set its fields and use push_back/emplace_back? That would be more natural, I think.

493–494

Ditto.

[grimar]

In D58119#1401344, @jhenderson wrote:

That was needed in this patch since .gnu.version_r adds strings to .dynsym.

I hope you're not adding any strings to .dynsym ;-)

That would be interesting behavior though.. Thanks! :)

include/llvm/ObjectYAML/ELFYAML.h

186

Its mentioned in a general spec about sh_info/sh_link fields for sections,
see "Table 7-15 ELF sh_link and sh_info Interpretation":
https://docs.oracle.com/cd/E19683-01/816-1386/chapter6-94076/index.html
sh_info contains "The number of version dependencies within the section. ".

Both GNU and LLD linkers set this field.

[jhenderson]

include/llvm/ObjectYAML/ELFYAML.h

186

Ah, okay. It's not listed in the description of the specific section, unlike the sh_link field, which would have made much more sense...

[grimar]

• Addressed review comments.

test/tools/obj2yaml/verneed-section.yaml

61

Did that, but FTR my vision of the problem is a bit different.
yaml2obj is a convenient tool for creating outputs and also test cases. For the latter sometimes
we want to create broken outputs, i.e. ones that are possible to produce only with a hex editing
the binaries normally.

I did not have plans to write a test for versions other than 1 (though as far I can see, we do
not check the version field when parsing inputs in LLD atm, and hence have no test),
but generally, we should probably keep in mind that might want to produce invalid outputs and yaml2obj should
allow doing that probably.

Anyways, I am ok to use version 1 here, as it was not the main aim of this patch to allow changing it.

tools/obj2yaml/elf2yaml.cpp

481

OK, that is not a style invented by me though. I think LLVM code use it sometimes.
It can be faster because allows avoiding expensive copying of members, like Entry.AuxV vector here.
Though in this particular place is not very important I think.

[jhenderson]

LGTM.

test/tools/obj2yaml/verneed-section.yaml

61

Ah, I see your point. In that case, I think the user should use the Content field (assuming that's allowed) instead of the explicit fields, because it is unclear what fields should exist. The version field explicitly exists to mark different formats for the section, so explicit fields may not make that much sense.

include/llvm/ObjectYAML/ELFYAML.h

 
 struct Section {
   enum class SectionKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
     NoBits,
+    Verneed,
     MipsABIFlags
   };
   SectionKind Kind;
   StringRef Name;
   ELF_SHT Type;
   ELF_SHF Flags;
   llvm::yaml::Hex64 Address;
   StringRef Link;
struct NoBitsSection : Section {
 
   NoBitsSection() : Section(SectionKind::NoBits) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::NoBits;
   }
 };
 
+struct VernauxEntry {
+  uint32_t Hash;
+  uint16_t Flags;
+  uint16_t Other;
+  StringRef Name;
+};
+
+struct VerneedEntry {
+  uint16_t Version;
+  StringRef File;
+  std::vector<VernauxEntry> AuxV;
+};
+
+struct VerneedSection : Section {
+  std::vector<VerneedEntry> VerneedV;
+  llvm::yaml::Hex64 Info;
+
+  VerneedSection() : Section(SectionKind::Verneed) {}
+
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::Verneed;
+  }
+};
+
 struct Group : Section {
   // Members of a group contain a flag and a list of section indices
   // that are part of the group.
   std::vector<SectionOrType> Members;
   StringRef Signature; /* Info */
 
   Group() : Section(SectionKind::Group) {}
 

 
 } // end namespace ELFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 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::VernauxEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
 
 namespace llvm {
 namespace yaml {
 
 template <>

 struct MappingTraits<ELFYAML::LocalGlobalWeakSymbols> {
   static void mapping(IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols);
 };
 
 template <> struct MappingTraits<ELFYAML::DynamicEntry> {
   static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
 };
 
+template <> struct MappingTraits<ELFYAML::VerneedEntry> {
+  static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
+};
+
+template <> struct MappingTraits<ELFYAML::VernauxEntry> {
+  static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
+};
+
 template <> struct MappingTraits<ELFYAML::Relocation> {
   static void mapping(IO &IO, ELFYAML::Relocation &Rel);
 };
 
 template <>
 struct MappingTraits<std::unique_ptr<ELFYAML::Section>> {
   static void mapping(IO &IO, std::unique_ptr<ELFYAML::Section> &Section);
   static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Section> &Section);

lib/ObjectYAML/ELFYAML.cpp

static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
   IO.mapOptional("Size", Section.Size, Hex64(Section.Content.binary_size()));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Size", Section.Size, Hex64(0));
 }
 
+static void sectionMapping(IO &IO, ELFYAML::VerneedSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapRequired("Info", Section.Info);
+  IO.mapRequired("Dependencies", Section.VerneedV);
+}
+
 static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Info", Section.RelocatableSec, StringRef());
   IO.mapOptional("Relocations", Section.Relocations);
 }
 
 static void groupSectionMapping(IO &IO, ELFYAML::Group &Group) {
   commonSectionMapping(IO, Group);
if (!IO.outputting())
       Section.reset(new ELFYAML::NoBitsSection());
     sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
     break;
   case ELF::SHT_MIPS_ABIFLAGS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::MipsABIFlags());
     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
     break;
+  case ELF::SHT_GNU_verneed:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::VerneedSection());
+    sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
+    break;
   default:
     if (!IO.outputting())
       Section.reset(new ELFYAML::RawContentSection());
     sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
   }
 }
 
 StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(

 void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,
                                                    ELFYAML::DynamicEntry &Rel) {
   assert(IO.getContext() && "The IO context is not initialized");
 
   IO.mapRequired("Tag", Rel.Tag);
   IO.mapRequired("Value", Rel.Val);
 }
 
+void MappingTraits<ELFYAML::VerneedEntry>::mapping(IO &IO,
+                                                   ELFYAML::VerneedEntry &E) {
+  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
+  assert(Object && "The IO context is not initialized");
+
+  IO.mapRequired("Version", E.Version);
+  IO.mapRequired("File", E.File);
+  IO.mapRequired("Entries", E.AuxV);
+}
+
+void MappingTraits<ELFYAML::VernauxEntry>::mapping(IO &IO,
+                                                   ELFYAML::VernauxEntry &E) {
+  const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
+  assert(Object && "The IO context is not initialized");
+
+  IO.mapRequired("Name", E.Name);
+  IO.mapRequired("Hash", E.Hash);
+  IO.mapRequired("Flags", E.Flags);
+  IO.mapRequired("Other", E.Other);
+}
+
 void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
                                                  ELFYAML::Relocation &Rel) {
   const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
   assert(Object && "The IO context is not initialized");
 
   IO.mapRequired("Offset", Rel.Offset);
   IO.mapOptional("Symbol", Rel.Symbol);
 

test/tools/obj2yaml/verneed-section.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: obj2yaml %t | FileCheck %s
+
+## Check we are able to yamalize SHT_GNU_verneed section.
+
+# CHECK:      - Name:            .gnu.version_r
+# CHECK-NEXT:   Type:            SHT_GNU_verneed
+# CHECK-NEXT:   Flags:           [ SHF_ALLOC ]
+# CHECK-NEXT:   Address:         0x0000000000200250
+# CHECK-NEXT:   Link:            .dynstr
+# CHECK-NEXT:   AddressAlign:    0x0000000000000004
+# CHECK-NEXT:   Info:            0x0000000000000002
+# CHECK-NEXT:   Dependencies:
+# CHECK-NEXT:     - Version:         1
+# CHECK-NEXT:       File:            dso.so.0
+# CHECK-NEXT:       Entries:
+# CHECK-NEXT:         - Name:            v1
+# CHECK-NEXT:           Hash:            1937
+# CHECK-NEXT:           Flags:           10
+# CHECK-NEXT:           Other:           3
+# CHECK-NEXT:         - Name:            v2
+# CHECK-NEXT:           Hash:            1938
+# CHECK-NEXT:           Flags:           11
+# CHECK-NEXT:           Other:           4
+# CHECK-NEXT:     - Version:         1
+# CHECK-NEXT:       File:            dso.so.1
+# CHECK-NEXT:       Entries:
+# CHECK-NEXT:         - Name:            v3
+# CHECK-NEXT:           Hash:            1939
+# CHECK-NEXT:           Flags:           12
+# CHECK-NEXT:           Other:           2
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+  Entry:           0x0000000000201000
+Sections:
+  - Name:            .gnu.version_r
+    Type:            SHT_GNU_verneed
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x200250
+    Link:            .dynstr
+    AddressAlign:    4
+    Info:            2
+    Dependencies:
+      - Version:         1
+        File:            dso.so.0
+        Entries:
+          - Name:            v1
+            Hash:            1937
+            Flags:           10
+            Other:           3
+          - Name:            v2
+            Hash:            1938
+            Flags:           11
+            Other:           4
+      - Version:         1
+        File:            dso.so.1
+        Entries:
+          - Name:            v3
+            Hash:            1939
+            Flags:           12
+            Other:           2
+DynamicSymbols:
+  Global:
+    - Name:            f1

test/tools/yaml2obj/verneed-section.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readelf -V %t | FileCheck %s
+
+# Check we are able to handle the SHT_GNU_verneed sections.
+
+# CHECK:      SHT_GNU_verneed {
+# CHECK-NEXT:   Dependency {
+# CHECK-NEXT:     Version: 1
+# CHECK-NEXT:     Count: 2
+# CHECK-NEXT:     FileName: dso.so.0
+# CHECK-NEXT:     Entry {
+# CHECK-NEXT:       Hash: 1937
+# CHECK-NEXT:       Flags: 0xA
+# CHECK-NEXT:       Index: 3
+# CHECK-NEXT:       Name: v1
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Entry {
+# CHECK-NEXT:       Hash: 1938
+# CHECK-NEXT:       Flags: 0xB
+# CHECK-NEXT:       Index: 4
+# CHECK-NEXT:       Name: v2
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Dependency {
+# CHECK-NEXT:     Version: 1
+# CHECK-NEXT:     Count: 1
+# CHECK-NEXT:     FileName: dso.so.1
+# CHECK-NEXT:     Entry {
+# CHECK-NEXT:       Hash: 1939
+# CHECK-NEXT:       Flags: 0xC
+# CHECK-NEXT:       Index: 2
+# CHECK-NEXT:       Name: v3
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT: }
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+  Entry:           0x0000000000201000
+Sections:
+  - Name:            .gnu.version_r
+    Type:            SHT_GNU_verneed
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000200250
+    Link:            .dynstr
+    AddressAlign:    0x0000000000000004
+    Info:            0x0000000000000002
+    Dependencies:
+      - Version:         1
+        File:            dso.so.0
+        Entries:
+          - Name:            v1
+            Hash:            1937
+            Flags:           10
+            Other:           3
+          - Name:            v2
+            Hash:            1938
+            Flags:           11
+            Other:           4
+      - Version:         1
+        File:            dso.so.1
+        Entries:
+          - Name:            v3
+            Hash:            1939
+            Flags:           12
+            Other:           2
+DynamicSymbols:
+  Global:
+    - Name:            f1

tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
   std::error_code dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
                                  ELFYAML::Relocation &R);
   
   ErrorOr<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::RawContentSection *>
   dumpContentSection(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
+  ErrorOr<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
   ErrorOr<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
 
 public:
   ELFDumper(const object::ELFFile<ELFT> &O);
   ErrorOr<ELFYAML::Object *> dump();
 };
 
for (const Elf_Shdr &Sec : Sections) {
     }
     case ELF::SHT_NOBITS: {
       ErrorOr<ELFYAML::NoBitsSection *> S = dumpNoBitsSection(&Sec);
       if (std::error_code EC = S.getError())
         return EC;
       Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
       break;
     }
+    case ELF::SHT_GNU_verneed: {
+      ErrorOr<ELFYAML::VerneedSection *> S = dumpVerneedSection(&Sec);
+      if (std::error_code EC = S.getError())
+        return EC;
+      Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
+      break;
+    }
     default: {
       ErrorOr<ELFYAML::RawContentSection *> S = dumpContentSection(&Sec);
       if (std::error_code EC = S.getError())
         return EC;
       Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
     }
     }
   }
ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
   if (std::error_code EC = dumpCommonSection(Shdr, *S))
     return EC;
   S->Size = Shdr->sh_size;
 
   return S.release();
 }
 
 template <class ELFT>
+ErrorOr<ELFYAML::VerneedSection *>
+ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
+  typedef typename ELFT::Verneed Elf_Verneed;
+  typedef typename ELFT::Vernaux Elf_Vernaux;
+
+  auto S = make_unique<ELFYAML::VerneedSection>();
+  if (std::error_code EC = dumpCommonSection(Shdr, *S))
+    return EC;
+
+  S->Info = Shdr->sh_info;
+
+  auto Contents = Obj.getSectionContents(Shdr);
+  if (!Contents)
+    return errorToErrorCode(Contents.takeError());
+
+  auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
+  if (!StringTableShdrOrErr)
+    return errorToErrorCode(StringTableShdrOrErr.takeError());
+
+  auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
+  if (!StringTableOrErr)
+    return errorToErrorCode(StringTableOrErr.takeError());
+
+  llvm::ArrayRef<uint8_t> Data = *Contents;
+  const uint8_t *Buf = Data.data();
+  while (Buf) {
+    const Elf_Verneed *Verneed = reinterpret_cast<const Elf_Verneed *>(Buf);
+
+    ELFYAML::VerneedEntry Entry;
+    Entry.Version = Verneed->vn_version;
+    Entry.File =
+        StringRef(StringTableOrErr->drop_front(Verneed->vn_file).data());
+
+    const uint8_t *BufAux = Buf + Verneed->vn_aux;
+    while (BufAux) {
+      const Elf_Vernaux *Vernaux =
+          reinterpret_cast<const Elf_Vernaux *>(BufAux);
+
+      ELFYAML::VernauxEntry Aux;
+      Aux.Hash = Vernaux->vna_hash;
+      Aux.Flags = Vernaux->vna_flags;
+      Aux.Other = Vernaux->vna_other;
+      Aux.Name =
+          StringRef(StringTableOrErr->drop_front(Vernaux->vna_name).data());
+
+      Entry.AuxV.push_back(Aux);
+      BufAux = Vernaux->vna_next ? BufAux + Vernaux->vna_next : nullptr;
+    }
+
+    S->VerneedV.push_back(Entry);
+    Buf = Verneed->vn_next ? Buf + Verneed->vn_next : nullptr;
+  }
+
+  return S.release();
+}
+
+template <class ELFT>
 ErrorOr<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::Group>();
 
   if (std::error_code EC = dumpCommonSection(Shdr, *S))
     return EC;
   // Get sh_info which is the signature.
   auto SymtabOrErr = Obj.getSection(Shdr->sh_link);
   if (!SymtabOrErr)

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::VerneedSection &Section,
+                           ContiguousBlobAccumulator &CBA);
+  bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::MipsABIFlags &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::DynamicSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool hasDynamicSymbols() const;
   SmallVector<const char *, 5> implicitSectionNames() const;
 
class ELFState {
   unsigned getDotDynSymSecNo() const { return SN2I.get(".dynsym"); }
   unsigned getDotDynStrSecNo() const { return SN2I.get(".dynstr"); }
   unsigned getSectionCount() const { return SN2I.size() + 1; }
 
   ELFState(const ELFYAML::Object &D) : Doc(D) {}
 
 public:
   static int writeELF(raw_ostream &OS, const ELFYAML::Object &Doc);
+
+private:
+  void finalizeStrings();
 };
 } // end anonymous namespace
 
 template <class ELFT>
 void ELFState<ELFT>::initELFHeader(Elf_Ehdr &Header) {
   using namespace llvm::ELF;
   zero(Header);
   Header.e_ident[EI_MAG0] = 0x7f;
for (const auto &Sec : Doc.Sections) {
     } 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::DynamicSection>(Sec.get())) {
       writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::VerneedSection>(Sec.get())) {
+      writeSectionContent(SHeader, *S, CBA);
     } else
       llvm_unreachable("Unknown section type");
 
     SHeaders.push_back(SHeader);
   }
   return true;
 }
 
void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
   std::vector<Elf_Sym> Syms;
   {
     // Ensure STN_UNDEF is present
     Elf_Sym Sym;
     zero(Sym);
     Syms.push_back(Sym);
   }
 
-  // Add symbol names to .strtab or .dynstr.
-  for (const auto &Sym : Symbols.Local)
-    Strtab.add(Sym.Name);
-  for (const auto &Sym : Symbols.Global)
-    Strtab.add(Sym.Name);
-  for (const auto &Sym : Symbols.Weak)
-    Strtab.add(Sym.Name);
-  Strtab.finalize();
-
   addSymbols(Symbols.Local, Syms, ELF::STB_LOCAL, Strtab);
   addSymbols(Symbols.Global, Syms, ELF::STB_GLOBAL, Strtab);
   addSymbols(Symbols.Weak, Syms, ELF::STB_WEAK, Strtab);
 
   writeArrayData(
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign),
       makeArrayRef(Syms));
   SHeader.sh_size = arrayDataSize(makeArrayRef(Syms));
for (auto member : Section.Members) {
     SIdx = sectionIndex;
     OS.write((const char *)&SIdx, sizeof(SIdx));
   }
   return true;
 }
 
 template <class ELFT>
 bool ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
+                                         const ELFYAML::VerneedSection &Section,
+                                         ContiguousBlobAccumulator &CBA) {
+ typedef typename ELFT::Verneed Elf_Verneed;
+ typedef typename ELFT::Vernaux Elf_Vernaux;
+
+ auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+ uint64_t AuxCnt = 0;
+ for (size_t I = 0; I < Section.VerneedV.size(); ++I) {
+   const ELFYAML::VerneedEntry &VE = Section.VerneedV[I];
+
+   Elf_Verneed VerNeed;
+   VerNeed.vn_version = VE.Version;
+   VerNeed.vn_file = DotDynstr.getOffset(VE.File);
+   if (I == Section.VerneedV.size() - 1)
+     VerNeed.vn_next = 0;
+   else
+     VerNeed.vn_next =
+         sizeof(Elf_Verneed) + VE.AuxV.size() * sizeof(Elf_Vernaux);
+   VerNeed.vn_cnt = VE.AuxV.size();
+   VerNeed.vn_aux = sizeof(Elf_Verneed);
+   OS.write((const char *)&VerNeed, sizeof(Elf_Verneed));
+
+   for (size_t J = 0; J < VE.AuxV.size(); ++J, ++AuxCnt) {
+     const ELFYAML::VernauxEntry &VAuxE = VE.AuxV[J];
+
+     Elf_Vernaux VernAux;
+     VernAux.vna_hash = VAuxE.Hash;
+     VernAux.vna_flags = VAuxE.Flags;
+     VernAux.vna_other = VAuxE.Other;
+     VernAux.vna_name = DotDynstr.getOffset(VAuxE.Name);
+     if (J == VE.AuxV.size() - 1)
+       VernAux.vna_next = 0;
+     else
+       VernAux.vna_next = sizeof(Elf_Vernaux);
+     OS.write((const char *)&VernAux, sizeof(Elf_Vernaux));
+   }
+ }
+
+ SHeader.sh_size = Section.VerneedV.size() * sizeof(Elf_Verneed) +
+                   AuxCnt * sizeof(Elf_Vernaux);
+ SHeader.sh_info = Section.Info;
+
+ 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);
   SHeader.sh_entsize = sizeof(Flags);
for (const auto &Sym : Symbols) {
     if (SymN2I.addName(Sym.Name, StartIndex)) {
       WithColor::error() << "Repeated symbol name: '" << Sym.Name << "'.\n";
       return false;
     }
   }
   return true;
 }
 
+template <class ELFT> void ELFState<ELFT>::finalizeStrings() {
+  auto AddSymbols = [](StringTableBuilder &StrTab,
+                       const ELFYAML::LocalGlobalWeakSymbols &Symbols) {
+    for (const auto &Sym : Symbols.Local)
+      StrTab.add(Sym.Name);
+    for (const auto &Sym : Symbols.Global)
+      StrTab.add(Sym.Name);
+    for (const auto &Sym : Symbols.Weak)
+      StrTab.add(Sym.Name);
+  };
+
+  // Add the regular symbol names to .strtab section.
+  AddSymbols(DotStrtab, Doc.Symbols);
+  DotStrtab.finalize();
+
+  if (!hasDynamicSymbols())
+    return;
+
+  // Add the dynamic symbol names to .dynstr section.
+  AddSymbols(DotDynstr, Doc.DynamicSymbols);
+
+  // SHT_GNU_verneed section also adds strings to .dynstr section.
+  for (const std::unique_ptr<ELFYAML::Section> &Sec : Doc.Sections) {
+    auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec.get());
+    if (!VerNeed)
+      continue;
+
+    for (const ELFYAML::VerneedEntry &VE : VerNeed->VerneedV) {
+      DotDynstr.add(VE.File);
+      for (const ELFYAML::VernauxEntry &Aux : VE.AuxV)
+        DotDynstr.add(Aux.Name);
+    }
+  }
+
+  DotDynstr.finalize();
+}
+
 template <class ELFT>
 int ELFState<ELFT>::writeELF(raw_ostream &OS, const ELFYAML::Object &Doc) {
   ELFState<ELFT> State(Doc);
+
+  // Finalize .strtab and .dynstr sections. We do that early because want to
+  // finalize the string table builders before writing the content of the
+  // sections that might want to use them.
+  State.finalizeStrings();
+
   if (!State.buildSectionIndex())
     return 1;
 
   std::size_t StartSymIndex = 0;
   if (!State.buildSymbolIndex(StartSymIndex, Doc.Symbols.Local) ||
       !State.buildSymbolIndex(StartSymIndex, Doc.Symbols.Global) ||
       !State.buildSymbolIndex(StartSymIndex, Doc.Symbols.Weak))
     return 1;