[llvm-readelf] Implement note parsing for NT_FILE and unknown descriptors

[rupprecht]

Summary

This patch implements two note parsers; one for NT_FILE coredumps, e.g.:

CORE                  0x00000080      NT_FILE (mapped files)
  Page size: 4096
               Start                 End         Page Offset
  0x0000000000001000  0x0000000000002000  0x0000000000003000
      /path/to/a.out
  0x0000000000004000  0x0000000000005000  0x0000000000006000
      /path/to/libc.so
  0x0000000000007000  0x0000000000008000  0x0000000000009000
      [stack]

(A more realistic example can be tested locally by creating a crashing program and running llvm-readelf -n core)

And also implements a raw hex dump for unknown descriptor data for unhandled descriptor types.

[MaskRay]

llvm/tools/llvm-readobj/ELFDumper.cpp

4362

StringRef Filename(reinterpret_cast<const char *>(Filenames.data()));

4363

(I think it is NUL, not null.)

4369

Or for (CoreFileMapping<ELFT> &Mapping : Ret.Mappings) {

4430

|| Obj->getHeader()->e_type == ELF::ET_CORE can be deleted.

readelf -n doesn't seem to perform the test, either.

5576

|| Obj->getHeader()->e_type == ELF::ET_CORE can be deleted.

[grimar]

llvm/test/tools/llvm-readobj/note-core-ntfile.test

63

Perhaps worth to check there is no more output here:

# GNU-NOT: {{.}}

llvm/tools/llvm-readobj/ELFDumper.cpp

4339

Other errors in this file are lowercase, I think the new errors should follow.

5541

This part is common and can be reused for both LLVM and GNU styles:

if (NoteType != ELF::NT_FILE)
  return;

Expected<CoreNote<ELFT>> Note = readCoreNote<ELFT>(Desc);
if (!Note) {
  warn(Note.takeError());
  return;
}

I.e. I would try either add a one more helper or try to combine printCoreNoteLLVMStyle and printCoreNote.

[rupprecht]

• Remove ET_CORE check
• null -> NUL
• Use more consistent error messages
• Check for no more lines in test output
• Other misc cleanup

llvm/tools/llvm-readobj/ELFDumper.cpp

4339

These are just lifted directly from GNU readelf, but we probably don't need to match them -- reformatted/reworded all of them to be more consistent. I'm open to different wording for any of them.

(especially "too short for supplied file count", I've rewritten it as "too short for number of files", but it still sounds a little awkward)

4363

Wow, TIL about the difference between NUL and null

4430

Removed -- but I should elaborate, readelf does perform this check. Note that GNU readelf actually prints notes in two stages:

• First it tries to print the note type. It starts by looking at the name, although the fallback (if the name is empty, doesn't match any of the known names, or in some (but not all) cases matches the name but doesn't match any known constants) will look at the file type (see process_note and get_note_type).
  • Note: none of the "names" it checks is "CORE", it _only_ prints out the NT_* core descriptions if the actual elf type is ET_CORE
• Second, it prints note data, this time only looking at the name, i.e. if name is "CORE" (and it ignores the elf type) -- this is what you're talking about, but not the first.

I think these points don't matter that much. I think the only thing this would break is if someone is expecting a ET_REL/ET_EXEC file with CORE notes to print non-core NT_* fields. But still, I think we should figure out if/how we want to match GNU readelf for printing notes.

5541

I moved some of this into the GNU/LLVMStyle::printNotes methods and it's a bit more succinct now, PTAL -- I'm not sure if it's what you're going for.

[rupprecht]

llvm/tools/llvm-readobj/ELFDumper.cpp

4430

Actually, I do notice a change after testing this locally:
When I run a dummy crashing program and then run llvm-readelf -n core, there's a note with type "LINUX" that says "NT_X86_XSTATE (x86 XSAVE extended state)" in GNU readelf that now shows up as "Unknown note type: (0x00000202)"

So, I'll have to undo this part of the change and update the diff in a bit. We should consider separating the note type vs description printing similarly.
(Aside: there is very little llvm-readobj test coverage for the FreeBSD/AMD/AMDGPU note types above, I'll add some in a separate commit)

[rupprecht]

• Restore ET_CORE check

[MaskRay]

llvm/test/tools/llvm-readobj/note-core-ntfile.test

8

llvm-mc doesn't support generating ET_CORE files; the following section data was generated with the following steps:

May be worth mentioning that the Content field of .note.foo` was derived from the following assembly.

The comment make me think that other fields of the file are derived from llvm-mc output, but they aren't according to "following steps".

(Not necessarily mentioned in the comment: llvm-readobj doesn't give hex pairs you can immediately use, but llvm-objcopy --dump-section=.note.foo=>(xxd -p) tmp.o /dev/null (>(..) is zsh syntax) does.)

15

Nit: /* */ -> #

# is probably a bit easier to read.

llvm/tools/llvm-readobj/ELFDumper.cpp

4430

Verified. || Obj->getHeader()->e_type == ELF::ET_CORE dumps "LINUX". This makes me think if we should use more specific Name == "CORE" || Name == "LINUX".

I think this should be sufficient. See Linux/fs/binfmt_elf{,_fdpic}.c, fill_note() is only called on "CORE" and "LINUX".

[grimar]

llvm/tools/llvm-readobj/ELFDumper.cpp

5541

Looks fine, thanks.

[rupprecht]

• Split up type/description printing
• Add printing for unknown note types
• Clarify comment about generating section data

[rupprecht]

llvm/test/tools/llvm-readobj/note-core-ntfile.test

15

I don't really have a preference, but this is consistent with all the other tests like this in this package.

llvm/tools/llvm-readobj/ELFDumper.cpp

4430

I think it's safer to check for the ET_CORE since the name seems vendor/kernel specific.

Actually, there's a bigger issue... the conditional logic for printing types vs description data seems to be orthogonal, so I've gone ahead and split it up. I've included my next (unmailed) patch for printing raw description bytes to show a stronger motivation, e.g. FreeBSD has custom note types defined (and so has a method to get those types), but goes through the fallback logic for printing raw bytes for the description. That's difficult/error prone to do with just one loop.

[rupprecht]

• Use DataExtractor instead of custom logic + remove some now unnecessary template use

[alexander-shaposhnikov]

llvm/tools/llvm-readobj/ELFDumper.cpp

4368

maybe const CoreNote &Note ?

[rupprecht]

• Use const for CoreNote param

[grimar]

LGTM. Please wait for other opinion(s) too.

llvm/test/tools/llvm-readobj/note-core-ntfile-bad.test

31

Please align:

Class:   ELFCLASS64
Data:    ELFDATA2LSB
Type:    ET_CORE
Machine: EM_X86_64

35

and here (and below).

llvm/test/tools/llvm-readobj/note-core-ntfile-bad.test

+## Test that malformed NT_FILE sections in core files are gracefully ignored.
+
+## llvm-mc doesn't support generating ET_CORE files; the following test cases
+## were generated with the following steps:
+# $ llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu tmp.s -o tmp.o
+# $ llvm-readobj --section-data --sections tmp.o
+# using the assembly shown with each test case.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1.o
+# RUN: llvm-readelf -n %t1.o 2>&1 | FileCheck %s --check-prefix=ERR-HEADER-SHORT
+# ERR-HEADER-SHORT: warning: malformed note: header too short
+
+# .section ".note.foo", "a"
+#       .align 4
+#       .long 5 /* namesz */
+#       .long end - begin /* descsz */
+#       .long 0x46494c45 /* type = NT_FILE */
+#       .asciz "CORE"
+#       .align 4
+# begin:
+#       .quad 0 /* no file mappings */
+# end:
+
+--- !ELF
+FileHeader:
+  Class:         ELFCLASS64
+  Data:          ELFDATA2LSB
+  Type:          ET_CORE
+  Machine:       EM_X86_64
+Sections:
+  - Name:        .note.foo
+    Type:        SHT_NOTE
+    Content: 0500000008000000454C4946434F5245000000000000000000000000
+ProgramHeaders:
+  - Type:        PT_NOTE
+    Sections:
+      - Section: .note.foo
+
+# RUN: yaml2obj --docnum=2 %s -o %t2.o
+# RUN: llvm-readelf -n %t2.o 2>&1 | FileCheck %s --check-prefix=ERR-NULL-TERM
+# ERR-NULL-TERM: warning: malformed note: not NUL terminated
+
+# .section ".note.foo", "a"
+#       .align 4
+#       .long 5 /* namesz */
+#       .long end - begin /* descsz */
+#       .long 0x46494c45 /* type = NT_FILE */
+#       .asciz "CORE"
+#       .align 4
+# begin:
+#       .quad 1 /* 1 file mapping */
+#       .quad 4096 /* page size */
+#       .quad 0x1000 /* start #1 */
+#       .quad 0x2000 /* end #1 */
+#       .quad 0x3000 /* offset #1 */
+#       .ascii "xxxx"
+# end:
+
+--- !ELF
+FileHeader:
+  Class:         ELFCLASS64
+  Data:          ELFDATA2LSB
+  Type:          ET_CORE
+  Machine:       EM_X86_64
+Sections:
+  - Name:        .note.foo
+    Type:        SHT_NOTE
+    Content: 050000002C000000454C4946434F5245000000000100000000000000001000000000000000100000000000000020000000000000003000000000000078787878
+ProgramHeaders:
+  - Type:        PT_NOTE
+    Sections:
+      - Section: .note.foo
+
+# RUN: yaml2obj --docnum=3 %s -o %t3.o
+# RUN: llvm-readelf -n %t3.o 2>&1 | FileCheck %s --check-prefix=ERR-FILE-COUNT
+# ERR-FILE-COUNT: warning: malformed note: too short for number of files
+
+# .section ".note.foo", "a"
+#       .align 4
+#       .long 5 /* namesz */
+#       .long end - begin /* descsz */
+#       .long 0x46494c45 /* type = NT_FILE */
+#       .asciz "CORE"
+#       .align 4
+# begin:
+#       .quad 2 /* 2 file mappings */
+#       .quad 4096 /* page size */
+#       .quad 0x1000 /* start #1 */
+#       .quad 0x2000 /* end #1 */
+#       .quad 0x3000 /* offset #1 */
+#       .asciz "xyz"
+# end:
+
+--- !ELF
+FileHeader:
+  Class:         ELFCLASS64
+  Data:          ELFDATA2LSB
+  Type:          ET_CORE
+  Machine:       EM_X86_64
+Sections:
+  - Name:        .note.foo
+    Type:        SHT_NOTE
+    Content: 050000002C000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000078797A00
+ProgramHeaders:
+  - Type:        PT_NOTE
+    Sections:
+      - Section: .note.foo
+
+# RUN: yaml2obj --docnum=4 %s -o %t4.o
+# RUN: llvm-readelf -n %t4.o 2>&1 | FileCheck %s --check-prefix=ERR-FILE-END-EARLY
+# ERR-FILE-END-EARLY: warning: malformed note: too few filenames
+
+# .section ".note.foo", "a"
+#       .align 4
+#       .long 5 /* namesz */
+#       .long end - begin /* descsz */
+#       .long 0x46494c45 /* type = NT_FILE */
+#       .asciz "CORE"
+#       .align 4
+# begin:
+#       .quad 2 /* 2 file mappings */
+#       .quad 4096 /* page size */
+#       .quad 0x1000 /* start #1 */
+#       .quad 0x2000 /* end #1 */
+#       .quad 0x3000 /* offset #1 */
+#       .quad 0x4000 /* start #2 */
+#       .quad 0x5000 /* end #2 */
+#       .quad 0x6000 /* offset #2 */
+#       .asciz "xyz"
+# end:
+
+--- !ELF
+FileHeader:
+  Class:         ELFCLASS64
+  Data:          ELFDATA2LSB
+  Type:          ET_CORE
+  Machine:       EM_X86_64
+Sections:
+  - Name:        .note.foo
+    Type:        SHT_NOTE
+    Content: 0500000044000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000078797A00
+ProgramHeaders:
+  - Type:        PT_NOTE
+    Sections:
+      - Section: .note.foo

llvm/test/tools/llvm-readobj/note-core-ntfile.test

+## Test that NT_FILE sections in core files are interpreted correctly.
+
+# RUN: yaml2obj %s > %t.o
+# RUN: llvm-readelf --notes %t.o | FileCheck %s --check-prefix=GNU
+# RUN: llvm-readobj --notes %t.o | FileCheck %s --check-prefix=LLVM
+
+## llvm-mc doesn't support generating ET_CORE files; the following section data
+## was generated with the following steps:
+# $ llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu tmp.s -o tmp.o
+# $ llvm-readobj --section-data --sections tmp.o
+## Using the following input:
+# .section ".note.foo", "a"
+#       .align 4
+#       .long 5 /* namesz */
+#       .long end - begin /* descsz */
+#       .long 0x46494c45 /* type = NT_FILE */
+#       .asciz "CORE"
+#       .align 4
+# begin:
+#       .quad 3 /* 3 file mappings */
+#       .quad 4096 /* page size */
+#       .quad 0x1000 /* start #1 */
+#       .quad 0x2000 /* end #1 */
+#       .quad 0x3000 /* offset #1 */
+#       .quad 0x4000 /* start #2 */
+#       .quad 0x5000 /* end #2 */
+#       .quad 0x6000 /* offset #2 */
+#       .quad 0x7000 /* start #3 */
+#       .quad 0x8000 /* end #3 */
+#       .quad 0x9000 /* offset #3 */
+#       .asciz "/path/to/a.out"
+#       .asciz "/path/to/libc.so"
+#       .asciz "[stack]"
+#       .align 4
+# end:
+
+--- !ELF
+FileHeader:
+  Class:         ELFCLASS64
+  Data:          ELFDATA2LSB
+  Type:          ET_CORE
+  Machine:       EM_X86_64
+Sections:
+  - Name:        .note.foo
+    Type:        SHT_NOTE
+    Content: 0500000080000000454C4946434F524500000000030000000000000000100000000000000010000000000000002000000000000000300000000000000040000000000000005000000000000000600000000000000070000000000000008000000000000000900000000000002F706174682F746F2F612E6F7574002F706174682F746F2F6C6962632E736F005B737461636B5D00
+ProgramHeaders:
+  - Type:        PT_NOTE
+    Sections:
+      - Section: .note.foo
+
+# GNU:      Displaying notes found
+# GNU-NEXT:   Owner                 Data size       Description
+# GNU-NEXT:   CORE                  0x00000080      NT_FILE (mapped files)
+# GNU-NEXT:     Page size: 4096
+# GNU-NEXT:                  Start                 End         Page Offset
+# GNU-NEXT:     0x0000000000001000  0x0000000000002000  0x0000000000003000
+# GNU-NEXT:         /path/to/a.out
+# GNU-NEXT:     0x0000000000004000  0x0000000000005000  0x0000000000006000
+# GNU-NEXT:         /path/to/libc.so
+# GNU-NEXT:     0x0000000000007000  0x0000000000008000  0x0000000000009000
+# GNU-NEXT:         [stack]
+# GNU-NOT:  {{.}}
+
+# LLVM:      Notes [
+# LLVM-NEXT:   NoteSection {
+# LLVM-NEXT:     Offset:
+# LLVM-NEXT:     Size:
+# LLVM-NEXT:     Note {
+# LLVM-NEXT:       Owner: CORE
+# LLVM-NEXT:       Data size: 0x80
+# LLVM-NEXT:       Type: NT_FILE (mapped files)
+# LLVM-NEXT:       Page Size: 4096
+# LLVM-NEXT:       Mapping [
+# LLVM-NEXT:         Start: 0x1000
+# LLVM-NEXT:         End: 0x2000
+# LLVM-NEXT:         Offset: 0x3000
+# LLVM-NEXT:         Filename: /path/to/a.out
+# LLVM-NEXT:       ]
+# LLVM-NEXT:       Mapping [
+# LLVM-NEXT:         Start: 0x4000
+# LLVM-NEXT:         End: 0x5000
+# LLVM-NEXT:         Offset: 0x6000
+# LLVM-NEXT:         Filename: /path/to/libc.so
+# LLVM-NEXT:       ]
+# LLVM-NEXT:       Mapping [
+# LLVM-NEXT:         Start: 0x7000
+# LLVM-NEXT:         End: 0x8000
+# LLVM-NEXT:         Offset: 0x9000
+# LLVM-NEXT:         Filename: [stack]
+# LLVM-NEXT:       ]
+# LLVM-NEXT:     }
+# LLVM-NEXT:   }
+# LLVM-NEXT: ]

llvm/tools/llvm-readobj/ELFDumper.cpp

case ELF::NT_AMDGPU_METADATA: {
     raw_string_ostream StrOS(HSAMetadataString);
     MsgPackDoc.toYAML(StrOS);
 
     return {"AMDGPU Metadata", StrOS.str()};
   }
   }
 }
 
+template <typename ELFT> struct CoreFileMapping {
+  using Elf_Addr = typename ELFT::Addr;
+  Elf_Addr Start, End, Offset;
+  StringRef Filename;
+};
+
+template <typename ELFT> struct CoreNote {
+  using Elf_Addr = typename ELFT::Addr;
+  Elf_Addr PageSize;
+  std::vector<CoreFileMapping<ELFT>> Mappings;
+};
+
+template <typename ELFT>
+static Expected<CoreNote<ELFT>> readCoreNote(ArrayRef<uint8_t> Desc) {
+  using Elf_Addr = typename ELFT::Addr;
+  // Expected format of the NT_FILE note description:
+  // 1. # of file mappings (call it N)
+  // 2. Page size
+  // 3. N (start, end, offset) triples
+  // 4. N packed filenames (null delimited)
+  // Each field is an Elf_Addr, except for filenames which are char* strings.
+
+  CoreNote<ELFT> Ret;
+  const int Bytes = ELFT::Is64Bits ? 8 : 4;
+
+  if (Desc.size() < 2 * Bytes)
+    return createStringError(object_error::parse_failed,
+                             "malformed note: header too short");
+
+  if (Desc.back() != 0)
+    return createStringError(object_error::parse_failed,
+                             "malformed note: not NUL terminated");
+
+  auto ReadField = [&Desc]() -> Elf_Addr {
+    auto Field = reinterpret_cast<const Elf_Addr *>(Desc.data());
+    Desc = Desc.drop_front(Bytes);
+    return *Field;
+  };
+  Elf_Addr FileCount = ReadField();
+  Ret.PageSize = ReadField();
+
+  if (Desc.size() < 3 * FileCount * Bytes)
+    return createStringError(object_error::parse_failed,
+                             "malformed note: too short for number of files");
+
+  ArrayRef<uint8_t> Filenames =
+      makeArrayRef(Desc.data() + 3 * FileCount * Bytes, Desc.end());
+  auto ReadFilename = [&Filenames]() -> StringRef {
+    StringRef Filename(reinterpret_cast<const char *>(Filenames.data()));
+    // Advance by size() + 1 due to NUL delimiter.
+    Filenames = Filenames.drop_front(Filename.size() + 1);
+    return Filename;
+  };
+
+  Ret.Mappings.resize(FileCount);
+  for (CoreFileMapping<ELFT> &Mapping : Ret.Mappings) {
+    if (Filenames.empty())
+      return createStringError(object_error::parse_failed,
+                               "malformed note: too few filenames");
+
+    Mapping.Start = ReadField();
+    Mapping.End = ReadField();
+    Mapping.Offset = ReadField();
+    Mapping.Filename = ReadFilename();
+  }
+
+  return Ret;
+}
+
+template <typename ELFT>
+static void printCoreNote(raw_ostream &OS, CoreNote<ELFT> &Note) {
+  // Length of "0x<address>" string.
+  const int FieldWidth = ELFT::Is64Bits ? 18 : 10;
+
+  OS << "    Page size: " << format_decimal(Note.PageSize, 0) << '\n';
+  OS << "    " << right_justify("Start", FieldWidth) << "  "
+     << right_justify("End", FieldWidth) << "  "
+     << right_justify("Page Offset", FieldWidth) << '\n';
+  for (const CoreFileMapping<ELFT> &Mapping : Note.Mappings) {
+    OS << "    " << format_hex(Mapping.Start, FieldWidth) << "  "
+       << format_hex(Mapping.End, FieldWidth) << "  "
+       << format_hex(Mapping.Offset, FieldWidth) << "\n        "
+       << Mapping.Filename << '\n';
+  }
+}
+
 template <class ELFT>
 void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
   auto PrintHeader = [&](const typename ELFT::Off Offset,
                          const typename ELFT::Addr Size) {
     OS << "Displaying notes found at file offset " << format_hex(Offset, 10)
        << " with length " << format_hex(Size, 10) << ":\n"
        << "  Owner                Data size \tDescription\n";
   };
if (Name == "GNU") {
       const AMDNote N = getAMDNote<ELFT>(Type, Descriptor);
       if (!N.Type.empty())
         OS << "    " << N.Type << ":\n        " << N.Value << '\n';
     } else if (Name == "AMDGPU") {
       OS << getAMDGPUNoteTypeName(Type) << '\n';
       const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
       if (!N.Type.empty())
         OS << "    " << N.Type << ":\n        " << N.Value << '\n';
+    } else if (Name == "CORE") {
+      OS << getCoreNoteTypeName(Type) << '\n';
+      if (Type == ELF::NT_FILE) {
+        Expected<CoreNote<ELFT>> Note = readCoreNote<ELFT>(Descriptor);
+        if (Note)
+          printCoreNote<ELFT>(OS, *Note);
+        else
+          warn(Note.takeError());
+      }
     } else {
-      StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE
-                               ? getCoreNoteTypeName(Type)
-                               : getGenericNoteTypeName(Type);
+      StringRef NoteType = getGenericNoteTypeName(Type);
       if (!NoteType.empty())
-        OS << NoteType;
+        OS << NoteType << '\n';
       else
-        OS << "Unknown note type: (" << format_hex(Type, 10) << ')';
+        OS << "Unknown note type: (" << format_hex(Type, 10) << ")\n";
     }
-    OS << '\n';
   };
 
   if (Obj->getHeader()->e_type == ELF::ET_CORE) {
     for (const auto &P : unwrapOrError(Obj->program_headers())) {
       if (P.p_type != PT_NOTE)
         continue;
       PrintHeader(P.p_offset, P.p_filesz);
       Error Err = Error::success();
static void printGNUNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc,
   case ELF::NT_GNU_PROPERTY_TYPE_0:
     ListScope D(W, "Property");
     for (const auto &Property : getGNUPropertyList<ELFT>(Desc))
       W.printString(Property);
     break;
   }
 }
 
+template <typename ELFT>
+static void printCoreNoteLLVMStyle(CoreNote<ELFT> &Note, ScopedPrinter &W) {
+  W.printNumber("Page Size", Note.PageSize);
+  for (const CoreFileMapping<ELFT> &Mapping : Note.Mappings) {
+    ListScope D(W, "Mapping");
+    W.printHex("Start", Mapping.Start);
+    W.printHex("End", Mapping.End);
+    W.printHex("Offset", Mapping.Offset);
+    W.printString("Filename", Mapping.Filename);
+  }
+}
+
 template <class ELFT>
 void LLVMStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
   ListScope L(W, "Notes");
 
   auto PrintHeader = [&](const typename ELFT::Off Offset,
                          const typename ELFT::Addr Size) {
     W.printHex("Offset", Offset);
     W.printHex("Size", Size);
if (Name == "GNU") {
       const AMDNote N = getAMDNote<ELFT>(Type, Descriptor);
       if (!N.Type.empty())
         W.printString(N.Type, N.Value);
     } else if (Name == "AMDGPU") {
       W.printString("Type", getAMDGPUNoteTypeName(Type));
       const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
       if (!N.Type.empty())
         W.printString(N.Type, N.Value);
+    } else if (Name == "CORE") {
+      W.printString("Type", getCoreNoteTypeName(Type));
+      if (Type == ELF::NT_FILE) {
+        Expected<CoreNote<ELFT>> Note = readCoreNote<ELFT>(Descriptor);
+        if (Note)
+          printCoreNoteLLVMStyle<ELFT>(*Note, W);
+        else
+          warn(Note.takeError());
+      }
     } else {
-      StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE
-                               ? getCoreNoteTypeName(Type)
-                               : getGenericNoteTypeName(Type);
+      StringRef NoteType = getGenericNoteTypeName(Type);
       if (!NoteType.empty())
         W.printString("Type", NoteType);
       else
         W.printString("Type",
                       "Unknown (" + to_string(format_hex(Type, 10)) + ")");
     }
   };