[Object] Fix handling of Elf_Nhdr with sh_addralign=8

[MaskRay]

Summary

The generic ABI says:

Padding is present, if necessary, to ensure 8 or 4-byte alignment for the next note entry (depending on whether the file is a 64-bit or 32-bit object). Such padding is not included in descsz.

Our parsing code currently aligns n_namesz. Fix the bug by aligning the start
offset of the descriptor instead. This issue has been benign because the primary
uses of sh_addralign=8 notes are .note.gnu.property, where
sizeof(Elf_Nhdr) + sizeof("GNU") = 16 (already aligned by 8).

In practice, many 64-bit systems incorrectly use sh_addralign=4 notes.
We can use sh_addralign (= p_align) to decide the descriptor padding.
Treat an alignment of 0 and 1 as 4. This approach matches modern GNU readelf
(since 2018).

We have a few tests incorrectly using sh_addralign=0. We may make our behavior
stricter after fixing these tests.

Linux kernel dumped core files use p_align=0 notes, so we need to support the
case for compatibility.

[jhenderson]

llvm/include/llvm/Object/ELF.h

319

This will permit p_align values of 2 and 3, and treat them as 4. Should we instead reject those too? The error message also is not techincally accurate ("is not 4 or 8"), since it could be 0 (or 1/2/3) and be handled by this code. I'm okay with that not changing if we are excluding other values, for convenience of wording though.

325

Nit: this probably wants to be a uint64_t rather than size_t max, right (since p_align could be uint64_t and therefore a larger type on 32-bit hosts than size_t)?

344

Nit: missing ".", and I think the tendency is for "TODO: ", i.e. with colon.

The duplication between this and the Phdr version of this makes me sad :( it feels like we could share the code and therefore avoid duplicating these extra checks.

llvm/include/llvm/Object/ELFTypes.h

647

Is 4 here correct?

llvm/test/tools/llvm-readobj/ELF/note-gnu-property2.s

21

Changing the logic means that there is no test coverage that hits the "<corrupted GNU_PROPERTY_TYPE_0>" output, as far as I can tell. Do we need a new test to cover that? It may be worth looking at note-gnu-property.s to see if that already covers what the new test covers.

llvm/tools/llvm-readobj/ELFDumper.cpp

5827

Similar to the earlier comment, should this be uint64_t? Same goes for other cases in the file.

[MaskRay]

address comments

llvm/include/llvm/Object/ELF.h

325

We have excluded larger p_align values, so using size_t is fine. ELFTypes.h Elf_Nhdr_Impl::getSize returns a size_t and the choice is to match its return value.

llvm/tools/llvm-readobj/ELFDumper.cpp

5827

This should be fine, since we've excluded large p_align values and reported an error very early.

[jhenderson]

Looks good.

llvm/include/llvm/Object/ELF.h

325

Okay, fair enough.

[ronlieb]

breaking our openmp buildbot, please fix
https://lab.llvm.org/buildbot/#/builders/193/builds/30954

lld/ELF/InputFiles.cpp

template <class ELFT> static uint32_t readAndFeatures(const InputSection &sec) {
   ArrayRef<uint8_t> data = sec.content();
   auto reportFatal = [&](const uint8_t *place, const char *msg) {
     fatal(toString(sec.file) + ":(" + sec.name + "+0x" +
           Twine::utohexstr(place - sec.content().data()) + "): " + msg);
   };
   while (!data.empty()) {
     // Read one NOTE record.
     auto *nhdr = reinterpret_cast<const Elf_Nhdr *>(data.data());
-    if (data.size() < sizeof(Elf_Nhdr) || data.size() < nhdr->getSize())
+    if (data.size() < sizeof(Elf_Nhdr) ||
+        data.size() < nhdr->getSize(sec.addralign))
       reportFatal(data.data(), "data is too short");
 
     Elf_Note note(*nhdr);
     if (nhdr->n_type != NT_GNU_PROPERTY_TYPE_0 || note.getName() != "GNU") {
-      data = data.slice(nhdr->getSize());
+      data = data.slice(nhdr->getSize(sec.addralign));
       continue;
     }
 
     uint32_t featureAndType = config->emachine == EM_AARCH64
                                   ? GNU_PROPERTY_AARCH64_FEATURE_1_AND
                                   : GNU_PROPERTY_X86_FEATURE_1_AND;
 
     // Read a body of a NOTE record, which consists of type-length-value fields.
-    ArrayRef<uint8_t> desc = note.getDesc();
+    ArrayRef<uint8_t> desc = note.getDesc(sec.addralign);
     while (!desc.empty()) {
       const uint8_t *place = desc.data();
       if (desc.size() < 8)
         reportFatal(place, "program property is too short");
       uint32_t type = read32<ELFT::TargetEndianness>(desc.data());
       uint32_t size = read32<ELFT::TargetEndianness>(desc.data() + 4);
       desc = desc.slice(8);
       if (desc.size() < size)
         reportFatal(place, "program property is too short");
 
       if (type == featureAndType) {
         // We found a FEATURE_1_AND field. There may be more than one of these
         // in a .note.gnu.property section, for a relocatable object we
         // accumulate the bits set.
         if (size < 4)
           reportFatal(place, "FEATURE_1_AND entry is too short");
         featuresSet |= read32<ELFT::TargetEndianness>(desc.data());
       }
 
       // Padding is present in the note descriptor, if necessary.
       desc = desc.slice(alignTo<(ELFT::Is64Bits ? 8 : 4)>(size));
     }
 
     // Go to next NOTE record to look for more FEATURE_1_AND descriptions.
-    data = data.slice(nhdr->getSize());
+    data = data.slice(nhdr->getSize(sec.addralign));
   }
 
   return featuresSet;
 }
 
 template <class ELFT>
 InputSectionBase *ObjFile<ELFT>::getRelocTarget(uint32_t idx,
                                                 const Elf_Shdr &sec,

llvm/include/llvm/Object/ELF.h

Elf_Note_Iterator notes_begin(const Elf_Phdr &Phdr, Error &Err) const {
     assert(Phdr.p_type == ELF::PT_NOTE && "Phdr is not of type PT_NOTE");
     ErrorAsOutParameter ErrAsOutParam(&Err);
     if (Phdr.p_offset + Phdr.p_filesz > getBufSize()) {
       Err =
           createError("invalid offset (0x" + Twine::utohexstr(Phdr.p_offset) +
                       ") or size (0x" + Twine::utohexstr(Phdr.p_filesz) + ")");
       return Elf_Note_Iterator(Err);
     }
-    return Elf_Note_Iterator(base() + Phdr.p_offset, Phdr.p_filesz, Err);
+    if (Phdr.p_align > 4 && Phdr.p_align != 8) {
+      Err =
+          createError("alignment (" + Twine(Phdr.p_align) + ") is not 4 or 8");
+      return Elf_Note_Iterator(Err);
+    }
+    return Elf_Note_Iterator(base() + Phdr.p_offset, Phdr.p_filesz,
+                             std::max<size_t>(Phdr.p_align, 4), Err);
   }
 
   /// Get an iterator over notes in a section.
   ///
   /// The section must be of type \c SHT_NOTE.
   ///
   /// \param Shdr the section to iterate over.
   /// \param Err [out] an error to support fallible iteration, which should
   ///  be checked after iteration ends.
   Elf_Note_Iterator notes_begin(const Elf_Shdr &Shdr, Error &Err) const {
     assert(Shdr.sh_type == ELF::SHT_NOTE && "Shdr is not of type SHT_NOTE");
     ErrorAsOutParameter ErrAsOutParam(&Err);
     if (Shdr.sh_offset + Shdr.sh_size > getBufSize()) {
       Err =
           createError("invalid offset (0x" + Twine::utohexstr(Shdr.sh_offset) +
                       ") or size (0x" + Twine::utohexstr(Shdr.sh_size) + ")");
       return Elf_Note_Iterator(Err);
     }
-    return Elf_Note_Iterator(base() + Shdr.sh_offset, Shdr.sh_size, Err);
+    // TODO Be stricter about the alignment
+    if (Shdr.sh_addralign > 4 && Shdr.sh_addralign != 8) {
+      Err = createError("alignment (" + Twine(Shdr.sh_addralign) +
+                        ") is not 4 or 8");
+      return Elf_Note_Iterator(Err);
+    }
+    return Elf_Note_Iterator(base() + Shdr.sh_offset, Shdr.sh_size,
+                             std::max<size_t>(Shdr.sh_addralign, 4), Err);
   }
 
   /// Get the end iterator for notes.
   Elf_Note_Iterator notes_end() const {
     return Elf_Note_Iterator();
   }
 
   /// Get an iterator range over notes of a program header.

llvm/include/llvm/Object/ELFTypes.h

 /// Note header
 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);
+  /// Get the size of the note, including name, descriptor, and padding. Both
+  /// the start and the end of the descriptor are aligned by the section
+  /// alignment. In practice many 64-bit systems deviate from the generic ABI by
+  /// using sh_addralign=4.
+  size_t getSize(size_t Align) const {
+    return alignToPowerOf2(sizeof(*this) + n_namesz, Align) +
+           alignToPowerOf2(n_descsz, Align);
   }
 };
 
 /// An ELF note.
 ///
 /// Wraps a note header, providing methods for accessing the name and
 /// descriptor safely.
 template <class ELFT>
public:
   StringRef getName() const {
     if (!Nhdr.n_namesz)
       return StringRef();
     return StringRef(reinterpret_cast<const char *>(&Nhdr) + sizeof(Nhdr),
                      Nhdr.n_namesz - 1);
   }
 
   /// Get the note's descriptor.
-  ArrayRef<uint8_t> getDesc() const {
+  ArrayRef<uint8_t> getDesc(size_t Align) const {
     if (!Nhdr.n_descsz)
       return ArrayRef<uint8_t>();
     return ArrayRef<uint8_t>(
-        reinterpret_cast<const uint8_t *>(&Nhdr) + sizeof(Nhdr) +
-          alignTo<Elf_Nhdr_Impl<ELFT>::Align>(Nhdr.n_namesz),
+        reinterpret_cast<const uint8_t *>(&Nhdr) +
+            alignToPowerOf2(sizeof(Nhdr) + Nhdr.n_namesz, Align),
         Nhdr.n_descsz);
   }
 
   /// Get the note's descriptor as StringRef
   StringRef getDescAsStringRef() const {
-    ArrayRef<uint8_t> Desc = getDesc();
+    ArrayRef<uint8_t> Desc = getDesc(4);
     return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
   }
 
   /// Get the note's type.
   Elf_Word getType() const { return Nhdr.n_type; }
 };
 
 template <class ELFT> class Elf_Note_Iterator_Impl {
 public:
   using iterator_category = std::forward_iterator_tag;
   using value_type = Elf_Note_Impl<ELFT>;
   using difference_type = std::ptrdiff_t;
   using pointer = value_type *;
   using reference = value_type &;
 
 private:
   // Nhdr being a nullptr marks the end of iteration.
   const Elf_Nhdr_Impl<ELFT> *Nhdr = nullptr;
   size_t RemainingSize = 0u;
+  size_t Align = 0;
   Error *Err = nullptr;
 
   template <class ELFFileELFT> friend class ELFFile;
 
   // Stop iteration and indicate an overflow.
   void stopWithOverflowError() {
     Nhdr = nullptr;
     *Err = make_error<StringError>("ELF note overflows container",
if (RemainingSize == 0u) {
       // Ensure that if the iterator walks to the end, the error is checked
       // afterwards.
       *Err = Error::success();
       Nhdr = nullptr;
     } else if (sizeof(*Nhdr) > RemainingSize)
       stopWithOverflowError();
     else {
       Nhdr = reinterpret_cast<const Elf_Nhdr_Impl<ELFT> *>(NhdrPos + NoteSize);
-      if (Nhdr->getSize() > RemainingSize)
+      if (Nhdr->getSize(Align) > RemainingSize)
         stopWithOverflowError();
       else
         *Err = Error::success();
     }
   }
 
   Elf_Note_Iterator_Impl() = default;
   explicit Elf_Note_Iterator_Impl(Error &Err) : Err(&Err) {}
-  Elf_Note_Iterator_Impl(const uint8_t *Start, size_t Size, Error &Err)
-      : RemainingSize(Size), Err(&Err) {
+  Elf_Note_Iterator_Impl(const uint8_t *Start, size_t Size, size_t Align,
+                         Error &Err)
+      : RemainingSize(Size), Align(Align), Err(&Err) {
     consumeError(std::move(Err));
     assert(Start && "ELF note iterator starting at NULL");
     advanceNhdr(Start, 0u);
   }
 
 public:
   Elf_Note_Iterator_Impl &operator++() {
     assert(Nhdr && "incremented ELF note end iterator");
     const uint8_t *NhdrPos = reinterpret_cast<const uint8_t *>(Nhdr);
-    size_t NoteSize = Nhdr->getSize();
+    size_t NoteSize = Nhdr->getSize(Align);
     advanceNhdr(NhdrPos, NoteSize);
     return *this;
   }
   bool operator==(Elf_Note_Iterator_Impl Other) const {
     if (!Nhdr && Other.Err)
       (void)(bool)(*Other.Err);
     if (!Other.Nhdr && Err)
       (void)(bool)(*Err);

llvm/lib/Object/BuildID.cpp

template <typename ELFT> BuildIDRef getBuildID(const ELFFile<ELFT> &Obj) {
   }
   for (const auto &P : *PhdrsOrErr) {
     if (P.p_type != ELF::PT_NOTE)
       continue;
     Error Err = Error::success();
     for (auto N : Obj.notes(P, Err))
       if (N.getType() == ELF::NT_GNU_BUILD_ID &&
           N.getName() == ELF::ELF_NOTE_GNU)
-        return N.getDesc();
+        return N.getDesc(P.p_align);
     consumeError(std::move(Err));
   }
   return {};
 }
 
 } // namespace
 
 BuildID llvm::object::parseBuildID(StringRef Str) {

llvm/test/tools/llvm-readobj/ELF/AArch64/aarch64-note-gnu-property.s

 // LLVM-NEXT:       Property [
 // LLVM-NEXT:         aarch64 feature: BTI, PAC
 // LLVM-NEXT:       ]
 // LLVM-NEXT:     }
 // LLVM-NEXT:   }
 // LLVM-NEXT: ]
 
 .section ".note.gnu.property", "a"
-.align 4
   .long 4           /* Name length is always 4 ("GNU") */
   .long end - begin /* Data length */
   .long 5           /* Type: NT_GNU_PROPERTY_TYPE_0 */
   .asciz "GNU"      /* Name */
   .p2align 3
 begin:
   /* BTI and PAC property note */
   .long 0xc0000000  /* Type: GNU_PROPERTY_AARCH64_FEATURE_1_AND */
   .long 4           /* Data size */
   .long 3           /* BTI and PAC */
   .p2align 3        /* Align to 8 byte for 64 bit */
 end:

llvm/test/tools/llvm-readobj/ELF/note-alignment-invalid.test

+# RUN: yaml2obj --docnum=1 %s -o %t1.so
+# RUN: llvm-readelf --notes %t1.so 2>&1 | FileCheck %s -DFILE=%t1.so
+# RUN: llvm-readobj --notes %t1.so 2>&1 | FileCheck %s -DFILE=%t1.so
+
+# CHECK: warning: '[[FILE]]': unable to read notes from the SHT_NOTE section with index 1: alignment (6) is not 4 or 8
+
+--- !ELF
+FileHeader:
+  Class:      ELFCLASS64
+  Data:       ELFDATA2LSB
+  Type:       ET_EXEC
+Sections:
+  - Name:         .note.invalid
+    Type:         SHT_NOTE
+    AddressAlign: 0x0000000000000006
+    Content:      0400000004000000cdab0000474E550061626364
+ProgramHeaders:
+  - Type:     PT_NOTE
+    FileSize: 0x20
+    FirstSec: .note.invalid
+    LastSec:  .note.invalid

llvm/test/tools/llvm-readobj/ELF/note-gnu-property2.s

 // REQUIRES: x86-registered-target
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o %t
 // RUN: llvm-readelf --notes %t | FileCheck %s --check-prefix=GNU
 // RUN: llvm-readobj --elf-output-style LLVM --notes %t | FileCheck %s --check-prefix=LLVM
 
 // GNU:      Displaying notes found in: .note.gnu.property
 // GNU-NEXT:   Owner                 Data size       Description
-// GNU-NEXT:   GNU                   0x00000004      NT_GNU_PROPERTY_TYPE_0 (property note)
-// GNU-NEXT:     Properties:  <corrupted GNU_PROPERTY_TYPE_0>
+// GNU-NEXT:   GNU                   0x00000008      NT_GNU_PROPERTY_TYPE_0 (property note)
+// GNU-NEXT:     Properties:  stack size: <corrupt length: 0x0>
 
 // LLVM:      Notes [
 // LLVM-NEXT:   NoteSection {
 // LLVM-NEXT:     Name: .note.gnu.property
 // LLVM-NEXT:     Offset: 0x40
-// LLVM-NEXT:     Size: 0x14
+// LLVM-NEXT:     Size: 0x18
 // LLVM-NEXT:     Note {
 // LLVM-NEXT:       Owner: GNU
-// LLVM-NEXT:       Data size: 0x4
+// LLVM-NEXT:       Data size: 0x8
 // LLVM-NEXT:       Type: NT_GNU_PROPERTY_TYPE_0 (property note)
 // LLVM-NEXT:       Property [
-// LLVM-NEXT:         <corrupted GNU_PROPERTY_TYPE_0>
+// LLVM-NEXT:         stack size: <corrupt length: 0x0>
 // LLVM-NEXT:       ]
 // LLVM-NEXT:     }
 // LLVM-NEXT:   }
 // LLVM-NEXT: ]
 
 // Section below is broken, check we report that.
 
 .section ".note.gnu.property", "a"
 .align 4 
   .long 4           /* Name length is always 4 ("GNU") */
   .long end - begin /* Data length */
   .long 5           /* Type: NT_GNU_PROPERTY_TYPE_0 */
   .asciz "GNU"      /* Name */
   .p2align 3
 begin:
   .long 1           /* Type: GNU_PROPERTY_STACK_SIZE */
+  .p2align 3
 end:

llvm/test/tools/llvm-readobj/ELF/note-unknown.s

 // LLVM-NEXT:       Data size: 0x1C
 // LLVM-NEXT:       Type: Unknown (0x00000003)
 // LLVM-NEXT:       Description data (
 // LLVM-NEXT:         0000: 4C6F7265 6D206970 73756D20 646F6C6F  |Lorem ipsum dolo|
 // LLVM-NEXT:         0010: 72207369 7420616D 65740000           |r sit amet..|
 // LLVM-NEXT:       )
 // LLVM-NEXT:     }
 // LLVM-NEXT:   }
+// LLVM-NEXT:   NoteSection {
+// LLVM-NEXT:     Name: .note.8
+// LLVM-NEXT:     Offset: 0x80
+// LLVM-NEXT:     Size: 0x40
+// LLVM-NEXT:     Note {
+// LLVM-NEXT:       Owner: WXYZ
+// LLVM-NEXT:       Data size: 0x8
+// LLVM-NEXT:       Type: Unknown (0x00000006)
+// LLVM-NEXT:       Description data (
+// LLVM-NEXT:         0000: 4C6F7265 6D000000                    |Lorem...|
+// LLVM-NEXT:       )
+// LLVM-NEXT:     }
+// LLVM-NEXT:     Note {
+// LLVM-NEXT:       Owner: VWXYZ
+// LLVM-NEXT:       Data size: 0x8
+// LLVM-NEXT:       Type: Unknown (0x00000006)
+// LLVM-NEXT:       Description data (
+// LLVM-NEXT:         0000: 78787800 00000000                    |xxx.....|
+// LLVM-NEXT:       )
+// LLVM-NEXT:     }
+// LLVM-NEXT:   }
 // LLVM-NEXT: ]
 
 .section ".note.foo", "a"
-  .align 4
   .long 4 /* namesz */
   .long 0 /* descsz */
   .long 3 /* type */
   .asciz "XYZ"
-.section ".note.bar", "a"
-       .align 4
+  .align 4
+.section ".note.bar", "a"
        .long 4 /* namesz */
        .long end - begin /* descsz */
        .long 3 /* type */
        .asciz "XYZ"
+       .align 4
 begin:
        .asciz "Lorem ipsum dolor sit amet"
        .align 4
 end:
+
+.section ".note.8", "a"
+       .long 5 /* namesz */
+       .long 2f - 1f /* descsz */
+       .long 6 /* type */
+       .asciz "WXYZ"
+       .align 8
+1:
+       .asciz "Lorem"
+       .align 8
+2:
+
+       .long 6 /* namesz */
+       .long 2f - 1f /* descsz */
+       .long 6 /* type */
+       .asciz "VWXYZ"
+       .align 8
+1:
+       .asciz "xxx"
+       .align 8
+2:

llvm/tools/llvm-readobj/ELFDumper.cpp

if (ELFType == ELF::ET_CORE)
     return FindNote(CoreNoteTypes);
   return FindNote(GenericNoteTypes);
 }
 
 template <class ELFT>
 static void processNotesHelper(
     const ELFDumper<ELFT> &Dumper,
     llvm::function_ref<void(std::optional<StringRef>, typename ELFT::Off,
-                            typename ELFT::Addr)>
+                            typename ELFT::Addr, size_t)>
         StartNotesFn,
     llvm::function_ref<Error(const typename ELFT::Note &, bool)> ProcessNoteFn,
     llvm::function_ref<void()> FinishNotesFn) {
   const ELFFile<ELFT> &Obj = Dumper.getElfObject().getELFFile();
   bool IsCoreFile = Obj.getHeader().e_type == ELF::ET_CORE;
 
   ArrayRef<typename ELFT::Shdr> Sections = cantFail(Obj.sections());
   if (!IsCoreFile && !Sections.empty()) {
     for (const typename ELFT::Shdr &S : Sections) {
       if (S.sh_type != SHT_NOTE)
         continue;
       StartNotesFn(expectedToStdOptional(Obj.getSectionName(S)), S.sh_offset,
-                   S.sh_size);
+                   S.sh_size, S.sh_addralign);
       Error Err = Error::success();
       size_t I = 0;
       for (const typename ELFT::Note Note : Obj.notes(S, Err)) {
         if (Error E = ProcessNoteFn(Note, IsCoreFile))
           Dumper.reportUniqueWarning(
               "unable to read note with index " + Twine(I) + " from the " +
               describe(Obj, S) + ": " + toString(std::move(E)));
         ++I;
Dumper.reportUniqueWarning(
         toString(PhdrsOrErr.takeError()));
     return;
   }
 
   for (size_t I = 0, E = (*PhdrsOrErr).size(); I != E; ++I) {
     const typename ELFT::Phdr &P = (*PhdrsOrErr)[I];
     if (P.p_type != PT_NOTE)
       continue;
-    StartNotesFn(/*SecName=*/std::nullopt, P.p_offset, P.p_filesz);
+    StartNotesFn(/*SecName=*/std::nullopt, P.p_offset, P.p_filesz, P.p_align);
     Error Err = Error::success();
     size_t Index = 0;
     for (const typename ELFT::Note Note : Obj.notes(P, Err)) {
       if (Error E = ProcessNoteFn(Note, IsCoreFile))
         Dumper.reportUniqueWarning("unable to read note with index " +
                                    Twine(Index) +
                                    " from the PT_NOTE segment with index " +
                                    Twine(I) + ": " + toString(std::move(E)));
       ++Index;
     }
     if (Err)
       Dumper.reportUniqueWarning(
           "unable to read notes from the PT_NOTE segment with index " +
           Twine(I) + ": " + toString(std::move(Err)));
     FinishNotesFn();
   }
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printNotes() {
+  size_t Align = 0;
   bool IsFirstHeader = true;
   auto PrintHeader = [&](std::optional<StringRef> SecName,
                          const typename ELFT::Off Offset,
-                         const typename ELFT::Addr Size) {
+                         const typename ELFT::Addr Size, size_t Al) {
+    Align = std::max<size_t>(Al, 4);
     // Print a newline between notes sections to match GNU readelf.
     if (!IsFirstHeader) {
       OS << '\n';
     } else {
       IsFirstHeader = false;
     }
 
     OS << "Displaying notes found ";
 
     if (SecName)
       OS << "in: " << *SecName << "\n";
     else
       OS << "at file offset " << format_hex(Offset, 10) << " with length "
          << format_hex(Size, 10) << ":\n";
 
     OS << "  Owner                Data size \tDescription\n";
   };
 
   auto ProcessNote = [&](const Elf_Note &Note, bool IsCore) -> Error {
     StringRef Name = Note.getName();
-    ArrayRef<uint8_t> Descriptor = Note.getDesc();
+    ArrayRef<uint8_t> Descriptor = Note.getDesc(Align);
     Elf_Word Type = Note.getType();
 
     // Print the note owner/type.
     OS << "  " << left_justify(Name, 20) << ' '
        << format_hex(Descriptor.size(), 10) << '\t';
 
     StringRef NoteType =
         getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type);
case DT_AARCH64_MEMTAG_STACK:
       break;
     }
   }
 
   ArrayRef<uint8_t> AndroidNoteDesc;
   auto FindAndroidNote = [&](const Elf_Note &Note, bool IsCore) -> Error {
     if (Note.getName() == "Android" &&
         Note.getType() == ELF::NT_ANDROID_TYPE_MEMTAG)
-      AndroidNoteDesc = Note.getDesc();
+      AndroidNoteDesc = Note.getDesc(4);
     return Error::success();
   };
 
   processNotesHelper(
       *this,
       /*StartNotesFn=*/
       [](std::optional<StringRef>, const typename ELFT::Off,
-         const typename ELFT::Addr) {},
+         const typename ELFT::Addr, size_t) {},
       /*ProcessNoteFn=*/FindAndroidNote, /*FinishNotesFn=*/[]() {});
 
   ArrayRef<uint8_t> Contents = getMemtagGlobalsSectionContents(MemtagGlobals);
   if (Contents.size() != MemtagGlobalsSz) {
     reportUniqueWarning(
         "mismatch between DT_AARCH64_MEMTAG_GLOBALSSZ (0x" +
         Twine::utohexstr(MemtagGlobalsSz) +
         ") and SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC section size (0x" +
for (const CoreFileMapping &Mapping : Note.Mappings) {
     W.printString("Filename", Mapping.Filename);
   }
 }
 
 template <class ELFT> void LLVMELFDumper<ELFT>::printNotes() {
   ListScope L(W, "Notes");
 
   std::unique_ptr<DictScope> NoteScope;
+  size_t Align = 0;
   auto StartNotes = [&](std::optional<StringRef> SecName,
                         const typename ELFT::Off Offset,
-                        const typename ELFT::Addr Size) {
+                        const typename ELFT::Addr Size, size_t Al) {
+    Align = std::max<size_t>(Al, 4);
     NoteScope = std::make_unique<DictScope>(W, "NoteSection");
     W.printString("Name", SecName ? *SecName : "<?>");
     W.printHex("Offset", Offset);
     W.printHex("Size", Size);
   };
 
   auto EndNotes = [&] { NoteScope.reset(); };
 
   auto ProcessNote = [&](const Elf_Note &Note, bool IsCore) -> Error {
     DictScope D2(W, "Note");
     StringRef Name = Note.getName();
-    ArrayRef<uint8_t> Descriptor = Note.getDesc();
+    ArrayRef<uint8_t> Descriptor = Note.getDesc(Align);
     Elf_Word Type = Note.getType();
 
     // Print the note owner/type.
     W.printString("Owner", Name);
     W.printHex("Data size", Descriptor.size());
 
     StringRef NoteType =
         getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type);

llvm/tools/obj2yaml/elf2yaml.cpp

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;
+  size_t Align = std::max<size_t>(Shdr->sh_addralign, 4);
   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()) {
+    if (Content.size() < Header->getSize(Align)) {
       S->Content = yaml::BinaryRef(*ContentOrErr);
       return S.release();
     }
 
     Elf_Note Note(*Header);
     Entries.push_back(
-        {Note.getName(), Note.getDesc(), (ELFYAML::ELF_NT)Note.getType()});
+        {Note.getName(), Note.getDesc(Align), (ELFYAML::ELF_NT)Note.getType()});
 
-    Content = Content.drop_front(Header->getSize());
+    Content = Content.drop_front(Header->getSize(Align));
   }
 
   S->Notes = std::move(Entries);
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::HashSection *>

llvm/unittests/Object/ELFTypesTest.cpp

 
 template <typename ELFT> using Elf_Note = typename ELFT::Note;
 
 template <class ELFT> struct NoteTestData {
   std::vector<uint8_t> Data;
 
   const Elf_Note_Impl<ELFT> getElfNote(StringRef Name, uint32_t Type,
                                        ArrayRef<uint8_t> Desc) {
-    Data.resize(sizeof(Elf_Nhdr_Impl<ELFT>) +
-                    alignTo<Elf_Nhdr_Impl<ELFT>::Align>(Name.size()) +
-                    alignTo<Elf_Nhdr_Impl<ELFT>::Align>(Desc.size()),
+    constexpr uint64_t Align = 4;
+    Data.resize(alignTo(sizeof(Elf_Nhdr_Impl<ELFT>) + Name.size(), Align) +
+                    alignTo(Desc.size(), Align),
                 0);
 
     Elf_Nhdr_Impl<ELFT> *Nhdr =
         reinterpret_cast<Elf_Nhdr_Impl<ELFT> *>(Data.data());
     Nhdr->n_namesz = (Name == "") ? 0 : Name.size() + 1;
     Nhdr->n_descsz = Desc.size();
     Nhdr->n_type = Type;
 
     auto NameOffset = Data.begin() + sizeof(*Nhdr);
     std::copy(Name.begin(), Name.end(), NameOffset);
 
     auto DescOffset =
-        NameOffset + alignTo<Elf_Nhdr_Impl<ELFT>::Align>(Nhdr->n_namesz);
+        Data.begin() + alignTo(sizeof(*Nhdr) + Nhdr->n_namesz, Align);
     std::copy(Desc.begin(), Desc.end(), DescOffset);
 
     return Elf_Note_Impl<ELFT>(*Nhdr);
   }
 };
 
 TEST(ELFTypesTest, NoteTest) {
   static const uint8_t Random[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
   ArrayRef<uint8_t> RandomData = ArrayRef(Random);
   NoteTestData<ELF64LE> TestData;
 
   auto Note1 = TestData.getElfNote(StringRef("AMD"), ELF::NT_AMDGPU_METADATA,
                                    RandomData);
   EXPECT_EQ(Note1.getName(), "AMD");
   EXPECT_EQ(Note1.getType(), ELF::NT_AMDGPU_METADATA);
-  EXPECT_EQ(Note1.getDesc(), RandomData);
+  EXPECT_EQ(Note1.getDesc(4), RandomData);
   EXPECT_EQ(Note1.getDescAsStringRef(),
             StringRef(reinterpret_cast<const char *>(Random), sizeof(Random)));
 
   auto Note2 = TestData.getElfNote("", ELF::NT_AMDGPU_METADATA, RandomData);
   EXPECT_EQ(Note2.getName(), "");
 
   auto Note3 =
       TestData.getElfNote("AMD", ELF::NT_AMDGPU_METADATA, ArrayRef<uint8_t>());
   EXPECT_EQ(Note3.getDescAsStringRef(), StringRef(""));
 }