[yaml2obj/obj2yaml] - Add support for SHT_LLVM_ADDRSIG sections.

[grimar]

Summary

SHT_LLVM_ADDRSIG is described here:
https://llvm.org/docs/Extensions.html#sht-llvm-addrsig-section-address-significance-table

This patch teaches tools to dump them and to parse the YAML declarations of such sections.

[MaskRay]

include/llvm/ObjectYAML/ELFYAML.h

261

{}; -> {}

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

200

Right shift 123{{$}}

[jhenderson]

include/llvm/ObjectYAML/ELFYAML.h

261–263

clang-format?

264

I'd find it easier to read if there were a blank line between the methods and member variables.

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

5

dumps -> dumping

6

when it can't match

I'd delete "found"

57

Delete "malformed"

58–59

broken, e.g. because the entry contains a malformed

62

I might use the prefix "INVALID-ENTRY"

80

obj2yaml produces a "Symbols" tag when describing an ...

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

4

using the "Symbols" tag

118

I'm not really sure what "Symbol"->"Index" is trying to say. Perhaps it could be written as follows: "Check that the maximum symbol index size is 32 bits."

This actually shows that an error is produced if the value is out of range. You should have a separate case without the error, using the maximum possible value.

136

the "Content" tag

159

"for SHT_LLVM_ADDRSIG sections." here and elsewhere.

tools/obj2yaml/elf2yaml.cpp

871

Whilst you're moving code around, I'd improve this comment slightly:
"Get symbol with index sh_info. This symbol's name is the signature of the group.

[grimar]

• Addressed review comments.

include/llvm/ObjectYAML/ELFYAML.h

261–263

(It was formatted.. but because of excessive ';' which I've removed, formatting did't add a space between ')' and '{').

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

118

This actually shows that an error is produced if the value is out of range. You should have a separate case without the error, using the maximum possible value.

I've included it to SYMBOL-INDEX test.

[jhenderson]

LGTM.

[RKSimon]

@grimar elf-llvm-addrsig-section.yaml is failing on EXPENSIVE_CHECKS builds please can you take a look?

http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/19989/

[grimar]

In D68333#1693020, @RKSimon wrote:

@grimar elf-llvm-addrsig-section.yaml is failing on EXPENSIVE_CHECKS builds please can you take a look?

http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/19989/

Yep, sorry for this. I`ve reverted it and recommitted with a fix in rL373606 recently. Should be fixed now.

include/llvm/ObjectYAML/ELFYAML.h

enum class SectionKind {
     Relocation,
     NoBits,
     Hash,
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
-    MipsABIFlags
+    MipsABIFlags,
+    Addrsig
   };
   SectionKind Kind;
   StringRef Name;
   ELF_SHT Type;
   Optional<ELF_SHF> Flags;
   llvm::yaml::Hex64 Address;
   StringRef Link;
   llvm::yaml::Hex64 AddressAlign;
struct VerneedSection : Section {
 
   VerneedSection() : Section(SectionKind::Verneed) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::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<std::vector<AddrsigSymbol>> Symbols;
+
+  AddrsigSection() : Section(SectionKind::Addrsig) {}
+  static bool classof(const Section *S) {
+    return S->Kind == SectionKind::Addrsig;
+  }
+};
+
 struct SymverSection : Section {
   std::vector<uint16_t> Entries;
 
   SymverSection() : Section(SectionKind::Symver) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::Symver;
   }
struct Object {
   // being a single SHT_SYMTAB section are upheld.
   std::vector<Symbol> Symbols;
   std::vector<Symbol> DynamicSymbols;
 };
 
 } // 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::ProgramHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)

 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::Relocation> {
   static void mapping(IO &IO, ELFYAML::Relocation &Rel);
 };
 
 template <>
 struct MappingTraits<std::unique_ptr<ELFYAML::Section>> {
   static void mapping(IO &IO, std::unique_ptr<ELFYAML::Section> &Section);
   static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Section> &Section);

lib/ObjectYAML/ELFEmitter.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::DynamicSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::StackSizesSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::HashSection &Section,
                            ContiguousBlobAccumulator &CBA);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::AddrsigSection &Section,
+                           ContiguousBlobAccumulator &CBA);
+
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
 };
 } // end anonymous namespace
 
for (size_t I = 0; I < Doc.Sections.size(); ++I) {
     } else if (auto S = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::StackSizesSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::HashSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::AddrsigSection>(Sec)) {
+      writeSectionContent(SHeader, *S, CBA);
     } else {
       llvm_unreachable("Unknown section type");
     }
 
     // Override the fields if requested.
     if (Sec) {
       if (Sec->ShName)
         SHeader.sh_name = *Sec->ShName;
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   for (const ELFYAML::DynamicEntry &DE : Section.Entries) {
     support::endian::write<uintX_t>(OS, DE.Tag, ELFT::TargetEndianness);
     support::endian::write<uintX_t>(OS, DE.Val, ELFT::TargetEndianness);
   }
   if (Section.Content)
     Section.Content->writeAsBinary(OS);
 }
 
+template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
+                                         const ELFYAML::AddrsigSection &Section,
+                                         ContiguousBlobAccumulator &CBA) {
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+  unsigned Link = 0;
+  if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
+    SHeader.sh_link = Link;
+
+  if (Section.Content) {
+    SHeader.sh_size = writeContent(OS, Section.Content, None);
+    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);
+  }
+}
+
 template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
   for (unsigned I = 0, E = Doc.Sections.size(); I != E; ++I) {
     StringRef Name = Doc.Sections[I]->Name;
     if (Name.empty())
       continue;
 
     DotShStrtab.add(ELFYAML::dropUniqueSuffix(Name));
     if (!SN2I.addName(Name, I))

lib/ObjectYAML/ELFYAML.cpp

static void groupSectionMapping(IO &IO, ELFYAML::Group &Group) {
   IO.mapRequired("Members", Group.Members);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::SymtabShndxSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Entries", Section.Entries);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::AddrsigSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Content", Section.Content);
+  IO.mapOptional("Symbols", Section.Symbols);
+}
+
 void MappingTraits<ELFYAML::SectionOrType>::mapping(
     IO &IO, ELFYAML::SectionOrType &sectionOrType) {
   IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
 }
 
 void MappingTraits<ELFYAML::SectionName>::mapping(
     IO &IO, ELFYAML::SectionName &sectionName) {
   IO.mapRequired("Section", sectionName.Section);
if (!IO.outputting())
       Section.reset(new ELFYAML::VerneedSection());
     sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
     break;
   case ELF::SHT_SYMTAB_SHNDX:
     if (!IO.outputting())
       Section.reset(new ELFYAML::SymtabShndxSection());
     sectionMapping(IO, *cast<ELFYAML::SymtabShndxSection>(Section.get()));
     break;
+  case ELF::SHT_LLVM_ADDRSIG:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::AddrsigSection());
+    sectionMapping(IO, *cast<ELFYAML::AddrsigSection>(Section.get()));
+    break;
   default:
     if (!IO.outputting()) {
       StringRef Name;
       IO.mapOptional("Name", Name, StringRef());
       Name = ELFYAML::dropUniqueSuffix(Name);
 
       if (ELFYAML::StackSizesSection::nameMatches(Name))
         Section = std::make_unique<ELFYAML::StackSizesSection>();
if (HS->Content || HS->Size) {
       return {};
     }
 
     if ((HS->Bucket && !HS->Chain) || (!HS->Bucket && HS->Chain))
       return "\"Bucket\" and \"Chain\" must be used together";
     return {};
   }
 
+  if (const auto *Sec = dyn_cast<ELFYAML::AddrsigSection>(Section.get())) {
+    if (!Sec->Symbols && !Sec->Content)
+      return "one of \"Symbols\" or \"Content\" must be specified";
+
+    if (Sec->Content) {
+      if (Sec->Symbols)
+        return "\"Content\" and \"Symbols\" cannot be used together";
+      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 {};
+  }
+
   return {};
 }
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Sections);
   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);
+}
+
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
 
 } // end namespace yaml
 
 } // end namespace llvm

test/tools/llvm-readobj/elf-section-types.test

Sections:
   - Name: llvm_odrtab
     Type: SHT_LLVM_ODRTAB
   - Name: linker_options
     Type: SHT_LLVM_LINKER_OPTIONS
   - Name: llvm_call_graph_profile
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
   - Name: llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
+    Symbols:
   - Name: .deplibs
     Type: SHT_LLVM_DEPENDENT_LIBRARIES
   - Name: .llvm_sympart.f
     Type: SHT_LLVM_SYMPART
   - Name: part1
     Type: SHT_LLVM_PART_EHDR
   - Name: .phdrs
     Type: SHT_LLVM_PART_PHDR

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_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
+
+--- !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
+  - Name: .llvm_addrsig_unlinked
+    Type: SHT_LLVM_ADDRSIG
+    Link: 0
+    Symbols:
+      - Index: 1
+      - Index: 2
+      - Index: 3
+      - Index: 0xFFFFFFFF
+Symbols:
+  - Name:    foo
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+  - Name:    bar
+    Type:    STT_FUNC
+    Binding: STB_GLOBAL
+
+## Check that obj2yaml dumps the SHT_LLVM_ADDRSIG section
+## data using the "Content" tag when at least one of the entries is broken,
+## e.g. because the entry contains a malformed uleb128 value.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID-ENTRY
+
+# INVALID-ENTRY:      - Name:    .llvm_addrsig
+# INVALID-ENTRY-NEXT:   Type:    SHT_LLVM_ADDRSIG
+# INVALID-ENTRY-NEXT:   Link:    .symtab
+# INVALID-ENTRY-NEXT:   Content: FFFFFFFFFF
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .llvm_addrsig
+    Type: SHT_LLVM_ADDRSIG
+    Content: "FFFFFFFFFF"
+
+## 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:   Link:    .symtab
+# 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: ""

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

+## Check how yaml2obj produces SHT_LLVM_ADDRSIG sections.
+
+## Check we can describe SHT_LLVM_ADDRSIG using the "Symbols" tag. We can define
+## symbols either using names or indexes.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=SYMBOLS
+
+# SYMBOLS:      Section {
+# SYMBOLS:        Index: 1
+# SYMBOLS-NEXT:   Name: .llvm_addrsig
+# SYMBOLS-NEXT:   Type: SHT_LLVM_ADDRSIG
+# SYMBOLS-NEXT:   Flags [
+# SYMBOLS-NEXT:   ]
+# SYMBOLS-NEXT:   Address: 0x0
+# SYMBOLS-NEXT:   Offset: 0x40
+# SYMBOLS-NEXT:   Size: 4
+# SYMBOLS-NEXT:   Link: 2
+# SYMBOLS-NEXT:   Info: 0
+# SYMBOLS-NEXT:   AddressAlignment: 0
+# SYMBOLS-NEXT:   EntrySize: 0
+# SYMBOLS-NEXT:   SectionData (
+# SYMBOLS-NEXT:     0000: 01020102
+# SYMBOLS-NEXT:   )
+# SYMBOLS-NEXT: }
+
+--- !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
+      - Index: 1
+      - Index: 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
+
+# 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
+
+## 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
+
+# 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
+
+## 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
+
+# SYMBOL-INDEX-OVERFLOW: error: out of range hex32 number
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .llvm_addrsig
+    Type: SHT_LLVM_ADDRSIG
+    Symbols:
+      - Index: 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
+
+# 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
+
+# NO-TAGS: error: one of "Symbols" or "Content" 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
+
+# CONTENT-SYMBOLS: error: "Content" and "Symbols" cannot be used together
+
+--- !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
+
+# 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: ""

tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
 
   DenseMap<StringRef, uint32_t> UsedSymbolNames;
   std::vector<std::string> SymbolNames;
 
   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;
 
   Error dumpSymbols(const Elf_Shdr *Symtab,
                     std::vector<ELFYAML::Symbol> &Symbols);
   Error dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
                    StringRef StrTable, ELFYAML::Symbol &S);
   Error dumpCommonSection(const Elf_Shdr *Shdr, ELFYAML::Section &S);
   Error dumpCommonRelocationSection(const Elf_Shdr *Shdr,
                                     ELFYAML::RelocationSection &S);
   template <class RelT>
   Error dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
                        ELFYAML::Relocation &R);
 
+  Expected<ELFYAML::AddrsigSection *> dumpAddrsigSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RawContentSection *>
   dumpContentSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymtabShndxSection *>
   dumpSymtabShndxSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::HashSection *> dumpHashSection(const Elf_Shdr *Shdr);
for (const Elf_Shdr &Sec : Sections) {
     }
     case ELF::SHT_GNU_verneed: {
       Expected<ELFYAML::VerneedSection *> SecOrErr = dumpVerneedSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Sections.emplace_back(*SecOrErr);
       break;
     }
+    case ELF::SHT_LLVM_ADDRSIG: {
+      Expected<ELFYAML::AddrsigSection *> SecOrErr = dumpAddrsigSection(&Sec);
+      if (!SecOrErr)
+        return SecOrErr.takeError();
+      Y->Sections.emplace_back(*SecOrErr);
+      break;
+    }
     case ELF::SHT_NULL: {
       // We only dump the SHT_NULL section at index 0 when it
       // has at least one non-null field, because yaml2obj
       // normally creates the zero section at index 0 implicitly.
       if (&Sec == &Sections[0]) {
         const uint8_t *Begin = reinterpret_cast<const uint8_t *>(&Sec);
         const uint8_t *End = Begin + sizeof(Elf_Shdr);
         if (std::find_if(Begin, End, [](uint8_t V) { return V != 0; }) == End)
ELFDumper<ELFT>::dumpStackSizesSection(const Elf_Shdr *Shdr) {
   } else {
     S->Entries = std::move(Entries);
   }
 
   return S.release();
 }
 
 template <class ELFT>
+Expected<ELFYAML::AddrsigSection *>
+ELFDumper<ELFT>::dumpAddrsigSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::AddrsigSection>();
+  if (Error E = dumpCommonSection(Shdr, *S))
+    return std::move(E);
+
+  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;
+  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);
+      continue;
+    }
+
+    Symbols.emplace_back(*SymbolName);
+  }
+
+  if (Cur) {
+    S->Symbols = std::move(Symbols);
+    return S.release();
+  }
+
+  S->Content = yaml::BinaryRef(Content);
+  return S.release();
+}
+
+template <class ELFT>
 Expected<ELFYAML::DynamicSection *>
 ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::DynamicSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(Shdr);
   if (!DynTagsOrErr)
while (Buf) {
     S->VerneedV.push_back(Entry);
     Buf = Verneed->vn_next ? Buf + Verneed->vn_next : nullptr;
   }
 
   return S.release();
 }
 
 template <class ELFT>
-Expected<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
-  auto S = std::make_unique<ELFYAML::Group>();
-  if (Error E = dumpCommonSection(Shdr, *S))
-    return std::move(E);
-
-  auto SymtabOrErr = Obj.getSection(Shdr->sh_link);
+Expected<StringRef> ELFDumper<ELFT>::getSymbolName(uint32_t SymtabNdx,
+                                                   uint32_t SymbolNdx) {
+  auto SymtabOrErr = Obj.getSection(SymtabNdx);
   if (!SymtabOrErr)
     return SymtabOrErr.takeError();
-  // Get symbol with index sh_info which name is the signature of the group.
+
   const Elf_Shdr *Symtab = *SymtabOrErr;
-  auto SymOrErr = Obj.getSymbol(Symtab, Shdr->sh_info);
+  auto SymOrErr = Obj.getSymbol(Symtab, SymbolNdx);
   if (!SymOrErr)
     return SymOrErr.takeError();
+
   auto StrTabOrErr = Obj.getStringTableForSymtab(*Symtab);
   if (!StrTabOrErr)
     return StrTabOrErr.takeError();
+  return getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab);
+}
+
+template <class ELFT>
+Expected<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::Group>();
+  if (Error E = dumpCommonSection(Shdr, *S))
+    return std::move(E);
 
-  Expected<StringRef> SymbolName =
-      getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab);
+  // Get symbol with index sh_info. This symbol's name is the signature of the group.
+  Expected<StringRef> SymbolName = getSymbolName(Shdr->sh_link, Shdr->sh_info);
   if (!SymbolName)
     return SymbolName.takeError();
   S->Signature = *SymbolName;
 
   auto MembersOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(Shdr);
   if (!MembersOrErr)
     return MembersOrErr.takeError();
 
   for (Elf_Word Member : *MembersOrErr) {
     if (Member == llvm::ELF::GRP_COMDAT) {
       S->Members.push_back({"GRP_COMDAT"});
       continue;
     }