1// RUN: %clang_cc1 %s -cl-std=CL2.0 -ffake-address-space-map -O0 -emit-llvm -o - -triple "spir-unknown-unknown" | FileCheck %s --check-prefix=COMMON --check-prefix=B32 2// RUN: %clang_cc1 %s -cl-std=CL2.0 -ffake-address-space-map -O0 -emit-llvm -o - -triple "spir64-unknown-unknown" | FileCheck %s --check-prefix=COMMON --check-prefix=B64 3 4#pragma OPENCL EXTENSION cl_khr_subgroups : enable 5 6typedef void (^bl_t)(local void *); 7typedef struct {int a;} ndrange_t; 8 9// For a block global variable, first emit the block literal as a global variable, then emit the block variable itself. 10// COMMON: [[BL_GLOBAL:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 11// COMMON: @block_G = addrspace(1) constant void (i8 addrspace(3)*) addrspace(4)* addrspacecast (void (i8 addrspace(3)*) addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BL_GLOBAL]] to void (i8 addrspace(3)*) addrspace(1)*) to void (i8 addrspace(3)*) addrspace(4)*) 12 13// For anonymous blocks without captures, emit block literals as global variable. 14// COMMON: [[BLG1:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 15// COMMON: [[BLG2:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 16// COMMON: [[BLG3:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 17// COMMON: [[BLG4:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 18// COMMON: [[BLG5:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 19// COMMON: [[BLG6:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 20// COMMON: [[BLG7:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 21// COMMON: [[BLG8:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 22// COMMON: [[BLG9:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 23// COMMON: [[BLG10:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 24// COMMON: [[BLG11:@__block_literal_global[^ ]*]] = internal addrspace(1) constant { i32, i32 } { i32 {{[0-9]+}}, i32 {{[0-9]+}} } 25 26// Emits block literal [[BL_GLOBAL]], invoke function [[INV_G]] and global block variable @block_G 27// COMMON: define internal spir_func void [[INV_G:.*]](i8 addrspace(4)* %{{.*}}, i8 addrspace(3)* %{{.*}}) 28const bl_t block_G = (bl_t) ^ (local void *a) {}; 29 30void callee(int id, __global int *out) { 31 out[id] = id; 32} 33 34// COMMON-LABEL: define spir_kernel void @device_side_enqueue(i32 addrspace(1)* %{{.*}}, i32 addrspace(1)* %b, i32 %i) 35kernel void device_side_enqueue(global int *a, global int *b, int i) { 36 // COMMON: %default_queue = alloca %opencl.queue_t* 37 queue_t default_queue; 38 // COMMON: %flags = alloca i32 39 unsigned flags = 0; 40 // COMMON: %ndrange = alloca %struct.ndrange_t 41 ndrange_t ndrange; 42 // COMMON: %clk_event = alloca %opencl.clk_event_t* 43 clk_event_t clk_event; 44 // COMMON: %event_wait_list = alloca %opencl.clk_event_t* 45 clk_event_t event_wait_list; 46 // COMMON: %event_wait_list2 = alloca [1 x %opencl.clk_event_t*] 47 clk_event_t event_wait_list2[] = {clk_event}; 48 49 // Emits block literal on stack and block kernel [[INVLK1]]. 50 // COMMON: [[NDR:%[a-z0-9]+]] = alloca %struct.ndrange_t, align 4 51 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 52 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 53 // B32: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block to void ()* 54 // B64: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i32 addrspace(1)*, i32 addrspace(1)*, i32 }>* %block to void ()* 55 // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast void ()* [[BL]] to i8 addrspace(4)* 56 // COMMON-LABEL: call i32 @__enqueue_kernel_basic( 57 // COMMON-SAME: %opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* byval [[NDR]]{{([0-9]+)?}}, 58 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVLK1:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 59 // COMMON-SAME: i8 addrspace(4)* [[BL_I8]]) 60 enqueue_kernel(default_queue, flags, ndrange, 61 ^(void) { 62 a[i] = b[i]; 63 }); 64 65 // Emits block literal on stack and block kernel [[INVLK2]]. 66 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 67 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 68 // COMMON: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %event_wait_list to %opencl.clk_event_t{{.*}}* addrspace(4)* 69 // COMMON: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)* 70 // COMMON: [[BL:%[0-9]+]] = bitcast <{ i32, i32, i32{{.*}}, i32{{.*}}, i32{{.*}} }>* %block3 to void ()* 71 // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast void ()* [[BL]] to i8 addrspace(4)* 72 // COMMON-LABEL: call i32 @__enqueue_kernel_basic_events 73 // COMMON-SAME: (%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}}* addrspace(4)* [[WAIT_EVNT]], %opencl.clk_event_t{{.*}}* addrspace(4)* [[EVNT]], 74 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVLK2:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 75 // COMMON-SAME: i8 addrspace(4)* [[BL_I8]]) 76 77 enqueue_kernel(default_queue, flags, ndrange, 2, &event_wait_list, &clk_event, 78 ^(void) { 79 a[i] = b[i]; 80 }); 81 82 // Emits global block literal [[BLG1]] and block kernel [[INVGK1]]. 83 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 84 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 85 // B32: %[[TMP:.*]] = alloca [1 x i32] 86 // B32: %[[TMP1:.*]] = getelementptr [1 x i32], [1 x i32]* %[[TMP]], i32 0, i32 0 87 // B32: store i32 256, i32* %[[TMP1]], align 4 88 // B64: %[[TMP:.*]] = alloca [1 x i64] 89 // B64: %[[TMP1:.*]] = getelementptr [1 x i64], [1 x i64]* %[[TMP]], i32 0, i32 0 90 // B64: store i64 256, i64* %[[TMP1]], align 8 91 // COMMON-LABEL: call i32 @__enqueue_kernel_varargs( 92 // COMMON-SAME: %opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* [[NDR]]{{([0-9]+)?}}, 93 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK1:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 94 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG1]] to i8 addrspace(1)*) to i8 addrspace(4)*), i32 1, 95 // B32-SAME: i32* %[[TMP1]]) 96 // B64-SAME: i64* %[[TMP1]]) 97 enqueue_kernel(default_queue, flags, ndrange, 98 ^(local void *p) { 99 return; 100 }, 101 256); 102 char c; 103 // Emits global block literal [[BLG2]] and block kernel [[INVGK2]]. 104 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 105 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 106 // B32: %[[TMP:.*]] = alloca [1 x i32] 107 // B32: %[[TMP1:.*]] = getelementptr [1 x i32], [1 x i32]* %[[TMP]], i32 0, i32 0 108 // B32: store i32 %{{.*}}, i32* %[[TMP1]], align 4 109 // B64: %[[TMP:.*]] = alloca [1 x i64] 110 // B64: %[[TMP1:.*]] = getelementptr [1 x i64], [1 x i64]* %[[TMP]], i32 0, i32 0 111 // B64: store i64 %{{.*}}, i64* %[[TMP1]], align 8 112 // COMMON-LABEL: call i32 @__enqueue_kernel_varargs( 113 // COMMON-SAME: %opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* [[NDR]]{{([0-9]+)?}}, 114 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK2:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 115 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG2]] to i8 addrspace(1)*) to i8 addrspace(4)*), i32 1, 116 // B32-SAME: i32* %[[TMP1]]) 117 // B64-SAME: i64* %[[TMP1]]) 118 enqueue_kernel(default_queue, flags, ndrange, 119 ^(local void *p) { 120 return; 121 }, 122 c); 123 124 // Emits global block literal [[BLG3]] and block kernel [[INVGK3]]. 125 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 126 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 127 // COMMON: [[AD:%arraydecay[0-9]*]] = getelementptr inbounds [1 x %opencl.clk_event_t*], [1 x %opencl.clk_event_t*]* %event_wait_list2, i32 0, i32 0 128 // COMMON: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** [[AD]] to %opencl.clk_event_t{{.*}}* addrspace(4)* 129 // COMMON: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)* 130 // B32: %[[TMP:.*]] = alloca [1 x i32] 131 // B32: %[[TMP1:.*]] = getelementptr [1 x i32], [1 x i32]* %[[TMP]], i32 0, i32 0 132 // B32: store i32 256, i32* %[[TMP1]], align 4 133 // B64: %[[TMP:.*]] = alloca [1 x i64] 134 // B64: %[[TMP1:.*]] = getelementptr [1 x i64], [1 x i64]* %[[TMP]], i32 0, i32 0 135 // B64: store i64 256, i64* %[[TMP1]], align 8 136 // COMMON-LABEL: call i32 @__enqueue_kernel_events_varargs 137 // COMMON-SAME: (%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}} [[WAIT_EVNT]], %opencl.clk_event_t{{.*}} [[EVNT]], 138 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK3:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 139 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG3]] to i8 addrspace(1)*) to i8 addrspace(4)*), i32 1, 140 // B32-SAME: i32* %[[TMP1]]) 141 // B64-SAME: i64* %[[TMP1]]) 142 enqueue_kernel(default_queue, flags, ndrange, 2, event_wait_list2, &clk_event, 143 ^(local void *p) { 144 return; 145 }, 146 256); 147 148 // Emits global block literal [[BLG4]] and block kernel [[INVGK4]]. 149 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 150 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 151 // COMMON: [[AD:%arraydecay[0-9]*]] = getelementptr inbounds [1 x %opencl.clk_event_t*], [1 x %opencl.clk_event_t*]* %event_wait_list2, i32 0, i32 0 152 // COMMON: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** [[AD]] to %opencl.clk_event_t{{.*}}* addrspace(4)* 153 // COMMON: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)* 154 // B32: %[[TMP:.*]] = alloca [1 x i32] 155 // B32: %[[TMP1:.*]] = getelementptr [1 x i32], [1 x i32]* %[[TMP]], i32 0, i32 0 156 // B32: store i32 %{{.*}}, i32* %[[TMP1]], align 4 157 // B64: %[[TMP:.*]] = alloca [1 x i64] 158 // B64: %[[TMP1:.*]] = getelementptr [1 x i64], [1 x i64]* %[[TMP]], i32 0, i32 0 159 // B64: store i64 %{{.*}}, i64* %[[TMP1]], align 8 160 // COMMON-LABEL: call i32 @__enqueue_kernel_events_varargs 161 // COMMON-SAME: (%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}}* addrspace(4)* [[WAIT_EVNT]], %opencl.clk_event_t{{.*}}* addrspace(4)* [[EVNT]], 162 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK4:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 163 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG4]] to i8 addrspace(1)*) to i8 addrspace(4)*), i32 1, 164 // B32-SAME: i32* %[[TMP1]]) 165 // B64-SAME: i64* %[[TMP1]]) 166 enqueue_kernel(default_queue, flags, ndrange, 2, event_wait_list2, &clk_event, 167 ^(local void *p) { 168 return; 169 }, 170 c); 171 172 long l; 173 // Emits global block literal [[BLG5]] and block kernel [[INVGK5]]. 174 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 175 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 176 // B32: %[[TMP:.*]] = alloca [1 x i32] 177 // B32: %[[TMP1:.*]] = getelementptr [1 x i32], [1 x i32]* %[[TMP]], i32 0, i32 0 178 // B32: store i32 %{{.*}}, i32* %[[TMP1]], align 4 179 // B64: %[[TMP:.*]] = alloca [1 x i64] 180 // B64: %[[TMP1:.*]] = getelementptr [1 x i64], [1 x i64]* %[[TMP]], i32 0, i32 0 181 // B64: store i64 %{{.*}}, i64* %[[TMP1]], align 8 182 // COMMON-LABEL: call i32 @__enqueue_kernel_varargs 183 // COMMON-SAME: (%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* [[NDR]]{{([0-9]+)?}}, 184 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK5:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 185 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG5]] to i8 addrspace(1)*) to i8 addrspace(4)*), i32 1, 186 // B32-SAME: i32* %[[TMP1]]) 187 // B64-SAME: i64* %[[TMP1]]) 188 enqueue_kernel(default_queue, flags, ndrange, 189 ^(local void *p) { 190 return; 191 }, 192 l); 193 194 // Emits global block literal [[BLG6]] and block kernel [[INVGK6]]. 195 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 196 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 197 // B32: %[[TMP:.*]] = alloca [3 x i32] 198 // B32: %[[TMP1:.*]] = getelementptr [3 x i32], [3 x i32]* %[[TMP]], i32 0, i32 0 199 // B32: store i32 1, i32* %[[TMP1]], align 4 200 // B32: %[[TMP2:.*]] = getelementptr [3 x i32], [3 x i32]* %[[TMP]], i32 0, i32 1 201 // B32: store i32 2, i32* %[[TMP2]], align 4 202 // B32: %[[TMP3:.*]] = getelementptr [3 x i32], [3 x i32]* %[[TMP]], i32 0, i32 2 203 // B32: store i32 4, i32* %[[TMP3]], align 4 204 // B64: %[[TMP:.*]] = alloca [3 x i64] 205 // B64: %[[TMP1:.*]] = getelementptr [3 x i64], [3 x i64]* %[[TMP]], i32 0, i32 0 206 // B64: store i64 1, i64* %[[TMP1]], align 8 207 // B64: %[[TMP2:.*]] = getelementptr [3 x i64], [3 x i64]* %[[TMP]], i32 0, i32 1 208 // B64: store i64 2, i64* %[[TMP2]], align 8 209 // B64: %[[TMP3:.*]] = getelementptr [3 x i64], [3 x i64]* %[[TMP]], i32 0, i32 2 210 // B64: store i64 4, i64* %[[TMP3]], align 8 211 // COMMON-LABEL: call i32 @__enqueue_kernel_varargs 212 // COMMON-SAME: (%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* [[NDR]]{{([0-9]+)?}}, 213 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK6:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 214 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG6]] to i8 addrspace(1)*) to i8 addrspace(4)*), i32 3, 215 // B32-SAME: i32* %[[TMP1]]) 216 // B64-SAME: i64* %[[TMP1]]) 217 enqueue_kernel(default_queue, flags, ndrange, 218 ^(local void *p1, local void *p2, local void *p3) { 219 return; 220 }, 221 1, 2, 4); 222 223 // Emits global block literal [[BLG7]] and block kernel [[INVGK7]]. 224 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t*, %opencl.queue_t** %default_queue 225 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 226 // B32: %[[TMP:.*]] = alloca [1 x i32] 227 // B32: %[[TMP1:.*]] = getelementptr [1 x i32], [1 x i32]* %[[TMP]], i32 0, i32 0 228 // B32: store i32 0, i32* %[[TMP1]], align 4 229 // B64: %[[TMP:.*]] = alloca [1 x i64] 230 // B64: %[[TMP1:.*]] = getelementptr [1 x i64], [1 x i64]* %[[TMP]], i32 0, i32 0 231 // B64: store i64 4294967296, i64* %[[TMP1]], align 8 232 // COMMON-LABEL: call i32 @__enqueue_kernel_varargs 233 // COMMON-SAME: (%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* [[NDR]]{{([0-9]+)?}}, 234 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK7:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 235 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG7]] to i8 addrspace(1)*) to i8 addrspace(4)*), i32 1, 236 // B32-SAME: i32* %[[TMP1]]) 237 // B64-SAME: i64* %[[TMP1]]) 238 enqueue_kernel(default_queue, flags, ndrange, 239 ^(local void *p) { 240 return; 241 }, 242 4294967296L); 243 244 // Emits global block literal [[BLG8]] and invoke function [[INVG8]]. 245 // The full type of these expressions are long (and repeated elsewhere), so we 246 // capture it as part of the regex for convenience and clarity. 247 // COMMON: store void () addrspace(4)* addrspacecast (void () addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG8]] to void () addrspace(1)*) to void () addrspace(4)*), void () addrspace(4)** %block_A 248 void (^const block_A)(void) = ^{ 249 return; 250 }; 251 252 // Emits global block literal [[BLG9]] and invoke function [[INVG9]]. 253 // COMMON: store void (i8 addrspace(3)*) addrspace(4)* addrspacecast (void (i8 addrspace(3)*) addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG9]] to void (i8 addrspace(3)*) addrspace(1)*) to void (i8 addrspace(3)*) addrspace(4)*), void (i8 addrspace(3)*) addrspace(4)** %block_B 254 void (^const block_B)(local void *) = ^(local void *a) { 255 return; 256 }; 257 258 // Uses global block literal [[BLG8]] and invoke function [[INVG8]]. 259 // COMMON: call spir_func void [[INVG8:.*]](i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 260 block_A(); 261 262 // Emits global block literal [[BLG8]] and block kernel [[INVGK8]]. [[INVGK8]] calls [[INVG8]]. 263 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 264 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 265 // COMMON-LABEL: call i32 @__enqueue_kernel_basic( 266 // COMMON-SAME: %opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* byval [[NDR]]{{([0-9]+)?}}, 267 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK8:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 268 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 269 enqueue_kernel(default_queue, flags, ndrange, block_A); 270 271 // Uses block kernel [[INVGK8]] and global block literal [[BLG8]]. 272 // COMMON: call i32 @__get_kernel_work_group_size_impl( 273 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK8]] to i8*) to i8 addrspace(4)*), 274 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 275 unsigned size = get_kernel_work_group_size(block_A); 276 277 // Uses global block literal [[BLG8]] and invoke function [[INVG8]]. Make sure no redundant block literal and invoke functions are emitted. 278 // COMMON: call spir_func void [[INVG8]](i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 279 block_A(); 280 281 void (^block_C)(void) = ^{ 282 callee(i, a); 283 }; 284 285 // Emits block literal on stack and block kernel [[INVLK3]]. 286 // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue 287 // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags 288 // COMMON: [[BL_I8:%[0-9]+]] = addrspacecast void ()* {{.*}} to i8 addrspace(4)* 289 // COMMON-LABEL: call i32 @__enqueue_kernel_basic( 290 // COMMON-SAME: %opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %struct.ndrange_t* byval [[NDR]]{{([0-9]+)?}}, 291 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVLK3:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 292 // COMMON-SAME: i8 addrspace(4)* [[BL_I8]]) 293 enqueue_kernel(default_queue, flags, ndrange, block_C); 294 295 // Emits global block literal [[BLG9]] and block kernel [[INVGK9]]. [[INVGK9]] calls [[INVG9]]. 296 // COMMON: call i32 @__get_kernel_work_group_size_impl( 297 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK9:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 298 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG9]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 299 size = get_kernel_work_group_size(block_B); 300 301 // Uses global block literal [[BLG8]] and block kernel [[INVGK8]]. Make sure no redundant block literal ind invoke functions are emitted. 302 // COMMON: call i32 @__get_kernel_preferred_work_group_size_multiple_impl( 303 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK8]] to i8*) to i8 addrspace(4)*), 304 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG8]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 305 size = get_kernel_preferred_work_group_size_multiple(block_A); 306 307 // Uses global block literal [[BL_GLOBAL]] and block kernel [[INV_G_K]]. [[INV_G_K]] calls [[INV_G]]. 308 // COMMON: call i32 @__get_kernel_preferred_work_group_size_multiple_impl( 309 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INV_G_K:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 310 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BL_GLOBAL]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 311 size = get_kernel_preferred_work_group_size_multiple(block_G); 312 313 // Emits global block literal [[BLG10]] and block kernel [[INVGK10]]. 314 // COMMON: call i32 @__get_kernel_max_sub_group_size_for_ndrange_impl(%struct.ndrange_t* {{[^,]+}}, 315 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK10:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 316 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG10]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 317 size = get_kernel_max_sub_group_size_for_ndrange(ndrange, ^(){}); 318 319 // Emits global block literal [[BLG11]] and block kernel [[INVGK11]]. 320 // COMMON: call i32 @__get_kernel_sub_group_count_for_ndrange_impl(%struct.ndrange_t* {{[^,]+}}, 321 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8* bitcast ({{.*}} [[INVGK11:[^ ]+_kernel]] to i8*) to i8 addrspace(4)*), 322 // COMMON-SAME: i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32 } addrspace(1)* [[BLG11]] to i8 addrspace(1)*) to i8 addrspace(4)*)) 323 size = get_kernel_sub_group_count_for_ndrange(ndrange, ^(){}); 324} 325 326// COMMON: define internal spir_kernel void [[INVLK1]](i8 addrspace(4)*) #{{[0-9]+}} { 327// COMMON: entry: 328// COMMON: call void @__device_side_enqueue_block_invoke(i8 addrspace(4)* %0) 329// COMMON: ret void 330// COMMON: } 331// COMMON: define internal spir_kernel void [[INVLK2]](i8 addrspace(4)*{{.*}}) 332// COMMON: define internal spir_kernel void [[INVGK1]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}}) 333// COMMON: define internal spir_kernel void [[INVGK2]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}}) 334// COMMON: define internal spir_kernel void [[INVGK3]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}}) 335// COMMON: define internal spir_kernel void [[INVGK4]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}}) 336// COMMON: define internal spir_kernel void [[INVGK5]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}}) 337// COMMON: define internal spir_kernel void [[INVGK6]](i8 addrspace(4)*, i8 addrspace(3)*, i8 addrspace(3)*, i8 addrspace(3)*) #{{[0-9]+}} { 338// COMMON: entry: 339// COMMON: call void @__device_side_enqueue_block_invoke_8(i8 addrspace(4)* %0, i8 addrspace(3)* %1, i8 addrspace(3)* %2, i8 addrspace(3)* %3) 340// COMMON: ret void 341// COMMON: } 342// COMMON: define internal spir_kernel void [[INVGK7]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}}) 343// COMMON: define internal spir_func void [[INVG8]](i8 addrspace(4)*{{.*}}) 344// COMMON: define internal spir_func void [[INVG9:.*]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)* %{{.*}}) 345// COMMON: define internal spir_kernel void [[INVGK8]](i8 addrspace(4)*{{.*}}) 346// COMMON: define internal spir_kernel void [[INVLK3]](i8 addrspace(4)*{{.*}}) 347// COMMON: define internal spir_kernel void [[INVGK9]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}}) 348// COMMON: define internal spir_kernel void [[INV_G_K]](i8 addrspace(4)*{{.*}}, i8 addrspace(3)*{{.*}}) 349// COMMON: define internal spir_kernel void [[INVGK10]](i8 addrspace(4)*{{.*}}) 350// COMMON: define internal spir_kernel void [[INVGK11]](i8 addrspace(4)*{{.*}}) 351