[SYCL] Add support for [[intel::reqd_sub_group_size()]] attribute (intel#2137)

This patch adds new spelling of IntelReqdSubGroupSize attribute
and generates a diagnostic which will tell that previous spelling
of the attribute is deprecated.

Signed-off-by: Soumi Manna <soumi.manna@intel.com>

Author: smanna12

clang/include/clang/Basic/Attr.td

@@ -1288,7 +1288,9 @@ def LoopUnrollHint : InheritableAttr {
 }
 
 def IntelReqdSubGroupSize: InheritableAttr {
-  let Spellings = [GNU<"intel_reqd_sub_group_size">, CXX11<"cl", "intel_reqd_sub_group_size">];
+  let Spellings = [GNU<"intel_reqd_sub_group_size">,
+                   CXX11<"cl", "intel_reqd_sub_group_size">,
+                   CXX11<"intel", "reqd_sub_group_size">];
   let Args = [ExprArgument<"SubGroupSize">];
   let Subjects = SubjectList<[Function, CXXMethod], ErrorDiag>;
   let Documentation = [IntelReqdSubGroupSizeDocs];

clang/include/clang/Basic/AttrDocs.td

@@ -3472,9 +3472,10 @@ code. See `cl_intel_required_subgroup_size
 for details.
 
 SYCL documentation:
-The [[cl::intel_reqd_sub_group_size(n)]] attribute indicates that the kernel
-must be compiled and executed with a sub-group of size n. The value of n must be
-set to a sub-group size supported by the device, or device compilation will fail.
+The [[cl::intel_reqd_sub_group_size(n)]] and [[intel::reqd_sub_group_size(n)]]
+attribute indicates that the kernel must be compiled and executed with a
+sub-group of size n. The value of n must be set to a sub-group size supported
+by the device, or device compilation will fail.
 
 In addition to device functions, the required sub-group size attribute may also
 be specified in the definition of a named functor object and lambda functions,
@@ -3495,6 +3496,19 @@ as in the examples below:
        /* kernel code */
   });
 
+  class Functor
+  {
+      [[intel::reqd_sub_group_size(16)]] void operator()(item<1> item)
+      {
+          /* kernel code */
+      }
+  }
+
+  kernel<class kernel_name>(
+  []() [[intel::reqd_sub_group_size(n)]] {
+       /* kernel code */
+  });
+
 See Sub-groups for NDRange Parallelism proposal in sycl/doc/extensions/sub_group_ndrange/sub_group_ndrange.md
   }];
 }

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10990,6 +10990,11 @@ def err_ivdep_declrefexpr_arg : Error<
 def warn_ivdep_redundant : Warning <"ignoring redundant Intel FPGA loop "
   "attribute 'ivdep': safelen %select{INF|%1}0 >= safelen %select{INF|%3}2">,
   InGroup<IgnoredAttributes>;
+def warn_attribute_spelling_deprecated : Warning<
+  "attribute %0 is deprecated">,
+  InGroup<DeprecatedAttributes>;
+def note_spelling_suggestion : Note<
+  "did you mean to use %0 instead?">;
 
 // errors of expect.with.probability
 def err_probability_not_constant_float : Error<

clang/lib/Sema/SemaDeclAttr.cpp

@@ -3014,6 +3014,13 @@ static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (D->getAttr<IntelReqdSubGroupSizeAttr>())
     S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
 
+  if (AL.getAttributeSpellingListIndex() ==
+      IntelReqdSubGroupSizeAttr::CXX11_cl_intel_reqd_sub_group_size) {
+    S.Diag(AL.getLoc(), diag::warn_attribute_spelling_deprecated) << AL;
+    S.Diag(AL.getLoc(), diag::note_spelling_suggestion)
+        << "'intel::reqd_sub_group_size'";
+  }
+
   S.addIntelReqdSubGroupSizeAttr(D, AL, E);
 }
 

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

@@ -1,22 +1,29 @@
 // RUN: %clang_cc1 -fsycl -fsycl-is-device -fsyntax-only -verify -DTRIGGER_ERROR %s
 // RUN: %clang_cc1 -fsycl -fsycl-is-device -ast-dump %s | FileCheck %s
 
-[[cl::intel_reqd_sub_group_size(4)]] void foo() {} // expected-note {{conflicting attribute is here}}
+[[intel::reqd_sub_group_size(4)]] void foo() {} // expected-note {{conflicting attribute is here}}
 // expected-note@-1 {{conflicting attribute is here}}
-[[cl::intel_reqd_sub_group_size(32)]] void baz() {} // expected-note {{conflicting attribute is here}}
+[[intel::reqd_sub_group_size(32)]] void baz() {} // expected-note {{conflicting attribute is here}}
 
 class Functor16 {
 public:
+  // expected-warning@+2 {{attribute 'intel_reqd_sub_group_size' is deprecated}}
+  // expected-note@+1 {{did you mean to use 'intel::reqd_sub_group_size' instead?}}
   [[cl::intel_reqd_sub_group_size(16)]] void operator()() {}
 };
 
 class Functor8 { // expected-error {{conflicting attributes applied to a SYCL kernel}}
 public:
-  [[cl::intel_reqd_sub_group_size(8)]] void operator()() { // expected-note {{conflicting attribute is here}}
+  [[intel::reqd_sub_group_size(8)]] void operator()() { // expected-note {{conflicting attribute is here}}
     foo();
   }
 };
 
+class Functor4 {
+public:
+  [[intel::reqd_sub_group_size(12)]] void operator()() {}
+};
+
 class Functor {
 public:
   void operator()() {
@@ -46,24 +53,31 @@ void bar() {
   });
 #endif
 
-  kernel<class kernel_name5>([]() [[cl::intel_reqd_sub_group_size(2)]] { });
-  kernel<class kernel_name6>([]() [[cl::intel_reqd_sub_group_size(4)]] { foo(); });
+  kernel<class kernel_name5>([]() [[intel::reqd_sub_group_size(2)]]{});
+  kernel<class kernel_name6>([]() [[intel::reqd_sub_group_size(4)]] { foo(); });
+  // expected-warning@+2 {{attribute 'intel_reqd_sub_group_size' is deprecated}}
+  // expected-note@+1 {{did you mean to use 'intel::reqd_sub_group_size' instead?}}
+  kernel<class kernel_name7>([]() [[cl::intel_reqd_sub_group_size(6)]]{});
+
+  Functor4 f4;
+  kernel<class kernel_name8>(f4);
 }
 
-[[cl::intel_reqd_sub_group_size(16)]] SYCL_EXTERNAL void B();
-[[cl::intel_reqd_sub_group_size(16)]] void A() {
+[[intel::reqd_sub_group_size(16)]] SYCL_EXTERNAL void B();
+[[intel::reqd_sub_group_size(16)]] void A() {
 }
-[[cl::intel_reqd_sub_group_size(16)]] SYCL_EXTERNAL void B() {
+
+[[intel::reqd_sub_group_size(16)]] SYCL_EXTERNAL void B() {
   A();
 }
 
 #ifdef TRIGGER_ERROR
 // expected-note@+1 {{conflicting attribute is here}}
-[[cl::intel_reqd_sub_group_size(2)]] void sg_size2() {}
+[[intel::reqd_sub_group_size(2)]] void sg_size2() {}
 
 // expected-note@+2 {{conflicting attribute is here}}
 // expected-error@+1 {{conflicting attributes applied to a SYCL kernel}}
-[[cl::intel_reqd_sub_group_size(4)]] __attribute__((sycl_device)) void sg_size4() {
+[[intel::reqd_sub_group_size(4)]] __attribute__((sycl_device)) void sg_size4() {
   sg_size2();
 }
 #endif
@@ -77,3 +91,9 @@ void bar() {
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name5
 // CHECK: IntelReqdSubGroupSizeAttr {{.*}}
 // CHECK-NEXT: IntegerLiteral{{.*}}2{{$}}
+// CHECK: FunctionDecl {{.*}} {{.*}}kernel_name7
+// CHECK: IntelReqdSubGroupSizeAttr {{.*}}
+// CHECK-NEXT: IntegerLiteral{{.*}}6{{$}}
+// CHECK: FunctionDecl {{.*}} {{.*}}kernel_name8
+// CHECK: IntelReqdSubGroupSizeAttr {{.*}}
+// CHECK-NEXT: IntegerLiteral{{.*}}12{{$}}

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

@@ -1,12 +1,12 @@
 // 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.
+// Test that checkes template parameter support for '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 positive integral compile time constant expression}}
-  [[cl::intel_reqd_sub_group_size(SIZE)]] void operator()() {}
+  // expected-error@+1{{'reqd_sub_group_size' attribute requires a positive integral compile time constant expression}}
+  [[intel::reqd_sub_group_size(SIZE)]] void operator()() {}
 };
 
 int main() {

clang/test/SemaSYCL/sycl-esimd.cpp

@@ -17,7 +17,7 @@ void kernel0(F f) __attribute__((sycl_kernel)) {
 }
 
 // expected-note@+1{{conflicting attribute is here}}
-[[cl::intel_reqd_sub_group_size(2)]] void g0() {}
+[[intel::reqd_sub_group_size(2)]] void g0() {}
 
 void test0() {
   // expected-error@+2{{conflicting attributes applied to a SYCL kernel}}