source: tests/builtins/sync.cfa @ bfa7bf0

Last change on this file since bfa7bf0 was 53692b3, checked in by Peter A. Buhr <pabuhr@…>, 3 years ago

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