[yaml2obj] - Make `Section::Link` field to be `Optional<>`.

[grimar]

Summary

Link is not an optional field currently.
Because of this it is not convenient to write macros.

This makes it to be optional and fixes corresponding test cases.

[MaskRay]

LGTM.

This makes it to be optional and fixes corresponding test cases.

This makes it optional...

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct Chunk {
   Chunk(ChunkKind K) : Kind(K) {}
   virtual ~Chunk();
 };
 
 struct Section : public Chunk {
   ELF_SHT Type;
   Optional<ELF_SHF> Flags;
   Optional<llvm::yaml::Hex64> Address;
-  StringRef Link;
+  Optional<StringRef> Link;
   llvm::yaml::Hex64 AddressAlign;
   Optional<llvm::yaml::Hex64> EntSize;
 
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
 
   // Usually sections are not created implicitly, but loaded from YAML.
   // When they are, this flag is used to signal about that.

llvm/lib/ObjectYAML/ELFEmitter.cpp

for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
 
     // Set the offset for all sections, except the SHN_UNDEF section with index
     // 0 when not explicitly requested.
     if (!IsFirstUndefSection || Sec->Offset)
       SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, Sec->Offset);
 
     assignSectionAddress(SHeader, Sec);
 
-    if (!Sec->Link.empty())
-      SHeader.sh_link = toSectionIndex(Sec->Link, Sec->Name);
+    if (Sec->Link)
+      SHeader.sh_link = toSectionIndex(*Sec->Link, Sec->Name);
 
     if (IsFirstUndefSection) {
       if (auto RawSec = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
         // We do not write any content for special SHN_UNDEF section.
         if (RawSec->Size)
           SHeader.sh_size = *RawSec->Size;
         if (RawSec->Info)
           SHeader.sh_info = *RawSec->Info;
void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
   zero(SHeader);
   SHeader.sh_name = getSectionNameOffset(IsStatic ? ".symtab" : ".dynsym");
 
   if (YAMLSec)
     SHeader.sh_type = YAMLSec->Type;
   else
     SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
 
-  if (RawSec && !RawSec->Link.empty()) {
+  if (RawSec && RawSec->Link) {
     // If the Link field is explicitly defined in the document,
     // we should use it.
-    SHeader.sh_link = toSectionIndex(RawSec->Link, RawSec->Name);
+    SHeader.sh_link = toSectionIndex(*RawSec->Link, RawSec->Name);
   } else {
     // When we describe the .dynsym section in the document explicitly, it is
     // allowed to omit the "DynamicSymbols" tag. In this case .dynstr is not
     // added implicitly and we should be able to leave the Link zeroed if
     // .dynstr is not defined.
     unsigned Link = 0;
     if (IsStatic) {
       if (!ExcludedSectionHeaders.count(".strtab"))
void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
   if (RawSec && RawSec->Info)
     SHeader.sh_info = *RawSec->Info;
 
   if (YAMLSec && YAMLSec->Flags)
     SHeader.sh_flags = *YAMLSec->Flags;
   else if (Name == ".debug_str")
     SHeader.sh_flags = ELF::SHF_MERGE | ELF::SHF_STRINGS;
 
-  if (YAMLSec && !YAMLSec->Link.empty())
-    SHeader.sh_link = toSectionIndex(YAMLSec->Link, Name);
+  if (YAMLSec && YAMLSec->Link)
+    SHeader.sh_link = toSectionIndex(*YAMLSec->Link, Name);
 
   assignSectionAddress(SHeader, YAMLSec);
 }
 
 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
   ErrHandler(Msg);
   HasError = true;
 }
void ELFState<ELFT>::writeSectionContent(
   bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
 
   // For relocation section set link to .symtab by default.
   unsigned Link = 0;
-  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
+  if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (!Section.RelocatableSec.empty())
     SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
 
   if (!Section.Relocations)
     return;
 
   for (const ELFYAML::Relocation &Rel : *Section.Relocations) {
-    unsigned SymIdx = Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name,
-                                                 Section.Link == ".dynsym")
-                                 : 0;
+    const bool IsDynamic = Section.Link && (*Section.Link == ".dynsym");
+    unsigned SymIdx =
+        Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name, IsDynamic) : 0;
     if (IsRela) {
       Elf_Rela REntry;
       zero(REntry);
       REntry.r_offset = Rel.Offset;
       REntry.r_addend = Rel.Addend;
       REntry.setSymbolAndType(SymIdx, Rel.Type, isMips64EL(Doc));
       CBA.write((const char *)&REntry, sizeof(REntry));
     } else {

 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GroupSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_GROUP &&
          "Section type is not SHT_GROUP");
 
   unsigned Link = 0;
-  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
+  if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   SHeader.sh_entsize = 4;
 
   if (Section.Signature)
     SHeader.sh_info =
         toSymbolIndex(*Section.Signature, Section.Name, /*IsDynamic=*/false);
void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::CallGraphProfileSection &Section,
     ContiguousBlobAccumulator &CBA) {
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = 16;
 
   unsigned Link = 0;
-  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
+  if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::CallGraphEntry &E : *Section.Entries) {
     unsigned From = toSymbolIndex(E.From, Section.Name, /*IsDynamic=*/false);
     unsigned To = toSymbolIndex(E.To, Section.Name, /*IsDynamic=*/false);
 
     CBA.write<uint32_t>(From, ELFT::TargetEndianness);
     CBA.write<uint32_t>(To, ELFT::TargetEndianness);
     CBA.write<uint64_t>(E.Weight, ELFT::TargetEndianness);
     SHeader.sh_size += 16;
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::HashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
-  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".dynsym") &&
+  if (!Section.Link && !ExcludedSectionHeaders.count(".dynsym") &&
       SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = sizeof(typename ELFT::Word);
 
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::AddrsigSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
-  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
+  if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (!Section.Symbols)
     return;
 
   if (!Section.Symbols)
     return;
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   SHeader.sh_size = CBA.tell() - Offset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GnuHashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
-  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".dynsym") &&
+  if (!Section.Link && !ExcludedSectionHeaders.count(".dynsym") &&
       SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
   if (!Section.HashBuckets)
     return;
 
   if (!Section.Header)
     return;

llvm/lib/ObjectYAML/ELFYAML.cpp

std::string MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
   return "";
 }
 
 static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
   IO.mapOptional("Name", Section.Name, StringRef());
   IO.mapRequired("Type", Section.Type);
   IO.mapOptional("Flags", Section.Flags);
   IO.mapOptional("Address", Section.Address);
-  IO.mapOptional("Link", Section.Link, StringRef());
+  IO.mapOptional("Link", Section.Link);
   IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
   IO.mapOptional("EntSize", Section.EntSize);
   IO.mapOptional("Offset", Section.Offset);
 
   IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Size", Section.Size);
 
   // obj2yaml does not dump these fields. They are expected to be empty when we

llvm/test/tools/llvm-readobj/ELF/relr-relocs.test

 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
     Flags:   [ SHF_ALLOC ]
     Entries: [ 0x00010D60, 0x00000103, 0x00020000,
                0x000F0501, 0x50400009 ]
     EntSize: [[ENTSIZE=<none>]]
     ShType:  [[SHTYPE=<none>]]
-    Link:    [[LINK=""]]
+    Link:    [[LINK=<none>]]
 
 ## Check we report a warning when we are unable to dump relocations
 ## for a SHT_RELR/SHT_ANDROID_RELR section.
 
 ## Case A: check the case when relocations can't be read from an SHT_RELR section.
 # RUN: yaml2obj --docnum=2 -DENTSIZE=1 %s -o %t2.broken
 # RUN: llvm-readobj --relocations %t2.broken 2>&1 | \
 # RUN:   FileCheck -DFILE=%t2.broken --check-prefix=BROKEN-LLVM %s -DSECNAME=SHT_RELR

llvm/test/tools/obj2yaml/ELF/DWARF/debug-addr.yaml

 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:         .debug_addr
     Type:         [[TYPE=SHT_PROGBITS]]
     Flags:        [[FLAGS=<none>]]
-    Link:         [[LINK='']]
+    Link:         [[LINK=<none>]]
     EntSize:      [[ENTSIZE=<none>]]
     Info:         [[INFO=<none>]]
     AddressAlign: [[ADDRALIGN=0]]
     Address:      [[ADDRESS=<none>]]
   - Name:         .sec
     Type:         SHT_PROGBITS
 DWARF:
   debug_addr:

llvm/test/tools/obj2yaml/ELF/DWARF/debug-aranges.yaml

 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:         .debug_aranges
     Type:         [[TYPE=SHT_PROGBITS]]
     Flags:        [[FLAGS=<none>]]
-    Link:         [[LINK='']]
+    Link:         [[LINK=<none>]]
     EntSize:      [[ENTSIZE=<none>]]
     Info:         [[INFO=<none>]]
     AddressAlign: [[ADDRALIGN=0]]
     Address:      [[ADDRESS=<none>]]
   - Name:         .sec
     Type:         SHT_PROGBITS
 DWARF:
   debug_aranges:

llvm/test/tools/obj2yaml/ELF/DWARF/debug-ranges.yaml

 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:         .debug_ranges
     Type:         [[TYPE=SHT_PROGBITS]]
     Flags:        [[FLAGS=<none>]]
-    Link:         [[LINK='']]
+    Link:         [[LINK=<none>]]
     EntSize:      [[ENTSIZE=<none>]]
     Info:         [[INFO=<none>]]
     AddressAlign: [[ADDRALIGN=0]]
     Address:      [[ADDRESS=<none>]]
   - Name:         .sec
     Type:         SHT_PROGBITS
 DWARF:
   debug_info:
     - Version:  4
       AddrSize: 8
   debug_ranges:
     - Entries:
         - LowOffset:  0x10
           HighOffset: 0x20

llvm/test/tools/obj2yaml/ELF/DWARF/debug-str.yaml

 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:         .debug_str
     Type:         SHT_[[TYPE=PROGBITS]]
     Flags:        [[FLAGS=<none>]]
-    Link:         [[LINK='']]
+    Link:         [[LINK=<none>]]
     EntSize:      [[ENTSIZE=1]]
     Info:         [[INFO=<none>]]
     AddressAlign: [[ADDRALIGN=1]]
     Address:      [[ADDRESS=<none>]]
   - Name:         .sec
     Type:         SHT_PROGBITS
 DWARF:
   debug_str:

llvm/test/tools/yaml2obj/ELF/dynsym-section.yaml

 
 # OFFSET:      Section Headers:
 # OFFSET-NEXT:   [Nr] Name    Type   Address          Off    Size   ES Flg Lk Inf Al
 # OFFSET-NEXT:   [ 0]         NULL   0000000000000000 000000 000000 00     0   0  0
 # OFFSET-NEXT:   [ 1] .dynsym DYNSYM 0000000000000000 000100 000018 18   A 0   1  0
 
 ## Check we are able to set Link = 0 for the .dynsym section explicitly.
 
-# RUN: yaml2obj %s --docnum=2 -DLINK="Link: 0" -o %t2
+# RUN: yaml2obj %s --docnum=2 -DLINK=0 -o %t2
 # RUN: llvm-readelf --section-headers %t2 | FileCheck %s --check-prefix=LINK-NULL
 
 # LINK-NULL: [Nr] Name    {{.*}} Flg Lk Inf
 # LINK-NULL: [ 1] .dynsym {{.*}}   A 0   1
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
-    [[LINK]]
+    Link: [[LINK=<none>]]
   - Name: .dynstr
     Type: SHT_STRTAB
   - Name: .foo
     Type: SHT_PROGBITS
 
 ## Check that by default the .dynsym section will be linked to the .dynstr section,
 ## when the latter one exists.
 
-# RUN: yaml2obj %s --docnum=2 -DLINK="" -o %t3
+# RUN: yaml2obj %s --docnum=2 -o %t3
 # RUN: llvm-readelf --section-headers %t3 | FileCheck %s --check-prefix=LINK-DEFAULT
 
 # LINK-DEFAULT: [Nr] Name    {{.*}} Flg Lk Inf
 # LINK-DEFAULT: [ 1] .dynsym {{.*}}   A 2   1
 # LINK-DEFAULT: [ 2] .dynstr {{.*}}   A 0   0
 
 ## Even when the .dynstr section exists, we can explicitly link the .dynsym section
 ## to another section.
 
-# RUN: yaml2obj %s --docnum=2 -DLINK="Link: 3" -o %t4
+# RUN: yaml2obj %s --docnum=2 -DLINK=3 -o %t4
 # RUN: llvm-readelf --section-headers %t4 | FileCheck %s --check-prefix=LINK-FOO
 
 # LINK-FOO: [Nr] Name     {{.*}} Flg Lk Inf
 # LINK-FOO: [ 1] .dynsym  {{.*}}   A 3   1
 # LINK-FOO: [ 3] .foo
 
 ## Check we can use a section name as a Link value for .dynsym.
 
-# RUN: yaml2obj %s --docnum=2 -DLINK="Link: .foo" -o %t5
+# RUN: yaml2obj %s --docnum=2 -DLINK=.foo -o %t5
 # RUN: llvm-readelf --section-headers %t5 | FileCheck %s --check-prefix=LINK-FOO

llvm/tools/obj2yaml/elf2yaml.cpp

bool ELFDumper<ELFT>::shouldPrintSection(const ELFYAML::Section &S,
   // the content of DWARF sections can be successfully parsed into the "DWARF:"
   // entry but their section headers may have special flags, entry size, address
   // alignment, etc. We will preserve the header for them under such
   // circumstances.
   StringRef SecName = S.Name.substr(1);
   if (DWARF && DWARF->getNonEmptySectionNames().count(SecName)) {
     if (const ELFYAML::RawContentSection *RawSec =
             dyn_cast<const ELFYAML::RawContentSection>(&S)) {
-      if (RawSec->Type != ELF::SHT_PROGBITS || !RawSec->Link.empty() ||
-          RawSec->Info || RawSec->AddressAlign != 1 || RawSec->Address ||
-          RawSec->EntSize)
+      if (RawSec->Type != ELF::SHT_PROGBITS || RawSec->Link || RawSec->Info ||
+          RawSec->AddressAlign != 1 || RawSec->Address || RawSec->EntSize)
         return true;
 
       ELFYAML::ELF_SHF ShFlags = RawSec->Flags.getValueOr(ELFYAML::ELF_SHF(0));
 
       if (SecName == "debug_str")
         return ShFlags != ELFYAML::ELF_SHF(ELF::SHF_MERGE | ELF::SHF_STRINGS);
 
       return ShFlags != 0;