This is an archive of the discontinued LLVM Phabricator instance.

Differential D26509

[OpenCL] Fix integer parameters of enqueue_kernel
ClosedPublic

Authored by Anastasia on Nov 10 2016, 8:52 AM.

Details

Reviewers
yaxunl
Summary

Parameters representing number of events as well as sizes of enqueued block arguments in enqueue_kernel function are specified as uint type. This prevents passing sizeof(int) type expressions on the 64 bit architectures because they return size_t which is a 64 bit wide in contrast to uint that is always 32 bits.

The suggestion is:

  • For the number of events argument allow to pass larger integers than 32 bits as soon as compiler can prove that the range fits in 32 bits. If not, the diagnostic will be given.
  • Change type of the arguments specifying sizes of the corresponding block arguments to be size_t.

The proposed enqueue_kernel signature would be:

int enqueue_kernel (queue_t queue, kernel_enqueue_flags_t flags, const ndrange_t ndrange, uint num_events_in_wait_list, const clk_event_t *event_wait_list, clk_event_t *event_ret, void (^block)(local void *, ...), size_t size0, ...)

and therefore compiler should allow the call:

enqueue_kernel(default_queue, flags, ndrange, sizeof(event_wait_list)/sizeof(event_wait_list[0]), event_wait_list2, &clk_event,
               ^(local void *p) {
                 return;
               },
               sizeof(int[2]));

See tests for more examples.

Diff Detail

Event Timeline

Anastasia updated this revision to Diff 77496.Nov 10 2016, 8:52 AM
Anastasia retitled this revision from to [OpenCL] Fix integer parameters of enqueue_kernel.
Anastasia updated this object.
Anastasia added a reviewer: yaxunl.
Anastasia updated this object.
Anastasia added a subscriber: cfe-commits.
yaxunl edited edge metadata.Nov 11 2016, 8:23 AM

My main concern is that by making the number of event be of type size_t instead of uint we are not conforming to the spec, although I agree it is better for the user.

lib/CodeGen/CGBuiltin.cpp
2547

should Int32Ty be SizeTy?

lib/Sema/SemaChecking.cpp
453

This comment does not match what this function does. The function checks if the argument is integer type but does not check if it fits into 32 bit. Also the diagnostic msg says it is not an integer type and does not mention the size requirement.

test/CodeGenOpenCL/cl20-device-side-enqueue.cl
1

It seems the command is changed by replacing all CHECK with COMMON.

Anastasia added inline comments.Nov 11 2016, 10:55 AM
lib/CodeGen/CGBuiltin.cpp
2547

I am not changing the width of the event number argument actually because I think 32 bit width is sufficient. I just want us to accept objects with the larger width types to be passed in case compiler can prove that they fit in 32 bits. This will allow passing sizeof expression for example (even in 64 bit architectures) but it will create diagnostic only in case the value returned doesn't fit in 32 bits.

See CheckImplicitConversion in SemaChecking.cpp.

lib/Sema/SemaChecking.cpp
453

As per above comment I intended to keep the 32 bit width type for the number of events, but the object passed can have large type as soon as the actual value in it fits in 32 bits (if compiler can deduce that). If the value doesn't fit in 32 bits or the value range is not known at compile time, a diagnostic will be generated.

test/CodeGenOpenCL/cl20-device-side-enqueue.cl
1

Indeed, I've done something wrong with the string replacement. Will correct that! Thanks!

yaxunl added a comment.Nov 11 2016, 12:16 PM

I thought the number of events was also changed to size_t type. Now I understand. Probably I was misled by the summary:

"Parameters representing number of events as well as sizes of enqueued block arguments in enqueue_kernel function are specified as uint type. This prevents passing sizeof(int) type expressions on the 64 bit architectures because they return size_t which is a 64 bit wide in contrast to uint that is always 32 bits."

It sounds like number of events should also be changed. Maybe drop 'number of events as well as' from the above sentence?

Anastasia added a comment.Nov 14 2016, 3:39 AM

I see. If I say something like:

  • For the number of event argument allow to pass larger integers than 32 bits as soon as compiler can prove that the range fits in 32 bits. If not, the diagnostic will be given.
  • Change type of the arguments specifying sizes of the corresponding block arguments to be size_t.
yaxunl accepted this revision.Nov 14 2016, 7:03 AM
yaxunl edited edge metadata.

LGTM with the change for the summary. Thanks!

This revision is now accepted and ready to land.Nov 14 2016, 7:03 AM
Anastasia updated this revision to Diff 77825.Nov 14 2016, 9:21 AM
Anastasia updated this object.
Anastasia edited edge metadata.
  1. Corrected typos in CodeGen test.
  2. Improved description.
Anastasia closed this revision.Nov 14 2016, 9:50 AM

Committed in r286849.

Revision Contents

PathSize
include/
clang/
Basic/
2 lines
lib/
CodeGen/
36 lines
Sema/
42 lines
test/
CodeGenOpenCL/
148 lines
SemaOpenCL/
43 lines

Diff 77825

include/clang/Basic/DiagnosticSemaKinds.td

Context not available.
def err_opencl_enqueue_kernel_local_size_args : Error< def err_opencl_enqueue_kernel_local_size_args : Error<
"mismatch in number of block parameters and local size arguments passed">; "mismatch in number of block parameters and local size arguments passed">;
def err_opencl_enqueue_kernel_invalid_local_size_type : Error< def err_opencl_enqueue_kernel_invalid_local_size_type : Error<
"local memory sizes need to be specified as uint">; "illegal call to enqueue_kernel, parameter needs to be specified as integer type">;
def err_opencl_enqueue_kernel_blocks_non_local_void_args : Error< def err_opencl_enqueue_kernel_blocks_non_local_void_args : Error<
"blocks used in device side enqueue are expected to have parameters of type 'local void*'">; "blocks used in device side enqueue are expected to have parameters of type 'local void*'">;
def err_opencl_enqueue_kernel_blocks_no_args : Error< def err_opencl_enqueue_kernel_blocks_no_args : Error<
Context not available.

lib/CodeGen/CGBuiltin.cpp

Context not available.
std::vector<llvm::Type *> ArgTys = {QueueTy, IntTy, RangeTy, Int8PtrTy, std::vector<llvm::Type *> ArgTys = {QueueTy, IntTy, RangeTy, Int8PtrTy,
IntTy}; IntTy};
// Add the variadics. // Each of the following arguments specifies the size of the corresponding
for (unsigned I = 4; I < NumArgs; ++I) { // argument passed to the enqueued block.
llvm::Value *ArgSize = EmitScalarExpr(E->getArg(I)); for (unsigned I = 4/*Position of the first size arg*/; I < NumArgs; ++I)
unsigned TypeSizeInBytes = Args.push_back(
getContext() Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(I)), SizeTy));
.getTypeSizeInChars(E->getArg(I)->getType())
.getQuantity();
Args.push_back(TypeSizeInBytes < 4
? Builder.CreateZExt(ArgSize, Int32Ty)
: ArgSize);
}
llvm::FunctionType *FTy = llvm::FunctionType::get( llvm::FunctionType *FTy = llvm::FunctionType::get(
Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), true); Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), true);
Context not available.
llvm::Type *EventPtrTy = EventTy->getPointerTo( llvm::Type *EventPtrTy = EventTy->getPointerTo(
CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic)); CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic));
llvm::Value *NumEvents = EmitScalarExpr(E->getArg(3)); llvm::Value *NumEvents =
Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(3)), Int32Ty);
llvm::Value *EventList = llvm::Value *EventList =
E->getArg(4)->getType()->isArrayType() E->getArg(4)->getType()->isArrayType()
? EmitArrayToPointerDecay(E->getArg(4)).getPointer() ? EmitArrayToPointerDecay(E->getArg(4)).getPointer()
yaxunlUnsubmitted
Not Done
ReplyInline Actions

should Int32Ty be SizeTy?

yaxunl: should Int32Ty be SizeTy?
AnastasiaAuthorUnsubmitted
Not Done
ReplyInline Actions

I am not changing the width of the event number argument actually because I think 32 bit width is sufficient. I just want us to accept objects with the larger width types to be passed in case compiler can prove that they fit in 32 bits. This will allow passing sizeof expression for example (even in 64 bit architectures) but it will create diagnostic only in case the value returned doesn't fit in 32 bits.

See CheckImplicitConversion in SemaChecking.cpp.

Anastasia: I am not changing the width of the event number argument actually because I think 32 bit width…
Context not available.
ArgTys.push_back(Int32Ty); ArgTys.push_back(Int32Ty);
Name = "__enqueue_kernel_events_vaargs"; Name = "__enqueue_kernel_events_vaargs";
// Add the variadics. // Each of the following arguments specifies the size of the corresponding
for (unsigned I = 7; I < NumArgs; ++I) { // argument passed to the enqueued block.
llvm::Value *ArgSize = EmitScalarExpr(E->getArg(I)); for (unsigned I = 7/*Position of the first size arg*/; I < NumArgs; ++I)
unsigned TypeSizeInBytes = Args.push_back(
getContext() Builder.CreateZExtOrTrunc(EmitScalarExpr(E->getArg(I)), SizeTy));
.getTypeSizeInChars(E->getArg(I)->getType())
.getQuantity();
Args.push_back(TypeSizeInBytes < 4
? Builder.CreateZExt(ArgSize, Int32Ty)
: ArgSize);
}
llvm::FunctionType *FTy = llvm::FunctionType::get( llvm::FunctionType *FTy = llvm::FunctionType::get(
Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), true); Int32Ty, llvm::ArrayRef<llvm::Type *>(ArgTys), true);
return RValue::get( return RValue::get(
Context not available.

lib/Sema/SemaChecking.cpp

Context not available.
return checkOpenCLBlockArgs(S, BlockArg); return checkOpenCLBlockArgs(S, BlockArg);
} }
/// Diagnose integer type and any valid implicit convertion to it.
static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E,
const QualType &IntType);
static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall, static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall,
unsigned Start, unsigned End); unsigned Start, unsigned End) {
bool IllegalParams = false;
for (unsigned I = Start; I <= End; ++I)
IllegalParams |= checkOpenCLEnqueueIntType(S, TheCall->getArg(I),
S.Context.getSizeType());
return IllegalParams;
}
/// OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all /// OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all
/// 'local void*' parameter of passed block. /// 'local void*' parameter of passed block.
yaxunlUnsubmitted
Not Done
ReplyInline Actions

This comment does not match what this function does. The function checks if the argument is integer type but does not check if it fits into 32 bit. Also the diagnostic msg says it is not an integer type and does not mention the size requirement.

yaxunl: This comment does not match what this function does. The function checks if the argument is…
AnastasiaAuthorUnsubmitted
Not Done
ReplyInline Actions

As per above comment I intended to keep the 32 bit width type for the number of events, but the object passed can have large type as soon as the actual value in it fits in 32 bits (if compiler can deduce that). If the value doesn't fit in 32 bits or the value range is not known at compile time, a diagnostic will be generated.

Anastasia: As per above comment I intended to keep the 32 bit width type for the number of events, but the…
Context not available.
} // end anonymous namespace } // end anonymous namespace
static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall, /// Diagnose integer type and any valid implicit convertion to it.
unsigned Start, unsigned End) { static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntT) {
bool IllegalParams = false; // Taking into account implicit conversions,
for (unsigned I = Start; I <= End; ++I) { // allow any integer.
QualType Ty = TheCall->getArg(I)->getType(); if (!E->getType()->isIntegerType()) {
// Taking into account implicit conversions, S.Diag(E->getLocStart(),
// allow any integer within 32 bits range diag::err_opencl_enqueue_kernel_invalid_local_size_type);
if (!Ty->isIntegerType() || return true;
S.Context.getTypeSizeInChars(Ty).getQuantity() > 4) {
S.Diag(TheCall->getArg(I)->getLocStart(),
diag::err_opencl_enqueue_kernel_invalid_local_size_type);
IllegalParams = true;
}
// Potentially emit standard warnings for implicit conversions if enabled
// using -Wconversion.
CheckImplicitConversion(S, TheCall->getArg(I), S.Context.UnsignedIntTy,
TheCall->getArg(I)->getLocStart());
} }
return IllegalParams; // Potentially emit standard warnings for implicit conversions if enabled
// using -Wconversion.
CheckImplicitConversion(S, E, IntT, E->getLocStart());
return false;
} }
// Helper function for Sema::DiagnoseAlwaysNonNullPointer. // Helper function for Sema::DiagnoseAlwaysNonNullPointer.
Context not available.

test/CodeGenOpenCL/cl20-device-side-enqueue.cl

// RUN: %clang_cc1 %s -cl-std=CL2.0 -ffake-address-space-map -O0 -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -cl-std=CL2.0 -ffake-address-space-map -O0 -emit-llvm -o - -triple "spir-unknown-unknown" | FileCheck %s --check-prefix=COMMON --check-prefix=B32
yaxunlUnsubmitted
Not Done
ReplyInline Actions

It seems the command is changed by replacing all CHECK with COMMON.

yaxunl: It seems the command is changed by replacing all CHECK with COMMON.
AnastasiaAuthorUnsubmitted
Not Done
ReplyInline Actions

Indeed, I've done something wrong with the string replacement. Will correct that! Thanks!

Anastasia: Indeed, I've done something wrong with the string replacement. Will correct that! Thanks!
// RUN: %clang_cc1 %s -cl-std=CL2.0 -ffake-address-space-map -O0 -emit-llvm -o - -triple "spir64-unknown-unknown" | FileCheck %s --check-prefix=COMMON --check-prefix=B64
typedef void (^bl_t)(local void *); typedef void (^bl_t)(local void *);
const bl_t block_G = (bl_t) ^ (local void *a) {}; const bl_t block_G = (bl_t) ^ (local void *a) {};
kernel void device_side_enqueue(global int *a, global int *b, int i) { kernel void device_side_enqueue(global int *a, global int *b, int i) {
// CHECK: %default_queue = alloca %opencl.queue_t* // COMMON: %default_queue = alloca %opencl.queue_t*
queue_t default_queue; queue_t default_queue;
// CHECK: %flags = alloca i32 // COMMON: %flags = alloca i32
unsigned flags = 0; unsigned flags = 0;
// CHECK: %ndrange = alloca %opencl.ndrange_t* // COMMON: %ndrange = alloca %opencl.ndrange_t*
ndrange_t ndrange; ndrange_t ndrange;
// CHECK: %clk_event = alloca %opencl.clk_event_t* // COMMON: %clk_event = alloca %opencl.clk_event_t*
clk_event_t clk_event; clk_event_t clk_event;
// CHECK: %event_wait_list = alloca %opencl.clk_event_t* // COMMON: %event_wait_list = alloca %opencl.clk_event_t*
clk_event_t event_wait_list; clk_event_t event_wait_list;
// CHECK: %event_wait_list2 = alloca [1 x %opencl.clk_event_t*] // COMMON: %event_wait_list2 = alloca [1 x %opencl.clk_event_t*]
clk_event_t event_wait_list2[] = {clk_event}; clk_event_t event_wait_list2[] = {clk_event};
// CHECK: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
// CHECK: [[FLAGS:%[0-9]+]] = load i32, i32* %flags // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
// CHECK: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange // COMMON: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange
// CHECK: [[BL:%[0-9]+]] = bitcast <{ i8*, i32, i32, i8*, %struct.__block_descriptor addrspace(3)*, i32{{.*}}, i32{{.*}}, i32{{.*}} }>* %block to void ()* // COMMON: [[BL:%[0-9]+]] = bitcast <{ i8*, i32, i32, i8*, %struct.__block_descriptor addrspace(3)*, i32{{.*}}, i32{{.*}}, i32{{.*}} }>* %block to void ()*
// CHECK: [[BL_I8:%[0-9]+]] = bitcast void ()* [[BL]] to i8* // COMMON: [[BL_I8:%[0-9]+]] = bitcast void ()* [[BL]] to i8*
// CHECK: call i32 @__enqueue_kernel_basic(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* [[BL_I8]]) // COMMON: call i32 @__enqueue_kernel_basic(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* [[BL_I8]])
enqueue_kernel(default_queue, flags, ndrange, enqueue_kernel(default_queue, flags, ndrange,
^(void) { ^(void) {
a[i] = b[i]; a[i] = b[i];
}); });
// CHECK: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
// CHECK: [[FLAGS:%[0-9]+]] = load i32, i32* %flags // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
// CHECK: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange // COMMON: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange
// CHECK: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %event_wait_list to %opencl.clk_event_t{{.*}}* addrspace(4)* // COMMON: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %event_wait_list to %opencl.clk_event_t{{.*}}* addrspace(4)*
// CHECK: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)* // COMMON: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)*
// CHECK: [[BL:%[0-9]+]] = bitcast <{ i8*, i32, i32, i8*, %struct.__block_descriptor addrspace(3)*, i32{{.*}}, i32{{.*}}, i32{{.*}} }>* %block3 to void ()* // COMMON: [[BL:%[0-9]+]] = bitcast <{ i8*, i32, i32, i8*, %struct.__block_descriptor addrspace(3)*, i32{{.*}}, i32{{.*}}, i32{{.*}} }>* %block3 to void ()*
// CHECK: [[BL_I8:%[0-9]+]] = bitcast void ()* [[BL]] to i8* // COMMON: [[BL_I8:%[0-9]+]] = bitcast void ()* [[BL]] to i8*
// CHECK: call i32 @__enqueue_kernel_basic_events(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}}* addrspace(4)* [[WAIT_EVNT]], %opencl.clk_event_t{{.*}}* addrspace(4)* [[EVNT]], i8* [[BL_I8]]) // COMMON: call i32 @__enqueue_kernel_basic_events(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}}* addrspace(4)* [[WAIT_EVNT]], %opencl.clk_event_t{{.*}}* addrspace(4)* [[EVNT]], i8* [[BL_I8]])
enqueue_kernel(default_queue, flags, ndrange, 2, &event_wait_list, &clk_event, enqueue_kernel(default_queue, flags, ndrange, 2, &event_wait_list, &clk_event,
^(void) { ^(void) {
a[i] = b[i]; a[i] = b[i];
}); });
// CHECK: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
// CHECK: [[FLAGS:%[0-9]+]] = load i32, i32* %flags // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
// CHECK: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange // COMMON: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange
// CHECK: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 256) // B32: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 256)
// B64: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i64 256)
enqueue_kernel(default_queue, flags, ndrange, enqueue_kernel(default_queue, flags, ndrange,
^(local void *p) { ^(local void *p) {
return; return;
}, },
256); 256);
char c; char c;
// CHECK: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
// CHECK: [[FLAGS:%[0-9]+]] = load i32, i32* %flags // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
// CHECK: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange // COMMON: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange
// CHECK: [[SIZE:%[0-9]+]] = zext i8 {{%[0-9]+}} to i32 // B32: [[SIZE:%[0-9]+]] = zext i8 {{%[0-9]+}} to i32
// CHECK: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 [[SIZE]]) // B32: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 [[SIZE]])
// B64: [[SIZE:%[0-9]+]] = zext i8 {{%[0-9]+}} to i64
// B64: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i64 [[SIZE]])
enqueue_kernel(default_queue, flags, ndrange, enqueue_kernel(default_queue, flags, ndrange,
^(local void *p) { ^(local void *p) {
return; return;
}, },
c); c);
// CHECK: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
// CHECK: [[FLAGS:%[0-9]+]] = load i32, i32* %flags // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
// CHECK: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange // COMMON: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange
// CHECK: [[AD:%arraydecay[0-9]*]] = getelementptr inbounds [1 x %opencl.clk_event_t*], [1 x %opencl.clk_event_t*]* %event_wait_list2, i32 0, i32 0 // COMMON: [[AD:%arraydecay[0-9]*]] = getelementptr inbounds [1 x %opencl.clk_event_t*], [1 x %opencl.clk_event_t*]* %event_wait_list2, i32 0, i32 0
// CHECK: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** [[AD]] to %opencl.clk_event_t{{.*}}* addrspace(4)* // COMMON: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** [[AD]] to %opencl.clk_event_t{{.*}}* addrspace(4)*
// CHECK: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)* // COMMON: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)*
// CHECK: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i32, %opencl.clk_event_t{{.*}}* addrspace(4)*, %opencl.clk_event_t{{.*}}* addrspace(4)*, i8*, i32, ...) @__enqueue_kernel_events_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}} [[WAIT_EVNT]], %opencl.clk_event_t{{.*}} [[EVNT]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 256) // B32: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i32, %opencl.clk_event_t{{.*}}* addrspace(4)*, %opencl.clk_event_t{{.*}}* addrspace(4)*, i8*, i32, ...) @__enqueue_kernel_events_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}} [[WAIT_EVNT]], %opencl.clk_event_t{{.*}} [[EVNT]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 256)
// B64: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i32, %opencl.clk_event_t{{.*}}* addrspace(4)*, %opencl.clk_event_t{{.*}}* addrspace(4)*, i8*, i32, ...) @__enqueue_kernel_events_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}} [[WAIT_EVNT]], %opencl.clk_event_t{{.*}} [[EVNT]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i64 256)
enqueue_kernel(default_queue, flags, ndrange, 2, event_wait_list2, &clk_event, enqueue_kernel(default_queue, flags, ndrange, 2, event_wait_list2, &clk_event,
^(local void *p) { ^(local void *p) {
return; return;
}, },
256); 256);
// CHECK: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t*, %opencl.queue_t** %default_queue // COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
// CHECK: [[FLAGS:%[0-9]+]] = load i32, i32* %flags // COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
// CHECK: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange // COMMON: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange
// CHECK: [[AD:%arraydecay[0-9]*]] = getelementptr inbounds [1 x %opencl.clk_event_t*], [1 x %opencl.clk_event_t*]* %event_wait_list2, i32 0, i32 0 // COMMON: [[AD:%arraydecay[0-9]*]] = getelementptr inbounds [1 x %opencl.clk_event_t*], [1 x %opencl.clk_event_t*]* %event_wait_list2, i32 0, i32 0
// CHECK: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** [[AD]] to %opencl.clk_event_t{{.*}}* addrspace(4)* // COMMON: [[WAIT_EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** [[AD]] to %opencl.clk_event_t{{.*}}* addrspace(4)*
// CHECK: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)* // COMMON: [[EVNT:%[0-9]+]] = addrspacecast %opencl.clk_event_t{{.*}}** %clk_event to %opencl.clk_event_t{{.*}}* addrspace(4)*
// B32: [[SIZE:%[0-9]+]] = zext i8 {{%[0-9]+}} to i32
// CHECK: [[SIZE:%[0-9]+]] = zext i8 {{%[0-9]+}} to i32 // B32: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i32, %opencl.clk_event_t{{.*}}* addrspace(4)*, %opencl.clk_event_t{{.*}}* addrspace(4)*, i8*, i32, ...) @__enqueue_kernel_events_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}}* addrspace(4)* [[WAIT_EVNT]], %opencl.clk_event_t{{.*}}* addrspace(4)* [[EVNT]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 [[SIZE]])
// CHECK: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i32, %opencl.clk_event_t{{.*}}* addrspace(4)*, %opencl.clk_event_t{{.*}}* addrspace(4)*, i8*, i32, ...) @__enqueue_kernel_events_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}}* addrspace(4)* [[WAIT_EVNT]], %opencl.clk_event_t{{.*}}* addrspace(4)* [[EVNT]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 [[SIZE]]) // B64: [[SIZE:%[0-9]+]] = zext i8 {{%[0-9]+}} to i64
// B64: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i32, %opencl.clk_event_t{{.*}}* addrspace(4)*, %opencl.clk_event_t{{.*}}* addrspace(4)*, i8*, i32, ...) @__enqueue_kernel_events_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* {{.*}}, i32 2, %opencl.clk_event_t{{.*}}* addrspace(4)* [[WAIT_EVNT]], %opencl.clk_event_t{{.*}}* addrspace(4)* [[EVNT]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i64 [[SIZE]])
enqueue_kernel(default_queue, flags, ndrange, 2, event_wait_list2, &clk_event, enqueue_kernel(default_queue, flags, ndrange, 2, event_wait_list2, &clk_event,
^(local void *p) { ^(local void *p) {
return; return;
}, },
c); c);
long l;
// COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t{{.*}}*, %opencl.queue_t{{.*}}** %default_queue
// COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
// COMMON: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange
// B32: [[SIZE:%[0-9]+]] = trunc i64 {{%[0-9]+}} to i32
// B32: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 [[SIZE]])
// B64: [[SIZE:%[0-9]+]] = load i64, i64* %l
// B64: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i64 [[SIZE]])
enqueue_kernel(default_queue, flags, ndrange,
^(local void *p) {
return;
},
l);
// COMMON: [[DEF_Q:%[0-9]+]] = load %opencl.queue_t*, %opencl.queue_t** %default_queue
// COMMON: [[FLAGS:%[0-9]+]] = load i32, i32* %flags
// COMMON: [[NDR:%[0-9]+]] = load %opencl.ndrange_t*, %opencl.ndrange_t** %ndrange
// B32: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i32 0)
// B64: call i32 (%opencl.queue_t{{.*}}*, i32, %opencl.ndrange_t*, i8*, i32, ...) @__enqueue_kernel_vaargs(%opencl.queue_t{{.*}}* [[DEF_Q]], i32 [[FLAGS]], %opencl.ndrange_t* [[NDR]], i8* bitcast ({ i8**, i32, i32, i8*, %struct.__block_descriptor addrspace(3)* }* @__block_literal_global{{(.[0-9]+)?}} to i8*), i32 1, i64 4294967296)
enqueue_kernel(default_queue, flags, ndrange,
^(local void *p) {
return;
},
4294967296L);
void (^const block_A)(void) = ^{ void (^const block_A)(void) = ^{
return; return;
}; };
Context not available.
return; return;
}; };
// CHECK: [[BL:%[0-9]+]] = load void ()*, void ()** %block_A // COMMON: [[BL:%[0-9]+]] = load void ()*, void ()** %block_A
// CHECK: [[BL_I8:%[0-9]+]] = bitcast void ()* [[BL]] to i8* // COMMON: [[BL_I8:%[0-9]+]] = bitcast void ()* [[BL]] to i8*
// CHECK: call i32 @__get_kernel_work_group_size_impl(i8* [[BL_I8]]) // COMMON: call i32 @__get_kernel_work_group_size_impl(i8* [[BL_I8]])
unsigned size = get_kernel_work_group_size(block_A); unsigned size = get_kernel_work_group_size(block_A);
// CHECK: [[BL:%[0-9]+]] = load void (i8 addrspace(2)*)*, void (i8 addrspace(2)*)** %block_B // COMMON: [[BL:%[0-9]+]] = load void (i8 addrspace(2)*)*, void (i8 addrspace(2)*)** %block_B
// CHECK: [[BL_I8:%[0-9]+]] = bitcast void (i8 addrspace(2)*)* [[BL]] to i8* // COMMON: [[BL_I8:%[0-9]+]] = bitcast void (i8 addrspace(2)*)* [[BL]] to i8*
// CHECK: call i32 @__get_kernel_work_group_size_impl(i8* [[BL_I8]]) // COMMON: call i32 @__get_kernel_work_group_size_impl(i8* [[BL_I8]])
size = get_kernel_work_group_size(block_B); size = get_kernel_work_group_size(block_B);
// CHECK: [[BL:%[0-9]+]] = load void ()*, void ()** %block_A // COMMON: [[BL:%[0-9]+]] = load void ()*, void ()** %block_A
// CHECK: [[BL_I8:%[0-9]+]] = bitcast void ()* [[BL]] to i8* // COMMON: [[BL_I8:%[0-9]+]] = bitcast void ()* [[BL]] to i8*
// CHECK: call i32 @__get_kernel_preferred_work_group_multiple_impl(i8* [[BL_I8]]) // COMMON: call i32 @__get_kernel_preferred_work_group_multiple_impl(i8* [[BL_I8]])
size = get_kernel_preferred_work_group_size_multiple(block_A); size = get_kernel_preferred_work_group_size_multiple(block_A);
// CHECK: [[BL:%[0-9]+]] = load void (i8 addrspace(2)*)*, void (i8 addrspace(2)*)* addrspace(1)* @block_G // COMMON: [[BL:%[0-9]+]] = load void (i8 addrspace(2)*)*, void (i8 addrspace(2)*)* addrspace(1)* @block_G
// CHECK: [[BL_I8:%[0-9]+]] = bitcast void (i8 addrspace(2)*)* [[BL]] to i8* // COMMON: [[BL_I8:%[0-9]+]] = bitcast void (i8 addrspace(2)*)* [[BL]] to i8*
// CHECK: call i32 @__get_kernel_preferred_work_group_multiple_impl(i8* [[BL_I8]]) // COMMON: call i32 @__get_kernel_preferred_work_group_multiple_impl(i8* [[BL_I8]])
size = get_kernel_preferred_work_group_size_multiple(block_G); size = get_kernel_preferred_work_group_size_multiple(block_G);
} }
Context not available.

test/SemaOpenCL/cl20-device-side-enqueue.cl

// RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only // RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only
// RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only -Wconversion -DWCONV // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32
// RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV
// Diagnostic tests for different overloads of enqueue_kernel from Table 6.13.17.1 of OpenCL 2.0 Spec. // Diagnostic tests for different overloads of enqueue_kernel from Table 6.13.17.1 of OpenCL 2.0 Spec.
kernel void enqueue_kernel_tests() { kernel void enqueue_kernel_tests() {
Context not available.
return 0; return 0;
}); });
enqueue_kernel(default_queue, flags, ndrange, vptr, &event_wait_list, &evt, ^(void) { // expected-error{{illegal call to enqueue_kernel, expected integer argument type}}
return 0;
});
enqueue_kernel(default_queue, flags, ndrange, 1, vptr, &evt, ^(void) // expected-error{{illegal call to enqueue_kernel, expected 'clk_event_t *' argument type}} enqueue_kernel(default_queue, flags, ndrange, 1, vptr, &evt, ^(void) // expected-error{{illegal call to enqueue_kernel, expected 'clk_event_t *' argument type}}
{ {
return 0; return 0;
Context not available.
^(local void *a, local void *b) { ^(local void *a, local void *b) {
return 0; return 0;
}, },
1024, 1024L); // expected-error{{local memory sizes need to be specified as uint}} 1024L, 1024);
enqueue_kernel(default_queue, flags, ndrange,
^(local void *a, local void *b) {
return 0;
},
1024, 4294967296L);
#ifdef B32
// expected-warning@-2{{implicit conversion from 'long' to 'unsigned int' changes value from 4294967296 to 0}}
#endif
char c; char c;
enqueue_kernel(default_queue, flags, ndrange, enqueue_kernel(default_queue, flags, ndrange,
^(local void *a, local void *b) { ^(local void *a, local void *b) {
return 0; return 0;
}, },
c, 1024); c, 1024L);
#ifdef WCONV #ifdef WCONV
// expected-warning@-2{{implicit conversion changes signedness: 'char' to 'unsigned int'}} // expected-warning-re@-2{{implicit conversion changes signedness: 'char' to 'unsigned {{int|long}}'}}
#endif #endif
#define UINT_MAX 4294967295
enqueue_kernel(default_queue, flags, ndrange,
^(local void *a, local void *b) {
return 0;
},
sizeof(int), sizeof(int) * UINT_MAX);
#ifdef B32
// expected-warning@-2{{implicit conversion from 'long' to 'unsigned int' changes value from 17179869180 to 4294967292}}
#endif
typedef void (^bl_A_t)(local void *); typedef void (^bl_A_t)(local void *);
const bl_A_t block_A = (bl_A_t) ^ (local void *a) {}; const bl_A_t block_A = (bl_A_t) ^ (local void *a) {};
Context not available.
^(local void *a, local void *b) { ^(local void *a, local void *b) {
return 0; return 0;
}, },
illegal_mem_size, illegal_mem_size); // expected-error{{local memory sizes need to be specified as uint}} expected-error{{local memory sizes need to be specified as uint}} illegal_mem_size, illegal_mem_size); // expected-error{{illegal call to enqueue_kernel, parameter needs to be specified as integer type}} expected-error{{illegal call to enqueue_kernel, parameter needs to be specified as integer type}}
#ifdef WCONV
// expected-warning@-2{{implicit conversion turns floating-point number into integer: 'float' to 'unsigned int'}} expected-warning@-2{{implicit conversion turns floating-point number into integer: 'float' to 'unsigned int'}}
#endif
enqueue_kernel(default_queue, flags, ndrange,
^(local void *a, local void *b) {
return 0;
},
illegal_mem_size, 1024); // expected-error{{illegal call to enqueue_kernel, parameter needs to be specified as integer type}}
// Testing the forth overload type // Testing the forth overload type
enqueue_kernel(default_queue, flags, ndrange, 1, event_wait_list2, &evt, enqueue_kernel(default_queue, flags, ndrange, 1, event_wait_list2, &evt,
^(local void *a, local void *b) { ^(local void *a, local void *b) {
Context not available.