[SYCL] Support intel::reqd_work_group_size (fix intel#8)

Signed-off-by: Aleksander Fadeev <[email protected]>

Author: fadeeval

clang/include/clang/Basic/Attr.td

@@ -2415,16 +2415,9 @@ def NoDeref : TypeAttr {
 
 def ReqdWorkGroupSize : InheritableAttr {
   let Spellings = [GNU<"reqd_work_group_size">,
-                   CXX11<"cl","reqd_work_group_size">];
-  let Args = [UnsignedArgument<"XDim">, UnsignedArgument<"YDim">,
-              UnsignedArgument<"ZDim">];
-  let Subjects = SubjectList<[Function], ErrorDiag>;
-  let Documentation = [Undocumented];
-}
-
-def SYCLIntelReqdWorkGroupSize : InheritableAttr {
-  let Spellings = [CXX11<"intel","reqd_work_group_size">];
-  let Args = [IntArgument<"XDim">, DefaultIntArgument<"YDim", 1>,
+                   CXX11<"cl","reqd_work_group_size">, 
+                   CXX11<"intel","reqd_work_group_size">];
+  let Args = [UnsignedArgument<"XDim">, DefaultIntArgument<"YDim", 1>,
               DefaultIntArgument<"ZDim", 1>];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [Undocumented];

clang/include/clang/Basic/AttributeCommonInfo.h

@@ -160,7 +160,6 @@ class AttributeCommonInfo {
     auto ParsedAttr = getParsedKind();
     if (ParsedAttr == AT_SYCLIntelKernelArgsRestrict ||
         (ParsedAttr == AT_ReqdWorkGroupSize && isCXX11Attribute()) ||
-        (ParsedAttr == AT_SYCLIntelReqdWorkGroupSize && isCXX11Attribute()) ||
         (ParsedAttr == AT_IntelReqdSubGroupSize && isCXX11Attribute()) ||
         ParsedAttr == AT_SYCLIntelNumSimdWorkItems ||
         ParsedAttr == AT_SYCLIntelMaxWorkGroupSize ||

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -644,16 +644,6 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
     Fn->setMetadata("reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
   }
 
-  if (const SYCLIntelReqdWorkGroupSizeAttr *A =
-          FD->getAttr<SYCLIntelReqdWorkGroupSizeAttr>()) {
-    llvm::Metadata *AttrMDArgs[] = {
-        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
-        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
-        llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
-    Fn->setMetadata("reqd_work_group_size",
-                    llvm::MDNode::get(Context, AttrMDArgs));
-  }
-
   if (const IntelReqdSubGroupSizeAttr *A =
           FD->getAttr<IntelReqdSubGroupSizeAttr>()) {
     llvm::Metadata *AttrMDArgs[] = {

clang/lib/Sema/SemaDeclAttr.cpp

@@ -2890,9 +2890,6 @@ static bool checkWorkGroupSizeValues(Sema &S, Decl *D, const ParsedAttr &Attr,
     if (const auto *A = D->getAttr<ReqdWorkGroupSizeAttr>())
       Result &= checkZeroDim(A, A->getXDim(), A->getYDim(), A->getZDim());
     return Result;
-    if (const auto *A = D->getAttr<SYCLIntelReqdWorkGroupSizeAttr>())
-      Result &= checkZeroDim(A, A->getXDim(), A->getYDim(), A->getZDim());
-    return Result;
   }
 
   if (const auto *A = D->getAttr<SYCLIntelMaxGlobalWorkDimAttr>())
@@ -2916,14 +2913,6 @@ static bool checkWorkGroupSizeValues(Sema &S, Decl *D, const ParsedAttr &Attr,
       Result &= false;
     }
   }
-  if (const auto *A = D->getAttr<SYCLIntelReqdWorkGroupSizeAttr>()) {
-    if (!(WGSize[0] >= A->getXDim() && WGSize[1] >= A->getYDim() &&
-          WGSize[2] >= A->getZDim())) {
-      S.Diag(Attr.getLoc(), diag::err_conflicting_sycl_function_attributes)
-          << Attr << A->getSpelling();
-      Result &= false;
-    }
-  }
   return Result;
 }
 
@@ -2935,13 +2924,15 @@ static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
     return;
 
   uint32_t WGSize[3];
-  if (std::is_same<WorkGroupAttr, SYCLIntelReqdWorkGroupSizeAttr>::value) {
-    WGSize[1] = SYCLIntelReqdWorkGroupSizeAttr::DefaultYDim;
-    WGSize[2] = SYCLIntelReqdWorkGroupSizeAttr::DefaultZDim;
-  }
+  if (AL.getNormalizedFullName() == "intel::reqd_work_group_size") {
+    WGSize[1] = ReqdWorkGroupSizeAttr::DefaultYDim;
+    WGSize[2] = ReqdWorkGroupSizeAttr::DefaultZDim;
+  } else if (!checkAttributeNumArgs(S, AL, 3))
+    return;
+
   for (unsigned i = 0; i < 3; ++i) {
     if (i < AL.getNumArgs())
-      if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(i), WGSize[i], i,
+          if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(i), WGSize[i], i,
                                /*StrictlyUnsigned=*/true))
         return;
     if (WGSize[i] == 0) {
@@ -7677,9 +7668,6 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_ReqdWorkGroupSize:
     handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, AL);
     break;
-  case ParsedAttr::AT_SYCLIntelReqdWorkGroupSize:
-    handleWorkGroupSize<SYCLIntelReqdWorkGroupSizeAttr>(S, D, AL);
-    break;
   case ParsedAttr::AT_SYCLIntelMaxWorkGroupSize:
     handleWorkGroupSize<SYCLIntelMaxWorkGroupSizeAttr>(S, D, AL);
     break;
@@ -8182,9 +8170,6 @@ void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
       // diag::err_attribute_wrong_decl_type + ExpectedKernelFunction.
       Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
       D->setInvalidDecl();
-    } else if (const auto *A = D->getAttr<SYCLIntelReqdWorkGroupSizeAttr>()) {
-      Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
-      D->setInvalidDecl();
     } else if (const auto *A = D->getAttr<WorkGroupSizeHintAttr>()) {
       Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
       D->setInvalidDecl();

clang/lib/Sema/SemaSYCL.cpp

@@ -410,8 +410,6 @@ class MarkDeviceFunction : public RecursiveASTVisitor<MarkDeviceFunction> {
         Attrs.insert(A);
       if (auto *A = FD->getAttr<ReqdWorkGroupSizeAttr>())
         Attrs.insert(A);
-      if (auto *A = FD->getAttr<SYCLIntelReqdWorkGroupSizeAttr>())
-        Attrs.insert(A);
       // Allow the following kernel attributes only on lambda functions and
       // function objects that are called directly from a kernel (i.e. the one
       // passed to the parallel_for function). For all other cases,
@@ -1372,23 +1370,6 @@ void Sema::MarkDevice(void) {
           }
           break;
         }
-        case attr::Kind::SYCLIntelReqdWorkGroupSize: {
-          auto *Attr = cast<SYCLIntelReqdWorkGroupSizeAttr>(A);
-          if (auto *Existing = SYCLKernel->getAttr<SYCLIntelReqdWorkGroupSizeAttr>()) {
-            if (Existing->getXDim() != Attr->getXDim() ||
-                Existing->getYDim() != Attr->getYDim() ||
-                Existing->getZDim() != Attr->getZDim()) {
-              Diag(SYCLKernel->getLocation(),
-                   diag::err_conflicting_sycl_kernel_attributes);
-              Diag(Existing->getLocation(), diag::note_conflicting_attribute);
-              Diag(Attr->getLocation(), diag::note_conflicting_attribute);
-              SYCLKernel->setInvalidDecl();
-            }
-          } else {
-            SYCLKernel->addAttr(A);
-          }
-          break;
-        }
         case attr::Kind::SYCLIntelKernelArgsRestrict:
         case attr::Kind::SYCLIntelNumSimdWorkItems:
         case attr::Kind::SYCLIntelMaxGlobalWorkDim:

clang/test/SemaSYCL/intel-reqd-work-group-size.cpp

@@ -30,9 +30,16 @@ void bar() {
 [[intel::reqd_work_group_size(32, 32, 1)]] void f32x32x1() {} // expected-note {{conflicting attribute is here}}
 [[intel::reqd_work_group_size(32, 32, 32)]] void f32x32x32() {} // expected-note {{conflicting attribute is here}}
 
+#ifdef TRIGGER_ERROR
+class Functor32 {
+public:
+  [[cl::reqd_work_group_size(32)]] void operator()() {} // expected-error {{'reqd_work_group_size' attribute requires exactly 3 arguments}}
+};
+#endif
+
 class Functor16 {
 public:
-  [[intel::reqd_work_group_size(16, 1)]] void operator()() {}
+  [[intel::reqd_work_group_size(16)]] void operator()() {}
 };
 
 class Functor16x16x16 {
@@ -110,13 +117,13 @@ void bar() {
 }
 
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name1
-// CHECK: SYCLIntelReqdWorkGroupSizeAttr {{.*}}  1 1 16
+// CHECK: ReqdWorkGroupSizeAttr {{.*}}  1 1 16
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name2
-// CHECK: SYCLIntelReqdWorkGroupSizeAttr {{.*}} 1 1 4
+// CHECK: ReqdWorkGroupSizeAttr {{.*}} 1 1 4
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name3
-// CHECK: SYCLIntelReqdWorkGroupSizeAttr {{.*}} 16 16 16
+// CHECK: ReqdWorkGroupSizeAttr {{.*}} 16 16 16
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name4
 // CHECK: ReqdWorkGroupSizeAttr {{.*}} 128 128 128
 // CHECK: FunctionDecl {{.*}} {{.*}}kernel_name5
-// CHECK: SYCLIntelReqdWorkGroupSizeAttr {{.*}} 32 32 32
+// CHECK: ReqdWorkGroupSizeAttr {{.*}} 32 32 32
 #endif // __SYCL_DEVICE_ONLY__