Changes based on reviewer comments.

Author: rdeodhar

clang/lib/Sema/SemaDecl.cpp

@@ -16683,9 +16683,11 @@ Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
   if (FD && !FD->isDeleted())
     checkTypeSupport(FD->getType(), FD->getLocation(), FD);
 
-  // Handle non-templated free function.
+  // Handle free functions.
   if (LangOpts.SYCLIsDevice && FD->hasAttr<SYCLDeviceAttr>() && Body &&
-      !FD->isTemplated())
+      (FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate ||
+       FD->getTemplatedKind() ==
+           FunctionDecl::TK_FunctionTemplateSpecialization))
     ProcessFreeFunction(FD);
 
   return dcl;

clang/lib/Sema/SemaSYCL.cpp

@@ -1131,8 +1131,7 @@ static bool IsFreeFunction(Sema &SemaRef, const FunctionDecl *FD) {
         SmallVector<std::pair<std::string, std::string>, 4> NameValuePairs =
             AnAttr->getAttributeNameValuePairs(SemaRef.Context);
         for (const auto &NameValuePair : NameValuePairs) {
-          if (NameValuePair.first == "sycl-range-kernel" ||
-              NameValuePair.first == "sycl-nd-range-kernel" ||
+          if (NameValuePair.first == "sycl-nd-range-kernel" ||
               NameValuePair.first == "sycl-single-task-kernel")
             return true;
         }
@@ -1142,8 +1141,7 @@ static bool IsFreeFunction(Sema &SemaRef, const FunctionDecl *FD) {
   return false;
 }
 
-static std::string constructFFKernelName(ASTContext &Ctx,
-                                         const FunctionDecl *FD) {
+static std::string constructFFKernelName(const FunctionDecl *FD) {
   IdentifierInfo *Id = FD->getIdentifier();
   std::string NewIdent = (Twine("__free_function_") + Id->getName()).str();
   return NewIdent;
@@ -1152,18 +1150,18 @@ static std::string constructFFKernelName(ASTContext &Ctx,
 // Gets a name for the free function kernel function. The suffix allows a normal
 // device function to coexist with the kernel function.
 static std::pair<std::string, std::string>
-constructFreeFunctionKernelName(Sema &S, const FunctionDecl *KernelCallerFunc,
+constructFreeFunctionKernelName(Sema &S, const FunctionDecl *FreeFunc,
                                 MangleContext &MC) {
   SmallString<256> Result;
   llvm::raw_svector_ostream Out(Result);
   std::string MangledName;
   std::string StableName;
 
-  if (KernelCallerFunc->getTemplateSpecializationArgs()) {
-    MC.mangleName(KernelCallerFunc, Out);
+  if (FreeFunc->getTemplateSpecializationArgs()) {
+    MC.mangleName(FreeFunc, Out);
     MangledName = (Twine("__free_function") + Out.str()).str();
   } else {
-    MangledName = constructFFKernelName(S.getASTContext(), KernelCallerFunc);
+    MangledName = constructFFKernelName(FreeFunc);
   }
   StableName = MangledName;
   return {MangledName, StableName};
@@ -2759,7 +2757,7 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
     FunctionProtoType::ExtProtoInfo Info(CC_OpenCLKernel);
     QualType FuncType = Ctx.getFunctionType(Ctx.VoidTy, {}, Info);
     const IdentifierInfo *NewIdent =
-        &Ctx.Idents.get(constructFFKernelName(Ctx, FD));
+        &Ctx.Idents.get(constructFFKernelName(FD));
     FD = FunctionDecl::Create(
         Ctx, Ctx.getTranslationUnitDecl(), Loc, Loc, DeclarationName(NewIdent),
         FuncType, Ctx.getTrivialTypeSourceInfo(Ctx.VoidTy), SC_None);

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -7034,10 +7034,6 @@ void Sema::PerformPendingInstantiations(bool LocalOnly) {
           TUKind == TU_Prefix && Function->instantiationIsPending())
         delayedPCHInstantiations.push_back(Inst);
       continue;
-
-      // Handle SYCL free function.
-      if (LangOpts.SYCLIsDevice && Function->hasAttr<SYCLDeviceAttr>())
-        ProcessFreeFunction(Function);
     }
 
     // Instantiate variable definitions

clang/test/SemaSYCL/free_function_kernel_params.cpp

@@ -13,7 +13,7 @@ struct Simple {
 };
 
 __attribute__((sycl_device))
-[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 2)]]
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 0)]]
 void ff_2(int *ptr, int start, int end, struct Simple S) {
   for (int i = start; i <= end; i++)
     ptr[i] = start + S.x + S.f + S.c[2];
@@ -22,4 +22,23 @@ void ff_2(int *ptr, int start, int end, struct Simple S) {
 // CHECK-NEXT: ParmVarDecl {{.*}} _arg_ptr '__global int *'
 // CHECK-NEXT: ParmVarDecl {{.*}} _arg_start 'int'
 // CHECK-NEXT: ParmVarDecl {{.*}} _arg_end 'int'
-// CHECK-NEXT: ParmVarDecl {{.*}} _arg_S 'struct Simple':'Simple'
+// CHECK-NEXT: ParmVarDecl {{.*}} _arg_S 'struct Simple':'Simple'
+
+
+// Templated free function definition.
+template <typename T>
+__attribute__((sycl_device))
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 0)]]
+  void ff_3(T* ptr, T start, int end, struct Simple S) {
+    for (int i = start; i <= end; i++)
+      ptr[i] = start + S.x + S.f + S.c[2];
+}
+
+// Explicit instantiation with “int*”
+template void ff_3(int* ptr, int start, int end, struct Simple S);
+
+// CHECK: FunctionDecl {{.*}} __free_function_Z4ff_3IiEvPT_S0_i6Simple 'void (__global int *, int, int, struct Simple)'
+// CHECK-NEXT: ParmVarDecl {{.*}} _arg_ptr '__global int *'
+// CHECK-NEXT: ParmVarDecl {{.*}} _arg_start 'int'
+// CHECK-NEXT: ParmVarDecl {{.*}} _arg_end 'int'
+// CHECK-NEXT: ParmVarDecl {{.*}} _arg_S 'struct Simple':'Simple'