[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
Anastasia accepted this revision. Anastasia added a comment. This revision is now accepted and ready to land. LGTM! Thanks! https://reviews.llvm.org/D30643 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
echuraev updated this revision to Diff 93837.
echuraev marked an inline comment as done.
https://reviews.llvm.org/D30643
Files:
include/clang/Basic/DiagnosticSemaKinds.td
lib/Sema/SemaExpr.cpp
lib/Sema/SemaInit.cpp
test/Parser/opencl-atomics-cl20.cl
test/SemaOpenCL/atomic-init.cl
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can be assigned to a variable
only in global address space}}
+ atomic_int a2 = 0; // expected-error {{atomic variable can be initialized to
a variable only in global address space}}
+ private atomic_int a3 = 0; // expected-error {{atomic variable can be
initialized to a variable only in global address space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have
an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot
be declared in global address space}}
+ static global atomic_int a6 = 0;
+}
Index: test/Parser/opencl-atomics-cl20.cl
===
--- test/Parser/opencl-atomics-cl20.cl
+++ test/Parser/opencl-atomics-cl20.cl
@@ -67,7 +67,7 @@
foo();
// OpenCL v2.0 s6.13.11.8, arithemtic operations are not permitted on atomic
types.
i++; // expected-error {{invalid argument type 'atomic_int' (aka
'_Atomic(int)') to unary expression}}
- i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant in the declaration statement in the program scope}}
+ i = 1; // expected-error {{atomic variable can be assigned to a variable
only in global address space}}
i += 1; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'int')}}
i = i + i; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'atomic_int')}}
}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6502,6 +6502,20 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global
scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+S.Diag(Args[0]->getLocStart(), diag::err_opencl_atomic_init) << 1 <<
+SourceRange(Entity.getDecl()->getLocStart(), Args[0]->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and
the
// pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Index: lib/Sema/SemaExpr.cpp
===
--- lib/Sema/SemaExpr.cpp
+++ lib/Sema/SemaExpr.cpp
@@ -11121,7 +11121,7 @@
if (LHSTy->isAtomicType() || RHSTy->isAtomicType()) {
SourceRange SR(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
if (BO_Assign == Opc)
-Diag(OpLoc, diag::err_atomic_init_constant) << SR;
+Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
else
ResultTy = InvalidOperands(OpLoc, LHS, RHS);
return ExprError();
Index: include/clang/Basic/DiagnosticSemaKinds.td
===
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -8284,9 +8284,9 @@
"return value cannot be qualified with address space">;
def err_opencl_constant_no_init : Error<
"variable in constant address space must be initialized">;
-def err_atomic_init_constant : Error<
- "atomic variable can only be assigned to a compile time constant"
- " in the declaration statement in the program scope">;
+def err_opencl_atomic_init: Error<
+ "atomic variable can be %select{assigned|initialized}0 to a variable only "
+ "in global address space">;
def err_opencl_implicit_vector_conversion : Error<
"implicit conversions between vector types (%0 and %1) are not permitted">;
def err_opencl_invalid_type_array : Error<
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
Anastasia added inline comments.
Comment at: test/SemaOpenCL/atomic-init.cl:6
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can only be assigned to a
compile time constant}}
+ atomic_int a2 = 0; // expected-error {{atomic variable can be initialized to
a variable only in global address space}}
This diagnostic seems wrong! How is 1 not a compile time constant?
Didn't we agree to drop the constant bit from the error message and just keep
reporting about the program (global visibility) scope? I think the restriction
about the scope holds for both initialization and assignment and therefore I
have asked to unify the diagnostic...
https://reviews.llvm.org/D30643
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
echuraev updated this revision to Diff 93602.
echuraev marked an inline comment as done.
https://reviews.llvm.org/D30643
Files:
include/clang/Basic/DiagnosticSemaKinds.td
lib/Sema/SemaExpr.cpp
lib/Sema/SemaInit.cpp
test/Parser/opencl-atomics-cl20.cl
test/SemaOpenCL/atomic-init.cl
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can only be assigned to a
compile time constant}}
+ atomic_int a2 = 0; // expected-error {{atomic variable can be initialized to
a variable only in global address space}}
+ private atomic_int a3 = 0; // expected-error {{atomic variable can be
initialized to a variable only in global address space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have
an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot
be declared in global address space}}
+ static global atomic_int a6 = 0;
+}
Index: test/Parser/opencl-atomics-cl20.cl
===
--- test/Parser/opencl-atomics-cl20.cl
+++ test/Parser/opencl-atomics-cl20.cl
@@ -67,7 +67,7 @@
foo();
// OpenCL v2.0 s6.13.11.8, arithemtic operations are not permitted on atomic
types.
i++; // expected-error {{invalid argument type 'atomic_int' (aka
'_Atomic(int)') to unary expression}}
- i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant in the declaration statement in the program scope}}
+ i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant}}
i += 1; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'int')}}
i = i + i; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'atomic_int')}}
}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6502,6 +6502,20 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global
scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+S.Diag(Args[0]->getLocStart(), diag::err_opencl_atomic_init) << 1 <<
+SourceRange(Entity.getDecl()->getLocStart(), Args[0]->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and
the
// pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Index: lib/Sema/SemaExpr.cpp
===
--- lib/Sema/SemaExpr.cpp
+++ lib/Sema/SemaExpr.cpp
@@ -2,7 +2,7 @@
if (LHSTy->isAtomicType() || RHSTy->isAtomicType()) {
SourceRange SR(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
if (BO_Assign == Opc)
-Diag(OpLoc, diag::err_atomic_init_constant) << SR;
+Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
else
ResultTy = InvalidOperands(OpLoc, LHS, RHS);
return ExprError();
Index: include/clang/Basic/DiagnosticSemaKinds.td
===
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -8284,9 +8284,9 @@
"return value cannot be qualified with address space">;
def err_opencl_constant_no_init : Error<
"variable in constant address space must be initialized">;
-def err_atomic_init_constant : Error<
- "atomic variable can only be assigned to a compile time constant"
- " in the declaration statement in the program scope">;
+def err_opencl_atomic_init: Error<
+ "atomic variable can %select{only be assigned to a compile time constant|"
+ "be initialized to a variable only in global address space}0">;
def err_opencl_implicit_vector_conversion : Error<
"implicit conversions between vector types (%0 and %1) are not permitted">;
def err_opencl_invalid_type_array : Error<
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
Anastasia added inline comments.
Comment at: test/SemaOpenCL/atomic-init.cl:6
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can only be assigned to a
compile time constant and to variables in global adress space}}
+ atomic_int a2 = 0; // expected-error {{atomic variable can only be assigned
to a compile time constant and to variables in global adress space}}
Anastasia wrote:
> Btw, you could keep "initialized" here by using 'select' in the diagnostic
> message.
Btw you still keep "assigned" in the error message. What I mean is that we
could put "initialized" instead in this case.
https://reviews.llvm.org/D30643
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
echuraev updated this revision to Diff 93368.
echuraev marked 2 inline comments as done.
https://reviews.llvm.org/D30643
Files:
include/clang/Basic/DiagnosticSemaKinds.td
lib/Sema/SemaExpr.cpp
lib/Sema/SemaInit.cpp
test/Parser/opencl-atomics-cl20.cl
test/SemaOpenCL/atomic-init.cl
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can only be assigned to a
compile time constant}}
+ atomic_int a2 = 0; // expected-error {{atomic variable can only be assigned
to a variable in global adress space}}
+ private atomic_int a3 = 0; // expected-error {{atomic variable can only be
assigned to a variable in global adress space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have
an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot
be declared in global address space}}
+ static global atomic_int a6 = 0;
+}
Index: test/Parser/opencl-atomics-cl20.cl
===
--- test/Parser/opencl-atomics-cl20.cl
+++ test/Parser/opencl-atomics-cl20.cl
@@ -67,7 +67,7 @@
foo();
// OpenCL v2.0 s6.13.11.8, arithemtic operations are not permitted on atomic
types.
i++; // expected-error {{invalid argument type 'atomic_int' (aka
'_Atomic(int)') to unary expression}}
- i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant in the declaration statement in the program scope}}
+ i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant}}
i += 1; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'int')}}
i = i + i; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'atomic_int')}}
}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6502,6 +6502,20 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global
scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+S.Diag(Args[0]->getLocStart(), diag::err_opencl_atomic_init) << 1 <<
+SourceRange(Entity.getDecl()->getLocStart(), Args[0]->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and
the
// pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Index: lib/Sema/SemaExpr.cpp
===
--- lib/Sema/SemaExpr.cpp
+++ lib/Sema/SemaExpr.cpp
@@ -2,7 +2,7 @@
if (LHSTy->isAtomicType() || RHSTy->isAtomicType()) {
SourceRange SR(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
if (BO_Assign == Opc)
-Diag(OpLoc, diag::err_atomic_init_constant) << SR;
+Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
else
ResultTy = InvalidOperands(OpLoc, LHS, RHS);
return ExprError();
Index: include/clang/Basic/DiagnosticSemaKinds.td
===
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -8284,9 +8284,9 @@
"return value cannot be qualified with address space">;
def err_opencl_constant_no_init : Error<
"variable in constant address space must be initialized">;
-def err_atomic_init_constant : Error<
- "atomic variable can only be assigned to a compile time constant"
- " in the declaration statement in the program scope">;
+def err_opencl_atomic_init: Error<
+ "atomic variable can only be assigned to a %select{compile time constant|"
+ "variable in global adress space}0">;
def err_opencl_implicit_vector_conversion : Error<
"implicit conversions between vector types (%0 and %1) are not permitted">;
def err_opencl_invalid_type_array : Error<
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can only be assigned to a
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
Anastasia added inline comments.
Comment at: test/SemaOpenCL/atomic-init.cl:6
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can only be assigned to a
compile time constant and to variables in global adress space}}
+ atomic_int a2 = 0; // expected-error {{atomic variable can only be assigned
to a compile time constant and to variables in global adress space}}
Btw, you could keep "initialized" here by using 'select' in the diagnostic
message.
Comment at: test/SemaOpenCL/atomic-init.cl:10
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have
an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot
be declared in global address space}}
+}
Could we also add a check for 'static global' variable?
https://reviews.llvm.org/D30643
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
echuraev updated this revision to Diff 93113.
echuraev marked 2 inline comments as done.
echuraev removed a reviewer: bader.
echuraev added a subscriber: bader.
https://reviews.llvm.org/D30643
Files:
include/clang/Basic/DiagnosticSemaKinds.td
lib/Sema/SemaExpr.cpp
lib/Sema/SemaInit.cpp
test/Parser/opencl-atomics-cl20.cl
test/SemaOpenCL/atomic-init.cl
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can only be assigned to a
compile time constant and to variables in global adress space}}
+ atomic_int a2 = 0; // expected-error {{atomic variable can only be assigned
to a compile time constant and to variables in global adress space}}
+ private atomic_int a3 = 0; // expected-error {{atomic variable can only be
assigned to a compile time constant and to variables in global adress space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have
an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot
be declared in global address space}}
+}
Index: test/Parser/opencl-atomics-cl20.cl
===
--- test/Parser/opencl-atomics-cl20.cl
+++ test/Parser/opencl-atomics-cl20.cl
@@ -67,7 +67,7 @@
foo();
// OpenCL v2.0 s6.13.11.8, arithemtic operations are not permitted on atomic
types.
i++; // expected-error {{invalid argument type 'atomic_int' (aka
'_Atomic(int)') to unary expression}}
- i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant in the declaration statement in the program scope}}
+ i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant and to variables in global adress space}}
i += 1; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'int')}}
i = i + i; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'atomic_int')}}
}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6502,6 +6502,20 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global
scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+S.Diag(Args[0]->getLocStart(), diag::err_opencl_atomic_init) <<
+SourceRange(Entity.getDecl()->getLocStart(), Args[0]->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and
the
// pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Index: lib/Sema/SemaExpr.cpp
===
--- lib/Sema/SemaExpr.cpp
+++ lib/Sema/SemaExpr.cpp
@@ -2,7 +2,7 @@
if (LHSTy->isAtomicType() || RHSTy->isAtomicType()) {
SourceRange SR(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
if (BO_Assign == Opc)
-Diag(OpLoc, diag::err_atomic_init_constant) << SR;
+Diag(OpLoc, diag::err_opencl_atomic_init) << SR;
else
ResultTy = InvalidOperands(OpLoc, LHS, RHS);
return ExprError();
Index: include/clang/Basic/DiagnosticSemaKinds.td
===
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -8284,9 +8284,8 @@
"return value cannot be qualified with address space">;
def err_opencl_constant_no_init : Error<
"variable in constant address space must be initialized">;
-def err_atomic_init_constant : Error<
- "atomic variable can only be assigned to a compile time constant"
- " in the declaration statement in the program scope">;
+def err_opencl_atomic_init: Error<
+ "atomic variable can only be assigned to a compile time constant and to
variables in global adress space">;
def err_opencl_implicit_vector_conversion : Error<
"implicit conversions between vector types (%0 and %1) are not permitted">;
def err_opencl_invalid_type_array : Error<
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
bader added inline comments.
Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8263
+def err_atomic_init_addressspace : Error<
+ "initialization of atomic variables is restricted to variables in global
address space">;
def err_atomic_init_constant : Error<
Anastasia wrote:
> bader wrote:
> > bader wrote:
> > > Anastasia wrote:
> > > > echuraev wrote:
> > > > > Anastasia wrote:
> > > > > > Could we combine this error diag with the one below? I guess they
> > > > > > are semantically very similar apart from one is about
> > > > > > initialization and another is about assignment?
> > > > > I'm not sure that it is a good idea to combine these errors. For
> > > > > example, if developer had declared a variable non-constant and not in
> > > > > global address space he would have got the same message for both
> > > > > errors. And it can be difficult to determine what the exact problem
> > > > > is. He can fix one of the problems but he will still get the same
> > > > > error.
> > > > Well, I don't actually see that we check for constant anywhere so it's
> > > > also OK if you want to drop this bit. Although I think the original
> > > > intension of this message as I understood was to provide the most
> > > > complete hint.
> > > >
> > > > My concern is that these two errors seem to be reporting nearly the
> > > > same issue and ideally we would like to keep diagnostic list as small
> > > > as possible. This also makes the file more concise and messages more
> > > > consistent.
> > > I suggest adding a test case with non-constant initialization case to
> > > validate that existing checks cover this case for atomic types already.
> > > If so, we can adjust existing diagnostic message to cover both cases:
> > > initialization and assignment expression.
> > I don't think it's quite true.
> > There are two requirements here that must be met the same time. Atomic
> > variables *declared in the global address space* can be initialized only
> > with "compile time constant'.
> > If understand the spec correctly this code is also valid:
> >
> > kernel void foo() {
> > static global atomic_int a = 42; // although it's not clear if we must
> > use ATOMIC_VAR_INIT here.
> > ...
> > }
> Precisely, but I think checking for compile time constant should be inherited
> from the general C implementation? I don't think we do anything extra for it.
> Regarding the macro I am not sure we can suitably diagnose it anyways...
> Precisely, but I think checking for compile time constant should be inherited
> from the general C implementation?
Agree. I suggested checking this above by extending OpenCL tests, but this can
be done separately.
https://reviews.llvm.org/D30643
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
Anastasia added inline comments.
Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8263
+def err_atomic_init_addressspace : Error<
+ "initialization of atomic variables is restricted to variables in global
address space">;
def err_atomic_init_constant : Error<
bader wrote:
> bader wrote:
> > Anastasia wrote:
> > > echuraev wrote:
> > > > Anastasia wrote:
> > > > > Could we combine this error diag with the one below? I guess they are
> > > > > semantically very similar apart from one is about initialization and
> > > > > another is about assignment?
> > > > I'm not sure that it is a good idea to combine these errors. For
> > > > example, if developer had declared a variable non-constant and not in
> > > > global address space he would have got the same message for both
> > > > errors. And it can be difficult to determine what the exact problem is.
> > > > He can fix one of the problems but he will still get the same error.
> > > Well, I don't actually see that we check for constant anywhere so it's
> > > also OK if you want to drop this bit. Although I think the original
> > > intension of this message as I understood was to provide the most
> > > complete hint.
> > >
> > > My concern is that these two errors seem to be reporting nearly the same
> > > issue and ideally we would like to keep diagnostic list as small as
> > > possible. This also makes the file more concise and messages more
> > > consistent.
> > I suggest adding a test case with non-constant initialization case to
> > validate that existing checks cover this case for atomic types already.
> > If so, we can adjust existing diagnostic message to cover both cases:
> > initialization and assignment expression.
> I don't think it's quite true.
> There are two requirements here that must be met the same time. Atomic
> variables *declared in the global address space* can be initialized only with
> "compile time constant'.
> If understand the spec correctly this code is also valid:
>
> kernel void foo() {
> static global atomic_int a = 42; // although it's not clear if we must
> use ATOMIC_VAR_INIT here.
> ...
> }
Precisely, but I think checking for compile time constant should be inherited
from the general C implementation? I don't think we do anything extra for it.
Regarding the macro I am not sure we can suitably diagnose it anyways...
Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8268
+// Atomics
+def err_atomic_init: Error<
+ "atomic variable can only be assigned to a compile time constant or to
variables in global adress space">;
also we should add opencl there:
err_opencl_...
https://reviews.llvm.org/D30643
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
bader added inline comments.
Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8263
+def err_atomic_init_addressspace : Error<
+ "initialization of atomic variables is restricted to variables in global
address space">;
def err_atomic_init_constant : Error<
bader wrote:
> Anastasia wrote:
> > echuraev wrote:
> > > Anastasia wrote:
> > > > Could we combine this error diag with the one below? I guess they are
> > > > semantically very similar apart from one is about initialization and
> > > > another is about assignment?
> > > I'm not sure that it is a good idea to combine these errors. For example,
> > > if developer had declared a variable non-constant and not in global
> > > address space he would have got the same message for both errors. And it
> > > can be difficult to determine what the exact problem is. He can fix one
> > > of the problems but he will still get the same error.
> > Well, I don't actually see that we check for constant anywhere so it's also
> > OK if you want to drop this bit. Although I think the original intension of
> > this message as I understood was to provide the most complete hint.
> >
> > My concern is that these two errors seem to be reporting nearly the same
> > issue and ideally we would like to keep diagnostic list as small as
> > possible. This also makes the file more concise and messages more
> > consistent.
> I suggest adding a test case with non-constant initialization case to
> validate that existing checks cover this case for atomic types already.
> If so, we can adjust existing diagnostic message to cover both cases:
> initialization and assignment expression.
I don't think it's quite true.
There are two requirements here that must be met the same time. Atomic
variables *declared in the global address space* can be initialized only with
"compile time constant'.
If understand the spec correctly this code is also valid:
kernel void foo() {
static global atomic_int a = 42; // although it's not clear if we must use
ATOMIC_VAR_INIT here.
...
}
Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8267
"variable in constant address space must be initialized">;
-def err_atomic_init_constant : Error<
- "atomic variable can only be assigned to a compile time constant"
- " in the declaration statement in the program scope">;
+// Atomics
+def err_atomic_init: Error<
I suggest removing this comment.
If you are going to add other diagnostic messages specific to OpenCL atomics,
then separate them from this list of unordered diagnostics similar to pipe
built-in functions below.
https://reviews.llvm.org/D30643
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
echuraev updated this revision to Diff 91536.
https://reviews.llvm.org/D30643
Files:
include/clang/Basic/DiagnosticSemaKinds.td
lib/Sema/SemaExpr.cpp
lib/Sema/SemaInit.cpp
test/Parser/opencl-atomics-cl20.cl
test/SemaOpenCL/atomic-init.cl
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic variable can only be assigned to a
compile time constant or to variables in global adress space}}
+ atomic_int a2 = 0; // expected-error {{atomic variable can only be assigned
to a compile time constant or to variables in global adress space}}
+ private atomic_int a3 = 0; // expected-error {{atomic variable can only be
assigned to a compile time constant or to variables in global adress space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have
an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot
be declared in global address space}}
+}
Index: test/Parser/opencl-atomics-cl20.cl
===
--- test/Parser/opencl-atomics-cl20.cl
+++ test/Parser/opencl-atomics-cl20.cl
@@ -67,7 +67,7 @@
foo();
// OpenCL v2.0 s6.13.11.8, arithemtic operations are not permitted on atomic
types.
i++; // expected-error {{invalid argument type 'atomic_int' (aka
'_Atomic(int)') to unary expression}}
- i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant in the declaration statement in the program scope}}
+ i = 1; // expected-error {{atomic variable can only be assigned to a compile
time constant or to variables in global adress space}}
i += 1; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'int')}}
i = i + i; // expected-error {{invalid operands to binary expression
('atomic_int' (aka '_Atomic(int)') and 'atomic_int')}}
}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6489,6 +6489,20 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global
scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+S.Diag(Args[0]->getLocStart(), diag::err_atomic_init) <<
+SourceRange(Entity.getDecl()->getLocStart(), Args[0]->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and
the
// pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Index: lib/Sema/SemaExpr.cpp
===
--- lib/Sema/SemaExpr.cpp
+++ lib/Sema/SemaExpr.cpp
@@ -11091,7 +11091,7 @@
if (LHSTy->isAtomicType() || RHSTy->isAtomicType()) {
SourceRange SR(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
if (BO_Assign == Opc)
-Diag(OpLoc, diag::err_atomic_init_constant) << SR;
+Diag(OpLoc, diag::err_atomic_init) << SR;
else
ResultTy = InvalidOperands(OpLoc, LHS, RHS);
return ExprError();
Index: include/clang/Basic/DiagnosticSemaKinds.td
===
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -8264,9 +8264,9 @@
"return value cannot be qualified with address space">;
def err_opencl_constant_no_init : Error<
"variable in constant address space must be initialized">;
-def err_atomic_init_constant : Error<
- "atomic variable can only be assigned to a compile time constant"
- " in the declaration statement in the program scope">;
+// Atomics
+def err_atomic_init: Error<
+ "atomic variable can only be assigned to a compile time constant or to
variables in global adress space">;
def err_opencl_implicit_vector_conversion : Error<
"implicit conversions between vector types (%0 and %1) are not permitted">;
def err_opencl_invalid_type_array : Error<
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ a1 = 1; // expected-error {{atomic
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
bader added inline comments. Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8263 +def err_atomic_init_addressspace : Error< + "initialization of atomic variables is restricted to variables in global address space">; def err_atomic_init_constant : Error< Anastasia wrote: > echuraev wrote: > > Anastasia wrote: > > > Could we combine this error diag with the one below? I guess they are > > > semantically very similar apart from one is about initialization and > > > another is about assignment? > > I'm not sure that it is a good idea to combine these errors. For example, > > if developer had declared a variable non-constant and not in global address > > space he would have got the same message for both errors. And it can be > > difficult to determine what the exact problem is. He can fix one of the > > problems but he will still get the same error. > Well, I don't actually see that we check for constant anywhere so it's also > OK if you want to drop this bit. Although I think the original intension of > this message as I understood was to provide the most complete hint. > > My concern is that these two errors seem to be reporting nearly the same > issue and ideally we would like to keep diagnostic list as small as possible. > This also makes the file more concise and messages more consistent. I suggest adding a test case with non-constant initialization case to validate that existing checks cover this case for atomic types already. If so, we can adjust existing diagnostic message to cover both cases: initialization and assignment expression. https://reviews.llvm.org/D30643 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
Anastasia added inline comments. Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8263 +def err_atomic_init_addressspace : Error< + "initialization of atomic variables is restricted to variables in global address space">; def err_atomic_init_constant : Error< echuraev wrote: > Anastasia wrote: > > Could we combine this error diag with the one below? I guess they are > > semantically very similar apart from one is about initialization and > > another is about assignment? > I'm not sure that it is a good idea to combine these errors. For example, if > developer had declared a variable non-constant and not in global address > space he would have got the same message for both errors. And it can be > difficult to determine what the exact problem is. He can fix one of the > problems but he will still get the same error. Well, I don't actually see that we check for constant anywhere so it's also OK if you want to drop this bit. Although I think the original intension of this message as I understood was to provide the most complete hint. My concern is that these two errors seem to be reporting nearly the same issue and ideally we would like to keep diagnostic list as small as possible. This also makes the file more concise and messages more consistent. https://reviews.llvm.org/D30643 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
echuraev added inline comments. Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8263 +def err_atomic_init_addressspace : Error< + "initialization of atomic variables is restricted to variables in global address space">; def err_atomic_init_constant : Error< Anastasia wrote: > Could we combine this error diag with the one below? I guess they are > semantically very similar apart from one is about initialization and another > is about assignment? I'm not sure that it is a good idea to combine these errors. For example, if developer had declared a variable non-constant and not in global address space he would have got the same message for both errors. And it can be difficult to determine what the exact problem is. He can fix one of the problems but he will still get the same error. https://reviews.llvm.org/D30643 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
echuraev updated this revision to Diff 91305.
echuraev marked 2 inline comments as done.
https://reviews.llvm.org/D30643
Files:
include/clang/Basic/DiagnosticSemaKinds.td
lib/Sema/SemaInit.cpp
test/SemaOpenCL/atomic-init.cl
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ atomic_int a2 = 0; // expected-error {{initialization of atomic variables is
restricted to variables in global address space}}
+ private atomic_int a3 = 0; // expected-error {{initialization of atomic
variables is restricted to variables in global address space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have
an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot
be declared in global address space}}
+}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6489,6 +6489,20 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global
scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+S.Diag(Args[0]->getLocStart(), diag::err_atomic_init_addressspace) <<
+SourceRange(Entity.getDecl()->getLocStart(), Args[0]->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and
the
// pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Index: include/clang/Basic/DiagnosticSemaKinds.td
===
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -8264,6 +8264,9 @@
"return value cannot be qualified with address space">;
def err_opencl_constant_no_init : Error<
"variable in constant address space must be initialized">;
+// Atomics
+def err_atomic_init_addressspace : Error<
+ "initialization of atomic variables is restricted to variables in global
address space">;
def err_atomic_init_constant : Error<
"atomic variable can only be assigned to a compile time constant"
" in the declaration statement in the program scope">;
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ atomic_int a2 = 0; // expected-error {{initialization of atomic variables is restricted to variables in global address space}}
+ private atomic_int a3 = 0; // expected-error {{initialization of atomic variables is restricted to variables in global address space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot be declared in global address space}}
+}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6489,6 +6489,20 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+S.Diag(Args[0]->getLocStart(), diag::err_atomic_init_addressspace) <<
+SourceRange(Entity.getDecl()->getLocStart(), Args[0]->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and the
// pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Index: include/clang/Basic/DiagnosticSemaKinds.td
===
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -8264,6 +8264,9 @@
"return value cannot be qualified with address space">;
def
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
Anastasia added inline comments.
Comment at: include/clang/Basic/DiagnosticSemaKinds.td:8263
+def err_atomic_init_addressspace : Error<
+ "initialization of atomic variables is restricted to variables in global
address space">;
def err_atomic_init_constant : Error<
Could we combine this error diag with the one below? I guess they are
semantically very similar apart from one is about initialization and another is
about assignment?
Comment at: lib/Sema/SemaInit.cpp:6498
+
+ if (S.getLangOpts().OpenCL && S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
I would remove S.getLangOpts().OpenCL check, it's redundant in my opinion!
Comment at: lib/Sema/SemaInit.cpp:6501
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+const Expr *Init = Args[0];
+S.Diag(Init->getLocStart(), diag::err_atomic_init_addressspace) <<
Even thought it's done above too, I don't really see the point of having this
variable.
https://reviews.llvm.org/D30643
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D30643: [OpenCL] Extended diagnostics for atomic initialization
echuraev created this revision.
Herald added a subscriber: yaxunl.
I saw the same changes in the following review: https://reviews.llvm.org/D17438
I don't know in that way I could determine that atomic variable was initialized
by macro ATOMIC_VAR_INIT. Anyway I added check that atomic variables can be
initialize only in global scope.
I think that we can discuss this change.
https://reviews.llvm.org/D30643
Files:
include/clang/Basic/DiagnosticSemaKinds.td
lib/Sema/SemaInit.cpp
test/SemaOpenCL/atomic-init.cl
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ atomic_int a2 = 0; // expected-error {{initialization of atomic variables is
restricted to variables in global address space}}
+ private atomic_int a3 = 0; // expected-error {{initialization of atomic
variables is restricted to variables in global address space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have
an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot
be declared in global address space}}
+}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6489,6 +6489,21 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global
scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCL && S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+const Expr *Init = Args[0];
+S.Diag(Init->getLocStart(), diag::err_atomic_init_addressspace) <<
+SourceRange(Entity.getDecl()->getLocStart(), Init->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and
the
// pointer obviously outlives the temporary.
if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Index: include/clang/Basic/DiagnosticSemaKinds.td
===
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -8258,6 +8258,9 @@
"return value cannot be qualified with address space">;
def err_opencl_constant_no_init : Error<
"variable in constant address space must be initialized">;
+// Atomics
+def err_atomic_init_addressspace : Error<
+ "initialization of atomic variables is restricted to variables in global
address space">;
def err_atomic_init_constant : Error<
"atomic variable can only be assigned to a compile time constant"
" in the declaration statement in the program scope">;
Index: test/SemaOpenCL/atomic-init.cl
===
--- /dev/null
+++ test/SemaOpenCL/atomic-init.cl
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+global atomic_int a1 = 0;
+
+kernel void test_atomic_initialization() {
+ atomic_int a2 = 0; // expected-error {{initialization of atomic variables is restricted to variables in global address space}}
+ private atomic_int a3 = 0; // expected-error {{initialization of atomic variables is restricted to variables in global address space}}
+ local atomic_int a4 = 0; // expected-error {{'__local' variable cannot have an initializer}}
+ global atomic_int a5 = 0; // expected-error {{function scope variable cannot be declared in global address space}}
+}
Index: lib/Sema/SemaInit.cpp
===
--- lib/Sema/SemaInit.cpp
+++ lib/Sema/SemaInit.cpp
@@ -6489,6 +6489,21 @@
<< Init->getSourceRange();
}
+ // OpenCL v2.0 s6.13.11.1. atomic variables can be initialized in global scope
+ QualType ETy = Entity.getType();
+ Qualifiers TyQualifiers = ETy.getQualifiers();
+ bool HasGlobalAS = TyQualifiers.hasAddressSpace() &&
+ TyQualifiers.getAddressSpace() == LangAS::opencl_global;
+
+ if (S.getLangOpts().OpenCL && S.getLangOpts().OpenCLVersion >= 200 &&
+ ETy->isAtomicType() && !HasGlobalAS &&
+ Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
+const Expr *Init = Args[0];
+S.Diag(Init->getLocStart(), diag::err_atomic_init_addressspace) <<
+SourceRange(Entity.getDecl()->getLocStart(), Init->getLocEnd());
+return ExprError();
+ }
+
// Diagnose cases where we initialize a pointer to an array temporary, and the
// pointer obviously outlives
