ELF: Add AMDGPU specific defintions

[• tstellarAMD]

Ping.

[• rafael]

Please include a llvm-readobj testcase.

include/llvm/Support/ELF.h

752

Please just include the final value.

838

Please just include the final value.

995

Please just include the final value.

tools/llvm-readobj/ELFDumper.cpp

967

Can't you add ad

static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = {
...
}
?

[• tstellarAMD]

Here is an updated patch. I've added a test case, cleaned up the symbol
type handling in llvm-readobj and fixed the enum values.

[• tstellarAMD]

Marked review comments as done.

[• rafael]

LGTM

include/llvm/Support/ELF.h

enum : unsigned {
 
   // This section should be merged.
   SHF_MIPS_MERGE   = 0x20000000,
 
   // Address size to be inferred from section entry size.
   SHF_MIPS_ADDR    = 0x40000000,
 
   // Section data is string data by default.
-  SHF_MIPS_STRING  = 0x80000000
+  SHF_MIPS_STRING  = 0x80000000,
+
+  SHF_AMDGPU_HSA_GLOBAL = (0x00100000 & SHF_MASKOS),
+  SHF_AMDGPU_HSA_READONLY = (0x00200000 & SHF_MASKOS),
+  SHF_AMDGPU_HSA_CODE = (0x00400000 & SHF_MASKOS),
+  SHF_AMDGPU_HSA_AGENT = (0x00800000 & SHF_MASKOS)
 };
 
 // Section Group Flags
 enum : unsigned {
   GRP_COMDAT = 0x1,
   GRP_MASKOS = 0x0ff00000,
   GRP_MASKPROC = 0xf0000000
 };
enum {
   STT_SECTION = 3,   // Symbol refers to a section
   STT_FILE    = 4,   // Local, absolute symbol that refers to a file
   STT_COMMON  = 5,   // An uninitialized common block
   STT_TLS     = 6,   // Thread local data object
   STT_GNU_IFUNC = 10, // GNU indirect function
   STT_LOOS    = 10,  // Lowest operating system-specific symbol type
   STT_HIOS    = 12,  // Highest operating system-specific symbol type
   STT_LOPROC  = 13,  // Lowest processor-specific symbol type
-  STT_HIPROC  = 15   // Highest processor-specific symbol type
+  STT_HIPROC  = 15,  // Highest processor-specific symbol type
+
+  // AMDGPU symbol types
+  STT_AMDGPU_HSA_KERNEL = STT_LOOS,
+  STT_AMDGPU_HSA_INDIRECT_FUNCTION = STT_LOOS + 1,
+  STT_AMDGPU_HSA_METADATA = STT_LOOS + 2
 };
 
 enum {
   STV_DEFAULT   = 0,  // Visibility is specified by binding type
   STV_INTERNAL  = 1,  // Defined by processor supplements
   STV_HIDDEN    = 2,  // Not visible to other components
   STV_PROTECTED = 3   // Visible in other components but not preemptable
 };
enum {
   // These all contain stack unwind tables.
   PT_ARM_EXIDX   = 0x70000001,
   PT_ARM_UNWIND  = 0x70000001,
 
   // MIPS program header types.
   PT_MIPS_REGINFO  = 0x70000000,  // Register usage information.
   PT_MIPS_RTPROC   = 0x70000001,  // Runtime procedure table.
   PT_MIPS_OPTIONS  = 0x70000002,  // Options segment.
-  PT_MIPS_ABIFLAGS = 0x70000003   // Abiflags segment.
+  PT_MIPS_ABIFLAGS = 0x70000003,  // Abiflags segment.
+
+  // AMDGPU program header types.
+  PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM = PT_LOOS,
+  PT_AMDGPU_HSA_LOAD_GLOBAL_AGENT = PT_LOOS + 1,
+  PT_AMDGPU_HSA_LOAD_READONLY_AGENT = PT_LOOS + 2,
+  PT_AMDGPU_HSA_LOAD_CODE_AGENT = PT_LOOS + 3
 };
 
 // Segment flag bits.
 enum : unsigned {
   PF_X        = 1,         // Execute
   PF_W        = 2,         // Write
   PF_R        = 4,         // Read
   PF_MASKOS   = 0x0ff00000,// Bits for operating system-specific semantics.

tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfSectionFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS         ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK       ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_LINK_ORDER      ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_OS_NONCONFORMING),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_GROUP           ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_TLS             ),
   LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
   LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION),
-  LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP    )
+  LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP    ),
+  LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_GLOBAL),
+  LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_READONLY),
+  LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_CODE),
+  LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_AGENT)
 };
 
 static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
   // Check potentially overlapped processor-specific
   // program header type.
   switch (Arch) {
+  case ELF::EM_AMDGPU:
+    switch (Type) {
+    LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM);
+    LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_AGENT);
+    LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_READONLY_AGENT);
+    LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_CODE_AGENT);
+    }
   case ELF::EM_ARM:
     switch (Type) {
     LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
     }
   case ELF::EM_MIPS:
   case ELF::EM_MIPS_RS3_LE:
     switch (Type) {
     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);

 template <class ELFT>
 void ELFDumper<ELFT>::printSymbol(const typename ELFO::Elf_Sym *Symbol,
                                   StringRef StrTable, bool IsDynamic) {
   unsigned SectionIndex = 0;
   StringRef SectionName;
   getSectionNameIndex(*Obj, Symbol, SectionName, SectionIndex);
   std::string FullSymbolName =
       getFullSymbolName(*Obj, Symbol, StrTable, IsDynamic);
+  unsigned char SymbolType = Symbol->getType();
 
   DictScope D(W, "Symbol");
   W.printNumber("Name", FullSymbolName, Symbol->st_name);
   W.printHex   ("Value", Symbol->st_value);
   W.printNumber("Size", Symbol->st_size);
   W.printEnum  ("Binding", Symbol->getBinding(),
                   makeArrayRef(ElfSymbolBindings));
-  W.printEnum  ("Type", Symbol->getType(), makeArrayRef(ElfSymbolTypes));
+  if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
+      SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS) {
+    switch(SymbolType) {
+    #define LLVM_READOBJ_AMDGPU_STT_CASE(name) \
+      case name: W.printHex("Type", #name, name); break;
+    LLVM_READOBJ_AMDGPU_STT_CASE(STT_AMDGPU_HSA_KERNEL);
+    LLVM_READOBJ_AMDGPU_STT_CASE(STT_AMDGPU_HSA_INDIRECT_FUNCTION);
+    LLVM_READOBJ_AMDGPU_STT_CASE(STT_AMDGPU_HSA_METADATA);
+    #undef LLVM_READOBJ_AMDGPU_STT_CASE
+    }
+  } else
+    W.printEnum  ("Type", SymbolType, makeArrayRef(ElfSymbolTypes));
   W.printNumber("Other", Symbol->st_other);
   W.printHex("Section", SectionName, SectionIndex);
 }
 
 #define LLVM_READOBJ_TYPE_CASE(name) \
   case DT_##name: return #name
 
 static const char *getTypeString(uint64_t Type) {