[yaml2obj,obj2yaml] - Make Symbol::Section field optional.

[grimar]

Summary

This is similar to what we did earlier for fields of the Section class.

When a field is optional we can use the =<none> syntax in macros.

This was splitted from D92478.

[MaskRay]

llvm/test/tools/yaml2obj/ELF/dynamic-symbols.yaml

79

You may need a test where Section: is empty

[grimar]

• Addressed review comment.

llvm/test/tools/yaml2obj/ELF/dynamic-symbols.yaml

79

I've added this test.

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct SectionHeaderTable {
   Optional<std::vector<SectionHeader>> Sections;
   Optional<std::vector<SectionHeader>> Excluded;
   Optional<bool> NoHeaders;
 };
 
 struct Symbol {
   StringRef Name;
   ELF_STT Type;
-  StringRef Section;
+  Optional<StringRef> Section;
   Optional<ELF_SHN> Index;
   ELF_STB Binding;
   llvm::yaml::Hex64 Value;
   llvm::yaml::Hex64 Size;
   Optional<uint8_t> Other;
 
   Optional<uint32_t> StName;
 };

llvm/lib/ObjectYAML/ELFEmitter.cpp

for (const ELFYAML::Symbol &Sym : Symbols) {
     // use it. This is useful for preparing broken objects. Otherwise, we add
     // the specified Name to the string table builder to get its offset.
     if (Sym.StName)
       Symbol.st_name = *Sym.StName;
     else if (!Sym.Name.empty())
       Symbol.st_name = Strtab.getOffset(ELFYAML::dropUniqueSuffix(Sym.Name));
 
     Symbol.setBindingAndType(Sym.Binding, Sym.Type);
-    if (!Sym.Section.empty())
-      Symbol.st_shndx = toSectionIndex(Sym.Section, "", Sym.Name);
+    if (Sym.Section)
+      Symbol.st_shndx = toSectionIndex(*Sym.Section, "", Sym.Name);
     else if (Sym.Index)
       Symbol.st_shndx = *Sym.Index;
 
     Symbol.st_value = Sym.Value;
     Symbol.st_other = Sym.Other ? *Sym.Other : 0;
     Symbol.st_size = Sym.Size;
   }
 

llvm/lib/ObjectYAML/ELFYAML.cpp

StringRef ScalarTraits<ELFYAML::YAMLIntUInt>::input(StringRef Scalar, void *Ctx,
   Val = UInt;
   return "";
 }
 
 void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
   IO.mapOptional("Name", Symbol.Name, StringRef());
   IO.mapOptional("StName", Symbol.StName);
   IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
-  IO.mapOptional("Section", Symbol.Section, StringRef());
+  IO.mapOptional("Section", Symbol.Section);
   IO.mapOptional("Index", Symbol.Index);
   IO.mapOptional("Binding", Symbol.Binding, ELFYAML::ELF_STB(0));
   IO.mapOptional("Value", Symbol.Value, Hex64(0));
   IO.mapOptional("Size", Symbol.Size, Hex64(0));
 
   // Symbol's Other field is a bit special. It is usually a field that
   // represents st_other and holds the symbol visibility. However, on some
   // platforms, it can contain bit fields and regular values, or even sometimes a
   // crazy mix of them (see comments for NormalizedOther). Because of this, we
   // need special handling.
   MappingNormalization<NormalizedOther, Optional<uint8_t>> Keys(IO,
                                                                 Symbol.Other);
   IO.mapOptional("Other", Keys->Other);
 }
 
 std::string MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
                                                      ELFYAML::Symbol &Symbol) {
-  if (Symbol.Index && Symbol.Section.data())
+  if (Symbol.Index && Symbol.Section)
     return "Index and Section cannot both be specified for Symbol";
   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);

llvm/test/tools/yaml2obj/ELF/dynamic-symbols.yaml

 # SECTION-NEXT: SHF_ALLOC
 
 # SYMBOL-DAG: d dynlocal
 # SYMBOL-DAG: D dynglobal
 # SYMBOL-DAG: V dynweak
 
 ## Check we can use numeric values to refer to sections.
 
-# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: yaml2obj --docnum=2 -DSEC=0xff %s -o %t2
 # RUN: llvm-readobj --dyn-symbols %t2 2>&1 | FileCheck -DFILE=%t2 %s --check-prefix=NUM
 
 # NUM:      Name: foo
 # NUM:      Section:
 # NUM-SAME: .data (0x1)
 
 # NUM:      Name: bar
 # NUM:      Section:
 # NUM-SAME: .dynsym (0x2)
 
-# NUM:      Name: zed
+# NUM:      Name: zed1
 # NUM: warning: '[[FILE]]': invalid section index: 255
 # NUM:      Section:
 # NUM-SAME: <?> (0xFF)
 
+# NUM:      Name: zed2
+# NUM:      Section:
+# NUM-SAME: Undefined (0x0)
+
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .data
     Type: SHT_PROGBITS
 DynamicSymbols:
-  - Name: foo
+  - Name:    foo
     Section: 1
-  - Name: bar
+  - Name:    bar
     Section: 2
-  - Name: zed
-    Section: 0xff
+  - Name:    zed1
+    Section: [[SEC=<none>]]
+## The case when no "Section" key is set.
+  - Name: zed2
+
+## Check that by default no section is set.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2.none
+# RUN: llvm-readobj --dyn-symbols %t2.none 2>&1 | \
+# RUN:   FileCheck -DFILE=%t2.none %s --check-prefix=NONE
+
+# NONE:      Name: zed1
+# NONE:      Section:
+# NONE-SAME: Undefined (0x0)
+# NONE:      Name: zed2
+# NONE:      Section:
+# NONE-SAME: Undefined (0x0)
 
 ## Check we report errors when unknown sections are referenced by dynamic symbols.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck -DFILE=%t3 %s --check-prefix=ERR
 
 # ERR: error: unknown section referenced: '.sec1' by YAML symbol 'foo'
 # ERR: error: unknown section referenced: '.sec2' by YAML symbol 'bar'
+# ERR: error: unknown section referenced: '' by YAML symbol 'zed'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .data
     Type: SHT_PROGBITS
 DynamicSymbols:
-  - Name: foo
+  - Name:    foo
     Section: .sec1
-  - Name: bar
+  - Name:    bar
     Section: .sec2
+  - Name:    zed
+    Section: ''