[llvm-readobj][AMDGPU] Moved AMDGPU-specific note record dumping into target

[tpr]

Summary

Change-Id: Ic9133164a7c0746bfb6c79c4cb484eb132882c5b

[tpr]

Requires D52821.

[abdulras]

I don't mind the separation, but, I don't see what makes this target specific still. I really think that we should have this be out-side of the target specific content, but having this in LLVM instead of the readobj tool makes sense. At the very least, I think that we need to fix the big endian case.

lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.cpp

951

You should be able to use ulittle_* to decode this even on a big endian host. I don't see why the content being in little endian should prevent the host tools from running on big endian.

lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.h

 #define LLVM_LIB_TARGET_AMDGPU_DISASSEMBLER_AMDGPUDISASSEMBLER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
 #include "llvm/MC/MCDisassembler/MCSymbolizer.h"
+#include "llvm/Object/ELFNoteDumper.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <memory>
 
 namespace llvm {
 
 class MCInst;
bool tryAddingSymbolicOperand(MCInst &Inst, raw_ostream &cStream,
                                 bool IsBranch, uint64_t Offset,
                                 uint64_t InstSize) override;
 
   void tryAddingPcLoadReferenceComment(raw_ostream &cStream,
                                        int64_t Value,
                                        uint64_t Address) override;
 };
 
+//===----------------------------------------------------------------------===//
+// AMDGPUELFNoteDumper
+//===----------------------------------------------------------------------===//
+
+class AMDGPUELFNoteDumper : public ELFNoteDumper {
+public:
+  AMDGPUELFNoteDumper() : ELFNoteDumper() {}
+
+  // Dump the contents of one note from the ELF .note section in readable
+  // format. This returns false if the implementation does not understand the
+  // note.
+  // The .note descriptor (i.e. contents) is passed as an StringRef of bytes as
+  // found in the ELF file, together with an indication of the endianness of
+  // the ELF file.
+  virtual bool dumpNote(unsigned Type, StringRef Name, StringRef Desc,
+              support::endianness TargetEndianness, raw_ostream &OS) override;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_AMDGPU_DISASSEMBLER_AMDGPUDISASSEMBLER_H

lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.cpp

 //===----------------------------------------------------------------------===//
 
 // ToDo: What to do with instruction suffixes (v_mov_b32 vs v_mov_b32_e32)?
 
 #include "Disassembler/AMDGPUDisassembler.h"
 #include "AMDGPU.h"
 #include "AMDGPURegisterInfo.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
+#include "MCTargetDesc/AMDGPUTargetStreamer.h"
 #include "SIDefines.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
 #include "Utils/AMDGPUBaseInfo.h"
 #include "llvm-c/Disassembler.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/ELF.h"

 
 void AMDGPUSymbolizer::tryAddingPcLoadReferenceComment(raw_ostream &cStream,
                                                        int64_t Value,
                                                        uint64_t Address) {
   llvm_unreachable("unimplemented");
 }
 
 //===----------------------------------------------------------------------===//
+// AMDGPUELFNoteDumper
+//===----------------------------------------------------------------------===//
+
+// Dump the contents of one note from the ELF .note section in readable
+// format. This returns false if the implementation does not understand the
+// note.
+bool AMDGPUELFNoteDumper::dumpNote(unsigned Type, StringRef Name,
+        StringRef Desc, support::endianness TargetEndianness, raw_ostream &OS) {
+  if (Name != "AMD")
+    return false;
+  switch (Type) {
+  default:
+    return false;
+  case ELF::NT_AMD_AMDGPU_HSA_METADATA:
+    OS << "NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)\n";
+    OS << "    HSA Metadata:\n"
+       << Desc;
+    return true;
+  case ELF::NT_AMD_AMDGPU_ISA:
+    OS << "NT_AMD_AMDGPU_ISA (ISA Version)\n";
+    OS << "    ISA Version:\n"
+       << "        "
+       << Desc;
+    return true;
+  case ELF::NT_AMD_AMDGPU_PAL_METADATA: {
+    // PAL metadata is in 32-bit words and only exists on AMDGPU, which is
+    // always little endian, so the following does not work if running
+    // llvm-readobj on a big-endian host.
+#if BYTE_ORDER == LITTLE_ENDIAN
+    OS << "NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)\n";
+    const uint32_t *PALMetadataBegin
+        = reinterpret_cast<const uint32_t *>(Desc.data());
+    const uint32_t *PALMetadataEnd
+        = PALMetadataBegin + Desc.size() / sizeof(uint32_t);
+    std::vector<uint32_t> PALMetadata(PALMetadataBegin, PALMetadataEnd);
+    std::string PALMetadataString;
+    auto Error = AMDGPU::PALMD::toString(PALMetadata, PALMetadataString);
+    OS << "    PAL Metadata:\n";
+    if (Error)
+      OS << "        Invalid";
+    else
+      OS << PALMetadataString;
+    return true;
+#endif
+    return false;
+  }
+  }
+}
+
+//===----------------------------------------------------------------------===//
 // Initialization
 //===----------------------------------------------------------------------===//
 
 static MCSymbolizer *createAMDGPUSymbolizer(const Triple &/*TT*/,
                               LLVMOpInfoCallback /*GetOpInfo*/,
                               LLVMSymbolLookupCallback /*SymbolLookUp*/,
                               void *DisInfo,
                               MCContext *Ctx,
                               std::unique_ptr<MCRelocationInfo> &&RelInfo) {
   return new AMDGPUSymbolizer(*Ctx, std::move(RelInfo), DisInfo);
 }
 
 static MCDisassembler *createAMDGPUDisassembler(const Target &T,
                                                 const MCSubtargetInfo &STI,
                                                 MCContext &Ctx) {
   return new AMDGPUDisassembler(STI, Ctx, T.createMCInstrInfo());
 }
 
+static ELFNoteDumper *createAMDGPUELFNoteDumper(const Target &T) {
+  return new AMDGPUELFNoteDumper();
+}
+
 extern "C" void LLVMInitializeAMDGPUDisassembler() {
   TargetRegistry::RegisterMCDisassembler(getTheGCNTarget(),
                                          createAMDGPUDisassembler);
   TargetRegistry::RegisterMCSymbolizer(getTheGCNTarget(),
                                        createAMDGPUSymbolizer);
+  TargetRegistry::RegisterELFNoteDumper(getTheGCNTarget(),
+                                        createAMDGPUELFNoteDumper);
 }

test/CodeGen/AMDGPU/elf-notes.ll

 ; OSABI-UNK-ELF-NOT: Unknown note type
 
 ; OSABI-HSA: .hsa_code_object_version
 ; OSABI-HSA: .hsa_code_object_isa
 ; OSABI-HSA: .amd_amdgpu_isa "amdgcn-amd-amdhsa--gfx802"
 ; OSABI-HSA: .amd_amdgpu_hsa_metadata
 ; OSABI-HSA-NOT: .amd_amdgpu_pal_metadata
 
-; OSABI-HSA-ELF: Unknown note type (0x00000001)
-; OSABI-HSA-ELF: Unknown note type (0x00000003)
+; OSABI-HSA-ELF: Unknown note type: (0x00000001)
+; OSABI-HSA-ELF: Unknown note type: (0x00000003)
 ; OSABI-HSA-ELF: NT_AMD_AMDGPU_ISA (ISA Version)
 ; OSABI-HSA-ELF: ISA Version:
 ; OSABI-HSA-ELF: amdgcn-amd-amdhsa--gfx802
 ; OSABI-HSA-ELF: NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)
 ; OSABI-HSA-ELF: HSA Metadata:
 ; OSABI-HSA-ELF: ---
 ; OSABI-HSA-ELF: Version: [ 1, 0 ]
 ; OSABI-HSA-ELF: Kernels:

 ; OSABI-HSA-ELF-NOT: NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)
 
 ; OSABI-PAL-NOT: .hsa_code_object_version
 ; OSABI-PAL: .hsa_code_object_isa
 ; OSABI-PAL: .amd_amdgpu_isa "amdgcn-amd-amdpal--gfx802"
 ; OSABI-PAL-NOT: .amd_amdgpu_hsa_metadata
 ; OSABI-PAL: .amd_amdgpu_pal_metadata
 
-; OSABI-PAL-ELF: Unknown note type (0x00000003)
+; OSABI-PAL-ELF: Unknown note type: (0x00000003)
 ; OSABI-PAL-ELF: NT_AMD_AMDGPU_ISA (ISA Version)
 ; OSABI-PAL-ELF: ISA Version:
 ; OSABI-PAL-ELF: amdgcn-amd-amdpal--gfx802
 ; OSABI-PAL-ELF-NOT: NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)
 ; OSABI-PAL-ELF: NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)
 ; OSABI-PAL-ELF: PAL Metadata:
 ; TODO: Following check line fails on mips:
 ; OSABI-PAL-ELF-XXX: 0x2e12,0xac02c0,0x2e13,0x80,0x1000001b,0x1,0x10000022,0x60,0x1000003e,0x0

tools/llvm-readobj/ELFDumper.cpp

if (Note.ID == NT)
       return std::string(Note.Name);
 
   std::string string;
   raw_string_ostream OS(string);
   OS << format("Unknown note type (0x%08x)", NT);
   return OS.str();
 }
 
-static std::string getAMDGPUNoteTypeName(const uint32_t NT) {
-  static const struct {
-    uint32_t ID;
-    const char *Name;
-  } Notes[] = {
-    {ELF::NT_AMD_AMDGPU_HSA_METADATA,
-     "NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)"},
-    {ELF::NT_AMD_AMDGPU_ISA,
-     "NT_AMD_AMDGPU_ISA (ISA Version)"},
-    {ELF::NT_AMD_AMDGPU_PAL_METADATA,
-     "NT_AMD_AMDGPU_PAL_METADATA (PAL Metadata)"}
-  };
-
-  for (const auto &Note : Notes)
-    if (Note.ID == NT)
-      return std::string(Note.Name);
-
-  std::string string;
-  raw_string_ostream OS(string);
-  OS << format("Unknown note type (0x%08x)", NT);
-  return OS.str();
-}
-
 template <typename ELFT>
 static void printGNUProperty(raw_ostream &OS, uint32_t Type, uint32_t DataSize,
                              ArrayRef<uint8_t> Data) {
   switch (Type) {
   default:
     OS << format("    <application-specific type 0x%x>\n", Type);
     return;
   case GNU_PROPERTY_STACK_SIZE: {
case ELF::NT_GNU_PROPERTY_TYPE_0:
 
     if (!Arr.empty())
       OS << "    <corrupted GNU_PROPERTY_TYPE_0>";
     break;
   }
   OS << '\n';
 }
 
-template <typename ELFT>
-static void printAMDGPUNote(raw_ostream &OS, uint32_t NoteType,
-                            ArrayRef<typename ELFT::Word> Words, size_t Size) {
-  switch (NoteType) {
-  default:
-    return;
-    case ELF::NT_AMD_AMDGPU_HSA_METADATA:
-      OS << "    HSA Metadata:\n"
-         << StringRef(reinterpret_cast<const char *>(Words.data()), Size);
-      break;
-    case ELF::NT_AMD_AMDGPU_ISA:
-      OS << "    ISA Version:\n"
-         << "        "
-         << StringRef(reinterpret_cast<const char *>(Words.data()), Size);
-      break;
-    case ELF::NT_AMD_AMDGPU_PAL_METADATA:
-      const uint32_t *PALMetadataBegin = reinterpret_cast<const uint32_t *>(Words.data());
-      const uint32_t *PALMetadataEnd = PALMetadataBegin + Size;
-      std::vector<uint32_t> PALMetadata(PALMetadataBegin, PALMetadataEnd);
-      std::string PALMetadataString;
-      auto Error = AMDGPU::PALMD::toString(PALMetadata, PALMetadataString);
-      OS << "    PAL Metadata:\n";
-      if (Error) {
-        OS << "        Invalid";
-        return;
-      }
-      OS << PALMetadataString;
-      break;
-  }
-  OS.flush();
-}
-
 template <class ELFT>
 void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
   const Elf_Ehdr *e = Obj->getHeader();
   bool IsCore = e->e_type == ELF::ET_CORE;
 
   auto PrintHeader = [&](const typename ELFT::Off Offset,
                          const typename ELFT::Addr Size) {
     OS << "Displaying notes found at file offset " << format_hex(Offset, 10)
auto ProcessNote = [&](const Elf_Note &Note) {
     OS << "  " << Name << std::string(22 - Name.size(), ' ')
        << format_hex(Descriptor.size(), 10) << '\t';
 
     if (Name == "GNU") {
       OS << getGNUNoteTypeName(Type) << '\n';
       printGNUNote<ELFT>(OS, Type, Descriptor, Descriptor.size());
     } else if (Name == "FreeBSD") {
       OS << getFreeBSDNoteTypeName(Type) << '\n';
-    } else if (Name == "AMD") {
-      OS << getAMDGPUNoteTypeName(Type) << '\n';
-      printAMDGPUNote<ELFT>(OS, Type, Descriptor, Descriptor.size());
     } else {
       // See if any compiled-in target knows how to dump this note record. A
       // target's ELFNoteDumper takes the descriptor as a StringRef of bytes
       // from the ELF file, and leaves it to the implementation to sort out
       // endianness.
       bool Dumped = false;
       StringRef Bytes((const char *)Descriptor.data(), Descriptor.size());
       for (auto &T : TargetRegistry::targets()) {