1 /* Test for _Atomic in C11. Test of valid code. See c11-atomic-2.c
2 for more exhaustive tests of assignment cases. */
3 /* { dg-do compile } */
4 /* { dg-options "-std=c11 -pedantic-errors" } */
5
6 /* The use of _Atomic as a qualifier, and of _Atomic (type-name), give
7 the same type. */
8 extern _Atomic int a;
9 extern _Atomic (int) a;
10 extern int *_Atomic b;
11 extern _Atomic (int *) b;
12 extern void f (int [_Atomic]);
13 extern void f (int *_Atomic);
14
15 /* _Atomic may be applied to arbitrary types, with or without other
16 qualifiers, and assignments may be made as with non-atomic
17 types. Structure and union elements may be atomic. */
18 _Atomic int ai1, ai2;
19 int i1;
20 volatile _Atomic long double ald1;
21 const _Atomic long double ald2;
22 long double ld1;
23 _Atomic _Complex double acd1, acd2;
24 _Complex double d1;
25 _Atomic volatile _Bool ab1;
26 int *p;
27 int *_Atomic restrict ap;
28 struct s { char c[1000]; };
29 _Atomic struct s as1;
30 struct s s1;
31 struct t { _Atomic int i; };
32 _Atomic struct t at1;
33 _Atomic struct t *atp1;
34 struct t t1;
35 union u { char c[1000]; };
36 _Atomic union u au1;
37 union u u1;
38 union v { _Atomic int i; };
39 _Atomic union v av1;
40 union v v1;
41
42 void
43 func (_Atomic volatile long al1)
44 {
45 ai1 = ai2;
46 ai1 = i1;
47 i1 = ai2;
48 ai1 = ald2;
49 ald1 = d1;
50 ld1 = acd2;
51 acd1 += ab1;
52 acd2 /= ai1;
53 p = ap;
54 ap = p;
55 ab1 = p;
56 as1 = s1;
57 s1 = as1;
58 at1 = t1;
59 t1 = at1;
60 /* It's unclear whether the undefined behavior (6.5.2.3#5) for
61 accessing elements of atomic structures and unions is at
62 translation or execution time; presume here that it's at
63 execution time. */
64 t1.i = at1.i; /* { dg-warning "accessing a member .i. of an atomic structure" } */
65 at1.i = t1.i; /* { dg-warning "accessing a member .i. of an atomic structure" } */
66 atp1->i = t1.i; /* { dg-warning "accessing a member .i. of an atomic structure" } */
67 au1 = u1;
68 u1 = au1;
69 av1 = v1;
70 v1 = av1;
71 v1.i = av1.i; /* { dg-warning "accessing a member .i. of an atomic union" } */
72 av1.i = v1.i; /* { dg-warning "accessing a member .i. of an atomic union" } */
73 /* _Atomic is valid on register variables, even if not particularly
74 useful. */
75 register _Atomic volatile int ra1 = 1, ra2 = 2;
76 ra1 = ra2;
77 ra2 = ra1;
78 /* And on parameters. */
79 al1 = ra1;
80 ra2 = al1;
81 }
82
83 /* A function may return an atomic type. */
84 _Atomic int
85 func2 (int i)
86 {
87 return i;
88 }
89
90 /* Casts may specify atomic type. */
91 int
92 func3 (int i)
93 {
94 return func2 ((_Atomic long) i);
95 }
96
97 /* The _Atomic void type is valid. */
98 _Atomic void *avp;
99
100 /* An array of atomic elements is valid (the elements being atomic,
101 not the array). */
102 _Atomic int aa[10];
103 int
104 func4 (void)
105 {
106 return aa[2];
107 }
108
109 /* Increment and decrement are valid for atomic types when they are
110 valid for non-atomic types. */
111 void
112 func5 (void)
113 {
114 ald1++;
115 ald1--;
116 ++ald1;
117 --ald1;
118 ai1++;
119 ai1--;
120 ++ai1;
121 --ai1;
122 ab1++;
123 ab1--;
124 ++ab1;
125 --ab1;
126 ap++;
127 ap--;
128 ++ap;
129 --ap;
130 }
131
132 /* Compound literals may have atomic type. */
133 _Atomic int *aiclp = &(_Atomic int) { 1 };
134
135 /* Test unary & and *. */
136 void
137 func6 (void)
138 {
139 int i = *aiclp;
140 _Atomic int *p = &ai2;
141 }
142
143 /* Casts to atomic type are valid (although the _Atomic has little
144 effect because the result is an rvalue). */
145 int i2 = (_Atomic int) 1.0;
146
147 /* For pointer subtraction and comparisons, _Atomic does not count as
148 a qualifier. Likewise for conditional expressions. */
149 _Atomic int *xaip1;
150 volatile _Atomic int *xaip2;
151 void *xvp1;
152
153 void
154 func7 (void)
155 {
156 int r;
157 r = xaip1 - xaip2;
158 r = xaip1 < xaip2;
159 r = xaip1 > xaip2;
160 r = xaip1 <= xaip2;
161 r = xaip1 >= xaip2;
162 r = xaip1 == xaip2;
163 r = xaip1 != xaip2;
164 r = xaip1 == xvp1;
165 r = xaip1 != xvp1;
166 r = xvp1 == xaip1;
167 r = xvp1 != xaip1;
168 r = xaip1 == 0;
169 r = ((void *) 0) == xaip2;
170 (void) (r ? xaip1 : xaip2);
171 (void) (r ? xvp1 : xaip2);
172 (void) (r ? xaip2 : xvp1);
173 (void) (r ? xaip1 : 0);
174 (void) (r ? 0 : xaip1);
175 /* The result of a conditional expression between a pointer to
176 qualified or unqualified (but not atomic) void, and a pointer to
177 an atomic type, is a pointer to appropriately qualified, not
178 atomic, void. As such, it is valid to use further in conditional
179 expressions with other pointer types. */
180 (void) (r ? xaip1 : (r ? xaip1 : xvp1));
181 }
182
183 /* Pointer += and -= integer is valid. */
184 void
185 func8 (void)
186 {
187 b += 1;
188 b -= 2ULL;
189 ap += 3;
190 }
191
192 /* Various other cases of simple assignment are valid (some already
193 tested above). */
194 void
195 func9 (void)
196 {
197 ap = 0;
198 ap = (void *) 0;
199 xvp1 = atp1;
200 atp1 = xvp1;
201 }
202
203 /* Test compatibility of function types in cases where _Atomic matches
204 (see c11-atomic-3.c for corresponding cases where it doesn't
205 match). */
206 void fc0a (int const);
207 void fc0a (int);
208 void fc0b (int _Atomic);
209 void fc0b (int _Atomic);
210 void fc1a (int);
211 void
212 fc1a (x)
213 volatile int x;
214 {
215 }
216 void fc1b (_Atomic int);
217 void
218 fc1b (x)
219 volatile _Atomic int x;
220 {
221 }
222 void
223 fc2a (x)
224 const int x;
225 {
226 }
227 void fc2a (int); /* { dg-warning "follows non-prototype" } */
228 void
229 fc2b (x)
230 _Atomic int x;
231 {
232 }
233 void fc2b (_Atomic int); /* { dg-warning "follows non-prototype" } */
234 void fc3a (int);
235 void
236 fc3a (x)
237 volatile short x;
238 {
239 }
240 void fc3b (_Atomic int);
241 void
242 fc3b (x)
243 _Atomic short x;
244 {
245 }
246 void
247 fc4a (x)
248 const short x;
249 {
250 }
251 void fc4a (int); /* { dg-warning "follows non-prototype" } */
252 void
253 fc4b (x)
254 _Atomic short x;
255 {
256 }
257 void fc4b (_Atomic int); /* { dg-warning "follows non-prototype" } */
258
259 /* Test cases involving C_MAYBE_CONST_EXPR work. */
260 void
261 func10 (_Atomic int *p)
262 {
263 p[0 / 0] = 1; /* { dg-warning "division by zero" } */
264 p[0 / 0] += 1; /* { dg-warning "division by zero" } */
265 *p = 0 / 0; /* { dg-warning "division by zero" } */
266 *p += 0 / 0; /* { dg-warning "division by zero" } */
267 }