source: tests/builtins/sync.cfa @ 107b01a

aaron-thesisarm-ehcleanup-dtorsdeferred_resnjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprno_listpersistent-indexer
Last change on this file since 107b01a was 107b01a, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

Several changes to the makefiles

  • change .c tests to .cfa
  • add require for libtool in configure
  • libtoolize to fix some warnings
  • Property mode set to 100644
File size: 23.7 KB
Line 
1#include <stdbool.h>
2#include <stdint.h>
3
4void foo() {
5        volatile _Bool * vpB = 0; _Bool vB = 0;
6        volatile char * vp1 = 0; char * rp1 = 0; char v1 = 0;
7        volatile short * vp2 = 0; short * rp2 = 0; short v2 = 0;
8        volatile int * vp4 = 0; int * rp4 = 0; int v4 = 0;
9        volatile long long int * vp8 = 0; long long int * rp8 = 0; long long int v8 = 0;
10        #if defined(__SIZEOF_INT128__)
11        volatile __int128 * vp16 = 0; __int128 * rp16 = 0; __int128 v16 = 0;
12        #endif
13
14        { char ret; ret = __sync_fetch_and_add(vp1, v1); }
15        { char ret; ret = __sync_fetch_and_add_1(vp1, v1); }
16        { short ret; ret = __sync_fetch_and_add(vp2, v2); }
17        { short ret; ret = __sync_fetch_and_add_2(vp2, v2); }
18        { int ret; ret = __sync_fetch_and_add(vp4, v4); }
19        { int ret; ret = __sync_fetch_and_add_4(vp4, v4); }
20        { long long int ret; ret = __sync_fetch_and_add(vp8, v8); }
21        { long long int ret; ret = __sync_fetch_and_add_8(vp8, v8); }
22        #if defined(__SIZEOF_INT128__)
23        { __int128 ret; ret = __sync_fetch_and_add(vp16, v16); }
24        { __int128 ret; ret = __sync_fetch_and_add_16(vp16, v16); }
25        #endif
26
27        { char ret; ret = __sync_fetch_and_sub(vp1, v1); }
28        { char ret; ret = __sync_fetch_and_sub_1(vp1, v1); }
29        { short ret; ret = __sync_fetch_and_sub(vp2, v2); }
30        { short ret; ret = __sync_fetch_and_sub_2(vp2, v2); }
31        { int ret; ret = __sync_fetch_and_sub(vp4, v4); }
32        { int ret; ret = __sync_fetch_and_sub_4(vp4, v4); }
33        { long long int ret; ret = __sync_fetch_and_sub(vp8, v8); }
34        { long long int ret; ret = __sync_fetch_and_sub_8(vp8, v8); }
35        #if defined(__SIZEOF_INT128__)
36        { __int128 ret; ret = __sync_fetch_and_sub(vp16, v16); }
37        { __int128 ret; ret = __sync_fetch_and_sub_16(vp16, v16); }
38        #endif
39
40        { char ret; ret = __sync_fetch_and_or(vp1, v1); }
41        { char ret; ret = __sync_fetch_and_or_1(vp1, v1); }
42        { short ret; ret = __sync_fetch_and_or(vp2, v2); }
43        { short ret; ret = __sync_fetch_and_or_2(vp2, v2); }
44        { int ret; ret = __sync_fetch_and_or(vp4, v4); }
45        { int ret; ret = __sync_fetch_and_or_4(vp4, v4); }
46        { long long int ret; ret = __sync_fetch_and_or(vp8, v8); }
47        { long long int ret; ret = __sync_fetch_and_or_8(vp8, v8); }
48        #if defined(__SIZEOF_INT128__)
49        { __int128 ret; ret = __sync_fetch_and_or(vp16, v16); }
50        { __int128 ret; ret = __sync_fetch_and_or_16(vp16, v16); }
51        #endif
52
53        { char ret; ret = __sync_fetch_and_and(vp1, v1); }
54        { char ret; ret = __sync_fetch_and_and_1(vp1, v1); }
55        { short ret; ret = __sync_fetch_and_and(vp2, v2); }
56        { short ret; ret = __sync_fetch_and_and_2(vp2, v2); }
57        { int ret; ret = __sync_fetch_and_and(vp4, v4); }
58        { int ret; ret = __sync_fetch_and_and_4(vp4, v4); }
59        { long long int ret; ret = __sync_fetch_and_and(vp8, v8); }
60        { long long int ret; ret = __sync_fetch_and_and_8(vp8, v8); }
61        #if defined(__SIZEOF_INT128__)
62        { __int128 ret; ret = __sync_fetch_and_and(vp16, v16); }
63        { __int128 ret; ret = __sync_fetch_and_and_16(vp16, v16); }
64        #endif
65
66        { char ret; ret = __sync_fetch_and_xor(vp1, v1); }
67        { char ret; ret = __sync_fetch_and_xor_1(vp1, v1); }
68        { short ret; ret = __sync_fetch_and_xor(vp2, v2); }
69        { short ret; ret = __sync_fetch_and_xor_2(vp2, v2); }
70        { int ret; ret = __sync_fetch_and_xor(vp4, v4); }
71        { int ret; ret = __sync_fetch_and_xor_4(vp4, v4); }
72        { long long int ret; ret = __sync_fetch_and_xor(vp8, v8); }
73        { long long int ret; ret = __sync_fetch_and_xor_8(vp8, v8); }
74        #if defined(__SIZEOF_INT128__)
75        { __int128 ret; ret = __sync_fetch_and_xor(vp16, v16); }
76        { __int128 ret; ret = __sync_fetch_and_xor_16(vp16, v16); }
77        #endif
78
79        { char ret; ret = __sync_fetch_and_nand(vp1, v1); }
80        { char ret; ret = __sync_fetch_and_nand_1(vp1, v1); }
81        { short ret; ret = __sync_fetch_and_nand(vp2, v2); }
82        { short ret; ret = __sync_fetch_and_nand_2(vp2, v2); }
83        { int ret; ret = __sync_fetch_and_nand(vp4, v4); }
84        { int ret; ret = __sync_fetch_and_nand_4(vp4, v4); }
85        { long long int ret; ret = __sync_fetch_and_nand(vp8, v8); }
86        { long long int ret; ret = __sync_fetch_and_nand_8(vp8, v8); }
87        #if defined(__SIZEOF_INT128__)
88        { __int128 ret; ret = __sync_fetch_and_nand(vp16, v16); }
89        { __int128 ret; ret = __sync_fetch_and_nand_16(vp16, v16); }
90        #endif
91
92        { char ret; ret = __sync_add_and_fetch(vp1, v1); }
93        { char ret; ret = __sync_add_and_fetch_1(vp1, v1); }
94        { short ret; ret = __sync_add_and_fetch(vp2, v2); }
95        { short ret; ret = __sync_add_and_fetch_2(vp2, v2); }
96        { int ret; ret = __sync_add_and_fetch(vp4, v4); }
97        { int ret; ret = __sync_add_and_fetch_4(vp4, v4); }
98        { long long int ret; ret = __sync_add_and_fetch(vp8, v8); }
99        { long long int ret; ret = __sync_add_and_fetch_8(vp8, v8); }
100        #if defined(__SIZEOF_INT128__)
101        { __int128 ret; ret = __sync_add_and_fetch(vp16, v16); }
102        { __int128 ret; ret = __sync_add_and_fetch_16(vp16, v16); }
103        #endif
104
105        { char ret; ret = __sync_sub_and_fetch(vp1, v1); }
106        { char ret; ret = __sync_sub_and_fetch_1(vp1, v1); }
107        { short ret; ret = __sync_sub_and_fetch(vp2, v2); }
108        { short ret; ret = __sync_sub_and_fetch_2(vp2, v2); }
109        { int ret; ret = __sync_sub_and_fetch(vp4, v4); }
110        { int ret; ret = __sync_sub_and_fetch_4(vp4, v4); }
111        { long long int ret; ret = __sync_sub_and_fetch(vp8, v8); }
112        { long long int ret; ret = __sync_sub_and_fetch_8(vp8, v8); }
113        #if defined(__SIZEOF_INT128__)
114        { __int128 ret; ret = __sync_sub_and_fetch(vp16, v16); }
115        { __int128 ret; ret = __sync_sub_and_fetch_16(vp16, v16); }
116        #endif
117
118        { char ret; ret = __sync_or_and_fetch(vp1, v1); }
119        { char ret; ret = __sync_or_and_fetch_1(vp1, v1); }
120        { short ret; ret = __sync_or_and_fetch(vp2, v2); }
121        { short ret; ret = __sync_or_and_fetch_2(vp2, v2); }
122        { int ret; ret = __sync_or_and_fetch(vp4, v4); }
123        { int ret; ret = __sync_or_and_fetch_4(vp4, v4); }
124        { long long int ret; ret = __sync_or_and_fetch(vp8, v8); }
125        { long long int ret; ret = __sync_or_and_fetch_8(vp8, v8); }
126        #if defined(__SIZEOF_INT128__)
127        { __int128 ret; ret = __sync_or_and_fetch(vp16, v16); }
128        { __int128 ret; ret = __sync_or_and_fetch_16(vp16, v16); }
129        #endif
130
131        { char ret; ret = __sync_and_and_fetch(vp1, v1); }
132        { char ret; ret = __sync_and_and_fetch_1(vp1, v1); }
133        { short ret; ret = __sync_and_and_fetch(vp2, v2); }
134        { short ret; ret = __sync_and_and_fetch_2(vp2, v2); }
135        { int ret; ret = __sync_and_and_fetch(vp4, v4); }
136        { int ret; ret = __sync_and_and_fetch_4(vp4, v4); }
137        { long long int ret; ret = __sync_and_and_fetch(vp8, v8); }
138        { long long int ret; ret = __sync_and_and_fetch_8(vp8, v8); }
139        #if defined(__SIZEOF_INT128__)
140        { __int128 ret; ret = __sync_and_and_fetch(vp16, v16); }
141        { __int128 ret; ret = __sync_and_and_fetch_16(vp16, v16); }
142        #endif
143
144        { char ret; ret = __sync_xor_and_fetch(vp1, v1); }
145        { char ret; ret = __sync_xor_and_fetch_1(vp1, v1); }
146        { short ret; ret = __sync_xor_and_fetch(vp2, v2); }
147        { short ret; ret = __sync_xor_and_fetch_2(vp2, v2); }
148        { int ret; ret = __sync_xor_and_fetch(vp4, v4); }
149        { int ret; ret = __sync_xor_and_fetch_4(vp4, v4); }
150        { long long int ret; ret = __sync_xor_and_fetch(vp8, v8); }
151        { long long int ret; ret = __sync_xor_and_fetch_8(vp8, v8); }
152        #if defined(__SIZEOF_INT128__)
153        { __int128 ret; ret = __sync_xor_and_fetch(vp16, v16); }
154        { __int128 ret; ret = __sync_xor_and_fetch_16(vp16, v16); }
155        #endif
156
157        { char ret; ret = __sync_nand_and_fetch(vp1, v1); }
158        { char ret; ret = __sync_nand_and_fetch_1(vp1, v1); }
159        { short ret; ret = __sync_nand_and_fetch(vp2, v2); }
160        { short ret; ret = __sync_nand_and_fetch_2(vp2, v2); }
161        { int ret; ret = __sync_nand_and_fetch(vp4, v4); }
162        { int ret; ret = __sync_nand_and_fetch_4(vp4, v4); }
163        { long long int ret; ret = __sync_nand_and_fetch(vp8, v8); }
164        { long long int ret; ret = __sync_nand_and_fetch_8(vp8, v8); }
165        #if defined(__SIZEOF_INT128__)
166        { __int128 ret; ret = __sync_nand_and_fetch(vp16, v16); }
167        { __int128 ret; ret = __sync_nand_and_fetch_16(vp16, v16); }
168        #endif
169
170        { _Bool ret; ret = __sync_bool_compare_and_swap(vp1, v1, v1); }
171        { _Bool ret; ret = __sync_bool_compare_and_swap_1(vp1, v1, v1); }
172        { _Bool ret; ret = __sync_bool_compare_and_swap(vp2, v2, v2); }
173        { _Bool ret; ret = __sync_bool_compare_and_swap_2(vp2, v2, v2); }
174        { _Bool ret; ret = __sync_bool_compare_and_swap(vp4, v4, v4); }
175        { _Bool ret; ret = __sync_bool_compare_and_swap_4(vp4, v4, v4); }
176        { _Bool ret; ret = __sync_bool_compare_and_swap(vp8, v8, v8); }
177        { _Bool ret; ret = __sync_bool_compare_and_swap_8(vp8, v8, v8); }
178        #if defined(__SIZEOF_INT128__)
179        { _Bool ret; ret = __sync_bool_compare_and_swap(vp16, v16, v16); }
180        { _Bool ret; ret = __sync_bool_compare_and_swap_16(vp16, v16,v16); }
181        #endif
182
183        { char ret; ret = __sync_val_compare_and_swap(vp1, v1, v1); }
184        { char ret; ret = __sync_val_compare_and_swap_1(vp1, v1, v1); }
185        { short ret; ret = __sync_val_compare_and_swap(vp2, v2, v2); }
186        { short ret; ret = __sync_val_compare_and_swap_2(vp2, v2, v2); }
187        { int ret; ret = __sync_val_compare_and_swap(vp4, v4, v4); }
188        { int ret; ret = __sync_val_compare_and_swap_4(vp4, v4, v4); }
189        { long long int ret; ret = __sync_val_compare_and_swap(vp8, v8, v8); }
190        { long long int ret; ret = __sync_val_compare_and_swap_8(vp8, v8, v8); }
191        #if defined(__SIZEOF_INT128__)
192        { __int128 ret; ret = __sync_val_compare_and_swap(vp16, v16, v16); }
193        { __int128 ret; ret = __sync_val_compare_and_swap_16(vp16, v16,v16); }
194        #endif
195
196        { char ret; ret = __sync_lock_test_and_set(vp1, v1); }
197        { char ret; ret = __sync_lock_test_and_set_1(vp1, v1); }
198        { short ret; ret = __sync_lock_test_and_set(vp2, v2); }
199        { short ret; ret = __sync_lock_test_and_set_2(vp2, v2); }
200        { int ret; ret = __sync_lock_test_and_set(vp4, v4); }
201        { int ret; ret = __sync_lock_test_and_set_4(vp4, v4); }
202        { long long int ret; ret = __sync_lock_test_and_set(vp8, v8); }
203        { long long int ret; ret = __sync_lock_test_and_set_8(vp8, v8); }
204        #if defined(__SIZEOF_INT128__)
205        { __int128 ret; ret = __sync_lock_test_and_set(vp16, v16); }
206        { __int128 ret; ret = __sync_lock_test_and_set_16(vp16, v16); }
207        #endif
208
209        { __sync_lock_release(vp1); }
210        { __sync_lock_release_1(vp1); }
211        { __sync_lock_release(vp2); }
212        { __sync_lock_release_2(vp2); }
213        { __sync_lock_release(vp4); }
214        { __sync_lock_release_4(vp4); }
215        { __sync_lock_release(vp8); }
216        { __sync_lock_release_8(vp8); }
217        #if defined(__SIZEOF_INT128__)
218        { __sync_lock_release(vp16); }
219        { __sync_lock_release_16(vp16); }
220        #endif
221
222        { __sync_synchronize(); }
223
224
225
226
227        { _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
228        { _Bool ret; ret = __atomic_test_and_set(vp1, v1); }
229        { __atomic_clear(vpB, vB); }
230        { __atomic_clear(vp1, v1); }
231
232        { char ret; ret = __atomic_exchange_n(vp1, &v1, __ATOMIC_SEQ_CST); }
233        { char ret; ret = __atomic_exchange_1(vp1, v1, __ATOMIC_SEQ_CST); }
234        { char ret; __atomic_exchange(vp1, &v1, &ret, __ATOMIC_SEQ_CST); }
235        { short ret; ret = __atomic_exchange_n(vp2, &v2, __ATOMIC_SEQ_CST); }
236        { short ret; ret = __atomic_exchange_2(vp2, v2, __ATOMIC_SEQ_CST); }
237        { short ret; __atomic_exchange(vp2, &v2, &ret, __ATOMIC_SEQ_CST); }
238        { int ret; ret = __atomic_exchange_n(vp4, &v4, __ATOMIC_SEQ_CST); }
239        { int ret; ret = __atomic_exchange_4(vp4, v4, __ATOMIC_SEQ_CST); }
240        { int ret; __atomic_exchange(vp4, &v4, &ret, __ATOMIC_SEQ_CST); }
241        { long long int ret; ret = __atomic_exchange_n(vp8, &v8, __ATOMIC_SEQ_CST); }
242        { long long int ret; ret = __atomic_exchange_8(vp8, v8, __ATOMIC_SEQ_CST); }
243        { long long int ret; __atomic_exchange(vp8, &v8, &ret, __ATOMIC_SEQ_CST); }
244        #if defined(__SIZEOF_INT128__)
245        { __int128 ret; ret = __atomic_exchange_n(vp16, &v16, __ATOMIC_SEQ_CST); }
246        { __int128 ret; ret = __atomic_exchange_16(vp16, v16, __ATOMIC_SEQ_CST); }
247        { __int128 ret; __atomic_exchange(vp16, &v16, &ret, __ATOMIC_SEQ_CST); }
248        #endif
249
250        { char ret; ret = __atomic_load_n(vp1, __ATOMIC_SEQ_CST); }
251        { char ret; ret = __atomic_load_1(vp1, __ATOMIC_SEQ_CST); }
252        { char ret; __atomic_load(vp1, &ret, __ATOMIC_SEQ_CST); }
253        { short ret; ret = __atomic_load_n(vp2, __ATOMIC_SEQ_CST); }
254        { short ret; ret = __atomic_load_2(vp2, __ATOMIC_SEQ_CST); }
255        { short ret; __atomic_load(vp2, &ret, __ATOMIC_SEQ_CST); }
256        { int ret; ret = __atomic_load_n(vp4, __ATOMIC_SEQ_CST); }
257        { int ret; ret = __atomic_load_4(vp4, __ATOMIC_SEQ_CST); }
258        { int ret; __atomic_load(vp4, &ret, __ATOMIC_SEQ_CST); }
259        { long long int ret; ret = __atomic_load_n(vp8, __ATOMIC_SEQ_CST); }
260        { long long int ret; ret = __atomic_load_8(vp8, __ATOMIC_SEQ_CST); }
261        { long long int ret; __atomic_load(vp8, &ret, __ATOMIC_SEQ_CST); }
262        #if defined(__SIZEOF_INT128__)
263        { __int128 ret; ret = __atomic_load_n(vp16, __ATOMIC_SEQ_CST); }
264        { __int128 ret; ret = __atomic_load_16(vp16, __ATOMIC_SEQ_CST); }
265        { __int128 ret; __atomic_load(vp16, &ret, __ATOMIC_SEQ_CST); }
266        #endif
267
268        { _Bool ret; ret = __atomic_compare_exchange_n(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
269        { _Bool ret; ret = __atomic_compare_exchange_1(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
270        { _Bool ret; ret = __atomic_compare_exchange(vp1, rp1, &v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
271        { _Bool ret; ret = __atomic_compare_exchange_n(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
272        { _Bool ret; ret = __atomic_compare_exchange_2(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
273        { _Bool ret; ret = __atomic_compare_exchange(vp2, rp2, &v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
274        { _Bool ret; ret = __atomic_compare_exchange_n(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
275        { _Bool ret; ret = __atomic_compare_exchange_4(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
276        { _Bool ret; ret = __atomic_compare_exchange(vp4, rp4, &v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
277        { _Bool ret; ret = __atomic_compare_exchange_n(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
278        { _Bool ret; ret = __atomic_compare_exchange_8(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
279        { _Bool ret; ret = __atomic_compare_exchange(vp8, rp8, &v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
280        #if defined(__SIZEOF_INT128__)
281        { _Bool ret; ret = __atomic_compare_exchange_n(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
282        { _Bool ret; ret = __atomic_compare_exchange_16(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
283        { _Bool ret; ret = __atomic_compare_exchange(vp16, rp16, &v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
284        #endif
285
286        { __atomic_store_n(vp1, v1, __ATOMIC_SEQ_CST); }
287        { __atomic_store_1(vp1, v1, __ATOMIC_SEQ_CST); }
288        { __atomic_store(vp1, &v1, __ATOMIC_SEQ_CST); }
289        { __atomic_store_n(vp2, v2, __ATOMIC_SEQ_CST); }
290        { __atomic_store_2(vp2, v2, __ATOMIC_SEQ_CST); }
291        { __atomic_store(vp2, &v2, __ATOMIC_SEQ_CST); }
292        { __atomic_store_n(vp4, v4, __ATOMIC_SEQ_CST); }
293        { __atomic_store_4(vp4, v4, __ATOMIC_SEQ_CST); }
294        { __atomic_store(vp4, &v4, __ATOMIC_SEQ_CST); }
295        { __atomic_store_n(vp8, v8, __ATOMIC_SEQ_CST); }
296        { __atomic_store_8(vp8, v8, __ATOMIC_SEQ_CST); }
297        { __atomic_store(vp8, &v8, __ATOMIC_SEQ_CST); }
298        #if defined(__SIZEOF_INT128__)
299        { __atomic_store_n(vp16, v16, __ATOMIC_SEQ_CST); }
300        { __atomic_store_16(vp16, v16, __ATOMIC_SEQ_CST); }
301        { __atomic_store(vp16, &v16, __ATOMIC_SEQ_CST); }
302        #endif
303
304        { char ret; ret = __atomic_add_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
305        { char ret; ret = __atomic_add_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
306        { short ret; ret = __atomic_add_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
307        { short ret; ret = __atomic_add_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
308        { int ret; ret = __atomic_add_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
309        { int ret; ret = __atomic_add_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
310        { long long int ret; ret = __atomic_add_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
311        { long long int ret; ret = __atomic_add_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
312        #if defined(__SIZEOF_INT128__)
313        { __int128 ret; ret = __atomic_add_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
314        { __int128 ret; ret = __atomic_add_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
315        #endif
316
317        { char ret; ret = __atomic_sub_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
318        { char ret; ret = __atomic_sub_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
319        { short ret; ret = __atomic_sub_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
320        { short ret; ret = __atomic_sub_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
321        { int ret; ret = __atomic_sub_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
322        { int ret; ret = __atomic_sub_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
323        { long long int ret; ret = __atomic_sub_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
324        { long long int ret; ret = __atomic_sub_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
325        #if defined(__SIZEOF_INT128__)
326        { __int128 ret; ret = __atomic_sub_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
327        { __int128 ret; ret = __atomic_sub_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
328        #endif
329
330        { char ret; ret = __atomic_and_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
331        { char ret; ret = __atomic_and_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
332        { short ret; ret = __atomic_and_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
333        { short ret; ret = __atomic_and_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
334        { int ret; ret = __atomic_and_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
335        { int ret; ret = __atomic_and_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
336        { long long int ret; ret = __atomic_and_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
337        { long long int ret; ret = __atomic_and_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
338        #if defined(__SIZEOF_INT128__)
339        { __int128 ret; ret = __atomic_and_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
340        { __int128 ret; ret = __atomic_and_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
341        #endif
342
343        { char ret; ret = __atomic_nand_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
344        { char ret; ret = __atomic_nand_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
345        { short ret; ret = __atomic_nand_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
346        { short ret; ret = __atomic_nand_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
347        { int ret; ret = __atomic_nand_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
348        { int ret; ret = __atomic_nand_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
349        { long long int ret; ret = __atomic_nand_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
350        { long long int ret; ret = __atomic_nand_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
351        #if defined(__SIZEOF_INT128__)
352        { __int128 ret; ret = __atomic_nand_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
353        { __int128 ret; ret = __atomic_nand_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
354        #endif
355
356        { char ret; ret = __atomic_xor_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
357        { char ret; ret = __atomic_xor_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
358        { short ret; ret = __atomic_xor_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
359        { short ret; ret = __atomic_xor_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
360        { int ret; ret = __atomic_xor_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
361        { int ret; ret = __atomic_xor_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
362        { long long int ret; ret = __atomic_xor_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
363        { long long int ret; ret = __atomic_xor_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
364        #if defined(__SIZEOF_INT128__)
365        { __int128 ret; ret = __atomic_xor_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
366        { __int128 ret; ret = __atomic_xor_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
367        #endif
368
369        { char ret; ret = __atomic_or_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
370        { char ret; ret = __atomic_or_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
371        { short ret; ret = __atomic_or_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
372        { short ret; ret = __atomic_or_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
373        { int ret; ret = __atomic_or_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
374        { int ret; ret = __atomic_or_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
375        { long long int ret; ret = __atomic_or_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
376        { long long int ret; ret = __atomic_or_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
377        #if defined(__SIZEOF_INT128__)
378        { __int128 ret; ret = __atomic_or_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
379        { __int128 ret; ret = __atomic_or_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
380        #endif
381
382        { char ret; ret = __atomic_fetch_add(vp1, v1, __ATOMIC_SEQ_CST); }
383        { char ret; ret = __atomic_fetch_add_1(vp1, v1, __ATOMIC_SEQ_CST); }
384        { short ret; ret = __atomic_fetch_add(vp2, v2, __ATOMIC_SEQ_CST); }
385        { short ret; ret = __atomic_fetch_add_2(vp2, v2, __ATOMIC_SEQ_CST); }
386        { int ret; ret = __atomic_fetch_add(vp4, v4, __ATOMIC_SEQ_CST); }
387        { int ret; ret = __atomic_fetch_add_4(vp4, v4, __ATOMIC_SEQ_CST); }
388        { long long int ret; ret = __atomic_fetch_add(vp8, v8, __ATOMIC_SEQ_CST); }
389        { long long int ret; ret = __atomic_fetch_add_8(vp8, v8, __ATOMIC_SEQ_CST); }
390        #if defined(__SIZEOF_INT128__)
391        { __int128 ret; ret = __atomic_fetch_add(vp16, v16, __ATOMIC_SEQ_CST); }
392        { __int128 ret; ret = __atomic_fetch_add_16(vp16, v16, __ATOMIC_SEQ_CST); }
393        #endif
394
395        { char ret; ret = __atomic_fetch_sub(vp1, v1, __ATOMIC_SEQ_CST); }
396        { char ret; ret = __atomic_fetch_sub_1(vp1, v1, __ATOMIC_SEQ_CST); }
397        { short ret; ret = __atomic_fetch_sub(vp2, v2, __ATOMIC_SEQ_CST); }
398        { short ret; ret = __atomic_fetch_sub_2(vp2, v2, __ATOMIC_SEQ_CST); }
399        { int ret; ret = __atomic_fetch_sub(vp4, v4, __ATOMIC_SEQ_CST); }
400        { int ret; ret = __atomic_fetch_sub_4(vp4, v4, __ATOMIC_SEQ_CST); }
401        { long long int ret; ret = __atomic_fetch_sub(vp8, v8, __ATOMIC_SEQ_CST); }
402        { long long int ret; ret = __atomic_fetch_sub_8(vp8, v8, __ATOMIC_SEQ_CST); }
403        #if defined(__SIZEOF_INT128__)
404        { __int128 ret; ret = __atomic_fetch_sub(vp16, v16, __ATOMIC_SEQ_CST); }
405        { __int128 ret; ret = __atomic_fetch_sub_16(vp16, v16, __ATOMIC_SEQ_CST); }
406        #endif
407
408        { char ret; ret = __atomic_fetch_and(vp1, v1, __ATOMIC_SEQ_CST); }
409        { char ret; ret = __atomic_fetch_and_1(vp1, v1, __ATOMIC_SEQ_CST); }
410        { short ret; ret = __atomic_fetch_and(vp2, v2, __ATOMIC_SEQ_CST); }
411        { short ret; ret = __atomic_fetch_and_2(vp2, v2, __ATOMIC_SEQ_CST); }
412        { int ret; ret = __atomic_fetch_and(vp4, v4, __ATOMIC_SEQ_CST); }
413        { int ret; ret = __atomic_fetch_and_4(vp4, v4, __ATOMIC_SEQ_CST); }
414        { long long int ret; ret = __atomic_fetch_and(vp8, v8, __ATOMIC_SEQ_CST); }
415        { long long int ret; ret = __atomic_fetch_and_8(vp8, v8, __ATOMIC_SEQ_CST); }
416        #if defined(__SIZEOF_INT128__)
417        { __int128 ret; ret = __atomic_fetch_and(vp16, v16, __ATOMIC_SEQ_CST); }
418        { __int128 ret; ret = __atomic_fetch_and_16(vp16, v16, __ATOMIC_SEQ_CST); }
419        #endif
420
421        { char ret; ret = __atomic_fetch_nand(vp1, v1, __ATOMIC_SEQ_CST); }
422        { char ret; ret = __atomic_fetch_nand_1(vp1, v1, __ATOMIC_SEQ_CST); }
423        { short ret; ret = __atomic_fetch_nand(vp2, v2, __ATOMIC_SEQ_CST); }
424        { short ret; ret = __atomic_fetch_nand_2(vp2, v2, __ATOMIC_SEQ_CST); }
425        { int ret; ret = __atomic_fetch_nand(vp4, v4, __ATOMIC_SEQ_CST); }
426        { int ret; ret = __atomic_fetch_nand_4(vp4, v4, __ATOMIC_SEQ_CST); }
427        { long long int ret; ret = __atomic_fetch_nand(vp8, v8, __ATOMIC_SEQ_CST); }
428        { long long int ret; ret = __atomic_fetch_nand_8(vp8, v8, __ATOMIC_SEQ_CST); }
429        #if defined(__SIZEOF_INT128__)
430        { __int128 ret; ret = __atomic_fetch_nand(vp16, v16, __ATOMIC_SEQ_CST); }
431        { __int128 ret; ret = __atomic_fetch_nand_16(vp16, v16, __ATOMIC_SEQ_CST); }
432        #endif
433
434        { char ret; ret = __atomic_fetch_xor(vp1, v1, __ATOMIC_SEQ_CST); }
435        { char ret; ret = __atomic_fetch_xor_1(vp1, v1, __ATOMIC_SEQ_CST); }
436        { short ret; ret = __atomic_fetch_xor(vp2, v2, __ATOMIC_SEQ_CST); }
437        { short ret; ret = __atomic_fetch_xor_2(vp2, v2, __ATOMIC_SEQ_CST); }
438        { int ret; ret = __atomic_fetch_xor(vp4, v4, __ATOMIC_SEQ_CST); }
439        { int ret; ret = __atomic_fetch_xor_4(vp4, v4, __ATOMIC_SEQ_CST); }
440        { long long int ret; ret = __atomic_fetch_xor(vp8, v8, __ATOMIC_SEQ_CST); }
441        { long long int ret; ret = __atomic_fetch_xor_8(vp8, v8, __ATOMIC_SEQ_CST); }
442        #if defined(__SIZEOF_INT128__)
443        { __int128 ret; ret = __atomic_fetch_xor(vp16, v16, __ATOMIC_SEQ_CST); }
444        { __int128 ret; ret = __atomic_fetch_xor_16(vp16, v16, __ATOMIC_SEQ_CST); }
445        #endif
446
447        { char ret; ret = __atomic_fetch_or(vp1, v1, __ATOMIC_SEQ_CST); }
448        { char ret; ret = __atomic_fetch_or_1(vp1, v1, __ATOMIC_SEQ_CST); }
449        { short ret; ret = __atomic_fetch_or(vp2, v2, __ATOMIC_SEQ_CST); }
450        { short ret; ret = __atomic_fetch_or_2(vp2, v2, __ATOMIC_SEQ_CST); }
451        { int ret; ret = __atomic_fetch_or(vp4, v4, __ATOMIC_SEQ_CST); }
452        { int ret; ret = __atomic_fetch_or_4(vp4, v4, __ATOMIC_SEQ_CST); }
453        { long long int ret; ret = __atomic_fetch_or(vp8, v8, __ATOMIC_SEQ_CST); }
454        { long long int ret; ret = __atomic_fetch_or_8(vp8, v8, __ATOMIC_SEQ_CST); }
455        #if defined(__SIZEOF_INT128__)
456        { __int128 ret; ret = __atomic_fetch_or(vp16, v16, __ATOMIC_SEQ_CST); }
457        { __int128 ret; ret = __atomic_fetch_or_16(vp16, v16, __ATOMIC_SEQ_CST); }
458        #endif
459
460        { _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vp4); }
461        { _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vp4); }
462        { __atomic_thread_fence(__ATOMIC_SEQ_CST); }
463        { __atomic_signal_fence(__ATOMIC_SEQ_CST); }
464}
465
466int main() {
467        return 0;
468}
Note: See TracBrowser for help on using the repository browser.