MC: Add support for parsing and emitting STT_AMDGPU_HSA_KERNEL with .type directive

[• tstellarAMD]

I think I'm going to add a target specific assembler macro instead to avoid having to plumb this flag through the whole MC infrastructure.

include/llvm/MC/MCDirectives.h

enum MCSymbolAttr {
   // Various directives in alphabetical order.
   MCSA_ELF_TypeFunction,    ///< .type _foo, STT_FUNC  # aka @function
   MCSA_ELF_TypeIndFunction, ///< .type _foo, STT_GNU_IFUNC
   MCSA_ELF_TypeObject,      ///< .type _foo, STT_OBJECT  # aka @object
   MCSA_ELF_TypeTLS,         ///< .type _foo, STT_TLS     # aka @tls_object
   MCSA_ELF_TypeCommon,      ///< .type _foo, STT_COMMON  # aka @common
   MCSA_ELF_TypeNoType,      ///< .type _foo, STT_NOTYPE  # aka @notype
   MCSA_ELF_TypeGnuUniqueObject, /// .type _foo, @gnu_unique_object
+  /// .type _foo, STT_AMDGPU_HSA_KERNEL, @amdgpu_hsa_kernel (AMDGPU)
+  MCSA_ELF_TypeAMDGPUHSAKernel,
   MCSA_Global,              ///< .globl
   MCSA_Hidden,              ///< .hidden (ELF)
   MCSA_IndirectSymbol,      ///< .indirect_symbol (MachO)
   MCSA_Internal,            ///< .internal (ELF)
   MCSA_LazyReference,       ///< .lazy_reference (MachO)
   MCSA_Local,               ///< .local (ELF)
   MCSA_NoDeadStrip,         ///< .no_dead_strip (MachO)
   MCSA_SymbolResolver,      ///< .symbol_resolver (MachO)

lib/MC/MCAsmStreamer.cpp

bool MCAsmStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
   case MCSA_Invalid: llvm_unreachable("Invalid symbol attribute");
   case MCSA_ELF_TypeFunction:    /// .type _foo, STT_FUNC  # aka @function
   case MCSA_ELF_TypeIndFunction: /// .type _foo, STT_GNU_IFUNC
   case MCSA_ELF_TypeObject:      /// .type _foo, STT_OBJECT  # aka @object
   case MCSA_ELF_TypeTLS:         /// .type _foo, STT_TLS     # aka @tls_object
   case MCSA_ELF_TypeCommon:      /// .type _foo, STT_COMMON  # aka @common
   case MCSA_ELF_TypeNoType:      /// .type _foo, STT_NOTYPE  # aka @notype
   case MCSA_ELF_TypeGnuUniqueObject:  /// .type _foo, @gnu_unique_object
+  case MCSA_ELF_TypeAMDGPUHSAKernel:  /// .type _foo, STT_AMDGPU_SHA_KERNEL
+                                      /// aka @amdgpu_hsa_kernel
     if (!MAI->hasDotTypeDotSizeDirective())
       return false; // Symbol attribute not supported
     OS << "\t.type\t";
     Symbol->print(OS, MAI);
     OS << ',' << ((MAI->getCommentString()[0] != '@') ? '@' : '%');
     switch (Attribute) {
     default: return false;
     case MCSA_ELF_TypeFunction:    OS << "function"; break;
     case MCSA_ELF_TypeIndFunction: OS << "gnu_indirect_function"; break;
     case MCSA_ELF_TypeObject:      OS << "object"; break;
     case MCSA_ELF_TypeTLS:         OS << "tls_object"; break;
     case MCSA_ELF_TypeCommon:      OS << "common"; break;
     case MCSA_ELF_TypeNoType:      OS << "no_type"; break;
     case MCSA_ELF_TypeGnuUniqueObject: OS << "gnu_unique_object"; break;
+    case MCSA_ELF_TypeAMDGPUHSAKernel: OS << "amdgpu_hsa_kernel"; break;
     }
     EmitEOL();
     return true;
   case MCSA_Global: // .globl/.global
     OS << MAI->getGlobalDirective();
     break;
   case MCSA_Hidden:         OS << "\t.hidden\t";          break;
   case MCSA_IndirectSymbol: OS << "\t.indirect_symbol\t"; break;

lib/MC/MCELFStreamer.cpp

case MCSA_Weak:
     Symbol->setExternal(true);
     break;
 
   case MCSA_Local:
     Symbol->setBinding(ELF::STB_LOCAL);
     Symbol->setExternal(false);
     break;
 
+  case MCSA_ELF_TypeAMDGPUHSAKernel:
+    Symbol->setType(ELF::STT_AMDGPU_HSA_KERNEL);
+    break;
+
   case MCSA_ELF_TypeFunction:
     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_FUNC));
     break;
 
   case MCSA_ELF_TypeIndFunction:
     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_GNU_IFUNC));
     break;
 

lib/MC/MCParser/ELFAsmParser.cpp

return StringSwitch<MCSymbolAttr>(Type)
           .Cases("STT_FUNC", "function", MCSA_ELF_TypeFunction)
           .Cases("STT_OBJECT", "object", MCSA_ELF_TypeObject)
           .Cases("STT_TLS", "tls_object", MCSA_ELF_TypeTLS)
           .Cases("STT_COMMON", "common", MCSA_ELF_TypeCommon)
           .Cases("STT_NOTYPE", "notype", MCSA_ELF_TypeNoType)
           .Cases("STT_GNU_IFUNC", "gnu_indirect_function",
                  MCSA_ELF_TypeIndFunction)
           .Case("gnu_unique_object", MCSA_ELF_TypeGnuUniqueObject)
+          .Cases("STT_AMDGPU_HSA_KERNEL", "amdgpu_hsa_kernel",
+                 MCSA_ELF_TypeAMDGPUHSAKernel)
           .Default(MCSA_Invalid);
 }
 
 /// ParseDirectiveELFType
 ///  ::= .type identifier , STT_<TYPE_IN_UPPER_CASE>
 ///  ::= .type identifier , #attribute
 ///  ::= .type identifier , @attribute
 ///  ::= .type identifier , %attribute

lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCAsmInfo.cpp

AMDGPUMCAsmInfo::AMDGPUMCAsmInfo(const Triple &TT) : MCAsmInfoELF() {
   Data32bitsDirective = ".long\t";
   Data64bitsDirective = ".quad\t";
   SunStyleELFSectionSwitchSyntax = true;
   UsesELFSectionDirectiveForBSS = true;
 
   //===--- Global Variable Emission Directives --------------------------===//
   HasAggressiveSymbolFolding = true;
   COMMDirectiveAlignmentIsInBytes = false;
-  HasDotTypeDotSizeDirective = false;
   HasNoDeadStrip = true;
   WeakRefDirective = ".weakref\t";
   //===--- Dwarf Emission Directives -----------------------------------===//
   SupportsDebugInformation = true;
 }

test/MC/AMDGPU/hsa.s

 // RUN: llvm-mc -triple amdgcn--amdhsa -mcpu=kaveri -show-encoding %s | FileCheck %s --check-prefix=ASM
-// RUN: llvm-mc -filetype=obj -triple amdgcn--amdhsa -mcpu=kaveri -show-encoding %s | llvm-readobj -s -sd | FileCheck %s --check-prefix=ELF
+// RUN: llvm-mc -filetype=obj -triple amdgcn--amdhsa -mcpu=kaveri -show-encoding %s | llvm-readobj -symbols -s -sd | FileCheck %s --check-prefix=ELF
 
 // ELF: SHT_NOTE
 // ELF: 0000: 04000000 08000000 01000000 414D4400
 // ELF: 0010: 01000000 00000000 04000000 1B000000
 // ELF: 0020: 03000000 414D4400 04000700 07000000
 // ELF: 0030: 00000000 00000000 414D4400 414D4447
 // ELF: 0040: 50550000
 
+// ELF: Symbol {
+// ELF: Name: amd_kernel_code_t_minimal
+// ELF: Type: AMDGPU_HSA_KERNEL (0xA)
+// ELF: }
+// ELF: Symbol {
+// ELF: Name: amd_kernel_code_t_test_all
+// ELF: Type: AMDGPU_HSA_KERNEL (0xA)
+// ELF: }
+
 .hsa_code_object_version 1,0
 // ASM: .hsa_code_object_version 1,0
 
 .hsa_code_object_isa 7,0,0,"AMD","AMDGPU"
 // ASM: .hsa_code_object_isa 7,0,0,"AMD","AMDGPU"
 
+.type amd_kernel_code_t_test_all,STT_AMDGPU_HSA_KERNEL
+.type amd_kernel_code_t_minimal,@amdgpu_hsa_kernel
+
 .text
 amd_kernel_code_t_test_all:
 ; Test all amd_kernel_code_t members with non-default values.
 .amd_kernel_code_t
   kernel_code_version_major = 100
   kernel_code_version_minor = 100
   machine_kind = 0
   machine_version_major = 5