source: src/tests/builtins/sync.c@ 242f705

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr no_list persistent-indexer pthread-emulation qualifiedEnum
Last change on this file since 242f705 was 1f81d61, checked in by Thierry Delisle <tdelisle@…>, 7 years ago

Fixed several build failures for 32-bit
  • Property mode set to 100644
File size: 23.7 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
[13073be]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); }
[1f81d61]22 #if defined(__SIZEOF_INT128__)
[13073be]23 { __int128 ret; ret = __sync_fetch_and_add(vp16, v16); }
24 { __int128 ret; ret = __sync_fetch_and_add_16(vp16, v16); }
[1f81d61]25 #endif
[13073be]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); }
[1f81d61]35 #if defined(__SIZEOF_INT128__)
[13073be]36 { __int128 ret; ret = __sync_fetch_and_sub(vp16, v16); }
37 { __int128 ret; ret = __sync_fetch_and_sub_16(vp16, v16); }
[1f81d61]38 #endif
[13073be]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); }
[1f81d61]48 #if defined(__SIZEOF_INT128__)
[13073be]49 { __int128 ret; ret = __sync_fetch_and_or(vp16, v16); }
50 { __int128 ret; ret = __sync_fetch_and_or_16(vp16, v16); }
[1f81d61]51 #endif
[13073be]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); }
[1f81d61]61 #if defined(__SIZEOF_INT128__)
[13073be]62 { __int128 ret; ret = __sync_fetch_and_and(vp16, v16); }
63 { __int128 ret; ret = __sync_fetch_and_and_16(vp16, v16); }
[1f81d61]64 #endif
[13073be]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); }
[1f81d61]74 #if defined(__SIZEOF_INT128__)
[13073be]75 { __int128 ret; ret = __sync_fetch_and_xor(vp16, v16); }
76 { __int128 ret; ret = __sync_fetch_and_xor_16(vp16, v16); }
[1f81d61]77 #endif
[13073be]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); }
[1f81d61]87 #if defined(__SIZEOF_INT128__)
[13073be]88 { __int128 ret; ret = __sync_fetch_and_nand(vp16, v16); }
89 { __int128 ret; ret = __sync_fetch_and_nand_16(vp16, v16); }
[1f81d61]90 #endif
[13073be]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); }
[1f81d61]100 #if defined(__SIZEOF_INT128__)
[13073be]101 { __int128 ret; ret = __sync_add_and_fetch(vp16, v16); }
102 { __int128 ret; ret = __sync_add_and_fetch_16(vp16, v16); }
[1f81d61]103 #endif
[13073be]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); }
[1f81d61]113 #if defined(__SIZEOF_INT128__)
[13073be]114 { __int128 ret; ret = __sync_sub_and_fetch(vp16, v16); }
115 { __int128 ret; ret = __sync_sub_and_fetch_16(vp16, v16); }
[1f81d61]116 #endif
[13073be]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); }
[1f81d61]126 #if defined(__SIZEOF_INT128__)
[13073be]127 { __int128 ret; ret = __sync_or_and_fetch(vp16, v16); }
128 { __int128 ret; ret = __sync_or_and_fetch_16(vp16, v16); }
[1f81d61]129 #endif
[13073be]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); }
[1f81d61]139 #if defined(__SIZEOF_INT128__)
[13073be]140 { __int128 ret; ret = __sync_and_and_fetch(vp16, v16); }
141 { __int128 ret; ret = __sync_and_and_fetch_16(vp16, v16); }
[1f81d61]142 #endif
[13073be]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); }
[1f81d61]152 #if defined(__SIZEOF_INT128__)
[13073be]153 { __int128 ret; ret = __sync_xor_and_fetch(vp16, v16); }
154 { __int128 ret; ret = __sync_xor_and_fetch_16(vp16, v16); }
[1f81d61]155 #endif
[13073be]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); }
[1f81d61]165 #if defined(__SIZEOF_INT128__)
[13073be]166 { __int128 ret; ret = __sync_nand_and_fetch(vp16, v16); }
167 { __int128 ret; ret = __sync_nand_and_fetch_16(vp16, v16); }
[1f81d61]168 #endif
[13073be]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); }
[1f81d61]178 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]181 #endif
[13073be]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); }
[1f81d61]191 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]194 #endif
[13073be]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); }
[1f81d61]204 #if defined(__SIZEOF_INT128__)
[13073be]205 { __int128 ret; ret = __sync_lock_test_and_set(vp16, v16); }
206 { __int128 ret; ret = __sync_lock_test_and_set_16(vp16, v16); }
[1f81d61]207 #endif
[13073be]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); }
[1f81d61]217 #if defined(__SIZEOF_INT128__)
[13073be]218 { __sync_lock_release(vp16); }
219 { __sync_lock_release_16(vp16); }
[1f81d61]220 #endif
[13073be]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); }
[1f81d61]244 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]248 #endif
[13073be]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); }
[1f81d61]262 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]266 #endif
[13073be]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); }
[1f81d61]280 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]284 #endif
[13073be]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); }
[1f81d61]298 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]302 #endif
[13073be]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); }
[1f81d61]312 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]315 #endif
[13073be]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); }
[1f81d61]325 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]328 #endif
[13073be]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); }
[1f81d61]338 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]341 #endif
[13073be]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); }
[1f81d61]351 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]354 #endif
[13073be]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); }
[1f81d61]364 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]367 #endif
[13073be]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); }
[1f81d61]377 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]380 #endif
[13073be]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); }
[1f81d61]390 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]393 #endif
[13073be]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); }
[1f81d61]403 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]406 #endif
[13073be]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); }
[1f81d61]416 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]419 #endif
[13073be]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); }
[1f81d61]429 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]432 #endif
[13073be]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); }
[1f81d61]442 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]445 #endif
[13073be]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); }
[1f81d61]455 #if defined(__SIZEOF_INT128__)
[13073be]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); }
[1f81d61]458 #endif
[13073be]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.