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