shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

Diagnose _Atomic as a C11 extension.

Browse Source 
llvm-svn: 370982
This commit is contained in:
Aaron Ballman 2019-09-04 21:01:57 +00:00
parent 48c6fadc0d
commit 5cd5d56eed
4 changed files with 84 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
clang/lib/Parse/ParseDecl.cpp
View File

@ -3924,6 +3924,9 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
// If the _Atomic keyword is immediately followed by a left parenthesis,
// it is interpreted as a type specifier (with a type name), not as a
// type qualifier.
if (!getLangOpts().C11)
Diag(Tok, diag::ext_c11_feature) << Tok.getName();
if (NextToken().is(tok::l_paren)) {
ParseAtomicSpecifier(DS);
continue;
@ -5330,6 +5333,8 @@ void Parser::ParseTypeQualifierListOpt(
case tok::kw__Atomic:
if (!AtomicAllowed)
goto DoneWithTypeQuals;
if (!getLangOpts().C11)
Diag(Tok, diag::ext_c11_feature) << Tok.getName();
isInvalid = DS.SetTypeQual(DeclSpec::TQ_atomic, Loc, PrevSpec, DiagID,
getLangOpts());
break;

55
clang/test/Parser/atomic.c
View File

@ -1,40 +1,47 @@
// RUN: %clang_cc1 -std=c11 %s -fsyntax-only -verify -pedantic
// RUN: %clang_cc1 -std=c99 %s -fsyntax-only -verify=expected,ext -pedantic -Wno-typedef-redefinition
typedef _Atomic(int) atomic_int;
typedef _Atomic int atomic_int;
typedef _Atomic _Atomic _Atomic(int) atomic_int; // expected-warning {{duplicate '_Atomic' declaration specifier}}
typedef _Atomic(int) atomic_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic int atomic_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic _Atomic _Atomic(int) atomic_int; // expected-warning {{duplicate '_Atomic' declaration specifier}} \
// ext-warning 3 {{'_Atomic' is a C11 extension}}
typedef const int const_int;
typedef const atomic_int const_atomic_int;
typedef _Atomic const int const_atomic_int;
typedef const _Atomic int const_atomic_int;
typedef const _Atomic(int) const_atomic_int;
typedef const _Atomic(_Atomic int) const_atomic_int; // expected-error {{_Atomic cannot be applied to atomic type '_Atomic(int)'}}
typedef _Atomic const_int const_atomic_int;
typedef _Atomic(const_int) const_atomic_int; // expected-error {{_Atomic cannot be applied to qualified type 'const_int' (aka 'const int')}}
typedef _Atomic const int const_atomic_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef const _Atomic int const_atomic_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef const _Atomic(int) const_atomic_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef const _Atomic(_Atomic int) const_atomic_int; // expected-error {{_Atomic cannot be applied to atomic type '_Atomic(int)'}} \
// ext-warning 2 {{'_Atomic' is a C11 extension}}
typedef _Atomic const_int const_atomic_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(const_int) const_atomic_int; // expected-error {{_Atomic cannot be applied to qualified type 'const_int' (aka 'const int')}} \
// ext-warning {{'_Atomic' is a C11 extension}}
typedef int *_Atomic atomic_int_ptr;
typedef _Atomic(int *) atomic_int_ptr;
typedef int (*_Atomic atomic_int_ptr);
typedef int *_Atomic atomic_int_ptr; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(int *) atomic_int_ptr; // ext-warning {{'_Atomic' is a C11 extension}}
typedef int (*_Atomic atomic_int_ptr); // ext-warning {{'_Atomic' is a C11 extension}}
typedef int _Atomic *int_atomic_ptr;
typedef _Atomic(int) *int_atomic_ptr;
typedef int _Atomic *int_atomic_ptr; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(int) *int_atomic_ptr; // ext-warning {{'_Atomic' is a C11 extension}}
typedef int int_fn();
typedef _Atomic int_fn atomic_int_fn; // expected-error {{_Atomic cannot be applied to function type 'int_fn' (aka 'int ()')}}
typedef _Atomic int atomic_int_array[3];
typedef _Atomic atomic_int_array atomic_int_atomic_array; // expected-error {{_Atomic cannot be applied to array type 'atomic_int_array' (aka '_Atomic(int) [3]')}}
typedef _Atomic int_fn atomic_int_fn; // expected-error {{_Atomic cannot be applied to function type 'int_fn' (aka 'int ()')}} \
// ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic int atomic_int_array[3]; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic atomic_int_array atomic_int_atomic_array; // expected-error {{_Atomic cannot be applied to array type 'atomic_int_array' (aka '_Atomic(int) [3]')}} \
// ext-warning {{'_Atomic' is a C11 extension}}
_Atomic struct S { int n; }; // expected-warning {{'_Atomic' ignored on this declaration}}
_Atomic struct S { int n; }; // expected-warning {{'_Atomic' ignored on this declaration}} \
// ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic int __attribute__((address_space(1))) atomic_addr_space_int;
typedef _Atomic(int) __attribute__((address_space(1))) atomic_addr_space_int;
typedef _Atomic int __attribute__((address_space(1))) atomic_addr_space_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(int) __attribute__((address_space(1))) atomic_addr_space_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic int __attribute__((vector_size(16))) atomic_vector_int;
typedef _Atomic(int __attribute__((vector_size(16)))) atomic_vector_int;
typedef _Atomic int __attribute__((vector_size(16))) atomic_vector_int; // ext-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(int __attribute__((vector_size(16)))) atomic_vector_int; // ext-warning {{'_Atomic' is a C11 extension}}
struct S
_Atomic atomic_s_no_missing_semicolon;
_Atomic atomic_s_no_missing_semicolon; // ext-warning {{'_Atomic' is a C11 extension}}
int *const _Atomic atomic_return_type();
int *const _Atomic atomic_return_type(); // ext-warning {{'_Atomic' is a C11 extension}}

73
clang/test/SemaCXX/atomic-type.cpp
View File

@ -2,7 +2,7 @@
// RUN: %clang_cc1 -verify -pedantic %s -std=c++11
template<typename T> struct atomic {
_Atomic(T) value;
_Atomic(T) value; // expected-warning {{'_Atomic' is a C11 extension}}
void f() _Atomic; // expected-error {{expected ';' at end of declaration list}}
};
@ -17,16 +17,16 @@ user<int> u;
// Test overloading behavior of atomics.
struct A { };
int &ovl1(_Atomic(int));
int &ovl1(_Atomic int); // ok, redeclaration
long &ovl1(_Atomic(long));
float &ovl1(_Atomic(float));
double &ovl1(_Atomic(A const *const *));
double &ovl1(A const *const *_Atomic);
short &ovl1(_Atomic(A **));
int &ovl1(_Atomic(int)); // expected-warning {{'_Atomic' is a C11 extension}}
int &ovl1(_Atomic int); // expected-warning {{'_Atomic' is a C11 extension}} // ok, redeclaration
long &ovl1(_Atomic(long)); // expected-warning {{'_Atomic' is a C11 extension}}
float &ovl1(_Atomic(float)); // expected-warning {{'_Atomic' is a C11 extension}}
double &ovl1(_Atomic(A const *const *)); // expected-warning {{'_Atomic' is a C11 extension}}
double &ovl1(A const *const *_Atomic); // expected-warning {{'_Atomic' is a C11 extension}}
short &ovl1(_Atomic(A **)); // expected-warning {{'_Atomic' is a C11 extension}}
void test_overloading(int i, float f, _Atomic(int) ai, _Atomic(float) af,
long l, _Atomic(long) al, A const *const *acc,
void test_overloading(int i, float f, _Atomic(int) ai, _Atomic(float) af, // expected-warning 2 {{'_Atomic' is a C11 extension}}
long l, _Atomic(long) al, A const *const *acc, // expected-warning {{'_Atomic' is a C11 extension}}
A const ** ac, A **a) {
int& ir1 = ovl1(i);
int& ir2 = ovl1(ai);
@ -39,23 +39,28 @@ void test_overloading(int i, float f, _Atomic(int) ai, _Atomic(float) af,
short &sr1 = ovl1(a);
}
typedef int (A::*fp)() _Atomic; // expected-error {{expected ';' after top level declarator}} expected-warning {{does not declare anything}}
typedef int (A::*fp)() _Atomic; // expected-error {{expected ';' after top level declarator}} expected-warning {{does not declare anything}} \
// expected-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(int(A::*)) atomic_mem_ptr_to_int;
typedef int(A::*_Atomic atomic_mem_ptr_to_int);
typedef _Atomic(int(A::*)) atomic_mem_ptr_to_int; // expected-warning {{'_Atomic' is a C11 extension}}
typedef int(A::*_Atomic atomic_mem_ptr_to_int); // expected-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(int)(A::*mem_ptr_to_atomic_int);
typedef _Atomic int(A::*mem_ptr_to_atomic_int);
typedef _Atomic(int)(A::*mem_ptr_to_atomic_int); // expected-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic int(A::*mem_ptr_to_atomic_int); // expected-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(int)&atomic_int_ref;
typedef _Atomic int &atomic_int_ref;
typedef _Atomic atomic_int_ref atomic_int_ref; // expected-warning {{'_Atomic' qualifier on reference type 'atomic_int_ref' (aka '_Atomic(int) &') has no effect}}
typedef _Atomic(int)&atomic_int_ref; // expected-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic int &atomic_int_ref; // expected-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic atomic_int_ref atomic_int_ref; // expected-warning {{'_Atomic' qualifier on reference type 'atomic_int_ref' (aka '_Atomic(int) &') has no effect}} \
// expected-warning {{'_Atomic' is a C11 extension}}
typedef int &_Atomic atomic_reference_to_int; // expected-error {{'_Atomic' qualifier may not be applied to a reference}}
typedef _Atomic(int &) atomic_reference_to_int; // expected-error {{_Atomic cannot be applied to reference type 'int &'}}
typedef int &_Atomic atomic_reference_to_int; // expected-error {{'_Atomic' qualifier may not be applied to a reference}} \
// expected-warning {{'_Atomic' is a C11 extension}}
typedef _Atomic(int &) atomic_reference_to_int; // expected-error {{_Atomic cannot be applied to reference type 'int &'}} \
// expected-warning {{'_Atomic' is a C11 extension}}
struct S {
_Atomic union { int n; }; // expected-warning {{anonymous union cannot be '_Atomic'}}
_Atomic union { int n; }; // expected-warning {{anonymous union cannot be '_Atomic'}} \
// expected-warning {{'_Atomic' is a C11 extension}}
};
namespace copy_init {
@ -63,21 +68,24 @@ namespace copy_init {
X(int);
int n;
};
_Atomic(X) y = X(0);
_Atomic(X) z(X(0));
_Atomic(X) y = X(0); // expected-warning {{'_Atomic' is a C11 extension}}
_Atomic(X) z(X(0)); // expected-warning {{'_Atomic' is a C11 extension}}
void f() { y = X(0); }
_Atomic(X) e1(0); // expected-error {{cannot initialize}}
_Atomic(X) e1(0); // expected-error {{cannot initialize}} \
// expected-warning {{'_Atomic' is a C11 extension}}
#if __cplusplus >= 201103L
_Atomic(X) e2{0}; // expected-error {{illegal initializer}}
_Atomic(X) a{X(0)};
_Atomic(X) e2{0}; // expected-error {{illegal initializer}} \
// expected-warning {{'_Atomic' is a C11 extension}}
_Atomic(X) a{X(0)}; // expected-warning {{'_Atomic' is a C11 extension}}
// FIXME: This does not seem like the right answer.
_Atomic(int) e3{0}; // expected-error {{illegal initializer}}
_Atomic(int) e3{0}; // expected-error {{illegal initializer}} \
// expected-warning {{'_Atomic' is a C11 extension}}
#endif
struct Y {
_Atomic(X) a;
_Atomic(int) b;
_Atomic(X) a; // expected-warning {{'_Atomic' is a C11 extension}}
_Atomic(int) b; // expected-warning {{'_Atomic' is a C11 extension}}
};
Y y1 = { X(0), 4 };
Y y2 = { 0, 4 }; // expected-error {{cannot initialize}}
@ -87,10 +95,11 @@ namespace copy_init {
// same answer in all these cases:
Y y3 = { X(0), { 4 } }; // expected-error {{illegal initializer type}}
Y y4 = { { X(0) }, 4 };
_Atomic(int) ai = { 4 }; // expected-error {{illegal initializer type}}
_Atomic(X) ax = { X(0) };
_Atomic(int) ai = { 4 }; // expected-error {{illegal initializer type}} \
// expected-warning {{'_Atomic' is a C11 extension}}
_Atomic(X) ax = { X(0) }; // expected-warning {{'_Atomic' is a C11 extension}}
}
bool PR21836(_Atomic(int) *x) {
bool PR21836(_Atomic(int) *x) { // expected-warning {{'_Atomic' is a C11 extension}}
return *x;
}

14
clang/test/SemaCXX/constant-expression-cxx11.cpp
View File

@ -1322,21 +1322,21 @@ namespace ComplexConstexpr {
// _Atomic(T) is exactly like T for the purposes of constant expression
// evaluation..
namespace Atomic {
constexpr _Atomic int n = 3;
constexpr _Atomic int n = 3; // expected-warning {{'_Atomic' is a C11 extension}}
struct S { _Atomic(double) d; };
struct S { _Atomic(double) d; }; // expected-warning {{'_Atomic' is a C11 extension}}
constexpr S s = { 0.5 };
constexpr double d1 = s.d;
constexpr double d2 = n;
constexpr _Atomic double d3 = n;
constexpr _Atomic double d3 = n; // expected-warning {{'_Atomic' is a C11 extension}}
constexpr _Atomic(int) n2 = d3;
constexpr _Atomic(int) n2 = d3; // expected-warning {{'_Atomic' is a C11 extension}}
static_assert(d1 == 0.5, "");
static_assert(d3 == 3.0, "");
namespace PR16056 {
struct TestVar {
_Atomic(int) value;
_Atomic(int) value; // expected-warning {{'_Atomic' is a C11 extension}}
constexpr TestVar(int value) : value(value) {}
};
constexpr TestVar testVar{-1};
@ -1345,11 +1345,11 @@ namespace Atomic {
namespace PR32034 {
struct A {};
struct B { _Atomic(A) a; };
struct B { _Atomic(A) a; }; // expected-warning {{'_Atomic' is a C11 extension}}
constexpr int n = (B(), B(), 0);
struct C { constexpr C() {} void *self = this; };
constexpr _Atomic(C) c = C();
constexpr _Atomic(C) c = C(); // expected-warning {{'_Atomic' is a C11 extension}}
}
}