[yaml2obj/obj2yaml] - Make RawContentSection::Info Optional<>

[grimar]

Summary

This allows to customize this field for "implicit" sections properly.

[jhenderson]

Looks good aside from some minor comments. By the way, you don't need the "to be" in the patch title.

test/tools/obj2yaml/implicit-sections-info.yaml

1 ↗

(On Diff #205311)

I'm not sure this test needs to be called "implicit-sections-info.yaml". Simply "section-info.yaml" seems like enough.

1 ↗

(On Diff #205311)

create Info -> write a section Info

23–24 ↗

(On Diff #205311)

Nit: spurious extra spaces between tag and value on these two lines.

tools/yaml2obj/yaml2elf.cpp

490 ↗

(On Diff #205311)

There should probably be a blank line before this if, to match the other blocks.

[grimar]

• Addressed review comments.

[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 {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
-  llvm::yaml::Hex64 Info;
+  Optional<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);
-  IO.mapOptional("Info", Section.Info, Hex64(0));
+  IO.mapOptional("Info", Section.Info);
 }
 
 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/sections-info.yaml

+## Check that obj2yaml does not write a section Info
+## field in the case when it has a value of zero.
+
+# RUN: yaml2obj %s -o %t
+# RUN: obj2yaml %t | FileCheck %s
+
+# CHECK:      Sections:
+# CHECK-NEXT:  - Name: .foo
+# CHECK-NEXT:    Type: SHT_PROGBITS
+# CHECK-NEXT:  - Name: .bar
+# CHECK-NEXT:    Type: SHT_PROGBITS
+# CHECK-NEXT:    Info: 0x0000000000000001
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+  - Name: .bar
+    Type: SHT_PROGBITS
+    Info: 1

llvm/trunk/test/tools/yaml2obj/dynsymtab-implicit-sections-size-content.yaml

 # CASE4-NEXT: Type: SHT_DYNSYM
 # CASE4-NEXT: Flags [
 # CASE4-NEXT:   SHF_ALLOC
 # CASE4-NEXT: ]
 # CASE4-NEXT: Address: 0x0
 # CASE4-NEXT: Offset: 0x180
 # CASE4-NEXT: Size: 2
 # CASE4-NEXT: Link: 0
-# CASE4-NEXT: Info: 0
+# CASE4-NEXT: Info: 1
 # CASE4-NEXT: AddressAlignment: 0
 # CASE4-NEXT: EntrySize: 24
 # CASE4-NEXT: SectionData (
 # CASE4-NEXT:   0000: 0123
 # CASE4-NEXT: )
 
 --- !ELF
 FileHeader:

 # CASE5-NEXT: Type: SHT_DYNSYM
 # CASE5-NEXT: Flags [
 # CASE5-NEXT:   SHF_ALLOC
 # CASE5-NEXT: ]
 # CASE5-NEXT: Address: 0x0
 # CASE5-NEXT: Offset: 0x180
 # CASE5-NEXT: Size: 5
 # CASE5-NEXT: Link: 0
-# CASE5-NEXT: Info: 0
+# CASE5-NEXT: Info: 1
 # CASE5-NEXT: AddressAlignment: 0
 # CASE5-NEXT: EntrySize: 24
 # CASE5-NEXT: SectionData (
 # CASE5-NEXT:   0000: 00000000 00
 # CASE5-NEXT: )
 
 --- !ELF
 FileHeader:

 # CASE6-NEXT: Type: SHT_DYNSYM
 # CASE6-NEXT: Flags [
 # CASE6-NEXT:   SHF_ALLOC
 # CASE6-NEXT: ]
 # CASE6-NEXT: Address: 0x0
 # CASE6-NEXT: Offset: 0x180
 # CASE6-NEXT: Size: 4
 # CASE6-NEXT: Link: 0
-# CASE6-NEXT: Info: 0
+# CASE6-NEXT: Info: 1
 # CASE6-NEXT: AddressAlignment: 0
 # CASE6-NEXT: EntrySize: 24
 # CASE6-NEXT: SectionData (
 # CASE6-NEXT:   0000: 01230000
 # CASE6-NEXT: )
 
 --- !ELF
 FileHeader:

 # CASE7-NEXT:  Type: SHT_DYNSYM
 # CASE7-NEXT:  Flags [
 # CASE7-NEXT:    SHF_ALLOC
 # CASE7-NEXT:  ]
 # CASE7-NEXT:  Address: 0x0
 # CASE7-NEXT:  Offset: 0x180
 # CASE7-NEXT:  Size: 2
 # CASE7-NEXT:  Link: 0
-# CASE7-NEXT:  Info: 0
+# CASE7-NEXT:  Info: 1
 # CASE7-NEXT:  AddressAlignment: 0
 # CASE7-NEXT:  EntrySize: 24
 # CASE7-NEXT:  SectionData (
 # CASE7-NEXT:    0000: 0123
 # CASE7-NEXT:  )
 
 --- !ELF
 FileHeader:

llvm/trunk/test/tools/yaml2obj/implicit-sections-info.yaml

+## Check the values of sh_info fields set by default for
+## explicitly listed .dynstr, .dynsym, .strtab and .symtab
+## sections.
+##
+## For symbol table sections, sh_info has a value which is
+## one greater than the symbol table index of the last
+## local symbol.
+##
+## sh_info isn't set for string table sections.
+
+# RUN: yaml2obj --docnum=1 %s -o %t
+# RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=CASE1
+
+# CASE1:      Name: .symtab
+# CASE1:      Info:
+# CASE1-SAME: 2
+# CASE1:      Name: .strtab
+# CASE1:      Info:
+# CASE1-SAME: 0
+# CASE1:      Name: .dynsym
+# CASE1:      Info:
+# CASE1-SAME: 1
+# CASE1:      Name: .dynstr
+# CASE1:      Info:
+# CASE1-SAME: 0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .symtab
+    Type:  SHT_SYMTAB
+  - Name:  .strtab
+    Type:  SHT_STRTAB
+  - Name:  .dynsym
+    Type:  SHT_DYNSYM
+  - Name:  .dynstr
+    Type:  SHT_STRTAB
+Symbols:
+  - Name:    local
+  - Name:    global1
+    Binding: STB_GLOBAL
+DynamicSymbols:
+  - Name:    global2
+    Binding: STB_GLOBAL
+
+## In the case when these sections are not defined in YAML, the
+## behavior is the same as when we define them, but do not set the Info.
+
+# RUN: yaml2obj --docnum=2 %s -o %t
+# RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=CASE1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Symbols:
+  - Name:    local
+  - Name:    global1
+    Binding: STB_GLOBAL
+DynamicSymbols:
+  - Name:    global2
+    Binding: STB_GLOBAL
+
+## Check we are able to set any sh_info explicitly.
+
+# RUN: yaml2obj --docnum=3 %s -o %t
+# RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=CASE2
+
+# CASE2:      Name: .dynstr
+# CASE2:      Info:
+# CASE2-SAME: 10
+# CASE2:      Name: .dynsym
+# CASE2:      Info:
+# CASE2-SAME: 11
+# CASE2:      Name: .strtab
+# CASE2:      Info:
+# CASE2-SAME: 12
+# CASE2:      Name: .symtab
+# CASE2:      Info:
+# CASE2-SAME: 13
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .dynstr
+    Type:  SHT_STRTAB
+    Info:  10
+  - Name:  .dynsym
+    Type:  SHT_DYNSYM
+    Info:  11
+  - Name:  .strtab
+    Type:  SHT_STRTAB
+    Info:  12
+  - Name:  .symtab
+    Type:  SHT_SYMTAB
+    Info:  13
+Symbols:
+  - Name:    local
+  - Name:    global1
+    Binding: STB_GLOBAL
+DynamicSymbols:
+  - Name:    global2
+    Binding: STB_GLOBAL

llvm/trunk/test/tools/yaml2obj/symtab-implicit-sections-size-content.yaml

 # CASE4:      Name: .symtab
 # CASE4-NEXT: Type: SHT_SYMTAB
 # CASE4-NEXT: Flags [ (0x0)
 # CASE4-NEXT: ]
 # CASE4-NEXT: Address: 0x0
 # CASE4-NEXT: Offset: 0x140
 # CASE4-NEXT: Size: 2
 # CASE4-NEXT: Link: 2
-# CASE4-NEXT: Info: 0
+# CASE4-NEXT: Info: 1
 # CASE4-NEXT: AddressAlignment: 0
 # CASE4-NEXT: EntrySize: 24
 # CASE4-NEXT: SectionData (
 # CASE4-NEXT:   0000: 0123
 # CASE4-NEXT: )
 
 --- !ELF
 FileHeader:

 # CASE5:      Name: .symtab (19)
 # CASE5-NEXT: Type: SHT_SYMTAB (0x2)
 # CASE5-NEXT: Flags [ (0x0)
 # CASE5-NEXT: ]
 # CASE5-NEXT: Address: 0x0
 # CASE5-NEXT: Offset: 0x140
 # CASE5-NEXT: Size: 5
 # CASE5-NEXT: Link: 2
-# CASE5-NEXT: Info: 0
+# CASE5-NEXT: Info: 1
 # CASE5-NEXT: AddressAlignment: 0
 # CASE5-NEXT: EntrySize: 24
 # CASE5-NEXT: SectionData (
 # CASE5-NEXT:   0000: 00000000 00
 # CASE5-NEXT: )
 
 --- !ELF
 FileHeader:

 # CASE6:      Name: .symtab
 # CASE6-NEXT: Type: SHT_SYMTAB
 # CASE6-NEXT: Flags [
 # CASE6-NEXT: ]
 # CASE6-NEXT: Address: 0x0
 # CASE6-NEXT: Offset: 0x140
 # CASE6-NEXT: Size: 4
 # CASE6-NEXT: Link: 2
-# CASE6-NEXT: Info: 0
+# CASE6-NEXT: Info: 1
 # CASE6-NEXT: AddressAlignment: 0
 # CASE6-NEXT: EntrySize: 24
 # CASE6-NEXT: SectionData (
 # CASE6-NEXT:   0000: 01230000
 # CASE6-NEXT: )
 
 --- !ELF
 FileHeader:

 # CASE7:       Name: .symtab
 # CASE7-NEXT:  Type: SHT_SYMTAB
 # CASE7-NEXT:  Flags [
 # CASE7-NEXT:  ]
 # CASE7-NEXT:  Address: 0x0
 # CASE7-NEXT:  Offset: 0x140
 # CASE7-NEXT:  Size: 2
 # CASE7-NEXT:  Link: 2
-# CASE7-NEXT:  Info: 0
+# CASE7-NEXT:  Info: 1
 # CASE7-NEXT:  AddressAlignment: 0
 # CASE7-NEXT:  EntrySize: 24
 # CASE7-NEXT:  SectionData (
 # CASE7-NEXT:    0000: 0123
 # CASE7-NEXT:  )
 
 --- !ELF
 FileHeader:

llvm/trunk/tools/obj2yaml/elf2yaml.cpp

if (std::error_code EC = dumpCommonSection(Shdr, *S))
     return EC;
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)
     return errorToErrorCode(ContentOrErr.takeError());
   ArrayRef<uint8_t> Content = *ContentOrErr;
   if (!Content.empty())
     S->Content = yaml::BinaryRef(Content);
-  S->Info = Shdr->sh_info;
+  if (Shdr->sh_info)
+    S->Info = static_cast<llvm::yaml::Hex64>(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,
 
   if (YAMLSec && YAMLSec->Flags)
     SHeader.sh_flags = *YAMLSec->Flags;
   else if (!IsStatic)
     SHeader.sh_flags = ELF::SHF_ALLOC;
 
   // If the symbol table section is explicitly described in the YAML
   // then we should set the fields requested.
-  SHeader.sh_info =
-      RawSec ? (unsigned)RawSec->Info : findFirstNonGlobal(Symbols) + 1;
+  SHeader.sh_info = (RawSec && RawSec->Info) ? (unsigned)(*RawSec->Info)
+                                             : findFirstNonGlobal(Symbols) + 1;
   SHeader.sh_entsize = (YAMLSec && YAMLSec->EntSize)
                            ? (uint64_t)(*YAMLSec->EntSize)
                            : sizeof(Elf_Sym);
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 8;
   SHeader.sh_addr = YAMLSec ? (uint64_t)YAMLSec->Address : 0;
 
   auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   if (RawSec && (RawSec->Content || RawSec->Size)) {
void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
   } else {
     STB.write(OS);
     SHeader.sh_size = STB.getSize();
   }
 
   if (YAMLSec && YAMLSec->EntSize)
     SHeader.sh_entsize = *YAMLSec->EntSize;
 
+  if (RawSec && RawSec->Info)
+    SHeader.sh_info = *RawSec->Info;
+
   if (YAMLSec && YAMLSec->Flags)
     SHeader.sh_flags = *YAMLSec->Flags;
   else if (Name == ".dynstr")
     SHeader.sh_flags = ELF::SHF_ALLOC;
 
   // If the section is explicitly described in the YAML
   // then we want to use its section address.
   if (YAMLSec)
bool ELFState<ELFT>::writeSectionContent(
   SHeader.sh_size = writeRawSectionData(OS, Section);
 
   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_info = Section.Info;
+
+  if (Section.Info)
+    SHeader.sh_info = *Section.Info;
+
   return true;
 }
 
 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);
 }