Author: Matt Arsenault
Date: 2023-01-10T20:35:49-05:00
New Revision: f9559b1e300ec636b15b350a981eebec65d3419a

URL: 
https://github.com/llvm/llvm-project/commit/f9559b1e300ec636b15b350a981eebec65d3419a
DIFF: 
https://github.com/llvm/llvm-project/commit/f9559b1e300ec636b15b350a981eebec65d3419a.diff

LOG: clang: Convert test to generated checks and opaque pointers

Added: 
    

Modified: 
    clang/test/CodeGenOpenCL/amdgpu-enqueue-kernel.cl

Removed: 
    


################################################################################
diff  --git a/clang/test/CodeGenOpenCL/amdgpu-enqueue-kernel.cl 
b/clang/test/CodeGenOpenCL/amdgpu-enqueue-kernel.cl
index 1bdf53652038b..210014d14c086 100644
--- a/clang/test/CodeGenOpenCL/amdgpu-enqueue-kernel.cl
+++ b/clang/test/CodeGenOpenCL/amdgpu-enqueue-kernel.cl
@@ -1,4 +1,5 @@
-// RUN: %clang_cc1 -no-opaque-pointers %s -cl-std=CL2.0 -O0 -emit-llvm -o - 
-triple amdgcn | FileCheck %s --check-prefix=CHECK
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --function-signature --check-attributes --check-globals 
--include-generated-funcs --prefix-filecheck-ir-name VAR
+// RUN: %clang_cc1 -cl-std=CL2.0 -O0 -disable-llvm-passes -fno-ident 
-emit-llvm -o - -triple amdgcn-amd-amdhsa -target-cpu gfx900 %s | FileCheck %s 
--check-prefix=CHECK
 
 typedef struct {int a;} ndrange_t;
 
@@ -6,7 +7,6 @@ void callee(long id, global long *out) {
   out[id] = id;
 }
 
-// CHECK-LABEL: define{{.*}} amdgpu_kernel void @test
 kernel void test(global char *a, char b, global long *c, long d) {
   queue_t default_queue;
   unsigned flags = 0;
@@ -35,24 +35,284 @@ kernel void test(global char *a, char b, global long *c, 
long d) {
 
   enqueue_kernel(default_queue, flags, ndrange, block);
 }
-
-// CHECK-LABEL: define internal amdgpu_kernel void 
@__test_block_invoke_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i8 }> %0)
-// CHECK-SAME: #[[ATTR:[0-9]+]] !kernel_arg_addr_space !{{.*}} 
!kernel_arg_access_qual !{{.*}} !kernel_arg_type !{{.*}} !kernel_arg_base_type 
!{{.*}} !kernel_arg_type_qual !{{.*}}
-// CHECK: entry:
-// CHECK:  %1 = alloca <{ i32, i32, i8*, i8 addrspace(1)*, i8 }>, align 8, 
addrspace(5)
-// CHECK:  store <{ i32, i32, i8*, i8 addrspace(1)*, i8 }> %0, <{ i32, i32, 
i8*, i8 addrspace(1)*, i8 }> addrspace(5)* %1, align 8
-// CHECK:  %2 ={{.*}} addrspacecast <{ i32, i32, i8*, i8 addrspace(1)*, i8 }> 
addrspace(5)* %1 to i8*
-// CHECK:  call void @__test_block_invoke(i8* %2)
-// CHECK:  ret void
-// CHECK:}
-
-// CHECK-LABEL: define internal amdgpu_kernel void 
@__test_block_invoke_2_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i64 
addrspace(1)*, i64, i8 }> %0)
-// CHECK-SAME: #[[ATTR]] !kernel_arg_addr_space !{{.*}} 
!kernel_arg_access_qual !{{.*}} !kernel_arg_type !{{.*}} !kernel_arg_base_type 
!{{.*}} !kernel_arg_type_qual !{{.*}}
-
-// CHECK-LABEL: define internal amdgpu_kernel void 
@__test_block_invoke_3_kernel(<{ i32, i32, i8*, i8 addrspace(1)*, i64 
addrspace(1)*, i64, i8 }> %0, i8 addrspace(3)* %1)
-// CHECK-SAME: #[[ATTR]] !kernel_arg_addr_space !{{.*}} 
!kernel_arg_access_qual !{{.*}} !kernel_arg_type !{{.*}} !kernel_arg_base_type 
!{{.*}} !kernel_arg_type_qual !{{.*}}
-
-// CHECK-LABEL: define internal amdgpu_kernel void 
@__test_block_invoke_4_kernel(<{ i32, i32, i8*, i64, i64 addrspace(1)* }> %0)
-// CHECK-SAME: #[[ATTR]] !kernel_arg_addr_space !{{.*}} 
!kernel_arg_access_qual !{{.*}} !kernel_arg_type !{{.*}} !kernel_arg_base_type 
!{{.*}} !kernel_arg_type_qual !{{.*}}
-
-// CHECK: attributes #[[ATTR]] = { nounwind "enqueued-block" }
+// CHECK: Function Attrs: convergent noinline norecurse nounwind optnone
+// CHECK-LABEL: define {{[^@]+}}@callee
+// CHECK-SAME: (i64 noundef [[ID:%.*]], ptr addrspace(1) noundef [[OUT:%.*]]) 
#[[ATTR0:[0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ID_ADDR:%.*]] = alloca i64, align 8, addrspace(5)
+// CHECK-NEXT:    [[OUT_ADDR:%.*]] = alloca ptr addrspace(1), align 8, 
addrspace(5)
+// CHECK-NEXT:    store i64 [[ID]], ptr addrspace(5) [[ID_ADDR]], align 8
+// CHECK-NEXT:    store ptr addrspace(1) [[OUT]], ptr addrspace(5) 
[[OUT_ADDR]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load i64, ptr addrspace(5) [[ID_ADDR]], align 
8
+// CHECK-NEXT:    [[TMP1:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[OUT_ADDR]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = load i64, ptr addrspace(5) [[ID_ADDR]], align 
8
+// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i64, ptr 
addrspace(1) [[TMP1]], i64 [[TMP2]]
+// CHECK-NEXT:    store i64 [[TMP0]], ptr addrspace(1) [[ARRAYIDX]], align 8
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: convergent noinline norecurse nounwind optnone
+// CHECK-LABEL: define {{[^@]+}}@test
+// CHECK-SAME: (ptr addrspace(1) noundef align 1 [[A:%.*]], i8 noundef 
[[B:%.*]], ptr addrspace(1) noundef align 8 [[C:%.*]], i64 noundef [[D:%.*]]) 
#[[ATTR1:[0-9]+]] !kernel_arg_addr_space !3 !kernel_arg_access_qual !4 
!kernel_arg_type !5 !kernel_arg_base_type !5 !kernel_arg_type_qual !6 {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca ptr addrspace(1), align 8, 
addrspace(5)
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i8, align 1, addrspace(5)
+// CHECK-NEXT:    [[C_ADDR:%.*]] = alloca ptr addrspace(1), align 8, 
addrspace(5)
+// CHECK-NEXT:    [[D_ADDR:%.*]] = alloca i64, align 8, addrspace(5)
+// CHECK-NEXT:    [[DEFAULT_QUEUE:%.*]] = alloca ptr addrspace(1), align 8, 
addrspace(5)
+// CHECK-NEXT:    [[FLAGS:%.*]] = alloca i32, align 4, addrspace(5)
+// CHECK-NEXT:    [[NDRANGE:%.*]] = alloca [[STRUCT_NDRANGE_T:%.*]], align 4, 
addrspace(5)
+// CHECK-NEXT:    [[TMP:%.*]] = alloca [[STRUCT_NDRANGE_T]], align 4, 
addrspace(5)
+// CHECK-NEXT:    [[BLOCK:%.*]] = alloca <{ i32, i32, ptr, ptr addrspace(1), 
i8 }>, align 8, addrspace(5)
+// CHECK-NEXT:    [[VARTMP2:%.*]] = alloca [[STRUCT_NDRANGE_T]], align 4, 
addrspace(5)
+// CHECK-NEXT:    [[BLOCK3:%.*]] = alloca <{ i32, i32, ptr, ptr addrspace(1), 
ptr addrspace(1), i64, i8 }>, align 8, addrspace(5)
+// CHECK-NEXT:    [[VARTMP11:%.*]] = alloca [[STRUCT_NDRANGE_T]], align 4, 
addrspace(5)
+// CHECK-NEXT:    [[BLOCK12:%.*]] = alloca <{ i32, i32, ptr, ptr addrspace(1), 
ptr addrspace(1), i64, i8 }>, align 8, addrspace(5)
+// CHECK-NEXT:    [[BLOCK_SIZES:%.*]] = alloca [1 x i64], align 8, addrspace(5)
+// CHECK-NEXT:    [[BLOCK20:%.*]] = alloca ptr, align 8, addrspace(5)
+// CHECK-NEXT:    [[BLOCK21:%.*]] = alloca <{ i32, i32, ptr, i64, ptr 
addrspace(1) }>, align 8, addrspace(5)
+// CHECK-NEXT:    [[VARTMP27:%.*]] = alloca [[STRUCT_NDRANGE_T]], align 4, 
addrspace(5)
+// CHECK-NEXT:    store ptr addrspace(1) [[A]], ptr addrspace(5) [[A_ADDR]], 
align 8
+// CHECK-NEXT:    store i8 [[B]], ptr addrspace(5) [[B_ADDR]], align 1
+// CHECK-NEXT:    store ptr addrspace(1) [[C]], ptr addrspace(5) [[C_ADDR]], 
align 8
+// CHECK-NEXT:    store i64 [[D]], ptr addrspace(5) [[D_ADDR]], align 8
+// CHECK-NEXT:    store i32 0, ptr addrspace(5) [[FLAGS]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[DEFAULT_QUEUE]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load i32, ptr addrspace(5) [[FLAGS]], align 4
+// CHECK-NEXT:    call void @llvm.memcpy.p5.p5.i64(ptr addrspace(5) align 4 
[[TMP]], ptr addrspace(5) align 4 [[NDRANGE]], i64 4, i1 false)
+// CHECK-NEXT:    [[BLOCK_SIZE:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), i8 }>, ptr addrspace(5) [[BLOCK]], i32 0, i32 0
+// CHECK-NEXT:    store i32 25, ptr addrspace(5) [[BLOCK_SIZE]], align 8
+// CHECK-NEXT:    [[BLOCK_ALIGN:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), i8 }>, ptr addrspace(5) [[BLOCK]], i32 0, i32 1
+// CHECK-NEXT:    store i32 8, ptr addrspace(5) [[BLOCK_ALIGN]], align 4
+// CHECK-NEXT:    [[BLOCK_INVOKE:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), i8 }>, ptr addrspace(5) [[BLOCK]], i32 0, i32 2
+// CHECK-NEXT:    store ptr @__test_block_invoke, ptr addrspace(5) 
[[BLOCK_INVOKE]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), i8 }>, ptr addrspace(5) [[BLOCK]], i32 0, i32 3
+// CHECK-NEXT:    [[TMP2:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[A_ADDR]], align 8
+// CHECK-NEXT:    store ptr addrspace(1) [[TMP2]], ptr addrspace(5) 
[[BLOCK_CAPTURED]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED1:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), i8 }>, ptr addrspace(5) [[BLOCK]], i32 0, i32 4
+// CHECK-NEXT:    [[TMP3:%.*]] = load i8, ptr addrspace(5) [[B_ADDR]], align 1
+// CHECK-NEXT:    store i8 [[TMP3]], ptr addrspace(5) [[BLOCK_CAPTURED1]], 
align 8
+// CHECK-NEXT:    [[TMP4:%.*]] = addrspacecast ptr addrspace(5) [[BLOCK]] to 
ptr
+// CHECK-NEXT:    [[TMP5:%.*]] = call i32 @__enqueue_kernel_basic(ptr 
addrspace(1) [[TMP0]], i32 [[TMP1]], ptr addrspace(5) 
byval([[STRUCT_NDRANGE_T]]) [[TMP]], ptr @__test_block_invoke_kernel, ptr 
[[TMP4]])
+// CHECK-NEXT:    [[TMP6:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[DEFAULT_QUEUE]], align 8
+// CHECK-NEXT:    [[TMP7:%.*]] = load i32, ptr addrspace(5) [[FLAGS]], align 4
+// CHECK-NEXT:    call void @llvm.memcpy.p5.p5.i64(ptr addrspace(5) align 4 
[[VARTMP2]], ptr addrspace(5) align 4 [[NDRANGE]], i64 4, i1 false)
+// CHECK-NEXT:    [[BLOCK_SIZE4:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK3]], i32 0, i32 0
+// CHECK-NEXT:    store i32 41, ptr addrspace(5) [[BLOCK_SIZE4]], align 8
+// CHECK-NEXT:    [[BLOCK_ALIGN5:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK3]], i32 0, i32 1
+// CHECK-NEXT:    store i32 8, ptr addrspace(5) [[BLOCK_ALIGN5]], align 4
+// CHECK-NEXT:    [[BLOCK_INVOKE6:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK3]], i32 0, i32 2
+// CHECK-NEXT:    store ptr @__test_block_invoke_2, ptr addrspace(5) 
[[BLOCK_INVOKE6]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED7:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK3]], i32 0, i32 3
+// CHECK-NEXT:    [[TMP8:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[A_ADDR]], align 8
+// CHECK-NEXT:    store ptr addrspace(1) [[TMP8]], ptr addrspace(5) 
[[BLOCK_CAPTURED7]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED8:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK3]], i32 0, i32 6
+// CHECK-NEXT:    [[TMP9:%.*]] = load i8, ptr addrspace(5) [[B_ADDR]], align 1
+// CHECK-NEXT:    store i8 [[TMP9]], ptr addrspace(5) [[BLOCK_CAPTURED8]], 
align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED9:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK3]], i32 0, i32 4
+// CHECK-NEXT:    [[TMP10:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[C_ADDR]], align 8
+// CHECK-NEXT:    store ptr addrspace(1) [[TMP10]], ptr addrspace(5) 
[[BLOCK_CAPTURED9]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED10:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK3]], i32 0, i32 5
+// CHECK-NEXT:    [[TMP11:%.*]] = load i64, ptr addrspace(5) [[D_ADDR]], align 
8
+// CHECK-NEXT:    store i64 [[TMP11]], ptr addrspace(5) [[BLOCK_CAPTURED10]], 
align 8
+// CHECK-NEXT:    [[TMP12:%.*]] = addrspacecast ptr addrspace(5) [[BLOCK3]] to 
ptr
+// CHECK-NEXT:    [[TMP13:%.*]] = call i32 @__enqueue_kernel_basic(ptr 
addrspace(1) [[TMP6]], i32 [[TMP7]], ptr addrspace(5) 
byval([[STRUCT_NDRANGE_T]]) [[VARTMP2]], ptr @__test_block_invoke_2_kernel, ptr 
[[TMP12]])
+// CHECK-NEXT:    [[TMP14:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[DEFAULT_QUEUE]], align 8
+// CHECK-NEXT:    [[TMP15:%.*]] = load i32, ptr addrspace(5) [[FLAGS]], align 4
+// CHECK-NEXT:    call void @llvm.memcpy.p5.p5.i64(ptr addrspace(5) align 4 
[[VARTMP11]], ptr addrspace(5) align 4 [[NDRANGE]], i64 4, i1 false)
+// CHECK-NEXT:    [[BLOCK_SIZE13:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK12]], i32 0, i32 0
+// CHECK-NEXT:    store i32 41, ptr addrspace(5) [[BLOCK_SIZE13]], align 8
+// CHECK-NEXT:    [[BLOCK_ALIGN14:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK12]], i32 0, i32 1
+// CHECK-NEXT:    store i32 8, ptr addrspace(5) [[BLOCK_ALIGN14]], align 4
+// CHECK-NEXT:    [[BLOCK_INVOKE15:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK12]], i32 0, i32 2
+// CHECK-NEXT:    store ptr @__test_block_invoke_3, ptr addrspace(5) 
[[BLOCK_INVOKE15]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED16:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK12]], i32 0, i32 3
+// CHECK-NEXT:    [[TMP16:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[A_ADDR]], align 8
+// CHECK-NEXT:    store ptr addrspace(1) [[TMP16]], ptr addrspace(5) 
[[BLOCK_CAPTURED16]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED17:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK12]], i32 0, i32 6
+// CHECK-NEXT:    [[TMP17:%.*]] = load i8, ptr addrspace(5) [[B_ADDR]], align 1
+// CHECK-NEXT:    store i8 [[TMP17]], ptr addrspace(5) [[BLOCK_CAPTURED17]], 
align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED18:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK12]], i32 0, i32 4
+// CHECK-NEXT:    [[TMP18:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[C_ADDR]], align 8
+// CHECK-NEXT:    store ptr addrspace(1) [[TMP18]], ptr addrspace(5) 
[[BLOCK_CAPTURED18]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED19:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr addrspace(5) 
[[BLOCK12]], i32 0, i32 5
+// CHECK-NEXT:    [[TMP19:%.*]] = load i64, ptr addrspace(5) [[D_ADDR]], align 
8
+// CHECK-NEXT:    store i64 [[TMP19]], ptr addrspace(5) [[BLOCK_CAPTURED19]], 
align 8
+// CHECK-NEXT:    [[TMP20:%.*]] = addrspacecast ptr addrspace(5) [[BLOCK12]] 
to ptr
+// CHECK-NEXT:    [[TMP21:%.*]] = getelementptr [1 x i64], ptr addrspace(5) 
[[BLOCK_SIZES]], i32 0, i32 0
+// CHECK-NEXT:    store i64 100, ptr addrspace(5) [[TMP21]], align 8
+// CHECK-NEXT:    [[TMP22:%.*]] = call i32 @__enqueue_kernel_varargs(ptr 
addrspace(1) [[TMP14]], i32 [[TMP15]], ptr addrspace(5) [[VARTMP11]], ptr 
@__test_block_invoke_3_kernel, ptr [[TMP20]], i32 1, ptr addrspace(5) [[TMP21]])
+// CHECK-NEXT:    [[BLOCK_SIZE22:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, i64, ptr addrspace(1) }>, ptr addrspace(5) [[BLOCK21]], i32 0, i32 0
+// CHECK-NEXT:    store i32 32, ptr addrspace(5) [[BLOCK_SIZE22]], align 8
+// CHECK-NEXT:    [[BLOCK_ALIGN23:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, i64, ptr addrspace(1) }>, ptr addrspace(5) [[BLOCK21]], i32 0, i32 1
+// CHECK-NEXT:    store i32 8, ptr addrspace(5) [[BLOCK_ALIGN23]], align 4
+// CHECK-NEXT:    [[BLOCK_INVOKE24:%.*]] = getelementptr inbounds <{ i32, i32, 
ptr, i64, ptr addrspace(1) }>, ptr addrspace(5) [[BLOCK21]], i32 0, i32 2
+// CHECK-NEXT:    store ptr @__test_block_invoke_4, ptr addrspace(5) 
[[BLOCK_INVOKE24]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED25:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, i64, ptr addrspace(1) }>, ptr addrspace(5) [[BLOCK21]], i32 0, i32 3
+// CHECK-NEXT:    [[TMP23:%.*]] = load i64, ptr addrspace(5) [[D_ADDR]], align 
8
+// CHECK-NEXT:    store i64 [[TMP23]], ptr addrspace(5) [[BLOCK_CAPTURED25]], 
align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURED26:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, i64, ptr addrspace(1) }>, ptr addrspace(5) [[BLOCK21]], i32 0, i32 4
+// CHECK-NEXT:    [[TMP24:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[C_ADDR]], align 8
+// CHECK-NEXT:    store ptr addrspace(1) [[TMP24]], ptr addrspace(5) 
[[BLOCK_CAPTURED26]], align 8
+// CHECK-NEXT:    [[BLOCK21_ASCAST:%.*]] = addrspacecast ptr addrspace(5) 
[[BLOCK21]] to ptr
+// CHECK-NEXT:    store ptr [[BLOCK21_ASCAST]], ptr addrspace(5) [[BLOCK20]], 
align 8
+// CHECK-NEXT:    [[TMP25:%.*]] = load ptr addrspace(1), ptr addrspace(5) 
[[DEFAULT_QUEUE]], align 8
+// CHECK-NEXT:    [[TMP26:%.*]] = load i32, ptr addrspace(5) [[FLAGS]], align 4
+// CHECK-NEXT:    call void @llvm.memcpy.p5.p5.i64(ptr addrspace(5) align 4 
[[VARTMP27]], ptr addrspace(5) align 4 [[NDRANGE]], i64 4, i1 false)
+// CHECK-NEXT:    [[TMP27:%.*]] = load ptr, ptr addrspace(5) [[BLOCK20]], 
align 8
+// CHECK-NEXT:    [[TMP28:%.*]] = addrspacecast ptr addrspace(5) [[BLOCK21]] 
to ptr
+// CHECK-NEXT:    [[TMP29:%.*]] = call i32 @__enqueue_kernel_basic(ptr 
addrspace(1) [[TMP25]], i32 [[TMP26]], ptr addrspace(5) 
byval([[STRUCT_NDRANGE_T]]) [[VARTMP27]], ptr @__test_block_invoke_4_kernel, 
ptr [[TMP28]])
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: convergent noinline nounwind optnone
+// CHECK-LABEL: define {{[^@]+}}@__test_block_invoke
+// CHECK-SAME: (ptr noundef [[DOTBLOCK_DESCRIPTOR:%.*]]) #[[ATTR3:[0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DOTBLOCK_DESCRIPTOR_ADDR:%.*]] = alloca ptr, align 8, 
addrspace(5)
+// CHECK-NEXT:    [[BLOCK_ADDR:%.*]] = alloca ptr, align 8, addrspace(5)
+// CHECK-NEXT:    store ptr [[DOTBLOCK_DESCRIPTOR]], ptr addrspace(5) 
[[DOTBLOCK_DESCRIPTOR_ADDR]], align 8
+// CHECK-NEXT:    store ptr [[DOTBLOCK_DESCRIPTOR]], ptr addrspace(5) 
[[BLOCK_ADDR]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), i8 }>, ptr [[DOTBLOCK_DESCRIPTOR]], i32 0, i32 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load i8, ptr [[BLOCK_CAPTURE_ADDR]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR1:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), i8 }>, ptr [[DOTBLOCK_DESCRIPTOR]], i32 0, i32 3
+// CHECK-NEXT:    [[TMP1:%.*]] = load ptr addrspace(1), ptr 
[[BLOCK_CAPTURE_ADDR1]], align 8
+// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i8, ptr 
addrspace(1) [[TMP1]], i64 0
+// CHECK-NEXT:    store i8 [[TMP0]], ptr addrspace(1) [[ARRAYIDX]], align 1
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: nounwind
+// CHECK-LABEL: define {{[^@]+}}@__test_block_invoke_kernel
+// CHECK-SAME: (<{ i32, i32, ptr, ptr addrspace(1), i8 }> [[TMP0:%.*]]) 
#[[ATTR4:[0-9]+]] !kernel_arg_addr_space !7 !kernel_arg_access_qual !8 
!kernel_arg_type !9 !kernel_arg_base_type !9 !kernel_arg_type_qual !10 {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[TMP1:%.*]] = alloca <{ i32, i32, ptr, ptr addrspace(1), i8 
}>, align 8, addrspace(5)
+// CHECK-NEXT:    store <{ i32, i32, ptr, ptr addrspace(1), i8 }> [[TMP0]], 
ptr addrspace(5) [[TMP1]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = addrspacecast ptr addrspace(5) [[TMP1]] to ptr
+// CHECK-NEXT:    call void @__test_block_invoke(ptr [[TMP2]])
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: convergent noinline nounwind optnone
+// CHECK-LABEL: define {{[^@]+}}@__test_block_invoke_2
+// CHECK-SAME: (ptr noundef [[DOTBLOCK_DESCRIPTOR:%.*]]) #[[ATTR3]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DOTBLOCK_DESCRIPTOR_ADDR:%.*]] = alloca ptr, align 8, 
addrspace(5)
+// CHECK-NEXT:    [[BLOCK_ADDR:%.*]] = alloca ptr, align 8, addrspace(5)
+// CHECK-NEXT:    store ptr [[DOTBLOCK_DESCRIPTOR]], ptr addrspace(5) 
[[DOTBLOCK_DESCRIPTOR_ADDR]], align 8
+// CHECK-NEXT:    store ptr [[DOTBLOCK_DESCRIPTOR]], ptr addrspace(5) 
[[BLOCK_ADDR]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr 
[[DOTBLOCK_DESCRIPTOR]], i32 0, i32 6
+// CHECK-NEXT:    [[TMP0:%.*]] = load i8, ptr [[BLOCK_CAPTURE_ADDR]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR1:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr 
[[DOTBLOCK_DESCRIPTOR]], i32 0, i32 3
+// CHECK-NEXT:    [[TMP1:%.*]] = load ptr addrspace(1), ptr 
[[BLOCK_CAPTURE_ADDR1]], align 8
+// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i8, ptr 
addrspace(1) [[TMP1]], i64 0
+// CHECK-NEXT:    store i8 [[TMP0]], ptr addrspace(1) [[ARRAYIDX]], align 1
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR2:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr 
[[DOTBLOCK_DESCRIPTOR]], i32 0, i32 5
+// CHECK-NEXT:    [[TMP2:%.*]] = load i64, ptr [[BLOCK_CAPTURE_ADDR2]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR3:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr 
[[DOTBLOCK_DESCRIPTOR]], i32 0, i32 4
+// CHECK-NEXT:    [[TMP3:%.*]] = load ptr addrspace(1), ptr 
[[BLOCK_CAPTURE_ADDR3]], align 8
+// CHECK-NEXT:    [[ARRAYIDX4:%.*]] = getelementptr inbounds i64, ptr 
addrspace(1) [[TMP3]], i64 0
+// CHECK-NEXT:    store i64 [[TMP2]], ptr addrspace(1) [[ARRAYIDX4]], align 8
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: nounwind
+// CHECK-LABEL: define {{[^@]+}}@__test_block_invoke_2_kernel
+// CHECK-SAME: (<{ i32, i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 
}> [[TMP0:%.*]]) #[[ATTR4]] !kernel_arg_addr_space !7 !kernel_arg_access_qual 
!8 !kernel_arg_type !9 !kernel_arg_base_type !9 !kernel_arg_type_qual !10 {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[TMP1:%.*]] = alloca <{ i32, i32, ptr, ptr addrspace(1), 
ptr addrspace(1), i64, i8 }>, align 8, addrspace(5)
+// CHECK-NEXT:    store <{ i32, i32, ptr, ptr addrspace(1), ptr addrspace(1), 
i64, i8 }> [[TMP0]], ptr addrspace(5) [[TMP1]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = addrspacecast ptr addrspace(5) [[TMP1]] to ptr
+// CHECK-NEXT:    call void @__test_block_invoke_2(ptr [[TMP2]])
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: convergent noinline nounwind optnone
+// CHECK-LABEL: define {{[^@]+}}@__test_block_invoke_3
+// CHECK-SAME: (ptr noundef [[DOTBLOCK_DESCRIPTOR:%.*]], ptr addrspace(3) 
noundef [[LP:%.*]]) #[[ATTR3]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DOTBLOCK_DESCRIPTOR_ADDR:%.*]] = alloca ptr, align 8, 
addrspace(5)
+// CHECK-NEXT:    [[LP_ADDR:%.*]] = alloca ptr addrspace(3), align 4, 
addrspace(5)
+// CHECK-NEXT:    [[BLOCK_ADDR:%.*]] = alloca ptr, align 8, addrspace(5)
+// CHECK-NEXT:    store ptr [[DOTBLOCK_DESCRIPTOR]], ptr addrspace(5) 
[[DOTBLOCK_DESCRIPTOR_ADDR]], align 8
+// CHECK-NEXT:    store ptr addrspace(3) [[LP]], ptr addrspace(5) [[LP_ADDR]], 
align 4
+// CHECK-NEXT:    store ptr [[DOTBLOCK_DESCRIPTOR]], ptr addrspace(5) 
[[BLOCK_ADDR]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr 
[[DOTBLOCK_DESCRIPTOR]], i32 0, i32 6
+// CHECK-NEXT:    [[TMP0:%.*]] = load i8, ptr [[BLOCK_CAPTURE_ADDR]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR1:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr 
[[DOTBLOCK_DESCRIPTOR]], i32 0, i32 3
+// CHECK-NEXT:    [[TMP1:%.*]] = load ptr addrspace(1), ptr 
[[BLOCK_CAPTURE_ADDR1]], align 8
+// CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i8, ptr 
addrspace(1) [[TMP1]], i64 0
+// CHECK-NEXT:    store i8 [[TMP0]], ptr addrspace(1) [[ARRAYIDX]], align 1
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR2:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr 
[[DOTBLOCK_DESCRIPTOR]], i32 0, i32 5
+// CHECK-NEXT:    [[TMP2:%.*]] = load i64, ptr [[BLOCK_CAPTURE_ADDR2]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR3:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 }>, ptr 
[[DOTBLOCK_DESCRIPTOR]], i32 0, i32 4
+// CHECK-NEXT:    [[TMP3:%.*]] = load ptr addrspace(1), ptr 
[[BLOCK_CAPTURE_ADDR3]], align 8
+// CHECK-NEXT:    [[ARRAYIDX4:%.*]] = getelementptr inbounds i64, ptr 
addrspace(1) [[TMP3]], i64 0
+// CHECK-NEXT:    store i64 [[TMP2]], ptr addrspace(1) [[ARRAYIDX4]], align 8
+// CHECK-NEXT:    [[TMP4:%.*]] = load ptr addrspace(3), ptr addrspace(5) 
[[LP_ADDR]], align 4
+// CHECK-NEXT:    [[ARRAYIDX5:%.*]] = getelementptr inbounds i32, ptr 
addrspace(3) [[TMP4]], i64 0
+// CHECK-NEXT:    store i32 1, ptr addrspace(3) [[ARRAYIDX5]], align 4
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: nounwind
+// CHECK-LABEL: define {{[^@]+}}@__test_block_invoke_3_kernel
+// CHECK-SAME: (<{ i32, i32, ptr, ptr addrspace(1), ptr addrspace(1), i64, i8 
}> [[TMP0:%.*]], ptr addrspace(3) [[TMP1:%.*]]) #[[ATTR4]] 
!kernel_arg_addr_space !11 !kernel_arg_access_qual !12 !kernel_arg_type !13 
!kernel_arg_base_type !13 !kernel_arg_type_qual !14 {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[TMP2:%.*]] = alloca <{ i32, i32, ptr, ptr addrspace(1), 
ptr addrspace(1), i64, i8 }>, align 8, addrspace(5)
+// CHECK-NEXT:    store <{ i32, i32, ptr, ptr addrspace(1), ptr addrspace(1), 
i64, i8 }> [[TMP0]], ptr addrspace(5) [[TMP2]], align 8
+// CHECK-NEXT:    [[TMP3:%.*]] = addrspacecast ptr addrspace(5) [[TMP2]] to ptr
+// CHECK-NEXT:    call void @__test_block_invoke_3(ptr [[TMP3]], ptr 
addrspace(3) [[TMP1]])
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: convergent noinline nounwind optnone
+// CHECK-LABEL: define {{[^@]+}}@__test_block_invoke_4
+// CHECK-SAME: (ptr noundef [[DOTBLOCK_DESCRIPTOR:%.*]]) #[[ATTR3]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DOTBLOCK_DESCRIPTOR_ADDR:%.*]] = alloca ptr, align 8, 
addrspace(5)
+// CHECK-NEXT:    [[BLOCK_ADDR:%.*]] = alloca ptr, align 8, addrspace(5)
+// CHECK-NEXT:    store ptr [[DOTBLOCK_DESCRIPTOR]], ptr addrspace(5) 
[[DOTBLOCK_DESCRIPTOR_ADDR]], align 8
+// CHECK-NEXT:    store ptr [[DOTBLOCK_DESCRIPTOR]], ptr addrspace(5) 
[[BLOCK_ADDR]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, i64, ptr addrspace(1) }>, ptr [[DOTBLOCK_DESCRIPTOR]], i32 0, i32 3
+// CHECK-NEXT:    [[TMP0:%.*]] = load i64, ptr [[BLOCK_CAPTURE_ADDR]], align 8
+// CHECK-NEXT:    [[BLOCK_CAPTURE_ADDR1:%.*]] = getelementptr inbounds <{ i32, 
i32, ptr, i64, ptr addrspace(1) }>, ptr [[DOTBLOCK_DESCRIPTOR]], i32 0, i32 4
+// CHECK-NEXT:    [[TMP1:%.*]] = load ptr addrspace(1), ptr 
[[BLOCK_CAPTURE_ADDR1]], align 8
+// CHECK-NEXT:    call void @callee(i64 noundef [[TMP0]], ptr addrspace(1) 
noundef [[TMP1]]) #[[ATTR5:[0-9]+]]
+// CHECK-NEXT:    ret void
+//
+//
+// CHECK: Function Attrs: nounwind
+// CHECK-LABEL: define {{[^@]+}}@__test_block_invoke_4_kernel
+// CHECK-SAME: (<{ i32, i32, ptr, i64, ptr addrspace(1) }> [[TMP0:%.*]]) 
#[[ATTR4]] !kernel_arg_addr_space !7 !kernel_arg_access_qual !8 
!kernel_arg_type !9 !kernel_arg_base_type !9 !kernel_arg_type_qual !10 {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[TMP1:%.*]] = alloca <{ i32, i32, ptr, i64, ptr 
addrspace(1) }>, align 8, addrspace(5)
+// CHECK-NEXT:    store <{ i32, i32, ptr, i64, ptr addrspace(1) }> [[TMP0]], 
ptr addrspace(5) [[TMP1]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = addrspacecast ptr addrspace(5) [[TMP1]] to ptr
+// CHECK-NEXT:    call void @__test_block_invoke_4(ptr [[TMP2]])
+// CHECK-NEXT:    ret void
+//
+//.
+// CHECK: attributes #0 = { convergent noinline norecurse nounwind optnone 
"no-trapping-math"="true" "stack-protector-buffer-size"="8" 
"target-cpu"="gfx900" 
"target-features"="+16-bit-insts,+ci-insts,+dpp,+gfx8-insts,+gfx9-insts,+s-memrealtime,+s-memtime-inst,+wavefrontsize64"
 }
+// CHECK: attributes #1 = { convergent noinline norecurse nounwind optnone 
"amdgpu-flat-work-group-size"="1,256" "no-trapping-math"="true" 
"stack-protector-buffer-size"="8" "target-cpu"="gfx900" 
"target-features"="+16-bit-insts,+ci-insts,+dpp,+gfx8-insts,+gfx9-insts,+s-memrealtime,+s-memtime-inst,+wavefrontsize64"
 "uniform-work-group-size"="false" }
+// CHECK: attributes #2 = { nocallback nofree nounwind willreturn 
memory(argmem: readwrite) }
+// CHECK: attributes #3 = { convergent noinline nounwind optnone 
"no-trapping-math"="true" "stack-protector-buffer-size"="8" 
"target-cpu"="gfx900" 
"target-features"="+16-bit-insts,+ci-insts,+dpp,+gfx8-insts,+gfx9-insts,+s-memrealtime,+s-memtime-inst,+wavefrontsize64"
 }
+// CHECK: attributes #4 = { nounwind "enqueued-block" }
+// CHECK: attributes #5 = { convergent }
+//.
+// CHECK: !0 = !{i32 1, !"amdgpu_code_object_version", i32 400}
+// CHECK: !1 = !{i32 1, !"wchar_size", i32 4}
+// CHECK: !2 = !{i32 2, i32 0}
+// CHECK: !3 = !{i32 1, i32 0, i32 1, i32 0}
+// CHECK: !4 = !{!"none", !"none", !"none", !"none"}
+// CHECK: !5 = !{!"char*", !"char", !"long*", !"long"}
+// CHECK: !6 = !{!"", !"", !"", !""}
+// CHECK: !7 = !{i32 0}
+// CHECK: !8 = !{!"none"}
+// CHECK: !9 = !{!"__block_literal"}
+// CHECK: !10 = !{!""}
+// CHECK: !11 = !{i32 0, i32 3}
+// CHECK: !12 = !{!"none", !"none"}
+// CHECK: !13 = !{!"__block_literal", !"void*"}
+// CHECK: !14 = !{!"", !""}
+//.


        
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

Reply via email to