AMDGPU: Add ELFOSABI_AMDGPU_PAL

[kzhuravl]

Summary

Docs by @tpr

[t-tye]

include/llvm/Object/ELFObjectFile.h

1067–1069

Perhaps this should be:

if (EF.getHeader()->e_ident[ELF::EI_CLASS] != ELF::ELFCLASS64)
  return Triple::amdgcn;
return Triple::UnknownArch;

The amdgcn only supports 64 bit and is independent of the OS.

tools/llvm-readobj/ELFDumper.cpp

3521–3523

Should this be:

if (e->e_machine == ELF::EM_AMDGPU && (e->e_ident[ELF::EI_OSABI] >= ELF::EI_FIRST_ARCH && e->e_ident[ELF::EI_OSABI] <= ELF::EI_LAST_ARCH))

Since only this range is the architecture specific, and other values should be handled by the ElfOSABI table. Technically there are some entries in that table that are architecture specific and probably ought to be handled in a similar way so that different architectures can use the same values, but if desired that can be done as another patch.

[kzhuravl]

Address review feedback.

tools/llvm-readobj/ELFDumper.cpp

3521–3523

Yes, I was planning to do it in separate patch.

[t-tye]

tools/llvm-readobj/ELFDumper.cpp

3521–3523

Still think should be testing the range of architecture specific codes, and use the general case if outside the range.

[kzhuravl]

tools/llvm-readobj/ELFDumper.cpp

3521–3523

This is done in a separate review: D38418.

[kzhuravl]

Rebase.

[t-tye]

include/llvm/Object/ELFObjectFile.h

1067–1068

Should a TODO be added to suggest adding an e_flags bit to distinguish between the amdgcn and r600 architectures?

1067–1068

Should this also return Triple::UnknownArch if not IsLittleEndian since that is the only supported byte ordering?

[kzhuravl]

Address review feedback.

[t-tye]

LGTM

[kzhuravl]

rL314843.

docs/AMDGPUUsage.rst

 Header
 ------
 
 The AMDGPU backend uses the following ELF header:
 
   .. table:: AMDGPU ELF Header
      :name: amdgpu-elf-header-table
 
-     ========================== =========================
+     ========================== ===============================
      Field                      Value
-     ========================== =========================
+     ========================== ===============================
      ``e_ident[EI_CLASS]``      ``ELFCLASS64``
      ``e_ident[EI_DATA]``       ``ELFDATA2LSB``
-     ``e_ident[EI_OSABI]``      ``ELFOSABI_AMDGPU_HSA``
-     ``e_ident[EI_ABIVERSION]`` ``ELFABIVERSION_AMDGPU_HSA``
+     ``e_ident[EI_OSABI]``      ``ELFOSABI_AMDGPU_HSA`` or
+                                ``ELFOSABI_AMDGPU_PAL``
+     ``e_ident[EI_ABIVERSION]`` ``ELFABIVERSION_AMDGPU_HSA`` or
+                                ``ELFABIVERSION_AMDGPU_PAL``
      ``e_type``                 ``ET_REL`` or ``ET_DYN``
      ``e_machine``              ``EM_AMDGPU``
      ``e_entry``                0
      ``e_flags``                0
-     ========================== =========================
+     ========================== ===============================
 
 ..
 
   .. table:: AMDGPU ELF Header Enumeration Values
      :name: amdgpu-elf-header-enumeration-values-table
 
      ============================ =====
      Name                         Value
      ============================ =====
      ``EM_AMDGPU``                224
      ``ELFOSABI_AMDGPU_HSA``      64
+     ``ELFOSABI_AMDGPU_PAL``      65
      ``ELFABIVERSION_AMDGPU_HSA`` 1
+     ``ELFABIVERSION_AMDGPU_PAL`` 0
      ============================ =====
 
 ``e_ident[EI_CLASS]``
-  The ELF class is always ``ELFCLASS64``. The AMDGPU backend only supports 64 bit
-  applications.
+  The ELF class is always ``ELFCLASS64``. The AMDGPU backend only supports 64
+  bit applications.
 
 ``e_ident[EI_DATA]``
   All AMDGPU targets use ELFDATA2LSB for little-endian byte ordering.
 
 ``e_ident[EI_OSABI]``
-  The AMD GPU architecture specific OS ABI of ``ELFOSABI_AMDGPU_HSA`` is used to
-  specify that the code object conforms to the AMD HSA runtime ABI [HSA]_.
+  One of two AMD GPU architecture specific OS ABI:
+
+  * ``ELFOSABI_AMDGPU_HSA`` is used to specify that the code object conforms to
+    the AMD HSA runtime ABI [HSA]_.
+
+  * ``ELFOSABI_AMDGPU_PAL`` is used to specify that the code object conforms to
+    the AMD PAL runtime ABI.
 
 ``e_ident[EI_ABIVERSION]``
-  The AMD GPU architecture specific OS ABI version of
-  ``ELFABIVERSION_AMDGPU_HSA`` is used to specify the version of AMD HSA runtime
-  ABI to which the code object conforms.
+  The ABI version of the AMD GPU architecture specific OS ABI to which the code
+  object conforms:
+
+  * ``ELFABIVERSION_AMDGPU_HSA`` is used to specify the version of AMD HSA
+    runtime ABI.
+
+  * ``ELFABIVERSION_AMDGPU_PAL`` is used to specify the version of AMD PAL
+    runtime ABI.
 
 ``e_type``
   Can be one of the following values:
 
 
   ``ET_REL``
     The type produced by the AMD GPU backend compiler as it is relocatable code
     object.

include/llvm/BinaryFormat/ELF.h

enum {
   ELFOSABI_MODESTO = 11,      // Novell Modesto
   ELFOSABI_OPENBSD = 12,      // OpenBSD
   ELFOSABI_OPENVMS = 13,      // OpenVMS
   ELFOSABI_NSK = 14,          // Hewlett-Packard Non-Stop Kernel
   ELFOSABI_AROS = 15,         // AROS
   ELFOSABI_FENIXOS = 16,      // FenixOS
   ELFOSABI_CLOUDABI = 17,     // Nuxi CloudABI
   ELFOSABI_C6000_ELFABI = 64, // Bare-metal TMS320C6000
-  ELFOSABI_AMDGPU_HSA = 64,   // AMD HSA runtime
   ELFOSABI_C6000_LINUX = 65,  // Linux TMS320C6000
+  ELFOSABI_AMDGPU_HSA = 64,   // AMD HSA runtime
+  ELFOSABI_AMDGPU_PAL = 65,   // AMD PAL runtime
   ELFOSABI_ARM = 97,          // ARM
   ELFOSABI_STANDALONE = 255   // Standalone (embedded) application
 };
 
 #define ELF_RELOC(name, value) name = value,
 
 // X86_64 relocations.
 enum {

include/llvm/Object/ELFObjectFile.h

case ELF::EM_S390:
       return "ELF64-s390";
     case ELF::EM_SPARCV9:
       return "ELF64-sparc";
     case ELF::EM_MIPS:
       return "ELF64-mips";
     case ELF::EM_WEBASSEMBLY:
       return "ELF64-wasm";
     case ELF::EM_AMDGPU:
-      return (EF.getHeader()->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA
-              && IsLittleEndian) ?
-             "ELF64-amdgpu-hsacobj" : "ELF64-amdgpu";
+      return "ELF64-amdgpu";
     case ELF::EM_BPF:
       return "ELF64-BPF";
     default:
       return "ELF64-unknown";
     }
   default:
     // FIXME: Proper error handling.
     report_fatal_error("Invalid ELFCLASS!");
unsigned ELFObjectFile<ELFT>::getArch() const {
   case ELF::EM_WEBASSEMBLY:
     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
     case ELF::ELFCLASS32: return Triple::wasm32;
     case ELF::ELFCLASS64: return Triple::wasm64;
     default: return Triple::UnknownArch;
     }
 
   case ELF::EM_AMDGPU:
-    return (EF.getHeader()->e_ident[ELF::EI_CLASS] == ELF::ELFCLASS64
-         && EF.getHeader()->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA
-         && IsLittleEndian) ?
+    return EF.getHeader()->e_ident[ELF::EI_CLASS] == ELF::ELFCLASS64 ?
         Triple::amdgcn : Triple::UnknownArch;
 
   case ELF::EM_BPF:
     return IsLittleEndian ? Triple::bpfel : Triple::bpfeb;
 
   default:
     return Triple::UnknownArch;
   }
 }
 

lib/ObjectYAML/ELFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(ELFOSABI_MODESTO);
   ECase(ELFOSABI_OPENBSD);
   ECase(ELFOSABI_OPENVMS);
   ECase(ELFOSABI_NSK);
   ECase(ELFOSABI_AROS);
   ECase(ELFOSABI_FENIXOS);
   ECase(ELFOSABI_CLOUDABI);
   ECase(ELFOSABI_C6000_ELFABI);
-  ECase(ELFOSABI_AMDGPU_HSA);
   ECase(ELFOSABI_C6000_LINUX);
+  ECase(ELFOSABI_AMDGPU_HSA);
+  ECase(ELFOSABI_AMDGPU_PAL);
   ECase(ELFOSABI_ARM);
   ECase(ELFOSABI_STANDALONE);
 #undef ECase
 }
 
 void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
                                                  ELFYAML::ELF_EF &Value) {
   const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());

test/CodeGen/AMDGPU/elf.ll

 ; RUN: llc < %s -march=amdgcn -verify-machineinstrs -filetype=obj | llvm-readobj -s -symbols -file-headers - | FileCheck --check-prefix=ELF %s
 ; RUN: llc < %s -march=amdgcn -verify-machineinstrs -o - | FileCheck --check-prefix=CONFIG --check-prefix=TYPICAL %s
 ; RUN: llc < %s -march=amdgcn -mcpu=tonga -mattr=-flat-for-global -verify-machineinstrs -filetype=obj | llvm-readobj -s -symbols -file-headers - | FileCheck --check-prefix=ELF %s
 ; RUN: llc < %s -march=amdgcn -mcpu=tonga -mattr=-flat-for-global -verify-machineinstrs -o - | FileCheck --check-prefix=CONFIG --check-prefix=TONGA %s
 ; RUN: llc < %s -march=amdgcn -mcpu=carrizo -mattr=-flat-for-global -verify-machineinstrs -filetype=obj | llvm-readobj -s -symbols -file-headers - | FileCheck --check-prefix=ELF %s
 ; RUN: llc < %s -march=amdgcn -mcpu=carrizo -mattr=-flat-for-global -verify-machineinstrs -o - | FileCheck --check-prefix=CONFIG --check-prefix=TYPICAL %s
 
 ; Test that we don't try to produce a COFF file on windows
 ; RUN: llc < %s -mtriple=amdgcn-pc-mingw -verify-machineinstrs -filetype=obj | llvm-readobj -s -symbols -file-headers - | FileCheck --check-prefix=ELF %s
 
 ; ELF: Format: ELF64
-; ELF: OS/ABI: AMDGPU_HSA (0x40)
+; ELF: OS/ABI: AMDHSA (0x40)
 ; ELF: Machine: EM_AMDGPU (0xE0)
 ; ELF: Name: .AMDGPU.config
 ; ELF: Type: SHT_PROGBITS
 
 ; ELF: Symbol {
 ; ELF: Name: test
 ; ELF: Binding: Global
 

test/Object/AMDGPU/elf-definitions.yaml

-# RUN: yaml2obj %s > %t.o
-# RUN: llvm-readobj -s -file-headers %t.o | FileCheck %s
-
-# CHECK: Format: ELF64-amdgpu-hsacobj
-# CHECK: Arch: amdgcn
-# CHECK: ElfHeader {
-# CHECK:   Ident {
-# CHECK:     OS/ABI: AMDGPU_HSA (0x40)
-# CHECK:     ABIVersion: 0
-# CHECK:   }
-# CHECK:   Machine: EM_AMDGPU (0xE0)
-# CHECK: }
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_REL
-  Machine: EM_AMDGPU
-  OSABI:   ELFOSABI_AMDGPU_HSA
-...

test/Object/AMDGPU/elf64-amdgcn-amdhsa-definitions.yaml

+# RUN: yaml2obj %s > %t.o
+# RUN: llvm-readobj -s -file-headers %t.o | FileCheck %s
+
+# CHECK: Format: ELF64-amdgpu
+# CHECK: Arch: amdgcn
+# CHECK: ElfHeader {
+# CHECK:   Ident {
+# CHECK:     OS/ABI: AMDHSA (0x40)
+# CHECK:     ABIVersion: 0
+# CHECK:   }
+# CHECK:   Machine: EM_AMDGPU (0xE0)
+# CHECK: }
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_AMDGPU
+  OSABI:   ELFOSABI_AMDGPU_HSA
+...

test/Object/AMDGPU/elf64-amdgcn-amdpal-definitions.yaml

+# RUN: yaml2obj %s > %t.o
+# RUN: llvm-readobj -s -file-headers %t.o | FileCheck %s
+
+# CHECK: Format: ELF64-amdgpu
+# CHECK: Arch: amdgcn
+# CHECK: ElfHeader {
+# CHECK:   Ident {
+# CHECK:     OS/ABI: AMDPAL (0x41)
+# CHECK:     ABIVersion: 0
+# CHECK:   }
+# CHECK:   Machine: EM_AMDGPU (0xE0)
+# CHECK: }
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_AMDGPU
+  OSABI:   ELFOSABI_AMDGPU_PAL
+...

test/Object/AMDGPU/objdump.s

BB5:
   v_add_i32_e32 v10, vcc, s8, v10
   v_mov_b32_e32 v6, s9
   v_addc_u32_e32 v11, vcc, v6, v11, vcc
   flat_load_dword v0, v[10:11]
   v_lshlrev_b32_e32 v6, 5, v8
   v_lshlrev_b32_e32 v7, 2, v7
         s_endpgm
 
-// CHECK:  file format ELF64-amdgpu-hsacobj
+// CHECK:  file format ELF64-amdgpu
 // CHECK:  Disassembly of section .text:
 // CHECK:  hello_world:
 // CHECK:  s_mov_b32 m0, 0x10000                                      // 000000000100: BEFC00FF 00010000
 // CHECK:  s_load_dwordx2 s[0:1], s[4:5], 0x8                         // 000000000108: C0060002 00000008
 // CHECK:  s_waitcnt lgkmcnt(0)                                       // 000000000110: BF8C007F
 // CHECK:  s_add_u32 s0, s7, s0                                       // 000000000114: 80000007
 // CHECK:  BB0:
 // CHECK:  v_add_i32_e32 v1, vcc, s0, v1                              // 000000000118: 32020200

test/tools/llvm-readobj/amdgpu-elf-definitions.test

 RUN: llvm-readobj -file-headers -program-headers -sections -symbols %p/Inputs/trivial.obj.elf-amdhsa-gfx803 | FileCheck %s
 
-CHECK: Format: ELF64-amdgpu-hsacobj
+CHECK: Format: ELF64-amdgpu
 CHECK: Arch: amdgcn
 CHECK: ElfHeader {
 CHECK:   Ident {
-CHECK:     OS/ABI: AMDGPU_HSA (0x40)
+CHECK:     OS/ABI: AMDHSA (0x40)
 CHECK:     ABIVersion: 0
 CHECK:   }
 CHECK:   Machine: EM_AMDGPU (0xE0)
 CHECK: }

tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfOSABI[] = {
   {"FenixOS",      "FenixOS",              ELF::ELFOSABI_FENIXOS},
   {"CloudABI",     "CloudABI",             ELF::ELFOSABI_CLOUDABI},
   {"C6000_ELFABI", "Bare-metal C6000",     ELF::ELFOSABI_C6000_ELFABI},
   {"C6000_LINUX",  "Linux C6000",          ELF::ELFOSABI_C6000_LINUX},
   {"ARM",          "ARM",                  ELF::ELFOSABI_ARM},
   {"Standalone",   "Standalone App",       ELF::ELFOSABI_STANDALONE}
 };
 
+static const EnumEntry<unsigned> AMDGPUElfOSABI[] = {
+  {"AMDHSA", "AMDGPU - HSA", ELF::ELFOSABI_AMDGPU_HSA},
+  {"AMDPAL", "AMDGPU - PAL", ELF::ELFOSABI_AMDGPU_PAL}
+};
+
 static const EnumEntry<unsigned> ElfMachineType[] = {
   ENUM_ENT(EM_NONE,          "None"),
   ENUM_ENT(EM_M32,           "WE32100"),
   ENUM_ENT(EM_SPARC,         "Sparc"),
   ENUM_ENT(EM_386,           "Intel 80386"),
   ENUM_ENT(EM_68K,           "MC68000"),
   ENUM_ENT(EM_88K,           "MC88000"),
   ENUM_ENT(EM_IAMCU,         "EM_IAMCU"),
DictScope D(W, "ElfHeader");
       DictScope D(W, "Ident");
       W.printBinary("Magic", makeArrayRef(e->e_ident).slice(ELF::EI_MAG0, 4));
       W.printEnum("Class", e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
       W.printEnum("DataEncoding", e->e_ident[ELF::EI_DATA],
                   makeArrayRef(ElfDataEncoding));
       W.printNumber("FileVersion", e->e_ident[ELF::EI_VERSION]);
 
       // Handle architecture specific OS/ABI values.
-      if (e->e_machine == ELF::EM_AMDGPU &&
-          e->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA)
-        W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA);
+      if (e->e_machine == ELF::EM_AMDGPU)
+        W.printEnum("OS/ABI", e->e_ident[ELF::EI_OSABI],
+                    makeArrayRef(AMDGPUElfOSABI));
       else
         W.printEnum("OS/ABI", e->e_ident[ELF::EI_OSABI],
                     makeArrayRef(ElfOSABI));
       W.printNumber("ABIVersion", e->e_ident[ELF::EI_ABIVERSION]);
       W.printBinary("Unused", makeArrayRef(e->e_ident).slice(ELF::EI_PAD));
     }
 
     W.printEnum("Type", e->e_type, makeArrayRef(ElfObjectFileType));