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

[grimar]

Summary

SHT_LLVM_LINKER_OPTIONS section contains pairs of null-terminated strings.
This patch adds support for them.

[jhenderson]

I assume that this is in preparation for updating a test that uses this section?

llvm/lib/ObjectYAML/ELFYAML.cpp

1371–1372

Hmm... I think it should be okay to not have to specify anything to create an empty such section (I'd actually support this for other sections too, thinking about it, where an empty section is legitimate).

llvm/test/tools/obj2yaml/linker-options.yaml

2

sections -> section

36

corrupted -> corrupt
using the "Content"

39

CORRUPTED -> CORRUPT

62–65

Perhaps also a case combining 2) and 3), i.e. Content: "610062" or something like that.

llvm/test/tools/yaml2obj/linker-options.yaml

8

Rather than the --section-data switch, it might be clearer to use the --string-dump switch to dump the first section. That way, you can more easily match the original strings to their contents. (I assume you're deliberately not using the --elf-linker-options switch)

104

should -> must (but see my earlier point)

llvm/tools/obj2yaml/elf2yaml.cpp

626

Isn't LLVM style to calculate the Strings size only once?

for (size_t I = 0, E = Strings.size(); I != E; I += 2)

[MaskRay]

llvm/include/llvm/ObjectYAML/ELFYAML.h

354

Just delete user-defined constructors.

llvm/test/tools/obj2yaml/linker-options.yaml

30

Align the values (The Content: value has the largest indentation).

32

Align the values.

59

Align the values.

62

Non-NUL terminated

[MaskRay]

llvm/lib/ObjectYAML/ELFYAML.cpp

1371–1372

Deleting the check here looks good to me.

llvm/tools/obj2yaml/elf2yaml.cpp

625

S->Options.emplace();

[grimar]

• Addressed review comments.

llvm/include/llvm/ObjectYAML/ELFYAML.h

354

I've added them to use S->Options->emplace_back(Strings[I], Strings[I + 1]); (In obj2yaml, otherwise it won't compile).
Perhaps it is too much and so I've removed them and used S->Options->push_back({Strings[I], Strings[I + 1]}); instead.
I have no strong feeling here, perhaps both approaches are OK, it is not a place that requires hard optimisations.

llvm/lib/ObjectYAML/ELFYAML.cpp

1371–1372

I think having an empty linker options section is uncommon? We always can use Content="" to explicitly show our intention to create such section. Is it a problem to require a Content then?
To clarify: I am OK to change it, but probably see no reason to add a complexity here.

llvm/test/tools/obj2yaml/linker-options.yaml

62

I see why you want to use NUL, but I am not sure is this place really wrong? wiki says:
"In computer programming, a null-terminated string is a character string stored as an array containing the characters and terminated with a null character ('\0', called NUL in ASCII)."
(https://en.wikipedia.org/wiki/Null-terminated_string)

I see that "non-null terminated string" is used widely (just google it). (And "non-NUL" looks a bit uncommon to me and seems almost never used in the wild). Should I change it?

62–65

Just to clarify. The current code is:

ArrayRef<uint8_t> Content = *ContentOrErr;
if (Content.empty() || Content.back() != 0) {
  S->Content = Content;
  return S.release();
}

SmallVector<StringRef, 16> Strings;
toStringRef(Content.drop_back()).split(Strings, '\0');
if (Strings.size() % 2 != 0) {
  S->Content = Content;
  return S.release();
}

I.e. "610062" will be captured by the first if, just like "61". What do you want to check with "610061"?
At least I need to know the intention to write a comment :) Perhaps we should not do that.

llvm/test/tools/yaml2obj/linker-options.yaml

8

--string-dump looks fine here, thanks, I've forgot about it.

I assume you're deliberately not using the --elf-linker-options switch

Yes, I wanted to use an independent approach to test the bytes emmitted.

llvm/tools/obj2yaml/elf2yaml.cpp

626

Ok. I do not understand this rule though: size() returns a constant, I see no reasons to hard-think about it. It probably comes from the past, when
"In C++11 it is required that for any standard container the .size() operation must be complete in "constant" complexity (O(1))", but "Previously in C++03 .size() should have constant complexity, but is not required". (https://stackoverflow.com/questions/228908/is-listsize-really-on/13751799#13751799)

[grimar]

In D69895#1735582, @jhenderson wrote:

I assume that this is in preparation for updating a test that uses this section?

Yep. We have a test: https://github.com/llvm-mirror/llvm/blob/master/test/tools/llvm-readobj/elf-linker-options.ll.
It uses llc and doesn't check any broken cases.
I think it worth to convert it to use YAML and improve.

[jhenderson]

llvm/lib/ObjectYAML/ELFYAML.cpp

1371–1372

I think removing the check reduces complexity at no real cost (the check goes as does the corresponding testing, perhaps with one new test case). I think it is more obvious if testing things that aren't to do with the section content (like the readobj test that has been modified) to not have to specify Content: ""

llvm/test/tools/obj2yaml/linker-options.yaml

62–65

It's to reduce reliance on knowledge of the code in the test/make the test less fragile. If somebody tried to refactor the code in the future to check at different points, case 2 might fail due to reordering of checks, even though I think it would be okay to do that check first. Thinking about it, I'd just change case 2 so that it couldn't possibly fail due to the second check (i.e. it has exactly one null byte in it), like my suggestion above.

llvm/tools/obj2yaml/elf2yaml.cpp

626

I agree that it seems unnecessary to add the complexity (compiler optimizers should be able to handle it, and we're not in performance critical code anyway). But it is the policy. Maybe suggest a style amendment on the mailing list?

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFYAML.cpp

1371–1372

I did it since it is not a point I'd like to argue hard about.
But FTR: I meant that removing an early check here involves an additional code lines that I had to add later anyways (see writeSectionContent). I.e. usually the earlier we fail is better and since an empty linker options section is a kind of corner case, I still see no reason to implicitly allow it and add a complexity to the code that runs much later. I'd rather prefer adding a single line to that particular test case and fail early.

llvm/test/tools/obj2yaml/linker-options.yaml

62–65

It's to reduce reliance on knowledge of the code in the test/make the test less fragile. If somebody tried to refactor the code in the future to check at different points, case 2 might fail due to reordering of checks

I am not sure what do you mean by "fail". These test fall back to emiting the "Content". Reordering of them should emit the "Content" still.

Thinking about it, I'd just change case 2 so that it couldn't possibly fail due to the second check (i.e. it has exactly one null byte in it), like my suggestion above.

Having a content that is "00" instead of "61" does not trigger the first if, so it breaks the current test actually. I'd suggest to check the current logic and not the logic we might have or not have in case if somebody decide to break it in the future... :)
(I have no preblems to add a one more test for "00" if you want though. Should I?"

[grimar]

This comment was removed by grimar.

[grimar]

• Restored the correct diff.

[grimar]

llvm/test/tools/obj2yaml/linker-options.yaml

62–65

Thinking about it, I'd just change case 2 so that it couldn't possibly fail due to the second check (i.e. it has exactly one null byte in it)

I think I see the reason of misunderstanding now. I have cases numbered 1, 2 and 2, so I was talking about the second one, while you seems suggested to change the third, which just has a wrong number. I'll change it from '6100' to '00'.

[grimar]

• Fixed numeration in the test case.
• Update the 3rd case as was suggested.

[jhenderson]

llvm/test/tools/obj2yaml/linker-options.yaml

62–65

Sorry, I meant falling back to Content when I said "fail". ("fail" as in "failed to parse").

Actually, I think I may have been talking about the real case 2 (i.e. the second one). I'm getting myself a bit confused though.

I think it makes sense to change both cases to not fail the other check, so "610062" would fail the null-termination check (but not the odd pairs check), whilst "6100" fails the pairs check, but not the null-termination.

Another thought, prompted by the suggestion of the "00" case - should it be an error to have an empty string in either parameter? E.g. Should "0000"/"610000"/"006100" fail?

Also, I'm not sure it's obvious that "00" represents an incomplete pair. Perhaps we should just talk about empty strings instead? A split on "\0" would usually render a pair of {"", ""} if run on a string containing a single '\0'.

llvm/test/tools/yaml2obj/linker-options.yaml

105

Perhaps "The we produce" -> "This produces"

[grimar]

• Rebased, addressed review comments.

llvm/test/tools/obj2yaml/linker-options.yaml

62–65

OK, I've updated the tests to use suggested samples.

Another thought, prompted by the suggestion of the "00" case - should it be an error to have an empty string in either parameter? E.g. Should "0000"/"610000"/"006100" fail?

I am not sure we should: we can implement this failure only if we add an additional code to check this, right? But while we can dump something reasonable and while the dump is human-readable and while it can be used by obj2yaml without changes, I believe we are on track.
I.e. empty strings are valid from the dumper's POV, while the whole content is correct. I would probably try to avoid adding a logic like "for this paricular section having an empty string inside is ubnormal" probably.

[jhenderson]

LGTM, with one remaining nit. Thanks!

llvm/test/tools/obj2yaml/linker-options.yaml

67

contains an incomplete

[MaskRay]

llvm/include/llvm/ObjectYAML/ELFYAML.h

151

Use a trailing comma so that next time the diff can contain one fewer line.

llvm/include/llvm/ObjectYAML/ELFYAML.h

enum class ChunkKind {
     GnuHash,
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
     MipsABIFlags,
     Addrsig,
-    Fill
+    Fill,
+    LinkerOptions,
   };
 
   ChunkKind Kind;
   StringRef Name;
 
   Chunk(ChunkKind K) : Kind(K) {}
   virtual ~Chunk();
 };
struct AddrsigSection : Section {
   Optional<llvm::yaml::Hex64> Size;
   Optional<std::vector<AddrsigSymbol>> Symbols;
 
   AddrsigSection() : Section(ChunkKind::Addrsig) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
 };
 
+struct LinkerOption {
+  StringRef Key;
+  StringRef Value;
+};
+
+struct LinkerOptionsSection : Section {
+  Optional<std::vector<LinkerOption>> Options;
+  Optional<yaml::BinaryRef> Content;
+
+  LinkerOptionsSection() : Section(ChunkKind::LinkerOptions) {}
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::LinkerOptions;
+  }
+};
+
 struct SymverSection : Section {
   std::vector<uint16_t> Entries;
 
   SymverSection() : Section(ChunkKind::Symver) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Symver; }
 };
 

 };
 
 } // 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::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)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)

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

llvm/lib/ObjectYAML/ELFEmitter.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::AddrsigSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::NoteSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::GnuHashSection &Section,
                            ContiguousBlobAccumulator &CBA);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::LinkerOptionsSection &Section,
+                           ContiguousBlobAccumulator &CBA);
 
   void writeFill(ELFYAML::Fill &Fill, ContiguousBlobAccumulator &CBA);
 
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     } 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 if (auto S = dyn_cast<ELFYAML::LinkerOptionsSection>(Sec)) {
+      writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::NoteSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::GnuHashSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else {
       llvm_unreachable("Unknown section type");
     }
 
void ELFState<ELFT>::writeSectionContent(
 
   for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
     support::endian::write<uintX_t>(OS, E.Address, ELFT::TargetEndianness);
     SHeader.sh_size += sizeof(uintX_t) + encodeULEB128(E.Size, OS);
   }
 }
 
 template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
+    ContiguousBlobAccumulator &CBA) {
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+  if (Section.Content) {
+    SHeader.sh_size = writeContent(OS, Section.Content, None);
+    return;
+  }
+
+  if (!Section.Options)
+    return;
+
+  for (const ELFYAML::LinkerOption &LO : *Section.Options) {
+    OS.write(LO.Key.data(), LO.Key.size());
+    OS.write('\0');
+    OS.write(LO.Value.data(), LO.Value.size());
+    OS.write('\0');
+    SHeader.sh_size += (LO.Key.size() + LO.Value.size() + 2);
+  }
+}
+
+template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::HashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
 
   unsigned Link = 0;
   if (Section.Link.empty() && SN2I.lookup(".dynsym", Link))

llvm/lib/ObjectYAML/ELFYAML.cpp

 }
 
 static void fillMapping(IO &IO, ELFYAML::Fill &Fill) {
   IO.mapOptional("Name", Fill.Name, StringRef());
   IO.mapOptional("Pattern", Fill.Pattern);
   IO.mapRequired("Size", Fill.Size);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Options", Section.Options);
+  IO.mapOptional("Content", Section.Content);
+}
+
 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::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;
+  case ELF::SHT_LLVM_LINKER_OPTIONS:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::LinkerOptionsSection());
+    sectionMapping(IO, *cast<ELFYAML::LinkerOptionsSection>(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 (Sec->Header || Sec->BloomFilter || Sec->HashBuckets ||
                "\"Content\"";
       return {};
     }
 
     // Only Content is specified.
     return {};
   }
 
+  if (const auto *Sec = dyn_cast<ELFYAML::LinkerOptionsSection>(C.get())) {
+    if (Sec->Options && Sec->Content)
+      return "\"Options\" and \"Content\" can't be used together";
+    return {};
+  }
+
   if (const auto *F = dyn_cast<ELFYAML::Fill>(C.get())) {
     if (!F->Pattern)
       return {};
     if (F->Pattern->binary_size() != 0 && !F->Size)
       return "\"Size\" can't be 0 when \"Pattern\" is not empty";
     return {};
   }
 

 }
 
 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);
+}
+
 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

llvm/test/tools/obj2yaml/linker-options.yaml

+## Check how obj2yaml produces SHT_LLVM_LINKER_OPTIONS section descriptions.
+
+## Check we dump valid sections using pairs of "Name" and "Value" strings.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
+
+# VALID:      - Name: .linker-options-valid1
+# VALID-NEXT:   Type: SHT_LLVM_LINKER_OPTIONS
+# VALID-NEXT:   Options:
+# VALID-NEXT:     - Name:  a
+# VALID-NEXT:       Value: b
+# VALID-NEXT: - Name: .linker-options-valid2
+# VALID-NEXT:   Type: SHT_LLVM_LINKER_OPTIONS
+# VALID-NEXT:   Options:
+# VALID-NEXT:     - Name:  a
+# VALID-NEXT:       Value: b
+# VALID-NEXT:     - Name:  c
+# VALID-NEXT:       Value: d
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:    .linker-options-valid1
+    Type:    SHT_LLVM_LINKER_OPTIONS
+    Content: "61006200"
+  - Name:    .linker-options-valid2
+    Type:    SHT_LLVM_LINKER_OPTIONS
+    Content: "6100620063006400"
+
+## Check we dump corrupt sections using the "Content" key.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=CORRUPT
+
+# CORRUPT:      - Name:    .linker-options-empty
+# CORRUPT-NEXT:   Type:    SHT_LLVM_LINKER_OPTIONS
+# CORRUPT-NEXT:   Content: ''
+# CORRUPT-NEXT: - Name:    .linker-options-no-null
+# CORRUPT-NEXT:   Type:    SHT_LLVM_LINKER_OPTIONS
+# CORRUPT-NEXT:   Content: '610062'
+# CORRUPT-NEXT: - Name:    .linker-options-incomplete
+# CORRUPT-NEXT:   Type:    SHT_LLVM_LINKER_OPTIONS
+# CORRUPT-NEXT:   Content: '6100'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+## 1) Empty content.
+  - Name:    .linker-options-empty
+    Type:    SHT_LLVM_LINKER_OPTIONS
+    Content: ""
+## 2) Non-null terminated content.
+  - Name:    .linker-options-no-null
+    Type:    SHT_LLVM_LINKER_OPTIONS
+    Content: "610062"
+## 3) Odd number of strings in the section.
+##   (Hence it contains an incomplete key-value pair).
+  - Name:    .linker-options-incomplete
+    Type:    SHT_LLVM_LINKER_OPTIONS
+    Content: "6100"

llvm/test/tools/yaml2obj/linker-options.yaml

+## Check we are able to produce a valid SHT_LLVM_LINKER_OPTIONS
+## section from its description.
+
+## Check we can use either "Options" or "Content" to describe the data.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --string-dump .linker-options1 --sections --section-data %t1 \
+# RUN:   | FileCheck %s --check-prefix=OPTIONS
+
+# OPTIONS:        Name: .linker-options1
+# OPTIONS-NEXT:   Type: SHT_LLVM_LINKER_OPTIONS
+# OPTIONS-NEXT:   Flags [
+# OPTIONS-NEXT:   ]
+# OPTIONS-NEXT:   Address: 0x0
+# OPTIONS-NEXT:   Offset: 0x40
+# OPTIONS-NEXT:   Size: 34
+# OPTIONS-NEXT:   Link: 0
+# OPTIONS-NEXT:   Info: 0
+# OPTIONS-NEXT:   AddressAlignment: 0
+# OPTIONS-NEXT:   EntrySize: 0
+
+# OPTIONS:      Name: .linker-options2
+# OPTIONS-NEXT: Type: SHT_LLVM_LINKER_OPTIONS
+# OPTIONS:      SectionData (
+# OPTIONS-NEXT:   0000: 00112233 |
+# OPTIONS-NEXT: )
+
+# OPTIONS:      String dump of section '.linker-options1':
+# OPTIONS-NEXT: [     0] option 0
+# OPTIONS-NEXT: [     9] value 0
+# OPTIONS-NEXT: [    11] option 1
+# OPTIONS-NEXT: [    1a] value 1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .linker-options1
+    Type: SHT_LLVM_LINKER_OPTIONS
+    Options:
+      - Name:  option 0
+        Value: value 0
+      - Name:  option 1
+        Value: value 1
+  - Name: .linker-options2
+    Type: SHT_LLVM_LINKER_OPTIONS
+    Content: "00112233"
+
+## Check that "Value" and "Name" fields are mandatory when using "Options" key.
+
+# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=NOVALUE
+# RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=NONAME
+
+# NOVALUE: error: missing required key 'Value'
+# NONAME: error: missing required key 'Name'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .linker-options
+    Type: SHT_LLVM_LINKER_OPTIONS
+    Options:
+      - Name: name
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .linker-options
+    Type: SHT_LLVM_LINKER_OPTIONS
+    Options:
+      - Value: value
+
+## Check we can't use both "Options" and "Content" together.
+
+# RUN: not yaml2obj %s --docnum=4 2>&1 | FileCheck %s --check-prefix=BOTH
+
+# BOTH: error: "Options" and "Content" can't be used together
+ 
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .linker-options
+    Type: SHT_LLVM_LINKER_OPTIONS
+    Options:
+      - Name:  name
+        Value: value
+    Content: "00112233"
+
+## Check we can omit both "Options" and "Content". This produces an empty section.
+
+# RUN: yaml2obj %s --docnum=5 2>&1 -o %t5
+# RUN: llvm-readelf --sections %t5 | FileCheck %s --check-prefix=NONE
+
+# NONE: [Nr] Name            Type                Address          Off    Size
+# NONE: [ 1] .linker-options LLVM_LINKER_OPTIONS 0000000000000000 000040 000000
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .linker-options
+    Type: SHT_LLVM_LINKER_OPTIONS

llvm/tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
   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::LinkerOptionsSection *>
+  dumpLinkerOptionsSection(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_LLVM_ADDRSIG: {
       Expected<ELFYAML::AddrsigSection *> SecOrErr = dumpAddrsigSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
+    case ELF::SHT_LLVM_LINKER_OPTIONS: {
+      Expected<ELFYAML::LinkerOptionsSection *> SecOrErr =
+          dumpLinkerOptionsSection(&Sec);
+      if (!SecOrErr)
+        return SecOrErr.takeError();
+      Y->Chunks.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>::dumpAddrsigSection(const Elf_Shdr *Shdr) {
   }
 
   consumeError(Cur.takeError());
   S->Content = yaml::BinaryRef(Content);
   return S.release();
 }
 
 template <class ELFT>
+Expected<ELFYAML::LinkerOptionsSection *>
+ELFDumper<ELFT>::dumpLinkerOptionsSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::LinkerOptionsSection>();
+  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;
+  if (Content.empty() || Content.back() != 0) {
+    S->Content = Content;
+    return S.release();
+  }
+
+  SmallVector<StringRef, 16> Strings;
+  toStringRef(Content.drop_back()).split(Strings, '\0');
+  if (Strings.size() % 2 != 0) {
+    S->Content = Content;
+    return S.release();
+  }
+
+  S->Options.emplace();
+  for (size_t I = 0, E = Strings.size(); I != E; I += 2)
+    S->Options->push_back({Strings[I], Strings[I + 1]});
+
+  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)