[yaml2obj][obj2yaml] - Simplify format of the SHT_LLVM_ADDRSIG section.

[grimar]

Summary

Previously the description allowed to describe symbols with use of
Name and Index keys. This patch removes them and now it is still
possible to use either names or symbol indexes, but the code is simpler
and the format is slightly different.

Such a change will be useful for another patches, e.g see:
https://reviews.llvm.org/D73788#inline-671077

[grimar]

llvm/test/tools/llvm-readobj/ELF/addrsig.test

23

Thinking about his again, I wonder if we want the following output format:

Symbols:
  - foo
  - bar

All what is needed is to stop using YAMLFlowString and use StringRef,
so the change is trivial.
That might produce a nicer (?) output when symbol names are long probably,
though I am not sure we should care too much here and/or what is better.

[MaskRay]

llvm/test/tools/llvm-readobj/ELF/addrsig.test

23

Is there a test having a special symbol name (a metacharacter in YAML.)? e.g. [

Just want to make sure they are properly quoted.

[MaskRay]

llvm/test/tools/llvm-readobj/ELF/addrsig.test

23

A list of YAMLFlowString can be wrapped (default wrap column is 70), can't it?

If yes, I think YAMLFlowString is fine. I don't have a strong opinion, though. We can also use StringRef.

[jhenderson]

LGTM, once @MaskRay is happy.

llvm/test/tools/llvm-readobj/ELF/addrsig.test

23

I personally prefer the YAMLFlowString syntax, as long as it can be wrapped as @MaskRay mentions. I think we made a similar change in recent months in that direction for something else, but I don't remember what.

However, if there's strong reasoning to favour the StringRef approach, I don't mind either.

[grimar]

llvm/test/tools/llvm-readobj/ELF/addrsig.test

23

Is there a test having a special symbol name (a metacharacter in YAML.)? e.g. [

If I correctly understood the idea, we have no tests for symbol like "[aabb", "aa[bb" etc yet.

23

A list of YAMLFlowString can be wrapped (default wrap column is 70), can't it?
If yes, I think YAMLFlowString is fine

Yep. here is the output from obj2yaml I had when tested it:

Symbols:         [ foo, bar, foo, bar, foo, bar, foo, bar, foo, bar,
                   foo, bar, foo, bar, foo, bar, foo, bar ]

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct VerneedSection : Section {
 
   VerneedSection() : Section(ChunkKind::Verneed) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::Verneed;
   }
 };
 
-struct AddrsigSymbol {
-  AddrsigSymbol(StringRef N) : Name(N), Index(None) {}
-  AddrsigSymbol(llvm::yaml::Hex32 Ndx) : Name(None), Index(Ndx) {}
-  AddrsigSymbol() : Name(None), Index(None) {}
-
-  Optional<StringRef> Name;
-  Optional<llvm::yaml::Hex32> Index;
-};
-
 struct AddrsigSection : Section {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
-  Optional<std::vector<AddrsigSymbol>> Symbols;
+  Optional<std::vector<YAMLFlowString>> Symbols;
 
   AddrsigSection() : Section(ChunkKind::Addrsig) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
 };
 
 struct LinkerOption {
   StringRef Key;
for (const std::unique_ptr<Chunk> &Sec : Chunks)
         Ret.push_back(S);
     return Ret;
   }
 };
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::AddrsigSymbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)

 template <> struct MappingTraits<ELFYAML::VerneedEntry> {
   static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
 };
 
 template <> struct MappingTraits<ELFYAML::VernauxEntry> {
   static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
 };
 
-template <> struct MappingTraits<ELFYAML::AddrsigSymbol> {
-  static void mapping(IO &IO, ELFYAML::AddrsigSymbol &Sym);
-};
-
 template <> struct MappingTraits<ELFYAML::LinkerOption> {
   static void mapping(IO &IO, ELFYAML::LinkerOption &Sym);
 };
 
 template <> struct MappingTraits<ELFYAML::CallGraphEntry> {
   static void mapping(IO &IO, ELFYAML::CallGraphEntry &E);
 };
 

llvm/lib/ObjectYAML/ELFEmitter.cpp

void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
-  for (const ELFYAML::AddrsigSymbol &Sym : *Section.Symbols) {
-    uint64_t Val =
-        Sym.Name ? toSymbolIndex(*Sym.Name, Section.Name, /*IsDynamic=*/false)
-                 : (uint32_t)*Sym.Index;
-    SHeader.sh_size += encodeULEB128(Val, OS);
-  }
+  for (StringRef Sym : *Section.Symbols)
+    SHeader.sh_size += encodeULEB128(
+        toSymbolIndex(Sym, Section.Name, /*IsDynamic=*/false), OS);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::NoteSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);

llvm/lib/ObjectYAML/ELFYAML.cpp

if (Sec->Content || Sec->Size) {
 
       if (Sec->Symbols)
         return "\"Symbols\" cannot be used with \"Content\" or \"Size\"";
       return {};
     }
 
     if (!Sec->Symbols)
       return {};
-
-    for (const ELFYAML::AddrsigSymbol &AS : *Sec->Symbols)
-      if (AS.Index && AS.Name)
-        return "\"Index\" and \"Name\" cannot be used together when defining a "
-               "symbol";
     return {};
   }
 
   if (const auto *NS = dyn_cast<ELFYAML::NoteSection>(C.get())) {
     if (!NS->Content && !NS->Size && !NS->Notes)
       return "one of \"Content\", \"Size\" or \"Notes\" must be "
              "specified";
 
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Chunks);
   IO.mapOptional("Symbols", Object.Symbols);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.setContext(nullptr);
 }
 
-void MappingTraits<ELFYAML::AddrsigSymbol>::mapping(IO &IO, ELFYAML::AddrsigSymbol &Sym) {
-  assert(IO.getContext() && "The IO context is not initialized");
-  IO.mapOptional("Name", Sym.Name);
-  IO.mapOptional("Index", Sym.Index);
-}
-
 void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,
                                                    ELFYAML::LinkerOption &Opt) {
   assert(IO.getContext() && "The IO context is not initialized");
   IO.mapRequired("Name", Opt.Key);
   IO.mapRequired("Value", Opt.Value);
 }
 
 void MappingTraits<ELFYAML::CallGraphEntry>::mapping(

llvm/test/tools/llvm-readobj/ELF/addrsig.test

 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
-    Symbols:
-      - Name: foo
-      - Name: bar
+    Symbols: [ foo, bar ]
 Symbols:
   - Name: foo
   - Name: bar
 
 ## Check that llvm-readobj dumps any SHT_LLVM_ADDRSIG section when --all
 ## is specified for LLVM style, but not for GNU style.
 ## TODO: Refine the llvm-readelf check when GNU-style dumping is implemented.
 

 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
-    Symbols:
-      - Index: 1
-      - Index: 255
-      - Index: 2
+    Symbols: [ 1, 255, 2 ]
 Symbols:
   - Name: foo
   - Name: bar

llvm/test/tools/obj2yaml/elf-llvm-addrsig-section.yaml

 ## Check how obj2yaml dumps the SHT_LLVM_ADDRSIG section.
 
 ## Check that when possible obj2yaml tries to produce the "Name" tag when
 ## dumping entries of the SHT_LLVM_ADDRSIG section. It falls back to producing
 ## the "Index" tag when it can't match a symbol index with a symbol table entry.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=NAME
 
-# NAME:      - Name: .llvm_addrsig
-# NAME-NEXT:   Type: SHT_LLVM_ADDRSIG
-# NAME-NEXT:   Link: .symtab
-# NAME-NEXT:   Symbols:
-# NAME-NEXT:     - Name:  foo
-# NAME-NEXT:     - Name:  bar
-# NAME-NEXT:     - Index: 0x00000003
-# NAME-NEXT:     - Index: 0xFFFFFFFF
+# NAME:      - Name:    .llvm_addrsig
+# NAME-NEXT:   Type:    SHT_LLVM_ADDRSIG
+# NAME-NEXT:   Link:    .symtab
+# NAME-NEXT:   Symbols: [ foo, bar, '3', '4294967295' ]
 # NAME:      - Name: .llvm_addrsig_unlinked
 # NAME-NEXT:   Type: SHT_LLVM_ADDRSIG
-# NAME-NEXT:   Symbols:
-# NAME-NEXT:     - Index: 0x00000001
-# NAME-NEXT:     - Index: 0x00000002
-# NAME-NEXT:     - Index: 0x00000003
-# NAME-NEXT:     - Index: 0xFFFFFFFF
+# NAME-NEXT:   Symbols: [ '1', '2', '3', '4294967295' ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
-    Symbols:
-      - Index: 1
-      - Index: 2
-      - Index: 3
-      - Index: 0xFFFFFFFF
+    Symbols: [ 1, 2, 3, 0xFFFFFFFF ]
   - Name: .llvm_addrsig_unlinked
     Type: SHT_LLVM_ADDRSIG
     Link: 0
-    Symbols:
-      - Index: 1
-      - Index: 2
-      - Index: 3
-      - Index: 0xFFFFFFFF
+    Symbols: [ 1, 2, 3, 0xFFFFFFFF ]
 Symbols:
   - Name:    foo
     Type:    STT_FUNC
     Binding: STB_GLOBAL
   - Name:    bar
     Type:    STT_FUNC
     Binding: STB_GLOBAL
 

 
 ## obj2yaml produces a "Symbols" tag when describing an empty SHT_LLVM_ADDRSIG section.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=EMPTY
 
 # EMPTY:      - Name:    .llvm_addrsig
 # EMPTY-NEXT:   Type:    SHT_LLVM_ADDRSIG
-# EMPTY-NEXT:   Symbols: []
+# EMPTY-NEXT:   Symbols: [ ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Content: ""

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

 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
-    Symbols:
-      - Name: foo
-      - Name: bar
-      - Index: 1
-      - Index: 2
+    Symbols: [ foo, bar, 1, 2 ]
 Symbols:
   - Name:    foo
     Type:    STT_FUNC
     Binding: STB_GLOBAL
   - Name:    bar
     Type:    STT_FUNC
     Binding: STB_GLOBAL
 
-## We can't specify both "Index" and "Name" when defining a symbol.
-
-# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=INDEX-NAME
-
-# INDEX-NAME: error: "Index" and "Name" cannot be used together when defining a symbol
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_DYN
-  Machine: EM_X86_64
-Sections:
-  - Name: .llvm_addrsig
-    Type: SHT_LLVM_ADDRSIG
-    Symbols:
-      - Name: foo
-        Index: 1
-Symbols:
-  - Name:    foo
-    Type:    STT_FUNC
-    Binding: STB_GLOBAL
-
 ## Check we report an error if an unknown symbol is referenced in the
 ## SHT_LLVM_ADDRSIG section description.
 
-# RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=SYMBOL-UNKNOWN
+# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=SYMBOL-UNKNOWN
 
 # SYMBOL-UNKNOWN: error: unknown symbol referenced: 'foo' by YAML section '.llvm_addrsig'
 # SYMBOL-UNKNOWN: error: unknown symbol referenced: 'bar' by YAML section '.llvm_addrsig'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
-    Symbols:
-      - Name: foo
-      - Name: bar
+    Symbols: [ foo, bar ]
 
 ## Check we can specify any arbitrary symbol indices.
 
-# RUN: yaml2obj --docnum=4 %s -o %t4
-# RUN: llvm-readobj --sections --section-data %t4 | FileCheck %s --check-prefix=SYMBOL-INDEX
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readobj --sections --section-data %t3 | FileCheck %s --check-prefix=SYMBOL-INDEX
 
 # SYMBOL-INDEX:      Type: SHT_LLVM_ADDRSIG
 # SYMBOL-INDEX:      SectionData (
 # SYMBOL-INDEX-NEXT:   0000: 00FF01C4 E6888901 FFFFFFFF 0F
 # SYMBOL-INDEX-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
-    Symbols:
-      - Index: 0
-      - Index: 255
-      - Index: 0x11223344
 ## 0xFFFFFFFF is a maximum allowed index value.
-      - Index: 0xFFFFFFFF
+    Symbols: [ 0, 255, 0x11223344, 0xFFFFFFFF ]
 
 ## Check that the maximum symbol index size is 32 bits.
 
-# RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=SYMBOL-INDEX-OVERFLOW
+# RUN: not yaml2obj --docnum=4 %s 2>&1 | FileCheck %s --check-prefix=SYMBOL-INDEX-OVERFLOW
 
-# SYMBOL-INDEX-OVERFLOW: error: out of range hex32 number
+# SYMBOL-INDEX-OVERFLOW: error: unknown symbol referenced: '0x1122334455' by YAML section '.llvm_addrsig'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
-    Symbols:
-      - Index: 0x1122334455
+    Symbols: [ 0x1122334455 ]
 
 ## Check we can use the "Content" tag to specify any data for SHT_LLVM_ADDRSIG sections.
 
-# RUN: yaml2obj --docnum=6 %s -o %t6
-# RUN: llvm-readobj --sections --section-data %t6 | FileCheck %s --check-prefix=CONTENT
+# RUN: yaml2obj --docnum=5 %s -o %t5
+# RUN: llvm-readobj --sections --section-data %t5 | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      Type: SHT_LLVM_ADDRSIG
 # CONTENT:      Size:
 # CONTENT-SAME: 5
 # CONTENT:      SectionData (
 # CONTENT-NEXT:   0000: 11223344 55
 # CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Content: "1122334455"
 
 ## Either "Content" or "Symbols" must be specifed for SHT_LLVM_ADDRSIG sections.
 
-# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
+# RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
 
 # NO-TAGS: error: one of "Content", "Size" or "Symbols" must be specified
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
 
 ## "Content" and "Symbols" cannot be used together to describe the SHT_LLVM_ADDRSIG section.
 
-# RUN: not yaml2obj --docnum=8 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-SYMBOLS
+# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-SYMBOLS
 
 # CONTENT-SYMBOLS: "Symbols" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Content: ""
     Symbols:
 
 ## Check we can set an arbitrary sh_link value for SHT_LLVM_ADDRSIG sections.
 
-# RUN: yaml2obj --docnum=9 %s -o %t9
-# RUN: llvm-readobj --sections %t9 | FileCheck %s --check-prefix=LINK
+# RUN: yaml2obj --docnum=8 %s -o %t8
+# RUN: llvm-readobj --sections %t8 | FileCheck %s --check-prefix=LINK
 
 # LINK:      Name: .llvm_addrsig
 # LINK:      Link:
 # LINK-SAME:       123{{$}}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Link: 123
     Content: ""
 
 ## Check we can use only "Size" to create a SHT_LLVM_ADDRSIG section.
 
-# RUN: yaml2obj --docnum=10 %s -o %t10
-# RUN: llvm-readobj --sections --section-data %t10 | FileCheck %s --check-prefix=SIZE
+# RUN: yaml2obj --docnum=9 %s -o %t9
+# RUN: llvm-readobj --sections --section-data %t9 | FileCheck %s --check-prefix=SIZE
 
 # SIZE:      Name: .llvm_addrsig
 # SIZE:      Size:
 # SIZE-SAME: 17
 # SIZE:      SectionData (
 # SIZE-NEXT:  0000: 00000000 00000000 00000000 00000000  |
 # SIZE-NEXT:  0010: 00                                   |
 # SIZE-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Size: 0x11
 
 ## Check we can use "Size" and "Content" together to create a SHT_LLVM_ADDRSIG section.
 
-# RUN: yaml2obj --docnum=11 %s -o %t11
-# RUN: llvm-readobj --sections --section-data %t11 | FileCheck %s --check-prefix=SIZE-CONTENT
+# RUN: yaml2obj --docnum=10 %s -o %t10
+# RUN: llvm-readobj --sections --section-data %t10 | FileCheck %s --check-prefix=SIZE-CONTENT
 
 # SIZE-CONTENT:      Name: .llvm_addrsig_sizegr
 # SIZE-CONTENT:      Size:
 # SIZE-CONTENT-SAME: 5
 # SIZE-CONTENT:      SectionData (
 # SIZE-CONTENT-NEXT:  0000: 11223300 00 |
 # SIZE-CONTENT-NEXT: )
 
Sections:
   - Name: .llvm_addrsig_sizeeq
     Type: SHT_LLVM_ADDRSIG
     Size: 0x3
     Content: "112233"
 
 ## Check that when "Size" and "Content" are used together, the size
 ## must be greater than or equal to the content size.
 
-# RUN: not yaml2obj --docnum=12 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
+# RUN: not yaml2obj --docnum=11 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
 
 # SIZE-CONTENT-ERR: error: "Size" must be greater than or equal to the content size
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Size: 0x1
     Content: "1122"
 
 ## Check we can't use "Size" and "Symbols" tags together.
 
-# RUN: not yaml2obj --docnum=13 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-SYMBOLS
+# RUN: not yaml2obj --docnum=12 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-SYMBOLS
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Size: 0x1
     Symbols: [ ]

llvm/tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
   ArrayRef<Elf_Sym> SymTable;
 
   DenseMap<StringRef, uint32_t> UsedSectionNames;
   std::vector<std::string> SectionNames;
 
   DenseMap<StringRef, uint32_t> UsedSymbolNames;
   std::vector<std::string> SymbolNames;
 
+  BumpPtrAllocator StringAllocator;
+
   Expected<StringRef> getUniquedSectionName(const Elf_Shdr *Sec);
   Expected<StringRef> getUniquedSymbolName(const Elf_Sym *Sym,
                                            StringRef StrTable,
                                            const Elf_Shdr *SymTab);
   Expected<StringRef> getSymbolName(uint32_t SymtabNdx, uint32_t SymbolNdx);
 
   const object::ELFFile<ELFT> &Obj;
   ArrayRef<Elf_Word> ShndxTable;
ELFDumper<ELFT>::dumpAddrsigSection(const Elf_Shdr *Shdr) {
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)
     return ContentOrErr.takeError();
 
   ArrayRef<uint8_t> Content = *ContentOrErr;
   DataExtractor::Cursor Cur(0);
   DataExtractor Data(Content, Obj.isLE(), /*AddressSize=*/0);
-  std::vector<ELFYAML::AddrsigSymbol> Symbols;
+  std::vector<ELFYAML::YAMLFlowString> Symbols;
   while (Cur && Cur.tell() < Content.size()) {
     uint64_t SymNdx = Data.getULEB128(Cur);
     if (!Cur)
       break;
 
     Expected<StringRef> SymbolName = getSymbolName(Shdr->sh_link, SymNdx);
     if (!SymbolName || SymbolName->empty()) {
       consumeError(SymbolName.takeError());
-      Symbols.emplace_back(SymNdx);
+      Symbols.emplace_back(
+          StringRef(std::to_string(SymNdx)).copy(StringAllocator));
       continue;
     }
 
     Symbols.emplace_back(*SymbolName);
   }
 
   if (Cur) {
     S->Symbols = std::move(Symbols);