[yaml2obj] - Allow setting custom sh_info for RawContentSection sections.

[grimar]

Summary

I need this for tweaking SHT_SYMTAB sections.
Their sh_info contains the (number of symbols + 1) usually. But for
creating invalid inputs for test cases it would be convenient
to allow explicitly override this field from YAML.

This change allowed to remove 4 precompiled binaries from
LLD test cases set: https://reviews.llvm.org/D58780,
https://reviews.llvm.org/D58783

[grimar]

Planning change.

[grimar]

No, it's OK as is :)

[jhenderson]

test/tools/yaml2obj/elf-symtab-shinfo.yaml

45 ↗

(On Diff #188720)

This looks like it belongs in a different test, as it's not to do with the sh_info field.

tools/yaml2obj/yaml2elf.cpp

347 ↗

(On Diff #188720)

If -> If the

348 ↗

(On Diff #188720)

want to be able to -> should

[grimar]

test/tools/yaml2obj/elf-symtab-shinfo.yaml

45 ↗

(On Diff #188720)

It is for line 352 of yaml2elf.cpp:

This line: if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec)) is needed,
without if this test would crash.

[grimar]

test/tools/yaml2obj/elf-symtab-shinfo.yaml

45 ↗

(On Diff #188720)

So it's technically relative with how we set sh_info. Want me to move this out?

[jhenderson]

test/tools/yaml2obj/elf-symtab-shinfo.yaml

45 ↗

(On Diff #188720)

Yes, I think so. It can be in this patch, but should be a different test, as although it is relevant to the current implementation, you could imagine it being more generally useful.

[grimar]

• Addressed review comments.

[jhenderson]

test/tools/yaml2obj/elf-symtab-shtype.yaml

2 ↗

(On Diff #188854)

Maybe it's worth showing what the output type of .symtab actually is?

[grimar]

• Addressed review comment.

test/tools/yaml2obj/elf-symtab-shtype.yaml

2 ↗

(On Diff #188854)

Done.

[jhenderson]

LGTM.

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

struct DynamicSection : Section {
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::Dynamic;
   }
 };
 
 struct RawContentSection : Section {
   yaml::BinaryRef Content;
   llvm::yaml::Hex64 Size;
+  llvm::yaml::Hex64 Info;
 
   RawContentSection() : Section(SectionKind::RawContent) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::RawContent;
   }
 };
 

llvm/trunk/lib/ObjectYAML/ELFYAML.cpp

static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
   IO.mapOptional("Entries", Section.Entries);
   IO.mapOptional("Content", Section.Content);
 }
 
 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()));
+  IO.mapOptional("Info", Section.Info, Hex64(0));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Size", Section.Size, Hex64(0));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {

llvm/trunk/test/tools/obj2yaml/elf-shinfo.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: obj2yaml %t | FileCheck %s
+
+## Check obj2yaml is able to dump sh_info field of a section.
+
+# CHECK:      - Name:            .test
+# CHECK-NEXT:   Type:            SHT_PROGBITS
+# CHECK-NEXT:   Content:         ''
+# CHECK-NEXT:   Info:            0x000000000000002A
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .test
+    Type:            SHT_PROGBITS
+    Info:            42

llvm/trunk/test/tools/yaml2obj/elf-symtab-shinfo.yaml

+## Check we are able to set sh_info field for SHT_SYMTAB sections.
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj -sections %t | FileCheck %s
+
+# CHECK:      Name: .symtab
+# CHECK-NEXT: Type: SHT_SYMTAB
+# CHECK-NEXT: Flags [
+# CHECK-NEXT: ]
+# CHECK-NEXT: Address:
+# CHECK-NEXT: Offset:
+# CHECK-NEXT: Size:
+# CHECK-NEXT: Link:
+# CHECK-NEXT: Info: 42
+# CHECK:      Name: .dynsym
+# CHECK-NEXT: Type: SHT_DYNSYM
+# CHECK-NEXT: Flags [
+# CHECK-NEXT:   SHF_ALLOC
+# CHECK-NEXT: ]
+# CHECK-NEXT: Address:
+# CHECK-NEXT: Offset:
+# CHECK-NEXT: Size:
+# CHECK-NEXT: Link:
+# CHECK-NEXT: Info: 26
+ 
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:          .symtab
+    Info:          42
+    Type:          SHT_SYMTAB
+  - Name:          .dynsym
+    Info:          26
+    Type:          SHT_SYMTAB
+Symbols:
+  Global:
+    - Name: foo
+DynamicSymbols:
+  Global:
+    - Name: bar

llvm/trunk/test/tools/yaml2obj/elf-symtab-shtype.yaml

+## Check we dont crash when .symtab has type different from SHT_SYMTAB.
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj -sections %t | FileCheck %s
+
+## TODO: the output is still SHT_SYMTAB because we do not yet
+## support changing it.
+# CHECK:      Name: .symtab
+# CHECK-NEXT: Type: SHT_SYMTAB
+
+--- !ELF
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:        
+  - Name:            .symtab
+    Type:            SHT_DYNAMIC
+Symbols:
+  Global:
+    - Name: foo

llvm/trunk/tools/obj2yaml/elf2yaml.cpp

ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
   if (std::error_code EC = dumpCommonSection(Shdr, *S))
     return EC;
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)
     return errorToErrorCode(ContentOrErr.takeError());
   S->Content = yaml::BinaryRef(ContentOrErr.get());
   S->Size = S->Content.binary_size();
+  S->Info = Shdr->sh_info;
 
   return S.release();
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::NoBitsSection *>
 ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::NoBitsSection>();

llvm/trunk/tools/yaml2obj/yaml2elf.cpp

void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
   SHeader.sh_link = IsStatic ? getDotStrTabSecNo() : getDotDynStrSecNo();
   const auto &Symbols = IsStatic ? Doc.Symbols : Doc.DynamicSymbols;
   auto &Strtab = IsStatic ? DotStrtab : DotDynstr;
   // One greater than symbol table index of the last local symbol.
   SHeader.sh_info = Symbols.Local.size() + 1;
   SHeader.sh_entsize = sizeof(Elf_Sym);
   SHeader.sh_addralign = 8;
 
-  // If .dynsym section is explicitly described in the YAML
-  // then we want to use its section address.
-  if (!IsStatic) {
-    // Take section index and ignore the SHT_NULL section.
-    unsigned SecNdx = getDotDynSymSecNo() - 1;
-    if (SecNdx < Doc.Sections.size())
-      SHeader.sh_addr = Doc.Sections[SecNdx]->Address;
+  // Get the section index ignoring the SHT_NULL section.
+  unsigned SecNdx =
+      IsStatic ? getDotSymTabSecNo() - 1 : getDotDynSymSecNo() - 1;
+  // If the symbol table section is explicitly described in the YAML
+  // then we should set the fields requested.
+  if (SecNdx < Doc.Sections.size()) {
+    ELFYAML::Section *Sec = Doc.Sections[SecNdx].get();
+    SHeader.sh_addr = Sec->Address;
+    if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec))
+      SHeader.sh_info = S->Info;
   }
 
   std::vector<Elf_Sym> Syms;
   {
     // Ensure STN_UNDEF is present
     Elf_Sym Sym;
     zero(Sym);
     Syms.push_back(Sym);
for (auto i = Section.Content.binary_size(); i < Section.Size; ++i)
     OS.write(0);
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else if (Section.Type == llvm::ELF::SHT_RELR)
     SHeader.sh_entsize = sizeof(Elf_Relr);
   else
     SHeader.sh_entsize = 0;
   SHeader.sh_size = Section.Size;
+  SHeader.sh_info = Section.Info;
 }
 
 static bool isMips64EL(const ELFYAML::Object &Doc) {
   return Doc.Header.Machine == ELFYAML::ELF_EM(llvm::ELF::EM_MIPS) &&
          Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64) &&
          Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
 }