diff options
Diffstat (limited to 'test/SemaOpenCL')
31 files changed, 978 insertions, 95 deletions
diff --git a/test/SemaOpenCL/access-qualifier.cl b/test/SemaOpenCL/access-qualifier.cl new file mode 100644 index 000000000000..7e5c70f915f6 --- /dev/null +++ b/test/SemaOpenCL/access-qualifier.cl @@ -0,0 +1,69 @@ +// RUN: %clang_cc1 -verify -pedantic -fsyntax-only -cl-std=CL1.2 %s +// RUN: %clang_cc1 -verify -pedantic -fsyntax-only -cl-std=CL2.0 %s + +typedef image1d_t img1d_ro_default; // expected-note {{previously declared 'read_only' here}} + +typedef write_only image1d_t img1d_wo; // expected-note {{previously declared 'write_only' here}} +typedef read_only image1d_t img1d_ro; + +#if __OPENCL_C_VERSION__ >= 200 +typedef read_write image1d_t img1d_rw; +#endif + +typedef int Int; +typedef read_only int IntRO; // expected-error {{access qualifier can only be used for pipe and image type}} + + +void myWrite(write_only image1d_t); // expected-note {{passing argument to parameter here}} expected-note {{passing argument to parameter here}} +void myRead(read_only image1d_t); // expected-note {{passing argument to parameter here}} + +#if __OPENCL_C_VERSION__ >= 200 +void myReadWrite(read_write image1d_t); +#else +void myReadWrite(read_write image1d_t); // expected-error {{access qualifier 'read_write' can not be used for '__read_write image1d_t' prior to OpenCL version 2.0}} +#endif + + +kernel void k1(img1d_wo img) { + myRead(img); // expected-error {{passing 'img1d_wo' (aka '__write_only image1d_t') to parameter of incompatible type '__read_only image1d_t'}} +} + +kernel void k2(img1d_ro img) { + myWrite(img); // expected-error {{passing 'img1d_ro' (aka '__read_only image1d_t') to parameter of incompatible type '__write_only image1d_t'}} +} + +kernel void k3(img1d_wo img) { + myWrite(img); +} + +#if __OPENCL_C_VERSION__ >= 200 +kernel void k4(img1d_rw img) { + myReadWrite(img); +} +#endif + +kernel void k5(img1d_ro_default img) { + myWrite(img); // expected-error {{passing 'img1d_ro_default' (aka '__read_only image1d_t') to parameter of incompatible type '__write_only image1d_t'}} +} + +kernel void k6(img1d_ro img) { + myRead(img); +} + +kernel void k7(read_only img1d_wo img){} // expected-error {{multiple access qualifiers}} + +kernel void k8(write_only img1d_ro_default img){} // expected-error {{multiple access qualifiers}} + +kernel void k9(read_only int i){} // expected-error{{access qualifier can only be used for pipe and image type}} + +kernel void k10(read_only Int img){} // expected-error {{access qualifier can only be used for pipe and image type}} + +kernel void k11(read_only write_only image1d_t i){} // expected-error{{multiple access qualifiers}} + +kernel void k12(read_only read_only image1d_t i){} // expected-error{{multiple access qualifiers}} + +#if __OPENCL_C_VERSION__ >= 200 +kernel void k13(read_write pipe int i){} // expected-error{{access qualifier 'read_write' can not be used for 'pipe int'}} +#else +kernel void k13(__read_write image1d_t i){} // expected-error{{access qualifier '__read_write' can not be used for '__read_write image1d_t' prior to OpenCL version 2.0}} +#endif diff --git a/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl b/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl index 50363f23a900..97fd07a24a24 100644 --- a/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl +++ b/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl @@ -225,3 +225,69 @@ void test_conversion(global int *arg_glob, local int *arg_loc, // expected-error@-2{{passing '__constant int *' to parameter of type '__generic int *' changes address space of pointer}} #endif } + +void test_ternary() { + AS int *var_cond; + generic int *var_gen; + global int *var_glob; + var_gen = 0 ? var_cond : var_glob; +#ifdef CONSTANT +// expected-error@-2{{conditional operator with the second and third operands of type ('__constant int *' and '__global int *') which are pointers to non-overlapping address spaces}} +#endif + + local int *var_loc; + var_gen = 0 ? var_cond : var_loc; +#ifndef GENERIC +// expected-error-re@-2{{conditional operator with the second and third operands of type ('__{{global|constant}} int *' and '__local int *') which are pointers to non-overlapping address spaces}} +#endif + + constant int *var_const; + var_cond = 0 ? var_cond : var_const; +#ifndef CONSTANT +// expected-error-re@-2{{conditional operator with the second and third operands of type ('__{{global|generic}} int *' and '__constant int *') which are pointers to non-overlapping address spaces}} +#endif + + private int *var_priv; + var_gen = 0 ? var_cond : var_priv; +#ifndef GENERIC +// expected-error-re@-2{{conditional operator with the second and third operands of type ('__{{global|constant}} int *' and 'int *') which are pointers to non-overlapping address spaces}} +#endif + + var_gen = 0 ? var_cond : var_gen; +#ifdef CONSTANT +// expected-error@-2{{conditional operator with the second and third operands of type ('__constant int *' and '__generic int *') which are pointers to non-overlapping address spaces}} +#endif + + void *var_void_gen; + global char *var_glob_ch; + var_void_gen = 0 ? var_cond : var_glob_ch; +#ifdef CONSTANT +// expected-error@-2{{conditional operator with the second and third operands of type ('__constant int *' and '__global char *') which are pointers to non-overlapping address spaces}} +#endif + + local char *var_loc_ch; + var_void_gen = 0 ? var_cond : var_loc_ch; +#ifndef GENERIC +// expected-error-re@-2{{conditional operator with the second and third operands of type ('__{{global|constant}} int *' and '__local char *') which are pointers to non-overlapping address spaces}} +#endif + + constant void *var_void_const; + constant char *var_const_ch; + var_void_const = 0 ? var_cond : var_const_ch; +#ifndef CONSTANT +// expected-error-re@-2{{conditional operator with the second and third operands of type ('__{{global|generic}} int *' and '__constant char *') which are pointers to non-overlapping address spaces}} +#endif + + private char *var_priv_ch; + var_void_gen = 0 ? var_cond : var_priv_ch; +#ifndef GENERIC +// expected-error-re@-2{{conditional operator with the second and third operands of type ('__{{global|constant}} int *' and 'char *') which are pointers to non-overlapping address spaces}} +#endif + + generic char *var_gen_ch; + var_void_gen = 0 ? var_cond : var_gen_ch; +#ifdef CONSTANT +// expected-error@-2{{conditional operator with the second and third operands of type ('__constant int *' and '__generic char *') which are pointers to non-overlapping address spaces}} +#endif +} + diff --git a/test/SemaOpenCL/as_type.cl b/test/SemaOpenCL/as_type.cl new file mode 100644 index 000000000000..f0bf4d7daef2 --- /dev/null +++ b/test/SemaOpenCL/as_type.cl @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 %s -emit-llvm -triple spir-unknown-unknown -o - -verify -fsyntax-only + +typedef __attribute__(( ext_vector_type(3) )) char char3; +typedef __attribute__(( ext_vector_type(16) )) char char16; + +char3 f1(char16 x) { + return __builtin_astype(x, char3); // expected-error{{invalid reinterpretation: sizes of 'char3' (vector of 3 'char' values) and 'char16' (vector of 16 'char' values) must match}} +} + +char16 f3(int x) { + return __builtin_astype(x, char16); // expected-error{{invalid reinterpretation: sizes of 'char16' (vector of 16 'char' values) and 'int' must match}} +} + diff --git a/test/SemaOpenCL/bool-vectors.cl b/test/SemaOpenCL/bool-vectors.cl new file mode 100644 index 000000000000..6df4d5653003 --- /dev/null +++ b/test/SemaOpenCL/bool-vectors.cl @@ -0,0 +1,3 @@ +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only + +typedef __attribute__((ext_vector_type(16))) _Bool bool8; // expected-error{{invalid vector element type 'bool'}} diff --git a/test/SemaOpenCL/builtin.cl b/test/SemaOpenCL/builtin.cl new file mode 100644 index 000000000000..d48a0c449591 --- /dev/null +++ b/test/SemaOpenCL/builtin.cl @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only + +// expected-no-diagnostics + +float __attribute__((overloadable)) acos(float); + +typedef float float4 __attribute__((ext_vector_type(4))); +int printf(__constant const char* st, ...); + +void test(void) +{ + float4 a; + printf("%8.4v4hlf\n", a); +} diff --git a/test/SemaOpenCL/cl20-device-side-enqueue.cl b/test/SemaOpenCL/cl20-device-side-enqueue.cl new file mode 100644 index 000000000000..298b8109881d --- /dev/null +++ b/test/SemaOpenCL/cl20-device-side-enqueue.cl @@ -0,0 +1,172 @@ +// 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 + +// Diagnostic tests for different overloads of enqueue_kernel from Table 6.13.17.1 of OpenCL 2.0 Spec. +kernel void enqueue_kernel_tests() { + queue_t default_queue; + unsigned flags = 0; + ndrange_t ndrange; + clk_event_t evt; + clk_event_t event_wait_list; + clk_event_t event_wait_list2[] = {evt, evt}; + void *vptr; + + // Testing the first overload type + enqueue_kernel(default_queue, flags, ndrange, ^(void) { + return 0; + }); + + enqueue_kernel(vptr, flags, ndrange, ^(void) { // expected-error{{illegal call to enqueue_kernel, expected 'queue_t' argument type}} + return 0; + }); + + enqueue_kernel(default_queue, vptr, ndrange, ^(void) { // expected-error{{illegal call to enqueue_kernel, expected 'kernel_enqueue_flags_t' (i.e. uint) argument type}} + return 0; + }); + + enqueue_kernel(default_queue, flags, vptr, ^(void) { // expected-error{{illegal call to enqueue_kernel, expected 'ndrange_t' argument type}} + return 0; + }); + + enqueue_kernel(default_queue, flags, ndrange, vptr); // expected-error{{illegal call to enqueue_kernel, expected block argument}} + + enqueue_kernel(default_queue, flags, ndrange, ^(int i) { // expected-error{{blocks in this form of device side enqueue call are expected to have have no parameters}} + return 0; + }); + + // Testing the second overload type + enqueue_kernel(default_queue, flags, ndrange, 1, &event_wait_list, &evt, ^(void) { + 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}} + { + return 0; + }); + + enqueue_kernel(default_queue, flags, ndrange, 1, &event_wait_list, vptr, ^(void) // expected-error{{illegal call to enqueue_kernel, expected 'clk_event_t *' argument type}} + { + return 0; + }); + + enqueue_kernel(default_queue, flags, ndrange, 1, &event_wait_list, &evt, vptr); // expected-error{{illegal call to enqueue_kernel, expected block argument}} + + // Testing the third overload type + enqueue_kernel(default_queue, flags, ndrange, + ^(local void *a, local void *b) { + return 0; + }, + 1024, 1024); + + enqueue_kernel(default_queue, flags, ndrange, + ^(local void *a, local void *b) { + return 0; + }, + 1024, 1024L); // expected-error{{local memory sizes need to be specified as uint}} + + char c; + enqueue_kernel(default_queue, flags, ndrange, + ^(local void *a, local void *b) { + return 0; + }, + c, 1024); +#ifdef WCONV +// expected-warning@-2{{implicit conversion changes signedness: 'char' to 'unsigned int'}} +#endif + + typedef void (^bl_A_t)(local void *); + + const bl_A_t block_A = (bl_A_t) ^ (local void *a) {}; + + enqueue_kernel(default_queue, flags, ndrange, block_A, 1024); + + typedef void (^bl_B_t)(local void *, local int *); + + const bl_B_t block_B = (bl_B_t) ^ (local void *a, local int *b) {}; + + enqueue_kernel(default_queue, flags, ndrange, block_B, 1024, 1024); // expected-error{{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + + enqueue_kernel(default_queue, flags, ndrange, // expected-error{{mismatch in number of block parameters and local size arguments passed}} + ^(local void *a, local void *b) { + return 0; + }, + 1024); + + float illegal_mem_size = (float)0.5f; + enqueue_kernel(default_queue, flags, ndrange, + ^(local void *a, local void *b) { + 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}} +#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 + + // Testing the forth overload type + enqueue_kernel(default_queue, flags, ndrange, 1, event_wait_list2, &evt, + ^(local void *a, local void *b) { + return 0; + }, + 1024, 1024); + + enqueue_kernel(default_queue, flags, ndrange, 1, &event_wait_list, &evt, // expected-error{{mismatch in number of block parameters and local size arguments passed}} + ^(local void *a, local void *b) { + return 0; + }, + 1024, 1024, 1024); + + // More random misc cases that can't be deduced + enqueue_kernel(default_queue, flags, ndrange, 1, &event_wait_list, &evt); // expected-error{{illegal call to enqueue_kernel, incorrect argument types}} + + enqueue_kernel(default_queue, flags, ndrange, 1, 1); // expected-error{{illegal call to enqueue_kernel, incorrect argument types}} +} + +// Diagnostic tests for get_kernel_work_group_size and allowed block parameter types in dynamic parallelism. +kernel void work_group_size_tests() { + void (^const block_A)(void) = ^{ + return; + }; + void (^const block_B)(int) = ^(int a) { + return; + }; + void (^const block_C)(local void *) = ^(local void *a) { + return; + }; + void (^const block_D)(local int *) = ^(local int *a) { + return; + }; + + unsigned size = get_kernel_work_group_size(block_A); + size = get_kernel_work_group_size(block_C); + size = get_kernel_work_group_size(^(local void *a) { + return; + }); + size = get_kernel_work_group_size(^(local int *a) { // expected-error {{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + return; + }); + size = get_kernel_work_group_size(block_B); // expected-error {{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + size = get_kernel_work_group_size(block_D); // expected-error {{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + size = get_kernel_work_group_size(^(int a) { // expected-error {{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + return; + }); + size = get_kernel_work_group_size(); // expected-error {{too few arguments to function call, expected 1, have 0}} + size = get_kernel_work_group_size(1); // expected-error{{expected block argument}} + size = get_kernel_work_group_size(block_A, 1); // expected-error{{too many arguments to function call, expected 1, have 2}} + + size = get_kernel_preferred_work_group_size_multiple(block_A); + size = get_kernel_preferred_work_group_size_multiple(block_C); + size = get_kernel_preferred_work_group_size_multiple(^(local void *a) { + return; + }); + size = get_kernel_preferred_work_group_size_multiple(^(local int *a) { // expected-error {{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + return; + }); + size = get_kernel_preferred_work_group_size_multiple(^(int a) { // expected-error {{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + return; + }); + size = get_kernel_preferred_work_group_size_multiple(block_B); // expected-error {{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + size = get_kernel_preferred_work_group_size_multiple(block_D); // expected-error {{blocks used in device side enqueue are expected to have parameters of type 'local void*'}} + size = get_kernel_preferred_work_group_size_multiple(); // expected-error {{too few arguments to function call, expected 1, have 0}} + size = get_kernel_preferred_work_group_size_multiple(1); // expected-error{{expected block argument}} + size = get_kernel_preferred_work_group_size_multiple(block_A, 1); // expected-error{{too many arguments to function call, expected 1, have 2}} +} diff --git a/test/SemaOpenCL/clang-builtin-version.cl b/test/SemaOpenCL/clang-builtin-version.cl new file mode 100644 index 000000000000..8574682ab93b --- /dev/null +++ b/test/SemaOpenCL/clang-builtin-version.cl @@ -0,0 +1,44 @@ +// RUN: %clang_cc1 %s -fblocks -verify -pedantic -fsyntax-only -ferror-limit 100 + +// Confirm CL2.0 Clang builtins are not available in earlier versions + +kernel void dse_builtins() { + int tmp; + enqueue_kernel(tmp, tmp, tmp, ^(void) { // expected-warning{{implicit declaration of function 'enqueue_kernel' is invalid in C99}} + return; + }); + unsigned size = get_kernel_work_group_size(^(void) { // expected-warning{{implicit declaration of function 'get_kernel_work_group_size' is invalid in C99}} + return; + }); + size = get_kernel_preferred_work_group_size_multiple(^(void) { // expected-warning{{implicit declaration of function 'get_kernel_preferred_work_group_size_multiple' is invalid in C99}} + return; + }); +} + +void pipe_builtins() { + int tmp; + + read_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'read_pipe' is invalid in C99}} + write_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'write_pipe' is invalid in C99}} + + reserve_read_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'reserve_read_pipe' is invalid in C99}} + reserve_write_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'reserve_write_pipe' is invalid in C99}} + + work_group_reserve_read_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'work_group_reserve_read_pipe' is invalid in C99}} + work_group_reserve_write_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'work_group_reserve_write_pipe' is invalid in C99}} + + sub_group_reserve_write_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'sub_group_reserve_write_pipe' is invalid in C99}} + sub_group_reserve_read_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'sub_group_reserve_read_pipe' is invalid in C99}} + + commit_read_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'commit_read_pipe' is invalid in C99}} + commit_write_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'commit_write_pipe' is invalid in C99}} + + work_group_commit_read_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'work_group_commit_read_pipe' is invalid in C99}} + work_group_commit_write_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'work_group_commit_write_pipe' is invalid in C99}} + + sub_group_commit_write_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'sub_group_commit_write_pipe' is invalid in C99}} + sub_group_commit_read_pipe(tmp, tmp); // expected-warning{{implicit declaration of function 'sub_group_commit_read_pipe' is invalid in C99}} + + get_pipe_num_packets(tmp); // expected-warning{{implicit declaration of function 'get_pipe_num_packets' is invalid in C99}} + get_pipe_max_packets(tmp); // expected-warning{{implicit declaration of function 'get_pipe_max_packets' is invalid in C99}} +} diff --git a/test/SemaOpenCL/event_t.cl b/test/SemaOpenCL/event_t.cl index e09883948cc6..990c06340942 100644 --- a/test/SemaOpenCL/event_t.cl +++ b/test/SemaOpenCL/event_t.cl @@ -3,7 +3,7 @@ event_t glb_evt; // expected-error {{the event_t type cannot be used to declare a program scope variable}} constant struct evt_s { - event_t evt; // expected-error {{the event_t type cannot be used to declare a structure or union field}} + event_t evt; // expected-error {{the 'event_t' type cannot be used to declare a structure or union field}} } evt_str = {0}; void foo(event_t evt); // expected-note {{passing argument to parameter 'evt' here}} @@ -14,5 +14,6 @@ void kernel ker(event_t argevt) { // expected-error {{'event_t' cannot be used a foo(e); foo(0); foo(5); // expected-error {{passing 'int' to parameter of incompatible type 'event_t'}} + foo((event_t)1); // expected-error {{cannot cast non-zero value '1' to 'event_t'}} } diff --git a/test/SemaOpenCL/extension-fp64-cl1.1.cl b/test/SemaOpenCL/extension-fp64-cl1.1.cl deleted file mode 100644 index 7e852ae70ebb..000000000000 --- a/test/SemaOpenCL/extension-fp64-cl1.1.cl +++ /dev/null @@ -1,19 +0,0 @@ -// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.1 - -void f1(double da) { // expected-error {{type 'double' requires cl_khr_fp64 extension}} - double d; // expected-error {{type 'double' requires cl_khr_fp64 extension}} - (void) 1.0; // expected-warning {{double precision constant requires cl_khr_fp64}} -} - -#pragma OPENCL EXTENSION cl_khr_fp64 : enable - -void f2(void) { - double d; - (void) 1.0; -} - -#pragma OPENCL EXTENSION cl_khr_fp64 : disable - -void f3(void) { - double d; // expected-error {{type 'double' requires cl_khr_fp64 extension}} -} diff --git a/test/SemaOpenCL/extension-fp64.cl b/test/SemaOpenCL/extension-fp64.cl deleted file mode 100644 index e0c2b1ea4b53..000000000000 --- a/test/SemaOpenCL/extension-fp64.cl +++ /dev/null @@ -1,19 +0,0 @@ -// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only - -void f1(double da) { // expected-error {{type 'double' requires cl_khr_fp64 extension}} - double d; // expected-error {{type 'double' requires cl_khr_fp64 extension}} - (void) 1.0; // expected-warning {{double precision constant requires cl_khr_fp64}} -} - -#pragma OPENCL EXTENSION cl_khr_fp64 : enable - -void f2(void) { - double d; - (void) 1.0; -} - -#pragma OPENCL EXTENSION cl_khr_fp64 : disable - -void f3(void) { - double d; // expected-error {{type 'double' requires cl_khr_fp64 extension}} -} diff --git a/test/SemaOpenCL/extension-version.cl b/test/SemaOpenCL/extension-version.cl new file mode 100644 index 000000000000..ae403aa1d193 --- /dev/null +++ b/test/SemaOpenCL/extension-version.cl @@ -0,0 +1,249 @@ +// RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple spir-unknown-unknown +// RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple spir-unknown-unknown +// RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple spir-unknown-unknown +// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple spir-unknown-unknown +// RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple spir-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES +// RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple spir-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES +// RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple spir-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES +// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple spir-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES + +#if __OPENCL_C_VERSION__ >= 200 && ! defined TEST_CORE_FEATURES +// expected-no-diagnostics +#endif + +// Extensions in all versions +#ifndef cl_clang_storage_class_specifiers +#error "Missing cl_clang_storage_class_specifiers define" +#endif +#pragma OPENCL EXTENSION cl_clang_storage_class_specifiers: enable + +#ifndef cl_khr_fp16 +#error "Missing cl_khr_fp16 define" +#endif +#pragma OPENCL EXTENSION cl_khr_fp16: enable + +#ifndef cl_khr_int64_base_atomics +#error "Missing cl_khr_int64_base_atomics define" +#endif +#pragma OPENCL EXTENSION cl_khr_int64_base_atomics: enable + +#ifndef cl_khr_int64_extended_atomics +#error "Missing cl_khr_int64_extended_atomics define" +#endif +#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics: enable + +#ifndef cl_khr_gl_sharing +#error "Missing cl_khr_gl_sharing define" +#endif +#pragma OPENCL EXTENSION cl_khr_gl_sharing: enable + +#ifndef cl_khr_icd +#error "Missing cl_khr_icd define" +#endif +#pragma OPENCL EXTENSION cl_khr_icd: enable + +// Core features in CL 1.1 + +#ifndef cl_khr_byte_addressable_store +#error "Missing cl_khr_byte_addressable_store define" +#endif +#pragma OPENCL EXTENSION cl_khr_byte_addressable_store: enable +#if (__OPENCL_C_VERSION__ >= 110) && defined TEST_CORE_FEATURES +// expected-warning@-2{{OpenCL extension 'cl_khr_byte_addressable_store' is core feature or supported optional core feature - ignoring}} +#endif + +#ifndef cl_khr_global_int32_base_atomics +#error "Missing cl_khr_global_int32_base_atomics define" +#endif +#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics: enable +#if (__OPENCL_C_VERSION__ >= 110) && defined TEST_CORE_FEATURES +// expected-warning@-2{{OpenCL extension 'cl_khr_global_int32_base_atomics' is core feature or supported optional core feature - ignoring}} +#endif + +#ifndef cl_khr_global_int32_extended_atomics +#error "Missing cl_khr_global_int32_extended_atomics define" +#endif +#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics: enable +#if (__OPENCL_C_VERSION__ >= 110) && defined TEST_CORE_FEATURES +// expected-warning@-2{{OpenCL extension 'cl_khr_global_int32_extended_atomics' is core feature or supported optional core feature - ignoring}} +#endif + +#ifndef cl_khr_local_int32_base_atomics +#error "Missing cl_khr_local_int32_base_atomics define" +#endif +#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics: enable +#if (__OPENCL_C_VERSION__ >= 110) && defined TEST_CORE_FEATURES +// expected-warning@-2{{OpenCL extension 'cl_khr_local_int32_base_atomics' is core feature or supported optional core feature - ignoring}} +#endif + +#ifndef cl_khr_local_int32_extended_atomics +#error "Missing cl_khr_local_int32_extended_atomics define" +#endif +#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics: enable +#if (__OPENCL_C_VERSION__ >= 110) && defined TEST_CORE_FEATURES +// expected-warning@-2{{OpenCL extension 'cl_khr_local_int32_extended_atomics' is core feature or supported optional core feature - ignoring}} +#endif + +#if (__OPENCL_C_VERSION__ < 110) +// Deprecated abvoe 1.0 +#ifndef cl_khr_select_fprounding_mode +#error "Missing cl_khr_select_fp_rounding_mode define" +#endif +#pragma OPENCL EXTENSION cl_khr_select_fprounding_mode: enable +#endif + + +// Core feature in CL 1.2 +#ifndef cl_khr_fp64 +#error "Missing cl_khr_fp64 define" +#endif +#pragma OPENCL EXTENSION cl_khr_fp64: enable +#if (__OPENCL_C_VERSION__ >= 120) && defined TEST_CORE_FEATURES +// expected-warning@-2{{OpenCL extension 'cl_khr_fp64' is core feature or supported optional core feature - ignoring}} +#endif + +//Core feature in CL 2.0 +#ifndef cl_khr_3d_image_writes +#error "Missing cl_khr_3d_image_writes define" +#endif +#pragma OPENCL EXTENSION cl_khr_3d_image_writes: enable +#if (__OPENCL_C_VERSION__ >= 200) && defined TEST_CORE_FEATURES +// expected-warning@-2{{OpenCL extension 'cl_khr_3d_image_writes' is core feature or supported optional core feature - ignoring}} +#endif + + + +#if (__OPENCL_C_VERSION__ >= 110) +#ifndef cl_khr_gl_event +#error "Missing cl_khr_gl_event define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_gl_event' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_gl_event: enable + +#if (__OPENCL_C_VERSION__ >= 110) +#ifndef cl_khr_d3d10_sharing +#error "Missing cl_khr_d3d10_sharing define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_d3d10_sharing' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_d3d10_sharing: enable + +#if (__OPENCL_C_VERSION__ >= 120) +#ifndef cl_khr_context_abort +#error "Missing cl_context_abort define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_context_abort' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_context_abort: enable + +#if (__OPENCL_C_VERSION__ >= 120) +#ifndef cl_khr_d3d11_sharing +#error "Missing cl_khr_d3d11_sharing define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_d3d11_sharing' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_d3d11_sharing: enable + +#if (__OPENCL_C_VERSION__ >= 120) +#ifndef cl_khr_dx9_media_sharing +#error "Missing cl_khr_dx9_media_sharing define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_dx9_media_sharing' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_dx9_media_sharing: enable + +#if (__OPENCL_C_VERSION__ >= 120) +#ifndef cl_khr_image2d_from_buffer +#error "Missing cl_khr_image2d_from_buffer define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_image2d_from_buffer' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_image2d_from_buffer: enable + +#if (__OPENCL_C_VERSION__ >= 120) +#ifndef cl_khr_initialize_memory +#error "Missing cl_khr_initialize_memory define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_initialize_memory' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_initialize_memory: enable + +#if (__OPENCL_C_VERSION__ >= 120) +#ifndef cl_khr_gl_depth_images +#error "Missing cl_khr_gl_depth_images define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_gl_depth_images' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_gl_depth_images: enable + +#if (__OPENCL_C_VERSION__ >= 120) +#ifndef cl_khr_gl_msaa_sharing +#error "Missing cl_khr_gl_msaa_sharing define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_gl_msaa_sharing' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing: enable + +#if (__OPENCL_C_VERSION__ >= 120) +#ifndef cl_khr_spir +#error "Missing cl_khr_spir define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_spir' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_spir: enable + +#if (__OPENCL_C_VERSION__ >= 200) +#ifndef cl_khr_egl_event +#error "Missing cl_khr_egl_event define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_egl_event' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_egl_event: enable + +#if (__OPENCL_C_VERSION__ >= 200) +#ifndef cl_khr_egl_image +#error "Missing cl_khr_egl_image define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_egl_image' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_egl_image: enable + +#if (__OPENCL_C_VERSION__ >= 200) +#ifndef cl_khr_srgb_image_writes +#error "Missing cl_khr_srgb_image_writes define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_srgb_image_writes' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_srgb_image_writes: enable + +#if (__OPENCL_C_VERSION__ >= 200) +#ifndef cl_khr_subgroups +#error "Missing cl_khr_subgroups define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_subgroups' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_subgroups: enable + +#if (__OPENCL_C_VERSION__ >= 200) +#ifndef cl_khr_terminate_context +#error "Missing cl_khr_terminate_context define" +#endif +#else +// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_terminate_context' - ignoring}} +#endif +#pragma OPENCL EXTENSION cl_khr_terminate_context: enable diff --git a/test/SemaOpenCL/extensions.cl b/test/SemaOpenCL/extensions.cl new file mode 100644 index 000000000000..31224e0df774 --- /dev/null +++ b/test/SemaOpenCL/extensions.cl @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only +// RUN: %clang_cc1 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-std=CL1.1 + +// Test with a target not supporting fp64. +// RUN: %clang_cc1 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -DNOFP64 + +void f1(double da) { // expected-error {{type 'double' requires cl_khr_fp64 extension}} + double d; // expected-error {{type 'double' requires cl_khr_fp64 extension}} + (void) 1.0; // expected-warning {{double precision constant requires cl_khr_fp64}} +} + +#pragma OPENCL EXTENSION cl_khr_fp64 : enable +#ifdef NOFP64 +// expected-warning@-2{{unsupported OpenCL extension 'cl_khr_fp64' - ignoring}} +#endif + +void f2(void) { + double d; +#ifdef NOFP64 +// expected-error@-2{{use of type 'double' requires cl_khr_fp64 extension to be enabled}} +#endif + + (void) 1.0; +#ifdef NOFP64 +// expected-warning@-2{{double precision constant requires cl_khr_fp64, casting to single precision}} +#endif +} + +#pragma OPENCL EXTENSION cl_khr_fp64 : disable +#ifdef NOFP64 +// expected-warning@-2{{unsupported OpenCL extension 'cl_khr_fp64' - ignoring}} +#endif + +void f3(void) { + double d; // expected-error {{type 'double' requires cl_khr_fp64 extension}} +} diff --git a/test/SemaOpenCL/extern.cl b/test/SemaOpenCL/extern.cl index b2e4857e28da..5f1f9f80b0fa 100644 --- a/test/SemaOpenCL/extern.cl +++ b/test/SemaOpenCL/extern.cl @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -x cl -cl-std=CL1.2 -emit-llvm -ffake-address-space-map %s -o - -verify | FileCheck %s +// RUN: %clang_cc1 -x cl -cl-opt-disable -cl-std=CL1.2 -emit-llvm -ffake-address-space-map %s -o - -verify | FileCheck %s // expected-no-diagnostics // CHECK: @foo = external addrspace(3) constant float diff --git a/test/SemaOpenCL/half.cl b/test/SemaOpenCL/half.cl index 11abf64633be..dd7bb9ab8c5d 100644 --- a/test/SemaOpenCL/half.cl +++ b/test/SemaOpenCL/half.cl @@ -1,6 +1,7 @@ -// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -Wno-unused-value +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -Wno-unused-value -triple spir-unknown-unknown #pragma OPENCL EXTENSION cl_khr_fp16 : disable +constant float f = 1.0h; // expected-error{{half precision constant requires cl_khr_fp16}} half half_disabled(half *p, // expected-error{{declaring function return value of type 'half' is not allowed}} half h) // expected-error{{declaring function parameter of type 'half' is not allowed}} @@ -12,6 +13,8 @@ half half_disabled(half *p, // expected-error{{declaring function return value o float c = 1.0f; b = (half) c; // expected-error{{casting to type 'half' is not allowed}} + c = (float) 1.0h; // expected-error{{half precision constant requires cl_khr_fp16}} + b = 1.0h; // expected-error{{half precision constant requires cl_khr_fp16}} half *allowed = &p[1]; half *allowed2 = &*p; @@ -22,6 +25,7 @@ half half_disabled(half *p, // expected-error{{declaring function return value o // Exactly the same as above but with the cl_khr_fp16 extension enabled. #pragma OPENCL EXTENSION cl_khr_fp16 : enable +constant half a = 1.0h; half half_enabled(half *p, half h) { half a[2]; @@ -31,6 +35,8 @@ half half_enabled(half *p, half h) float c = 1.0f; b = (half) c; + c = (float) 1.0h; + b = 1.0h; half *allowed = &p[1]; half *allowed2 = &*p; diff --git a/test/SemaOpenCL/images.cl b/test/SemaOpenCL/images.cl new file mode 100644 index 000000000000..f963de4e1359 --- /dev/null +++ b/test/SemaOpenCL/images.cl @@ -0,0 +1,9 @@ +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only + +void img2d_ro(__read_only image2d_t img) {} // expected-note{{passing argument to parameter 'img' here}} expected-note{{passing argument to parameter 'img' here}} + +void imgage_access_test(image2d_t img2dro, write_only image2d_t img2dwo, image3d_t img3dro) { + img2d_ro(img2dro); + img2d_ro(img2dwo); // expected-error{{passing '__write_only image2d_t' to parameter of incompatible type '__read_only image2d_t'}} + img2d_ro(img3dro); // expected-error{{passing '__read_only image3d_t' to parameter of incompatible type '__read_only image2d_t'}} +} diff --git a/test/SemaOpenCL/invalid-block.cl b/test/SemaOpenCL/invalid-block.cl new file mode 100644 index 000000000000..6721d0ea234a --- /dev/null +++ b/test/SemaOpenCL/invalid-block.cl @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 -verify -fblocks -cl-std=CL2.0 %s + +// OpenCL v2.0 s6.12.5 +void f0(int (^const bl)()); +// All blocks declarations must be const qualified and initialized. +void f1() { + int (^bl1)() = ^() {return 1;}; + int (^const bl2)() = ^(){return 1;}; + f0(bl1); + f0(bl2); + bl1 = bl2; // expected-error{{invalid operands to binary expression ('int (^const)()' and 'int (^const)()')}} + int (^const bl3)(); // expected-error{{invalid block variable declaration - must be initialized}} +} + +// A block with extern storage class is not allowed. +extern int (^bl)() = ^(){return 1;}; // expected-error{{invalid block variable declaration - using 'extern' storage class is disallowed}} +void f2() { + extern int (^bl)() = ^(){return 1;}; // expected-error{{invalid block variable declaration - using 'extern' storage class is disallowed}} +} + +// A block cannot be the return value of a function. +typedef int (^bl_t)(void); +bl_t f3(bl_t bl); // expected-error{{declaring function return value of type 'bl_t' (aka 'int (^const)(void)') is not allowed}} + +struct bl_s { + int (^bl)(void); // expected-error {{the 'int (^const)(void)' type cannot be used to declare a structure or union field}} +}; + +void f4() { + __block int a = 10; // expected-error {{the __block storage type is not permitted}} +} + +// A block with variadic argument is not allowed. +int (^bl)(int, ...) = ^int(int I, ...) { // expected-error {{invalid block prototype, variadic arguments are not allowed in OpenCL}} + return 0; +}; + +// A block can't be used to declare an array +typedef int (^bl1_t)(int); +void f5(int i) { + bl1_t bl1 = ^(int i) {return 1;}; + bl1_t bl2 = ^(int i) {return 2;}; + bl1_t arr[] = {bl1, bl2}; // expected-error {{array of 'bl1_t' (aka 'int (^const)(int)') type is invalid in OpenCL}} + int tmp = i ? bl1(i) // expected-error {{block type cannot be used as expression in ternary expression in OpenCL}} + : bl2(i); // expected-error {{block type cannot be used as expression in ternary expression in OpenCL}} +} +// A block pointer type and all pointer operations are disallowed +void f6(bl1_t * bl_ptr) { // expected-error{{pointer to type '__generic bl1_t' (aka 'int (^const __generic)(int)') is invalid in OpenCL}} + bl1_t bl = ^(int i) {return 1;}; + bl1_t *p; // expected-error {{pointer to type '__generic bl1_t' (aka 'int (^const __generic)(int)') is invalid in OpenCL}} + *bl; // expected-error {{invalid argument type 'bl1_t' (aka 'int (^const)(int)') to unary expression}} + &bl; // expected-error {{invalid argument type 'bl1_t' (aka 'int (^const)(int)') to unary expression}} +} diff --git a/test/SemaOpenCL/invalid-image.cl b/test/SemaOpenCL/invalid-image.cl new file mode 100644 index 000000000000..d15746fbab91 --- /dev/null +++ b/test/SemaOpenCL/invalid-image.cl @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -verify %s + +void test1(image1d_t *i) {} // expected-error{{pointer to type '__read_only image1d_t' is invalid in OpenCL}} + +void test2(image1d_t i) { + image1d_t ti; // expected-error{{type '__read_only image1d_t' can only be used as a function parameter}} + image1d_t ai[] = {i, i}; // expected-error{{array of '__read_only image1d_t' type is invalid in OpenCL}} + i=i; // expected-error{{invalid operands to binary expression ('__read_only image1d_t' and '__read_only image1d_t')}} + i+1; // expected-error{{invalid operands to binary expression ('__read_only image1d_t' and 'int')}} + &i; // expected-error{{invalid argument type '__read_only image1d_t' to unary expression}} + *i; // expected-error{{invalid argument type '__read_only image1d_t' to unary expression}} +} + +image1d_t test3() {} // expected-error{{declaring function return value of type '__read_only image1d_t' is not allowed}} diff --git a/test/SemaOpenCL/invalid-kernel-attrs.cl b/test/SemaOpenCL/invalid-kernel-attrs.cl index 4b4fdf79e3d1..cedbb0664675 100644 --- a/test/SemaOpenCL/invalid-kernel-attrs.cl +++ b/test/SemaOpenCL/invalid-kernel-attrs.cl @@ -28,8 +28,6 @@ constant int foo3 __attribute__((vec_type_hint(char))) = 0; // expected-error {{ void f_kernel_image2d_t( kernel image2d_t image ) { // expected-error {{'kernel' attribute only applies to functions}} int __kernel x; // expected-error {{'__kernel' attribute only applies to functions}} - read_only int i; // expected-error {{'read_only' attribute only applies to parameters}} - __write_only int j; // expected-error {{'__write_only' attribute only applies to parameters}} } kernel __attribute__((reqd_work_group_size(1,2,0))) void kernel11(){} // expected-error {{'reqd_work_group_size' attribute must be greater than 0}} diff --git a/test/SemaOpenCL/invalid-kernel-parameters.cl b/test/SemaOpenCL/invalid-kernel-parameters.cl index de32eae8821e..e2e48e83c6b9 100644 --- a/test/SemaOpenCL/invalid-kernel-parameters.cl +++ b/test/SemaOpenCL/invalid-kernel-parameters.cl @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s +// RUN: %clang_cc1 -fsyntax-only -verify %s -triple spir-unknown-unknown #pragma OPENCL EXTENSION cl_khr_fp16 : enable @@ -24,7 +24,10 @@ kernel void bool_in_struct_arg(ContainsBool x) { } // expected-error{{'ContainsB typedef struct FooImage2D // expected-note{{within field of type 'FooImage2D' declared here}} { - image2d_t imageField; // expected-note{{field of illegal type 'image2d_t' declared here}} + // TODO: Clean up needed - we don't really need to check for image, event, etc + // as a note here any longer. + // They are diagnosed as an error for all struct fields (OpenCL v1.2 s6.9b,r). + image2d_t imageField; // expected-note{{field of illegal type '__read_only image2d_t' declared here}} expected-error{{the '__read_only image2d_t' type cannot be used to declare a structure or union field}} } FooImage2D; kernel void image_in_struct_arg(FooImage2D arg) { } // expected-error{{struct kernel parameters may not contain pointers}} diff --git a/test/SemaOpenCL/invalid-logical-ops-1.2.cl b/test/SemaOpenCL/invalid-logical-ops-1.2.cl index 7ba1adbf53e0..bee52396cc6c 100644 --- a/test/SemaOpenCL/invalid-logical-ops-1.2.cl +++ b/test/SemaOpenCL/invalid-logical-ops-1.2.cl @@ -1,6 +1,7 @@ // RUN: %clang_cc1 %s -verify -cl-std=CL1.2 -triple x86_64-unknown-linux-gnu #pragma OPENCL EXTENSION cl_khr_fp64 : enable + typedef __attribute__((ext_vector_type(4))) float float4; typedef __attribute__((ext_vector_type(4))) double double4; typedef __attribute__((ext_vector_type(4))) int int4; diff --git a/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl b/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl new file mode 100644 index 000000000000..386c6b6c7456 --- /dev/null +++ b/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl @@ -0,0 +1,65 @@ +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 + +void test1(read_only pipe int p, global int* ptr){ + int tmp; + reserve_id_t rid; + + // read/write_pipe + read_pipe(p, &tmp); + read_pipe(p, ptr); + read_pipe(tmp, p); // expected-error {{first argument to 'read_pipe' must be a pipe type}} + read_pipe(p); // expected-error {{invalid number of arguments to function: 'read_pipe'}} + read_pipe(p, rid, tmp, ptr); + read_pipe(p, tmp, tmp, ptr); // expected-error {{invalid argument type to function 'read_pipe' (expecting 'reserve_id_t' having 'int')}} + read_pipe(p, rid, rid, ptr); // expected-error {{invalid argument type to function 'read_pipe' (expecting 'unsigned int' having 'reserve_id_t')}} + read_pipe(p, tmp); // expected-error {{invalid argument type to function 'read_pipe' (expecting 'int *' having 'int')}} + write_pipe(p, ptr); // expected-error {{invalid pipe access modifier (expecting write_only)}} + write_pipe(p, rid, tmp, ptr); // expected-error {{invalid pipe access modifier (expecting write_only)}} + + // reserve_read/write_pipe + reserve_read_pipe(p, tmp); + reserve_read_pipe(p, ptr); // expected-error{{invalid argument type to function 'reserve_read_pipe' (expecting 'unsigned int' having '__global int *')}} + work_group_reserve_read_pipe(tmp, tmp); // expected-error{{first argument to 'work_group_reserve_read_pipe' must be a pipe type}} + sub_group_reserve_write_pipe(p, tmp); // expected-error{{invalid pipe access modifier (expecting write_only)}} + + // commit_read/write_pipe + commit_read_pipe(p, rid); + commit_read_pipe(tmp, rid); // expected-error{{first argument to 'commit_read_pipe' must be a pipe type}} + work_group_commit_read_pipe(p, tmp); // expected-error{{invalid argument type to function 'work_group_commit_read_pipe' (expecting 'reserve_id_t' having 'int')}} + sub_group_commit_write_pipe(p, tmp); // expected-error{{invalid pipe access modifier (expecting write_only)}} +} + +void test2(write_only pipe int p, global int* ptr){ + int tmp; + reserve_id_t rid; + + // read/write_pipe + write_pipe(p, &tmp); + write_pipe(p, ptr); + write_pipe(tmp, p); // expected-error {{first argument to 'write_pipe' must be a pipe type}} + write_pipe(p); // expected-error {{invalid number of arguments to function: 'write_pipe'}} + write_pipe(p, rid, tmp, ptr); + write_pipe(p, tmp, tmp, ptr); // expected-error {{invalid argument type to function 'write_pipe' (expecting 'reserve_id_t' having 'int')}} + write_pipe(p, rid, rid, ptr); // expected-error {{invalid argument type to function 'write_pipe' (expecting 'unsigned int' having 'reserve_id_t')}} + write_pipe(p, tmp); // expected-error {{invalid argument type to function 'write_pipe' (expecting 'int *' having 'int')}} + read_pipe(p, ptr); // expected-error {{invalid pipe access modifier (expecting read_only)}} + read_pipe(p, rid, tmp, ptr); // expected-error {{invalid pipe access modifier (expecting read_only)}} + + // reserve_read/write_pipe + reserve_write_pipe(p, tmp); + reserve_write_pipe(p, ptr); // expected-error{{invalid argument type to function 'reserve_write_pipe' (expecting 'unsigned int' having '__global int *')}} + work_group_reserve_write_pipe(tmp, tmp); // expected-error{{first argument to 'work_group_reserve_write_pipe' must be a pipe type}} + sub_group_reserve_read_pipe(p, tmp); // expected-error{{invalid pipe access modifier (expecting read_only)}} + + // commit_read/write_pipe + commit_write_pipe(p, rid); + commit_write_pipe(tmp, rid); // expected-error{{first argument to 'commit_write_pipe' must be a pipe type}} + work_group_commit_write_pipe(p, tmp); // expected-error{{invalid argument type to function 'work_group_commit_write_pipe' (expecting 'reserve_id_t' having 'int')}} + sub_group_commit_read_pipe(p, tmp); // expected-error{{invalid pipe access modifier (expecting read_only)}} +} + +void test3(){ + int tmp; + get_pipe_num_packets(tmp); // expected-error {{first argument to 'get_pipe_num_packets' must be a pipe type}} + get_pipe_max_packets(tmp); // expected-error {{first argument to 'get_pipe_max_packets' must be a pipe type}} +} diff --git a/test/SemaOpenCL/invalid-pipes-cl2.0.cl b/test/SemaOpenCL/invalid-pipes-cl2.0.cl index ee36892b93d4..1993df5c44d4 100644 --- a/test/SemaOpenCL/invalid-pipes-cl2.0.cl +++ b/test/SemaOpenCL/invalid-pipes-cl2.0.cl @@ -1,8 +1,22 @@ // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -void test1(pipe int *p){// expected-error {{pipes packet types cannot be of reference type}} +void test1(pipe int *p) {// expected-error {{pipes packet types cannot be of reference type}} } -void test2(pipe p){// expected-error {{missing actual type specifier for pipe}} +void test2(pipe p) {// expected-error {{missing actual type specifier for pipe}} } -void test3(int pipe p){// expected-error {{cannot combine with previous 'int' declaration specifier}} +void test3(int pipe p) {// expected-error {{cannot combine with previous 'int' declaration specifier}} } +void test4() { + pipe int p; // expected-error {{type 'pipe int' can only be used as a function parameter}} + //TODO: fix parsing of this pipe int (*p); +} + +void test5(pipe int p) { + p+p; // expected-error{{invalid operands to binary expression ('pipe int' and 'pipe int')}} + p=p; // expected-error{{invalid operands to binary expression ('pipe int' and 'pipe int')}} + &p; // expected-error{{invalid argument type 'pipe int' to unary expression}} + *p; // expected-error{{invalid argument type 'pipe int' to unary expression}} +} + +typedef pipe int pipe_int_t; +pipe_int_t test6() {} // expected-error{{declaring function return value of type 'pipe_int_t' (aka 'pipe int') is not allowed}} diff --git a/test/SemaOpenCL/nosvm.cl b/test/SemaOpenCL/nosvm.cl new file mode 100644 index 000000000000..658cb3aaf4d1 --- /dev/null +++ b/test/SemaOpenCL/nosvm.cl @@ -0,0 +1,17 @@ +// RUN: %clang_cc1 -verify %s +// RUN: %clang_cc1 -verify -cl-std=CL2.0 -D CL20 %s +// RUN: %clang_cc1 -verify -x c -D NOCL %s + +#ifndef NOCL +kernel void f(__attribute__((nosvm)) global int* a); +#ifndef CL20 +// expected-error@-2 {{'nosvm' attribute requires OpenCL version 2.0}} +#else +// expected-warning@-4 {{'nosvm' attribute is deprecated and ignored in OpenCL version 2.0}} +#endif + +__attribute__((nosvm)) void g(); // expected-warning {{'nosvm' attribute only applies to variables}} + +#else +void f(__attribute__((nosvm)) int* a); // expected-warning {{'nosvm' attribute ignored}} +#endif diff --git a/test/SemaOpenCL/optional-core-fp64-cl1.2.cl b/test/SemaOpenCL/optional-core-fp64-cl1.2.cl deleted file mode 100644 index e0f7f1db4ff1..000000000000 --- a/test/SemaOpenCL/optional-core-fp64-cl1.2.cl +++ /dev/null @@ -1,20 +0,0 @@ -// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -// expected-no-diagnostics - -void f1(double da) { - double d; - (void) 1.0; -} - -#pragma OPENCL EXTENSION cl_khr_fp64 : enable - -void f2(void) { - double d; - (void) 1.0; -} - -#pragma OPENCL EXTENSION cl_khr_fp64 : disable - -void f3(void) { - double d; -} diff --git a/test/SemaOpenCL/optional-core-fp64-cl2.0.cl b/test/SemaOpenCL/optional-core-fp64-cl2.0.cl deleted file mode 100644 index 832529d4adf7..000000000000 --- a/test/SemaOpenCL/optional-core-fp64-cl2.0.cl +++ /dev/null @@ -1,20 +0,0 @@ -// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -// expected-no-diagnostics - -void f1(double da) { - double d; - (void) 1.0; -} - -#pragma OPENCL EXTENSION cl_khr_fp64 : enable - -void f2(void) { - double d; - (void) 1.0; -} - -#pragma OPENCL EXTENSION cl_khr_fp64 : disable - -void f3(void) { - double d; -} diff --git a/test/SemaOpenCL/sampler_t.cl b/test/SemaOpenCL/sampler_t.cl index 96f6dbf086b7..0553db8fd662 100644 --- a/test/SemaOpenCL/sampler_t.cl +++ b/test/SemaOpenCL/sampler_t.cl @@ -2,12 +2,30 @@ constant sampler_t glb_smp = 5; -void foo(sampler_t); +void foo(sampler_t); + +constant struct sampler_s { + sampler_t smp; // expected-error{{the 'sampler_t' type cannot be used to declare a structure or union field}} +} sampler_str = {0}; void kernel ker(sampler_t argsmp) { - local sampler_t smp; // expected-error {{sampler type cannot be used with the __local and __global address space qualifiers}} + local sampler_t smp; // expected-error{{sampler type cannot be used with the __local and __global address space qualifiers}} const sampler_t const_smp = 7; foo(glb_smp); foo(const_smp); - foo(5); // expected-error {{sampler_t variable required - got 'int'}} + foo(5); // expected-error{{sampler_t variable required - got 'int'}} + sampler_t sa[] = {argsmp, const_smp}; // expected-error {{array of 'sampler_t' type is invalid in OpenCL}} } + +void bad(sampler_t*); // expected-error{{pointer to type 'sampler_t' is invalid in OpenCL}} + +void bar() { + sampler_t smp1 = 7; + sampler_t smp2 = 2; + smp1=smp2; //expected-error{{invalid operands to binary expression ('sampler_t' and 'sampler_t')}} + smp1+1; //expected-error{{invalid operands to binary expression ('sampler_t' and 'int')}} + &smp1; //expected-error{{invalid argument type 'sampler_t' to unary expression}} + *smp2; //expected-error{{invalid argument type 'sampler_t' to unary expression}} +} + +sampler_t bad(); //expected-error{{declaring function return value of type 'sampler_t' is not allowed}} diff --git a/test/SemaOpenCL/storageclass-cl20.cl b/test/SemaOpenCL/storageclass-cl20.cl index c8e7faa208f1..1eba64b44c8a 100644 --- a/test/SemaOpenCL/storageclass-cl20.cl +++ b/test/SemaOpenCL/storageclass-cl20.cl @@ -1,15 +1,19 @@ -// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -DCL20 -cl-std=CL2.0 +// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 static constant int G1 = 0; int G2 = 0; global int G3 = 0; -local int G4 = 0;// expected-error{{program scope variable must reside in global or constant address space}} +local int G4 = 0; // expected-error{{program scope variable must reside in global or constant address space}} void kernel foo() { static int S1 = 5; static global int S2 = 5; - static private int S3 = 5;// expected-error{{program scope variable must reside in global or constant address space}} + static private int S3 = 5; // expected-error{{static local variable must reside in global or constant address space}} constant int L1 = 0; local int L2; + global int L3; // expected-error{{function scope variable cannot be declared in global address space}} + + extern global int G5; + extern int G6; // expected-error{{extern variable must reside in global or constant address space}} } diff --git a/test/SemaOpenCL/storageclass.cl b/test/SemaOpenCL/storageclass.cl index c7d8ab984687..a93f8244dcbd 100644 --- a/test/SemaOpenCL/storageclass.cl +++ b/test/SemaOpenCL/storageclass.cl @@ -13,7 +13,8 @@ void kernel foo() { constant int L1 = 0; local int L2; - auto int L3 = 7; // expected-error{{OpenCL does not support the 'auto' storage class specifier}} + auto int L3 = 7; // expected-error{{OpenCL version 1.2 does not support the 'auto' storage class specifier}} + global int L4; // expected-error{{function scope variable cannot be declared in global address space}} } static void kernel bar() { // expected-error{{kernel functions cannot be declared static}} @@ -26,4 +27,6 @@ void f() { constant int L1 = 0; // expected-error{{non-kernel function variable cannot be declared in constant address space}} local int L2; // expected-error{{non-kernel function variable cannot be declared in local address space}} } + global int L3; // expected-error{{function scope variable cannot be declared in global address space}} + extern constant float L4; } diff --git a/test/SemaOpenCL/to_addr_builtin.cl b/test/SemaOpenCL/to_addr_builtin.cl new file mode 100644 index 000000000000..a145626cfcee --- /dev/null +++ b/test/SemaOpenCL/to_addr_builtin.cl @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -verify -fsyntax-only %s +// RUN: %clang_cc1 -verify -fsyntax-only -cl-std=CL2.0 %s + +void test(void) { + global int *glob; + local int *loc; + constant int *con; + typedef constant int const_int_ty; + const_int_ty *con_typedef; + + glob = to_global(glob, loc); +#if __OPENCL_C_VERSION__ < CL_VERSION_2_0 + // expected-warning@-2{{implicit declaration of function 'to_global' is invalid in C99}} + // expected-warning@-3{{incompatible integer to pointer conversion assigning to '__global int *' from 'int'}} +#else + // expected-error@-5{{invalid number of arguments to function: 'to_global'}} +#endif + + int x; + glob = to_global(x); +#if __OPENCL_C_VERSION__ < CL_VERSION_2_0 + // expected-warning@-2{{incompatible integer to pointer conversion assigning to '__global int *' from 'int'}} +#else + // expected-error@-4{{invalid argument x to function: 'to_global', expecting a generic pointer argument}} +#endif + + glob = to_global(con); +#if __OPENCL_C_VERSION__ < CL_VERSION_2_0 + // expected-warning@-2{{incompatible integer to pointer conversion assigning to '__global int *' from 'int'}} +#else + // expected-error@-4{{invalid argument con to function: 'to_global', expecting a generic pointer argument}} +#endif + + glob = to_global(con_typedef); +#if __OPENCL_C_VERSION__ < CL_VERSION_2_0 + // expected-warning@-2{{incompatible integer to pointer conversion assigning to '__global int *' from 'int'}} +#else + // expected-error@-4{{invalid argument con_typedef to function: 'to_global', expecting a generic pointer argument}} +#endif + + loc = to_global(glob); +#if __OPENCL_C_VERSION__ < CL_VERSION_2_0 + // expected-warning@-2{{incompatible integer to pointer conversion assigning to '__local int *' from 'int'}} +#else + // expected-error@-4{{assigning '__global int *' to '__local int *' changes address space of pointer}} +#endif + + global char *glob_c = to_global(loc); +#if __OPENCL_C_VERSION__ < CL_VERSION_2_0 + // expected-warning@-2{{incompatible integer to pointer conversion initializing '__global char *' with an expression of type 'int'}} +#else + // expected-warning@-4{{incompatible pointer types initializing '__global char *' with an expression of type '__global int *'}} +#endif + +} diff --git a/test/SemaOpenCL/unroll-hint.cl b/test/SemaOpenCL/unroll-hint.cl new file mode 100644 index 000000000000..996986603695 --- /dev/null +++ b/test/SemaOpenCL/unroll-hint.cl @@ -0,0 +1,30 @@ +//RUN: %clang_cc1 -O0 -fsyntax-only -verify %s +//RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify -DCL20 %s + +kernel void D (global int *x) { + int i = 10; +#ifndef CL20 + // expected-error@+2 {{'opencl_unroll_hint' attribute requires OpenCL version 2.0 or above}} +#endif + __attribute__((opencl_unroll_hint)) + do { + } while(i--); +} + +#ifdef CL20 +kernel void C (global int *x) { + int I = 3; + __attribute__((opencl_unroll_hint(I))) // expected-error {{'opencl_unroll_hint' attribute requires an integer constant}} + while (I--); +} + +kernel void E() { + __attribute__((opencl_unroll_hint(2,4))) // expected-error {{'opencl_unroll_hint' attribute takes no more than 1 argument}} + for(int i=0; i<100; i++); +} + +kernel void F() { + __attribute__((opencl_unroll_hint(-1))) // expected-error {{'opencl_unroll_hint' attribute requires a positive integral compile time constant expression}} + for(int i=0; i<100; i++); +} +#endif diff --git a/test/SemaOpenCL/unsupported.cl b/test/SemaOpenCL/unsupported.cl index bb9da4b272d7..a39a61b9542a 100644 --- a/test/SemaOpenCL/unsupported.cl +++ b/test/SemaOpenCL/unsupported.cl @@ -7,3 +7,7 @@ struct { void no_vla(int n) { int a[n]; // expected-error {{variable length arrays are not supported in OpenCL}} } + +void no_logxor(int n) { + int logxor = n ^^ n; // expected-error {{^^ is a reserved operator in OpenCL}} +} |