Context Navigation

sync.cfa @ d8c4fab

ADTast-experimentalenumpthread-emulationqualifiedEnum

Last change on this file since d8c4fab was 53692b3, checked in by Peter A. Buhr <pabuhr@…>, 3 years ago
second attempt to fix compile-only pragma message that gcc-10/11 quote
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	#endif
69
70	{ char ret; ret = __sync_add_and_fetch(vpc, vc); }
71	{ short ret; ret = __sync_add_and_fetch(vps, vs); }
72	{ int ret; ret = __sync_add_and_fetch(vpi, vi); }
73	{ long int ret; ret = __sync_add_and_fetch(vpl, vl); }
74	{ long long int ret; ret = __sync_add_and_fetch(vpll, vll); }
75	#if defined(__SIZEOF_INT128__)
76	{ __int128 ret; ret = __sync_add_and_fetch(vplll, vlll); }
77	#endif
78
79	{ char ret; ret = __sync_sub_and_fetch(vpc, vc); }
80	{ short ret; ret = __sync_sub_and_fetch(vps, vs); }
81	{ int ret; ret = __sync_sub_and_fetch(vpi, vi); }
82	{ long int ret; ret = __sync_sub_and_fetch(vpl, vl); }
83	{ long long int ret; ret = __sync_sub_and_fetch(vpll, vll); }
84	#if defined(__SIZEOF_INT128__)
85	{ __int128 ret; ret = __sync_sub_and_fetch(vplll, vlll); }
86	#endif
87
88	{ char ret; ret = __sync_or_and_fetch(vpc, vc); }
89	{ short ret; ret = __sync_or_and_fetch(vps, vs); }
90	{ int ret; ret = __sync_or_and_fetch(vpi, vi); }
91	{ long int ret; ret = __sync_or_and_fetch(vpl, vl); }
92	{ long long int ret; ret = __sync_or_and_fetch(vpll, vll); }
93	#if defined(__SIZEOF_INT128__)
94	{ __int128 ret; ret = __sync_or_and_fetch(vplll, vlll); }
95	#endif
96
97	{ char ret; ret = __sync_and_and_fetch(vpc, vc); }
98	{ short ret; ret = __sync_and_and_fetch(vps, vs); }
99	{ int ret; ret = __sync_and_and_fetch(vpi, vi); }
100	{ long int ret; ret = __sync_and_and_fetch(vpl, vl); }
101	{ long long int ret; ret = __sync_and_and_fetch(vpll, vll); }
102	#if defined(__SIZEOF_INT128__)
103	{ __int128 ret; ret = __sync_and_and_fetch(vplll, vlll); }
104	#endif
105
106	{ char ret; ret = __sync_xor_and_fetch(vpc, vc); }
107	{ short ret; ret = __sync_xor_and_fetch(vps, vs); }
108	{ int ret; ret = __sync_xor_and_fetch(vpi, vi); }
109	{ long int ret; ret = __sync_xor_and_fetch(vpl, vl); }
110	{ long long int ret; ret = __sync_xor_and_fetch(vpll, vll); }
111	#if defined(__SIZEOF_INT128__)
112	{ __int128 ret; ret = __sync_xor_and_fetch(vplll, vlll); }
113	#endif
114
115	{ char ret; ret = __sync_nand_and_fetch(vpc, vc); }
116	{ short ret; ret = __sync_nand_and_fetch(vps, vs); }
117	{ int ret; ret = __sync_nand_and_fetch(vpi, vi); }
118	{ long int ret; ret = __sync_nand_and_fetch(vpl, vl); }
119	{ long long int ret; ret = __sync_nand_and_fetch(vpll, vll); }
120	#if defined(__SIZEOF_INT128__)
121	{ __int128 ret; ret = __sync_nand_and_fetch(vplll, vlll); }
122	#endif
123
124	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpc, vc, vc); }
125	{ _Bool ret; ret = __sync_bool_compare_and_swap(vps, vs, vs); }
126	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpi, vi, vi); }
127	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpl, vl, vl); }
128	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpll, vll, vll); }
129	#if defined(__SIZEOF_INT128__)
130	{ _Bool ret; ret = __sync_bool_compare_and_swap(vplll, vlll, vlll); }
131	#endif
132	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpp, vp, vp); }
133
134	{ char ret; ret = __sync_val_compare_and_swap(vpc, vc, vc); }
135	{ short ret; ret = __sync_val_compare_and_swap(vps, vs, vs); }
136	{ int ret; ret = __sync_val_compare_and_swap(vpi, vi, vi); }
137	{ long int ret; ret = __sync_val_compare_and_swap(vpl, vl, vl); }
138	{ long long int ret; ret = __sync_val_compare_and_swap(vpll, vll, vll); }
139	#if defined(__SIZEOF_INT128__)
140	{ __int128 ret; ret = __sync_val_compare_and_swap(vplll, vlll, vlll); }
141	#endif
142	{ struct type * ret; ret = __sync_val_compare_and_swap(vpp, vp, vp); }
143
144
145	{ char ret; ret = __sync_lock_test_and_set(vpc, vc); }
146	{ short ret; ret = __sync_lock_test_and_set(vps, vs); }
147	{ int ret; ret = __sync_lock_test_and_set(vpi, vi); }
148	{ long int ret; ret = __sync_lock_test_and_set(vpl, vl); }
149	{ long long int ret; ret = __sync_lock_test_and_set(vpll, vll); }
150	#if defined(__SIZEOF_INT128__)
151	{ __int128 ret; ret = __sync_lock_test_and_set(vplll, vlll); }
152	#endif
153
154	{ __sync_lock_release(vpc); }
155	{ __sync_lock_release(vps); }
156	{ __sync_lock_release(vpi); }
157	{ __sync_lock_release(vpl); }
158	{ __sync_lock_release(vpll); }
159	#if defined(__SIZEOF_INT128__)
160	{ __sync_lock_release(vplll); }
161	#endif
162
163	{ __sync_synchronize(); }
164
165
166
167
168	{ _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
169	{ _Bool ret; ret = __atomic_test_and_set(vpc, vc); }
170	{ __atomic_clear(vpB, vB); }
171	{ __atomic_clear(vpc, vc); }
172
173	{ char ret; ret = __atomic_exchange_n(vpc, vc, __ATOMIC_SEQ_CST); }
174	{ char ret; __atomic_exchange(vpc, &vc, &ret, __ATOMIC_SEQ_CST); }
175	{ short ret; ret = __atomic_exchange_n(vps, vs, __ATOMIC_SEQ_CST); }
176	{ short ret; __atomic_exchange(vps, &vs, &ret, __ATOMIC_SEQ_CST); }
177	{ int ret; ret = __atomic_exchange_n(vpi, vi, __ATOMIC_SEQ_CST); }
178	{ int ret; __atomic_exchange(vpi, &vi, &ret, __ATOMIC_SEQ_CST); }
179	{ long int ret; ret = __atomic_exchange_n(vpl, vl, __ATOMIC_SEQ_CST); }
180	{ long int ret; __atomic_exchange(vpl, &vl, &ret, __ATOMIC_SEQ_CST); }
181	{ long long int ret; ret = __atomic_exchange_n(vpll, vll, __ATOMIC_SEQ_CST); }
182	{ long long int ret; __atomic_exchange(vpll, &vll, &ret, __ATOMIC_SEQ_CST); }
183	#if defined(__SIZEOF_INT128__)
184	{ __int128 ret; ret = __atomic_exchange_n(vplll, vlll, __ATOMIC_SEQ_CST); }
185	{ __int128 ret; __atomic_exchange(vplll, &vlll, &ret, __ATOMIC_SEQ_CST); }
186	#endif
187	{ struct type * ret; ret = __atomic_exchange_n(vpp, vp, __ATOMIC_SEQ_CST); }
188	{ struct type * ret; __atomic_exchange(vpp, &vp, &ret, __ATOMIC_SEQ_CST); }
189
190	{ char ret; ret = __atomic_load_n(vpc, __ATOMIC_SEQ_CST); }
191	{ char ret; __atomic_load(vpc, &ret, __ATOMIC_SEQ_CST); }
192	{ short ret; ret = __atomic_load_n(vps, __ATOMIC_SEQ_CST); }
193	{ short ret; __atomic_load(vps, &ret, __ATOMIC_SEQ_CST); }
194	{ int ret; ret = __atomic_load_n(vpi, __ATOMIC_SEQ_CST); }
195	{ int ret; __atomic_load(vpi, &ret, __ATOMIC_SEQ_CST); }
196	{ long int ret; ret = __atomic_load_n(vpl, __ATOMIC_SEQ_CST); }
197	{ long int ret; __atomic_load(vpl, &ret, __ATOMIC_SEQ_CST); }
198	{ long long int ret; ret = __atomic_load_n(vpll, __ATOMIC_SEQ_CST); }
199	{ long long int ret; __atomic_load(vpll, &ret, __ATOMIC_SEQ_CST); }
200	#if defined(__SIZEOF_INT128__)
201	{ __int128 ret; ret = __atomic_load_n(vplll, __ATOMIC_SEQ_CST); }
202	{ __int128 ret; __atomic_load(vplll, &ret, __ATOMIC_SEQ_CST); }
203	#endif
204	{ struct type * ret; ret = __atomic_load_n(vpp, __ATOMIC_SEQ_CST); }
205	{ struct type * ret; __atomic_load(vpp, &ret, __ATOMIC_SEQ_CST); }
206
207	{ _Bool ret; ret = __atomic_compare_exchange_n(vpc, rpc, vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
208	{ _Bool ret; ret = __atomic_compare_exchange(vpc, rpc, &vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
209	{ _Bool ret; ret = __atomic_compare_exchange_n(vps, rps, vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
210	{ _Bool ret; ret = __atomic_compare_exchange(vps, rps, &vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
211	{ _Bool ret; ret = __atomic_compare_exchange_n(vpi, rpi, vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
212	{ _Bool ret; ret = __atomic_compare_exchange(vpi, rpi, &vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
213	{ _Bool ret; ret = __atomic_compare_exchange_n(vpl, rpl, vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
214	{ _Bool ret; ret = __atomic_compare_exchange(vpl, rpl, &vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
215	{ _Bool ret; ret = __atomic_compare_exchange_n(vpll, rpll, vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
216	{ _Bool ret; ret = __atomic_compare_exchange(vpll, rpll, &vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
217	#if defined(__SIZEOF_INT128__)
218	{ _Bool ret; ret = __atomic_compare_exchange_n(vplll, rplll, vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
219	{ _Bool ret; ret = __atomic_compare_exchange(vplll, rplll, &vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
220	#endif
221	{ _Bool ret; ret = __atomic_compare_exchange_n(vpp, rpp, vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
222	{ _Bool ret; ret = __atomic_compare_exchange(vpp, rpp, &vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
223
224	{ __atomic_store_n(vpc, vc, __ATOMIC_SEQ_CST); }
225	{ __atomic_store(vpc, &vc, __ATOMIC_SEQ_CST); }
226	{ __atomic_store_n(vps, vs, __ATOMIC_SEQ_CST); }
227	{ __atomic_store(vps, &vs, __ATOMIC_SEQ_CST); }
228	{ __atomic_store_n(vpi, vi, __ATOMIC_SEQ_CST); }
229	{ __atomic_store(vpi, &vi, __ATOMIC_SEQ_CST); }
230	{ __atomic_store_n(vpl, vl, __ATOMIC_SEQ_CST); }
231	{ __atomic_store(vpl, &vl, __ATOMIC_SEQ_CST); }
232	{ __atomic_store_n(vpll, vll, __ATOMIC_SEQ_CST); }
233	{ __atomic_store(vpll, &vll, __ATOMIC_SEQ_CST); }
234	#if defined(__SIZEOF_INT128__)
235	{ __atomic_store_n(vplll, vlll, __ATOMIC_SEQ_CST); }
236	{ __atomic_store(vplll, &vlll, __ATOMIC_SEQ_CST); }
237	#endif
238	{ __atomic_store_n(vpp, vp, __ATOMIC_SEQ_CST); }
239	{ __atomic_store(vpp, &vp, __ATOMIC_SEQ_CST); }
240
241	{ char ret; ret = __atomic_add_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
242	{ short ret; ret = __atomic_add_fetch(vps, vs, __ATOMIC_SEQ_CST); }
243	{ int ret; ret = __atomic_add_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
244	{ long int ret; ret = __atomic_add_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
245	{ long long int ret; ret = __atomic_add_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
246	#if defined(__SIZEOF_INT128__)
247	{ __int128 ret; ret = __atomic_add_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
248	#endif
249
250	{ char ret; ret = __atomic_sub_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
251	{ short ret; ret = __atomic_sub_fetch(vps, vs, __ATOMIC_SEQ_CST); }
252	{ int ret; ret = __atomic_sub_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
253	{ long int ret; ret = __atomic_sub_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
254	{ long long int ret; ret = __atomic_sub_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
255	#if defined(__SIZEOF_INT128__)
256	{ __int128 ret; ret = __atomic_sub_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
257	#endif
258
259	{ char ret; ret = __atomic_and_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
260	{ short ret; ret = __atomic_and_fetch(vps, vs, __ATOMIC_SEQ_CST); }
261	{ int ret; ret = __atomic_and_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
262	{ long int ret; ret = __atomic_and_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
263	{ long long int ret; ret = __atomic_and_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
264	#if defined(__SIZEOF_INT128__)
265	{ __int128 ret; ret = __atomic_and_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
266	#endif
267
268	{ char ret; ret = __atomic_nand_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
269	{ short ret; ret = __atomic_nand_fetch(vps, vs, __ATOMIC_SEQ_CST); }
270	{ int ret; ret = __atomic_nand_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
271	{ long int ret; ret = __atomic_nand_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
272	{ long long int ret; ret = __atomic_nand_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
273	#if defined(__SIZEOF_INT128__)
274	{ __int128 ret; ret = __atomic_nand_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
275	#endif
276
277	{ char ret; ret = __atomic_xor_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
278	{ short ret; ret = __atomic_xor_fetch(vps, vs, __ATOMIC_SEQ_CST); }
279	{ int ret; ret = __atomic_xor_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
280	{ long int ret; ret = __atomic_xor_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
281	{ long long int ret; ret = __atomic_xor_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
282	#if defined(__SIZEOF_INT128__)
283	{ __int128 ret; ret = __atomic_xor_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
284	#endif
285
286	{ char ret; ret = __atomic_or_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
287	{ short ret; ret = __atomic_or_fetch(vps, vs, __ATOMIC_SEQ_CST); }
288	{ int ret; ret = __atomic_or_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
289	{ long int ret; ret = __atomic_or_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
290	{ long long int ret; ret = __atomic_or_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
291	#if defined(__SIZEOF_INT128__)
292	{ __int128 ret; ret = __atomic_or_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
293	#endif
294
295	{ char ret; ret = __atomic_fetch_add(vpc, vc, __ATOMIC_SEQ_CST); }
296	{ short ret; ret = __atomic_fetch_add(vps, vs, __ATOMIC_SEQ_CST); }
297	{ int ret; ret = __atomic_fetch_add(vpi, vi, __ATOMIC_SEQ_CST); }
298	{ long int ret; ret = __atomic_fetch_add(vpl, vl, __ATOMIC_SEQ_CST); }
299	{ long long int ret; ret = __atomic_fetch_add(vpll, vll, __ATOMIC_SEQ_CST); }
300	#if defined(__SIZEOF_INT128__)
301	{ __int128 ret; ret = __atomic_fetch_add(vplll, vlll, __ATOMIC_SEQ_CST); }
302	#endif
303
304	{ char ret; ret = __atomic_fetch_sub(vpc, vc, __ATOMIC_SEQ_CST); }
305	{ short ret; ret = __atomic_fetch_sub(vps, vs, __ATOMIC_SEQ_CST); }
306	{ int ret; ret = __atomic_fetch_sub(vpi, vi, __ATOMIC_SEQ_CST); }
307	{ long int ret; ret = __atomic_fetch_sub(vpl, vl, __ATOMIC_SEQ_CST); }
308	{ long long int ret; ret = __atomic_fetch_sub(vpll, vll, __ATOMIC_SEQ_CST); }
309	#if defined(__SIZEOF_INT128__)
310	{ __int128 ret; ret = __atomic_fetch_sub(vplll, vlll, __ATOMIC_SEQ_CST); }
311	#endif
312
313	{ char ret; ret = __atomic_fetch_and(vpc, vc, __ATOMIC_SEQ_CST); }
314	{ short ret; ret = __atomic_fetch_and(vps, vs, __ATOMIC_SEQ_CST); }
315	{ int ret; ret = __atomic_fetch_and(vpi, vi, __ATOMIC_SEQ_CST); }
316	{ long int ret; ret = __atomic_fetch_and(vpl, vl, __ATOMIC_SEQ_CST); }
317	{ long long int ret; ret = __atomic_fetch_and(vpll, vll, __ATOMIC_SEQ_CST); }
318	#if defined(__SIZEOF_INT128__)
319	{ __int128 ret; ret = __atomic_fetch_and(vplll, vlll, __ATOMIC_SEQ_CST); }
320	#endif
321
322	{ char ret; ret = __atomic_fetch_nand(vpc, vc, __ATOMIC_SEQ_CST); }
323	{ short ret; ret = __atomic_fetch_nand(vps, vs, __ATOMIC_SEQ_CST); }
324	{ int ret; ret = __atomic_fetch_nand(vpi, vi, __ATOMIC_SEQ_CST); }
325	{ long int ret; ret = __atomic_fetch_nand(vpl, vl, __ATOMIC_SEQ_CST); }
326	{ long long int ret; ret = __atomic_fetch_nand(vpll, vll, __ATOMIC_SEQ_CST); }
327	#if defined(__SIZEOF_INT128__)
328	{ __int128 ret; ret = __atomic_fetch_nand(vplll, vlll, __ATOMIC_SEQ_CST); }
329	#endif
330
331	{ char ret; ret = __atomic_fetch_xor(vpc, vc, __ATOMIC_SEQ_CST); }
332	{ short ret; ret = __atomic_fetch_xor(vps, vs, __ATOMIC_SEQ_CST); }
333	{ int ret; ret = __atomic_fetch_xor(vpi, vi, __ATOMIC_SEQ_CST); }
334	{ long int ret; ret = __atomic_fetch_xor(vpl, vl, __ATOMIC_SEQ_CST); }
335	{ long long int ret; ret = __atomic_fetch_xor(vpll, vll, __ATOMIC_SEQ_CST); }
336	#if defined(__SIZEOF_INT128__)
337	{ __int128 ret; ret = __atomic_fetch_xor(vplll, vlll, __ATOMIC_SEQ_CST); }
338	#endif
339
340	{ char ret; ret = __atomic_fetch_or(vpc, vc, __ATOMIC_SEQ_CST); }
341	{ short ret; ret = __atomic_fetch_or(vps, vs, __ATOMIC_SEQ_CST); }
342	{ int ret; ret = __atomic_fetch_or(vpi, vi, __ATOMIC_SEQ_CST); }
343	{ long int ret; ret = __atomic_fetch_or(vpl, vl, __ATOMIC_SEQ_CST); }
344	{ long long int ret; ret = __atomic_fetch_or(vpll, vll, __ATOMIC_SEQ_CST); }
345	#if defined(__SIZEOF_INT128__)
346	{ __int128 ret; ret = __atomic_fetch_or(vplll, vlll, __ATOMIC_SEQ_CST); }
347	#endif
348
349	{ _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vpi); }
350	{ _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vpi); }
351	{ __atomic_thread_fence(__ATOMIC_SEQ_CST); }
352	{ __atomic_signal_fence(__ATOMIC_SEQ_CST); }
353	}
354
355	int main() {
356	#pragma GCC warning "Compiled" // force non-empty .expect file, NO TABS!!!
357	}

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

Download in other formats:

Original Format