[OpenCL] Blocks are allowed to capture arrays in OpenCL 2.0 and higher.

[Anastasia]

I have created a bug to Khronos regarding this, but unfortunately I don't see it being progressed yet.
https://cvs.khronos.org/bugzilla/show_bug.cgi?id=15659

The problem here is that I am not sure we should deviate from the ObjC implementation because OpenCL blocks are largely taken from Clang ObjC implementation. My issue is in particular that it's not clear what the capture of array would mean and spec should either state it precisely or disallow using this feature at all to avoid costly operations. In ObjC community itself there were multiple interpretation of this in the past: http://lists.llvm.org/pipermail/cfe-dev/2016-March/047849.html

I am not sure we should go ahead with any implementation without further clarifications. I will ping the Khronos bug to see if the documentation can be improved.

I think this issue has been seen in the OpenCL conformance tests, but was fixed later on?

[Anastasia]

In D26794#598784, @Anastasia wrote:

I have created a bug to Khronos regarding this, but unfortunately I don't see it being progressed yet.
https://cvs.khronos.org/bugzilla/show_bug.cgi?id=15659

The problem here is that I am not sure we should deviate from the ObjC implementation because OpenCL blocks are largely taken from Clang ObjC implementation. My issue is in particular that it's not clear what the capture of array would mean and spec should either state it precisely or disallow using this feature at all to avoid costly operations. In ObjC community itself there were multiple interpretation of this in the past: http://lists.llvm.org/pipermail/cfe-dev/2016-March/047849.html

I am not sure we should go ahead with any implementation without further clarifications. I will ping the Khronos bug to see if the documentation can be improved.

I think this issue has been seen in the OpenCL conformance tests, but was fixed later on?

Sure. Do you have an access to revision with an update? I will ask to publish it online too.

lib/Sema/SemaExpr.cpp

13651

Can we do this consistently for all OpenCL (Not just v2.0)!

[echuraev]

Yes, I have an access to the new revision and I have read it.

[Anastasia]

lib/Sema/SemaExpr.cpp

13645

I think the comment should be updated.

test/SemaOpenCL/blocks_with_array.cl

9

Does this test anything different from the function foo below?

21

Can we check there is a memcpy here?

27

Can we CHECK-NOT memcpy?

30

Do we need this line as well?

lib/Sema/SemaExpr.cpp

static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *Var,
                                  const bool BuildAndDiagnose, 
                                  QualType &CaptureType,
                                  QualType &DeclRefType, 
                                  const bool Nested,
                                  Sema &S) {
   Expr *CopyExpr = nullptr;
   bool ByRef = false;
       
   // Blocks are not allowed to capture arrays.
-  if (CaptureType->isArrayType()) {
+  if (!S.getLangOpts().OpenCL && CaptureType->isArrayType()) {
     if (BuildAndDiagnose) {
       S.Diag(Loc, diag::err_ref_array_type);
       S.Diag(Var->getLocation(), diag::note_previous_decl) 
       << Var->getDeclName();
     }
     return false;
   }
 
   // Forbid the block-capture of autoreleasing variables.
   if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
     if (BuildAndDiagnose) {
       S.Diag(Loc, diag::err_arc_autoreleasing_capture)
         << /*block*/ 0;

test/SemaOpenCL/blocks_with_array.cl

+// RUN: %clang_cc1 -O0 -fblocks -triple spir64-unkown-unkown -emit-llvm %s -o -| FileCheck %s
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -triple spir64-unkown-unkown -emit-llvm %s -o -| FileCheck %s
+
+typedef int (^block_t)();
+
+int block_typedef_kernel(global int* res) {
+  int a[3] = {1, 2, 3};
+  block_t b = ^() {
+// CHECK:   %{{.*}} = getelementptr inbounds [3 x i32], [3 x i32] addrspace(4)* %{{.*}}, i64 0, i64 0
+    return a[0];
+  };
+  return b();
+}
+
+// CHECK: define spir_func void @foo()
+void foo() {
+  struct v {
+    int arr[2];
+  } s = {0, 1};
+  block_t bl1 = ^(){return s.arr[1];};
+// CHECK: define internal spir_func i32 @__foo_block_invoke(i8 addrspace(4)* %.block_descriptor)
+// CHECK:   %{{.*}} = getelementptr inbounds %struct.v, %struct.v addrspace(4)* %{{.*}}, i32 0, i32 0
+// CHECK:   %{{.*}} = getelementptr inbounds [2 x i32], [2 x i32] addrspace(4)* %{{.*}}, i64 0, i64 1
+  // array content copied into captured struct location
+  int arr[2] = {0, 1};
+  block_t bl2 = ^(){return arr[1];};
+// CHECK: define internal spir_func i32 @__foo_block_invoke_2(i8 addrspace(4)* %.block_descriptor)
+// CHECK:   %{{.*}} = getelementptr inbounds [2 x i32], [2 x i32] addrspace(4)* %{{.*}}, i64 0, i64 1
+  // array decayed to pointer while captured
+  s.arr[1] = arr[1] = 877;
+}