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