source: tests/builtins/sync.cfa @ b60ed54

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since b60ed54 was c64e979, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

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