1/* Tests for atomic.h macros.
2 Copyright (C) 2003-2024 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. */
27static int
28do_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

source code of glibc/misc/tst-atomic.c