[openmp][ELF] Recognize LLVM OpenMP offload specific notes

[vzakhari]

Summary

This patch is a piece of D99360. The new ELF notes are added in clang-offload-wrapper, and llvm-readobj has to visualize them properly.

[jhenderson]

@vzakhari you should add to the summary "Depends on DXXXXXX" to indicate which patch(es) this patch relies on. Same goes with your other reviews. Alternatively, use the Phabricator "Edit Related Revisions" option to do a similar thing. This will tie the patches into a series, and make it clear what order you anticipate landing each change in. Note that it should be possible to land each review individually as its own commit, rather than combining them into a single big blob. this might mean redoing some reviews so that common parts (e.g. BinaryFormat) land first.

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

1 ↗

(On Diff #334010)

Most note tests are named note-xxx.test, I recommend you rename this to note-llvmompoffload.test.

Add a brief top-level comment to this test to indicate what the test is supposed to be testing.

Name the output files distinctly, based on the important difference. This makes test debugging easier, should there be any failures.

Example naming: %t.64be %t.32be %t.64le %t.32le

2 ↗

(On Diff #334010)

You probably want GNU-style testing too? I.e:

# RUN: llvm-readelf --notes %t.o | FileCheck %s --check-prefix=NOTES-GNU

(or something like that)

36–37 ↗

(On Diff #334010)

We usually get rid of extra whitespace, so that there is a minimal amount between the key and value in yaml docs (only enough to make all values line up vertically within a block).

49 ↗

(On Diff #334010)

Rather than duplicate the YAML 4 times, use yaml2obj's -D option to switch on the Class/Data types. Example usage:

# RUN: yaml2obj %s -o %t.64be -DBITS=64 -DENCODING=MSB
# RUN: yaml2obj %s -o %t.32be -DBITS=32 -DENCODING=MSB
...

--- !ELF
FileHeader:
  Class: ELFCLASS[[BITS]]
  Data: ELFDATA2[[ENCODING]]
...

You can see various similar examples in many of the existing llvm-readobj tests.

[vzakhari]

@jhenderson, thank you for the review and useful hints!

[MaskRay]

The change looks good to me.

[jhenderson]

Couple of nits, otherwise looks good to me.

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

2

Nit: In more recent llvm tool tests, we tend to use '##' for comment markers, to distinguish them from lit and FileCheck directives.

5

Here and in each other case, I'd add --match-full-lines to the FileCheck call, as this will prevent other output in the Type etc fields after the checked-for value.

20–21

If you go ahead with my --match-full-lines suggestion, use {{.*}} as a regex to avoid having to check the actual offset and size here.

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

+## Test that llvm-readobj is able to recognize LLVMOMPOFFLOAD ELF notes.
+
+# RUN: yaml2obj %s -o %t.64le -DBITS=64 -DENCODING=LSB
+# RUN: llvm-readobj --notes %t.64le | FileCheck %s --match-full-lines --check-prefix=NOTES
+# RUN: llvm-readelf --notes %t.64le | FileCheck %s --match-full-lines --check-prefix=NOTES-GNU
+# RUN: yaml2obj %s -o %t.64be -DBITS=64 -DENCODING=MSB
+# RUN: llvm-readobj --notes %t.64be | FileCheck %s --match-full-lines --check-prefix=NOTES
+# RUN: llvm-readelf --notes %t.64be | FileCheck %s --match-full-lines --check-prefix=NOTES-GNU
+# RUN: yaml2obj %s -o %t.32le -DBITS=32 -DENCODING=LSB
+# RUN: llvm-readobj --notes %t.32le | FileCheck %s --match-full-lines --check-prefix=NOTES
+# RUN: llvm-readelf --notes %t.32le | FileCheck %s --match-full-lines --check-prefix=NOTES-GNU
+# RUN: yaml2obj %s -o %t.32be -DBITS=32 -DENCODING=MSB
+# RUN: llvm-readobj --notes %t.32be | FileCheck %s --match-full-lines --check-prefix=NOTES
+# RUN: llvm-readelf --notes %t.32be | FileCheck %s --match-full-lines --check-prefix=NOTES-GNU
+
+# NOTES:      Notes [
+# NOTES-NEXT:   NoteSection {
+# NOTES-NEXT:     Name: .note.openmp
+# NOTES-NEXT:     Offset: {{.*}}
+# NOTES-NEXT:     Size: {{.*}}
+# NOTES-NEXT:     Note {
+# NOTES-NEXT:       Owner: LLVMOMPOFFLOAD
+# NOTES-NEXT:       Data size: 0x3
+# NOTES-NEXT:       Type: NT_LLVM_OPENMP_OFFLOAD_VERSION (image format version)
+# NOTES-NEXT:       Version: 1.0
+# NOTES-NEXT:     }
+# NOTES-NEXT:     Note {
+# NOTES-NEXT:       Owner: LLVMOMPOFFLOAD
+# NOTES-NEXT:       Data size: 0x4
+# NOTES-NEXT:       Type: NT_LLVM_OPENMP_OFFLOAD_PRODUCER (producing toolchain)
+# NOTES-NEXT:       Producer: LLVM
+# NOTES-NEXT:     }
+# NOTES-NEXT:     Note {
+# NOTES-NEXT:       Owner: LLVMOMPOFFLOAD
+# NOTES-NEXT:       Data size: 0x9
+# NOTES-NEXT:       Type: NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION (producing toolchain version)
+# NOTES-NEXT:       Producer version: 13.0.0git
+# NOTES-NEXT:     }
+# NOTES-NEXT:   }
+# NOTES-NEXT: ]
+
+# NOTES-GNU:      Displaying notes found in: .note.openmp
+# NOTES-GNU-NEXT:   Owner                Data size        Description
+# NOTES-GNU-NEXT:   LLVMOMPOFFLOAD       0x00000003       NT_LLVM_OPENMP_OFFLOAD_VERSION (image format version)
+# NOTES-GNU-NEXT:     Version: 1.0
+# NOTES-GNU-NEXT:   LLVMOMPOFFLOAD       0x00000004       NT_LLVM_OPENMP_OFFLOAD_PRODUCER (producing toolchain)
+# NOTES-GNU-NEXT:     Producer: LLVM
+# NOTES-GNU-NEXT:   LLVMOMPOFFLOAD       0x00000009       NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION (producing toolchain version)
+# NOTES-GNU-NEXT:     Producer version: 13.0.0git
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS[[BITS]]
+  Data:  ELFDATA2[[ENCODING]]
+  Type:  ET_REL
+Sections:
+  - Name: .note.openmp
+    Type: SHT_NOTE
+    Notes:
+      - Name: LLVMOMPOFFLOAD
+        Type: 1 # NT_LLVM_OPENMP_OFFLOAD_VERSION
+        Desc: '312e30'
+      - Name: LLVMOMPOFFLOAD
+        Type: 2 # NT_LLVM_OPENMP_OFFLOAD_PRODUCER
+        Desc: '4c4c564d'
+      - Name: LLVMOMPOFFLOAD
+        Type: 3 # NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION
+        Desc: '31332e302e30676974'

llvm/tools/llvm-readobj/ELFDumper.cpp

 static std::string getGNUBuildId(ArrayRef<uint8_t> Desc) {
   std::string str;
   raw_string_ostream OS(str);
   for (uint8_t B : Desc)
     OS << format_hex_no_prefix(B, 2);
   return OS.str();
 }
 
-static StringRef getGNUGoldVersion(ArrayRef<uint8_t> Desc) {
+static StringRef getDescAsStringRef(ArrayRef<uint8_t> Desc) {
   return StringRef(reinterpret_cast<const char *>(Desc.data()), Desc.size());
 }
 
 template <typename ELFT>
 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 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);
+    OS << "    Version: " << getDescAsStringRef(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;
 }
 
+template <typename ELFT>
+static bool printLLVMOMPOFFLOADNote(raw_ostream &OS, uint32_t NoteType,
+                                    ArrayRef<uint8_t> Desc) {
+  switch (NoteType) {
+  default:
+    return false;
+  case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION:
+    OS << "    Version: " << getDescAsStringRef(Desc);
+    break;
+  case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER:
+    OS << "    Producer: " << getDescAsStringRef(Desc);
+    break;
+  case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION:
+    OS << "    Producer version: " << getDescAsStringRef(Desc);
+    break;
+  }
+  OS << '\n';
+  return true;
+}
+
 static const EnumEntry<unsigned> FreeBSDFeatureCtlFlags[] = {
     {"ASLR_DISABLE", NT_FREEBSD_FCTL_ASLR_DISABLE},
     {"PROTMAX_DISABLE", NT_FREEBSD_FCTL_PROTMAX_DISABLE},
     {"STKGAP_DISABLE", NT_FREEBSD_FCTL_STKGAP_DISABLE},
     {"WXNEEDED", NT_FREEBSD_FCTL_WXNEEDED},
     {"LA48", NT_FREEBSD_FCTL_LA48},
     {"ASG_DISABLE", NT_FREEBSD_FCTL_ASG_DISABLE},
 };
static const NoteType AMDNoteTypes[] = {
     {ELF::NT_AMD_HSA_ISA_NAME, "NT_AMD_HSA_ISA_NAME (AMD HSA ISA Name)"},
     {ELF::NT_AMD_PAL_METADATA, "NT_AMD_PAL_METADATA (AMD PAL Metadata)"},
 };
 
 static const NoteType AMDGPUNoteTypes[] = {
     {ELF::NT_AMDGPU_METADATA, "NT_AMDGPU_METADATA (AMDGPU Metadata)"},
 };
 
+static const NoteType LLVMOMPOFFLOADNoteTypes[] = {
+    {ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION,
+     "NT_LLVM_OPENMP_OFFLOAD_VERSION (image format version)"},
+    {ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER,
+     "NT_LLVM_OPENMP_OFFLOAD_PRODUCER (producing toolchain)"},
+    {ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION,
+     "NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION (producing toolchain version)"},
+};
+
 static const NoteType CoreNoteTypes[] = {
     {ELF::NT_PRSTATUS, "NT_PRSTATUS (prstatus structure)"},
     {ELF::NT_FPREGSET, "NT_FPREGSET (floating point registers)"},
     {ELF::NT_PRPSINFO, "NT_PRPSINFO (prpsinfo structure)"},
     {ELF::NT_TASKSTRUCT, "NT_TASKSTRUCT (task structure)"},
     {ELF::NT_AUXV, "NT_AUXV (auxiliary vector)"},
     {ELF::NT_PSTATUS, "NT_PSTATUS (pstatus structure)"},
     {ELF::NT_FPREGS, "NT_FPREGS (floating point registers)"},
if (Name == "FreeBSD") {
     } else {
       return FindNote(FreeBSDNoteTypes);
     }
   }
   if (Name == "AMD")
     return FindNote(AMDNoteTypes);
   if (Name == "AMDGPU")
     return FindNote(AMDGPUNoteTypes);
+  if (Name == "LLVMOMPOFFLOAD")
+    return FindNote(LLVMOMPOFFLOADNoteTypes);
 
   if (ELFType == ELF::ET_CORE)
     return FindNote(CoreNoteTypes);
   return FindNote(GenericNoteTypes);
 }
 
 template <class ELFT>
 static void printNotesHelper(
if (Name == "GNU") {
         return Error::success();
       }
     } else if (Name == "AMDGPU") {
       const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
       if (!N.Type.empty()) {
         OS << "    " << N.Type << ":\n        " << N.Value << '\n';
         return Error::success();
       }
+    } else if (Name == "LLVMOMPOFFLOAD") {
+      if (printLLVMOMPOFFLOADNote<ELFT>(OS, Type, Descriptor))
+        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)) {
           printCoreNote<ELFT>(OS, *NoteOrErr);
           return Error::success();
case ELF::NT_GNU_ABI_TAG: {
     }
     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));
+    W.printString("Version", getDescAsStringRef(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;
 }
 
+template <typename ELFT>
+static bool printLLVMOMPOFFLOADNoteLLVMStyle(uint32_t NoteType,
+                                             ArrayRef<uint8_t> Desc,
+                                             ScopedPrinter &W) {
+  switch (NoteType) {
+  default:
+    return false;
+  case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION:
+    W.printString("Version", getDescAsStringRef(Desc));
+    break;
+  case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER:
+    W.printString("Producer", getDescAsStringRef(Desc));
+    break;
+  case ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION:
+    W.printString("Producer version", getDescAsStringRef(Desc));
+    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);
     W.printHex("Offset", Mapping.Offset);
     W.printString("Filename", Mapping.Filename);
if (Name == "GNU") {
         return Error::success();
       }
     } else if (Name == "AMDGPU") {
       const AMDGPUNote N = getAMDGPUNote<ELFT>(Type, Descriptor);
       if (!N.Type.empty()) {
         W.printString(N.Type, N.Value);
         return Error::success();
       }
+    } else if (Name == "LLVMOMPOFFLOAD") {
+      if (printLLVMOMPOFFLOADNoteLLVMStyle<ELFT>(Type, Descriptor, W))
+        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> N = readCoreNote(DescExtractor)) {
           printCoreNoteLLVMStyle(*N, W);
           return Error::success();