source: tests/builtins/sync.cfa@ 794db28

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 794db28 was c701332a, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

Cleanup of builtin atomics to remove _1,2,4 suffix versions and support all basic ints
  • 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 { __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); }
[1f81d61]132 #endif
[c64e979]133 { _Bool ret; ret = __sync_bool_compare_and_swap(vpp, vp, vp); }
[13073be]134
[c701332a]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); }
[1f81d61]140 #if defined(__SIZEOF_INT128__)
[c701332a]141 { __int128 ret; ret = __sync_val_compare_and_swap(vplll, vlll, vlll); }
[1f81d61]142 #endif
[c64e979]143 { struct type * ret; ret = __sync_val_compare_and_swap(vpp, vp, vp); }
144
[13073be]145
[c701332a]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); }
[1f81d61]151 #if defined(__SIZEOF_INT128__)
[c701332a]152 { __int128 ret; ret = __sync_lock_test_and_set(vplll, vlll); }
[1f81d61]153 #endif
[13073be]154
[c701332a]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); }
[1f81d61]160 #if defined(__SIZEOF_INT128__)
[c701332a]161 { __sync_lock_release(vplll); }
[1f81d61]162 #endif
[13073be]163
164 { __sync_synchronize(); }
165
166
167
168
169 { _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
[c701332a]170 { _Bool ret; ret = __atomic_test_and_set(vpc, vc); }
[13073be]171 { __atomic_clear(vpB, vB); }
[c701332a]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); }
[1f81d61]187 #endif
[c64e979]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); }
[13073be]190
[c701332a]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); }
[1f81d61]204 #endif
[c64e979]205 { struct type * ret; ret = __atomic_load_n(vpp, __ATOMIC_SEQ_CST); }
206 { struct type * ret; __atomic_load(vpp, &ret, __ATOMIC_SEQ_CST); }
[13073be]207
[c701332a]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); }
[1f81d61]221 #endif
[c64e979]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); }
[13073be]224
[c701332a]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); }
[1f81d61]238 #endif
[c64e979]239 { __atomic_store_n(vpp, vp, __ATOMIC_SEQ_CST); }
240 { __atomic_store(vpp, &vp, __ATOMIC_SEQ_CST); }
[13073be]241
[c701332a]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); }
[13073be]352 { __atomic_thread_fence(__ATOMIC_SEQ_CST); }
353 { __atomic_signal_fence(__ATOMIC_SEQ_CST); }
354}
355
356int main() {
357 return 0;
358}
Note: See TracBrowser for help on using the repository browser.