llvm/test/CodeGen/SPIRV/transcoding/enqueue_kernel.ll

   1 ; RUN: llc -O0 -mtriple=spirv32-unknown-unknown %s -o - | FileCheck %s --check-prefix=CHECK-SPIRV
   2 ; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv32-unknown-unknown %s -o - -filetype=obj | spirv-val %}
   3
   4 ; TODO(#60133): Requires updates following opaque pointer migration.
   5 ; XFAIL: *
   6
   7 ; CHECK-SPIRV: OpEntryPoint Kernel %[[#BlockKer1:]] "__device_side_enqueue_block_invoke_kernel"
   8 ; CHECK-SPIRV: OpEntryPoint Kernel %[[#BlockKer2:]] "__device_side_enqueue_block_invoke_2_kernel"
   9 ; CHECK-SPIRV: OpEntryPoint Kernel %[[#BlockKer3:]] "__device_side_enqueue_block_invoke_3_kernel"
  10 ; CHECK-SPIRV: OpEntryPoint Kernel %[[#BlockKer4:]] "__device_side_enqueue_block_invoke_4_kernel"
  11 ; CHECK-SPIRV: OpEntryPoint Kernel %[[#BlockKer5:]] "__device_side_enqueue_block_invoke_5_kernel"
  12 ; CHECK-SPIRV: OpName %[[#BlockGlb1:]] "__block_literal_global"
  13 ; CHECK-SPIRV: OpName %[[#BlockGlb2:]] "__block_literal_global.1"
  14
  15 ; CHECK-SPIRV: %[[#Int32Ty:]] = OpTypeInt 32
  16 ; CHECK-SPIRV: %[[#Int8Ty:]] = OpTypeInt 8
  17 ; CHECK-SPIRV: %[[#VoidTy:]] = OpTypeVoid
  18 ; CHECK-SPIRV: %[[#Int8PtrGenTy:]] = OpTypePointer Generic %[[#Int8Ty]]
  19 ; CHECK-SPIRV: %[[#EventTy:]] = OpTypeDeviceEvent
  20 ; CHECK-SPIRV: %[[#EventPtrTy:]] = OpTypePointer Generic %[[#EventTy]]
  21 ; CHECK-SPIRV: %[[#Int32LocPtrTy:]] = OpTypePointer Function %[[#Int32Ty]]
  22 ; CHECK-SPIRV: %[[#BlockStructTy:]] = OpTypeStruct
  23 ; CHECK-SPIRV: %[[#BlockStructLocPtrTy:]] = OpTypePointer Function %[[#BlockStructTy]]
  24 ; CHECK-SPIRV: %[[#BlockTy1:]] = OpTypeFunction %[[#VoidTy]] %[[#Int8PtrGenTy]]
  25 ; CHECK-SPIRV: %[[#BlockTy2:]] = OpTypeFunction %[[#VoidTy]] %[[#Int8PtrGenTy]]
  26 ; CHECK-SPIRV: %[[#BlockTy3:]] = OpTypeFunction %[[#VoidTy]] %[[#Int8PtrGenTy]]
  27
  28 ; CHECK-SPIRV: %[[#ConstInt0:]] = OpConstant %[[#Int32Ty]] 0
  29 ; CHECK-SPIRV: %[[#EventNull:]] = OpConstantNull %[[#EventPtrTy]]
  30 ; CHECK-SPIRV: %[[#ConstInt21:]] = OpConstant %[[#Int32Ty]] 21
  31 ; CHECK-SPIRV: %[[#ConstInt8:]] = OpConstant %[[#Int32Ty]] 8
  32 ; CHECK-SPIRV: %[[#ConstInt24:]] = OpConstant %[[#Int32Ty]] 24
  33 ; CHECK-SPIRV: %[[#ConstInt12:]] = OpConstant %[[#Int32Ty]] 12
  34 ; CHECK-SPIRV: %[[#ConstInt2:]] = OpConstant %[[#Int32Ty]] 2
  35
  36 ;; typedef struct {int a;} ndrange_t;
  37 ;; #define NULL ((void*)0)
  38
  39 ;; kernel void device_side_enqueue(global int *a, global int *b, int i, char c0) {
  40 ;;   queue_t default_queue;
  41 ;;   unsigned flags = 0;
  42 ;;   ndrange_t ndrange;
  43 ;;   clk_event_t clk_event;
  44 ;;   clk_event_t event_wait_list;
  45 ;;   clk_event_t event_wait_list2[] = {clk_event};
  46
  47 ;; Emits block literal on stack and block kernel.
  48
  49 ; CHECK-SPIRV:      %[[#BlockLitPtr1:]] = OpBitcast %[[#BlockStructLocPtrTy]]
  50 ; CHECK-SPIRV-NEXT: %[[#BlockLit1:]] = OpPtrCastToGeneric %[[#Int8PtrGenTy]] %[[#BlockLitPtr1]]
  51 ; CHECK-SPIRV-NEXT: %[[#]] = OpEnqueueKernel %[[#Int32Ty]] %[[#]] %[[#]] %[[#]] %[[#ConstInt0]] %[[#EventNull]] %[[#EventNull]] %[[#BlockKer1]] %[[#BlockLit1]] %[[#ConstInt21]] %[[#ConstInt8]]
  52
  53 ;;   enqueue_kernel(default_queue, flags, ndrange,
  54 ;;                  ^(void) {
  55 ;;                    a[i] = c0;
  56 ;;                  });
  57
  58 ;; Emits block literal on stack and block kernel.
  59
  60 ; CHECK-SPIRV:      %[[#Event1:]] = OpPtrCastToGeneric %[[#EventPtrTy]]
  61 ; CHECK-SPIRV:      %[[#Event2:]] = OpPtrCastToGeneric %[[#EventPtrTy]]
  62 ; CHECK-SPIRV:      %[[#BlockLitPtr2:]] = OpBitcast %[[#BlockStructLocPtrTy]]
  63 ; CHECK-SPIRV-NEXT: %[[#BlockLit2:]] = OpPtrCastToGeneric %[[#Int8PtrGenTy]] %[[#BlockLitPtr2]]
  64 ; CHECK-SPIRV-NEXT: %[[#]] = OpEnqueueKernel %[[#Int32Ty]] %[[#]] %[[#]] %[[#]] %[[#ConstInt2]] %[[#Event1]] %[[#Event2]] %[[#BlockKer2]] %[[#BlockLit2]] %[[#ConstInt24]] %[[#ConstInt8]]
  65
  66 ;;   enqueue_kernel(default_queue, flags, ndrange, 2, &event_wait_list, &clk_event,
  67 ;;                  ^(void) {
  68 ;;                    a[i] = b[i];
  69 ;;                  });
  70
  71 ;;   char c;
  72 ;; Emits global block literal and block kernel.
  73
  74 ; CHECK-SPIRV: %[[#Event1:]] = OpPtrCastToGeneric %[[#EventPtrTy]]
  75 ; CHECK-SPIRV: %[[#Event2:]] = OpPtrCastToGeneric %[[#EventPtrTy]]
  76 ; CHECK-SPIRV: %[[#BlockLit3Tmp:]] = OpBitcast %[[#]] %[[#BlockGlb1]]
  77 ; CHECK-SPIRV: %[[#BlockLit3:]] = OpPtrCastToGeneric %[[#Int8PtrGenTy]] %[[#BlockLit3Tmp]]
  78 ; CHECK-SPIRV: %[[#LocalBuf31:]] = OpPtrAccessChain %[[#Int32LocPtrTy]]
  79 ; CHECK-SPIRV: %[[#]] = OpEnqueueKernel %[[#Int32Ty]] %[[#]] %[[#]] %[[#]] %[[#ConstInt2]] %[[#Event1]] %[[#Event2]] %[[#BlockKer3]] %[[#BlockLit3]] %[[#ConstInt12]] %[[#ConstInt8]] %[[#LocalBuf31]]
  80
  81 ;;   enqueue_kernel(default_queue, flags, ndrange, 2, event_wait_list2, &clk_event,
  82 ;;                  ^(local void *p) {
  83 ;;                    return;
  84 ;;                  },
  85 ;;                  c);
  86
  87 ;; Emits global block literal and block kernel.
  88
  89 ; CHECK-SPIRV:      %[[#BlockLit4Tmp:]] = OpBitcast %[[#]] %[[#BlockGlb2]]
  90 ; CHECK-SPIRV:      %[[#BlockLit4:]] = OpPtrCastToGeneric %[[#Int8PtrGenTy]] %[[#BlockLit4Tmp]]
  91 ; CHECK-SPIRV:      %[[#LocalBuf41:]] = OpPtrAccessChain %[[#Int32LocPtrTy]]
  92 ; CHECK-SPIRV-NEXT: %[[#LocalBuf42:]] = OpPtrAccessChain %[[#Int32LocPtrTy]]
  93 ; CHECK-SPIRV-NEXT: %[[#LocalBuf43:]] = OpPtrAccessChain %[[#Int32LocPtrTy]]
  94 ; CHECK-SPIRV-NEXT: %[[#]] = OpEnqueueKernel %[[#Int32Ty]] %[[#]] %[[#]] %[[#]] %[[#ConstInt0]] %[[#EventNull]] %[[#EventNull]] %[[#BlockKer4]] %[[#BlockLit4]] %[[#ConstInt12]] %[[#ConstInt8]] %[[#LocalBuf41]] %[[#LocalBuf42]] %[[#LocalBuf43]]
  95
  96 ;;   enqueue_kernel(default_queue, flags, ndrange,
  97 ;;                  ^(local void *p1, local void *p2, local void *p3) {
  98 ;;                    return;
  99 ;;                  },
 100 ;;                  1, 2, 4);
 101
 102 ;; Emits block literal on stack and block kernel.
 103
 104 ; CHECK-SPIRV:      %[[#Event1:]] = OpPtrCastToGeneric %[[#EventPtrTy]]
 105 ; CHECK-SPIRV:      %[[#BlockLit5Tmp:]] = OpBitcast %[[#BlockStructLocPtrTy]]
 106 ; CHECK-SPIRV-NEXT: %[[#BlockLit5:]] = OpPtrCastToGeneric %[[#Int8PtrGenTy]] %[[#BlockLit5Tmp]]
 107 ; CHECK-SPIRV-NEXT: %[[#]] = OpEnqueueKernel %[[#Int32Ty]] %[[#]] %[[#]] %[[#]] %[[#ConstInt0]] %[[#EventNull]] %[[#Event1]] %[[#BlockKer5]] %[[#BlockLit5]] %[[#ConstInt24]] %[[#ConstInt8]]
 108
 109 ;;   enqueue_kernel(default_queue, flags, ndrange, 0, NULL, &clk_event,
 110 ;;                  ^(void) {
 111 ;;                    a[i] = b[i];
 112 ;;                  });
 113 ;; }
 114
 115 ; CHECK-SPIRV-DAG: %[[#BlockKer1]] = OpFunction %[[#VoidTy]] None %[[#BlockTy1]]
 116 ; CHECK-SPIRV-DAG: %[[#BlockKer2]] = OpFunction %[[#VoidTy]] None %[[#BlockTy1]]
 117 ; CHECK-SPIRV-DAG: %[[#BlockKer3]] = OpFunction %[[#VoidTy]] None %[[#BlockTy3]]
 118 ; CHECK-SPIRV-DAG: %[[#BlockKer4]] = OpFunction %[[#VoidTy]] None %[[#BlockTy2]]
 119 ; CHECK-SPIRV-DAG: %[[#BlockKer5]] = OpFunction %[[#VoidTy]] None %[[#BlockTy1]]
 120
 121 %opencl.queue_t = type opaque
 122 %struct.ndrange_t = type { i32 }
 123 %opencl.clk_event_t = type opaque
 124 %struct.__opencl_block_literal_generic = type { i32, i32, i8 addrspace(4)* }
 125
 126 @__block_literal_global = internal addrspace(1) constant { i32, i32, i8 addrspace(4)* } { i32 12, i32 4, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*, i8 addrspace(3)*)* @__device_side_enqueue_block_invoke_3 to i8*) to i8 addrspace(4)*) }, align 4
 127 @__block_literal_global.1 = internal addrspace(1) constant { i32, i32, i8 addrspace(4)* } { i32 12, i32 4, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*, i8 addrspace(3)*, i8 addrspace(3)*, i8 addrspace(3)*)* @__device_side_enqueue_block_invoke_4 to i8*) to i8 addrspace(4)*) }, align 4
 128
 129 define dso_local spir_kernel void @device_side_enqueue(i32 addrspace(1)* noundef %a, i32 addrspace(1)* noundef %b, i32 noundef %i, i8 noundef signext %c0) {
 130 entry:
 131   %a.addr = alloca i32 addrspace(1)*, align 4
 132   %b.addr = alloca i32 addrspace(1)*, align 4
 133   %i.addr = alloca i32, align 4
 134   %c0.addr = alloca i8, align 1
 135   %default_queue = alloca %opencl.queue_t*, align 4
 136   %flags = alloca i32, align 4
 137   %ndrange = alloca %struct.ndrange_t, align 4
 138   %clk_event = alloca %opencl.clk_event_t*, align 4
 139   %event_wait_list = alloca %opencl.clk_event_t*, align 4
 140   %event_wait_list2 = alloca [1 x %opencl.clk_event_t*], align 4
 141   %tmp = alloca %struct.ndrange_t, align 4
 142   %block = alloca <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, align 4
 143   %tmp3 = alloca %struct.ndrange_t, align 4
 144   %block4 = alloca <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, align 4
 145   %c = alloca i8, align 1
 146   %tmp11 = alloca %struct.ndrange_t, align 4
 147   %block_sizes = alloca [1 x i32], align 4
 148   %tmp12 = alloca %struct.ndrange_t, align 4
 149   %block_sizes13 = alloca [3 x i32], align 4
 150   %tmp14 = alloca %struct.ndrange_t, align 4
 151   %block15 = alloca <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, align 4
 152   store i32 addrspace(1)* %a, i32 addrspace(1)** %a.addr, align 4
 153   store i32 addrspace(1)* %b, i32 addrspace(1)** %b.addr, align 4
 154   store i32 %i, i32* %i.addr, align 4
 155   store i8 %c0, i8* %c0.addr, align 1
 156   store i32 0, i32* %flags, align 4
 157   %arrayinit.begin = getelementptr inbounds [1 x %opencl.clk_event_t*], [1 x %opencl.clk_event_t*]* %event_wait_list2, i32 0, i32 0
 158   %0 = load %opencl.clk_event_t*, %opencl.clk_event_t** %clk_event, align 4
 159   store %opencl.clk_event_t* %0, %opencl.clk_event_t** %arrayinit.begin, align 4
 160   %1 = load %opencl.queue_t*, %opencl.queue_t** %default_queue, align 4
 161   %2 = load i32, i32* %flags, align 4
 162   %3 = bitcast %struct.ndrange_t* %tmp to i8*
 163   %4 = bitcast %struct.ndrange_t* %ndrange to i8*
 164   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %3, i8* align 4 %4, i32 4, i1 false)
 165   %block.size = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>* %block, i32 0, i32 0
 166   store i32 21, i32* %block.size, align 4
 167   %block.align = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>* %block, i32 0, i32 1
 168   store i32 4, i32* %block.align, align 4
 169   %block.invoke = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>* %block, i32 0, i32 2
 170   store i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* @__device_side_enqueue_block_invoke to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %block.invoke, align 4
 171   %block.captured = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>* %block, i32 0, i32 3
 172   %5 = load i32 addrspace(1)*, i32 addrspace(1)** %a.addr, align 4
 173   store i32 addrspace(1)* %5, i32 addrspace(1)** %block.captured, align 4
 174   %block.captured1 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>* %block, i32 0, i32 4
 175   %6 = load i32, i32* %i.addr, align 4
 176   store i32 %6, i32* %block.captured1, align 4
 177   %block.captured2 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>* %block, i32 0, i32 5
 178   %7 = load i8, i8* %c0.addr, align 1
 179   store i8 %7, i8* %block.captured2, align 4
 180   %8 = bitcast <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>* %block to %struct.__opencl_block_literal_generic*
 181   %9 = addrspacecast %struct.__opencl_block_literal_generic* %8 to i8 addrspace(4)*
 182   %10 = call spir_func i32 @__enqueue_kernel_basic(%opencl.queue_t* %1, i32 %2, %struct.ndrange_t* byval(%struct.ndrange_t) %tmp, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* @__device_side_enqueue_block_invoke_kernel to i8*) to i8 addrspace(4)*), i8 addrspace(4)* %9)
 183   %11 = load %opencl.queue_t*, %opencl.queue_t** %default_queue, align 4
 184   %12 = load i32, i32* %flags, align 4
 185   %13 = bitcast %struct.ndrange_t* %tmp3 to i8*
 186   %14 = bitcast %struct.ndrange_t* %ndrange to i8*
 187   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %13, i8* align 4 %14, i32 4, i1 false)
 188   %15 = addrspacecast %opencl.clk_event_t** %event_wait_list to %opencl.clk_event_t* addrspace(4)*
 189   %16 = addrspacecast %opencl.clk_event_t** %clk_event to %opencl.clk_event_t* addrspace(4)*
 190   %block.size5 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block4, i32 0, i32 0
 191   store i32 24, i32* %block.size5, align 4
 192   %block.align6 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block4, i32 0, i32 1
 193   store i32 4, i32* %block.align6, align 4
 194   %block.invoke7 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block4, i32 0, i32 2
 195   store i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* @__device_side_enqueue_block_invoke_2 to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %block.invoke7, align 4
 196   %block.captured8 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block4, i32 0, i32 3
 197   %17 = load i32 addrspace(1)*, i32 addrspace(1)** %a.addr, align 4
 198   store i32 addrspace(1)* %17, i32 addrspace(1)** %block.captured8, align 4
 199   %block.captured9 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block4, i32 0, i32 4
 200   %18 = load i32, i32* %i.addr, align 4
 201   store i32 %18, i32* %block.captured9, align 4
 202   %block.captured10 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block4, i32 0, i32 5
 203   %19 = load i32 addrspace(1)*, i32 addrspace(1)** %b.addr, align 4
 204   store i32 addrspace(1)* %19, i32 addrspace(1)** %block.captured10, align 4
 205   %20 = bitcast <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block4 to %struct.__opencl_block_literal_generic*
 206   %21 = addrspacecast %struct.__opencl_block_literal_generic* %20 to i8 addrspace(4)*
 207   %22 = call spir_func i32 @__enqueue_kernel_basic_events(%opencl.queue_t* %11, i32 %12, %struct.ndrange_t* %tmp3, i32 2, %opencl.clk_event_t* addrspace(4)* %15, %opencl.clk_event_t* addrspace(4)* %16, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* @__device_side_enqueue_block_invoke_2_kernel to i8*) to i8 addrspace(4)*), i8 addrspace(4)* %21)
 208   %23 = load %opencl.queue_t*, %opencl.queue_t** %default_queue, align 4
 209   %24 = load i32, i32* %flags, align 4
 210   %25 = bitcast %struct.ndrange_t* %tmp11 to i8*
 211   %26 = bitcast %struct.ndrange_t* %ndrange to i8*
 212   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %25, i8* align 4 %26, i32 4, i1 false)
 213   %arraydecay = getelementptr inbounds [1 x %opencl.clk_event_t*], [1 x %opencl.clk_event_t*]* %event_wait_list2, i32 0, i32 0
 214   %27 = addrspacecast %opencl.clk_event_t** %arraydecay to %opencl.clk_event_t* addrspace(4)*
 215   %28 = addrspacecast %opencl.clk_event_t** %clk_event to %opencl.clk_event_t* addrspace(4)*
 216   %29 = getelementptr [1 x i32], [1 x i32]* %block_sizes, i32 0, i32 0
 217   %30 = load i8, i8* %c, align 1
 218   %31 = zext i8 %30 to i32
 219   store i32 %31, i32* %29, align 4
 220   %32 = call spir_func i32 @__enqueue_kernel_events_varargs(%opencl.queue_t* %23, i32 %24, %struct.ndrange_t* %tmp11, i32 2, %opencl.clk_event_t* addrspace(4)* %27, %opencl.clk_event_t* addrspace(4)* %28, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*, i8 addrspace(3)*)* @__device_side_enqueue_block_invoke_3_kernel to i8*) to i8 addrspace(4)*), i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* @__block_literal_global to i8 addrspace(1)*) to i8 addrspace(4)*), i32 1, i32* %29)
 221   %33 = load %opencl.queue_t*, %opencl.queue_t** %default_queue, align 4
 222   %34 = load i32, i32* %flags, align 4
 223   %35 = bitcast %struct.ndrange_t* %tmp12 to i8*
 224   %36 = bitcast %struct.ndrange_t* %ndrange to i8*
 225   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %35, i8* align 4 %36, i32 4, i1 false)
 226   %37 = getelementptr [3 x i32], [3 x i32]* %block_sizes13, i32 0, i32 0
 227   store i32 1, i32* %37, align 4
 228   %38 = getelementptr [3 x i32], [3 x i32]* %block_sizes13, i32 0, i32 1
 229   store i32 2, i32* %38, align 4
 230   %39 = getelementptr [3 x i32], [3 x i32]* %block_sizes13, i32 0, i32 2
 231   store i32 4, i32* %39, align 4
 232   %40 = call spir_func i32 @__enqueue_kernel_varargs(%opencl.queue_t* %33, i32 %34, %struct.ndrange_t* %tmp12, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*, i8 addrspace(3)*, i8 addrspace(3)*, i8 addrspace(3)*)* @__device_side_enqueue_block_invoke_4_kernel to i8*) to i8 addrspace(4)*), i8 addrspace(4)* addrspacecast (i8 addrspace(1)* bitcast ({ i32, i32, i8 addrspace(4)* } addrspace(1)* @__block_literal_global.1 to i8 addrspace(1)*) to i8 addrspace(4)*), i32 3, i32* %37)
 233   %41 = load %opencl.queue_t*, %opencl.queue_t** %default_queue, align 4
 234   %42 = load i32, i32* %flags, align 4
 235   %43 = bitcast %struct.ndrange_t* %tmp14 to i8*
 236   %44 = bitcast %struct.ndrange_t* %ndrange to i8*
 237   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %43, i8* align 4 %44, i32 4, i1 false)
 238   %45 = addrspacecast %opencl.clk_event_t** %clk_event to %opencl.clk_event_t* addrspace(4)*
 239   %block.size16 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block15, i32 0, i32 0
 240   store i32 24, i32* %block.size16, align 4
 241   %block.align17 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block15, i32 0, i32 1
 242   store i32 4, i32* %block.align17, align 4
 243   %block.invoke18 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block15, i32 0, i32 2
 244   store i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* @__device_side_enqueue_block_invoke_5 to i8*) to i8 addrspace(4)*), i8 addrspace(4)** %block.invoke18, align 4
 245   %block.captured19 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block15, i32 0, i32 3
 246   %46 = load i32 addrspace(1)*, i32 addrspace(1)** %a.addr, align 4
 247   store i32 addrspace(1)* %46, i32 addrspace(1)** %block.captured19, align 4
 248   %block.captured20 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block15, i32 0, i32 4
 249   %47 = load i32, i32* %i.addr, align 4
 250   store i32 %47, i32* %block.captured20, align 4
 251   %block.captured21 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block15, i32 0, i32 5
 252   %48 = load i32 addrspace(1)*, i32 addrspace(1)** %b.addr, align 4
 253   store i32 addrspace(1)* %48, i32 addrspace(1)** %block.captured21, align 4
 254   %49 = bitcast <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>* %block15 to %struct.__opencl_block_literal_generic*
 255   %50 = addrspacecast %struct.__opencl_block_literal_generic* %49 to i8 addrspace(4)*
 256   %51 = call spir_func i32 @__enqueue_kernel_basic_events(%opencl.queue_t* %41, i32 %42, %struct.ndrange_t* %tmp14, i32 0, %opencl.clk_event_t* addrspace(4)* null, %opencl.clk_event_t* addrspace(4)* %45, i8 addrspace(4)* addrspacecast (i8* bitcast (void (i8 addrspace(4)*)* @__device_side_enqueue_block_invoke_5_kernel to i8*) to i8 addrspace(4)*), i8 addrspace(4)* %50)
 257   ret void
 258 }
 259
 260 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i32, i1 immarg)
 261
 262 define internal spir_func void @__device_side_enqueue_block_invoke(i8 addrspace(4)* noundef %.block_descriptor) {
 263 entry:
 264   %.block_descriptor.addr = alloca i8 addrspace(4)*, align 4
 265   %block.addr = alloca <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }> addrspace(4)*, align 4
 266   store i8 addrspace(4)* %.block_descriptor, i8 addrspace(4)** %.block_descriptor.addr, align 4
 267   %block = bitcast i8 addrspace(4)* %.block_descriptor to <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }> addrspace(4)*
 268   store <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }> addrspace(4)* %block, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }> addrspace(4)** %block.addr, align 4
 269   %block.capture.addr = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }> addrspace(4)* %block, i32 0, i32 5
 270   %0 = load i8, i8 addrspace(4)* %block.capture.addr, align 4
 271   %conv = sext i8 %0 to i32
 272   %block.capture.addr1 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }> addrspace(4)* %block, i32 0, i32 3
 273   %1 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(4)* %block.capture.addr1, align 4
 274   %block.capture.addr2 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i8 }> addrspace(4)* %block, i32 0, i32 4
 275   %2 = load i32, i32 addrspace(4)* %block.capture.addr2, align 4
 276   %arrayidx = getelementptr inbounds i32, i32 addrspace(1)* %1, i32 %2
 277   store i32 %conv, i32 addrspace(1)* %arrayidx, align 4
 278   ret void
 279 }
 280
 281 define spir_kernel void @__device_side_enqueue_block_invoke_kernel(i8 addrspace(4)* %0) {
 282 entry:
 283   call spir_func void @__device_side_enqueue_block_invoke(i8 addrspace(4)* %0)
 284   ret void
 285 }
 286
 287 declare spir_func i32 @__enqueue_kernel_basic(%opencl.queue_t*, i32, %struct.ndrange_t*, i8 addrspace(4)*, i8 addrspace(4)*)
 288
 289 define internal spir_func void @__device_side_enqueue_block_invoke_2(i8 addrspace(4)* noundef %.block_descriptor) {
 290 entry:
 291   %.block_descriptor.addr = alloca i8 addrspace(4)*, align 4
 292   %block.addr = alloca <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)*, align 4
 293   store i8 addrspace(4)* %.block_descriptor, i8 addrspace(4)** %.block_descriptor.addr, align 4
 294   %block = bitcast i8 addrspace(4)* %.block_descriptor to <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)*
 295   store <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)** %block.addr, align 4
 296   %block.capture.addr = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, i32 0, i32 5
 297   %0 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(4)* %block.capture.addr, align 4
 298   %block.capture.addr1 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, i32 0, i32 4
 299   %1 = load i32, i32 addrspace(4)* %block.capture.addr1, align 4
 300   %arrayidx = getelementptr inbounds i32, i32 addrspace(1)* %0, i32 %1
 301   %2 = load i32, i32 addrspace(1)* %arrayidx, align 4
 302   %block.capture.addr2 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, i32 0, i32 3
 303   %3 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(4)* %block.capture.addr2, align 4
 304   %block.capture.addr3 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, i32 0, i32 4
 305   %4 = load i32, i32 addrspace(4)* %block.capture.addr3, align 4
 306   %arrayidx4 = getelementptr inbounds i32, i32 addrspace(1)* %3, i32 %4
 307   store i32 %2, i32 addrspace(1)* %arrayidx4, align 4
 308   ret void
 309 }
 310
 311 define spir_kernel void @__device_side_enqueue_block_invoke_2_kernel(i8 addrspace(4)* %0) {
 312 entry:
 313   call spir_func void @__device_side_enqueue_block_invoke_2(i8 addrspace(4)* %0)
 314   ret void
 315 }
 316
 317 declare spir_func i32 @__enqueue_kernel_basic_events(%opencl.queue_t*, i32, %struct.ndrange_t*, i32, %opencl.clk_event_t* addrspace(4)*, %opencl.clk_event_t* addrspace(4)*, i8 addrspace(4)*, i8 addrspace(4)*)
 318
 319 define internal spir_func void @__device_side_enqueue_block_invoke_3(i8 addrspace(4)* noundef %.block_descriptor, i8 addrspace(3)* noundef %p) {
 320 entry:
 321   %.block_descriptor.addr = alloca i8 addrspace(4)*, align 4
 322   %p.addr = alloca i8 addrspace(3)*, align 4
 323   %block.addr = alloca <{ i32, i32, i8 addrspace(4)* }> addrspace(4)*, align 4
 324   store i8 addrspace(4)* %.block_descriptor, i8 addrspace(4)** %.block_descriptor.addr, align 4
 325   %block = bitcast i8 addrspace(4)* %.block_descriptor to <{ i32, i32, i8 addrspace(4)* }> addrspace(4)*
 326   store i8 addrspace(3)* %p, i8 addrspace(3)** %p.addr, align 4
 327   store <{ i32, i32, i8 addrspace(4)* }> addrspace(4)* %block, <{ i32, i32, i8 addrspace(4)* }> addrspace(4)** %block.addr, align 4
 328   ret void
 329 }
 330
 331 define spir_kernel void @__device_side_enqueue_block_invoke_3_kernel(i8 addrspace(4)* %0, i8 addrspace(3)* %1) {
 332 entry:
 333   call spir_func void @__device_side_enqueue_block_invoke_3(i8 addrspace(4)* %0, i8 addrspace(3)* %1)
 334   ret void
 335 }
 336
 337 declare spir_func i32 @__enqueue_kernel_events_varargs(%opencl.queue_t*, i32, %struct.ndrange_t*, i32, %opencl.clk_event_t* addrspace(4)*, %opencl.clk_event_t* addrspace(4)*, i8 addrspace(4)*, i8 addrspace(4)*, i32, i32*)
 338
 339 define internal spir_func void @__device_side_enqueue_block_invoke_4(i8 addrspace(4)* noundef %.block_descriptor, i8 addrspace(3)* noundef %p1, i8 addrspace(3)* noundef %p2, i8 addrspace(3)* noundef %p3) {
 340 entry:
 341   %.block_descriptor.addr = alloca i8 addrspace(4)*, align 4
 342   %p1.addr = alloca i8 addrspace(3)*, align 4
 343   %p2.addr = alloca i8 addrspace(3)*, align 4
 344   %p3.addr = alloca i8 addrspace(3)*, align 4
 345   %block.addr = alloca <{ i32, i32, i8 addrspace(4)* }> addrspace(4)*, align 4
 346   store i8 addrspace(4)* %.block_descriptor, i8 addrspace(4)** %.block_descriptor.addr, align 4
 347   %block = bitcast i8 addrspace(4)* %.block_descriptor to <{ i32, i32, i8 addrspace(4)* }> addrspace(4)*
 348   store i8 addrspace(3)* %p1, i8 addrspace(3)** %p1.addr, align 4
 349   store i8 addrspace(3)* %p2, i8 addrspace(3)** %p2.addr, align 4
 350   store i8 addrspace(3)* %p3, i8 addrspace(3)** %p3.addr, align 4
 351   store <{ i32, i32, i8 addrspace(4)* }> addrspace(4)* %block, <{ i32, i32, i8 addrspace(4)* }> addrspace(4)** %block.addr, align 4
 352   ret void
 353 }
 354
 355 define spir_kernel void @__device_side_enqueue_block_invoke_4_kernel(i8 addrspace(4)* %0, i8 addrspace(3)* %1, i8 addrspace(3)* %2, i8 addrspace(3)* %3) {
 356 entry:
 357   call spir_func void @__device_side_enqueue_block_invoke_4(i8 addrspace(4)* %0, i8 addrspace(3)* %1, i8 addrspace(3)* %2, i8 addrspace(3)* %3)
 358   ret void
 359 }
 360
 361 declare spir_func i32 @__enqueue_kernel_varargs(%opencl.queue_t*, i32, %struct.ndrange_t*, i8 addrspace(4)*, i8 addrspace(4)*, i32, i32*)
 362
 363 define internal spir_func void @__device_side_enqueue_block_invoke_5(i8 addrspace(4)* noundef %.block_descriptor) {
 364 entry:
 365   %.block_descriptor.addr = alloca i8 addrspace(4)*, align 4
 366   %block.addr = alloca <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)*, align 4
 367   store i8 addrspace(4)* %.block_descriptor, i8 addrspace(4)** %.block_descriptor.addr, align 4
 368   %block = bitcast i8 addrspace(4)* %.block_descriptor to <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)*
 369   store <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)** %block.addr, align 4
 370   %block.capture.addr = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, i32 0, i32 5
 371   %0 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(4)* %block.capture.addr, align 4
 372   %block.capture.addr1 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, i32 0, i32 4
 373   %1 = load i32, i32 addrspace(4)* %block.capture.addr1, align 4
 374   %arrayidx = getelementptr inbounds i32, i32 addrspace(1)* %0, i32 %1
 375   %2 = load i32, i32 addrspace(1)* %arrayidx, align 4
 376   %block.capture.addr2 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, i32 0, i32 3
 377   %3 = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(4)* %block.capture.addr2, align 4
 378   %block.capture.addr3 = getelementptr inbounds <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }>, <{ i32, i32, i8 addrspace(4)*, i32 addrspace(1)*, i32, i32 addrspace(1)* }> addrspace(4)* %block, i32 0, i32 4
 379   %4 = load i32, i32 addrspace(4)* %block.capture.addr3, align 4
 380   %arrayidx4 = getelementptr inbounds i32, i32 addrspace(1)* %3, i32 %4
 381   store i32 %2, i32 addrspace(1)* %arrayidx4, align 4
 382   ret void
 383 }
 384
 385 define spir_kernel void @__device_side_enqueue_block_invoke_5_kernel(i8 addrspace(4)* %0) {
 386 entry:
 387   call spir_func void @__device_side_enqueue_block_invoke_5(i8 addrspace(4)* %0)
 388   ret void
 389 }