source: tests/builtins/sync.cfa@ def9d4e

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors 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 def9d4e was 107b01a, checked in by Thierry Delisle <tdelisle@…>, 7 years ago

Several changes to the makefiles

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