[llvm-readelf] Print raw ELF note contents if we can't parse it

[arichardson]

Summary

Currently, if the note name is known, but the value isn't we don't print
the contents.

[MaskRay]

Since this extends llvm-readelf output, can you also send an email to [e-mail] and check what output they want for GNU readelf? For llvm-readobj output, we are not bound to GNU decisions. Though, if the GNU output is not bad, aiming for consistency can usually make our implementation simpler.

[jhenderson]

Is there a test case that shows we don't print the raw data when the decoding is known?

[arichardson]

In D74367#1868875, @jhenderson wrote:

Is there a test case that shows we don't print the raw data when the decoding is known?

Not yet, but I've added a test case that would previously not print the contents for a GNU note of an unknown type.

llvm/tools/llvm-readobj/ELFDumper.cpp

4893

It seems like GNU readelf does not print the contents in this case.

[arichardson]

Add a test showing the change in behaviour for GNU notes with unknown types

[jhenderson]

I assume that you've verified against GNU readelf all the behaviour that you're changing here?

llvm/test/tools/llvm-readobj/ELF/gnu-note-size.test

2

It's unclear to me what this test is testing, so I can't really say whether this change is good. Would you mind adding a comment at the top of the test, either in this patch or a different one, briefly explaining its purpose, please? I imagine you might need to dig into the old commit messages for this file to find out.

llvm/tools/llvm-readobj/ELFDumper.cpp

4893

Nit: missing trailing full stop.

[emaste]

Do you expect to pick this up again?

[arichardson]

Rebase

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/gnu-note-size.test

5–6

## for comments.

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

29

Maybe .note.unknown rather than invalid? Invalid to me suggests a recognised type, but broken data.

llvm/test/tools/llvm-readobj/ELF/note-amdgpu-invalid.s

90

Unless you're planning on fixing this immediately, it would be worth mentioning this test in the bug, or the TODO might get missed.

llvm/test/tools/llvm-readobj/ELF/note-amdgpu.test

106

As above: maybe .note.unknown for clarity?

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

4 ↗

(On Diff #321370)

This looks wrong?

Also, I'm not sure why this test is changing as part of this change?

[arichardson]

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

4 ↗

(On Diff #321370)

Yes, sorry about that - it's a debugging leftover to compare against GNU readelf and the changes should be part of D96010. Will fix.

[arichardson]

Address review feedback

[jhenderson]

Possibly this is a patch ordering thing, but some of the pre-merge bots are failing for this patch, I think. LGTM, apart than that.

[arichardson]

In D74367#2548036, @jhenderson wrote:

Possibly this is a patch ordering thing, but some of the pre-merge bots are failing for this patch, I think. LGTM, apart than that.

Yes, the problem was that I didn't mark D95953 as a parent of this change.

llvm/test/tools/llvm-readobj/ELF/gnu-note-size.test

+## Check that a malformed NT_GNU_ABI_TAG note can be dumped without crashing.
 # RUN: yaml2obj %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 binutils does not print the raw description data when encountering an
+## invalid NT_GNU_ABI_TAG, but in LLVM style we print it.
 
 # GNU:      Displaying notes found in: .note.ABI-tag
 # GNU-NEXT:   Owner                 Data size       Description
 # GNU-NEXT:   GNU                   0x00000004      NT_GNU_ABI_TAG (ABI version tag)
 # GNU-NEXT:     <corrupt GNU_ABI_TAG>
+# GNU-EMPTY:
 
 # LLVM:      Notes [
 # LLVM-NEXT:   NoteSection {
 # LLVM-NEXT:     Name: .note.ABI-tag
 # LLVM-NEXT:     Offset:
 # LLVM-NEXT:     Size: 0x14
 # LLVM-NEXT:     Note {
 # LLVM-NEXT:       Owner: GNU
 # LLVM-NEXT:       Data size: 0x4
 # LLVM-NEXT:       Type: NT_GNU_ABI_TAG (ABI version tag)
 # LLVM-NEXT:       ABI: <corrupt GNU_ABI_TAG>
+# LLVM-NEXT:       Description data (
+# LLVM-NEXT:         0000: 00000000 |....|
+# LLVM-NEXT:       )
 # LLVM-NEXT:     }
 # LLVM-NEXT:   }
 # LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:            .note.ABI-tag
     Type:            SHT_NOTE
     AddressAlign:    0x0000000000000004
     Content:         040000000400000001000000474E550000000000

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

 ## Test tools are able to dump different types of notes.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1.so
 # RUN: llvm-readelf --notes %t1.so | FileCheck %s --check-prefix=GNU --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --notes %t1.so | FileCheck %s --check-prefix=LLVM
 # RUN: llvm-objcopy --strip-sections %t1.so %t1.stripped.so
 # RUN: llvm-readelf --notes %t1.stripped.so | FileCheck %s --check-prefix=GNU-STRIPPED --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --notes %t1.stripped.so | FileCheck %s --check-prefix=LLVM-STRIPPED
 
 #      GNU:Displaying notes found in: .note.ABI-tag
 # GNU-NEXT:  Owner                Data size   Description
 # GNU-NEXT:  GNU                  0x00000010  NT_GNU_ABI_TAG (ABI version tag)
 # GNU-NEXT:    OS: Linux, ABI: 2.6.32
-
-#      GNU:Displaying notes found in: .note.gnu.build-id
+# GNU-EMPTY:
+# GNU-NEXT:Displaying notes found in: .note.gnu.build-id
 # GNU-NEXT:  Owner                Data size   Description
 # GNU-NEXT:  GNU                  0x00000010  NT_GNU_BUILD_ID (unique build ID bitstring)
 # GNU-NEXT:    Build ID: 4fcb712aa6387724a9f465a32cd8c14b
-
-#      GNU:Displaying notes found in: .note.gnu.gold-version
+# GNU-EMPTY:
+# GNU-NEXT:Displaying notes found in: .note.gnu.gold-version
 # GNU-NEXT:  Owner                Data size   Description
 # GNU-NEXT:  GNU                  0x00000009  NT_GNU_GOLD_VERSION (gold version)
 # GNU-NEXT:    Version: gold 1.11
+# GNU-EMPTY:
+# GNU-NEXT:Displaying notes found in: .note.gnu.unknown
+# GNU-NEXT:  Owner                Data size   Description
+# GNU-NEXT:  GNU                  0x00000004  Unknown note type: (0x0000abcd)
+# GNU-NEXT:   description data: 61 62 63 64
+# GNU-EMPTY:
 
 # LLVM:      Notes [
 # LLVM-NEXT:   NoteSection {
 # LLVM-NEXT:     Name: .note.ABI-tag
 # LLVM-NEXT:     Offset: 0x78
 # LLVM-NEXT:     Size: 0x20
 # LLVM-NEXT:     Note {
 # LLVM-NEXT:       Owner: GNU

 # LLVM-NEXT:     Size: 0x1C
 # LLVM-NEXT:     Note {
 # LLVM-NEXT:       Owner: GNU
 # LLVM-NEXT:       Data size: 0x9
 # LLVM-NEXT:       Type: NT_GNU_GOLD_VERSION (gold version)
 # LLVM-NEXT:       Version: gold 1.11
 # LLVM-NEXT:     }
 # LLVM-NEXT:   }
+# LLVM-NEXT:   NoteSection {
+# LLVM-NEXT:     Name: .note.gnu.unknown
+# LLVM-NEXT:     Offset: 0xD4
+# LLVM-NEXT:     Size: 0x14
+# LLVM-NEXT:     Note {
+# LLVM-NEXT:       Owner: GNU
+# LLVM-NEXT:       Data size: 0x4
+# LLVM-NEXT:       Type: Unknown (0x0000abcd)
+# LLVM-NEXT:       Description data (
+# LLVM-NEXT:         0000: 61626364                             |abcd|
+# LLVM-NEXT:       )
+# LLVM-NEXT:     }
+# LLVM-NEXT:   }
 # LLVM-NEXT: ]
 
 ## Note: the section name is <?> here because the section header table is not present.
 # LLVM-STRIPPED:      Notes [
 # LLVM-STRIPPED-NEXT:   NoteSection {
 # LLVM-STRIPPED-NEXT:     Name: <?>
 # LLVM-STRIPPED-NEXT:     Offset: 0x78
 # LLVM-STRIPPED-NEXT:     Size: 0x20
- Name:         .note.gnu.build-id
     Flags:        [ SHF_ALLOC ]
     Address:      0x0000000000400120
     AddressAlign: 0x0000000000000004
     Content:      040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B
   - Name:         .note.gnu.gold-version
     Type:         SHT_NOTE
     AddressAlign: 0x0000000000000004
     Content:      040000000900000004000000474E5500676F6C6420312E3131000000
+  - Name:         .note.gnu.unknown
+    Type:         SHT_NOTE
+    AddressAlign: 0x0000000000000004
+    Content:      0400000004000000cdab0000474E550061626364
 ProgramHeaders:
   - Type:     PT_NOTE
     FileSize: 0x20
     FirstSec: .note.gnu.build-id
     LastSec:  .note.gnu.build-id
 
 ## Test tools report an error if a note section has an invalid offset
 ## that goes past the end of file.
 
 # RUN: yaml2obj --docnum=2 -DSHOFFSET=0xffff0000 %s -o %t2.so
 # RUN: llvm-readelf --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1-GNU
 # RUN: llvm-readobj --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1-LLVM
 
 # ERR1-GNU:      Displaying notes found in: .note
 # ERR1-GNU-NEXT:   Owner                Data size        Description
 # ERR1-GNU-NEXT: warning: '[[FILE]]': unable to read notes from the SHT_NOTE section with index 1: invalid offset (0xffff0000) or size (0x0)
-# ERR1-GNU-NOT: {{.}}
+# ERR1-GNU-EMPTY:
 
 # ERR1-LLVM:      Notes [
 # ERR1-LLVM-NEXT:   NoteSection {
 # ERR1-LLVM-NEXT:     Name:   .note
 # ERR1-LLVM-NEXT:     Offset: 0xFFFF0000
 # ERR1-LLVM-NEXT:     Size:   0x0
 # ERR1-LLVM-NEXT: warning: '[[FILE]]': unable to read notes from the SHT_NOTE section with index 1: invalid offset (0xffff0000) or size (0x0)
 # ERR1-LLVM-NEXT:   }

 
 # RUN: yaml2obj --docnum=2 -DSHSIZE=0xffff0000 %s -o %t3.so
 # RUN: llvm-readelf --notes %t3.so 2>&1 | FileCheck -DFILE=%t3.so %s --check-prefix=ERR2-GNU
 # RUN: llvm-readobj --notes %t3.so 2>&1 | FileCheck -DFILE=%t3.so %s --check-prefix=ERR2-LLVM
 
 # ERR2-GNU:      Displaying notes found in: .note
 # ERR2-GNU-NEXT:   Owner                Data size        Description
 # ERR2-GNU-NEXT: warning: '[[FILE]]': unable to read notes from the SHT_NOTE section with index 1: invalid offset (0x40) or size (0xffff0000)
-# ERR2-GNU-NOT: {{.}}
+# ERR2-GNU-EMPTY:
 
 # ERR2-LLVM:      Notes [
 # ERR2-LLVM-NEXT:   NoteSection {
 # ERR2-LLVM-NEXT:     Name: .note
 # ERR2-LLVM-NEXT:     Offset: 0x40
 # ERR2-LLVM-NEXT:     Size: 0xFFFF0000
 # ERR2-LLVM-NEXT: warning: '[[FILE]]': unable to read notes from the SHT_NOTE section with index 1: invalid offset (0x40) or size (0xffff0000)
 # ERR2-LLVM-NEXT:   }

 
 # RUN: yaml2obj --docnum=3 -DPHFILESIZE=0xffff0000 %s -o %t5.so
 # RUN: llvm-readelf --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefix=ERR4-GNU
 # RUN: llvm-readobj --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefix=ERR4-LLVM
 
 # ERR4-GNU:      Displaying notes found at file offset 0x00000000 with length 0xffff0000:
 # ERR4-GNU-NEXT:   Owner                Data size        Description
 # ERR4-GNU-NEXT: warning: '[[FILE]]': unable to read notes from the PT_NOTE segment with index 0: invalid offset (0x0) or size (0xffff0000)
-# ERR4-GNU-NOT: {{.}}
+# ERR4-GNU-EMPTY:
 
 # ERR4-LLVM:      Notes [
 # ERR4-LLVM-NEXT:   NoteSection {
 # ERR4-LLVM-NEXT:     Name: <?>
 # ERR4-LLVM-NEXT:     Offset: 0x0
 # ERR4-LLVM-NEXT:     Size: 0xFFFF0000
 # ERR4-LLVM-NEXT: warning: '[[FILE]]': unable to read notes from the PT_NOTE segment with index 0: invalid offset (0x0) or size (0xffff0000)
 # ERR4-LLVM-NEXT:   }

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

 // 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 in: .note.other
 // GNU-NEXT:   Owner                Data size        Description
 // GNU-NEXT:   AMD                  0x00000000       NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)
 // GNU-EMPTY:
+// GNU-NEXT: Displaying notes found in: .note.unknown
+// GNU-NEXT:   Owner                Data size   Description
+// GNU-NEXT:   AMD                  0x00000007  Unknown note type: (0x000004d2)
+// GNU-NEXT:    description data: 61 62 63 64 65 66 00
+// GNU-EMPTY:
 
 // LLVM:      Notes [
 // LLVM-NEXT:   NoteSection {
 // LLVM-NEXT:     Name: .note.no.desc
 // LLVM-NEXT:     Offset:
 // LLVM-NEXT:     Size:
 // LLVM-NEXT:     Note {
 // LLVM-NEXT:       Owner: AMD

 // LLVM-NEXT:     Offset:
 // LLVM-NEXT:     Size:
 // LLVM-NEXT:     Note {
 // LLVM-NEXT:       Owner: AMD
 // LLVM-NEXT:       Data size: 0x0
 // LLVM-NEXT:       Type: NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)
 // LLVM-NEXT:     }
 // LLVM-NEXT:   }
+// LLVM-NEXT:   NoteSection {
+// LLVM-NEXT:     Name: .note.unknown
+// LLVM-NEXT:     Offset:
+// LLVM-NEXT:     Size:
+// LLVM-NEXT:     Note {
+// LLVM-NEXT:       Owner: AMD
+// LLVM-NEXT:       Data size: 0x7
+// LLVM-NEXT:       Type: Unknown (0x000004d2)
+// LLVM-NEXT:       Description data (
+// LLVM-NEXT:         0000: 61626364 656600                      |abcdef.|
+// LLVM-NEXT:       )
+// LLVM-NEXT:     }
+// LLVM-NEXT:   }
 // LLVM-NEXT: ]
 
 .section ".note.no.desc", "a"
   .align 4
   .long 4 /* namesz */
   .long 0 /* descsz */
   .long 10 /* type = NT_AMD_AMDGPU_HSA_METADATA */
   .asciz "AMD"

 end.isa:
   .align 4
 .section ".note.other", "a"
   .align 4
   .long 4 /* namesz */
   .long 0 /* descsz */
   .long 12 /* type = NT_AMD_AMDGPU_PAL_METADATA */
   .asciz "AMD"
+.section ".note.unknown", "a"
+  .align 4
+  .long 4 /* namesz */
+  .long end.unknown_data - begin.unknown_data /* descsz */
+  .long 1234 /* type = unknown */
+  .asciz "AMD"
+begin.unknown_data:
+  .asciz "abcdef"
+end.unknown_data:
+  .align 4

llvm/test/tools/llvm-readobj/ELF/note-amdgpu-invalid.s

 # GNU-NEXT:     .name:           foo
 # GNU-NEXT:     .private_segment_fixed_size: 3
 # GNU-NEXT:     .sgpr_count:     6
 # GNU-NEXT:     .symbol:         foo
 # GNU-NEXT:     .vgpr_count:     7
 # GNU-NEXT:     .wavefront_size: 5
 # GNU-NEXT: ...
 # GNU-EMPTY:
+# GNU-EMPTY:
+# GNU-NEXT: Displaying notes found in: .note.bar
+# GNU-NEXT:   Owner                Data size  Description
+# GNU-NEXT:   AMDGPU               0x00000003 NT_AMDGPU_METADATA (AMDGPU Metadata)
+# GNU-NEXT:    description data: 12 34 56
+# GNU-EMPTY:
 
 # LLVM:      Notes [
 # LLVM-NEXT:   NoteSection {
 # LLVM-NEXT:     Name: .note.foo
 # LLVM-NEXT:     Offset: 0x40
 # LLVM-NEXT:     Size: 0xE8
 # LLVM-NEXT:     Note {
 # LLVM-NEXT:       Owner: AMDGPU

 # LLVM-NEXT:     .sgpr_count:     6
 # LLVM-NEXT:     .symbol:         foo
 # LLVM-NEXT:     .vgpr_count:     7
 # LLVM-NEXT:     .wavefront_size: 5
 # LLVM-NEXT: ...
 # LLVM-EMPTY:
 # LLVM-NEXT:     }
 # LLVM-NEXT:   }
-# LLVM-NEXT: ]
+# LLVM-NEXT:  NoteSection {
+# LLVM-NEXT:    Name: .note.bar
+# LLVM-NEXT:    Offset: 0x128
+# LLVM-NEXT:    Size: 0x18
+# LLVM-NEXT:    Note {
+# LLVM-NEXT:      Owner: AMDGPU
+# LLVM-NEXT:      Data size: 0x3
+# LLVM-NEXT:      Type: NT_AMDGPU_METADATA (AMDGPU Metadata)
+# LLVM-NEXT:      Description data (
+# LLVM-NEXT:        0000: 123456                               |.4V|
+# LLVM-NEXT:      )
+# LLVM-NEXT:    }
+# LLVM-NEXT:  }
+# LLVM-NEXT:]
 
 ## Use yaml2obj instead of llvm-mc for more test portability. This was
 ## generated by grabbing section data from note-amdgpu.s and removing the amdhsa.version field.
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:        .note.foo
     Type:        SHT_NOTE
     Content:     07000000D400000020000000414D44475055000081ae616d646873612e6b65726e656c73918ab92e67726f75705f7365676d656e745f66697865645f73697a6502b62e6b65726e6172675f7365676d656e745f616c69676e04b52e6b65726e6172675f7365676d656e745f73697a6501b82e6d61785f666c61745f776f726b67726f75705f73697a6508a52e6e616d65a3666f6fbb2e707269766174655f7365676d656e745f66697865645f73697a6503ab2e736770725f636f756e7406a72e73796d626f6ca3666f6fab2e766770725f636f756e7407af2e7761766566726f6e745f73697a6505
+  - Name:        .note.bar
+    Type:        SHT_NOTE
+    Notes:
+      - Name: AMDGPU
+        Type: NT_AMDGPU_METADATA
+        Desc: '123456'
+      # TODO: https://bugs.llvm.org/show_bug.cgi?id=49034
+      # - Name: AMDGPU
+      #   Type: NT_AMDGPU_METADATA
+      #    Desc: 'abcdef'

llvm/test/tools/llvm-readobj/ELF/note-amdgpu.test

 # GNU-NEXT:     .sgpr_count:     6
 # GNU-NEXT:     .symbol:         foo
 # GNU-NEXT:     .vgpr_count:     7
 # GNU-NEXT:     .wavefront_size: 5
 # GNU-NEXT: amdhsa.version:
 # GNU-NEXT:   - 1
 # GNU-NEXT:   - 0
 # GNU-NEXT: ...
+# GNU-EMPTY:
+# GNU-EMPTY:
+# GNU-NEXT: Displaying notes found in: .note.unknown
+# GNU-NEXT:   Owner                Data size  Description
+# GNU-NEXT:   AMDGPU               0x00000002 Unknown note type: (0x00000101)
+# GNU-NEXT:    description data: ab cd
+# GNU-EMPTY:
 
 # LLVM:      Notes [
 # LLVM-NEXT:   NoteSection {
 # LLVM-NEXT:     Name: .note.foo
 # LLVM-NEXT:     Offset:
 # LLVM-NEXT:     Size:
 # LLVM-NEXT:     Note {
 # LLVM-NEXT:       Owner: AMDGPU

 # LLVM-NEXT:     .wavefront_size: 5
 # LLVM-NEXT: amdhsa.version:
 # LLVM-NEXT:   - 1
 # LLVM-NEXT:   - 0
 # LLVM-NEXT: ...
 # LLVM-EMPTY:
 # LLVM-NEXT:     }
 # LLVM-NEXT:   }
+# LLVM-NEXT:   NoteSection {
+# LLVM-NEXT:     Name: .note.unknown
+# LLVM-NEXT:     Offset: 0x13C
+# LLVM-NEXT:     Size: 0x18
+# LLVM-NEXT:     Note {
+# LLVM-NEXT:       Owner: AMDGPU
+# LLVM-NEXT:       Data size: 0x2
+# LLVM-NEXT:       Type: Unknown (0x00000101)
+# LLVM-NEXT:       Description data (
+# LLVM-NEXT:         0000: ABCD                                 |..|
+# LLVM-NEXT:       )
+# LLVM-NEXT:     }
+# LLVM-NEXT:   }
 # LLVM-NEXT: ]
 
 ## Use yaml2obj instead of llvm-mc for more test portability. This was
 ## generated by grabbing section data from an object built via:
 # $ llvm-mc -filetype=obj -triple amdgcn-amd-amdhsa %s -o %t.o
 ## On input:
 # .amdgpu_metadata
 #   amdhsa.version:

 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:        .note.foo
     Type:        SHT_NOTE
     Content:     07000000E600000020000000414D44475055000082AE616D646873612E6B65726E656C73918AB92E67726F75705F7365676D656E745F66697865645F73697A6502B62E6B65726E6172675F7365676D656E745F616C69676E04B52E6B65726E6172675F7365676D656E745F73697A6501B82E6D61785F666C61745F776F726B67726F75705F73697A6508A52E6E616D65A3666F6FBB2E707269766174655F7365676D656E745F66697865645F73697A6503AB2E736770725F636F756E7406A72E73796D626F6CA3666F6FAB2E766770725F636F756E7407AF2E7761766566726F6E745F73697A6505AE616D646873612E76657273696F6E9201000000
+  - Name:        .note.unknown
+    Type:        SHT_NOTE
+    Notes:
+      - Name: AMDGPU
+        Type: NT_GNU_BUILD_ATTRIBUTE_FUNC
+        Desc: 'abcd'

llvm/tools/llvm-readobj/ELFDumper.cpp

static std::string getGNUBuildId(ArrayRef<uint8_t> Desc) {
   return OS.str();
 }
 
 static StringRef getGNUGoldVersion(ArrayRef<uint8_t> Desc) {
   return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
 }
 
 template <typename ELFT>
-static void printGNUNote(raw_ostream &OS, uint32_t NoteType,
+static bool printGNUNote(raw_ostream &OS, uint32_t NoteType,
                          ArrayRef<uint8_t> Desc) {
+  // Return true if we were able to pretty-print the note, false otherwise.
   switch (NoteType) {
   default:
-    return;
+    return false;
   case ELF::NT_GNU_ABI_TAG: {
     const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc);
     if (!AbiTag.IsValid)
       OS << "    <corrupt GNU_ABI_TAG>";
     else
       OS << "    OS: " << AbiTag.OSName << ", ABI: " << AbiTag.ABI;
     break;
   }
   case ELF::NT_GNU_BUILD_ID: {
     OS << "    Build ID: " << getGNUBuildId(Desc);
     break;
   }
   case ELF::NT_GNU_GOLD_VERSION:
     OS << "    Version: " << getGNUGoldVersion(Desc);
     break;
   case ELF::NT_GNU_PROPERTY_TYPE_0:
     OS << "    Properties:";
     for (const std::string &Property : getGNUPropertyList<ELFT>(Desc))
       OS << "    " << Property << "\n";
     break;
   }
   OS << '\n';
+  return true;
 }
 
 struct AMDNote {
   std::string Type;
   std::string Value;
 };
 
 template <typename ELFT>
static AMDGPUNote getAMDGPUNote(uint32_t NoteType, ArrayRef<uint8_t> Desc) {
   switch (NoteType) {
   default:
     return {"", ""};
   case ELF::NT_AMDGPU_METADATA: {
     StringRef MsgPackString =
         StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
     msgpack::Document MsgPackDoc;
     if (!MsgPackDoc.readFromBlob(MsgPackString, /*Multi=*/false))
-      return {"AMDGPU Metadata", "Invalid AMDGPU Metadata"};
+      return {"", ""};
 
     AMDGPU::HSAMD::V3::MetadataVerifier Verifier(true);
     std::string HSAMetadataString;
     if (!Verifier.verify(MsgPackDoc.getRoot()))
       HSAMetadataString = "Invalid AMDGPU Metadata\n";
 
     raw_string_ostream StrOS(HSAMetadataString);
+    if (MsgPackDoc.getRoot().isScalar()) {
+      // TODO: passing a scalar root to toYAML() asserts:
+      // (PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar &&
+      //    "plain scalar documents are not supported")
+      // To avoid this crash we print the raw data instead.
+      return {"", ""};
+    }
     MsgPackDoc.toYAML(StrOS);
-
     return {"AMDGPU Metadata", StrOS.str()};
   }
   }
 }
 
 struct CoreFileMapping {
   uint64_t Start, End, Offset;
   StringRef Filename;
auto ProcessNote = [&](const Elf_Note &Note) -> Error {
     StringRef NoteType =
         getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type);
     if (!NoteType.empty())
       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.
+    // owners/if we fail to pretty-print the contents.
     if (Name == "GNU") {
-      printGNUNote<ELFT>(OS, Type, Descriptor);
+      if (printGNUNote<ELFT>(OS, Type, Descriptor))
+        return Error::success();
     } else if (Name == "AMD") {
       const AMDNote N = getAMDNote<ELFT>(Type, Descriptor);
-      if (!N.Type.empty())
+      if (!N.Type.empty()) {
         OS << "    " << N.Type << ":\n        " << N.Value << '\n';
+        return Error::success();
+      }
     } else if (Name == "AMDGPU") {
       const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
-      if (!N.Type.empty())
+      if (!N.Type.empty()) {
         OS << "    " << N.Type << ":\n        " << N.Value << '\n';
+        return Error::success();
+      }
     } else if (Name == "CORE") {
       if (Type == ELF::NT_FILE) {
         DataExtractor DescExtractor(Descriptor,
                                     ELFT::TargetEndianness == support::little,
                                     sizeof(Elf_Addr));
-        if (Expected<CoreNote> NoteOrErr = readCoreNote(DescExtractor))
+        if (Expected<CoreNote> NoteOrErr = readCoreNote(DescExtractor)) {
           printCoreNote<ELFT>(OS, *NoteOrErr);
-        else
+          return Error::success();
+        } else {
           return NoteOrErr.takeError();
         }
-    } else if (!Descriptor.empty()) {
+      }
+    }
+    if (!Descriptor.empty()) {
       OS << "   description data:";
       for (uint8_t B : Descriptor)
         OS << " " << format("%02x", B);
       OS << '\n';
     }
     return Error::success();
   };
 
if (!SymsOrErr) {
     return;
   }
 
   for (uint64_t Sym : *SymsOrErr)
     W.printNumber("Sym", this->getStaticSymbolName(Sym), Sym);
 }
 
 template <typename ELFT>
-static void printGNUNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc,
+static bool printGNUNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc,
                                   ScopedPrinter &W) {
+  // Return true if we were able to pretty-print the note, false otherwise.
   switch (NoteType) {
   default:
-    return;
+    return false;
   case ELF::NT_GNU_ABI_TAG: {
     const GNUAbiTag &AbiTag = getGNUAbiTag<ELFT>(Desc);
     if (!AbiTag.IsValid) {
       W.printString("ABI", "<corrupt GNU_ABI_TAG>");
+      return false;
     } else {
       W.printString("OS", AbiTag.OSName);
       W.printString("ABI", AbiTag.ABI);
     }
     break;
   }
   case ELF::NT_GNU_BUILD_ID: {
     W.printString("Build ID", getGNUBuildId(Desc));
     break;
   }
   case ELF::NT_GNU_GOLD_VERSION:
     W.printString("Version", getGNUGoldVersion(Desc));
     break;
   case ELF::NT_GNU_PROPERTY_TYPE_0:
     ListScope D(W, "Property");
     for (const std::string &Property : getGNUPropertyList<ELFT>(Desc))
       W.printString(Property);
     break;
   }
+  return true;
 }
 
 static void printCoreNoteLLVMStyle(const CoreNote &Note, ScopedPrinter &W) {
   W.printNumber("Page Size", Note.PageSize);
   for (const CoreFileMapping &Mapping : Note.Mappings) {
     ListScope D(W, "Mapping");
     W.printHex("Start", Mapping.Start);
     W.printHex("End", Mapping.End);
StringRef NoteType =
         getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_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.
+    // owners/if we fail to pretty-print the contents.
     if (Name == "GNU") {
-      printGNUNoteLLVMStyle<ELFT>(Type, Descriptor, W);
+      if (printGNUNoteLLVMStyle<ELFT>(Type, Descriptor, W))
+        return Error::success();
     } else if (Name == "AMD") {
       const AMDNote N = getAMDNote<ELFT>(Type, Descriptor);
-      if (!N.Type.empty())
+      if (!N.Type.empty()) {
         W.printString(N.Type, N.Value);
+        return Error::success();
+      }
     } else if (Name == "AMDGPU") {
       const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
-      if (!N.Type.empty())
+      if (!N.Type.empty()) {
         W.printString(N.Type, N.Value);
+        return Error::success();
+      }
     } else if (Name == "CORE") {
       if (Type == ELF::NT_FILE) {
         DataExtractor DescExtractor(Descriptor,
                                     ELFT::TargetEndianness == support::little,
                                     sizeof(Elf_Addr));
-        if (Expected<CoreNote> Note = readCoreNote(DescExtractor))
-          printCoreNoteLLVMStyle(*Note, W);
-        else
-          return Note.takeError();
-      }
-    } else if (!Descriptor.empty()) {
+        if (Expected<CoreNote> N = readCoreNote(DescExtractor)) {
+          printCoreNoteLLVMStyle(*N, W);
+          return Error::success();
+        } else {
+          return N.takeError();
+        }
+      }
+    if (!Descriptor.empty()) {
       W.printBinaryBlock("Description data", Descriptor);
     }
     return Error::success();
   };
 
   printNotesHelper(*this, StartNotes, ProcessNote, EndNotes);
 }