[SYCL] Add template parameter support for intel_reqd_sub_group_size attribute

Signed-off-by: Soumi Manna <[email protected]>

Author: smanna12

clang/include/clang/Basic/Attr.td

@@ -1262,7 +1262,7 @@ def LoopUnrollHint : InheritableAttr {
 
 def IntelReqdSubGroupSize: InheritableAttr {
   let Spellings = [GNU<"intel_reqd_sub_group_size">, CXX11<"cl", "intel_reqd_sub_group_size">];
-  let Args = [UnsignedArgument<"SubGroupSize">];
+  let Args = [ExprArgument<"SubGroupSize">];
   let Subjects = SubjectList<[Function, CXXMethod], ErrorDiag>;
   let Documentation = [IntelReqdSubGroupSizeDocs];
   let LangOpts = [OpenCL, SYCLIsDevice, SYCLIsHost];

clang/include/clang/Sema/Sema.h

@@ -9917,6 +9917,11 @@ class Sema final {
 
   bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
 
+  // addIntelReqdSubGroupSizeAttr - Adds an intel_reqd_sub_group_size attribute
+  // to a particular declaration.
+  void addIntelReqdSubGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI,
+                                    Expr *E);
+
   //===--------------------------------------------------------------------===//
   // C++ Coroutines TS
   //

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -574,8 +574,14 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
 
   if (const IntelReqdSubGroupSizeAttr *A =
           FD->getAttr<IntelReqdSubGroupSizeAttr>()) {
+    llvm::APSInt ArgVal(32);
+    llvm::LLVMContext &Context = getLLVMContext();
+    bool IsValid = A->getSubGroupSize()->isIntegerConstantExpr(
+        ArgVal, FD->getASTContext());
+    assert(IsValid && "Not an integer constant expression");
+    (void)IsValid;
     llvm::Metadata *AttrMDArgs[] = {
-        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getSubGroupSize()))};
+        llvm::ConstantAsMetadata::get(Builder.getInt32(ArgVal.getSExtValue()))};
     Fn->setMetadata("intel_reqd_sub_group_size",
                     llvm::MDNode::get(Context, AttrMDArgs));
   }

clang/lib/Sema/SemaDeclAttr.cpp

@@ -2980,27 +2980,46 @@ static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
 }
 
 // Handles intel_reqd_sub_group_size.
+void Sema::addIntelReqdSubGroupSizeAttr(Decl *D,
+                                        const AttributeCommonInfo &Attr,
+                                        Expr *E) {
+  if (!E)
+    return;
+
+  if (!E->isInstantiationDependent()) {
+    llvm::APSInt ArgVal(32);
+    if (!E->isIntegerConstantExpr(ArgVal, getASTContext())) {
+      Diag(E->getExprLoc(), diag::err_attribute_argument_type)
+          << Attr.getAttrName() << AANT_ArgumentIntegerConstant
+          << E->getSourceRange();
+      return;
+    }
+    int32_t ArgInt = ArgVal.getSExtValue();
+    if (ArgInt < 0) {
+      Diag(E->getExprLoc(), diag::err_attribute_requires_positive_integer)
+          << Attr.getAttrName() << /*non-negative*/ 1;
+      return;
+    }
+    if (ArgInt == 0) {
+      Diag(E->getExprLoc(), diag::err_attribute_argument_is_zero)
+          << Attr.getAttrName() << 0;
+      return;
+    }
+  }
+
+  D->addAttr(::new (Context) IntelReqdSubGroupSizeAttr(Context, Attr, E));
+}
+
 static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (S.LangOpts.SYCLIsHost)
     return;
 
-  uint32_t SGSize;
-  const Expr *E = AL.getArgAsExpr(0);
-  if (!checkUInt32Argument(S, AL, E, SGSize))
-    return;
-  if (SGSize == 0) {
-    S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
-        << AL << E->getSourceRange();
-    return;
-  }
+  Expr *E = AL.getArgAsExpr(0);
 
-  IntelReqdSubGroupSizeAttr *Existing =
-      D->getAttr<IntelReqdSubGroupSizeAttr>();
-  if (Existing && Existing->getSubGroupSize() != SGSize)
+  if (D->getAttr<IntelReqdSubGroupSizeAttr>())
     S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
 
-  D->addAttr(::new (S.Context)
-                 IntelReqdSubGroupSizeAttr(S.Context, AL, SGSize));
+  S.addIntelReqdSubGroupSizeAttr(D, AL, E);
 }
 
 // Handles num_simd_work_items.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -579,6 +579,17 @@ static void instantiateSYCLIntelPipeIOAttr(
     S.addSYCLIntelPipeIOAttr(New, *Attr, Result.getAs<Expr>());
 }
 
+static void instantiateIntelReqdSubGroupSizeAttr(
+    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
+    const IntelReqdSubGroupSizeAttr *Attr, Decl *New) {
+  // The SubGroupSize expression is a constant expressions.
+  EnterExpressionEvaluationContext Unevaluated(
+      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+  ExprResult Result = S.SubstExpr(Attr->getSubGroupSize(), TemplateArgs);
+  if (!Result.isInvalid())
+    S.addIntelReqdSubGroupSizeAttr(New, *Attr, Result.getAs<Expr>());
+}
+
 void Sema::InstantiateAttrsForDecl(
     const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
     Decl *New, LateInstantiatedAttrVec *LateAttrs,
@@ -721,7 +732,12 @@ void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
       instantiateSYCLIntelPipeIOAttr(*this, TemplateArgs, SYCLIntelPipeIO, New);
       continue;
     }
-
+    if (const auto *IntelReqdSubGroupSize =
+            dyn_cast<IntelReqdSubGroupSizeAttr>(TmplAttr)) {
+      instantiateIntelReqdSubGroupSizeAttr(*this, TemplateArgs,
+                                           IntelReqdSubGroupSize, New);
+      continue;
+    }
     // Existing DLL attribute on the instantiation takes precedence.
     if (TmplAttr->getKind() == attr::DLLExport ||
         TmplAttr->getKind() == attr::DLLImport) {

clang/test/SemaSYCL/reqd-sub-group-size-device.cpp

@@ -49,8 +49,11 @@ void bar() {
 }
 
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name1
-// CHECK: IntelReqdSubGroupSizeAttr {{.*}} 16
+// CHECK: IntelReqdSubGroupSizeAttr {{.*}}
+// CHECK-NEXT: IntegerLiteral{{.*}}16{{$}}
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name2
-// CHECK: IntelReqdSubGroupSizeAttr {{.*}} 4
+// CHECK: IntelReqdSubGroupSizeAttr {{.*}}
+// CHECK-NEXT: IntegerLiteral{{.*}}4{{$}}
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name5
-// CHECK: IntelReqdSubGroupSizeAttr {{.*}} 2
+// CHECK: IntelReqdSubGroupSizeAttr {{.*}}
+// CHECK-NEXT: IntegerLiteral{{.*}}2{{$}}

clang/test/SemaSYCL/sycl-device-reqd-sub-group-size-template.cpp

@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsyntax-only -verify -pedantic %s
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsyntax-only -ast-dump -verify -pedantic %s | FileCheck %s
+
+// Test that checkes template parameter support for 'intel_reqd_sub_group_size' attribute on sycl device.
+
+template <int SIZE>
+class KernelFunctor {
+public:
+  //expected-error@+1{{'intel_reqd_sub_group_size' attribute requires a non-negative integral compile time constant expression}}
+  [[cl::intel_reqd_sub_group_size(SIZE)]] void operator()(){};
+
+  int main() {
+    //expected-note@+1{{in instantiation of template class 'KernelFunctor<-1>' requested here}}
+    KernelFunctor<-1>();
+    // no error expected
+    KernelFunctor<10>();
+  }
+
+  // CHECK: ClassTemplateDecl {{.*}} {{.*}} KernelFunctor
+  // CHECK: ClassTemplateSpecializationDecl {{.*}} {{.*}} class KernelFunctor definition
+  // CHECK: CXXRecordDecl {{.*}} {{.*}} implicit class KernelFunctor
+  // CHECK: IntelReqdSubGroupSizeAttr {{.*}}
+  // CHECK: SubstNonTypeTemplateParmExpr {{.*}}
+  // CHECK-NEXT: IntegerLiteral{{.*}}10{{$}}