[yaml2obj][obj2yaml] - Support SHT_GNU_versym (.gnu.version) section.

[grimar]

Summary

This patch adds support for parsing dumping the .gnu.version section.
Description of the section is: https://refspecs.linuxfoundation.org/LSB_1.3.0/gLSB/gLSB/symversion.html#SYMVERTBL

Its rebased on top of D58119.

[jhenderson]

test/tools/obj2yaml/versym-section.yaml

18

Should this have a link field? As far as I can see, the field is not specified in the specification.

[grimar]

test/tools/obj2yaml/versym-section.yaml

18

Yes, it should:
sh_link here is a "The section header index of the associated symbol table. "
according to generic specification about the special sections:
(https://docs.oracle.com/cd/E19683-01/816-1386/chapter6-94076/index.html,
Table 7-15 ELF sh_link and sh_info Interpretation)

[jhenderson]

LGTM, with two small comments.

tools/yaml2obj/yaml2elf.cpp

563

I don't know what the type here is, so best not to use auto, I think.

565

Do you need this cast here? It looks superfluous.

[grimar]

tools/yaml2obj/yaml2elf.cpp

563

Generally, I follow the same rule, but the whole file use auto, so I did that for consistency.
Perhaps it is a good idea to fix it though.

565

Yep :(, MSVS2017 complains:

error C2440: 'initializing': cannot convert from 'uint16_t' to 'llvm::support::detail::packed_endian_specific_integral<uint16_t,llvm::support::little,1>'

[jhenderson]

tools/yaml2obj/yaml2elf.cpp

565

Sounds to me like there's a missing conversion constructor or similar in that type then...

[grimar]

tools/yaml2obj/yaml2elf.cpp

565

I think it would be a bit simpler to do something like:

for (uint16_t V : Section.Entries)
  support::endian::write<uint16_t>(OS, V, ELFT::TargetEndianness);

(Elf_Half is always 2 bytes).
It seems can simplify/cleanup a few other methods of this file too.
I'll take a look.

include/llvm/ObjectYAML/ELFYAML.h

 struct Section {
   enum class SectionKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
     NoBits,
     Verneed,
+    Symver,
     MipsABIFlags
   };
   SectionKind Kind;
   StringRef Name;
   ELF_SHT Type;
   ELF_SHF Flags;
   llvm::yaml::Hex64 Address;
   StringRef Link;
struct VerneedSection : Section {
 
   VerneedSection() : Section(SectionKind::Verneed) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::Verneed;
   }
 };
 
+struct SymverSection : Section {
+  std::vector<uint16_t> Entries;
+
+  SymverSection() : Section(SectionKind::Symver) {}
+
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::Symver;
+  }
+};
+
 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) {}
 

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::SymverSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapRequired("Entries", Section.Entries);
+}
+
 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);
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_versym:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::SymverSection());
+    sectionMapping(IO, *cast<ELFYAML::SymverSection>(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());

test/tools/obj2yaml/versym-section.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: obj2yaml %t | FileCheck %s
+
+## Check we are able to yamalize the SHT_GNU_versym section.
+
+# CHECK:      --- !ELF
+# CHECK-NEXT: FileHeader:
+# CHECK-NEXT:   Class:           ELFCLASS64
+# CHECK-NEXT:   Data:            ELFDATA2LSB
+# CHECK-NEXT:   Type:            ET_EXEC
+# CHECK-NEXT:   Machine:         EM_X86_64
+# CHECK-NEXT:   Entry:           0x0000000000201000
+# CHECK-NEXT: Sections:
+# CHECK-NEXT:   - Name:            .gnu.version
+# CHECK-NEXT:     Type:            SHT_GNU_versym
+# CHECK-NEXT:     Flags:           [ SHF_ALLOC ]
+# CHECK-NEXT:     Address:         0x0000000000200210
+# CHECK-NEXT:     Link:            .dynsym
+# CHECK-NEXT:     AddressAlign:    0x0000000000000002
+# CHECK-NEXT:     EntSize:         0x0000000000000002
+# CHECK-NEXT:     Entries:         [ 0, 3, 4 ]
+# CHECK-NEXT: Symbols:         {}
+# CHECK-NEXT: DynamicSymbols:
+# CHECK-NEXT:   Global:
+# CHECK-NEXT:     - Name:            f1
+# CHECK-NEXT:     - Name:            f2
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+  Entry:           0x0000000000201000
+Sections:
+  - Name:            .gnu.version
+    Type:            SHT_GNU_versym
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000200210
+    Link:            .dynsym
+    AddressAlign:    0x0000000000000002
+    EntSize:         0x0000000000000002
+    Entries:         [ 0, 3, 4 ]
+DynamicSymbols:
+  Global:
+    - Name:            f1
+    - Name:            f2
+...

test/tools/yaml2obj/versym-section.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readelf -V %t | FileCheck %s
+
+## Check we are able to produce a valid SHT_GNU_versym
+## section from its description.
+
+# CHECK:      Version symbols {
+# CHECK-NEXT:   Section Name: .gnu.version
+# CHECK-NEXT:   Address: 0x200210
+# CHECK-NEXT:   Offset: 0x240
+# CHECK-NEXT:   Link: 6
+# CHECK-NEXT:   Symbols [
+# CHECK-NEXT:     Symbol {
+# CHECK-NEXT:       Version: 0
+# CHECK-NEXT:       Name:
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Symbol {
+# CHECK-NEXT:       Version: 3
+# CHECK-NEXT:       Name: f1@v1
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Symbol {
+# CHECK-NEXT:       Version: 4
+# CHECK-NEXT:       Name: f2@v2
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]
+# CHECK-NEXT: }
+# CHECK-NEXT: SHT_GNU_verdef {
+# CHECK-NEXT: }
+# CHECK-NEXT: 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: 0x0
+# CHECK-NEXT:       Index: 3
+# CHECK-NEXT:       Name: v1
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Entry {
+# CHECK-NEXT:       Hash: 1938
+# CHECK-NEXT:       Flags: 0x0
+# CHECK-NEXT:       Index: 4
+# CHECK-NEXT:       Name: v2
+# 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
+    Type:            SHT_GNU_versym
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000200210
+    Link:            .dynsym
+    AddressAlign:    0x0000000000000002
+    EntSize:         0x0000000000000002
+    Entries:         [ 0, 3, 4 ]
+  - Name:            .gnu.version_r
+    Type:            SHT_GNU_verneed
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000200250
+    Link:            .dynstr
+    AddressAlign:    0x0000000000000004
+    Info:            0x0000000000000001
+    Dependencies:
+      - Version:         1
+        File:            dso.so.0
+        Entries:         
+          - Name:            v1
+            Hash:            1937
+            Flags:           0
+            Other:           3
+          - Name:            v2
+            Hash:            1938
+            Flags:           0
+            Other:           4
+DynamicSymbols:
+  Global:
+    - Name:            f1
+    - Name:            f2
+...

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::SymverSection *> dumpSymverSection(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_versym: {
+      ErrorOr<ELFYAML::SymverSection *> S = dumpSymverSection(&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: {
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::SymverSection *>
+ELFDumper<ELFT>::dumpSymverSection(const Elf_Shdr *Shdr) {
+  typedef typename ELFT::Half Elf_Half;
+
+  auto S = make_unique<ELFYAML::SymverSection>();
+  if (std::error_code EC = dumpCommonSection(Shdr, *S))
+    return EC;
+
+  auto VersionsOrErr = Obj.template getSectionContentsAsArray<Elf_Half>(Shdr);
+  if (!VersionsOrErr)
+    return errorToErrorCode(VersionsOrErr.takeError());
+  for (const Elf_Half &E : *VersionsOrErr)
+    S->Entries.push_back(E);
+
+  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;

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::SymverSection &Section,
+                           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);
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::SymverSection>(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;
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::SymverSection &Section,
+                                         ContiguousBlobAccumulator &CBA) {
+  typedef typename ELFT::Half Elf_Half;
+
+  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  for (uint16_t V : Section.Entries) {
+    Elf_Half Version = (Elf_Half)V;
+    OS.write((const char *)&Version, sizeof(Elf_Half));
+  }
+
+  SHeader.sh_size = Section.Entries.size() * sizeof(Elf_Half);
+  SHeader.sh_entsize = sizeof(Elf_Half);
+  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;