address feedback

Signed-off-by: Sarnie, Nick <[email protected]>

Author: sarnex

clang/include/clang/Basic/Attr.td

@@ -191,7 +191,8 @@ def FunctionPointer : SubsetSubject<DeclBase,
 
 def OpenCLKernelFunction
     : SubsetSubject<Function, [{S->getASTContext().getLangOpts().OpenCL &&
-                               S->hasAttr<DeviceKernelAttr>()}],
+                               DeviceKernelAttr::isOpenCLSpelling(
+			                 S->getAttr<DeviceKernelAttr>()}],
                                "kernel functions">;
 
 // HasFunctionProto is a more strict version of FunctionLike, so it should
@@ -1556,18 +1557,38 @@ def DeviceKernel : DeclOrTypeAttr {
              A.getAttributeSpellingListIndex() == CXX11_clang_amdgpu_kernel ||
              A.getAttributeSpellingListIndex() == C23_clang_amdgpu_kernel;
     }
+    static inline bool isAMDGPUSpelling(const AttributeCommonInfo* A) {
+      if(!A) return false;
+      return isAMDGPUSpelling(*A);
+    }
     static inline bool isNVPTXSpelling(const AttributeCommonInfo& A) {
       return A.getAttributeSpellingListIndex() == GNU_nvptx_kernel ||
              A.getAttributeSpellingListIndex() == CXX11_clang_nvptx_kernel ||
              A.getAttributeSpellingListIndex() == C23_clang_nvptx_kernel;
     }
+    static inline bool isNVPTXSpelling(const AttributeCommonInfo* A) {
+      if(!A) return false;
+      return isNVPTXSpelling(*A);
+    }
     static inline bool isSYCLSpelling(const AttributeCommonInfo& A) {
       return A.getAttributeSpellingListIndex() == GNU_sycl_kernel ||
              A.getAttributeSpellingListIndex() == CXX11_clang_sycl_kernel ||
              A.getAttributeSpellingListIndex() == C23_clang_sycl_kernel;
     }
+    static inline bool isSYCLSpelling(const AttributeCommonInfo* A) {
+      if(!A) return false;
+      return isSYCLSpelling(*A);
+    }
     static inline bool isOpenCLSpelling(const AttributeCommonInfo& A) {
-      return A.getAttributeSpellingListIndex() == Keyword_kernel;
+    // Tablegen trips underscores from spellings to build the spelling
+    // list, but here we have the same spelling with unscores and without,
+    // so handle that case manually.
+      return A.getAttributeSpellingListIndex() == Keyword_kernel ||
+      A.getAttrName()->getName() == "kernel";
+    }
+    static inline bool isOpenCLSpelling(const AttributeCommonInfo* A) {
+    if (!A) return false;
+    return isOpenCLSpelling(*A);
     }
 }];
 }

clang/lib/AST/Decl.cpp

@@ -3541,7 +3541,7 @@ bool FunctionDecl::isExternC() const {
 }
 
 bool FunctionDecl::isInExternCContext() const {
-  if (hasAttr<DeviceKernelAttr>() && getASTContext().getLangOpts().OpenCL)
+  if (DeviceKernelAttr::isOpenCLSpelling(getAttr<DeviceKernelAttr>()))
     return true;
   return getLexicalDeclContext()->isExternCContext();
 }
@@ -5510,7 +5510,8 @@ FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) {
 }
 
 bool FunctionDecl::isReferenceableKernel() const {
-  return hasAttr<CUDAGlobalAttr>() || hasAttr<DeviceKernelAttr>();
+  return hasAttr<CUDAGlobalAttr>() ||
+         DeviceKernelAttr::isOpenCLSpelling(getAttr<DeviceKernelAttr>());
 }
 
 BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {

clang/lib/AST/ItaniumMangle.cpp

@@ -1556,8 +1556,8 @@ void CXXNameMangler::mangleUnqualifiedName(
           FD && FD->hasAttr<CUDAGlobalAttr>() &&
           GD.getKernelReferenceKind() == KernelReferenceKind::Stub;
       bool IsOCLDeviceStub =
-          getASTContext().getLangOpts().OpenCL && FD &&
-          FD->hasAttr<DeviceKernelAttr>() &&
+          FD &&
+          DeviceKernelAttr::isOpenCLSpelling(FD->getAttr<DeviceKernelAttr>()) &&
           GD.getKernelReferenceKind() == KernelReferenceKind::Stub;
       if (IsDeviceStub)
         mangleDeviceStubName(II);

clang/lib/AST/MicrosoftMangle.cpp

@@ -1164,8 +1164,9 @@ void MicrosoftCXXNameMangler::mangleUnqualifiedName(GlobalDecl GD,
                   ->hasAttr<CUDAGlobalAttr>())) &&
             GD.getKernelReferenceKind() == KernelReferenceKind::Stub;
         bool IsOCLDeviceStub =
-            getASTContext().getLangOpts().OpenCL && ND &&
-            isa<FunctionDecl>(ND) && ND->hasAttr<DeviceKernelAttr>() &&
+            ND && isa<FunctionDecl>(ND) &&
+            DeviceKernelAttr::isOpenCLSpelling(
+                ND->getAttr<DeviceKernelAttr>()) &&
             GD.getKernelReferenceKind() == KernelReferenceKind::Stub;
         if (IsDeviceStub)
           mangleSourceName(

clang/lib/CodeGen/CGCall.cpp

@@ -539,7 +539,7 @@ CodeGenTypes::arrangeFunctionDeclaration(const GlobalDecl GD) {
   assert(isa<FunctionType>(FTy));
   setCUDAKernelCallingConvention(FTy, CGM, FD);
 
-  if (getContext().getLangOpts().OpenCL && FD->hasAttr<DeviceKernelAttr>() &&
+  if (DeviceKernelAttr::isOpenCLSpelling(FD->getAttr<DeviceKernelAttr>()) &&
       GD.getKernelReferenceKind() == KernelReferenceKind::Stub) {
     const FunctionType *FT = FTy->getAs<FunctionType>();
     CGM.getTargetCodeGenInfo().setOCLKernelStubCallingConvention(FT);
@@ -2535,7 +2535,8 @@ void CodeGenModule::ConstructAttributeList(StringRef Name,
                                  NumElemsParam);
     }
 
-    if (getLangOpts().OpenCL && TargetDecl->hasAttr<DeviceKernelAttr>() &&
+    if (DeviceKernelAttr::isOpenCLSpelling(
+            TargetDecl->getAttr<DeviceKernelAttr>()) &&
         CallingConv != CallingConv::CC_C &&
         CallingConv != CallingConv::CC_SpirFunction) {
       // Check CallingConv to avoid adding uniform-work-group-size attribute to
@@ -2918,8 +2919,10 @@ void CodeGenModule::ConstructAttributeList(StringRef Name,
     // > For arguments to a __kernel function declared to be a pointer to a
     // > data type, the OpenCL compiler can assume that the pointee is always
     // > appropriately aligned as required by the data type.
-    if (getLangOpts().OpenCL && TargetDecl &&
-        TargetDecl->hasAttr<DeviceKernelAttr>() && ParamType->isPointerType()) {
+    if (TargetDecl &&
+        DeviceKernelAttr::isOpenCLSpelling(
+            TargetDecl->getAttr<DeviceKernelAttr>()) &&
+        ParamType->isPointerType()) {
       QualType PTy = ParamType->getPointeeType();
       if (!PTy->isIncompleteType() && PTy->isConstantSizeType()) {
         llvm::Align Alignment =

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -1588,7 +1588,8 @@ void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
     // Implicit copy-assignment gets the same special treatment as implicit
     // copy-constructors.
     emitImplicitAssignmentOperatorBody(Args);
-  } else if (getLangOpts().OpenCL && FD->hasAttr<DeviceKernelAttr>() &&
+  } else if (DeviceKernelAttr::isOpenCLSpelling(
+                 FD->getAttr<DeviceKernelAttr>()) &&
              GD.getKernelReferenceKind() == KernelReferenceKind::Kernel) {
     CallArgList CallArgs;
     for (unsigned i = 0; i < Args.size(); ++i) {

clang/lib/CodeGen/CodeGenModule.cpp

@@ -1912,8 +1912,9 @@ static std::string getMangledNameImpl(CodeGenModule &CGM, GlobalDecl GD,
     } else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
                GD.getKernelReferenceKind() == KernelReferenceKind::Stub) {
       Out << "__device_stub__" << II->getName();
-    } else if (FD && FD->hasAttr<DeviceKernelAttr>() &&
-               CGM.getLangOpts().OpenCL &&
+    } else if (FD &&
+               DeviceKernelAttr::isOpenCLSpelling(
+                   FD->getAttr<DeviceKernelAttr>()) &&
                GD.getKernelReferenceKind() == KernelReferenceKind::Stub) {
       Out << "__clang_ocl_kern_imp_" << II->getName();
     } else {
@@ -6178,7 +6179,7 @@ void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
                           (CodeGenOpts.OptimizationLevel == 0) &&
                           !D->hasAttr<MinSizeAttr>();
 
-  if (getLangOpts().OpenCL && D->hasAttr<DeviceKernelAttr>()) {
+  if (DeviceKernelAttr::isOpenCLSpelling(D->getAttr<DeviceKernelAttr>())) {
     if (GD.getKernelReferenceKind() == KernelReferenceKind::Stub &&
         !D->hasAttr<NoInlineAttr>() &&
         !Fn->hasFnAttribute(llvm::Attribute::NoInline) &&