[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

3 ↗

(On Diff #225186)

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.

62 ↗

(On Diff #225186)

when the content is shorter than the computed size

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

26 ↗

(On Diff #225186)

NUL terminator.

NUL != null.

56 ↗

(On Diff #225186)

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

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

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).

llvm/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;
+  yaml::BinaryRef 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);
 };
 

llvm/include/llvm/Support/YAMLTraits.h

 // 5.1. Character Set
 // The allowed character range explicitly excludes the C0 control block #x0-#x1F
 // (except for TAB #x9, LF #xA, and CR #xD which are allowed), DEL #x7F, the C1
 // control block #x80-#x9F (except for NEL #x85 which is allowed), the surrogate
 // block #xD800-#xDFFF, #xFFFE, and #xFFFF.
 inline QuotingType needsQuotes(StringRef S) {
   if (S.empty())
     return QuotingType::Single;
-  if (isspace(static_cast<unsigned char>(S.front())) ||
-      isspace(static_cast<unsigned char>(S.back())))
+  if (isspace(S.front()) || isspace(S.back()))
     return QuotingType::Single;
   if (isNull(S))
     return QuotingType::Single;
   if (isBool(S))
     return QuotingType::Single;
   if (isNumeric(S))
     return QuotingType::Single;
 

llvm/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.binary_size() == 0)
+      support::endian::write<uint32_t>(OS, 0, ELFT::TargetEndianness);
+    else
+      support::endian::write<uint32_t>(OS, NE.Desc.binary_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.binary_size() != 0) {
+      NE.Desc.writeAsBinary(OS);
+      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))

llvm/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);

llvm/test/tools/llvm-objcopy/ELF/set-section-alignment.test

 Sections:
   - Name:         .foo
     Type:         SHT_PROGBITS
   - Name:         .bar
     Type:         SHT_NOBITS
   - Name:         .baz
     Type:         SHT_NOTE
     AddressAlign: 4
+    Notes:        []

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

- Name: rela
     Info: progbits
   - Name: hash
     Type: SHT_HASH
     Content: ''
   - Name: dynamic
     Type: SHT_DYNAMIC
   - Name: note
     Type: SHT_NOTE
+    Notes: []
   - Name: nobits
     Type: SHT_NOBITS
   - Name: rel
     Type: SHT_REL
     Info: progbits
   - Name: shlib
     Type: SHT_SHLIB
   - Name: dynsym

llvm/test/tools/llvm-readobj/gnu-notes.test

 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:     .note
     Type:     SHT_NOTE
+    Notes:    []
     ShOffset: 0xffff0000
 
 ## Test tools report an error if a note section has invalid size
 ## that goes past the end of file.
 
 # RUN: yaml2obj --docnum=3 %s > %t3.so
 # RUN: not llvm-readelf --notes %t3.so 2>&1 | FileCheck -DFILE=%t3.so %s --check-prefix=ERR2
 # RUN: not llvm-readobj --notes %t3.so 2>&1 | FileCheck -DFILE=%t3.so %s --check-prefix=ERR2
 
 # ERR2: error: '[[FILE]]': SHT_NOTE section [index 1] has invalid offset (0x40) or size (0xffff0000)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:   .note
     Type:   SHT_NOTE
     ShSize: 0xffff0000
+    Notes:  []
 
 ## Test tools report an error if a note program header has an invalid offset that
 ## goes past the end of file.
 
 # RUN: yaml2obj --docnum=4 %s > %t4.so
 # RUN: not llvm-readelf --notes %t4.so 2>&1 | FileCheck -DFILE=%t4.so %s --check-prefix=ERR3
 # RUN: not llvm-readobj --notes %t4.so 2>&1 | FileCheck -DFILE=%t4.so %s --check-prefix=ERR3
 
 # ERR3: error: '[[FILE]]': PT_NOTE header has invalid offset (0xffff0000) or size (0x0)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_CORE
   Machine: EM_X86_64
 Sections:
-  - Name: .note
-    Type: SHT_NOTE
+  - Name:  .note
+    Type:  SHT_NOTE
+    Notes: []
 ProgramHeaders:
   - Type: PT_NOTE
     Offset: 0xffff0000
     Sections:
       - Section: .note
 
 ## Test tools report an error if a note program header has an invalid size that
 ## goes past the end of file.
 
 # RUN: yaml2obj --docnum=5 %s > %t5.so
 # RUN: not llvm-readelf --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so  %s --check-prefix=ERR4
 # RUN: not llvm-readobj --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefix=ERR4
 
 # ERR4: error: '[[FILE]]': PT_NOTE header has invalid offset (0x78) or size (0xffff0000)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_CORE
   Machine: EM_X86_64
 Sections:
-  - Name: .note
-    Type: SHT_NOTE
+  - Name:  .note
+    Type:  SHT_NOTE
+    Notes: []
 ProgramHeaders:
   - Type: PT_NOTE
     FileSize: 0xffff0000
     Sections:
       - Section: .note

llvm/test/tools/llvm-size/elf-sysv.test

Sections:
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     ShSize:  0x80
     Address: 0x8000
   - Name:    .note
     Type:    SHT_NOTE
     ShSize:  0x100
     Address: 0x4000
+    Notes:   []
   - Name:    .nobits
     Type:    SHT_NOBITS
     ShSize:  0x200
     Address: 0x2000
   - Name:    .rel
     Type:    SHT_REL
     ShSize:  0x400
     Address: 0x1000

llvm/test/tools/yaml2obj/implicit-sections-types.test

Sections:
   - Name: .symtab
     Type: SHT_DYNAMIC
   - Name: .strtab
     Type: SHT_RELA
   - Name: .shstrtab
     Type: SHT_PROGBITS
   - Name: .dynsym
     Type: SHT_NOTE
+    Size: 0
   - Name: .dynstr
     Type: SHT_NOBITS
 ## Needed to set the proper content size for .symtab, so
 ## that llvm-readobj can dump this section.
 Symbols:
   - Name: foo

llvm/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(), Note.getDesc(), (llvm::yaml::Hex32)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)