[yaml2obj/obj2yaml] - Move `Info` field out from `Section` class.

[grimar]

Summary

ELFYAML.h contains a Section class which is a base for a few other
sections classes that are used for mapping different section types.

In rL230124 Info field was moved there from RelocationSection class
because patch reused it for Group section type. Info has a string type.

At the same time, sh_info has very different meanings for sections.
For SHT_GROUP the meaning of sh_info is "The symbol table index of an entry
in the associated symbol table. The name of the specified symbol table entry provides
a signature for the section group."
And for SHT_REL[A] is "The section header index of the section to which the relocation
applies."

So it cannot be processed in a similar way generally,
for example ELFDumper does not handle it in dumpCommonSection
but do that in dumpGroup and dumpCommonRelocationSection respectively.
(see patch).

At this moment, we have and handle it as a string, because that was possible for
the current use case. But also it can simply be a number,
see for example SHT_SUNW_verdef/SHT_SUNW_verneed sections (SHT_GNU_verdef/SHT_GNU_verneed):
https://docs.oracle.com/cd/E19683-01/816-1386/6m7qcoblj/index.html#chapter6-47976

Given above, I think keeping is as StringRef in a common Section class is probably wrong.
I want to move it out to be able to have it as a number and to implement dumping/parsing the versioning
sections mentioned above. With that change, each class will be able to decide what type and purpose
of the sh_info field it wants to use.

I also had to edit 2 test cases. This is because patch fixes a bug. Previously we accepted
yaml files with Info fields for all sections (for example, for SHT_DYNSYM too).
But we do not handle it and the resulting objects had zero sh_info fields set for such sections.
Now it is accepted only for sections that support it.

[Higuoxing]

Agree, because I've struggled on this for some time ...

[ruiu]

LGTM

llvm/trunk/include/llvm/ObjectYAML/ELFYAML.h

enum class SectionKind {
     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 DynamicSection : Section {
static bool classof(const Section *S) {
     return S->Kind == SectionKind::NoBits;
   }
 };
 
 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) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::Group;
   }
 };
 
 struct Relocation {
   llvm::yaml::Hex64 Offset;
   int64_t Addend;
   ELF_REL Type;
   Optional<StringRef> Symbol;
 };
 
 struct RelocationSection : Section {
   std::vector<Relocation> Relocations;
+  StringRef RelocatableSec; /* Info */
 
   RelocationSection() : Section(SectionKind::Relocation) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::Relocation;
   }
 };
 

llvm/trunk/lib/ObjectYAML/ELFYAML.cpp

 static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
   IO.mapOptional("Name", Section.Name, StringRef());
   IO.mapRequired("Type", Section.Type);
   IO.mapOptional("Flags", Section.Flags, ELFYAML::ELF_SHF(0));
   IO.mapOptional("Address", Section.Address, Hex64(0));
   IO.mapOptional("Link", Section.Link, StringRef());
   IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
   IO.mapOptional("EntSize", Section.EntSize);
-  IO.mapOptional("Info", Section.Info, StringRef());
 }
 
 static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Entries", Section.Entries);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Content", Section.Content);
   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::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);
-  IO.mapRequired("Members", group.Members);
+static void groupSectionMapping(IO &IO, ELFYAML::Group &Group) {
+  commonSectionMapping(IO, Group);
+  IO.mapOptional("Info", Group.Signature, StringRef());
+  IO.mapRequired("Members", Group.Members);
 }
 
 void MappingTraits<ELFYAML::SectionOrType>::mapping(
     IO &IO, ELFYAML::SectionOrType &sectionOrType) {
   IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
 }
 
 void MappingTraits<ELFYAML::SectionName>::mapping(

llvm/trunk/test/tools/llvm-readobj/demangle.test

- Name:         .dynstr
     AddressAlign: 0x100
     EntSize:      0x1
     ## "\0_Z3fooi\0"
     Content: "005f5a33666f6f6900"
   - Name:         .dynsym
     Type:         SHT_DYNSYM
     Flags:        [ SHF_ALLOC ]
     Link:         .dynstr
-    Info:         1
     Address:      0x100
     AddressAlign: 0x100
     EntSize:      0x18
     ## Null symbol;
     ## st_name: 1; st_info: Global | Func; st_other: 0;
     ##   st_shndx: .text.foo; st_value: 0x2000; st_size: 0
     Content: "000000000000000000000000000000000000000000000000010000001200050000200000000000000000000000000000"
   - Name:         .rela.dyn

llvm/trunk/test/tools/llvm-readobj/gnu-hash-symbols.test

- Name:         .dynstr
     AddressAlign: 0x100
     EntSize:      0x1
     ## "\0_Z3fooi\0"
     Content: "005f5a33666f6f6900"
   - Name:         .dynsym
     Type:         SHT_DYNSYM
     Flags:        [ SHF_ALLOC ]
     Link:         .dynstr
-    Info:         1
     Address:      0x100
     AddressAlign: 0x100
     EntSize:      0x18
     ## Null symbol;
     ## st_name: 1; st_info: Global | Func; st_other: 0;
     ##   st_shndx: .text.foo; st_value: 0x2000; st_size: 0
     Content: "000000000000000000000000000000000000000000000000010000001200040000200000000000000000000000000000"
   - Name:            .dynamic

llvm/trunk/tools/obj2yaml/elf2yaml.cpp

ELFDumper<ELFT>::dumpCommonRelocationSection(const Elf_Shdr *Shdr,
 
   auto InfoSection = Obj.getSection(Shdr->sh_info);
   if (!InfoSection)
     return errorToErrorCode(InfoSection.takeError());
 
   auto NameOrErr = getUniquedSectionName(*InfoSection);
   if (!NameOrErr)
     return errorToErrorCode(NameOrErr.takeError());
-  S.Info = NameOrErr.get();
+  S.RelocatableSec = NameOrErr.get();
 
   return obj2yaml_error::success;
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::DynamicSection *>
 ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::DynamicSection>();
if (!StrTabOrErr)
     return errorToErrorCode(StrTabOrErr.takeError());
   StringRef StrTab = *StrTabOrErr;
   auto sectionContents = Obj.getSectionContents(Shdr);
   if (!sectionContents)
     return errorToErrorCode(sectionContents.takeError());
   Expected<StringRef> symbolName = getSymbolName(symbol, StrTab, Symtab);
   if (!symbolName)
     return errorToErrorCode(symbolName.takeError());
-  S->Info = *symbolName;
+  S->Signature = *symbolName;
   const Elf_Word *groupMembers =
       reinterpret_cast<const Elf_Word *>(sectionContents->data());
   const long count = (Shdr->sh_size) / sizeof(Elf_Word);
   ELFYAML::SectionOrType s;
   for (int i = 0; i < count; i++) {
     if (groupMembers[i] == llvm::ELF::GRP_COMDAT) {
       s.sectionNameOrType = "GRP_COMDAT";
     } else {

llvm/trunk/tools/yaml2obj/yaml2elf.cpp

for (const auto &Sec : Doc.Sections) {
     if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec.get()))
       writeSectionContent(SHeader, *S, CBA);
     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 (!convertSectionIndex(SN2I, S->Name, S->Info, Index))
+      if (!convertSectionIndex(SN2I, S->Name, S->RelocatableSec, 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
+      if (SymN2I.lookup(S->Signature, SymIdx) &&
+          !to_integer(S->Signature, SymIdx)) {
+        WithColor::error() << "Unknown symbol referenced: '" << S->Signature
                            << "' at YAML section '" << S->Name << "'.\n";
         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))