Mercurial > hg > CbC > CbC_gcc
comparison gcc/testsuite/gcc.dg/c11-atomic-3.c @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 /* Test for _Atomic in C11. Test of invalid code. */ | |
2 /* { dg-do compile } */ | |
3 /* { dg-options "-std=c11 -pedantic-errors" } */ | |
4 | |
5 /* Increment and decrement are invalid for atomic complex types and | |
6 atomic pointers to incomplete types, just as for the corresponding | |
7 non-atomic types. Likewise for types on which arithmetic is | |
8 invalid. */ | |
9 _Atomic _Complex float acf; | |
10 void *_Atomic apv; | |
11 struct s *_Atomic aps; | |
12 _Atomic struct t { char c; } as; | |
13 | |
14 void | |
15 func (void) | |
16 { | |
17 acf++; /* { dg-error "complex types" } */ | |
18 acf--; /* { dg-error "complex types" } */ | |
19 ++acf; /* { dg-error "complex types" } */ | |
20 --acf; /* { dg-error "complex types" } */ | |
21 apv++; /* { dg-error "wrong type|pointer of type" } */ | |
22 apv--; /* { dg-error "wrong type|pointer of type" } */ | |
23 ++apv; /* { dg-error "wrong type|pointer of type" } */ | |
24 --apv; /* { dg-error "wrong type|pointer of type" } */ | |
25 aps++; /* { dg-error "pointer to|invalid use of undefined type" } */ | |
26 aps--; /* { dg-error "pointer to|invalid use of undefined type" } */ | |
27 ++aps; /* { dg-error "pointer to|invalid use of undefined type" } */ | |
28 --aps; /* { dg-error "pointer to|invalid use of undefined type" } */ | |
29 as++; /* { dg-error "wrong type" } */ | |
30 as--; /* { dg-error "wrong type" } */ | |
31 ++as; /* { dg-error "wrong type" } */ | |
32 --as; /* { dg-error "wrong type" } */ | |
33 } | |
34 | |
35 /* Pointer subtraction and comparisons differing in _Atomic are | |
36 invalid where such subtraction and comparisons differing in | |
37 qualifiers are valid. There is no special allowance for equality | |
38 comparisons of pointers to atomic void to pointers to object | |
39 types. Likewise for conditional expressions. */ | |
40 int *pi; | |
41 _Atomic int *pai; | |
42 _Atomic void *pav; | |
43 int r; | |
44 | |
45 void | |
46 func2 (void) | |
47 { | |
48 r = pai - pi; /* { dg-error "invalid operands" } */ | |
49 r = pi - pai; /* { dg-error "invalid operands" } */ | |
50 r = pi < pai; /* { dg-error "distinct pointer types" } */ | |
51 r = pi > pai; /* { dg-error "distinct pointer types" } */ | |
52 r = pi <= pai; /* { dg-error "distinct pointer types" } */ | |
53 r = pi >= pai; /* { dg-error "distinct pointer types" } */ | |
54 r = pai < pi; /* { dg-error "distinct pointer types" } */ | |
55 r = pai > pi; /* { dg-error "distinct pointer types" } */ | |
56 r = pai <= pi; /* { dg-error "distinct pointer types" } */ | |
57 r = pai >= pi; /* { dg-error "distinct pointer types" } */ | |
58 r = pav == pi; /* { dg-error "distinct pointer types" } */ | |
59 r = pav != pi; /* { dg-error "distinct pointer types" } */ | |
60 r = pi == pav; /* { dg-error "distinct pointer types" } */ | |
61 r = pi != pav; /* { dg-error "distinct pointer types" } */ | |
62 (void) (r ? pai : pi); /* { dg-error "pointer type mismatch" } */ | |
63 (void) (r ? pi : pai); /* { dg-error "pointer type mismatch" } */ | |
64 (void) (r ? pai : pav); /* { dg-error "pointer type mismatch" } */ | |
65 (void) (r ? pav : pai); /* { dg-error "pointer type mismatch" } */ | |
66 } | |
67 | |
68 /* Likewise for pointer assignment. */ | |
69 void | |
70 func3 (void) | |
71 { | |
72 pai = pi; /* { dg-error "incompatible pointer type" } */ | |
73 pi = pai; /* { dg-error "incompatible pointer type" } */ | |
74 pav = pai; /* { dg-error "incompatible pointer type" } */ | |
75 pai = pav; /* { dg-error "incompatible pointer type" } */ | |
76 } | |
77 | |
78 /* Cases that are invalid for normal assignments are just as invalid | |
79 (and should not ICE) when the LHS is atomic. */ | |
80 void | |
81 func4 (void) | |
82 { | |
83 as = acf; /* { dg-error "incompatible types" } */ | |
84 apv = as; /* { dg-error "incompatible types" } */ | |
85 as += 1; /* { dg-error "invalid operands" } */ | |
86 apv -= 1; /* { dg-error "pointer of type" } */ | |
87 apv *= 1; /* { dg-error "invalid operands" } */ | |
88 apv /= 1; /* { dg-error "invalid operands" } */ | |
89 apv %= 1; /* { dg-error "invalid operands" } */ | |
90 apv <<= 1; /* { dg-error "invalid operands" } */ | |
91 apv >>= 1; /* { dg-error "invalid operands" } */ | |
92 apv &= 1; /* { dg-error "invalid operands" } */ | |
93 apv ^= 1; /* { dg-error "invalid operands" } */ | |
94 apv |= 1; /* { dg-error "invalid operands" } */ | |
95 } | |
96 | |
97 /* We don't allow atomic bit-fields in GCC (implementation-defined | |
98 whether they are permitted). */ | |
99 struct abf | |
100 { | |
101 _Atomic int i : 1; /* { dg-error "atomic type" } */ | |
102 _Atomic int : 0; /* { dg-error "atomic type" } */ | |
103 }; | |
104 | |
105 /* _Atomic (type-name) may not use a name for an array, function, | |
106 qualified or atomic type. */ | |
107 _Atomic (int [2]) v0; /* { dg-error "array type" } */ | |
108 _Atomic (void (void)) v1; /* { dg-error "function type" } */ | |
109 _Atomic (_Atomic int) v2; /* { dg-error "applied to a qualified type" } */ | |
110 _Atomic (const int) v3; /* { dg-error "applied to a qualified type" } */ | |
111 _Atomic (volatile int) v4; /* { dg-error "applied to a qualified type" } */ | |
112 _Atomic (int *restrict) v5; /* { dg-error "applied to a qualified type" } */ | |
113 | |
114 /* _Atomic, used as a qualifier, may not be applied to a function or | |
115 array type. */ | |
116 typedef int arraytype[2]; | |
117 typedef void functiontype (void); | |
118 _Atomic arraytype v6; /* { dg-error "array type" } */ | |
119 _Atomic arraytype *v7; /* { dg-error "array type" } */ | |
120 typedef _Atomic arraytype v8; /* { dg-error "array type" } */ | |
121 int v9 = sizeof (_Atomic arraytype); /* { dg-error "array type" } */ | |
122 void v10 (_Atomic arraytype parm); /* { dg-error "array type" } */ | |
123 struct v11 { _Atomic arraytype f; }; /* { dg-error "array type" } */ | |
124 _Atomic functiontype v12; /* { dg-error "function type" } */ | |
125 _Atomic functiontype *v13; /* { dg-error "function type" } */ | |
126 typedef _Atomic functiontype *v14; /* { dg-error "function type" } */ | |
127 void v15 (_Atomic functiontype parm); /* { dg-error "function type" } */ | |
128 | |
129 /* Function parameters, when function types are required to be | |
130 compatible, may not differ in the presence of _Atomic. See | |
131 c11-atomic-1.c for corresponding tests where _Atomic matches. */ | |
132 void fc0 (int _Atomic); /* { dg-message "previous declaration" } */ | |
133 void fc0 (int); /* { dg-error "conflicting types" } */ | |
134 void fc1 (int); /* { dg-message "prototype declaration" } */ | |
135 void | |
136 fc1 (x) | |
137 _Atomic int x; /* { dg-error "match prototype" } */ | |
138 { | |
139 } | |
140 void | |
141 fc2 (x) /* { dg-message "previous definition" } */ | |
142 _Atomic int x; | |
143 { | |
144 } | |
145 void fc2 (int); /* { dg-error "incompatible type" } */ | |
146 void fc3 (int); /* { dg-message "prototype declaration" } */ | |
147 void | |
148 fc3 (x) | |
149 _Atomic short x; /* { dg-error "match prototype" } */ | |
150 { | |
151 } | |
152 void | |
153 fc4 (x) /* { dg-message "previous definition" } */ | |
154 _Atomic short x; | |
155 { | |
156 } | |
157 void fc4 (int); /* { dg-error "incompatible type" } */ | |
158 | |
159 /* Arrays of atomic elements cannot be initialized with string | |
160 literals. */ | |
161 _Atomic char si0[] = ""; /* { dg-error "inappropriate type" } */ | |
162 _Atomic char si1[] = u8""; /* { dg-error "inappropriate type" } */ | |
163 _Atomic signed char si2[] = ""; /* { dg-error "inappropriate type" } */ | |
164 _Atomic signed char si3[] = u8""; /* { dg-error "inappropriate type" } */ | |
165 _Atomic unsigned char si4[] = ""; /* { dg-error "inappropriate type" } */ | |
166 _Atomic unsigned char si5[] = u8""; /* { dg-error "inappropriate type" } */ | |
167 _Atomic __WCHAR_TYPE__ si6[] = L""; /* { dg-error "inappropriate type" } */ | |
168 _Atomic __CHAR16_TYPE__ si7[] = u""; /* { dg-error "inappropriate type" } */ | |
169 _Atomic __CHAR32_TYPE__ si8[] = U""; /* { dg-error "inappropriate type" } */ | |
170 | |
171 /* Anything that is syntactically a qualifier applied to the (void) | |
172 parameter list results in undefined behavior, which we | |
173 diagnose. */ | |
174 void fv (_Atomic void); /* { dg-error "may not be qualified" } */ |