source: src/tests/builtins/sync.c @ 13073be

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerwith_gc
Last change on this file since 13073be was 13073be, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Fix atomic builtins in libcfa and prelude

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