[yaml2obj, obj2yaml] - Add support for SHT_NOTE sections.

[grimar]

Summary

SHT_NOTE is the section that consists of
namesz, descsz, type, name + padding, desc + padding data.
This patch teaches yaml2obj, obj2yaml to dump and parse them.

This patch implements the section how it is described here:
https://docs.oracle.com/cd/E23824_01/html/819-0690/chapter6-18048.html
Which says: "For 64–bit objects and 32–bit objects, each entry is an array of 4-byte words in
the format of the target processor"

The official specification is different
http://www.sco.com/developers/gabi/latest/ch5.pheader.html#note_section
And says: "n 64-bit objects (files with e_ident[EI_CLASS] equal to ELFCLASS64), each entry is an array
of 8-byte words in the format of the target processor. In 32-bit objects (files with e_ident[EI_CLASS]
equal to ELFCLASS32), each entry is an array of 4-byte words in the format of the target processor"

Since LLVM uses the first, 32-bit way, this patch follows it.

[MaskRay]

There is an official reference: http://www.sco.com/developers/gabi/latest/ch5.pheader.html#note_section

When operating systems implemented the 64-bit ELF ABI, many (including Linux, FreeBSD, and NetBSD) interpreted the gABI wording incorrectly and chose 32-bit struct members for Elf64_Nhdr. A few (including Solaris) are correct and use 64-bit members. This inconsistency should not affect this patch, but I just want to mention the problem.

I think all platforms that have interests in these binary utilities (Linux, *BSD, Fuchsia) use 32-bit members. So we are fine to use write32 etc. This may need a comment though.

@phosek to confirm n_namesz/n_descsz/n_type are 32-bit on 64-bit Fuchsia.

[grimar]

In D68983#1710544, @MaskRay wrote:

There is an official reference: http://www.sco.com/developers/gabi/latest/ch5.pheader.html#note_section

Thanks!

When operating systems implemented the 64-bit ELF ABI, many (including Linux, FreeBSD, and NetBSD) interpreted the gABI wording incorrectly and chose 32-bit struct members for Elf64_Nhdr. A few (including Solaris) are correct and use 64-bit members. This inconsistency should not affect this patch, but I just want to mention the problem.

Interesting. I guess if we wanted to support it, we would probably be able to check OSABI:

--- !ELF
FileHeader:
...
OSABI = Solaris

For now I'd not do anything with that. I think LLVM tools like llvm-readobj implement only 32-bit case anyways:

template <class ELFT>
struct Elf_Nhdr_Impl {
  LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
  Elf_Word n_namesz;
  Elf_Word n_descsz;
  Elf_Word n_type;

  /// The alignment of the name and descriptor.
  ///
  /// Implementations differ from the specification here: in practice all
  /// variants align both the name and descriptor to 4-bytes.
  static const unsigned int Align = 4;

  /// Get the size of the note, including name, descriptor, and padding.
  size_t getSize() const {
    return sizeof(*this) + alignTo<Align>(n_namesz) + alignTo<Align>(n_descsz);
  }
};

[grimar]

Planning an update.

[grimar]

• Implement NoteEntry::Desc as yaml::BinaryRef instead of StringRef. Description is not a null-terminated string, but a binary data. Previous implementation tried to use StringRef, but it was incorrect, it produced wrong output.
• Fix the code and one more test case (seems I've forgot to do a final tests run before posting).

[MaskRay]

include/llvm/Support/YAMLTraits.h

652 ↗

(On Diff #225186)

Interesting. Is there a test covering the fixed bug?

test/tools/obj2yaml/elf-sht-note.yaml

4

Check we dump hex digit pairs if the note section is invalid.

Then, group invalid cases together, the first of which is when the size is less than 12 bytes.

It may be clearer if we place valid cases first.

63

when the content is shorter than the computed size

test/tools/yaml2obj/elf-sht-note.yaml

27

NUL terminator.

NUL != null.

57

What is 'Tag'

[grimar]

• Addressed review comments, rebased.

[grimar]

include/llvm/Support/YAMLTraits.h

652 ↗

(On Diff #225186)

I faced it running the tools\obj2yaml\missing_symtab.test initially.
It uses a precompiled binary.
I planned to convert it and add a separate test case for this place later,
but after your comment I decided to do it right now and this revealed
a different bug:

I am creating notes in dumpNoteSection().
I used toStringRef before this diff:

Entries.push_back({Note.getName(), toStringRef(Note.getDesc()), Note.getType()});

It was there because previously Desc was a StringRef, but now it is a yaml::BinaryRef,
so toStringRef became excessive and actually harmfull.

Problem of toStringRef is that BinaryRef constructor has a different behavior for
StringRef and ArrayRef<uint8_t>):

BinaryRef(ArrayRef<uint8_t> Data) : Data(Data), DataIsHexString(false) {}
BinaryRef(StringRef Data) : Data(arrayRefFromStringRef(Data)) {}

it wasn't correct to use StringRef version and I removed this change
from the patch after the fix, as it is not needed anymore.

I've added a one more test to elf-sht-note.yaml that covers this place.

I think I might be able to trigger this issue in a different way and going to investigate how
and suggest an independent patch for this place probably.
(I'll try to corrupt a section name in the same way, it should work I think).

[grimar]

Going to add a one more test case for obj2yaml.

[grimar]

• Added few more test cases.

[grimar]

include/llvm/Support/YAMLTraits.h

652 ↗

(On Diff #225186)

Patch: D69160

[rupprecht]

llvm/include/llvm/Support/YAMLTraits.h

652–653 ↗

(On Diff #226401)

Was this part of the change intentional? This looks like a rebase that accidentally reverted one of your previous patches.

[grimar]

llvm/include/llvm/Support/YAMLTraits.h

652–653 ↗

(On Diff #226401)

Thanks! It wasn't intentional. I've moved this and other my active patches to monorepo and I guess I've forgot to rebase it. I am going to recommit this part.

(I've re-checked that the existing test case for this, which is invalid-section-name.yaml fails for me now under windows in debug. I guess bots never build in debug probably, that is why it was not catched by them).

include/llvm/ObjectYAML/ELFYAML.h

struct DynamicEntry {
   llvm::yaml::Hex64 Val;
 };
 
 struct StackSizeEntry {
   llvm::yaml::Hex64 Address;
   llvm::yaml::Hex64 Size;
 };
 
+struct NoteEntry {
+  StringRef Name;
+  StringRef Desc;
+  llvm::yaml::Hex32 Type;
+};
+
 struct Section {
   enum class SectionKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
     NoBits,
+    Note,
     Hash,
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
     MipsABIFlags,
     Addrsig
struct NoBitsSection : Section {
 
   NoBitsSection() : Section(SectionKind::NoBits) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::NoBits;
   }
 };
 
+struct NoteSection : Section {
+  Optional<yaml::BinaryRef> Content;
+  Optional<llvm::yaml::Hex64> Size;
+  Optional<std::vector<ELFYAML::NoteEntry>> Notes;
+
+  NoteSection() : Section(SectionKind::Note) {}
+  static bool classof(const Section *S) { return S->Kind == SectionKind::Note; }
+};
+
 struct HashSection : Section {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
   Optional<std::vector<uint32_t>> Bucket;
   Optional<std::vector<uint32_t>> Chain;
 
   HashSection() : Section(SectionKind::Hash) {}
 

 };
 
 } // 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::NoteEntry)
 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)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)

 template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
   static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
 };
 
 template <> struct MappingTraits<ELFYAML::DynamicEntry> {
   static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
 };
 
+template <> struct MappingTraits<ELFYAML::NoteEntry> {
+  static void mapping(IO &IO, ELFYAML::NoteEntry &N);
+};
+
 template <> struct MappingTraits<ELFYAML::VerdefEntry> {
   static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
 };
 
 template <> struct MappingTraits<ELFYAML::VerneedEntry> {
   static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
 };
 

lib/ObjectYAML/ELFEmitter.cpp

 // track of an offset in the output (which notionally begins at
 // `InitialOffset`).
 namespace {
 class ContiguousBlobAccumulator {
   const uint64_t InitialOffset;
   SmallVector<char, 128> Buf;
   raw_svector_ostream OS;
 
+public:
+  ContiguousBlobAccumulator(uint64_t InitialOffset_)
+      : InitialOffset(InitialOffset_), Buf(), OS(Buf) {}
+
+  template <class Integer>
+  raw_ostream &getOSAndAlignedOffset(Integer &Offset, unsigned Align) {
+    Offset = padToAlignment(Align);
+    return OS;
+  }
+
   /// \returns The new offset.
   uint64_t padToAlignment(unsigned Align) {
     if (Align == 0)
       Align = 1;
     uint64_t CurrentOffset = InitialOffset + OS.tell();
     uint64_t AlignedOffset = alignTo(CurrentOffset, Align);
     OS.write_zeros(AlignedOffset - CurrentOffset);
     return AlignedOffset; // == CurrentOffset;
   }
 
-public:
-  ContiguousBlobAccumulator(uint64_t InitialOffset_)
-      : InitialOffset(InitialOffset_), Buf(), OS(Buf) {}
-  template <class Integer>
-  raw_ostream &getOSAndAlignedOffset(Integer &Offset, unsigned Align) {
-    Offset = padToAlignment(Align);
-    return OS;
-  }
   void writeBlobToStream(raw_ostream &Out) { Out << OS.str(); }
 };
 
 // Used to keep track of section and symbol names, so that in the YAML file
 // sections and symbols can be referenced by name instead of by index.
 class NameToIdxMap {
   StringMap<unsigned> Map;
 
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);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::NoteSection &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::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::NoteSection>(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::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>::writeSectionContent(Elf_Shdr &SHeader,
+                                         const ELFYAML::NoteSection &Section,
+                                         ContiguousBlobAccumulator &CBA) {
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  uint64_t Offset = OS.tell();
+
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
+    return;
+  }
+
+  for (const ELFYAML::NoteEntry &NE : *Section.Notes) {
+    // Write name size.
+    if (NE.Name.empty())
+      support::endian::write<uint32_t>(OS, 0, ELFT::TargetEndianness);
+    else
+      support::endian::write<uint32_t>(OS, NE.Name.size() + 1,
+                                       ELFT::TargetEndianness);
+
+    // Write description size.
+    if (NE.Desc.empty())
+      support::endian::write<uint32_t>(OS, 0, ELFT::TargetEndianness);
+    else
+      support::endian::write<uint32_t>(OS, NE.Desc.size(),
+                                       ELFT::TargetEndianness);
+
+    // Write type.
+    support::endian::write<uint32_t>(OS, NE.Type, ELFT::TargetEndianness);
+
+    // Write name, null terminator and padding.
+    if (!NE.Name.empty()) {
+      support::endian::write<uint8_t>(OS, arrayRefFromStringRef(NE.Name),
+                                      ELFT::TargetEndianness);
+      support::endian::write<uint8_t>(OS, 0, ELFT::TargetEndianness);
+      CBA.padToAlignment(4);
+    }
+
+    // Write description and padding.
+    if (!NE.Desc.empty()) {
+      support::endian::write<uint8_t>(OS, arrayRefFromStringRef(NE.Desc),
+                                      ELFT::TargetEndianness);
+      CBA.padToAlignment(4);
+    }
+
+    SHeader.sh_size = OS.tell() - Offset;
+  }
+}
+
 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 sectionMapping(IO &IO, ELFYAML::HashSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Bucket", Section.Bucket);
   IO.mapOptional("Chain", Section.Chain);
   IO.mapOptional("Size", Section.Size);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::NoteSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Content", Section.Content);
+  IO.mapOptional("Size", Section.Size);
+  IO.mapOptional("Notes", Section.Notes);
+}
+
 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Size", Section.Size, Hex64(0));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Info", Section.Info);
if (!IO.outputting())
       Section.reset(new ELFYAML::NoBitsSection());
     sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
     break;
   case ELF::SHT_HASH:
     if (!IO.outputting())
       Section.reset(new ELFYAML::HashSection());
     sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));
     break;
+  case ELF::SHT_NOTE:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::NoteSection());
+    sectionMapping(IO, *cast<ELFYAML::NoteSection>(Section.get()));
+    break;
   case ELF::SHT_MIPS_ABIFLAGS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::MipsABIFlags());
     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
     break;
   case ELF::SHT_GNU_verdef:
     if (!IO.outputting())
       Section.reset(new ELFYAML::VerdefSection());
if (const auto *Sec = dyn_cast<ELFYAML::AddrsigSection>(Section.get())) {
 
     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>(Section.get())) {
+    if (!NS->Content && !NS->Size && !NS->Notes)
+      return "one of \"Content\", \"Size\" or \"Notes\" must be "
+             "specified";
+
+    if (!NS->Content && !NS->Size)
+      return {};
+
+    if (NS->Size && NS->Content &&
+        (uint64_t)*NS->Size < NS->Content->binary_size())
+      return "\"Size\" must be greater than or equal to the content "
+             "size";
+
+    if (NS->Notes)
+      return "\"Notes\" cannot be used with \"Content\" or \"Size\"";
+    return {};
+  }
+
   return {};
 }
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

 void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,
                                                    ELFYAML::DynamicEntry &Rel) {
   assert(IO.getContext() && "The IO context is not initialized");
 
   IO.mapRequired("Tag", Rel.Tag);
   IO.mapRequired("Value", Rel.Val);
 }
 
+void MappingTraits<ELFYAML::NoteEntry>::mapping(IO &IO, ELFYAML::NoteEntry &N) {
+  assert(IO.getContext() && "The IO context is not initialized");
+
+  IO.mapOptional("Name", N.Name);
+  IO.mapOptional("Desc", N.Desc);
+  IO.mapRequired("Type", N.Type);
+}
+
 void MappingTraits<ELFYAML::VerdefEntry>::mapping(IO &IO,
                                                   ELFYAML::VerdefEntry &E) {
   assert(IO.getContext() && "The IO context is not initialized");
 
   IO.mapRequired("Version", E.Version);
   IO.mapRequired("Flags", E.Flags);
   IO.mapRequired("VersionNdx", E.VersionNdx);
   IO.mapRequired("Hash", E.Hash);

test/tools/obj2yaml/elf-sht-note.yaml

+## Check how obj2yaml dumps the SHT_NOTE section.
+
+## Check how we dump the broken case when the content is less than 12 bytes in size.
+## (12 is the size of n_namesz, n_descsz and n_type 4-bytes fields that must always present).
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: obj2yaml %t1 | FileCheck %s --check-prefix=TOO-SHORT
+
+# TOO-SHORT:      --- !ELF
+# TOO-SHORT-NEXT: FileHeader:
+# TOO-SHORT-NEXT:   Class:   ELFCLASS64
+# TOO-SHORT-NEXT:   Data:    ELFDATA2LSB
+# TOO-SHORT-NEXT:   Type:    ET_DYN
+# TOO-SHORT-NEXT:   Machine: EM_X86_64
+# TOO-SHORT-NEXT: Sections:
+# TOO-SHORT-NEXT:   - Name:    .note.foo
+# TOO-SHORT-NEXT:     Type:    SHT_NOTE
+# TOO-SHORT-NEXT:     Content: '0000000000000000000000'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.foo
+    Type: SHT_NOTE
+    Size: 11
+
+## We can dump the Name, Desc and Type fields when SHT_NOTE has data of
+## size >= 12 + size of name, size of desc and their paddings.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=VALID
+
+# VALID:      --- !ELF
+# VALID-NEXT: FileHeader:
+# VALID-NEXT:   Class:   ELFCLASS64
+# VALID-NEXT:   Data:    ELFDATA2LSB
+# VALID-NEXT:   Type:    ET_DYN
+# VALID-NEXT:   Machine: EM_X86_64
+# VALID-NEXT: Sections:
+# VALID-NEXT:   - Name: .note.foo
+# VALID-NEXT:     Type: SHT_NOTE
+# VALID-NEXT:     Notes:
+# VALID-NEXT:       - Name:  ''
+# VALID-NEXT:         Desc:  ''
+# VALID-NEXT:         Type:  0x00
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.foo
+    Type: SHT_NOTE
+    Size: 12
+
+## We can't dump the Name, Desc and Type fields when SHT_NOTE has data of
+## size < 12 + size of name, desc and their paddings.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: obj2yaml %t3 | FileCheck %s --check-prefix=TOO-LONG-NAME-SIZE
+
+# RUN: yaml2obj --docnum=4 %s -o %t4
+# RUN: obj2yaml %t4 | FileCheck %s --check-prefix=TOO-LONG-DESC-SIZE
+
+# TOO-LONG-NAME-SIZE:      --- !ELF
+# TOO-LONG-NAME-SIZE-NEXT: FileHeader:
+# TOO-LONG-NAME-SIZE-NEXT:   Class:   ELFCLASS64
+# TOO-LONG-NAME-SIZE-NEXT:   Data:    ELFDATA2LSB
+# TOO-LONG-NAME-SIZE-NEXT:   Type:    ET_DYN
+# TOO-LONG-NAME-SIZE-NEXT:   Machine: EM_X86_64
+# TOO-LONG-NAME-SIZE-NEXT: Sections:
+# TOO-LONG-NAME-SIZE-NEXT:   - Name:    .note.foo
+# TOO-LONG-NAME-SIZE-NEXT:     Type:    SHT_NOTE
+# TOO-LONG-NAME-SIZE-NEXT:     Content: 0100000000000000FF000000
+
+# TOO-LONG-DESC-SIZE: --- !ELF
+# TOO-LONG-DESC-SIZE: FileHeader:
+# TOO-LONG-DESC-SIZE:   Class:   ELFCLASS64
+# TOO-LONG-DESC-SIZE:   Data:    ELFDATA2LSB
+# TOO-LONG-DESC-SIZE:   Type:    ET_DYN
+# TOO-LONG-DESC-SIZE:   Machine: EM_X86_64
+# TOO-LONG-DESC-SIZE: Sections:
+# TOO-LONG-DESC-SIZE:   - Name:    .note.foo
+# TOO-LONG-DESC-SIZE:     Type:    SHT_NOTE
+# TOO-LONG-DESC-SIZE:     Content: 0000000001000000FF000000
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.foo
+    Type: SHT_NOTE
+    Content: "0100000000000000ff00000000"
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.foo
+    Type: SHT_NOTE
+    Content: "0000000001000000ff00000000"

test/tools/yaml2obj/elf-sht-note.yaml

+## Check how yaml2obj produces SHT_NOTE sections.
+
+## Check we can describe SHT_NOTE using the "Notes" tag. We can define
+## notes using names, descriptions and types.
+## Check we produce a valid name size and description size fields.
+## Check we produce valid paddings.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=NOTE
+
+# NOTE:      Section {
+# NOTE:        Index: 1
+# NOTE-NEXT:   Name: .note.foo (1)
+# NOTE-NEXT:   Type: SHT_NOTE (0x7)
+# NOTE-NEXT:   Flags [ (0x2)
+# NOTE-NEXT:     SHF_ALLOC (0x2)
+# NOTE-NEXT:   ]
+# NOTE-NEXT:   Address: 0x0
+# NOTE-NEXT:   Offset: 0x40
+# NOTE-NEXT:   Size: 40
+# NOTE-NEXT:   Link: 0
+# NOTE-NEXT:   Info: 0
+# NOTE-NEXT:   AddressAlignment: 0
+# NOTE-NEXT:   EntrySize: 0
+# NOTE-NEXT:   SectionData (
+## namesz == (0x03000000) == sizeof("AB") + null terminator.
+## descsz == (0x00000000) for an empty description.
+## Check we produce a valid 2 bytes zeroes padding after the Name.
+# NOTE-NEXT:     0000: 03000000 00000000 FF000000 41420000  |............AB..|
+## namesz == (0x04000000) == sizeof("ABC") + null terminator.
+## descsz == (0x06000000) == sizeof("123456").
+## Check we produce a valid (zero align to 4) 1 byte padding after the Name.
+## Check we produce a valid (zero align to 4) 2 bytes padding after the Desc.
+# NOTE-NEXT:     0010: 04000000 06000000 FE000000 41424300  |............ABC.|
+# NOTE-NEXT:     0020: 31323334 35360000                    |123456..|
+# NOTE-NEXT:   )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:  .note.foo
+    Type:  SHT_NOTE
+    Flags: [ SHF_ALLOC ]
+    Notes:
+      - Name: AB
+        Desc: ''
+        Type: 0xFF
+      - Name: ABC
+        Desc: '123456'
+        Type: 254
+
+## Check that 'Tag' field is mandatory. 
+
+# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=TAG-REQ
+# TAG-REQ: error: missing required key 'Type'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:  .note.foo
+    Type:  SHT_NOTE
+    Notes:
+      - Name: ''
+        Desc: ''
+
+## Check that neither `Name` nor `Desc` are mandatory fields.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readobj --sections --section-data %t3 | FileCheck %s --check-prefix=NAME-DESC
+
+# NAME-DESC:      Name: .note.foo
+# NAME-DESC:      SectionData (
+# NAME-DESC-NEXT:   0000: 00000000 00000000 FF000000 |
+# NAME-DESC-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:  .note.foo
+    Type:  SHT_NOTE
+    Notes:
+      - Type: 0xFF
+
+## Check we can use the "Content" tag to specify any data for SHT_NOTE sections.
+
+# RUN: yaml2obj --docnum=4 %s -o %t4
+# RUN: llvm-readobj --sections --section-data %t4 | FileCheck %s --check-prefix=CONTENT
+
+# CONTENT:      Name: .note.foo
+# CONTENT:      SectionData (
+# CONTENT-NEXT:   0000: 11223344 55 |
+# CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.foo
+    Type: SHT_NOTE
+    Content: "1122334455"
+
+## Either "Content", "Size" or "Notes" must be specifed for SHT_NOTE sections.
+
+# RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
+
+# NO-TAGS: error: one of "Content", "Size" or "Notes" must be specified
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.foo
+    Type: SHT_NOTE
+
+## "Content" and "Notes" cannot be used together to describe the SHT_NOTE section.
+
+# RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-NOTES
+
+# CONTENT-NOTES: error: "Notes" cannot be used with "Content" or "Size"
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.foo
+    Type: SHT_NOTE
+    Content: ""
+    Notes: []
+
+## "Size" and "Notes" cannot be used together to describe the SHT_NOTE section.
+
+# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-NOTES
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.foo
+    Type: SHT_NOTE
+    Size: 1
+    Notes: []
+
+## Check we can use only "Size" to create a SHT_NOTE section.
+
+# RUN: yaml2obj --docnum=8 %s -o %t8
+# RUN: llvm-readobj --sections --section-data %t8 | FileCheck %s --check-prefix=SIZE
+
+# SIZE:      Name: .note.foo
+# 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: .note.foo
+    Type: SHT_NOTE
+    Size: 0x11
+
+## Check we can use "Size" and "Content" together to create a SHT_NOTE section.
+
+# RUN: yaml2obj --docnum=9 %s -o %t9
+# RUN: llvm-readobj --sections --section-data %t9 | FileCheck %s --check-prefix=SIZE-CONTENT
+
+# SIZE-CONTENT:      Name: .note.sizegr
+# SIZE-CONTENT:      SectionData (
+# SIZE-CONTENT-NEXT:   0000: 11223300 00 |
+# SIZE-CONTENT-NEXT: )
+
+# SIZE-CONTENT:      Name: .note.sizeeq
+# SIZE-CONTENT:      SectionData (
+# SIZE-CONTENT-NEXT:   0000: 112233 |
+# SIZE-CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name: .note.sizegr
+    Type: SHT_NOTE
+    Size: 0x5
+    Content: "112233"
+  - Name: .note.sizeeq
+    Type: SHT_NOTE
+    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=10 %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: .note
+    Type: SHT_NOTE
+    Size: 0x1
+    Content: "1122"
+
+## Check we can't use "Size" and "Notes" tags together.
+
+# RUN: not yaml2obj --docnum=11 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-NOTES
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name: .note
+    Type: SHT_NOTE
+    Size: 0x1
+    Notes: []

tools/obj2yaml/elf2yaml.cpp

 template <class ELFT>
 class ELFDumper {
   typedef object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef typename ELFT::Dyn Elf_Dyn;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Word Elf_Word;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
+  using Elf_Nhdr = typename ELFT::Nhdr;
+  using Elf_Note = typename ELFT::Note;
 
   ArrayRef<Elf_Shdr> Sections;
   ArrayRef<Elf_Sym> SymTable;
 
   DenseMap<StringRef, uint32_t> UsedSectionNames;
   std::vector<std::string> SectionNames;
 
   DenseMap<StringRef, uint32_t> UsedSymbolNames;
class ELFDumper {
   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);
+  Expected<ELFYAML::NoteSection *> dumpNoteSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
   Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
   Expected<ELFYAML::StackSizesSection *>
   dumpStackSizesSection(const Elf_Shdr *Shdr);
 
for (const Elf_Shdr &Sec : Sections) {
     }
     case ELF::SHT_NOBITS: {
       Expected<ELFYAML::NoBitsSection *> SecOrErr = dumpNoBitsSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Sections.emplace_back(*SecOrErr);
       break;
     }
+    case ELF::SHT_NOTE: {
+      Expected<ELFYAML::NoteSection *> SecOrErr = dumpNoteSection(&Sec);
+      if (!SecOrErr)
+        return SecOrErr.takeError();
+      Y->Sections.emplace_back(*SecOrErr);
+      break;
+    }
     case ELF::SHT_HASH: {
       Expected<ELFYAML::HashSection *> SecOrErr = dumpHashSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Sections.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_GNU_verdef: {
ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
   S->Size = Shdr->sh_size;
 
   return S.release();
 }
 
 template <class ELFT>
+Expected<ELFYAML::NoteSection *>
+ELFDumper<ELFT>::dumpNoteSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::NoteSection>();
+  if (Error E = dumpCommonSection(Shdr, *S))
+    return std::move(E);
+
+  auto ContentOrErr = Obj.getSectionContents(Shdr);
+  if (!ContentOrErr)
+    return ContentOrErr.takeError();
+
+  std::vector<ELFYAML::NoteEntry> Entries;
+  ArrayRef<uint8_t> Content = *ContentOrErr;
+  while (!Content.empty()) {
+    if (Content.size() < sizeof(Elf_Nhdr)) {
+      S->Content = yaml::BinaryRef(*ContentOrErr);
+      return S.release();
+    }
+
+    const Elf_Nhdr *Header = reinterpret_cast<const Elf_Nhdr *>(Content.data());
+    if (Content.size() < Header->getSize()) {
+      S->Content = yaml::BinaryRef(*ContentOrErr);
+      return S.release();
+    }
+
+    Elf_Note Note(*Header);
+    Entries.push_back(
+        {Note.getName(), toStringRef(Note.getDesc()), Note.getType()});
+
+    Content = Content.drop_front(Header->getSize());
+  }
+
+  S->Notes = std::move(Entries);
+  return S.release();
+}
+
+template <class ELFT>
 Expected<ELFYAML::HashSection *>
 ELFDumper<ELFT>::dumpHashSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::HashSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)