Merge from 'sycl' to 'sycl-web'

Author: iclsrc

.github/CODEOWNERS

@@ -99,6 +99,10 @@ llvm/**/file-table-tform/ @kbobrovs @AlexeySachkov
 llvm/**/llvm-foreach/ @AlexeySachkov  @Fznamznon
 llvm/**/llvm-no-spir-kernel/ @AGindinson @AlexeySachkov
 llvm/**/sycl-post-link/ @kbobrovs @AlexeySachkov
+llvm/include/llvm/Support/PropertySetIO.h @kbobrovs @AlexeySachkov
+llvm/lib/Support/PropertySetIO.cpp @kbobrovs @AlexeySachkov
+llvm/unittests/Support/PropertySetIOTest.cpp @kbobrovs @AlexeySachkov
+llvm/lib/Support/Base64.cpp @kbobrovs @AlexeySachkov
 
 # Clang offload tools
 clang/tools/clang-offload-bundler/ @kbobrovs @sndmitriev

buildbot/dependency.conf

@@ -4,8 +4,8 @@ ocl_cpu_rt_ver=2020.11.11.0.04
 # https://github.com/intel/llvm/releases/download/2020-WW45/win-oclcpuexp-2020.11.11.0.04_rel.zip
 ocl_cpu_rt_ver_win=2020.11.11.0.04
 # Same GPU driver supports Level Zero and OpenCL
-# https://github.com/intel/compute-runtime/releases/tag/21.02.18820
-ocl_gpu_rt_ver=21.02.18820
+# https://github.com/intel/compute-runtime/releases/tag/21.03.18857
+ocl_gpu_rt_ver=21.03.18857
 # Same GPU driver supports Level Zero and OpenCL
 # https://downloadmirror.intel.com/30066/a08/igfx_win10_100.9030.zip
 ocl_gpu_rt_ver_win=27.20.100.9030
@@ -30,7 +30,7 @@ ocloc_ver_win=27.20.100.8935
 [DRIVER VERSIONS]
 cpu_driver_lin=2020.11.11.0.04
 cpu_driver_win=2020.11.11.0.04
-gpu_driver_lin=21.02.18820
+gpu_driver_lin=21.03.18857
 gpu_driver_win=27.20.100.9030
 fpga_driver_lin=2020.11.11.0.04
 fpga_driver_win=2020.11.11.0.04

clang/include/clang/Basic/AttrDocs.td

@@ -2199,7 +2199,7 @@ attribute was applied. This effect is equivalent to annotating restrict on
 **all** kernel pointer arguments in an OpenCL or SPIR-V kernel.
 
 If ``intel::kernel_args_restrict`` is applied to a function called from a device
-kernel, the attribute is ignored and it is not propagated to a kernel.
+kernel, the attribute is not ignored and it is propagated to the kernel.
 
 The attribute forms an unchecked assertion, in that implementations
 do not need to check/confirm the pre-condition in any way. If a user applies
@@ -2229,7 +2229,7 @@ def SYCLIntelNumSimdWorkItemsAttrDocs : Documentation {
 Applies to a device function/lambda function. Indicates the number of work
 items that should be processed in parallel. Valid values are positive integers.
 If ``intel::num_simd_work_items`` is applied to a function called from a
-device kernel, the attribute is ignored and it is not propagated to a kernel.
+device kernel, the attribute is not ignored and it is propagated to the kernel.
   }];
 }
 
@@ -2243,7 +2243,7 @@ clusters handle stalls using a stall-enable signal to freeze computation
 within the cluster. This attribute is ignored on the host.
 
 If ``intel::use_stall_enable_clusters`` is applied to a function called from a device
-kernel, the attribute is ignored and it is not propagated to a kernel.
+kernel, the attribute is ignored and it is not propagated to the kernel.
 
 The ``intel::use_stall_enable_clusters`` attribute takes no argument and has an effect
 when applied to a function, and no effect otherwise.
@@ -2305,7 +2305,7 @@ of a work group. Values must be positive integers. This is similar to
 reqd_work_group_size, but allows work groups that are smaller or equal to the
 specified sizes.
 If ``intel::max_work_group_size`` is applied to a function called from a
-device kernel, the attribute is ignored and it is not propagated to a kernel.
+device kernel, the attribute is not ignored and it is propagated to the kernel.
   }];
 }
 
@@ -2321,7 +2321,7 @@ range of [0, 3]. A kernel with max_global_work_dim(0) must be invoked with a
 ``cl::reqd_work_group_size`` are applied to the kernel as well - they shall
 have arguments of (1, 1, 1).
 If ``intel::max_global_work_dim`` is applied to a function called from a
-device kernel, the attribute is ignored and it is not propagated to a kernel.
+device kernel, the attribute is not ignored and it is propagated to the kernel.
   }];
 }
 

clang/test/CodeGenSYCL/intel-max-global-work-dim.cpp

@@ -16,6 +16,9 @@ class Functor {
   [[intel::max_global_work_dim(SIZE)]] void operator()() const {}
 };
 
+template <int N>
+[[intel::max_global_work_dim(N)]] void func() {}
+
 int main() {
   q.submit([&](handler &h) {
     Foo boo;
@@ -26,12 +29,17 @@ int main() {
 
     Functor<2> f;
     h.single_task<class kernel_name3>(f);
+
+    h.single_task<class kernel_name4>([]() {
+      func<2>();
+    });
   });
   return 0;
 }
 
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name1"() #0 {{.*}} !max_global_work_dim ![[NUM1:[0-9]+]]
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name2"() #0 {{.*}} !max_global_work_dim ![[NUM2:[0-9]+]]
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name3"() #0 {{.*}} !max_global_work_dim ![[NUM2]]
+// CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name4"() #0 {{.*}} !max_global_work_dim ![[NUM2]]
 // CHECK: ![[NUM1]] = !{i32 1}
 // CHECK: ![[NUM2]] = !{i32 2}

clang/test/CodeGenSYCL/num-simd-work-items.cpp

@@ -16,6 +16,9 @@ class Functor {
   [[intel::num_simd_work_items(SIZE)]] void operator()() const {}
 };
 
+template <int N>
+[[intel::num_simd_work_items(N)]] void func() {}
+
 int main() {
   q.submit([&](handler &h) {
     Foo boo;
@@ -26,13 +29,19 @@ int main() {
 
     Functor<2> f;
     h.single_task<class kernel_name3>(f);
+
+    h.single_task<class kernel_name4>([]() {
+      func<4>();
+    });
   });
   return 0;
 }
 
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name1"() #0 {{.*}} !num_simd_work_items ![[NUM1:[0-9]+]]
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name2"() #0 {{.*}} !num_simd_work_items ![[NUM42:[0-9]+]]
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name3"() #0 {{.*}} !num_simd_work_items ![[NUM2:[0-9]+]]
+// CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name4"() #0 {{.*}} !num_simd_work_items ![[NUM4:[0-9]+]]
 // CHECK: ![[NUM1]] = !{i32 1}
 // CHECK: ![[NUM42]] = !{i32 42}
 // CHECK: ![[NUM2]] = !{i32 2}
+// CHECK: ![[NUM4]] = !{i32 4}

clang/test/CodeGenSYCL/reqd-sub-group-size.cpp

@@ -25,6 +25,9 @@ class Functor2 {
   [[intel::reqd_sub_group_size(SIZE)]] void operator()() const {}
 };
 
+template <int N>
+[[intel::reqd_sub_group_size(N)]] void func() {}
+
 int main() {
   q.submit([&](handler &h) {
     Functor16 f16;
@@ -38,6 +41,10 @@ int main() {
 
     Functor2<2> f2;
     h.single_task<class kernel_name4>(f2);
+
+    h.single_task<class kernel_name5>([]() {
+      func<2>();
+    });
   });
   return 0;
 }
@@ -46,6 +53,7 @@ int main() {
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name2"() #0 {{.*}} !intel_reqd_sub_group_size ![[SGSIZE8:[0-9]+]]
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name3"() #0 {{.*}} !intel_reqd_sub_group_size ![[SGSIZE4:[0-9]+]]
 // CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name4"() #0 {{.*}} !intel_reqd_sub_group_size ![[SGSIZE2:[0-9]+]]
+// CHECK: define {{.*}}spir_kernel void @{{.*}}kernel_name5"() #0 {{.*}} !intel_reqd_sub_group_size ![[SGSIZE2]]
 // CHECK: ![[SGSIZE16]] = !{i32 16}
 // CHECK: ![[SGSIZE8]] = !{i32 8}
 // CHECK: ![[SGSIZE4]] = !{i32 4}

clang/test/SemaSYCL/sycl-device-intel-max-global-work-dim-template.cpp

@@ -2,6 +2,32 @@
 
 // Test that checkes template parameter support for 'max_global_work_dim' attribute on sycl device.
 
+// Test that checks wrong function template instantiation and ensures that the type
+// is checked properly when instantiating from the template definition.
+template <typename Ty>
+// expected-error@+1 2{{'max_global_work_dim' attribute requires an integer constant}}
+[[intel::max_global_work_dim(Ty{})]] void func() {}
+
+struct S {};
+void test() {
+  //expected-note@+1{{in instantiation of function template specialization 'func<S>' requested here}}
+  func<S>();
+  //expected-note@+1{{in instantiation of function template specialization 'func<float>' requested here}}
+  func<float>();
+  // no error expected
+  func<int>(); // OK
+}
+
+// Test that checks expression is not a constant expression.
+int foo();
+// expected-error@+1{{'max_global_work_dim' attribute requires an integer constant}}
+[[intel::max_global_work_dim(foo() + 1)]] void func1();
+
+// Test that checks expression is a constant expression.
+constexpr int bar() { return 0; }
+[[intel::max_global_work_dim(bar() + 2)]] void func2(); // OK
+
+// Test that checks template parameter support on member function of class template.
 template <int SIZE>
 class KernelFunctor {
 public:
@@ -23,3 +49,24 @@ int main() {
 // CHECK: SubstNonTypeTemplateParmExpr {{.*}}
 // CHECK-NEXT: NonTypeTemplateParmDecl {{.*}}
 // CHECK-NEXT: IntegerLiteral{{.*}}2{{$}}
+
+// Test that checks template parameter support on function.
+template <int N>
+// expected-error@+1{{'max_global_work_dim' attribute requires a non-negative integral compile time constant expression}}
+[[intel::max_global_work_dim(N)]] void func3() {}
+
+int check() {
+  // no error expected
+  func3<2>();
+  //expected-note@+1{{in instantiation of function template specialization 'func3<-1>' requested here}}
+  func3<-1>();
+  return 0;
+}
+
+// CHECK: FunctionTemplateDecl {{.*}} {{.*}} func3
+// CHECK: NonTypeTemplateParmDecl {{.*}} {{.*}} referenced 'int' depth 0 index 0 N
+// CHECK: FunctionDecl {{.*}} {{.*}} func3 'void ()'
+// CHECK: SYCLIntelMaxGlobalWorkDimAttr {{.*}}
+// CHECK: SubstNonTypeTemplateParmExpr {{.*}}
+// CHECK-NEXT: NonTypeTemplateParmDecl {{.*}}
+// CHECK-NEXT: IntegerLiteral{{.*}}2{{$}}

clang/test/SemaSYCL/sycl-device-intel-max-work-group-size-template.cpp

@@ -24,7 +24,7 @@ int foo();
 constexpr int bar() { return 0; }
 [[intel::max_work_group_size(bar() + 12, bar() + 12, bar() + 12)]] void func2(); // OK
 
-// Test that checks template parameter suppport on member function of class template.
+// Test that checks template parameter support on member function of class template.
 template <int SIZE, int SIZE1, int SIZE2>
 class KernelFunctor {
 public:

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

@@ -24,7 +24,7 @@ int foo();
 constexpr int bar() { return 0; }
 [[intel::reqd_work_group_size(bar() + 12, bar() + 12, bar() + 12)]] void func2(); // OK
 
-// Test that checks template parameter suppport on member function of class template.
+// Test that checks template parameter support on member function of class template.
 template <int SIZE, int SIZE1, int SIZE2>
 class KernelFunctor {
 public:

clang/test/SemaSYCL/sycl-device-num_simd_work_items-template.cpp

@@ -2,6 +2,33 @@
 
 // Test that checkes template parameter support for 'num_simd_work_items' attribute on sycl device.
 
+// Test that checks wrong function template instantiation and ensures that the type
+// is checked properly when instantiating from the template definition.
+template <typename Ty>
+// expected-error@+2{{'num_simd_work_items' attribute requires a positive integral compile time constant expression}}
+// expected-error@+1 2{{'num_simd_work_items' attribute requires an integer constant}}
+[[intel::num_simd_work_items(Ty{})]] void func() {}
+
+struct S {};
+void test() {
+  //expected-note@+1{{in instantiation of function template specialization 'func<S>' requested here}}
+  func<S>();
+  //expected-note@+1{{in instantiation of function template specialization 'func<float>' requested here}}
+  func<float>();
+  //expected-note@+1{{in instantiation of function template specialization 'func<int>' requested here}}
+  func<int>();
+}
+
+// Test that checks expression is not a constant expression.
+int foo();
+// expected-error@+1{{'num_simd_work_items' attribute requires an integer constant}}
+[[intel::num_simd_work_items(foo() + 12)]] void func1();
+
+// Test that checks expression is a constant expression.
+constexpr int bar() { return 0; }
+[[intel::num_simd_work_items(bar() + 12)]] void func2(); // OK
+
+// Test that checks template parameter support on member function of class template.
 template <int SIZE>
 class KernelFunctor {
 public:
@@ -14,6 +41,7 @@ int main() {
   KernelFunctor<-1>();
   // no error expected
   KernelFunctor<10>();
+  return 0;
 }
 
 // CHECK: ClassTemplateDecl {{.*}} {{.*}} KernelFunctor
@@ -23,3 +51,24 @@ int main() {
 // CHECK: SubstNonTypeTemplateParmExpr {{.*}}
 // CHECK-NEXT: NonTypeTemplateParmDecl {{.*}}
 // CHECK-NEXT: IntegerLiteral{{.*}}10{{$}}
+
+// Test that checks template parameter support on function.
+template <int N>
+// expected-error@+1{{'num_simd_work_items' attribute requires a positive integral compile time constant expression}}
+[[intel::num_simd_work_items(N)]] void func3() {}
+
+int check() {
+  // no error expected
+  func3<8>();
+  //expected-note@+1{{in instantiation of function template specialization 'func3<-1>' requested here}}
+  func3<-1>();
+  return 0;
+}
+
+// CHECK: FunctionTemplateDecl {{.*}} {{.*}} func3
+// CHECK: NonTypeTemplateParmDecl {{.*}} {{.*}} referenced 'int' depth 0 index 0 N
+// CHECK: FunctionDecl {{.*}} {{.*}} func3 'void ()'
+// CHECK: SYCLIntelNumSimdWorkItemsAttr {{.*}}
+// CHECK: SubstNonTypeTemplateParmExpr {{.*}}
+// CHECK-NEXT: NonTypeTemplateParmDecl {{.*}}
+// CHECK-NEXT: IntegerLiteral{{.*}}8{{$}}

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

@@ -2,6 +2,33 @@
 
 // Test that checkes template parameter support for 'reqd_sub_group_size' attribute on sycl device.
 
+// Test that checks wrong function template instantiation and ensures that the type
+// is checked properly when instantiating from the template definition.
+template <typename Ty>
+// expected-error@+2{{'reqd_sub_group_size' attribute requires a positive integral compile time constant expression}}
+// expected-error@+1 2{{'reqd_sub_group_size' attribute requires an integer constant}}
+[[intel::reqd_sub_group_size(Ty{})]] void func() {}
+
+struct S {};
+void test() {
+  //expected-note@+1{{in instantiation of function template specialization 'func<S>' requested here}}
+  func<S>();
+  //expected-note@+1{{in instantiation of function template specialization 'func<float>' requested here}}
+  func<float>();
+  //expected-note@+1{{in instantiation of function template specialization 'func<int>' requested here}}
+  func<int>();
+}
+
+// Test that checks expression is not a constant expression.
+int foo();
+// expected-error@+1{{'reqd_sub_group_size' attribute requires an integer constant}}
+[[intel::reqd_sub_group_size(foo() + 12)]] void func1();
+
+// Test that checks expression is a constant expression.
+constexpr int bar() { return 0; }
+[[intel::reqd_sub_group_size(bar() + 12)]] void func2(); // OK
+
+// Test that checks template parameter support on member function of class template.
 template <int SIZE>
 class KernelFunctor {
 public:
@@ -14,6 +41,7 @@ int main() {
   KernelFunctor<-1>();
   // no error expected
   KernelFunctor<10>();
+  return 0;
 }
 
 // CHECK: ClassTemplateDecl {{.*}} {{.*}} KernelFunctor
@@ -23,3 +51,24 @@ int main() {
 // CHECK: SubstNonTypeTemplateParmExpr {{.*}}
 // CHECK-NEXT: NonTypeTemplateParmDecl {{.*}}
 // CHECK-NEXT: IntegerLiteral{{.*}}10{{$}}
+
+// Test that checks template parameter support on function.
+template <int N>
+// expected-error@+1{{'reqd_sub_group_size' attribute requires a positive integral compile time constant expression}}
+[[intel::reqd_sub_group_size(N)]] void func3() {}
+
+int check() {
+  // no error expected
+  func3<12>();
+  //expected-note@+1{{in instantiation of function template specialization 'func3<-1>' requested here}}
+  func3<-1>();
+  return 0;
+}
+
+// CHECK: FunctionTemplateDecl {{.*}} {{.*}} func3
+// CHECK: NonTypeTemplateParmDecl {{.*}} {{.*}} referenced 'int' depth 0 index 0 N
+// CHECK: FunctionDecl {{.*}} {{.*}} func3 'void ()'
+// CHECK: IntelReqdSubGroupSizeAttr {{.*}}
+// CHECK: SubstNonTypeTemplateParmExpr {{.*}}
+// CHECK-NEXT: NonTypeTemplateParmDecl {{.*}}
+// CHECK-NEXT: IntegerLiteral{{.*}}12{{$}}

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

@@ -24,7 +24,7 @@ int foo();
 constexpr int bar() { return 0; }
 [[cl::reqd_work_group_size(bar() + 12, bar() + 12, bar() + 12)]] void func2(); // OK
 
-// Test that checks template parameter suppport on member function of class template.
+// Test that checks template parameter support on member function of class template.
 template <int SIZE, int SIZE1, int SIZE2>
 class KernelFunctor {
 public: