source: tests/builtins/sync.cfa@ 6a25b8f

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 6a25b8f was c64e979, checked in by Thierry Delisle <tdelisle@…>, 7 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.