1// -*- C++ -*- header.
2
3// Copyright (C) 2008-2018 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file include/atomic
26 * This is a Standard C++ Library header.
27 */
28
29// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
30// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
31
32#ifndef _GLIBCXX_ATOMIC
33#define _GLIBCXX_ATOMIC 1
34
35#pragma GCC system_header
36
37#if __cplusplus < 201103L
38# include <bits/c++0x_warning.h>
39#else
40
41#include <bits/atomic_base.h>
42#include <bits/move.h>
43
44namespace std _GLIBCXX_VISIBILITY(default)
45{
46_GLIBCXX_BEGIN_NAMESPACE_VERSION
47
48 /**
49 * @addtogroup atomics
50 * @{
51 */
52
53#if __cplusplus > 201402L
54# define __cpp_lib_atomic_is_always_lock_free 201603
55#endif
56
57 template<typename _Tp>
58 struct atomic;
59
60 /// atomic<bool>
61 // NB: No operators or fetch-operations for this type.
62 template<>
63 struct atomic<bool>
64 {
65 private:
66 __atomic_base<bool> _M_base;
67
68 public:
69 atomic() noexcept = default;
70 ~atomic() noexcept = default;
71 atomic(const atomic&) = delete;
72 atomic& operator=(const atomic&) = delete;
73 atomic& operator=(const atomic&) volatile = delete;
74
75 constexpr atomic(bool __i) noexcept : _M_base(__i) { }
76
77 bool
78 operator=(bool __i) noexcept
79 { return _M_base.operator=(__i); }
80
81 bool
82 operator=(bool __i) volatile noexcept
83 { return _M_base.operator=(__i); }
84
85 operator bool() const noexcept
86 { return _M_base.load(); }
87
88 operator bool() const volatile noexcept
89 { return _M_base.load(); }
90
91 bool
92 is_lock_free() const noexcept { return _M_base.is_lock_free(); }
93
94 bool
95 is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
96
97#if __cplusplus > 201402L
98 static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE == 2;
99#endif
100
101 void
102 store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
103 { _M_base.store(__i, __m); }
104
105 void
106 store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
107 { _M_base.store(__i, __m); }
108
109 bool
110 load(memory_order __m = memory_order_seq_cst) const noexcept
111 { return _M_base.load(__m); }
112
113 bool
114 load(memory_order __m = memory_order_seq_cst) const volatile noexcept
115 { return _M_base.load(__m); }
116
117 bool
118 exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
119 { return _M_base.exchange(__i, __m); }
120
121 bool
122 exchange(bool __i,
123 memory_order __m = memory_order_seq_cst) volatile noexcept
124 { return _M_base.exchange(__i, __m); }
125
126 bool
127 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
128 memory_order __m2) noexcept
129 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
130
131 bool
132 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
133 memory_order __m2) volatile noexcept
134 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
135
136 bool
137 compare_exchange_weak(bool& __i1, bool __i2,
138 memory_order __m = memory_order_seq_cst) noexcept
139 { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
140
141 bool
142 compare_exchange_weak(bool& __i1, bool __i2,
143 memory_order __m = memory_order_seq_cst) volatile noexcept
144 { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
145
146 bool
147 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
148 memory_order __m2) noexcept
149 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
150
151 bool
152 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
153 memory_order __m2) volatile noexcept
154 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
155
156 bool
157 compare_exchange_strong(bool& __i1, bool __i2,
158 memory_order __m = memory_order_seq_cst) noexcept
159 { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
160
161 bool
162 compare_exchange_strong(bool& __i1, bool __i2,
163 memory_order __m = memory_order_seq_cst) volatile noexcept
164 { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
165 };
166
167
168 /**
169 * @brief Generic atomic type, primary class template.
170 *
171 * @tparam _Tp Type to be made atomic, must be trivally copyable.
172 */
173 template<typename _Tp>
174 struct atomic
175 {
176 private:
177 // Align 1/2/4/8/16-byte types to at least their size.
178 static constexpr int _S_min_alignment
179 = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
180 ? 0 : sizeof(_Tp);
181
182 static constexpr int _S_alignment
183 = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
184
185 alignas(_S_alignment) _Tp _M_i;
186
187 static_assert(__is_trivially_copyable(_Tp),
188 "std::atomic requires a trivially copyable type");
189
190 static_assert(sizeof(_Tp) > 0,
191 "Incomplete or zero-sized types are not supported");
192
193 public:
194 atomic() noexcept = default;
195 ~atomic() noexcept = default;
196 atomic(const atomic&) = delete;
197 atomic& operator=(const atomic&) = delete;
198 atomic& operator=(const atomic&) volatile = delete;
199
200 constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
201
202 operator _Tp() const noexcept
203 { return load(); }
204
205 operator _Tp() const volatile noexcept
206 { return load(); }
207
208 _Tp
209 operator=(_Tp __i) noexcept
210 { store(__i); return __i; }
211
212 _Tp
213 operator=(_Tp __i) volatile noexcept
214 { store(__i); return __i; }
215
216 bool
217 is_lock_free() const noexcept
218 {
219 // Produce a fake, minimally aligned pointer.
220 return __atomic_is_lock_free(sizeof(_M_i),
221 reinterpret_cast<void *>(-__alignof(_M_i)));
222 }
223
224 bool
225 is_lock_free() const volatile noexcept
226 {
227 // Produce a fake, minimally aligned pointer.
228 return __atomic_is_lock_free(sizeof(_M_i),
229 reinterpret_cast<void *>(-__alignof(_M_i)));
230 }
231
232#if __cplusplus > 201402L
233 static constexpr bool is_always_lock_free
234 = __atomic_always_lock_free(sizeof(_M_i), 0);
235#endif
236
237 void
238 store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
239 { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), __m); }
240
241 void
242 store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
243 { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), __m); }
244
245 _Tp
246 load(memory_order __m = memory_order_seq_cst) const noexcept
247 {
248 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
249 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
250 __atomic_load(std::__addressof(_M_i), __ptr, __m);
251 return *__ptr;
252 }
253
254 _Tp
255 load(memory_order __m = memory_order_seq_cst) const volatile noexcept
256 {
257 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
258 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
259 __atomic_load(std::__addressof(_M_i), __ptr, __m);
260 return *__ptr;
261 }
262
263 _Tp
264 exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
265 {
266 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
267 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
268 __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
269 __ptr, __m);
270 return *__ptr;
271 }
272
273 _Tp
274 exchange(_Tp __i,
275 memory_order __m = memory_order_seq_cst) volatile noexcept
276 {
277 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
278 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
279 __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
280 __ptr, __m);
281 return *__ptr;
282 }
283
284 bool
285 compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
286 memory_order __f) noexcept
287 {
288 return __atomic_compare_exchange(std::__addressof(_M_i),
289 std::__addressof(__e),
290 std::__addressof(__i),
291 true, __s, __f);
292 }
293
294 bool
295 compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
296 memory_order __f) volatile noexcept
297 {
298 return __atomic_compare_exchange(std::__addressof(_M_i),
299 std::__addressof(__e),
300 std::__addressof(__i),
301 true, __s, __f);
302 }
303
304 bool
305 compare_exchange_weak(_Tp& __e, _Tp __i,
306 memory_order __m = memory_order_seq_cst) noexcept
307 { return compare_exchange_weak(__e, __i, __m,
308 __cmpexch_failure_order(__m)); }
309
310 bool
311 compare_exchange_weak(_Tp& __e, _Tp __i,
312 memory_order __m = memory_order_seq_cst) volatile noexcept
313 { return compare_exchange_weak(__e, __i, __m,
314 __cmpexch_failure_order(__m)); }
315
316 bool
317 compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
318 memory_order __f) noexcept
319 {
320 return __atomic_compare_exchange(std::__addressof(_M_i),
321 std::__addressof(__e),
322 std::__addressof(__i),
323 false, __s, __f);
324 }
325
326 bool
327 compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
328 memory_order __f) volatile noexcept
329 {
330 return __atomic_compare_exchange(std::__addressof(_M_i),
331 std::__addressof(__e),
332 std::__addressof(__i),
333 false, __s, __f);
334 }
335
336 bool
337 compare_exchange_strong(_Tp& __e, _Tp __i,
338 memory_order __m = memory_order_seq_cst) noexcept
339 { return compare_exchange_strong(__e, __i, __m,
340 __cmpexch_failure_order(__m)); }
341
342 bool
343 compare_exchange_strong(_Tp& __e, _Tp __i,
344 memory_order __m = memory_order_seq_cst) volatile noexcept
345 { return compare_exchange_strong(__e, __i, __m,
346 __cmpexch_failure_order(__m)); }
347 };
348
349
350 /// Partial specialization for pointer types.
351 template<typename _Tp>
352 struct atomic<_Tp*>
353 {
354 typedef _Tp* __pointer_type;
355 typedef __atomic_base<_Tp*> __base_type;
356 __base_type _M_b;
357
358 atomic() noexcept = default;
359 ~atomic() noexcept = default;
360 atomic(const atomic&) = delete;
361 atomic& operator=(const atomic&) = delete;
362 atomic& operator=(const atomic&) volatile = delete;
363
364 constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
365
366 operator __pointer_type() const noexcept
367 { return __pointer_type(_M_b); }
368
369 operator __pointer_type() const volatile noexcept
370 { return __pointer_type(_M_b); }
371
372 __pointer_type
373 operator=(__pointer_type __p) noexcept
374 { return _M_b.operator=(__p); }
375
376 __pointer_type
377 operator=(__pointer_type __p) volatile noexcept
378 { return _M_b.operator=(__p); }
379
380 __pointer_type
381 operator++(int) noexcept
382 { return _M_b++; }
383
384 __pointer_type
385 operator++(int) volatile noexcept
386 { return _M_b++; }
387
388 __pointer_type
389 operator--(int) noexcept
390 { return _M_b--; }
391
392 __pointer_type
393 operator--(int) volatile noexcept
394 { return _M_b--; }
395
396 __pointer_type
397 operator++() noexcept
398 { return ++_M_b; }
399
400 __pointer_type
401 operator++() volatile noexcept
402 { return ++_M_b; }
403
404 __pointer_type
405 operator--() noexcept
406 { return --_M_b; }
407
408 __pointer_type
409 operator--() volatile noexcept
410 { return --_M_b; }
411
412 __pointer_type
413 operator+=(ptrdiff_t __d) noexcept
414 { return _M_b.operator+=(__d); }
415
416 __pointer_type
417 operator+=(ptrdiff_t __d) volatile noexcept
418 { return _M_b.operator+=(__d); }
419
420 __pointer_type
421 operator-=(ptrdiff_t __d) noexcept
422 { return _M_b.operator-=(__d); }
423
424 __pointer_type
425 operator-=(ptrdiff_t __d) volatile noexcept
426 { return _M_b.operator-=(__d); }
427
428 bool
429 is_lock_free() const noexcept
430 { return _M_b.is_lock_free(); }
431
432 bool
433 is_lock_free() const volatile noexcept
434 { return _M_b.is_lock_free(); }
435
436#if __cplusplus > 201402L
437 static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
438#endif
439
440 void
441 store(__pointer_type __p,
442 memory_order __m = memory_order_seq_cst) noexcept
443 { return _M_b.store(__p, __m); }
444
445 void
446 store(__pointer_type __p,
447 memory_order __m = memory_order_seq_cst) volatile noexcept
448 { return _M_b.store(__p, __m); }
449
450 __pointer_type
451 load(memory_order __m = memory_order_seq_cst) const noexcept
452 { return _M_b.load(__m); }
453
454 __pointer_type
455 load(memory_order __m = memory_order_seq_cst) const volatile noexcept
456 { return _M_b.load(__m); }
457
458 __pointer_type
459 exchange(__pointer_type __p,
460 memory_order __m = memory_order_seq_cst) noexcept
461 { return _M_b.exchange(__p, __m); }
462
463 __pointer_type
464 exchange(__pointer_type __p,
465 memory_order __m = memory_order_seq_cst) volatile noexcept
466 { return _M_b.exchange(__p, __m); }
467
468 bool
469 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
470 memory_order __m1, memory_order __m2) noexcept
471 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
472
473 bool
474 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
475 memory_order __m1,
476 memory_order __m2) volatile noexcept
477 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
478
479 bool
480 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
481 memory_order __m = memory_order_seq_cst) noexcept
482 {
483 return compare_exchange_weak(__p1, __p2, __m,
484 __cmpexch_failure_order(__m));
485 }
486
487 bool
488 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
489 memory_order __m = memory_order_seq_cst) volatile noexcept
490 {
491 return compare_exchange_weak(__p1, __p2, __m,
492 __cmpexch_failure_order(__m));
493 }
494
495 bool
496 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
497 memory_order __m1, memory_order __m2) noexcept
498 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
499
500 bool
501 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
502 memory_order __m1,
503 memory_order __m2) volatile noexcept
504 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
505
506 bool
507 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
508 memory_order __m = memory_order_seq_cst) noexcept
509 {
510 return _M_b.compare_exchange_strong(__p1, __p2, __m,
511 __cmpexch_failure_order(__m));
512 }
513
514 bool
515 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
516 memory_order __m = memory_order_seq_cst) volatile noexcept
517 {
518 return _M_b.compare_exchange_strong(__p1, __p2, __m,
519 __cmpexch_failure_order(__m));
520 }
521
522 __pointer_type
523 fetch_add(ptrdiff_t __d,
524 memory_order __m = memory_order_seq_cst) noexcept
525 { return _M_b.fetch_add(__d, __m); }
526
527 __pointer_type
528 fetch_add(ptrdiff_t __d,
529 memory_order __m = memory_order_seq_cst) volatile noexcept
530 { return _M_b.fetch_add(__d, __m); }
531
532 __pointer_type
533 fetch_sub(ptrdiff_t __d,
534 memory_order __m = memory_order_seq_cst) noexcept
535 { return _M_b.fetch_sub(__d, __m); }
536
537 __pointer_type
538 fetch_sub(ptrdiff_t __d,
539 memory_order __m = memory_order_seq_cst) volatile noexcept
540 { return _M_b.fetch_sub(__d, __m); }
541 };
542
543
544 /// Explicit specialization for char.
545 template<>
546 struct atomic<char> : __atomic_base<char>
547 {
548 typedef char __integral_type;
549 typedef __atomic_base<char> __base_type;
550
551 atomic() noexcept = default;
552 ~atomic() noexcept = default;
553 atomic(const atomic&) = delete;
554 atomic& operator=(const atomic&) = delete;
555 atomic& operator=(const atomic&) volatile = delete;
556
557 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
558
559 using __base_type::operator __integral_type;
560 using __base_type::operator=;
561
562#if __cplusplus > 201402L
563 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
564#endif
565 };
566
567 /// Explicit specialization for signed char.
568 template<>
569 struct atomic<signed char> : __atomic_base<signed char>
570 {
571 typedef signed char __integral_type;
572 typedef __atomic_base<signed char> __base_type;
573
574 atomic() noexcept= default;
575 ~atomic() noexcept = default;
576 atomic(const atomic&) = delete;
577 atomic& operator=(const atomic&) = delete;
578 atomic& operator=(const atomic&) volatile = delete;
579
580 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
581
582 using __base_type::operator __integral_type;
583 using __base_type::operator=;
584
585#if __cplusplus > 201402L
586 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
587#endif
588 };
589
590 /// Explicit specialization for unsigned char.
591 template<>
592 struct atomic<unsigned char> : __atomic_base<unsigned char>
593 {
594 typedef unsigned char __integral_type;
595 typedef __atomic_base<unsigned char> __base_type;
596
597 atomic() noexcept= default;
598 ~atomic() noexcept = default;
599 atomic(const atomic&) = delete;
600 atomic& operator=(const atomic&) = delete;
601 atomic& operator=(const atomic&) volatile = delete;
602
603 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
604
605 using __base_type::operator __integral_type;
606 using __base_type::operator=;
607
608#if __cplusplus > 201402L
609 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
610#endif
611 };
612
613 /// Explicit specialization for short.
614 template<>
615 struct atomic<short> : __atomic_base<short>
616 {
617 typedef short __integral_type;
618 typedef __atomic_base<short> __base_type;
619
620 atomic() noexcept = default;
621 ~atomic() noexcept = default;
622 atomic(const atomic&) = delete;
623 atomic& operator=(const atomic&) = delete;
624 atomic& operator=(const atomic&) volatile = delete;
625
626 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
627
628 using __base_type::operator __integral_type;
629 using __base_type::operator=;
630
631#if __cplusplus > 201402L
632 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
633#endif
634 };
635
636 /// Explicit specialization for unsigned short.
637 template<>
638 struct atomic<unsigned short> : __atomic_base<unsigned short>
639 {
640 typedef unsigned short __integral_type;
641 typedef __atomic_base<unsigned short> __base_type;
642
643 atomic() noexcept = default;
644 ~atomic() noexcept = default;
645 atomic(const atomic&) = delete;
646 atomic& operator=(const atomic&) = delete;
647 atomic& operator=(const atomic&) volatile = delete;
648
649 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
650
651 using __base_type::operator __integral_type;
652 using __base_type::operator=;
653
654#if __cplusplus > 201402L
655 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
656#endif
657 };
658
659 /// Explicit specialization for int.
660 template<>
661 struct atomic<int> : __atomic_base<int>
662 {
663 typedef int __integral_type;
664 typedef __atomic_base<int> __base_type;
665
666 atomic() noexcept = default;
667 ~atomic() noexcept = default;
668 atomic(const atomic&) = delete;
669 atomic& operator=(const atomic&) = delete;
670 atomic& operator=(const atomic&) volatile = delete;
671
672 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
673
674 using __base_type::operator __integral_type;
675 using __base_type::operator=;
676
677#if __cplusplus > 201402L
678 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
679#endif
680 };
681
682 /// Explicit specialization for unsigned int.
683 template<>
684 struct atomic<unsigned int> : __atomic_base<unsigned int>
685 {
686 typedef unsigned int __integral_type;
687 typedef __atomic_base<unsigned int> __base_type;
688
689 atomic() noexcept = default;
690 ~atomic() noexcept = default;
691 atomic(const atomic&) = delete;
692 atomic& operator=(const atomic&) = delete;
693 atomic& operator=(const atomic&) volatile = delete;
694
695 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
696
697 using __base_type::operator __integral_type;
698 using __base_type::operator=;
699
700#if __cplusplus > 201402L
701 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
702#endif
703 };
704
705 /// Explicit specialization for long.
706 template<>
707 struct atomic<long> : __atomic_base<long>
708 {
709 typedef long __integral_type;
710 typedef __atomic_base<long> __base_type;
711
712 atomic() noexcept = default;
713 ~atomic() noexcept = default;
714 atomic(const atomic&) = delete;
715 atomic& operator=(const atomic&) = delete;
716 atomic& operator=(const atomic&) volatile = delete;
717
718 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
719
720 using __base_type::operator __integral_type;
721 using __base_type::operator=;
722
723#if __cplusplus > 201402L
724 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
725#endif
726 };
727
728 /// Explicit specialization for unsigned long.
729 template<>
730 struct atomic<unsigned long> : __atomic_base<unsigned long>
731 {
732 typedef unsigned long __integral_type;
733 typedef __atomic_base<unsigned long> __base_type;
734
735 atomic() noexcept = default;
736 ~atomic() noexcept = default;
737 atomic(const atomic&) = delete;
738 atomic& operator=(const atomic&) = delete;
739 atomic& operator=(const atomic&) volatile = delete;
740
741 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
742
743 using __base_type::operator __integral_type;
744 using __base_type::operator=;
745
746#if __cplusplus > 201402L
747 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
748#endif
749 };
750
751 /// Explicit specialization for long long.
752 template<>
753 struct atomic<long long> : __atomic_base<long long>
754 {
755 typedef long long __integral_type;
756 typedef __atomic_base<long long> __base_type;
757
758 atomic() noexcept = default;
759 ~atomic() noexcept = default;
760 atomic(const atomic&) = delete;
761 atomic& operator=(const atomic&) = delete;
762 atomic& operator=(const atomic&) volatile = delete;
763
764 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
765
766 using __base_type::operator __integral_type;
767 using __base_type::operator=;
768
769#if __cplusplus > 201402L
770 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
771#endif
772 };
773
774 /// Explicit specialization for unsigned long long.
775 template<>
776 struct atomic<unsigned long long> : __atomic_base<unsigned long long>
777 {
778 typedef unsigned long long __integral_type;
779 typedef __atomic_base<unsigned long long> __base_type;
780
781 atomic() noexcept = default;
782 ~atomic() noexcept = default;
783 atomic(const atomic&) = delete;
784 atomic& operator=(const atomic&) = delete;
785 atomic& operator=(const atomic&) volatile = delete;
786
787 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
788
789 using __base_type::operator __integral_type;
790 using __base_type::operator=;
791
792#if __cplusplus > 201402L
793 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
794#endif
795 };
796
797 /// Explicit specialization for wchar_t.
798 template<>
799 struct atomic<wchar_t> : __atomic_base<wchar_t>
800 {
801 typedef wchar_t __integral_type;
802 typedef __atomic_base<wchar_t> __base_type;
803
804 atomic() noexcept = default;
805 ~atomic() noexcept = default;
806 atomic(const atomic&) = delete;
807 atomic& operator=(const atomic&) = delete;
808 atomic& operator=(const atomic&) volatile = delete;
809
810 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
811
812 using __base_type::operator __integral_type;
813 using __base_type::operator=;
814
815#if __cplusplus > 201402L
816 static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
817#endif
818 };
819
820 /// Explicit specialization for char16_t.
821 template<>
822 struct atomic<char16_t> : __atomic_base<char16_t>
823 {
824 typedef char16_t __integral_type;
825 typedef __atomic_base<char16_t> __base_type;
826
827 atomic() noexcept = default;
828 ~atomic() noexcept = default;
829 atomic(const atomic&) = delete;
830 atomic& operator=(const atomic&) = delete;
831 atomic& operator=(const atomic&) volatile = delete;
832
833 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
834
835 using __base_type::operator __integral_type;
836 using __base_type::operator=;
837
838#if __cplusplus > 201402L
839 static constexpr bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2;
840#endif
841 };
842
843 /// Explicit specialization for char32_t.
844 template<>
845 struct atomic<char32_t> : __atomic_base<char32_t>
846 {
847 typedef char32_t __integral_type;
848 typedef __atomic_base<char32_t> __base_type;
849
850 atomic() noexcept = default;
851 ~atomic() noexcept = default;
852 atomic(const atomic&) = delete;
853 atomic& operator=(const atomic&) = delete;
854 atomic& operator=(const atomic&) volatile = delete;
855
856 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
857
858 using __base_type::operator __integral_type;
859 using __base_type::operator=;
860
861#if __cplusplus > 201402L
862 static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2;
863#endif
864 };
865
866
867 /// atomic_bool
868 typedef atomic<bool> atomic_bool;
869
870 /// atomic_char
871 typedef atomic<char> atomic_char;
872
873 /// atomic_schar
874 typedef atomic<signed char> atomic_schar;
875
876 /// atomic_uchar
877 typedef atomic<unsigned char> atomic_uchar;
878
879 /// atomic_short
880 typedef atomic<short> atomic_short;
881
882 /// atomic_ushort
883 typedef atomic<unsigned short> atomic_ushort;
884
885 /// atomic_int
886 typedef atomic<int> atomic_int;
887
888 /// atomic_uint
889 typedef atomic<unsigned int> atomic_uint;
890
891 /// atomic_long
892 typedef atomic<long> atomic_long;
893
894 /// atomic_ulong
895 typedef atomic<unsigned long> atomic_ulong;
896
897 /// atomic_llong
898 typedef atomic<long long> atomic_llong;
899
900 /// atomic_ullong
901 typedef atomic<unsigned long long> atomic_ullong;
902
903 /// atomic_wchar_t
904 typedef atomic<wchar_t> atomic_wchar_t;
905
906 /// atomic_char16_t
907 typedef atomic<char16_t> atomic_char16_t;
908
909 /// atomic_char32_t
910 typedef atomic<char32_t> atomic_char32_t;
911
912#ifdef _GLIBCXX_USE_C99_STDINT_TR1
913 // _GLIBCXX_RESOLVE_LIB_DEFECTS
914 // 2441. Exact-width atomic typedefs should be provided
915
916 /// atomic_int8_t
917 typedef atomic<int8_t> atomic_int8_t;
918
919 /// atomic_uint8_t
920 typedef atomic<uint8_t> atomic_uint8_t;
921
922 /// atomic_int16_t
923 typedef atomic<int16_t> atomic_int16_t;
924
925 /// atomic_uint16_t
926 typedef atomic<uint16_t> atomic_uint16_t;
927
928 /// atomic_int32_t
929 typedef atomic<int32_t> atomic_int32_t;
930
931 /// atomic_uint32_t
932 typedef atomic<uint32_t> atomic_uint32_t;
933
934 /// atomic_int64_t
935 typedef atomic<int64_t> atomic_int64_t;
936
937 /// atomic_uint64_t
938 typedef atomic<uint64_t> atomic_uint64_t;
939
940
941 /// atomic_int_least8_t
942 typedef atomic<int_least8_t> atomic_int_least8_t;
943
944 /// atomic_uint_least8_t
945 typedef atomic<uint_least8_t> atomic_uint_least8_t;
946
947 /// atomic_int_least16_t
948 typedef atomic<int_least16_t> atomic_int_least16_t;
949
950 /// atomic_uint_least16_t
951 typedef atomic<uint_least16_t> atomic_uint_least16_t;
952
953 /// atomic_int_least32_t
954 typedef atomic<int_least32_t> atomic_int_least32_t;
955
956 /// atomic_uint_least32_t
957 typedef atomic<uint_least32_t> atomic_uint_least32_t;
958
959 /// atomic_int_least64_t
960 typedef atomic<int_least64_t> atomic_int_least64_t;
961
962 /// atomic_uint_least64_t
963 typedef atomic<uint_least64_t> atomic_uint_least64_t;
964
965
966 /// atomic_int_fast8_t
967 typedef atomic<int_fast8_t> atomic_int_fast8_t;
968
969 /// atomic_uint_fast8_t
970 typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
971
972 /// atomic_int_fast16_t
973 typedef atomic<int_fast16_t> atomic_int_fast16_t;
974
975 /// atomic_uint_fast16_t
976 typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
977
978 /// atomic_int_fast32_t
979 typedef atomic<int_fast32_t> atomic_int_fast32_t;
980
981 /// atomic_uint_fast32_t
982 typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
983
984 /// atomic_int_fast64_t
985 typedef atomic<int_fast64_t> atomic_int_fast64_t;
986
987 /// atomic_uint_fast64_t
988 typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
989#endif
990
991
992 /// atomic_intptr_t
993 typedef atomic<intptr_t> atomic_intptr_t;
994
995 /// atomic_uintptr_t
996 typedef atomic<uintptr_t> atomic_uintptr_t;
997
998 /// atomic_size_t
999 typedef atomic<size_t> atomic_size_t;
1000
1001 /// atomic_ptrdiff_t
1002 typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
1003
1004#ifdef _GLIBCXX_USE_C99_STDINT_TR1
1005 /// atomic_intmax_t
1006 typedef atomic<intmax_t> atomic_intmax_t;
1007
1008 /// atomic_uintmax_t
1009 typedef atomic<uintmax_t> atomic_uintmax_t;
1010#endif
1011
1012 // Function definitions, atomic_flag operations.
1013 inline bool
1014 atomic_flag_test_and_set_explicit(atomic_flag* __a,
1015 memory_order __m) noexcept
1016 { return __a->test_and_set(__m); }
1017
1018 inline bool
1019 atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
1020 memory_order __m) noexcept
1021 { return __a->test_and_set(__m); }
1022
1023 inline void
1024 atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
1025 { __a->clear(__m); }
1026
1027 inline void
1028 atomic_flag_clear_explicit(volatile atomic_flag* __a,
1029 memory_order __m) noexcept
1030 { __a->clear(__m); }
1031
1032 inline bool
1033 atomic_flag_test_and_set(atomic_flag* __a) noexcept
1034 { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1035
1036 inline bool
1037 atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
1038 { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1039
1040 inline void
1041 atomic_flag_clear(atomic_flag* __a) noexcept
1042 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1043
1044 inline void
1045 atomic_flag_clear(volatile atomic_flag* __a) noexcept
1046 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1047
1048
1049 // Function templates generally applicable to atomic types.
1050 template<typename _ITp>
1051 inline bool
1052 atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
1053 { return __a->is_lock_free(); }
1054
1055 template<typename _ITp>
1056 inline bool
1057 atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
1058 { return __a->is_lock_free(); }
1059
1060 template<typename _ITp>
1061 inline void
1062 atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept
1063 { __a->store(__i, memory_order_relaxed); }
1064
1065 template<typename _ITp>
1066 inline void
1067 atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept
1068 { __a->store(__i, memory_order_relaxed); }
1069
1070 template<typename _ITp>
1071 inline void
1072 atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
1073 memory_order __m) noexcept
1074 { __a->store(__i, __m); }
1075
1076 template<typename _ITp>
1077 inline void
1078 atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
1079 memory_order __m) noexcept
1080 { __a->store(__i, __m); }
1081
1082 template<typename _ITp>
1083 inline _ITp
1084 atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
1085 { return __a->load(__m); }
1086
1087 template<typename _ITp>
1088 inline _ITp
1089 atomic_load_explicit(const volatile atomic<_ITp>* __a,
1090 memory_order __m) noexcept
1091 { return __a->load(__m); }
1092
1093 template<typename _ITp>
1094 inline _ITp
1095 atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
1096 memory_order __m) noexcept
1097 { return __a->exchange(__i, __m); }
1098
1099 template<typename _ITp>
1100 inline _ITp
1101 atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
1102 memory_order __m) noexcept
1103 { return __a->exchange(__i, __m); }
1104
1105 template<typename _ITp>
1106 inline bool
1107 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1108 _ITp* __i1, _ITp __i2,
1109 memory_order __m1,
1110 memory_order __m2) noexcept
1111 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1112
1113 template<typename _ITp>
1114 inline bool
1115 atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
1116 _ITp* __i1, _ITp __i2,
1117 memory_order __m1,
1118 memory_order __m2) noexcept
1119 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1120
1121 template<typename _ITp>
1122 inline bool
1123 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1124 _ITp* __i1, _ITp __i2,
1125 memory_order __m1,
1126 memory_order __m2) noexcept
1127 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1128
1129 template<typename _ITp>
1130 inline bool
1131 atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
1132 _ITp* __i1, _ITp __i2,
1133 memory_order __m1,
1134 memory_order __m2) noexcept
1135 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1136
1137
1138 template<typename _ITp>
1139 inline void
1140 atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
1141 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1142
1143 template<typename _ITp>
1144 inline void
1145 atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
1146 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1147
1148 template<typename _ITp>
1149 inline _ITp
1150 atomic_load(const atomic<_ITp>* __a) noexcept
1151 { return atomic_load_explicit(__a, memory_order_seq_cst); }
1152
1153 template<typename _ITp>
1154 inline _ITp
1155 atomic_load(const volatile atomic<_ITp>* __a) noexcept
1156 { return atomic_load_explicit(__a, memory_order_seq_cst); }
1157
1158 template<typename _ITp>
1159 inline _ITp
1160 atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
1161 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1162
1163 template<typename _ITp>
1164 inline _ITp
1165 atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
1166 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1167
1168 template<typename _ITp>
1169 inline bool
1170 atomic_compare_exchange_weak(atomic<_ITp>* __a,
1171 _ITp* __i1, _ITp __i2) noexcept
1172 {
1173 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1174 memory_order_seq_cst,
1175 memory_order_seq_cst);
1176 }
1177
1178 template<typename _ITp>
1179 inline bool
1180 atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
1181 _ITp* __i1, _ITp __i2) noexcept
1182 {
1183 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1184 memory_order_seq_cst,
1185 memory_order_seq_cst);
1186 }
1187
1188 template<typename _ITp>
1189 inline bool
1190 atomic_compare_exchange_strong(atomic<_ITp>* __a,
1191 _ITp* __i1, _ITp __i2) noexcept
1192 {
1193 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1194 memory_order_seq_cst,
1195 memory_order_seq_cst);
1196 }
1197
1198 template<typename _ITp>
1199 inline bool
1200 atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
1201 _ITp* __i1, _ITp __i2) noexcept
1202 {
1203 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1204 memory_order_seq_cst,
1205 memory_order_seq_cst);
1206 }
1207
1208 // Function templates for atomic_integral operations only, using
1209 // __atomic_base. Template argument should be constricted to
1210 // intergral types as specified in the standard, excluding address
1211 // types.
1212 template<typename _ITp>
1213 inline _ITp
1214 atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1215 memory_order __m) noexcept
1216 { return __a->fetch_add(__i, __m); }
1217
1218 template<typename _ITp>
1219 inline _ITp
1220 atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1221 memory_order __m) noexcept
1222 { return __a->fetch_add(__i, __m); }
1223
1224 template<typename _ITp>
1225 inline _ITp
1226 atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1227 memory_order __m) noexcept
1228 { return __a->fetch_sub(__i, __m); }
1229
1230 template<typename _ITp>
1231 inline _ITp
1232 atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1233 memory_order __m) noexcept
1234 { return __a->fetch_sub(__i, __m); }
1235
1236 template<typename _ITp>
1237 inline _ITp
1238 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1239 memory_order __m) noexcept
1240 { return __a->fetch_and(__i, __m); }
1241
1242 template<typename _ITp>
1243 inline _ITp
1244 atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1245 memory_order __m) noexcept
1246 { return __a->fetch_and(__i, __m); }
1247
1248 template<typename _ITp>
1249 inline _ITp
1250 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1251 memory_order __m) noexcept
1252 { return __a->fetch_or(__i, __m); }
1253
1254 template<typename _ITp>
1255 inline _ITp
1256 atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1257 memory_order __m) noexcept
1258 { return __a->fetch_or(__i, __m); }
1259
1260 template<typename _ITp>
1261 inline _ITp
1262 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1263 memory_order __m) noexcept
1264 { return __a->fetch_xor(__i, __m); }
1265
1266 template<typename _ITp>
1267 inline _ITp
1268 atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1269 memory_order __m) noexcept
1270 { return __a->fetch_xor(__i, __m); }
1271
1272 template<typename _ITp>
1273 inline _ITp
1274 atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1275 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1276
1277 template<typename _ITp>
1278 inline _ITp
1279 atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1280 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1281
1282 template<typename _ITp>
1283 inline _ITp
1284 atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1285 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1286
1287 template<typename _ITp>
1288 inline _ITp
1289 atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1290 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1291
1292 template<typename _ITp>
1293 inline _ITp
1294 atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1295 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1296
1297 template<typename _ITp>
1298 inline _ITp
1299 atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1300 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1301
1302 template<typename _ITp>
1303 inline _ITp
1304 atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1305 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1306
1307 template<typename _ITp>
1308 inline _ITp
1309 atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1310 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1311
1312 template<typename _ITp>
1313 inline _ITp
1314 atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1315 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1316
1317 template<typename _ITp>
1318 inline _ITp
1319 atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1320 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1321
1322
1323 // Partial specializations for pointers.
1324 template<typename _ITp>
1325 inline _ITp*
1326 atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1327 memory_order __m) noexcept
1328 { return __a->fetch_add(__d, __m); }
1329
1330 template<typename _ITp>
1331 inline _ITp*
1332 atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
1333 memory_order __m) noexcept
1334 { return __a->fetch_add(__d, __m); }
1335
1336 template<typename _ITp>
1337 inline _ITp*
1338 atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1339 { return __a->fetch_add(__d); }
1340
1341 template<typename _ITp>
1342 inline _ITp*
1343 atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1344 { return __a->fetch_add(__d); }
1345
1346 template<typename _ITp>
1347 inline _ITp*
1348 atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
1349 ptrdiff_t __d, memory_order __m) noexcept
1350 { return __a->fetch_sub(__d, __m); }
1351
1352 template<typename _ITp>
1353 inline _ITp*
1354 atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1355 memory_order __m) noexcept
1356 { return __a->fetch_sub(__d, __m); }
1357
1358 template<typename _ITp>
1359 inline _ITp*
1360 atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1361 { return __a->fetch_sub(__d); }
1362
1363 template<typename _ITp>
1364 inline _ITp*
1365 atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1366 { return __a->fetch_sub(__d); }
1367 // @} group atomics
1368
1369_GLIBCXX_END_NAMESPACE_VERSION
1370} // namespace
1371
1372#endif // C++11
1373
1374#endif // _GLIBCXX_ATOMIC
1375