maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/SemaOpenCL/storageclass.cl

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

281 lines
14 KiB
Common Lisp
Raw Normal View History

Extend the support for cl-std to include 1.2. Add error checking for the static qualifier which is now allowed in certain situations for OpenCL 1.2. Use the CL version to turn on this feature. Added test case for 1.2 static storage class feature. llvm-svn: 158759
2012-06-20 07:09:52 +08:00
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2
[OpenCL] Add support of __opencl_c_device_enqueue feature macro. This feature requires support of __opencl_c_generic_address_space and __opencl_c_program_scope_global_variables so diagnostics for that is provided as well. Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D115640
2021-12-13 23:43:37 +08:00
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=-all
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=-all,+__opencl_c_program_scope_global_variables
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=-all,+__opencl_c_generic_address_space
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=-all,+__opencl_c_program_scope_global_variables,+__opencl_c_generic_address_space
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=clc++2021 -cl-ext=-all
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=clc++2021 -cl-ext=-all,+__opencl_c_program_scope_global_variables
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=clc++2021 -cl-ext=-all,+__opencl_c_generic_address_space
// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=clc++2021 -cl-ext=-all,+__opencl_c_program_scope_global_variables,+__opencl_c_generic_address_space
[OpenCL 2.0] Enable program scope variables, Section 6.5.1. - Remove virtual SC_OpenCLWorkGroupLocal storage type specifier as it conflicts with static local variables now and prevents diagnosing static local address space variables correctly. - Allow static local and global variables (OpenCL2.0 s6.8 and s6.5.1). - Improve diagnostics of allowed ASes for variables in different scopes: (i) Global or static local variables have to be in global or constant ASes (OpenCL1.2 s6.5, OpenCL2.0 s6.5.1); (ii) Non-kernel function variables can't be declared in local or constant ASes (OpenCL1.1 s6.5.2 and s6.5.3). http://reviews.llvm.org/D13105 llvm-svn: 248906
2015-09-30 22:08:20 +08:00
static constant int G1 = 0;
constant int G2 = 0;
Extend the support for cl-std to include 1.2. Add error checking for the static qualifier which is now allowed in certain situations for OpenCL 1.2. Use the CL version to turn on this feature. Added test case for 1.2 static storage class feature. llvm-svn: 158759
2012-06-20 07:09:52 +08:00
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
int G3 = 0;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{program scope variable must reside in constant address space}}
#endif
global int G4 = 0;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{program scope variable must reside in constant address space}}
#endif
static float g_implicit_static_var = 0;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{program scope variable must reside in constant address space}}
#endif
[OpenCL] Add LangAS::opencl_private to represent private address space in AST Currently Clang uses default address space (0) to represent private address space for OpenCL in AST. There are two issues with this: Multiple address spaces including private address space cannot be diagnosed. There is no mangling for default address space. For example, if private int* is emitted as i32 addrspace(5)* in IR. It is supposed to be mangled as PUAS5i but it is mangled as Pi instead. This patch attempts to represent OpenCL private address space explicitly in AST. It adds a new enum LangAS::opencl_private and adds it to the variable types which are implicitly private: automatic variables without address space qualifier function parameter pointee type without address space qualifier (OpenCL 1.2 and below) Differential Revision: https://reviews.llvm.org/D35082 llvm-svn: 315668
2017-10-13 11:37:48 +08:00
static constant float g_constant_static_var = 0;
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
static global float g_global_static_var = 0;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{program scope variable must reside in constant address space}}
#endif
static local float g_local_static_var = 0;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{program scope variable must reside in constant address space}}
#else
// expected-error@-4 {{program scope variable must reside in global or constant address space}}
#endif
static private float g_private_static_var = 0;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{program scope variable must reside in constant address space}}
#else
// expected-error@-4 {{program scope variable must reside in global or constant address space}}
#endif
static generic float g_generic_static_var = 0;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{OpenCL C version 1.2 does not support the 'generic' type qualifier}}
// expected-error@-3 {{program scope variable must reside in constant address space}}
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#elif (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300)
#if !defined(__opencl_c_generic_address_space)
#if (__OPENCL_C_VERSION__ == 300)
// expected-error@-7 {{OpenCL C version 3.0 does not support the 'generic' type qualifier}}
#elif (__OPENCL_CPP_VERSION__ == 202100)
// expected-error@-9 {{C++ for OpenCL version 2021 does not support the 'generic' type qualifier}}
#endif
#endif
#if !defined(__opencl_c_program_scope_global_variables)
// expected-error@-13 {{program scope variable must reside in constant address space}}
#endif
#if defined(__opencl_c_generic_address_space) && defined(__opencl_c_program_scope_global_variables)
// expected-error@-16 {{program scope variable must reside in global or constant address space}}
#endif
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
#endif
extern float g_implicit_extern_var;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{extern variable must reside in constant address space}}
#endif
[OpenCL] Add LangAS::opencl_private to represent private address space in AST Currently Clang uses default address space (0) to represent private address space for OpenCL in AST. There are two issues with this: Multiple address spaces including private address space cannot be diagnosed. There is no mangling for default address space. For example, if private int* is emitted as i32 addrspace(5)* in IR. It is supposed to be mangled as PUAS5i but it is mangled as Pi instead. This patch attempts to represent OpenCL private address space explicitly in AST. It adds a new enum LangAS::opencl_private and adds it to the variable types which are implicitly private: automatic variables without address space qualifier function parameter pointee type without address space qualifier (OpenCL 1.2 and below) Differential Revision: https://reviews.llvm.org/D35082 llvm-svn: 315668
2017-10-13 11:37:48 +08:00
extern constant float g_constant_extern_var;
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
extern global float g_global_extern_var;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{extern variable must reside in constant address space}}
#endif
extern local float g_local_extern_var;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{extern variable must reside in constant address space}}
#else
// expected-error@-4 {{extern variable must reside in global or constant address space}}
#endif
extern private float g_private_extern_var;
#ifndef __opencl_c_program_scope_global_variables
// expected-error@-2 {{extern variable must reside in constant address space}}
#else
// expected-error@-4 {{extern variable must reside in global or constant address space}}
#endif
extern generic float g_generic_extern_var;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{OpenCL C version 1.2 does not support the 'generic' type qualifier}}
// expected-error@-3 {{extern variable must reside in constant address space}}
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#elif (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300)
#if !defined(__opencl_c_generic_address_space)
#if (__OPENCL_C_VERSION__ == 300)
// expected-error@-7 {{OpenCL C version 3.0 does not support the 'generic' type qualifier}}
#elif (__OPENCL_CPP_VERSION__ == 202100)
// expected-error@-9 {{C++ for OpenCL version 2021 does not support the 'generic' type qualifier}}
#endif
#endif
#if !defined(__opencl_c_program_scope_global_variables)
// expected-error@-13 {{extern variable must reside in constant address space}}
#endif
#if defined(__opencl_c_generic_address_space) && defined(__opencl_c_program_scope_global_variables)
// expected-error@-16 {{extern variable must reside in global or constant address space}}
#endif
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
#endif
[OpenCL] Add LangAS::opencl_private to represent private address space in AST Currently Clang uses default address space (0) to represent private address space for OpenCL in AST. There are two issues with this: Multiple address spaces including private address space cannot be diagnosed. There is no mangling for default address space. For example, if private int* is emitted as i32 addrspace(5)* in IR. It is supposed to be mangled as PUAS5i but it is mangled as Pi instead. This patch attempts to represent OpenCL private address space explicitly in AST. It adds a new enum LangAS::opencl_private and adds it to the variable types which are implicitly private: automatic variables without address space qualifier function parameter pointee type without address space qualifier (OpenCL 1.2 and below) Differential Revision: https://reviews.llvm.org/D35082 llvm-svn: 315668
2017-10-13 11:37:48 +08:00
[OpenCL] Emit function-scope variable in constant address space as static variable Differential Revision: https://reviews.llvm.org/D32977 llvm-svn: 303072
2017-05-15 22:47:47 +08:00
void kernel foo(int x) {
[OpenCL 2.0] Enable program scope variables, Section 6.5.1. - Remove virtual SC_OpenCLWorkGroupLocal storage type specifier as it conflicts with static local variables now and prevents diagnosing static local address space variables correctly. - Allow static local and global variables (OpenCL2.0 s6.8 and s6.5.1). - Improve diagnostics of allowed ASes for variables in different scopes: (i) Global or static local variables have to be in global or constant ASes (OpenCL1.2 s6.5, OpenCL2.0 s6.5.1); (ii) Non-kernel function variables can't be declared in local or constant ASes (OpenCL1.1 s6.5.2 and s6.5.3). http://reviews.llvm.org/D13105 llvm-svn: 248906
2015-09-30 22:08:20 +08:00
// static is not allowed at local scope before CL2.0
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
static int S1 = 5;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{variables in function scope cannot be declared static}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{static local variable must reside in constant address space}}
#endif
static constant int S2 = 5;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{variables in function scope cannot be declared static}}
#endif
[OpenCL 2.0] Enable program scope variables, Section 6.5.1. - Remove virtual SC_OpenCLWorkGroupLocal storage type specifier as it conflicts with static local variables now and prevents diagnosing static local address space variables correctly. - Allow static local and global variables (OpenCL2.0 s6.8 and s6.5.1). - Improve diagnostics of allowed ASes for variables in different scopes: (i) Global or static local variables have to be in global or constant ASes (OpenCL1.2 s6.5, OpenCL2.0 s6.5.1); (ii) Non-kernel function variables can't be declared in local or constant ASes (OpenCL1.1 s6.5.2 and s6.5.3). http://reviews.llvm.org/D13105 llvm-svn: 248906
2015-09-30 22:08:20 +08:00
constant int L1 = 0;
local int L2;
[OpenCL] Diagnose scoped address-space qualified variables Produce an error if variables qualified with a local or a constant address space are not declared in the outermost scope of a kernel. Patch by Simon Perretta. Differential Revision: https://reviews.llvm.org/D34024 llvm-svn: 305798
2017-06-20 22:50:45 +08:00
if (true) {
local int L1; // expected-error {{variables in the local address space can only be declared in the outermost scope of a kernel function}}
constant int L1 = 42; // expected-error {{variables in the constant address space can only be declared in the outermost scope of a kernel function}}
}
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
auto int L3 = 7;
#if (__OPENCL_CPP_VERSION__ == 202100)
// expected-error@-2{{C++ for OpenCL version 2021 does not support the 'auto' storage class specifier}}
#else
// expected-error-re@-4{{OpenCL C version {{1.2|3.0}} does not support the 'auto' storage class specifier}}
#endif
CodeGen: Cast alloca to expected address space Alloca always returns a pointer in alloca address space, which may be different from the type defined by the language. For example, in C++ the auto variables are in the default address space. Therefore cast alloca to the expected address space when necessary. Differential Revision: https://reviews.llvm.org/D32248 llvm-svn: 303370
2017-05-19 02:51:09 +08:00
global int L4; // expected-error{{function scope variable cannot be declared in global address space}}
__attribute__((address_space(100))) int L5; // expected-error{{automatic variable qualified with an invalid address space}}
constant int L6 = x; // expected-error {{initializer element is not a compile-time constant}}
global int *constant L7 = &G4;
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
CodeGen: Cast alloca to expected address space Alloca always returns a pointer in alloca address space, which may be different from the type defined by the language. For example, in C++ the auto variables are in the default address space. Therefore cast alloca to the expected address space when necessary. Differential Revision: https://reviews.llvm.org/D32248 llvm-svn: 303370
2017-05-19 02:51:09 +08:00
private int *constant L8 = &x; // expected-error {{initializer element is not a compile-time constant}}
constant int *constant L9 = &L1;
local int *constant L10 = &L2; // expected-error {{initializer element is not a compile-time constant}}
Extend the support for cl-std to include 1.2. Add error checking for the static qualifier which is now allowed in certain situations for OpenCL 1.2. Use the CL version to turn on this feature. Added test case for 1.2 static storage class feature. llvm-svn: 158759
2012-06-20 07:09:52 +08:00
}
static void kernel bar() { // expected-error{{kernel functions cannot be declared static}}
}
[OpenCL 2.0] Enable program scope variables, Section 6.5.1. - Remove virtual SC_OpenCLWorkGroupLocal storage type specifier as it conflicts with static local variables now and prevents diagnosing static local address space variables correctly. - Allow static local and global variables (OpenCL2.0 s6.8 and s6.5.1). - Improve diagnostics of allowed ASes for variables in different scopes: (i) Global or static local variables have to be in global or constant ASes (OpenCL1.2 s6.5, OpenCL2.0 s6.5.1); (ii) Non-kernel function variables can't be declared in local or constant ASes (OpenCL1.1 s6.5.2 and s6.5.3). http://reviews.llvm.org/D13105 llvm-svn: 248906
2015-09-30 22:08:20 +08:00
void f() {
CodeGen: Cast alloca to expected address space Alloca always returns a pointer in alloca address space, which may be different from the type defined by the language. For example, in C++ the auto variables are in the default address space. Therefore cast alloca to the expected address space when necessary. Differential Revision: https://reviews.llvm.org/D32248 llvm-svn: 303370
2017-05-19 02:51:09 +08:00
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}}
__attribute__((address_space(100))) int L4; // expected-error{{automatic variable qualified with an invalid address space}}
[OpenCL 2.0] Enable program scope variables, Section 6.5.1. - Remove virtual SC_OpenCLWorkGroupLocal storage type specifier as it conflicts with static local variables now and prevents diagnosing static local address space variables correctly. - Allow static local and global variables (OpenCL2.0 s6.8 and s6.5.1). - Improve diagnostics of allowed ASes for variables in different scopes: (i) Global or static local variables have to be in global or constant ASes (OpenCL1.2 s6.5, OpenCL2.0 s6.5.1); (ii) Non-kernel function variables can't be declared in local or constant ASes (OpenCL1.1 s6.5.2 and s6.5.3). http://reviews.llvm.org/D13105 llvm-svn: 248906
2015-09-30 22:08:20 +08:00
{
CodeGen: Cast alloca to expected address space Alloca always returns a pointer in alloca address space, which may be different from the type defined by the language. For example, in C++ the auto variables are in the default address space. Therefore cast alloca to the expected address space when necessary. Differential Revision: https://reviews.llvm.org/D32248 llvm-svn: 303370
2017-05-19 02:51:09 +08:00
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}}
__attribute__((address_space(100))) int L4; // expected-error{{automatic variable qualified with an invalid address space}}
[OpenCL 2.0] Enable program scope variables, Section 6.5.1. - Remove virtual SC_OpenCLWorkGroupLocal storage type specifier as it conflicts with static local variables now and prevents diagnosing static local address space variables correctly. - Allow static local and global variables (OpenCL2.0 s6.8 and s6.5.1). - Improve diagnostics of allowed ASes for variables in different scopes: (i) Global or static local variables have to be in global or constant ASes (OpenCL1.2 s6.5, OpenCL2.0 s6.5.1); (ii) Non-kernel function variables can't be declared in local or constant ASes (OpenCL1.1 s6.5.2 and s6.5.3). http://reviews.llvm.org/D13105 llvm-svn: 248906
2015-09-30 22:08:20 +08:00
}
CodeGen: Cast alloca to expected address space Alloca always returns a pointer in alloca address space, which may be different from the type defined by the language. For example, in C++ the auto variables are in the default address space. Therefore cast alloca to the expected address space when necessary. Differential Revision: https://reviews.llvm.org/D32248 llvm-svn: 303370
2017-05-19 02:51:09 +08:00
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
static float l_implicit_static_var = 0;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{variables in function scope cannot be declared static}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{static local variable must reside in constant address space}}
#endif
static constant float l_constant_static_var = 0;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{variables in function scope cannot be declared static}}
#endif
static global float l_global_static_var = 0;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{variables in function scope cannot be declared static}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{static local variable must reside in constant address space}}
#endif
static local float l_local_static_var = 0;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{variables in function scope cannot be declared static}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{static local variable must reside in constant address space}}
#elif defined(__opencl_c_program_scope_global_variables)
// expected-error@-6 {{static local variable must reside in global or constant address space}}
#endif
static private float l_private_static_var = 0;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{variables in function scope cannot be declared static}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{static local variable must reside in constant address space}}
#elif defined(__opencl_c_program_scope_global_variables)
// expected-error@-6 {{static local variable must reside in global or constant address space}}
#endif
static generic float l_generic_static_var = 0;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{OpenCL C version 1.2 does not support the 'generic' type qualifier}}
// expected-error@-3 {{variables in function scope cannot be declared static}}
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#elif (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300)
#if !defined(__opencl_c_generic_address_space)
#if (__OPENCL_C_VERSION__ == 300)
// expected-error@-7 {{OpenCL C version 3.0 does not support the 'generic' type qualifier}}
#elif (__OPENCL_CPP_VERSION__ == 202100)
// expected-error@-9 {{C++ for OpenCL version 2021 does not support the 'generic' type qualifier}}
#endif
#endif
#if !defined(__opencl_c_program_scope_global_variables)
// expected-error@-13 {{static local variable must reside in constant address space}}
#endif
#if defined(__opencl_c_generic_address_space) && defined(__opencl_c_program_scope_global_variables)
// expected-error@-16 {{static local variable must reside in global or constant address space}}
#endif
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
#endif
extern float l_implicit_extern_var;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{extern variable must reside in constant address space}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{extern variable must reside in constant address space}}
#endif
CodeGen: Cast alloca to expected address space Alloca always returns a pointer in alloca address space, which may be different from the type defined by the language. For example, in C++ the auto variables are in the default address space. Therefore cast alloca to the expected address space when necessary. Differential Revision: https://reviews.llvm.org/D32248 llvm-svn: 303370
2017-05-19 02:51:09 +08:00
[OpenCL] Add LangAS::opencl_private to represent private address space in AST Currently Clang uses default address space (0) to represent private address space for OpenCL in AST. There are two issues with this: Multiple address spaces including private address space cannot be diagnosed. There is no mangling for default address space. For example, if private int* is emitted as i32 addrspace(5)* in IR. It is supposed to be mangled as PUAS5i but it is mangled as Pi instead. This patch attempts to represent OpenCL private address space explicitly in AST. It adds a new enum LangAS::opencl_private and adds it to the variable types which are implicitly private: automatic variables without address space qualifier function parameter pointee type without address space qualifier (OpenCL 1.2 and below) Differential Revision: https://reviews.llvm.org/D35082 llvm-svn: 315668
2017-10-13 11:37:48 +08:00
extern constant float l_constant_extern_var;
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
extern global float l_global_extern_var;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{extern variable must reside in constant address space}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{extern variable must reside in constant address space}}
#endif
extern local float l_local_extern_var;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{extern variable must reside in constant address space}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{extern variable must reside in constant address space}}
#elif defined(__opencl_c_program_scope_global_variables)
// expected-error@-6 {{extern variable must reside in global or constant address space}}
#endif
extern private float l_private_extern_var;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{extern variable must reside in constant address space}}
#elif !defined(__opencl_c_program_scope_global_variables)
// expected-error@-4 {{extern variable must reside in constant address space}}
#elif defined(__opencl_c_program_scope_global_variables)
// expected-error@-6 {{extern variable must reside in global or constant address space}}
#endif
extern generic float l_generic_extern_var;
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#if (defined(__OPENCL_C_VERSION__) && __OPENCL_C_VERSION__ < 300)
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
// expected-error@-2 {{OpenCL C version 1.2 does not support the 'generic' type qualifier}}
// expected-error@-3 {{extern variable must reside in constant address space}}
[OpenCL] Supports optional program scope global variables in C++ for OpenCL 2021 Adds support for macro `__opencl_c_program_scope_global_variables` in C++ for OpenCL 2021 enabling a respective optional core feature from OpenCL 3.0. This change aims to achieve compatibility between C++ for OpenCL 2021 and OpenCL 3.0. Differential Revision: https://reviews.llvm.org/D109305
2021-09-02 00:14:22 +08:00
#elif (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300)
#if !defined(__opencl_c_generic_address_space)
#if (__OPENCL_C_VERSION__ == 300)
// expected-error@-7 {{OpenCL C version 3.0 does not support the 'generic' type qualifier}}
#elif (__OPENCL_CPP_VERSION__ == 202100 && !defined(__opencl_c_generic_address_space))
// expected-error@-9 {{C++ for OpenCL version 2021 does not support the 'generic' type qualifier}}
#endif
#endif
#if !defined(__opencl_c_program_scope_global_variables)
// expected-error@-13 {{extern variable must reside in constant address space}}
#endif
#if defined(__opencl_c_generic_address_space) && defined(__opencl_c_program_scope_global_variables)
// expected-error@-16 {{extern variable must reside in global or constant address space}}
#endif
[OpenCL] Add support of __opencl_c_program_scope_global_variables feature macro Reviewed By: Anastasia Differential Revision: https://reviews.llvm.org/D103191
2021-07-15 18:02:47 +08:00
#endif
[OpenCL 2.0] Enable program scope variables, Section 6.5.1. - Remove virtual SC_OpenCLWorkGroupLocal storage type specifier as it conflicts with static local variables now and prevents diagnosing static local address space variables correctly. - Allow static local and global variables (OpenCL2.0 s6.8 and s6.5.1). - Improve diagnostics of allowed ASes for variables in different scopes: (i) Global or static local variables have to be in global or constant ASes (OpenCL1.2 s6.5, OpenCL2.0 s6.5.1); (ii) Non-kernel function variables can't be declared in local or constant ASes (OpenCL1.1 s6.5.2 and s6.5.3). http://reviews.llvm.org/D13105 llvm-svn: 248906
2015-09-30 22:08:20 +08:00
}