Context Navigation

sync.cfa @ 66812dd

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since 66812dd was 66812dd, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago
convert tests to always print output (no empty .expect files)
Property mode set to `100644`
File size: 16.9 KB

Line
1	#include <stdbool.h>
2	#include <stdint.h>
3
4	void foo() {
5	volatile _Bool * vpB = 0; _Bool vB = 0;
6	volatile char * vpc = 0; char * rpc = 0; char vc = 0;
7	volatile short * vps = 0; short * rps = 0; short vs = 0;
8	volatile int * vpi = 0; int * rpi = 0; int vi = 0;
9	volatile long int * vpl = 0; long int * rpl = 0; long int vl = 0;
10	volatile long long int * vpll = 0; long long int * rpll = 0; long long int vll = 0;
11	#if defined(__SIZEOF_INT128__)
12	volatile __int128 * vplll = 0; __int128 * rplll = 0; __int128 vlll = 0;
13	#endif
14	struct type * volatile * vpp = 0; struct type ** rpp = 0; struct type * vp = 0;
15
16	{ char ret; ret = __sync_fetch_and_add(vpc, vc); }
17	{ short ret; ret = __sync_fetch_and_add(vps, vs); }
18	{ int ret; ret = __sync_fetch_and_add(vpi, vi); }
19	{ long int ret; ret = __sync_fetch_and_add(vpl, vl); }
20	{ long long int ret; ret = __sync_fetch_and_add(vpll, vll); }
21	#if defined(__SIZEOF_INT128__)
22	{ __int128 ret; ret = __sync_fetch_and_add(vplll, vlll); }
23	#endif
24
25	{ char ret; ret = __sync_fetch_and_sub(vpc, vc); }
26	{ short ret; ret = __sync_fetch_and_sub(vps, vs); }
27	{ int ret; ret = __sync_fetch_and_sub(vpi, vi); }
28	{ long int ret; ret = __sync_fetch_and_sub(vpl, vl); }
29	{ long long int ret; ret = __sync_fetch_and_sub(vpll, vll); }
30	#if defined(__SIZEOF_INT128__)
31	{ __int128 ret; ret = __sync_fetch_and_sub(vplll, vlll); }
32	#endif
33
34	{ char ret; ret = __sync_fetch_and_or(vpc, vc); }
35	{ short ret; ret = __sync_fetch_and_or(vps, vs); }
36	{ int ret; ret = __sync_fetch_and_or(vpi, vi); }
37	{ long int ret; ret = __sync_fetch_and_or(vpl, vl); }
38	{ long long int ret; ret = __sync_fetch_and_or(vpll, vll); }
39	#if defined(__SIZEOF_INT128__)
40	{ __int128 ret; ret = __sync_fetch_and_or(vplll, vlll); }
41	#endif
42
43	{ char ret; ret = __sync_fetch_and_and(vpc, vc); }
44	{ short ret; ret = __sync_fetch_and_and(vps, vs); }
45	{ int ret; ret = __sync_fetch_and_and(vpi, vi); }
46	{ long int ret; ret = __sync_fetch_and_and(vpl, vl); }
47	{ long long int ret; ret = __sync_fetch_and_and(vpll, vll); }
48	#if defined(__SIZEOF_INT128__)
49	{ __int128 ret; ret = __sync_fetch_and_and(vplll, vlll); }
50	#endif
51
52	{ char ret; ret = __sync_fetch_and_xor(vpc, vc); }
53	{ short ret; ret = __sync_fetch_and_xor(vps, vs); }
54	{ int ret; ret = __sync_fetch_and_xor(vpi, vi); }
55	{ long int ret; ret = __sync_fetch_and_xor(vpl, vl); }
56	{ long long int ret; ret = __sync_fetch_and_xor(vpll, vll); }
57	#if defined(__SIZEOF_INT128__)
58	{ __int128 ret; ret = __sync_fetch_and_xor(vplll, vlll); }
59	#endif
60
61	{ char ret; ret = __sync_fetch_and_nand(vpc, vc); }
62	{ short ret; ret = __sync_fetch_and_nand(vps, vs); }
63	{ int ret; ret = __sync_fetch_and_nand(vpi, vi); }
64	{ long int ret; ret = __sync_fetch_and_nand(vpl, vl); }
65	{ long long int ret; ret = __sync_fetch_and_nand(vpll, vll); }
66	#if defined(__SIZEOF_INT128__)
67	{ __int128 ret; ret = __sync_fetch_and_nand(vplll, vlll); }
68	{ __int128 ret; ret = __sync_fetch_and_nand_16(vplll, vlll); }
69	#endif
70
71	{ char ret; ret = __sync_add_and_fetch(vpc, vc); }
72	{ short ret; ret = __sync_add_and_fetch(vps, vs); }
73	{ int ret; ret = __sync_add_and_fetch(vpi, vi); }
74	{ long int ret; ret = __sync_add_and_fetch(vpl, vl); }
75	{ long long int ret; ret = __sync_add_and_fetch(vpll, vll); }
76	#if defined(__SIZEOF_INT128__)
77	{ __int128 ret; ret = __sync_add_and_fetch(vplll, vlll); }
78	#endif
79
80	{ char ret; ret = __sync_sub_and_fetch(vpc, vc); }
81	{ short ret; ret = __sync_sub_and_fetch(vps, vs); }
82	{ int ret; ret = __sync_sub_and_fetch(vpi, vi); }
83	{ long int ret; ret = __sync_sub_and_fetch(vpl, vl); }
84	{ long long int ret; ret = __sync_sub_and_fetch(vpll, vll); }
85	#if defined(__SIZEOF_INT128__)
86	{ __int128 ret; ret = __sync_sub_and_fetch(vplll, vlll); }
87	#endif
88
89	{ char ret; ret = __sync_or_and_fetch(vpc, vc); }
90	{ short ret; ret = __sync_or_and_fetch(vps, vs); }
91	{ int ret; ret = __sync_or_and_fetch(vpi, vi); }
92	{ long int ret; ret = __sync_or_and_fetch(vpl, vl); }
93	{ long long int ret; ret = __sync_or_and_fetch(vpll, vll); }
94	#if defined(__SIZEOF_INT128__)
95	{ __int128 ret; ret = __sync_or_and_fetch(vplll, vlll); }
96	#endif
97
98	{ char ret; ret = __sync_and_and_fetch(vpc, vc); }
99	{ short ret; ret = __sync_and_and_fetch(vps, vs); }
100	{ int ret; ret = __sync_and_and_fetch(vpi, vi); }
101	{ long int ret; ret = __sync_and_and_fetch(vpl, vl); }
102	{ long long int ret; ret = __sync_and_and_fetch(vpll, vll); }
103	#if defined(__SIZEOF_INT128__)
104	{ __int128 ret; ret = __sync_and_and_fetch(vplll, vlll); }
105	#endif
106
107	{ char ret; ret = __sync_xor_and_fetch(vpc, vc); }
108	{ short ret; ret = __sync_xor_and_fetch(vps, vs); }
109	{ int ret; ret = __sync_xor_and_fetch(vpi, vi); }
110	{ long int ret; ret = __sync_xor_and_fetch(vpl, vl); }
111	{ long long int ret; ret = __sync_xor_and_fetch(vpll, vll); }
112	#if defined(__SIZEOF_INT128__)
113	{ __int128 ret; ret = __sync_xor_and_fetch(vplll, vlll); }
114	#endif
115
116	{ char ret; ret = __sync_nand_and_fetch(vpc, vc); }
117	{ short ret; ret = __sync_nand_and_fetch(vps, vs); }
118	{ int ret; ret = __sync_nand_and_fetch(vpi, vi); }
119	{ long int ret; ret = __sync_nand_and_fetch(vpl, vl); }
120	{ long long int ret; ret = __sync_nand_and_fetch(vpll, vll); }
121	#if defined(__SIZEOF_INT128__)
122	{ __int128 ret; ret = __sync_nand_and_fetch(vplll, vlll); }
123	#endif
124
125	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpc, vc, vc); }
126	{ _Bool ret; ret = __sync_bool_compare_and_swap(vps, vs, vs); }
127	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpi, vi, vi); }
128	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpl, vl, vl); }
129	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpll, vll, vll); }
130	#if defined(__SIZEOF_INT128__)
131	{ _Bool ret; ret = __sync_bool_compare_and_swap(vplll, vlll, vlll); }
132	#endif
133	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpp, vp, vp); }
134
135	{ char ret; ret = __sync_val_compare_and_swap(vpc, vc, vc); }
136	{ short ret; ret = __sync_val_compare_and_swap(vps, vs, vs); }
137	{ int ret; ret = __sync_val_compare_and_swap(vpi, vi, vi); }
138	{ long int ret; ret = __sync_val_compare_and_swap(vpl, vl, vl); }
139	{ long long int ret; ret = __sync_val_compare_and_swap(vpll, vll, vll); }
140	#if defined(__SIZEOF_INT128__)
141	{ __int128 ret; ret = __sync_val_compare_and_swap(vplll, vlll, vlll); }
142	#endif
143	{ struct type * ret; ret = __sync_val_compare_and_swap(vpp, vp, vp); }
144
145
146	{ char ret; ret = __sync_lock_test_and_set(vpc, vc); }
147	{ short ret; ret = __sync_lock_test_and_set(vps, vs); }
148	{ int ret; ret = __sync_lock_test_and_set(vpi, vi); }
149	{ long int ret; ret = __sync_lock_test_and_set(vpl, vl); }
150	{ long long int ret; ret = __sync_lock_test_and_set(vpll, vll); }
151	#if defined(__SIZEOF_INT128__)
152	{ __int128 ret; ret = __sync_lock_test_and_set(vplll, vlll); }
153	#endif
154
155	{ __sync_lock_release(vpc); }
156	{ __sync_lock_release(vps); }
157	{ __sync_lock_release(vpi); }
158	{ __sync_lock_release(vpl); }
159	{ __sync_lock_release(vpll); }
160	#if defined(__SIZEOF_INT128__)
161	{ __sync_lock_release(vplll); }
162	#endif
163
164	{ __sync_synchronize(); }
165
166
167
168
169	{ _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
170	{ _Bool ret; ret = __atomic_test_and_set(vpc, vc); }
171	{ __atomic_clear(vpB, vB); }
172	{ __atomic_clear(vpc, vc); }
173
174	{ char ret; ret = __atomic_exchange_n(vpc, vc, __ATOMIC_SEQ_CST); }
175	{ char ret; __atomic_exchange(vpc, &vc, &ret, __ATOMIC_SEQ_CST); }
176	{ short ret; ret = __atomic_exchange_n(vps, vs, __ATOMIC_SEQ_CST); }
177	{ short ret; __atomic_exchange(vps, &vs, &ret, __ATOMIC_SEQ_CST); }
178	{ int ret; ret = __atomic_exchange_n(vpi, vi, __ATOMIC_SEQ_CST); }
179	{ int ret; __atomic_exchange(vpi, &vi, &ret, __ATOMIC_SEQ_CST); }
180	{ long int ret; ret = __atomic_exchange_n(vpl, vl, __ATOMIC_SEQ_CST); }
181	{ long int ret; __atomic_exchange(vpl, &vl, &ret, __ATOMIC_SEQ_CST); }
182	{ long long int ret; ret = __atomic_exchange_n(vpll, vll, __ATOMIC_SEQ_CST); }
183	{ long long int ret; __atomic_exchange(vpll, &vll, &ret, __ATOMIC_SEQ_CST); }
184	#if defined(__SIZEOF_INT128__)
185	{ __int128 ret; ret = __atomic_exchange_n(vplll, vlll, __ATOMIC_SEQ_CST); }
186	{ __int128 ret; __atomic_exchange(vplll, &vlll, &ret, __ATOMIC_SEQ_CST); }
187	#endif
188	{ struct type * ret; ret = __atomic_exchange_n(vpp, vp, __ATOMIC_SEQ_CST); }
189	{ struct type * ret; __atomic_exchange(vpp, &vp, &ret, __ATOMIC_SEQ_CST); }
190
191	{ char ret; ret = __atomic_load_n(vpc, __ATOMIC_SEQ_CST); }
192	{ char ret; __atomic_load(vpc, &ret, __ATOMIC_SEQ_CST); }
193	{ short ret; ret = __atomic_load_n(vps, __ATOMIC_SEQ_CST); }
194	{ short ret; __atomic_load(vps, &ret, __ATOMIC_SEQ_CST); }
195	{ int ret; ret = __atomic_load_n(vpi, __ATOMIC_SEQ_CST); }
196	{ int ret; __atomic_load(vpi, &ret, __ATOMIC_SEQ_CST); }
197	{ long int ret; ret = __atomic_load_n(vpl, __ATOMIC_SEQ_CST); }
198	{ long int ret; __atomic_load(vpl, &ret, __ATOMIC_SEQ_CST); }
199	{ long long int ret; ret = __atomic_load_n(vpll, __ATOMIC_SEQ_CST); }
200	{ long long int ret; __atomic_load(vpll, &ret, __ATOMIC_SEQ_CST); }
201	#if defined(__SIZEOF_INT128__)
202	{ __int128 ret; ret = __atomic_load_n(vplll, __ATOMIC_SEQ_CST); }
203	{ __int128 ret; __atomic_load(vplll, &ret, __ATOMIC_SEQ_CST); }
204	#endif
205	{ struct type * ret; ret = __atomic_load_n(vpp, __ATOMIC_SEQ_CST); }
206	{ struct type * ret; __atomic_load(vpp, &ret, __ATOMIC_SEQ_CST); }
207
208	{ _Bool ret; ret = __atomic_compare_exchange_n(vpc, rpc, vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
209	{ _Bool ret; ret = __atomic_compare_exchange(vpc, rpc, &vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
210	{ _Bool ret; ret = __atomic_compare_exchange_n(vps, rps, vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
211	{ _Bool ret; ret = __atomic_compare_exchange(vps, rps, &vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
212	{ _Bool ret; ret = __atomic_compare_exchange_n(vpi, rpi, vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
213	{ _Bool ret; ret = __atomic_compare_exchange(vpi, rpi, &vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
214	{ _Bool ret; ret = __atomic_compare_exchange_n(vpl, rpl, vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
215	{ _Bool ret; ret = __atomic_compare_exchange(vpl, rpl, &vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
216	{ _Bool ret; ret = __atomic_compare_exchange_n(vpll, rpll, vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
217	{ _Bool ret; ret = __atomic_compare_exchange(vpll, rpll, &vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
218	#if defined(__SIZEOF_INT128__)
219	{ _Bool ret; ret = __atomic_compare_exchange_n(vplll, rplll, vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
220	{ _Bool ret; ret = __atomic_compare_exchange(vplll, rplll, &vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
221	#endif
222	{ _Bool ret; ret = __atomic_compare_exchange_n(vpp, rpp, vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
223	{ _Bool ret; ret = __atomic_compare_exchange(vpp, rpp, &vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
224
225	{ __atomic_store_n(vpc, vc, __ATOMIC_SEQ_CST); }
226	{ __atomic_store(vpc, &vc, __ATOMIC_SEQ_CST); }
227	{ __atomic_store_n(vps, vs, __ATOMIC_SEQ_CST); }
228	{ __atomic_store(vps, &vs, __ATOMIC_SEQ_CST); }
229	{ __atomic_store_n(vpi, vi, __ATOMIC_SEQ_CST); }
230	{ __atomic_store(vpi, &vi, __ATOMIC_SEQ_CST); }
231	{ __atomic_store_n(vpl, vl, __ATOMIC_SEQ_CST); }
232	{ __atomic_store(vpl, &vl, __ATOMIC_SEQ_CST); }
233	{ __atomic_store_n(vpll, vll, __ATOMIC_SEQ_CST); }
234	{ __atomic_store(vpll, &vll, __ATOMIC_SEQ_CST); }
235	#if defined(__SIZEOF_INT128__)
236	{ __atomic_store_n(vplll, vlll, __ATOMIC_SEQ_CST); }
237	{ __atomic_store(vplll, &vlll, __ATOMIC_SEQ_CST); }
238	#endif
239	{ __atomic_store_n(vpp, vp, __ATOMIC_SEQ_CST); }
240	{ __atomic_store(vpp, &vp, __ATOMIC_SEQ_CST); }
241
242	{ char ret; ret = __atomic_add_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
243	{ short ret; ret = __atomic_add_fetch(vps, vs, __ATOMIC_SEQ_CST); }
244	{ int ret; ret = __atomic_add_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
245	{ long int ret; ret = __atomic_add_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
246	{ long long int ret; ret = __atomic_add_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
247	#if defined(__SIZEOF_INT128__)
248	{ __int128 ret; ret = __atomic_add_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
249	#endif
250
251	{ char ret; ret = __atomic_sub_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
252	{ short ret; ret = __atomic_sub_fetch(vps, vs, __ATOMIC_SEQ_CST); }
253	{ int ret; ret = __atomic_sub_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
254	{ long int ret; ret = __atomic_sub_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
255	{ long long int ret; ret = __atomic_sub_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
256	#if defined(__SIZEOF_INT128__)
257	{ __int128 ret; ret = __atomic_sub_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
258	#endif
259
260	{ char ret; ret = __atomic_and_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
261	{ short ret; ret = __atomic_and_fetch(vps, vs, __ATOMIC_SEQ_CST); }
262	{ int ret; ret = __atomic_and_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
263	{ long int ret; ret = __atomic_and_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
264	{ long long int ret; ret = __atomic_and_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
265	#if defined(__SIZEOF_INT128__)
266	{ __int128 ret; ret = __atomic_and_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
267	#endif
268
269	{ char ret; ret = __atomic_nand_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
270	{ short ret; ret = __atomic_nand_fetch(vps, vs, __ATOMIC_SEQ_CST); }
271	{ int ret; ret = __atomic_nand_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
272	{ long int ret; ret = __atomic_nand_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
273	{ long long int ret; ret = __atomic_nand_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
274	#if defined(__SIZEOF_INT128__)
275	{ __int128 ret; ret = __atomic_nand_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
276	#endif
277
278	{ char ret; ret = __atomic_xor_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
279	{ short ret; ret = __atomic_xor_fetch(vps, vs, __ATOMIC_SEQ_CST); }
280	{ int ret; ret = __atomic_xor_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
281	{ long int ret; ret = __atomic_xor_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
282	{ long long int ret; ret = __atomic_xor_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
283	#if defined(__SIZEOF_INT128__)
284	{ __int128 ret; ret = __atomic_xor_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
285	#endif
286
287	{ char ret; ret = __atomic_or_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
288	{ short ret; ret = __atomic_or_fetch(vps, vs, __ATOMIC_SEQ_CST); }
289	{ int ret; ret = __atomic_or_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
290	{ long int ret; ret = __atomic_or_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
291	{ long long int ret; ret = __atomic_or_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
292	#if defined(__SIZEOF_INT128__)
293	{ __int128 ret; ret = __atomic_or_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
294	#endif
295
296	{ char ret; ret = __atomic_fetch_add(vpc, vc, __ATOMIC_SEQ_CST); }
297	{ short ret; ret = __atomic_fetch_add(vps, vs, __ATOMIC_SEQ_CST); }
298	{ int ret; ret = __atomic_fetch_add(vpi, vi, __ATOMIC_SEQ_CST); }
299	{ long int ret; ret = __atomic_fetch_add(vpl, vl, __ATOMIC_SEQ_CST); }
300	{ long long int ret; ret = __atomic_fetch_add(vpll, vll, __ATOMIC_SEQ_CST); }
301	#if defined(__SIZEOF_INT128__)
302	{ __int128 ret; ret = __atomic_fetch_add(vplll, vlll, __ATOMIC_SEQ_CST); }
303	#endif
304
305	{ char ret; ret = __atomic_fetch_sub(vpc, vc, __ATOMIC_SEQ_CST); }
306	{ short ret; ret = __atomic_fetch_sub(vps, vs, __ATOMIC_SEQ_CST); }
307	{ int ret; ret = __atomic_fetch_sub(vpi, vi, __ATOMIC_SEQ_CST); }
308	{ long int ret; ret = __atomic_fetch_sub(vpl, vl, __ATOMIC_SEQ_CST); }
309	{ long long int ret; ret = __atomic_fetch_sub(vpll, vll, __ATOMIC_SEQ_CST); }
310	#if defined(__SIZEOF_INT128__)
311	{ __int128 ret; ret = __atomic_fetch_sub(vplll, vlll, __ATOMIC_SEQ_CST); }
312	#endif
313
314	{ char ret; ret = __atomic_fetch_and(vpc, vc, __ATOMIC_SEQ_CST); }
315	{ short ret; ret = __atomic_fetch_and(vps, vs, __ATOMIC_SEQ_CST); }
316	{ int ret; ret = __atomic_fetch_and(vpi, vi, __ATOMIC_SEQ_CST); }
317	{ long int ret; ret = __atomic_fetch_and(vpl, vl, __ATOMIC_SEQ_CST); }
318	{ long long int ret; ret = __atomic_fetch_and(vpll, vll, __ATOMIC_SEQ_CST); }
319	#if defined(__SIZEOF_INT128__)
320	{ __int128 ret; ret = __atomic_fetch_and(vplll, vlll, __ATOMIC_SEQ_CST); }
321	#endif
322
323	{ char ret; ret = __atomic_fetch_nand(vpc, vc, __ATOMIC_SEQ_CST); }
324	{ short ret; ret = __atomic_fetch_nand(vps, vs, __ATOMIC_SEQ_CST); }
325	{ int ret; ret = __atomic_fetch_nand(vpi, vi, __ATOMIC_SEQ_CST); }
326	{ long int ret; ret = __atomic_fetch_nand(vpl, vl, __ATOMIC_SEQ_CST); }
327	{ long long int ret; ret = __atomic_fetch_nand(vpll, vll, __ATOMIC_SEQ_CST); }
328	#if defined(__SIZEOF_INT128__)
329	{ __int128 ret; ret = __atomic_fetch_nand(vplll, vlll, __ATOMIC_SEQ_CST); }
330	#endif
331
332	{ char ret; ret = __atomic_fetch_xor(vpc, vc, __ATOMIC_SEQ_CST); }
333	{ short ret; ret = __atomic_fetch_xor(vps, vs, __ATOMIC_SEQ_CST); }
334	{ int ret; ret = __atomic_fetch_xor(vpi, vi, __ATOMIC_SEQ_CST); }
335	{ long int ret; ret = __atomic_fetch_xor(vpl, vl, __ATOMIC_SEQ_CST); }
336	{ long long int ret; ret = __atomic_fetch_xor(vpll, vll, __ATOMIC_SEQ_CST); }
337	#if defined(__SIZEOF_INT128__)
338	{ __int128 ret; ret = __atomic_fetch_xor(vplll, vlll, __ATOMIC_SEQ_CST); }
339	#endif
340
341	{ char ret; ret = __atomic_fetch_or(vpc, vc, __ATOMIC_SEQ_CST); }
342	{ short ret; ret = __atomic_fetch_or(vps, vs, __ATOMIC_SEQ_CST); }
343	{ int ret; ret = __atomic_fetch_or(vpi, vi, __ATOMIC_SEQ_CST); }
344	{ long int ret; ret = __atomic_fetch_or(vpl, vl, __ATOMIC_SEQ_CST); }
345	{ long long int ret; ret = __atomic_fetch_or(vpll, vll, __ATOMIC_SEQ_CST); }
346	#if defined(__SIZEOF_INT128__)
347	{ __int128 ret; ret = __atomic_fetch_or(vplll, vlll, __ATOMIC_SEQ_CST); }
348	#endif
349
350	{ _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vpi); }
351	{ _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vpi); }
352	{ __atomic_thread_fence(__ATOMIC_SEQ_CST); }
353	{ __atomic_signal_fence(__ATOMIC_SEQ_CST); }
354	}
355
356	int main() {
357	#pragma message( "Compiled" ) // force non-empty .expect file
358	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format