[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

4414

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

4415

(I think it is NUL, not null.)

4421

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

4475

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

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

5657

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

4391

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

5628

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

4391

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)

4415

Wow, TIL about the difference between NUL and null

4475

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.

5628

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

4475

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

4475

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

5628

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

4475

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

4420

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-amd.s

 // REQUIRES: x86-registered-target
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o %t.o
 
 // RUN: llvm-readobj --notes %t.o | FileCheck %s --check-prefix=LLVM
 // RUN: llvm-readelf --notes %t.o | FileCheck %s --check-prefix=GNU
 
 // GNU:      Displaying notes found
 // GNU-NEXT:   Owner                Data size        Description
 // GNU-NEXT:   AMD                  0x00000000       NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)
 // GNU-NEXT:     HSA Metadata:
 // GNU-NEXT: {{^ +$}}
-// GNU-EMPTY:
 // GNU-NEXT:   AMD                  0x00000000       NT_AMD_AMDGPU_ISA (ISA Version)
 // GNU-NEXT:     ISA Version:
 // GNU-NEXT: {{^ +$}}
-// GNU-EMPTY:
 // GNU-NEXT: Displaying notes found
 // GNU-NEXT:   Owner                Data size        Description
 // GNU-NEXT:   AMD                  0x0000000a       NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)
 // GNU-NEXT:     HSA Metadata:
 // GNU-NEXT:     meta_blah
-// GNU-EMPTY:
 // GNU-NEXT:   AMD                  0x00000009       NT_AMD_AMDGPU_ISA (ISA Version)
 // GNU-NEXT:     ISA Version:
 // GNU-NEXT:     isa_blah
-// GNU-EMPTY:
 // GNU-NEXT: Displaying notes found
 // GNU-NEXT:   Owner                Data size        Description
 // GNU-NEXT:   AMD                  0x00000000       NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)
 
 // LLVM:      Notes [
 // LLVM-NEXT:   NoteSection {
 // LLVM-NEXT:     Offset:
 // LLVM-NEXT:     Size:

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 'Content' field in
+## each of 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
+# $ bin/llvm-objcopy --dump-section=.note.foo=tmp.txt tmp.o /dev/null
+# $ xxd -p tmp.txt | tr -d '\n'; echo
+# 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 'Content' field was
+## generated with the following steps:
+# $ llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu tmp.s -o tmp.o
+# $ bin/llvm-objcopy --dump-section=.note.foo=tmp.txt tmp.o /dev/null
+# $ xxd -p tmp.txt | tr -d '\n'; echo
+## 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/test/tools/llvm-readobj/note-freebsd.s

 // REQUIRES: x86-registered-target
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o %t.o
 
 // RUN: llvm-readobj --notes %t.o | FileCheck %s --check-prefix=LLVM
 // RUN: llvm-readelf --notes %t.o | FileCheck %s --check-prefix=GNU
 
 // GNU:      Displaying notes found
 // GNU-NEXT:   Owner                Data size        Description
 // GNU-NEXT:   FreeBSD              0x00000000       NT_THRMISC (thrmisc structure)
-// GNU-EMPTY:
 // GNU-NEXT:   FreeBSD              0x00000000       NT_PROCSTAT_PROC (proc data)
-// GNU-EMPTY:
 // GNU-NEXT: Displaying notes found
 // GNU-NEXT:   Owner                Data size        Description
 // GNU-NEXT:   FreeBSD              0x00000000       NT_PROCSTAT_FILES (files data)
+// GNU-NEXT: Displaying notes found
+// GNU-NEXT:   Owner                Data size        Description
+// GNU-NEXT:   FreeBSD              0x0000001c       Unknown note type (0x00000003)
+// GNU-NEXT:    description data: 4c 6f 72 65 6d 20 69 70 73 75 6d 20 64 6f 6c 6f 72 20 73 69 74 20 61 6d 65 74 00 00
 
 // LLVM:      Notes [
 // LLVM-NEXT:   NoteSection {
 // LLVM-NEXT:     Offset:
 // LLVM-NEXT:     Size:
 // LLVM-NEXT:     Note {
 // LLVM-NEXT:       Owner: FreeBSD
 // LLVM-NEXT:       Data size: 0x0

 // LLVM-NEXT:     Offset: 0x68
 // LLVM-NEXT:     Size: 0x14
 // LLVM-NEXT:     Note {
 // LLVM-NEXT:       Owner: FreeBSD
 // LLVM-NEXT:       Data size: 0x0
 // LLVM-NEXT:       Type: NT_PROCSTAT_FILES (files data)
 // LLVM-NEXT:     }
 // LLVM-NEXT:   }
+// LLVM-NEXT:   NoteSection {
+// LLVM-NEXT:     Offset: 0x7C
+// LLVM-NEXT:     Size: 0x30
+// LLVM-NEXT:     Note {
+// LLVM-NEXT:       Owner: FreeBSD
+// LLVM-NEXT:       Data size: 0x1C
+// LLVM-NEXT:       Type: Unknown note type (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: ]
 
 .section ".note.foo", "a"
   .align 4
   .long 8 /* namesz */
   .long 0 /* descsz */
   .long 7 /* type = NT_FREEBSD_THRMISC */
   .asciz "FreeBSD"
   .long 8 /* namesz */
   .long 0 /* descsz */
   .long 8 /* type = NT_FREEBSD_PROC */
   .asciz "FreeBSD"
 .section ".note.bar", "a"
   .align 4
   .long 8 /* namesz */
   .long 0 /* descsz */
   .long 9 /* type = NT_FREEBSD_FILES */
   .asciz "FreeBSD"
+.section ".note.baz", "a"
+       .align 4
+       .long 8 /* namesz */
+       .long end - begin /* descsz */
+       .long 3 /* type */
+       .asciz "FreeBSD"
+begin:
+       .asciz "Lorem ipsum dolor sit amet"
+       .align 4
+end:

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

 // REQUIRES: x86-registered-target
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o %t.o
 
 // RUN: llvm-readobj --notes %t.o | FileCheck %s --check-prefix=LLVM
 // RUN: llvm-readelf --notes %t.o | FileCheck %s --check-prefix=GNU
 
 // GNU:      Displaying notes found at file offset 0x00000040 with length 0x00000010:
 // GNU-NEXT:   Owner                 Data size       Description
 // GNU-NEXT:   XYZ                  0x00000000       Unknown note type: (0x00000003)
+// GNU-NEXT: Displaying notes found at file offset 0x00000050 with length 0x0000002c:
+// GNU-NEXT:   Owner                 Data size       Description
+// GNU-NEXT:   XYZ                  0x0000001c       Unknown note type: (0x00000003)
+// GNU-NEXT:     description data: 4c 6f 72 65 6d 20 69 70 73 75 6d 20 64 6f 6c 6f 72 20 73 69 74 20 61 6d 65 74 00 00
 
 // LLVM:      Notes [
 // LLVM-NEXT:   NoteSection {
 // LLVM-NEXT:     Offset: 0x40
 // LLVM-NEXT:     Size: 0x10
 // LLVM-NEXT:     Note {
 // LLVM-NEXT:       Owner: XYZ
 // LLVM-NEXT:       Data size: 0x0
 // LLVM-NEXT:       Type: Unknown (0x00000003)
 // LLVM-NEXT:     }
 // LLVM-NEXT:   }
+// LLVM-NEXT:   NoteSection {
+// LLVM-NEXT:     Offset: 0x50
+// LLVM-NEXT:     Size: 0x2C
+// LLVM-NEXT:     Note {
+// LLVM-NEXT:       Owner: XYZ
+// 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: ]
 
 .section ".note.foo", "a"
   .align 4
   .long 4 /* namesz */
   .long 0 /* descsz */
   .long 3 /* type */
   .asciz "XYZ"
+.section ".note.bar", "a"
+       .align 4
+       .long 4 /* namesz */
+       .long end - begin /* descsz */
+       .long 3 /* type */
+       .asciz "XYZ"
+begin:
+       .asciz "Lorem ipsum dolor sit amet"
+       .align 4
+end:

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";
   };
 
   auto ProcessNote = [&](const Elf_Note &Note) {
     StringRef Name = Note.getName();
     ArrayRef<uint8_t> Descriptor = Note.getDesc();
     Elf_Word Type = Note.getType();
 
+    // Print the note owner/type.
     OS << "  " << left_justify(Name, 20) << ' '
        << format_hex(Descriptor.size(), 10) << '\t';
-
     if (Name == "GNU") {
       OS << getGNUNoteTypeName(Type) << '\n';
-      printGNUNote<ELFT>(OS, Type, Descriptor);
     } else if (Name == "FreeBSD") {
       OS << getFreeBSDNoteTypeName(Type) << '\n';
     } else if (Name == "AMD") {
       OS << getAMDNoteTypeName(Type) << '\n';
-      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 {
       StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE
                                ? getCoreNoteTypeName(Type)
                                : getGenericNoteTypeName(Type);
       if (!NoteType.empty())
-        OS << NoteType;
+        OS << NoteType << '\n';
+      else
+        OS << "Unknown note type: (" << format_hex(Type, 10) << ")\n";
+    }
+
+    // Print the description, or fallback to printing raw bytes for unknown
+    // owners.
+    if (Name == "GNU") {
+      printGNUNote<ELFT>(OS, Type, Descriptor);
+    } else if (Name == "AMD") {
+      const AMDNote N = getAMDNote<ELFT>(Type, Descriptor);
+      if (!N.Type.empty())
+        OS << "    " << N.Type << ":\n        " << N.Value << '\n';
+    } else if (Name == "AMDGPU") {
+      const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
+      if (!N.Type.empty())
+        OS << "    " << N.Type << ":\n        " << N.Value << '\n';
+    } else if (Name == "CORE") {
+      if (Type == ELF::NT_FILE) {
+        Expected<CoreNote<ELFT>> Note = readCoreNote<ELFT>(Descriptor);
+        if (Note)
+          printCoreNote<ELFT>(OS, *Note);
         else
-        OS << "Unknown note type: (" << format_hex(Type, 10) << ')';
+          warn(Note.takeError());
       }
+    } else if (!Descriptor.empty()) {
+      OS << "   description data:";
+      for (uint8_t B : Descriptor)
+        OS << " " << format("%02x", B);
       OS << '\n';
+    }
   };
 
   if (Obj->getHeader()->e_type == ELF::ET_CORE) {
     for (const auto &P :
          unwrapOrError(this->FileName, Obj->program_headers())) {
       if (P.p_type != PT_NOTE)
         continue;
       PrintHeader(P.p_offset, P.p_filesz);
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);
   };
 
   auto ProcessNote = [&](const Elf_Note &Note) {
     DictScope D2(W, "Note");
     StringRef Name = Note.getName();
     ArrayRef<uint8_t> Descriptor = Note.getDesc();
     Elf_Word Type = Note.getType();
 
+    // Print the note owner/type.
     W.printString("Owner", Name);
     W.printHex("Data size", Descriptor.size());
     if (Name == "GNU") {
       W.printString("Type", getGNUNoteTypeName(Type));
-      printGNUNoteLLVMStyle<ELFT>(Type, Descriptor, W);
     } else if (Name == "FreeBSD") {
       W.printString("Type", getFreeBSDNoteTypeName(Type));
     } else if (Name == "AMD") {
       W.printString("Type", getAMDNoteTypeName(Type));
-      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 {
       StringRef NoteType = Obj->getHeader()->e_type == ELF::ET_CORE
                                ? getCoreNoteTypeName(Type)
                                : getGenericNoteTypeName(Type);
       if (!NoteType.empty())
         W.printString("Type", NoteType);
       else
         W.printString("Type",
                       "Unknown (" + to_string(format_hex(Type, 10)) + ")");
     }
+
+    // Print the description, or fallback to printing raw bytes for unknown
+    // owners.
+    if (Name == "GNU") {
+      printGNUNoteLLVMStyle<ELFT>(Type, Descriptor, W);
+    } else if (Name == "AMD") {
+      const AMDNote N = getAMDNote<ELFT>(Type, Descriptor);
+      if (!N.Type.empty())
+        W.printString(N.Type, N.Value);
+    } else if (Name == "AMDGPU") {
+      const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
+      if (!N.Type.empty())
+        W.printString(N.Type, N.Value);
+    } else if (Name == "CORE") {
+      if (Type == ELF::NT_FILE) {
+        Expected<CoreNote<ELFT>> Note = readCoreNote<ELFT>(Descriptor);
+        if (Note)
+          printCoreNoteLLVMStyle<ELFT>(*Note, W);
+        else
+          warn(Note.takeError());
+      }
+    } else if (!Descriptor.empty()) {
+      W.printBinaryBlock("Description data", Descriptor);
+    }
   };
 
   if (Obj->getHeader()->e_type == ELF::ET_CORE) {
     for (const auto &P :
          unwrapOrError(this->FileName, Obj->program_headers())) {
       if (P.p_type != PT_NOTE)
         continue;
       DictScope D(W, "NoteSection");