1 | /* Tests for atomic.h macros. |
2 | Copyright (C) 2003-2022 Free Software Foundation, Inc. |
3 | This file is part of the GNU C Library. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <https://www.gnu.org/licenses/>. */ |
18 | |
19 | #include <stdio.h> |
20 | #include <atomic.h> |
21 | |
22 | #ifndef atomic_t |
23 | # define atomic_t int |
24 | #endif |
25 | |
26 | /* Test various atomic.h macros. */ |
27 | static int |
28 | do_test (void) |
29 | { |
30 | atomic_t mem, expected; |
31 | int ret = 0; |
32 | |
33 | #ifdef atomic_compare_and_exchange_val_acq |
34 | mem = 24; |
35 | if (atomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24 |
36 | || mem != 35) |
37 | { |
38 | puts (s: "atomic_compare_and_exchange_val_acq test 1 failed" ); |
39 | ret = 1; |
40 | } |
41 | |
42 | mem = 12; |
43 | if (atomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12 |
44 | || mem != 12) |
45 | { |
46 | puts (s: "atomic_compare_and_exchange_val_acq test 2 failed" ); |
47 | ret = 1; |
48 | } |
49 | |
50 | mem = -15; |
51 | if (atomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15 |
52 | || mem != -56) |
53 | { |
54 | puts (s: "atomic_compare_and_exchange_val_acq test 3 failed" ); |
55 | ret = 1; |
56 | } |
57 | |
58 | mem = -1; |
59 | if (atomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1 |
60 | || mem != -1) |
61 | { |
62 | puts (s: "atomic_compare_and_exchange_val_acq test 4 failed" ); |
63 | ret = 1; |
64 | } |
65 | #endif |
66 | |
67 | mem = 24; |
68 | if (atomic_compare_and_exchange_bool_acq (&mem, 35, 24) |
69 | || mem != 35) |
70 | { |
71 | puts (s: "atomic_compare_and_exchange_bool_acq test 1 failed" ); |
72 | ret = 1; |
73 | } |
74 | |
75 | mem = 12; |
76 | if (! atomic_compare_and_exchange_bool_acq (&mem, 10, 15) |
77 | || mem != 12) |
78 | { |
79 | puts (s: "atomic_compare_and_exchange_bool_acq test 2 failed" ); |
80 | ret = 1; |
81 | } |
82 | |
83 | mem = -15; |
84 | if (atomic_compare_and_exchange_bool_acq (&mem, -56, -15) |
85 | || mem != -56) |
86 | { |
87 | puts (s: "atomic_compare_and_exchange_bool_acq test 3 failed" ); |
88 | ret = 1; |
89 | } |
90 | |
91 | mem = -1; |
92 | if (! atomic_compare_and_exchange_bool_acq (&mem, 17, 0) |
93 | || mem != -1) |
94 | { |
95 | puts (s: "atomic_compare_and_exchange_bool_acq test 4 failed" ); |
96 | ret = 1; |
97 | } |
98 | |
99 | mem = 64; |
100 | if (atomic_exchange_acq (&mem, 31) != 64 |
101 | || mem != 31) |
102 | { |
103 | puts (s: "atomic_exchange_acq test failed" ); |
104 | ret = 1; |
105 | } |
106 | |
107 | mem = 2; |
108 | if (atomic_exchange_and_add (&mem, 11) != 2 |
109 | || mem != 13) |
110 | { |
111 | puts (s: "atomic_exchange_and_add test failed" ); |
112 | ret = 1; |
113 | } |
114 | |
115 | mem = 2; |
116 | if (atomic_exchange_and_add_acq (&mem, 11) != 2 |
117 | || mem != 13) |
118 | { |
119 | puts (s: "atomic_exchange_and_add test failed" ); |
120 | ret = 1; |
121 | } |
122 | |
123 | mem = 2; |
124 | if (atomic_exchange_and_add_rel (&mem, 11) != 2 |
125 | || mem != 13) |
126 | { |
127 | puts (s: "atomic_exchange_and_add test failed" ); |
128 | ret = 1; |
129 | } |
130 | |
131 | mem = -21; |
132 | atomic_add (&mem, 22); |
133 | if (mem != 1) |
134 | { |
135 | puts (s: "atomic_add test failed" ); |
136 | ret = 1; |
137 | } |
138 | |
139 | mem = -1; |
140 | atomic_increment (&mem); |
141 | if (mem != 0) |
142 | { |
143 | puts (s: "atomic_increment test failed" ); |
144 | ret = 1; |
145 | } |
146 | |
147 | mem = 2; |
148 | if (atomic_increment_val (&mem) != 3) |
149 | { |
150 | puts (s: "atomic_increment_val test failed" ); |
151 | ret = 1; |
152 | } |
153 | |
154 | mem = 0; |
155 | if (atomic_increment_and_test (&mem) |
156 | || mem != 1) |
157 | { |
158 | puts (s: "atomic_increment_and_test test 1 failed" ); |
159 | ret = 1; |
160 | } |
161 | |
162 | mem = 35; |
163 | if (atomic_increment_and_test (&mem) |
164 | || mem != 36) |
165 | { |
166 | puts (s: "atomic_increment_and_test test 2 failed" ); |
167 | ret = 1; |
168 | } |
169 | |
170 | mem = -1; |
171 | if (! atomic_increment_and_test (&mem) |
172 | || mem != 0) |
173 | { |
174 | puts (s: "atomic_increment_and_test test 3 failed" ); |
175 | ret = 1; |
176 | } |
177 | |
178 | mem = 17; |
179 | atomic_decrement (&mem); |
180 | if (mem != 16) |
181 | { |
182 | puts (s: "atomic_decrement test failed" ); |
183 | ret = 1; |
184 | } |
185 | |
186 | if (atomic_decrement_val (&mem) != 15) |
187 | { |
188 | puts (s: "atomic_decrement_val test failed" ); |
189 | ret = 1; |
190 | } |
191 | |
192 | mem = 0; |
193 | if (atomic_decrement_and_test (&mem) |
194 | || mem != -1) |
195 | { |
196 | puts (s: "atomic_decrement_and_test test 1 failed" ); |
197 | ret = 1; |
198 | } |
199 | |
200 | mem = 15; |
201 | if (atomic_decrement_and_test (&mem) |
202 | || mem != 14) |
203 | { |
204 | puts (s: "atomic_decrement_and_test test 2 failed" ); |
205 | ret = 1; |
206 | } |
207 | |
208 | mem = 1; |
209 | if (! atomic_decrement_and_test (&mem) |
210 | || mem != 0) |
211 | { |
212 | puts (s: "atomic_decrement_and_test test 3 failed" ); |
213 | ret = 1; |
214 | } |
215 | |
216 | mem = 1; |
217 | if (atomic_decrement_if_positive (&mem) != 1 |
218 | || mem != 0) |
219 | { |
220 | puts (s: "atomic_decrement_if_positive test 1 failed" ); |
221 | ret = 1; |
222 | } |
223 | |
224 | mem = 0; |
225 | if (atomic_decrement_if_positive (&mem) != 0 |
226 | || mem != 0) |
227 | { |
228 | puts (s: "atomic_decrement_if_positive test 2 failed" ); |
229 | ret = 1; |
230 | } |
231 | |
232 | mem = -1; |
233 | if (atomic_decrement_if_positive (&mem) != -1 |
234 | || mem != -1) |
235 | { |
236 | puts (s: "atomic_decrement_if_positive test 3 failed" ); |
237 | ret = 1; |
238 | } |
239 | |
240 | mem = -12; |
241 | if (! atomic_add_negative (&mem, 10) |
242 | || mem != -2) |
243 | { |
244 | puts (s: "atomic_add_negative test 1 failed" ); |
245 | ret = 1; |
246 | } |
247 | |
248 | mem = 0; |
249 | if (atomic_add_negative (&mem, 100) |
250 | || mem != 100) |
251 | { |
252 | puts (s: "atomic_add_negative test 2 failed" ); |
253 | ret = 1; |
254 | } |
255 | |
256 | mem = 15; |
257 | if (atomic_add_negative (&mem, -10) |
258 | || mem != 5) |
259 | { |
260 | puts (s: "atomic_add_negative test 3 failed" ); |
261 | ret = 1; |
262 | } |
263 | |
264 | mem = -12; |
265 | if (atomic_add_negative (&mem, 14) |
266 | || mem != 2) |
267 | { |
268 | puts (s: "atomic_add_negative test 4 failed" ); |
269 | ret = 1; |
270 | } |
271 | |
272 | mem = 0; |
273 | if (! atomic_add_negative (&mem, -1) |
274 | || mem != -1) |
275 | { |
276 | puts (s: "atomic_add_negative test 5 failed" ); |
277 | ret = 1; |
278 | } |
279 | |
280 | mem = -31; |
281 | if (atomic_add_negative (&mem, 31) |
282 | || mem != 0) |
283 | { |
284 | puts (s: "atomic_add_negative test 6 failed" ); |
285 | ret = 1; |
286 | } |
287 | |
288 | mem = -34; |
289 | if (atomic_add_zero (&mem, 31) |
290 | || mem != -3) |
291 | { |
292 | puts (s: "atomic_add_zero test 1 failed" ); |
293 | ret = 1; |
294 | } |
295 | |
296 | mem = -36; |
297 | if (! atomic_add_zero (&mem, 36) |
298 | || mem != 0) |
299 | { |
300 | puts (s: "atomic_add_zero test 2 failed" ); |
301 | ret = 1; |
302 | } |
303 | |
304 | mem = 113; |
305 | if (atomic_add_zero (&mem, -13) |
306 | || mem != 100) |
307 | { |
308 | puts (s: "atomic_add_zero test 3 failed" ); |
309 | ret = 1; |
310 | } |
311 | |
312 | mem = -18; |
313 | if (atomic_add_zero (&mem, 20) |
314 | || mem != 2) |
315 | { |
316 | puts (s: "atomic_add_zero test 4 failed" ); |
317 | ret = 1; |
318 | } |
319 | |
320 | mem = 10; |
321 | if (atomic_add_zero (&mem, -20) |
322 | || mem != -10) |
323 | { |
324 | puts (s: "atomic_add_zero test 5 failed" ); |
325 | ret = 1; |
326 | } |
327 | |
328 | mem = 10; |
329 | if (! atomic_add_zero (&mem, -10) |
330 | || mem != 0) |
331 | { |
332 | puts (s: "atomic_add_zero test 6 failed" ); |
333 | ret = 1; |
334 | } |
335 | |
336 | mem = 0; |
337 | atomic_bit_set (&mem, 1); |
338 | if (mem != 2) |
339 | { |
340 | puts (s: "atomic_bit_set test 1 failed" ); |
341 | ret = 1; |
342 | } |
343 | |
344 | mem = 8; |
345 | atomic_bit_set (&mem, 3); |
346 | if (mem != 8) |
347 | { |
348 | puts (s: "atomic_bit_set test 2 failed" ); |
349 | ret = 1; |
350 | } |
351 | |
352 | #ifdef TEST_ATOMIC64 |
353 | mem = 16; |
354 | atomic_bit_set (&mem, 35); |
355 | if (mem != 0x800000010LL) |
356 | { |
357 | puts (s: "atomic_bit_set test 3 failed" ); |
358 | ret = 1; |
359 | } |
360 | #endif |
361 | |
362 | mem = 0; |
363 | if (atomic_bit_test_set (&mem, 1) |
364 | || mem != 2) |
365 | { |
366 | puts (s: "atomic_bit_test_set test 1 failed" ); |
367 | ret = 1; |
368 | } |
369 | |
370 | mem = 8; |
371 | if (! atomic_bit_test_set (&mem, 3) |
372 | || mem != 8) |
373 | { |
374 | puts (s: "atomic_bit_test_set test 2 failed" ); |
375 | ret = 1; |
376 | } |
377 | |
378 | #ifdef TEST_ATOMIC64 |
379 | mem = 16; |
380 | if (atomic_bit_test_set (&mem, 35) |
381 | || mem != 0x800000010LL) |
382 | { |
383 | puts (s: "atomic_bit_test_set test 3 failed" ); |
384 | ret = 1; |
385 | } |
386 | |
387 | mem = 0x100000000LL; |
388 | if (! atomic_bit_test_set (&mem, 32) |
389 | || mem != 0x100000000LL) |
390 | { |
391 | puts (s: "atomic_bit_test_set test 4 failed" ); |
392 | ret = 1; |
393 | } |
394 | #endif |
395 | |
396 | #ifdef catomic_compare_and_exchange_val_acq |
397 | mem = 24; |
398 | if (catomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24 |
399 | || mem != 35) |
400 | { |
401 | puts (s: "catomic_compare_and_exchange_val_acq test 1 failed" ); |
402 | ret = 1; |
403 | } |
404 | |
405 | mem = 12; |
406 | if (catomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12 |
407 | || mem != 12) |
408 | { |
409 | puts (s: "catomic_compare_and_exchange_val_acq test 2 failed" ); |
410 | ret = 1; |
411 | } |
412 | |
413 | mem = -15; |
414 | if (catomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15 |
415 | || mem != -56) |
416 | { |
417 | puts (s: "catomic_compare_and_exchange_val_acq test 3 failed" ); |
418 | ret = 1; |
419 | } |
420 | |
421 | mem = -1; |
422 | if (catomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1 |
423 | || mem != -1) |
424 | { |
425 | puts (s: "catomic_compare_and_exchange_val_acq test 4 failed" ); |
426 | ret = 1; |
427 | } |
428 | #endif |
429 | |
430 | mem = 24; |
431 | if (catomic_compare_and_exchange_bool_acq (&mem, 35, 24) |
432 | || mem != 35) |
433 | { |
434 | puts (s: "catomic_compare_and_exchange_bool_acq test 1 failed" ); |
435 | ret = 1; |
436 | } |
437 | |
438 | mem = 12; |
439 | if (! catomic_compare_and_exchange_bool_acq (&mem, 10, 15) |
440 | || mem != 12) |
441 | { |
442 | puts (s: "catomic_compare_and_exchange_bool_acq test 2 failed" ); |
443 | ret = 1; |
444 | } |
445 | |
446 | mem = -15; |
447 | if (catomic_compare_and_exchange_bool_acq (&mem, -56, -15) |
448 | || mem != -56) |
449 | { |
450 | puts (s: "catomic_compare_and_exchange_bool_acq test 3 failed" ); |
451 | ret = 1; |
452 | } |
453 | |
454 | mem = -1; |
455 | if (! catomic_compare_and_exchange_bool_acq (&mem, 17, 0) |
456 | || mem != -1) |
457 | { |
458 | puts (s: "catomic_compare_and_exchange_bool_acq test 4 failed" ); |
459 | ret = 1; |
460 | } |
461 | |
462 | mem = 2; |
463 | if (catomic_exchange_and_add (&mem, 11) != 2 |
464 | || mem != 13) |
465 | { |
466 | puts (s: "catomic_exchange_and_add test failed" ); |
467 | ret = 1; |
468 | } |
469 | |
470 | mem = -21; |
471 | catomic_add (&mem, 22); |
472 | if (mem != 1) |
473 | { |
474 | puts (s: "catomic_add test failed" ); |
475 | ret = 1; |
476 | } |
477 | |
478 | mem = -1; |
479 | catomic_increment (&mem); |
480 | if (mem != 0) |
481 | { |
482 | puts (s: "catomic_increment test failed" ); |
483 | ret = 1; |
484 | } |
485 | |
486 | mem = 2; |
487 | if (catomic_increment_val (&mem) != 3) |
488 | { |
489 | puts (s: "catomic_increment_val test failed" ); |
490 | ret = 1; |
491 | } |
492 | |
493 | mem = 17; |
494 | catomic_decrement (&mem); |
495 | if (mem != 16) |
496 | { |
497 | puts (s: "catomic_decrement test failed" ); |
498 | ret = 1; |
499 | } |
500 | |
501 | if (catomic_decrement_val (&mem) != 15) |
502 | { |
503 | puts (s: "catomic_decrement_val test failed" ); |
504 | ret = 1; |
505 | } |
506 | |
507 | /* Tests for C11-like atomics. */ |
508 | mem = 11; |
509 | if (atomic_load_relaxed (&mem) != 11 || atomic_load_acquire (&mem) != 11) |
510 | { |
511 | puts (s: "atomic_load_{relaxed,acquire} test failed" ); |
512 | ret = 1; |
513 | } |
514 | |
515 | atomic_store_relaxed (&mem, 12); |
516 | if (mem != 12) |
517 | { |
518 | puts (s: "atomic_store_relaxed test failed" ); |
519 | ret = 1; |
520 | } |
521 | atomic_store_release (&mem, 13); |
522 | if (mem != 13) |
523 | { |
524 | puts (s: "atomic_store_release test failed" ); |
525 | ret = 1; |
526 | } |
527 | |
528 | mem = 14; |
529 | expected = 14; |
530 | if (!atomic_compare_exchange_weak_relaxed (&mem, &expected, 25) |
531 | || mem != 25 || expected != 14) |
532 | { |
533 | puts (s: "atomic_compare_exchange_weak_relaxed test 1 failed" ); |
534 | ret = 1; |
535 | } |
536 | if (atomic_compare_exchange_weak_relaxed (&mem, &expected, 14) |
537 | || mem != 25 || expected != 25) |
538 | { |
539 | puts (s: "atomic_compare_exchange_weak_relaxed test 2 failed" ); |
540 | ret = 1; |
541 | } |
542 | mem = 14; |
543 | expected = 14; |
544 | if (!atomic_compare_exchange_weak_acquire (&mem, &expected, 25) |
545 | || mem != 25 || expected != 14) |
546 | { |
547 | puts (s: "atomic_compare_exchange_weak_acquire test 1 failed" ); |
548 | ret = 1; |
549 | } |
550 | if (atomic_compare_exchange_weak_acquire (&mem, &expected, 14) |
551 | || mem != 25 || expected != 25) |
552 | { |
553 | puts (s: "atomic_compare_exchange_weak_acquire test 2 failed" ); |
554 | ret = 1; |
555 | } |
556 | mem = 14; |
557 | expected = 14; |
558 | if (!atomic_compare_exchange_weak_release (&mem, &expected, 25) |
559 | || mem != 25 || expected != 14) |
560 | { |
561 | puts (s: "atomic_compare_exchange_weak_release test 1 failed" ); |
562 | ret = 1; |
563 | } |
564 | if (atomic_compare_exchange_weak_release (&mem, &expected, 14) |
565 | || mem != 25 || expected != 25) |
566 | { |
567 | puts (s: "atomic_compare_exchange_weak_release test 2 failed" ); |
568 | ret = 1; |
569 | } |
570 | |
571 | mem = 23; |
572 | if (atomic_exchange_acquire (&mem, 42) != 23 || mem != 42) |
573 | { |
574 | puts (s: "atomic_exchange_acquire test failed" ); |
575 | ret = 1; |
576 | } |
577 | mem = 23; |
578 | if (atomic_exchange_release (&mem, 42) != 23 || mem != 42) |
579 | { |
580 | puts (s: "atomic_exchange_release test failed" ); |
581 | ret = 1; |
582 | } |
583 | |
584 | mem = 23; |
585 | if (atomic_fetch_add_relaxed (&mem, 1) != 23 || mem != 24) |
586 | { |
587 | puts (s: "atomic_fetch_add_relaxed test failed" ); |
588 | ret = 1; |
589 | } |
590 | mem = 23; |
591 | if (atomic_fetch_add_acquire (&mem, 1) != 23 || mem != 24) |
592 | { |
593 | puts (s: "atomic_fetch_add_acquire test failed" ); |
594 | ret = 1; |
595 | } |
596 | mem = 23; |
597 | if (atomic_fetch_add_release (&mem, 1) != 23 || mem != 24) |
598 | { |
599 | puts (s: "atomic_fetch_add_release test failed" ); |
600 | ret = 1; |
601 | } |
602 | mem = 23; |
603 | if (atomic_fetch_add_acq_rel (&mem, 1) != 23 || mem != 24) |
604 | { |
605 | puts (s: "atomic_fetch_add_acq_rel test failed" ); |
606 | ret = 1; |
607 | } |
608 | |
609 | mem = 3; |
610 | if (atomic_fetch_and_acquire (&mem, 2) != 3 || mem != 2) |
611 | { |
612 | puts (s: "atomic_fetch_and_acquire test failed" ); |
613 | ret = 1; |
614 | } |
615 | |
616 | mem = 4; |
617 | if (atomic_fetch_or_relaxed (&mem, 2) != 4 || mem != 6) |
618 | { |
619 | puts (s: "atomic_fetch_or_relaxed test failed" ); |
620 | ret = 1; |
621 | } |
622 | mem = 4; |
623 | if (atomic_fetch_or_acquire (&mem, 2) != 4 || mem != 6) |
624 | { |
625 | puts (s: "atomic_fetch_or_acquire test failed" ); |
626 | ret = 1; |
627 | } |
628 | |
629 | /* This is a single-threaded test, so we can't test the effects of the |
630 | fences. */ |
631 | atomic_thread_fence_acquire (); |
632 | atomic_thread_fence_release (); |
633 | atomic_thread_fence_seq_cst (); |
634 | |
635 | return ret; |
636 | } |
637 | |
638 | #include <support/test-driver.c> |
639 | |