source: tests/builtins/sync.cfa @ 66812dd

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 66812dd was 66812dd, checked in by Peter A. Buhr <pabuhr@…>, 14 months ago

convert tests to always print output (no empty .expect files)

  • Property mode set to 100644
File size: 16.9 KB
Line 
1#include <stdbool.h>
2#include <stdint.h>
3
4void foo() {
5        volatile _Bool * vpB = 0; _Bool vB = 0;
6        volatile char * vpc = 0; char * rpc = 0; char vc = 0;
7        volatile short * vps = 0; short * rps = 0; short vs = 0;
8        volatile int * vpi = 0; int * rpi = 0; int vi = 0;
9        volatile long int * vpl = 0; long int * rpl = 0; long int vl = 0;
10        volatile long long int * vpll = 0; long long int * rpll = 0; long long int vll = 0;
11        #if defined(__SIZEOF_INT128__)
12        volatile __int128 * vplll = 0; __int128 * rplll = 0; __int128 vlll = 0;
13        #endif
14        struct type * volatile * vpp = 0; struct type ** rpp = 0; struct type * vp = 0;
15
16        { char ret; ret = __sync_fetch_and_add(vpc, vc); }
17        { short ret; ret = __sync_fetch_and_add(vps, vs); }
18        { int ret; ret = __sync_fetch_and_add(vpi, vi); }
19        { long int ret; ret = __sync_fetch_and_add(vpl, vl); }
20        { long long int ret; ret = __sync_fetch_and_add(vpll, vll); }
21        #if defined(__SIZEOF_INT128__)
22        { __int128 ret; ret = __sync_fetch_and_add(vplll, vlll); }
23        #endif
24
25        { char ret; ret = __sync_fetch_and_sub(vpc, vc); }
26        { short ret; ret = __sync_fetch_and_sub(vps, vs); }
27        { int ret; ret = __sync_fetch_and_sub(vpi, vi); }
28        { long int ret; ret = __sync_fetch_and_sub(vpl, vl); }
29        { long long int ret; ret = __sync_fetch_and_sub(vpll, vll); }
30        #if defined(__SIZEOF_INT128__)
31        { __int128 ret; ret = __sync_fetch_and_sub(vplll, vlll); }
32        #endif
33
34        { char ret; ret = __sync_fetch_and_or(vpc, vc); }
35        { short ret; ret = __sync_fetch_and_or(vps, vs); }
36        { int ret; ret = __sync_fetch_and_or(vpi, vi); }
37        { long int ret; ret = __sync_fetch_and_or(vpl, vl); }
38        { long long int ret; ret = __sync_fetch_and_or(vpll, vll); }
39        #if defined(__SIZEOF_INT128__)
40        { __int128 ret; ret = __sync_fetch_and_or(vplll, vlll); }
41        #endif
42
43        { char ret; ret = __sync_fetch_and_and(vpc, vc); }
44        { short ret; ret = __sync_fetch_and_and(vps, vs); }
45        { int ret; ret = __sync_fetch_and_and(vpi, vi); }
46        { long int ret; ret = __sync_fetch_and_and(vpl, vl); }
47        { long long int ret; ret = __sync_fetch_and_and(vpll, vll); }
48        #if defined(__SIZEOF_INT128__)
49        { __int128 ret; ret = __sync_fetch_and_and(vplll, vlll); }
50        #endif
51
52        { char ret; ret = __sync_fetch_and_xor(vpc, vc); }
53        { short ret; ret = __sync_fetch_and_xor(vps, vs); }
54        { int ret; ret = __sync_fetch_and_xor(vpi, vi); }
55        { long int ret; ret = __sync_fetch_and_xor(vpl, vl); }
56        { long long int ret; ret = __sync_fetch_and_xor(vpll, vll); }
57        #if defined(__SIZEOF_INT128__)
58        { __int128 ret; ret = __sync_fetch_and_xor(vplll, vlll); }
59        #endif
60
61        { char ret; ret = __sync_fetch_and_nand(vpc, vc); }
62        { short ret; ret = __sync_fetch_and_nand(vps, vs); }
63        { int ret; ret = __sync_fetch_and_nand(vpi, vi); }
64        { long int ret; ret = __sync_fetch_and_nand(vpl, vl); }
65        { long long int ret; ret = __sync_fetch_and_nand(vpll, vll); }
66        #if defined(__SIZEOF_INT128__)
67        { __int128 ret; ret = __sync_fetch_and_nand(vplll, vlll); }
68        { __int128 ret; ret = __sync_fetch_and_nand_16(vplll, vlll); }
69        #endif
70
71        { char ret; ret = __sync_add_and_fetch(vpc, vc); }
72        { short ret; ret = __sync_add_and_fetch(vps, vs); }
73        { int ret; ret = __sync_add_and_fetch(vpi, vi); }
74        { long int ret; ret = __sync_add_and_fetch(vpl, vl); }
75        { long long int ret; ret = __sync_add_and_fetch(vpll, vll); }
76        #if defined(__SIZEOF_INT128__)
77        { __int128 ret; ret = __sync_add_and_fetch(vplll, vlll); }
78        #endif
79
80        { char ret; ret = __sync_sub_and_fetch(vpc, vc); }
81        { short ret; ret = __sync_sub_and_fetch(vps, vs); }
82        { int ret; ret = __sync_sub_and_fetch(vpi, vi); }
83        { long int ret; ret = __sync_sub_and_fetch(vpl, vl); }
84        { long long int ret; ret = __sync_sub_and_fetch(vpll, vll); }
85        #if defined(__SIZEOF_INT128__)
86        { __int128 ret; ret = __sync_sub_and_fetch(vplll, vlll); }
87        #endif
88
89        { char ret; ret = __sync_or_and_fetch(vpc, vc); }
90        { short ret; ret = __sync_or_and_fetch(vps, vs); }
91        { int ret; ret = __sync_or_and_fetch(vpi, vi); }
92        { long int ret; ret = __sync_or_and_fetch(vpl, vl); }
93        { long long int ret; ret = __sync_or_and_fetch(vpll, vll); }
94        #if defined(__SIZEOF_INT128__)
95        { __int128 ret; ret = __sync_or_and_fetch(vplll, vlll); }
96        #endif
97
98        { char ret; ret = __sync_and_and_fetch(vpc, vc); }
99        { short ret; ret = __sync_and_and_fetch(vps, vs); }
100        { int ret; ret = __sync_and_and_fetch(vpi, vi); }
101        { long int ret; ret = __sync_and_and_fetch(vpl, vl); }
102        { long long int ret; ret = __sync_and_and_fetch(vpll, vll); }
103        #if defined(__SIZEOF_INT128__)
104        { __int128 ret; ret = __sync_and_and_fetch(vplll, vlll); }
105        #endif
106
107        { char ret; ret = __sync_xor_and_fetch(vpc, vc); }
108        { short ret; ret = __sync_xor_and_fetch(vps, vs); }
109        { int ret; ret = __sync_xor_and_fetch(vpi, vi); }
110        { long int ret; ret = __sync_xor_and_fetch(vpl, vl); }
111        { long long int ret; ret = __sync_xor_and_fetch(vpll, vll); }
112        #if defined(__SIZEOF_INT128__)
113        { __int128 ret; ret = __sync_xor_and_fetch(vplll, vlll); }
114        #endif
115
116        { char ret; ret = __sync_nand_and_fetch(vpc, vc); }
117        { short ret; ret = __sync_nand_and_fetch(vps, vs); }
118        { int ret; ret = __sync_nand_and_fetch(vpi, vi); }
119        { long int ret; ret = __sync_nand_and_fetch(vpl, vl); }
120        { long long int ret; ret = __sync_nand_and_fetch(vpll, vll); }
121        #if defined(__SIZEOF_INT128__)
122        { __int128 ret; ret = __sync_nand_and_fetch(vplll, vlll); }
123        #endif
124
125        { _Bool ret; ret = __sync_bool_compare_and_swap(vpc, vc, vc); }
126        { _Bool ret; ret = __sync_bool_compare_and_swap(vps, vs, vs); }
127        { _Bool ret; ret = __sync_bool_compare_and_swap(vpi, vi, vi); }
128        { _Bool ret; ret = __sync_bool_compare_and_swap(vpl, vl, vl); }
129        { _Bool ret; ret = __sync_bool_compare_and_swap(vpll, vll, vll); }
130        #if defined(__SIZEOF_INT128__)
131        { _Bool ret; ret = __sync_bool_compare_and_swap(vplll, vlll, vlll); }
132        #endif
133        { _Bool ret; ret = __sync_bool_compare_and_swap(vpp, vp, vp); }
134
135        { char ret; ret = __sync_val_compare_and_swap(vpc, vc, vc); }
136        { short ret; ret = __sync_val_compare_and_swap(vps, vs, vs); }
137        { int ret; ret = __sync_val_compare_and_swap(vpi, vi, vi); }
138        { long int ret; ret = __sync_val_compare_and_swap(vpl, vl, vl); }
139        { long long int ret; ret = __sync_val_compare_and_swap(vpll, vll, vll); }
140        #if defined(__SIZEOF_INT128__)
141        { __int128 ret; ret = __sync_val_compare_and_swap(vplll, vlll, vlll); }
142        #endif
143        { struct type * ret; ret = __sync_val_compare_and_swap(vpp, vp, vp); }
144
145
146        { char ret; ret = __sync_lock_test_and_set(vpc, vc); }
147        { short ret; ret = __sync_lock_test_and_set(vps, vs); }
148        { int ret; ret = __sync_lock_test_and_set(vpi, vi); }
149        { long int ret; ret = __sync_lock_test_and_set(vpl, vl); }
150        { long long int ret; ret = __sync_lock_test_and_set(vpll, vll); }
151        #if defined(__SIZEOF_INT128__)
152        { __int128 ret; ret = __sync_lock_test_and_set(vplll, vlll); }
153        #endif
154
155        { __sync_lock_release(vpc); }
156        { __sync_lock_release(vps); }
157        { __sync_lock_release(vpi); }
158        { __sync_lock_release(vpl); }
159        { __sync_lock_release(vpll); }
160        #if defined(__SIZEOF_INT128__)
161        { __sync_lock_release(vplll); }
162        #endif
163
164        { __sync_synchronize(); }
165
166
167
168
169        { _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
170        { _Bool ret; ret = __atomic_test_and_set(vpc, vc); }
171        { __atomic_clear(vpB, vB); }
172        { __atomic_clear(vpc, vc); }
173
174        { char ret; ret = __atomic_exchange_n(vpc, vc, __ATOMIC_SEQ_CST); }
175        { char ret; __atomic_exchange(vpc, &vc, &ret, __ATOMIC_SEQ_CST); }
176        { short ret; ret = __atomic_exchange_n(vps, vs, __ATOMIC_SEQ_CST); }
177        { short ret; __atomic_exchange(vps, &vs, &ret, __ATOMIC_SEQ_CST); }
178        { int ret; ret = __atomic_exchange_n(vpi, vi, __ATOMIC_SEQ_CST); }
179        { int ret; __atomic_exchange(vpi, &vi, &ret, __ATOMIC_SEQ_CST); }
180        { long int ret; ret = __atomic_exchange_n(vpl, vl, __ATOMIC_SEQ_CST); }
181        { long int ret; __atomic_exchange(vpl, &vl, &ret, __ATOMIC_SEQ_CST); }
182        { long long int ret; ret = __atomic_exchange_n(vpll, vll, __ATOMIC_SEQ_CST); }
183        { long long int ret; __atomic_exchange(vpll, &vll, &ret, __ATOMIC_SEQ_CST); }
184        #if defined(__SIZEOF_INT128__)
185        { __int128 ret; ret = __atomic_exchange_n(vplll, vlll, __ATOMIC_SEQ_CST); }
186        { __int128 ret; __atomic_exchange(vplll, &vlll, &ret, __ATOMIC_SEQ_CST); }
187        #endif
188        { struct type * ret; ret = __atomic_exchange_n(vpp, vp, __ATOMIC_SEQ_CST); }
189        { struct type * ret; __atomic_exchange(vpp, &vp, &ret, __ATOMIC_SEQ_CST); }
190
191        { char ret; ret = __atomic_load_n(vpc, __ATOMIC_SEQ_CST); }
192        { char ret; __atomic_load(vpc, &ret, __ATOMIC_SEQ_CST); }
193        { short ret; ret = __atomic_load_n(vps, __ATOMIC_SEQ_CST); }
194        { short ret; __atomic_load(vps, &ret, __ATOMIC_SEQ_CST); }
195        { int ret; ret = __atomic_load_n(vpi, __ATOMIC_SEQ_CST); }
196        { int ret; __atomic_load(vpi, &ret, __ATOMIC_SEQ_CST); }
197        { long int ret; ret = __atomic_load_n(vpl, __ATOMIC_SEQ_CST); }
198        { long int ret; __atomic_load(vpl, &ret, __ATOMIC_SEQ_CST); }
199        { long long int ret; ret = __atomic_load_n(vpll, __ATOMIC_SEQ_CST); }
200        { long long int ret; __atomic_load(vpll, &ret, __ATOMIC_SEQ_CST); }
201        #if defined(__SIZEOF_INT128__)
202        { __int128 ret; ret = __atomic_load_n(vplll, __ATOMIC_SEQ_CST); }
203        { __int128 ret; __atomic_load(vplll, &ret, __ATOMIC_SEQ_CST); }
204        #endif
205        { struct type * ret; ret = __atomic_load_n(vpp, __ATOMIC_SEQ_CST); }
206        { struct type * ret; __atomic_load(vpp, &ret, __ATOMIC_SEQ_CST); }
207
208        { _Bool ret; ret = __atomic_compare_exchange_n(vpc, rpc, vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
209        { _Bool ret; ret = __atomic_compare_exchange(vpc, rpc, &vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
210        { _Bool ret; ret = __atomic_compare_exchange_n(vps, rps, vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
211        { _Bool ret; ret = __atomic_compare_exchange(vps, rps, &vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
212        { _Bool ret; ret = __atomic_compare_exchange_n(vpi, rpi, vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
213        { _Bool ret; ret = __atomic_compare_exchange(vpi, rpi, &vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
214        { _Bool ret; ret = __atomic_compare_exchange_n(vpl, rpl, vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
215        { _Bool ret; ret = __atomic_compare_exchange(vpl, rpl, &vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
216        { _Bool ret; ret = __atomic_compare_exchange_n(vpll, rpll, vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
217        { _Bool ret; ret = __atomic_compare_exchange(vpll, rpll, &vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
218        #if defined(__SIZEOF_INT128__)
219        { _Bool ret; ret = __atomic_compare_exchange_n(vplll, rplll, vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
220        { _Bool ret; ret = __atomic_compare_exchange(vplll, rplll, &vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
221        #endif
222        { _Bool ret; ret = __atomic_compare_exchange_n(vpp, rpp, vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
223        { _Bool ret; ret = __atomic_compare_exchange(vpp, rpp, &vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
224
225        { __atomic_store_n(vpc, vc, __ATOMIC_SEQ_CST); }
226        { __atomic_store(vpc, &vc, __ATOMIC_SEQ_CST); }
227        { __atomic_store_n(vps, vs, __ATOMIC_SEQ_CST); }
228        { __atomic_store(vps, &vs, __ATOMIC_SEQ_CST); }
229        { __atomic_store_n(vpi, vi, __ATOMIC_SEQ_CST); }
230        { __atomic_store(vpi, &vi, __ATOMIC_SEQ_CST); }
231        { __atomic_store_n(vpl, vl, __ATOMIC_SEQ_CST); }
232        { __atomic_store(vpl, &vl, __ATOMIC_SEQ_CST); }
233        { __atomic_store_n(vpll, vll, __ATOMIC_SEQ_CST); }
234        { __atomic_store(vpll, &vll, __ATOMIC_SEQ_CST); }
235        #if defined(__SIZEOF_INT128__)
236        { __atomic_store_n(vplll, vlll, __ATOMIC_SEQ_CST); }
237        { __atomic_store(vplll, &vlll, __ATOMIC_SEQ_CST); }
238        #endif
239        { __atomic_store_n(vpp, vp, __ATOMIC_SEQ_CST); }
240        { __atomic_store(vpp, &vp, __ATOMIC_SEQ_CST); }
241
242        { char ret; ret = __atomic_add_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
243        { short ret; ret = __atomic_add_fetch(vps, vs, __ATOMIC_SEQ_CST); }
244        { int ret; ret = __atomic_add_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
245        { long int ret; ret = __atomic_add_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
246        { long long int ret; ret = __atomic_add_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
247        #if defined(__SIZEOF_INT128__)
248        { __int128 ret; ret = __atomic_add_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
249        #endif
250
251        { char ret; ret = __atomic_sub_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
252        { short ret; ret = __atomic_sub_fetch(vps, vs, __ATOMIC_SEQ_CST); }
253        { int ret; ret = __atomic_sub_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
254        { long int ret; ret = __atomic_sub_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
255        { long long int ret; ret = __atomic_sub_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
256        #if defined(__SIZEOF_INT128__)
257        { __int128 ret; ret = __atomic_sub_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
258        #endif
259
260        { char ret; ret = __atomic_and_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
261        { short ret; ret = __atomic_and_fetch(vps, vs, __ATOMIC_SEQ_CST); }
262        { int ret; ret = __atomic_and_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
263        { long int ret; ret = __atomic_and_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
264        { long long int ret; ret = __atomic_and_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
265        #if defined(__SIZEOF_INT128__)
266        { __int128 ret; ret = __atomic_and_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
267        #endif
268
269        { char ret; ret = __atomic_nand_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
270        { short ret; ret = __atomic_nand_fetch(vps, vs, __ATOMIC_SEQ_CST); }
271        { int ret; ret = __atomic_nand_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
272        { long int ret; ret = __atomic_nand_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
273        { long long int ret; ret = __atomic_nand_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
274        #if defined(__SIZEOF_INT128__)
275        { __int128 ret; ret = __atomic_nand_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
276        #endif
277
278        { char ret; ret = __atomic_xor_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
279        { short ret; ret = __atomic_xor_fetch(vps, vs, __ATOMIC_SEQ_CST); }
280        { int ret; ret = __atomic_xor_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
281        { long int ret; ret = __atomic_xor_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
282        { long long int ret; ret = __atomic_xor_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
283        #if defined(__SIZEOF_INT128__)
284        { __int128 ret; ret = __atomic_xor_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
285        #endif
286
287        { char ret; ret = __atomic_or_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
288        { short ret; ret = __atomic_or_fetch(vps, vs, __ATOMIC_SEQ_CST); }
289        { int ret; ret = __atomic_or_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
290        { long int ret; ret = __atomic_or_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
291        { long long int ret; ret = __atomic_or_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
292        #if defined(__SIZEOF_INT128__)
293        { __int128 ret; ret = __atomic_or_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
294        #endif
295
296        { char ret; ret = __atomic_fetch_add(vpc, vc, __ATOMIC_SEQ_CST); }
297        { short ret; ret = __atomic_fetch_add(vps, vs, __ATOMIC_SEQ_CST); }
298        { int ret; ret = __atomic_fetch_add(vpi, vi, __ATOMIC_SEQ_CST); }
299        { long int ret; ret = __atomic_fetch_add(vpl, vl, __ATOMIC_SEQ_CST); }
300        { long long int ret; ret = __atomic_fetch_add(vpll, vll, __ATOMIC_SEQ_CST); }
301        #if defined(__SIZEOF_INT128__)
302        { __int128 ret; ret = __atomic_fetch_add(vplll, vlll, __ATOMIC_SEQ_CST); }
303        #endif
304
305        { char ret; ret = __atomic_fetch_sub(vpc, vc, __ATOMIC_SEQ_CST); }
306        { short ret; ret = __atomic_fetch_sub(vps, vs, __ATOMIC_SEQ_CST); }
307        { int ret; ret = __atomic_fetch_sub(vpi, vi, __ATOMIC_SEQ_CST); }
308        { long int ret; ret = __atomic_fetch_sub(vpl, vl, __ATOMIC_SEQ_CST); }
309        { long long int ret; ret = __atomic_fetch_sub(vpll, vll, __ATOMIC_SEQ_CST); }
310        #if defined(__SIZEOF_INT128__)
311        { __int128 ret; ret = __atomic_fetch_sub(vplll, vlll, __ATOMIC_SEQ_CST); }
312        #endif
313
314        { char ret; ret = __atomic_fetch_and(vpc, vc, __ATOMIC_SEQ_CST); }
315        { short ret; ret = __atomic_fetch_and(vps, vs, __ATOMIC_SEQ_CST); }
316        { int ret; ret = __atomic_fetch_and(vpi, vi, __ATOMIC_SEQ_CST); }
317        { long int ret; ret = __atomic_fetch_and(vpl, vl, __ATOMIC_SEQ_CST); }
318        { long long int ret; ret = __atomic_fetch_and(vpll, vll, __ATOMIC_SEQ_CST); }
319        #if defined(__SIZEOF_INT128__)
320        { __int128 ret; ret = __atomic_fetch_and(vplll, vlll, __ATOMIC_SEQ_CST); }
321        #endif
322
323        { char ret; ret = __atomic_fetch_nand(vpc, vc, __ATOMIC_SEQ_CST); }
324        { short ret; ret = __atomic_fetch_nand(vps, vs, __ATOMIC_SEQ_CST); }
325        { int ret; ret = __atomic_fetch_nand(vpi, vi, __ATOMIC_SEQ_CST); }
326        { long int ret; ret = __atomic_fetch_nand(vpl, vl, __ATOMIC_SEQ_CST); }
327        { long long int ret; ret = __atomic_fetch_nand(vpll, vll, __ATOMIC_SEQ_CST); }
328        #if defined(__SIZEOF_INT128__)
329        { __int128 ret; ret = __atomic_fetch_nand(vplll, vlll, __ATOMIC_SEQ_CST); }
330        #endif
331
332        { char ret; ret = __atomic_fetch_xor(vpc, vc, __ATOMIC_SEQ_CST); }
333        { short ret; ret = __atomic_fetch_xor(vps, vs, __ATOMIC_SEQ_CST); }
334        { int ret; ret = __atomic_fetch_xor(vpi, vi, __ATOMIC_SEQ_CST); }
335        { long int ret; ret = __atomic_fetch_xor(vpl, vl, __ATOMIC_SEQ_CST); }
336        { long long int ret; ret = __atomic_fetch_xor(vpll, vll, __ATOMIC_SEQ_CST); }
337        #if defined(__SIZEOF_INT128__)
338        { __int128 ret; ret = __atomic_fetch_xor(vplll, vlll, __ATOMIC_SEQ_CST); }
339        #endif
340
341        { char ret; ret = __atomic_fetch_or(vpc, vc, __ATOMIC_SEQ_CST); }
342        { short ret; ret = __atomic_fetch_or(vps, vs, __ATOMIC_SEQ_CST); }
343        { int ret; ret = __atomic_fetch_or(vpi, vi, __ATOMIC_SEQ_CST); }
344        { long int ret; ret = __atomic_fetch_or(vpl, vl, __ATOMIC_SEQ_CST); }
345        { long long int ret; ret = __atomic_fetch_or(vpll, vll, __ATOMIC_SEQ_CST); }
346        #if defined(__SIZEOF_INT128__)
347        { __int128 ret; ret = __atomic_fetch_or(vplll, vlll, __ATOMIC_SEQ_CST); }
348        #endif
349
350        { _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vpi); }
351        { _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vpi); }
352        { __atomic_thread_fence(__ATOMIC_SEQ_CST); }
353        { __atomic_signal_fence(__ATOMIC_SEQ_CST); }
354}
355
356int main() {
357        #pragma message( "Compiled" )                   // force non-empty .expect file
358}
Note: See TracBrowser for help on using the repository browser.