Context Navigation

sync.cfa@ f3811df

Visit:

Last change on this file since f3811df was 53692b3, checked in by Peter A. Buhr <pabuhr@…>, 4 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

Rev	Line
[13073be]	1	#include <stdbool.h>
	2	#include <stdint.h>
	3
	4	void foo() {
	5	volatile _Bool * vpB = 0; _Bool vB = 0;
[c701332a]	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;
[1f81d61]	11	#if defined(__SIZEOF_INT128__)
[c701332a]	12	volatile __int128 * vplll = 0; __int128 * rplll = 0; __int128 vlll = 0;
[1f81d61]	13	#endif
[c64e979]	14	struct type * volatile * vpp = 0; struct type ** rpp = 0; struct type * vp = 0;
[13073be]	15
[c701332a]	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); }
[1f81d61]	131	#endif
[c64e979]	132	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpp, vp, vp); }
[13073be]	133
[c701332a]	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); }
[1f81d61]	139	#if defined(__SIZEOF_INT128__)
[c701332a]	140	{ __int128 ret; ret = __sync_val_compare_and_swap(vplll, vlll, vlll); }
[1f81d61]	141	#endif
[c64e979]	142	{ struct type * ret; ret = __sync_val_compare_and_swap(vpp, vp, vp); }
	143
[13073be]	144
[c701332a]	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); }
[1f81d61]	150	#if defined(__SIZEOF_INT128__)
[c701332a]	151	{ __int128 ret; ret = __sync_lock_test_and_set(vplll, vlll); }
[1f81d61]	152	#endif
[13073be]	153
[c701332a]	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); }
[1f81d61]	159	#if defined(__SIZEOF_INT128__)
[c701332a]	160	{ __sync_lock_release(vplll); }
[1f81d61]	161	#endif
[13073be]	162
	163	{ __sync_synchronize(); }
	164
	165
	166
	167
	168	{ _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
[c701332a]	169	{ _Bool ret; ret = __atomic_test_and_set(vpc, vc); }
[13073be]	170	{ __atomic_clear(vpB, vB); }
[c701332a]	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); }
[1f81d61]	186	#endif
[c64e979]	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); }
[13073be]	189
[c701332a]	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); }
[1f81d61]	203	#endif
[c64e979]	204	{ struct type * ret; ret = __atomic_load_n(vpp, __ATOMIC_SEQ_CST); }
	205	{ struct type * ret; __atomic_load(vpp, &ret, __ATOMIC_SEQ_CST); }
[13073be]	206
[c701332a]	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); }
[1f81d61]	220	#endif
[c64e979]	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); }
[13073be]	223
[c701332a]	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); }
[1f81d61]	237	#endif
[c64e979]	238	{ __atomic_store_n(vpp, vp, __ATOMIC_SEQ_CST); }
	239	{ __atomic_store(vpp, &vp, __ATOMIC_SEQ_CST); }
[13073be]	240
[c701332a]	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); }
[13073be]	351	{ __atomic_thread_fence(__ATOMIC_SEQ_CST); }
	352	{ __atomic_signal_fence(__ATOMIC_SEQ_CST); }
	353	}
	354
	355	int main() {
[53692b3]	356	#pragma GCC warning "Compiled" // force non-empty .expect file, NO TABS!!!
[66812dd]	357	}

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

Download in other formats:

Original Format