[thirdparty/gcc.git] / gcc / testsuite / gcc.dg / atomic-op-1.c

/* Test __atomic routines for existence and proper execution on 1 byte 
   values with each valid memory model.  */
/* { dg-do run } */
/* { dg-require-effective-target sync_char_short } */

/* Test the execution of the __atomic_*OP builtin routines for a char.  */

extern void abort(void);

char v, count, res;
const char init = ~0;

/* The fetch_op routines return the original value before the operation.  */

void
test_fetch_add ()
{
  v = 0;
  count = 1;

  if (__atomic_fetch_add (&v, count, __ATOMIC_RELAXED) != 0)
    abort ();

  if (__atomic_fetch_add (&v, 1, __ATOMIC_CONSUME) != 1) 
    abort ();

  if (__atomic_fetch_add (&v, count, __ATOMIC_ACQUIRE) != 2)
    abort ();

  if (__atomic_fetch_add (&v, 1, __ATOMIC_RELEASE) != 3) 
    abort ();

  if (__atomic_fetch_add (&v, count, __ATOMIC_ACQ_REL) != 4) 
    abort ();

  if (__atomic_fetch_add (&v, 1, __ATOMIC_SEQ_CST) != 5) 
    abort ();
}


void
test_fetch_sub()
{
  v = res = 20;
  count = 0;

  if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_RELAXED) !=  res--) 
    abort ();

  if (__atomic_fetch_sub (&v, 1, __ATOMIC_CONSUME) !=  res--) 
    abort ();

  if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_ACQUIRE) !=  res--) 
    abort ();

  if (__atomic_fetch_sub (&v, 1, __ATOMIC_RELEASE) !=  res--) 
    abort ();

  if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_ACQ_REL) !=  res--) 
    abort ();

  if (__atomic_fetch_sub (&v, 1, __ATOMIC_SEQ_CST) !=  res--) 
    abort ();
}

void
test_fetch_and ()
{
  v = init;

  if (__atomic_fetch_and (&v, 0, __ATOMIC_RELAXED) !=  init) 
    abort ();

  if (__atomic_fetch_and (&v, init, __ATOMIC_CONSUME) !=  0) 
    abort ();

  if (__atomic_fetch_and (&v, 0, __ATOMIC_ACQUIRE) !=  0)
    abort ();

  v = ~v;
  if (__atomic_fetch_and (&v, init, __ATOMIC_RELEASE) !=  init)
    abort ();

  if (__atomic_fetch_and (&v, 0, __ATOMIC_ACQ_REL) !=  init) 
    abort ();

  if (__atomic_fetch_and (&v, 0, __ATOMIC_SEQ_CST) !=  0) 
    abort ();
}

void
test_fetch_nand ()
{
  v = init;

  if (__atomic_fetch_nand (&v, 0, __ATOMIC_RELAXED) !=  init) 
    abort ();

  if (__atomic_fetch_nand (&v, init, __ATOMIC_CONSUME) !=  init) 
    abort ();

  if (__atomic_fetch_nand (&v, 0, __ATOMIC_ACQUIRE) !=  0 ) 
    abort ();

  if (__atomic_fetch_nand (&v, init, __ATOMIC_RELEASE) !=  init)
    abort ();

  if (__atomic_fetch_nand (&v, init, __ATOMIC_ACQ_REL) !=  0) 
    abort ();

  if (__atomic_fetch_nand (&v, 0, __ATOMIC_SEQ_CST) !=  init) 
    abort ();
}

void
test_fetch_xor ()
{
  v = init;
  count = 0;

  if (__atomic_fetch_xor (&v, count, __ATOMIC_RELAXED) !=  init) 
    abort ();

  if (__atomic_fetch_xor (&v, ~count, __ATOMIC_CONSUME) !=  init) 
    abort ();

  if (__atomic_fetch_xor (&v, 0, __ATOMIC_ACQUIRE) !=  0) 
    abort ();

  if (__atomic_fetch_xor (&v, ~count, __ATOMIC_RELEASE) !=  0) 
    abort ();

  if (__atomic_fetch_xor (&v, 0, __ATOMIC_ACQ_REL) !=  init) 
    abort ();

  if (__atomic_fetch_xor (&v, ~count, __ATOMIC_SEQ_CST) !=  init) 
    abort ();
}

void
test_fetch_or ()
{
  v = 0;
  count = 1;

  if (__atomic_fetch_or (&v, count, __ATOMIC_RELAXED) !=  0) 
    abort ();

  count *= 2;
  if (__atomic_fetch_or (&v, 2, __ATOMIC_CONSUME) !=  1) 
    abort ();

  count *= 2;
  if (__atomic_fetch_or (&v, count, __ATOMIC_ACQUIRE) !=  3) 
    abort ();

  count *= 2;
  if (__atomic_fetch_or (&v, 8, __ATOMIC_RELEASE) !=  7) 
    abort ();

  count *= 2;
  if (__atomic_fetch_or (&v, count, __ATOMIC_ACQ_REL) !=  15) 
    abort ();

  count *= 2;
  if (__atomic_fetch_or (&v, count, __ATOMIC_SEQ_CST) !=  31) 
    abort ();
}

/* The OP_fetch routines return the new value after the operation.  */

void
test_add_fetch ()
{
  v = 0;
  count = 1;

  if (__atomic_add_fetch (&v, count, __ATOMIC_RELAXED) != 1)
    abort ();

  if (__atomic_add_fetch (&v, 1, __ATOMIC_CONSUME) != 2) 
    abort ();

  if (__atomic_add_fetch (&v, count, __ATOMIC_ACQUIRE) != 3)
    abort ();

  if (__atomic_add_fetch (&v, 1, __ATOMIC_RELEASE) != 4) 
    abort ();

  if (__atomic_add_fetch (&v, count, __ATOMIC_ACQ_REL) != 5) 
    abort ();

  if (__atomic_add_fetch (&v, count, __ATOMIC_SEQ_CST) != 6) 
    abort ();
}


void
test_sub_fetch ()
{
  v = res = 20;
  count = 0;

  if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_RELAXED) !=  --res) 
    abort ();

  if (__atomic_sub_fetch (&v, 1, __ATOMIC_CONSUME) !=  --res) 
    abort ();                                                  
                                                               
  if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQUIRE) !=  --res) 
    abort ();                                                  
                                                               
  if (__atomic_sub_fetch (&v, 1, __ATOMIC_RELEASE) !=  --res) 
    abort ();                                                  
                                                               
  if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQ_REL) !=  --res) 
    abort ();                                                  
                                                               
  if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_SEQ_CST) !=  --res) 
    abort ();
}

void
test_and_fetch ()
{
  v = init;

  if (__atomic_and_fetch (&v, 0, __ATOMIC_RELAXED) !=  0) 
    abort ();

  v = init;
  if (__atomic_and_fetch (&v, init, __ATOMIC_CONSUME) !=  init) 
    abort ();

  if (__atomic_and_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  0) 
    abort ();

  v = ~v;
  if (__atomic_and_fetch (&v, init, __ATOMIC_RELEASE) !=  init)
    abort ();

  if (__atomic_and_fetch (&v, 0, __ATOMIC_ACQ_REL) !=  0) 
    abort ();

  v = ~v;
  if (__atomic_and_fetch (&v, 0, __ATOMIC_SEQ_CST) !=  0) 
    abort ();
}

void
test_nand_fetch ()
{
  v = init;

  if (__atomic_nand_fetch (&v, 0, __ATOMIC_RELAXED) !=  init) 
    abort ();              
                           
  if (__atomic_nand_fetch (&v, init, __ATOMIC_CONSUME) !=  0) 
    abort ();              
                           
  if (__atomic_nand_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  init) 
    abort ();              
                           
  if (__atomic_nand_fetch (&v, init, __ATOMIC_RELEASE) !=  0)
    abort ();              
                           
  if (__atomic_nand_fetch (&v, init, __ATOMIC_ACQ_REL) !=  init) 
    abort ();              
                           
  if (__atomic_nand_fetch (&v, 0, __ATOMIC_SEQ_CST) !=  init) 
    abort ();
}


void
test_xor_fetch ()
{
  v = init;
  count = 0;

  if (__atomic_xor_fetch (&v, count, __ATOMIC_RELAXED) !=  init) 
    abort ();

  if (__atomic_xor_fetch (&v, ~count, __ATOMIC_CONSUME) !=  0) 
    abort ();

  if (__atomic_xor_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  0) 
    abort ();

  if (__atomic_xor_fetch (&v, ~count, __ATOMIC_RELEASE) !=  init) 
    abort ();

  if (__atomic_xor_fetch (&v, 0, __ATOMIC_ACQ_REL) !=  init) 
    abort ();

  if (__atomic_xor_fetch (&v, ~count, __ATOMIC_SEQ_CST) !=  0) 
    abort ();
}

void
test_or_fetch ()
{
  v = 0;
  count = 1;

  if (__atomic_or_fetch (&v, count, __ATOMIC_RELAXED) !=  1) 
    abort ();

  count *= 2;
  if (__atomic_or_fetch (&v, 2, __ATOMIC_CONSUME) !=  3) 
    abort ();

  count *= 2;
  if (__atomic_or_fetch (&v, count, __ATOMIC_ACQUIRE) !=  7) 
    abort ();

  count *= 2;
  if (__atomic_or_fetch (&v, 8, __ATOMIC_RELEASE) !=  15) 
    abort ();

  count *= 2;
  if (__atomic_or_fetch (&v, count, __ATOMIC_ACQ_REL) !=  31) 
    abort ();

  count *= 2;
  if (__atomic_or_fetch (&v, count, __ATOMIC_SEQ_CST) !=  63) 
    abort ();
}


/* Test the OP routines with a result which isn't used. Use both variations
   within each function.  */

void
test_add ()
{
  v = 0;
  count = 1;

  __atomic_add_fetch (&v, count, __ATOMIC_RELAXED);
  if (v != 1)
    abort ();

  __atomic_fetch_add (&v, count, __ATOMIC_CONSUME);
  if (v != 2)
    abort ();

  __atomic_add_fetch (&v, 1 , __ATOMIC_ACQUIRE);
  if (v != 3)
    abort ();

  __atomic_fetch_add (&v, 1, __ATOMIC_RELEASE);
  if (v != 4)
    abort ();

  __atomic_add_fetch (&v, count, __ATOMIC_ACQ_REL);
  if (v != 5)
    abort ();

  __atomic_fetch_add (&v, count, __ATOMIC_SEQ_CST);
  if (v != 6)
    abort ();
}


void
test_sub()
{
  v = res = 20;
  count = 0;

  __atomic_sub_fetch (&v, count + 1, __ATOMIC_RELAXED);
  if (v != --res)
    abort ();

  __atomic_fetch_sub (&v, count + 1, __ATOMIC_CONSUME);
  if (v != --res)
    abort ();                                                  
                                                               
  __atomic_sub_fetch (&v, 1, __ATOMIC_ACQUIRE);
  if (v != --res)
    abort ();                                                  
                                                               
  __atomic_fetch_sub (&v, 1, __ATOMIC_RELEASE);
  if (v != --res)
    abort ();                                                  
                                                               
  __atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQ_REL);
  if (v != --res)
    abort ();                                                  
                                                               
  __atomic_fetch_sub (&v, count + 1, __ATOMIC_SEQ_CST);
  if (v != --res)
    abort ();
}

void
test_and ()
{
  v = init;

  __atomic_and_fetch (&v, 0, __ATOMIC_RELAXED);
  if (v != 0)
    abort ();

  v = init;
  __atomic_fetch_and (&v, init, __ATOMIC_CONSUME);
  if (v != init)
    abort ();

  __atomic_and_fetch (&v, 0, __ATOMIC_ACQUIRE);
  if (v != 0)
    abort ();

  v = ~v;
  __atomic_fetch_and (&v, init, __ATOMIC_RELEASE);
  if (v != init)
    abort ();

  __atomic_and_fetch (&v, 0, __ATOMIC_ACQ_REL);
  if (v != 0)
    abort ();

  v = ~v;
  __atomic_fetch_and (&v, 0, __ATOMIC_SEQ_CST);
  if (v != 0)
    abort ();
}

void
test_nand ()
{
  v = init;

  __atomic_fetch_nand (&v, 0, __ATOMIC_RELAXED);
  if (v != init)
    abort ();

  __atomic_fetch_nand (&v, init, __ATOMIC_CONSUME);
  if (v != 0)
    abort ();

  __atomic_nand_fetch (&v, 0, __ATOMIC_ACQUIRE);
  if (v != init)
    abort ();

  __atomic_nand_fetch (&v, init, __ATOMIC_RELEASE);
  if (v != 0)
    abort ();

  __atomic_fetch_nand (&v, init, __ATOMIC_ACQ_REL);
  if (v != init)
    abort ();

  __atomic_nand_fetch (&v, 0, __ATOMIC_SEQ_CST);
  if (v != init)
    abort ();
}


void
test_xor ()
{
  v = init;
  count = 0;

  __atomic_xor_fetch (&v, count, __ATOMIC_RELAXED);
  if (v != init)
    abort ();

  __atomic_fetch_xor (&v, ~count, __ATOMIC_CONSUME);
  if (v != 0)
    abort ();

  __atomic_xor_fetch (&v, 0, __ATOMIC_ACQUIRE);
  if (v != 0)
    abort ();

  __atomic_fetch_xor (&v, ~count, __ATOMIC_RELEASE);
  if (v != init)
    abort ();

  __atomic_fetch_xor (&v, 0, __ATOMIC_ACQ_REL);
  if (v != init)
    abort ();

  __atomic_xor_fetch (&v, ~count, __ATOMIC_SEQ_CST);
  if (v != 0)
    abort ();
}

void
test_or ()
{
  v = 0;
  count = 1;

  __atomic_or_fetch (&v, count, __ATOMIC_RELAXED);
  if (v != 1)
    abort ();

  count *= 2;
  __atomic_fetch_or (&v, count, __ATOMIC_CONSUME);
  if (v != 3)
    abort ();

  count *= 2;
  __atomic_or_fetch (&v, 4, __ATOMIC_ACQUIRE);
  if (v != 7)
    abort ();

  count *= 2;
  __atomic_fetch_or (&v, 8, __ATOMIC_RELEASE);
  if (v != 15)
    abort ();

  count *= 2;
  __atomic_or_fetch (&v, count, __ATOMIC_ACQ_REL);
  if (v != 31)
    abort ();

  count *= 2;
  __atomic_fetch_or (&v, count, __ATOMIC_SEQ_CST);
  if (v != 63)
    abort ();
}

int
main ()
{
  test_fetch_add ();
  test_fetch_sub ();
  test_fetch_and ();
  test_fetch_nand ();
  test_fetch_xor ();
  test_fetch_or ();

  test_add_fetch ();
  test_sub_fetch ();
  test_and_fetch ();
  test_nand_fetch ();
  test_xor_fetch ();
  test_or_fetch ();

  test_add ();
  test_sub ();
  test_and ();
  test_nand ();
  test_xor ();
  test_or ();

  return 0;
}
Commit	Line	Data
86951993 AM	1	/* Test __atomic routines for existence and proper execution on 1 byte
	2	values with each valid memory model. */
	3	/* { dg-do run } */
	4	/* { dg-require-effective-target sync_char_short } */
	5
	6	/* Test the execution of the __atomic_OP builtin routines for a char. /
	7
	8	extern void abort(void);
	9
	10	char v, count, res;
	11	const char init = ~0;
	12
	13	/* The fetch_op routines return the original value before the operation. */
	14
	15	void
	16	test_fetch_add ()
	17	{
	18	v = 0;
	19	count = 1;
	20
	21	if (__atomic_fetch_add (&v, count, __ATOMIC_RELAXED) != 0)
	22	abort ();
	23
	24	if (__atomic_fetch_add (&v, 1, __ATOMIC_CONSUME) != 1)
	25	abort ();
	26
	27	if (__atomic_fetch_add (&v, count, __ATOMIC_ACQUIRE) != 2)
	28	abort ();
	29
	30	if (__atomic_fetch_add (&v, 1, __ATOMIC_RELEASE) != 3)
	31	abort ();
	32
	33	if (__atomic_fetch_add (&v, count, __ATOMIC_ACQ_REL) != 4)
	34	abort ();
	35
	36	if (__atomic_fetch_add (&v, 1, __ATOMIC_SEQ_CST) != 5)
	37	abort ();
	38	}
	39
	40
	41	void
	42	test_fetch_sub()
	43	{
	44	v = res = 20;
	45	count = 0;
	46
	47	if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_RELAXED) != res--)
	48	abort ();
	49
	50	if (__atomic_fetch_sub (&v, 1, __ATOMIC_CONSUME) != res--)
	51	abort ();
	52
	53	if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_ACQUIRE) != res--)
	54	abort ();
	55
	56	if (__atomic_fetch_sub (&v, 1, __ATOMIC_RELEASE) != res--)
	57	abort ();
	58
	59	if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_ACQ_REL) != res--)
	60	abort ();
	61
	62	if (__atomic_fetch_sub (&v, 1, __ATOMIC_SEQ_CST) != res--)
	63	abort ();
	64	}
65
66	void
67	test_fetch_and ()
68	{
69	v = init;
70
71	if (__atomic_fetch_and (&v, 0, __ATOMIC_RELAXED) != init)
72	abort ();
73
74	if (__atomic_fetch_and (&v, init, __ATOMIC_CONSUME) != 0)
75	abort ();
76
77	if (__atomic_fetch_and (&v, 0, __ATOMIC_ACQUIRE) != 0)
78	abort ();
79
80	v = ~v;
81	if (__atomic_fetch_and (&v, init, __ATOMIC_RELEASE) != init)
82	abort ();
83
84	if (__atomic_fetch_and (&v, 0, __ATOMIC_ACQ_REL) != init)
85	abort ();
86
87	if (__atomic_fetch_and (&v, 0, __ATOMIC_SEQ_CST) != 0)
88	abort ();
89	}
90
91	void
92	test_fetch_nand ()
93	{
94	v = init;
95
96	if (__atomic_fetch_nand (&v, 0, __ATOMIC_RELAXED) != init)
97	abort ();
98
99	if (__atomic_fetch_nand (&v, init, __ATOMIC_CONSUME) != init)
100	abort ();
101
102	if (__atomic_fetch_nand (&v, 0, __ATOMIC_ACQUIRE) != 0 )
103	abort ();
104
105	if (__atomic_fetch_nand (&v, init, __ATOMIC_RELEASE) != init)
106	abort ();
107
108	if (__atomic_fetch_nand (&v, init, __ATOMIC_ACQ_REL) != 0)
109	abort ();
110
111	if (__atomic_fetch_nand (&v, 0, __ATOMIC_SEQ_CST) != init)
112	abort ();
113	}
114
115	void
116	test_fetch_xor ()
117	{
118	v = init;
119	count = 0;
120
121	if (__atomic_fetch_xor (&v, count, __ATOMIC_RELAXED) != init)
122	abort ();
123
124	if (__atomic_fetch_xor (&v, ~count, __ATOMIC_CONSUME) != init)
125	abort ();
126
127	if (__atomic_fetch_xor (&v, 0, __ATOMIC_ACQUIRE) != 0)
128	abort ();
129
130	if (__atomic_fetch_xor (&v, ~count, __ATOMIC_RELEASE) != 0)
131	abort ();
132
133	if (__atomic_fetch_xor (&v, 0, __ATOMIC_ACQ_REL) != init)
134	abort ();
135
136	if (__atomic_fetch_xor (&v, ~count, __ATOMIC_SEQ_CST) != init)
137	abort ();
138	}
139
140	void
141	test_fetch_or ()
142	{
143	v = 0;
144	count = 1;
145
146	if (__atomic_fetch_or (&v, count, __ATOMIC_RELAXED) != 0)
147	abort ();
148
149	count *= 2;
150	if (__atomic_fetch_or (&v, 2, __ATOMIC_CONSUME) != 1)
151	abort ();
152
153	count *= 2;
154	if (__atomic_fetch_or (&v, count, __ATOMIC_ACQUIRE) != 3)
155	abort ();
156
157	count *= 2;
158	if (__atomic_fetch_or (&v, 8, __ATOMIC_RELEASE) != 7)
159	abort ();
160
161	count *= 2;
162	if (__atomic_fetch_or (&v, count, __ATOMIC_ACQ_REL) != 15)
163	abort ();
164
165	count *= 2;
166	if (__atomic_fetch_or (&v, count, __ATOMIC_SEQ_CST) != 31)
167	abort ();
168	}
169
170	/* The OP_fetch routines return the new value after the operation. */
171
172	void
173	test_add_fetch ()
174	{
175	v = 0;
176	count = 1;
177
178	if (__atomic_add_fetch (&v, count, __ATOMIC_RELAXED) != 1)
179	abort ();
180
181	if (__atomic_add_fetch (&v, 1, __ATOMIC_CONSUME) != 2)
182	abort ();
183
184	if (__atomic_add_fetch (&v, count, __ATOMIC_ACQUIRE) != 3)
185	abort ();
186
187	if (__atomic_add_fetch (&v, 1, __ATOMIC_RELEASE) != 4)
188	abort ();
189
190	if (__atomic_add_fetch (&v, count, __ATOMIC_ACQ_REL) != 5)
191	abort ();
192
193	if (__atomic_add_fetch (&v, count, __ATOMIC_SEQ_CST) != 6)
194	abort ();
195	}
196
197
198	void
199	test_sub_fetch ()
200	{
201	v = res = 20;
202	count = 0;
203
204	if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_RELAXED) != --res)
205	abort ();
206
207	if (__atomic_sub_fetch (&v, 1, __ATOMIC_CONSUME) != --res)
208	abort ();
209
210	if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQUIRE) != --res)
211	abort ();
212
213	if (__atomic_sub_fetch (&v, 1, __ATOMIC_RELEASE) != --res)
214	abort ();
215
216	if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQ_REL) != --res)
217	abort ();
218
219	if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_SEQ_CST) != --res)
220	abort ();
221	}
222
223	void
224	test_and_fetch ()
225	{
226	v = init;
227
228	if (__atomic_and_fetch (&v, 0, __ATOMIC_RELAXED) != 0)
229	abort ();
230
231	v = init;
232	if (__atomic_and_fetch (&v, init, __ATOMIC_CONSUME) != init)
233	abort ();
234
235	if (__atomic_and_fetch (&v, 0, __ATOMIC_ACQUIRE) != 0)
236	abort ();
237
238	v = ~v;
239	if (__atomic_and_fetch (&v, init, __ATOMIC_RELEASE) != init)
240	abort ();
241
242	if (__atomic_and_fetch (&v, 0, __ATOMIC_ACQ_REL) != 0)
243	abort ();
244
245	v = ~v;
246	if (__atomic_and_fetch (&v, 0, __ATOMIC_SEQ_CST) != 0)
247	abort ();
248	}
249
250	void
251	test_nand_fetch ()
252	{
253	v = init;
254
255	if (__atomic_nand_fetch (&v, 0, __ATOMIC_RELAXED) != init)
256	abort ();
257
258	if (__atomic_nand_fetch (&v, init, __ATOMIC_CONSUME) != 0)
259	abort ();
260
261	if (__atomic_nand_fetch (&v, 0, __ATOMIC_ACQUIRE) != init)
262	abort ();
263
264	if (__atomic_nand_fetch (&v, init, __ATOMIC_RELEASE) != 0)
265	abort ();
266
267	if (__atomic_nand_fetch (&v, init, __ATOMIC_ACQ_REL) != init)
268	abort ();
269
270	if (__atomic_nand_fetch (&v, 0, __ATOMIC_SEQ_CST) != init)
271	abort ();
272	}
273
274
275
276	void
277	test_xor_fetch ()
278	{
279	v = init;
280	count = 0;
281
282	if (__atomic_xor_fetch (&v, count, __ATOMIC_RELAXED) != init)
283	abort ();
284
285	if (__atomic_xor_fetch (&v, ~count, __ATOMIC_CONSUME) != 0)
286	abort ();
287
288	if (__atomic_xor_fetch (&v, 0, __ATOMIC_ACQUIRE) != 0)
289	abort ();
290
291	if (__atomic_xor_fetch (&v, ~count, __ATOMIC_RELEASE) != init)
292	abort ();
293
294	if (__atomic_xor_fetch (&v, 0, __ATOMIC_ACQ_REL) != init)
295	abort ();
296
297	if (__atomic_xor_fetch (&v, ~count, __ATOMIC_SEQ_CST) != 0)
298	abort ();
299	}
300
301	void
302	test_or_fetch ()
303	{
304	v = 0;
305	count = 1;
306
307	if (__atomic_or_fetch (&v, count, __ATOMIC_RELAXED) != 1)
308	abort ();
309
310	count *= 2;
311	if (__atomic_or_fetch (&v, 2, __ATOMIC_CONSUME) != 3)
312	abort ();
313
314	count *= 2;
315	if (__atomic_or_fetch (&v, count, __ATOMIC_ACQUIRE) != 7)
316	abort ();
317
318	count *= 2;
319	if (__atomic_or_fetch (&v, 8, __ATOMIC_RELEASE) != 15)
320	abort ();
321
322	count *= 2;
323	if (__atomic_or_fetch (&v, count, __ATOMIC_ACQ_REL) != 31)
324	abort ();
325
326	count *= 2;
327	if (__atomic_or_fetch (&v, count, __ATOMIC_SEQ_CST) != 63)
328	abort ();
329	}
330
331
332	/* Test the OP routines with a result which isn't used. Use both variations
333	within each function. */
334
335	void
336	test_add ()
337	{
338	v = 0;
339	count = 1;
340
341	__atomic_add_fetch (&v, count, __ATOMIC_RELAXED);
342	if (v != 1)
343	abort ();
344
345	__atomic_fetch_add (&v, count, __ATOMIC_CONSUME);
346	if (v != 2)
347	abort ();
348
349	__atomic_add_fetch (&v, 1 , __ATOMIC_ACQUIRE);
350	if (v != 3)
351	abort ();
352
353	__atomic_fetch_add (&v, 1, __ATOMIC_RELEASE);
354	if (v != 4)
355	abort ();
356
357	__atomic_add_fetch (&v, count, __ATOMIC_ACQ_REL);
358	if (v != 5)
359	abort ();
360
361	__atomic_fetch_add (&v, count, __ATOMIC_SEQ_CST);
362	if (v != 6)
363	abort ();
364	}
365
366
367	void
368	test_sub()
369	{
370	v = res = 20;
371	count = 0;
372
373	__atomic_sub_fetch (&v, count + 1, __ATOMIC_RELAXED);
374	if (v != --res)
375	abort ();
376
377	__atomic_fetch_sub (&v, count + 1, __ATOMIC_CONSUME);
378	if (v != --res)
379	abort ();
380
381	__atomic_sub_fetch (&v, 1, __ATOMIC_ACQUIRE);
382	if (v != --res)
383	abort ();
384
385	__atomic_fetch_sub (&v, 1, __ATOMIC_RELEASE);
386	if (v != --res)
387	abort ();
388
389	__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQ_REL);
390	if (v != --res)
391	abort ();
392
393	__atomic_fetch_sub (&v, count + 1, __ATOMIC_SEQ_CST);
394	if (v != --res)
395	abort ();
396	}
397
398	void
399	test_and ()
400	{
401	v = init;
402
403	__atomic_and_fetch (&v, 0, __ATOMIC_RELAXED);
404	if (v != 0)
405	abort ();
406
407	v = init;
408	__atomic_fetch_and (&v, init, __ATOMIC_CONSUME);
409	if (v != init)
410	abort ();
411
412	__atomic_and_fetch (&v, 0, __ATOMIC_ACQUIRE);
413	if (v != 0)
414	abort ();
415
416	v = ~v;
417	__atomic_fetch_and (&v, init, __ATOMIC_RELEASE);
418	if (v != init)
419	abort ();
420
421	__atomic_and_fetch (&v, 0, __ATOMIC_ACQ_REL);
422	if (v != 0)
423	abort ();
424
425	v = ~v;
426	__atomic_fetch_and (&v, 0, __ATOMIC_SEQ_CST);
427	if (v != 0)
428	abort ();
429	}
430
431	void
432	test_nand ()
433	{
434	v = init;
435
436	__atomic_fetch_nand (&v, 0, __ATOMIC_RELAXED);
437	if (v != init)
438	abort ();
439
440	__atomic_fetch_nand (&v, init, __ATOMIC_CONSUME);
441	if (v != 0)
442	abort ();
443
444	__atomic_nand_fetch (&v, 0, __ATOMIC_ACQUIRE);
445	if (v != init)
446	abort ();
447
448	__atomic_nand_fetch (&v, init, __ATOMIC_RELEASE);
449	if (v != 0)
450	abort ();
451
452	__atomic_fetch_nand (&v, init, __ATOMIC_ACQ_REL);
453	if (v != init)
454	abort ();
455
456	__atomic_nand_fetch (&v, 0, __ATOMIC_SEQ_CST);
457	if (v != init)
458	abort ();
459	}
460
461
462
463	void
464	test_xor ()
465	{
466	v = init;
467	count = 0;
468
469	__atomic_xor_fetch (&v, count, __ATOMIC_RELAXED);
470	if (v != init)
471	abort ();
472
473	__atomic_fetch_xor (&v, ~count, __ATOMIC_CONSUME);
474	if (v != 0)
475	abort ();
476
477	__atomic_xor_fetch (&v, 0, __ATOMIC_ACQUIRE);
478	if (v != 0)
479	abort ();
480
481	__atomic_fetch_xor (&v, ~count, __ATOMIC_RELEASE);
482	if (v != init)
483	abort ();
484
485	__atomic_fetch_xor (&v, 0, __ATOMIC_ACQ_REL);
486	if (v != init)
487	abort ();
488
489	__atomic_xor_fetch (&v, ~count, __ATOMIC_SEQ_CST);
490	if (v != 0)
491	abort ();
492	}
493
494	void
495	test_or ()
496	{
497	v = 0;
498	count = 1;
499
500	__atomic_or_fetch (&v, count, __ATOMIC_RELAXED);
501	if (v != 1)
502	abort ();
503
504	count *= 2;
505	__atomic_fetch_or (&v, count, __ATOMIC_CONSUME);
506	if (v != 3)
507	abort ();
508
509	count *= 2;
510	__atomic_or_fetch (&v, 4, __ATOMIC_ACQUIRE);
511	if (v != 7)
512	abort ();
513
514	count *= 2;
515	__atomic_fetch_or (&v, 8, __ATOMIC_RELEASE);
516	if (v != 15)
517	abort ();
518
519	count *= 2;
520	__atomic_or_fetch (&v, count, __ATOMIC_ACQ_REL);
521	if (v != 31)
522	abort ();
523
524	count *= 2;
525	__atomic_fetch_or (&v, count, __ATOMIC_SEQ_CST);
526	if (v != 63)
527	abort ();
528	}
529
722516b8	530	int
86951993 AM	531	main ()
	532	{
	533	test_fetch_add ();
	534	test_fetch_sub ();
	535	test_fetch_and ();
	536	test_fetch_nand ();
	537	test_fetch_xor ();
	538	test_fetch_or ();
	539
	540	test_add_fetch ();
	541	test_sub_fetch ();
	542	test_and_fetch ();
	543	test_nand_fetch ();
	544	test_xor_fetch ();
	545	test_or_fetch ();
	546
	547	test_add ();
	548	test_sub ();
	549	test_and ();
	550	test_nand ();
	551	test_xor ();
	552	test_or ();
	553
	554	return 0;
	555	}