OSDN Git Service

PR libstdc++/56012
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / std / atomic
1 // -*- C++ -*- header.
2
3 // Copyright (C) 2008, 2009, 2010, 2011 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 #ifndef __GXX_EXPERIMENTAL_CXX0X__
38 # include <bits/c++0x_warning.h>
39 #endif
40
41 #include <bits/atomic_base.h>
42
43 namespace std _GLIBCXX_VISIBILITY(default)
44 {
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47   /**
48    * @addtogroup atomics
49    * @{
50    */
51
52   /// atomic_bool
53   // NB: No operators or fetch-operations for this type.
54   struct atomic_bool
55   {
56   private:
57     __atomic_base<bool> _M_base;
58
59   public:
60     atomic_bool() noexcept = default;
61     ~atomic_bool() noexcept = default;
62     atomic_bool(const atomic_bool&) = delete;
63     atomic_bool& operator=(const atomic_bool&) = delete;
64     atomic_bool& operator=(const atomic_bool&) volatile = delete;
65
66     constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { }
67
68     bool
69     operator=(bool __i) noexcept
70     { return _M_base.operator=(__i); }
71
72     bool
73     operator=(bool __i) volatile noexcept
74     { return _M_base.operator=(__i); }
75
76     operator bool() const noexcept
77     { return _M_base.load(); }
78
79     operator bool() const volatile noexcept
80     { return _M_base.load(); }
81
82     bool
83     is_lock_free() const noexcept { return _M_base.is_lock_free(); }
84
85     bool
86     is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
87
88     void
89     store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
90     { _M_base.store(__i, __m); }
91
92     void
93     store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
94     { _M_base.store(__i, __m); }
95
96     bool
97     load(memory_order __m = memory_order_seq_cst) const noexcept
98     { return _M_base.load(__m); }
99
100     bool
101     load(memory_order __m = memory_order_seq_cst) const volatile noexcept
102     { return _M_base.load(__m); }
103
104     bool
105     exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
106     { return _M_base.exchange(__i, __m); }
107
108     bool
109     exchange(bool __i,
110              memory_order __m = memory_order_seq_cst) volatile noexcept
111     { return _M_base.exchange(__i, __m); }
112
113     bool
114     compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
115                           memory_order __m2) noexcept
116     { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
117
118     bool
119     compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
120                           memory_order __m2) volatile noexcept
121     { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
122
123     bool
124     compare_exchange_weak(bool& __i1, bool __i2,
125                           memory_order __m = memory_order_seq_cst) noexcept
126     { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
127
128     bool
129     compare_exchange_weak(bool& __i1, bool __i2,
130                      memory_order __m = memory_order_seq_cst) volatile noexcept
131     { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
132
133     bool
134     compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
135                             memory_order __m2) noexcept
136     { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
137
138     bool
139     compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
140                             memory_order __m2) volatile noexcept
141     { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
142
143     bool
144     compare_exchange_strong(bool& __i1, bool __i2,
145                             memory_order __m = memory_order_seq_cst) noexcept
146     { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
147
148     bool
149     compare_exchange_strong(bool& __i1, bool __i2,
150                     memory_order __m = memory_order_seq_cst) volatile noexcept
151     { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
152   };
153
154
155   /// atomic
156   /// 29.4.3, Generic atomic type, primary class template.
157   template<typename _Tp>
158     struct atomic
159     {
160     private:
161       _Tp _M_i;
162
163     public:
164       atomic() noexcept = default;
165       ~atomic() noexcept = default;
166       atomic(const atomic&) = delete;
167       atomic& operator=(const atomic&) = delete;
168       atomic& operator=(const atomic&) volatile = delete;
169
170       constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
171
172       operator _Tp() const noexcept
173       { return load(); }
174
175       operator _Tp() const volatile noexcept
176       { return load(); }
177
178       _Tp
179       operator=(_Tp __i) noexcept 
180       { store(__i); return __i; }
181
182       _Tp
183       operator=(_Tp __i) volatile noexcept 
184       { store(__i); return __i; }
185
186       bool
187       is_lock_free() const noexcept
188       { return __atomic_is_lock_free(sizeof(_M_i), &_M_i); }
189
190       bool
191       is_lock_free() const volatile noexcept
192       { return __atomic_is_lock_free(sizeof(_M_i), &_M_i); }
193
194       void
195       store(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept
196       { __atomic_store(&_M_i, &__i, _m); }
197
198       void
199       store(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept
200       { __atomic_store(&_M_i, &__i, _m); }
201
202       _Tp
203       load(memory_order _m = memory_order_seq_cst) const noexcept
204       { 
205         _Tp tmp;
206         __atomic_load(&_M_i, &tmp, _m); 
207         return tmp;
208       }
209
210       _Tp
211       load(memory_order _m = memory_order_seq_cst) const volatile noexcept
212       { 
213         _Tp tmp;
214         __atomic_load(&_M_i, &tmp, _m); 
215         return tmp;
216       }
217
218       _Tp
219       exchange(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept
220       { 
221         _Tp tmp;
222         __atomic_exchange(&_M_i, &__i, &tmp, _m); 
223         return tmp;
224       }
225
226       _Tp
227       exchange(_Tp __i, 
228                memory_order _m = memory_order_seq_cst) volatile noexcept
229       { 
230         _Tp tmp;
231         __atomic_exchange(&_M_i, &__i, &tmp, _m); 
232         return tmp;
233       }
234
235       bool
236       compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 
237                             memory_order __f) noexcept
238       {
239         return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); 
240       }
241
242       bool
243       compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 
244                             memory_order __f) volatile noexcept
245       {
246         return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); 
247       }
248
249       bool
250       compare_exchange_weak(_Tp& __e, _Tp __i,
251                             memory_order __m = memory_order_seq_cst) noexcept
252       { return compare_exchange_weak(__e, __i, __m, __m); }
253
254       bool
255       compare_exchange_weak(_Tp& __e, _Tp __i,
256                      memory_order __m = memory_order_seq_cst) volatile noexcept
257       { return compare_exchange_weak(__e, __i, __m, __m); }
258
259       bool
260       compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 
261                               memory_order __f) noexcept
262       {
263         return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); 
264       }
265
266       bool
267       compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 
268                               memory_order __f) volatile noexcept
269       {
270         return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); 
271       }
272
273       bool
274       compare_exchange_strong(_Tp& __e, _Tp __i,
275                                memory_order __m = memory_order_seq_cst) noexcept
276       { return compare_exchange_strong(__e, __i, __m, __m); }
277
278       bool
279       compare_exchange_strong(_Tp& __e, _Tp __i,
280                      memory_order __m = memory_order_seq_cst) volatile noexcept
281       { return compare_exchange_strong(__e, __i, __m, __m); }
282     };
283
284
285   /// Partial specialization for pointer types.
286   template<typename _Tp>
287     struct atomic<_Tp*>
288     {
289       typedef _Tp*                      __pointer_type;
290       typedef __atomic_base<_Tp*>       __base_type;
291       __base_type                       _M_b;
292
293       atomic() noexcept = default;
294       ~atomic() noexcept = default;
295       atomic(const atomic&) = delete;
296       atomic& operator=(const atomic&) = delete;
297       atomic& operator=(const atomic&) volatile = delete;
298
299       constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
300
301       operator __pointer_type() const noexcept
302       { return __pointer_type(_M_b); }
303
304       operator __pointer_type() const volatile noexcept
305       { return __pointer_type(_M_b); }
306
307       __pointer_type
308       operator=(__pointer_type __p) noexcept
309       { return _M_b.operator=(__p); }
310
311       __pointer_type
312       operator=(__pointer_type __p) volatile noexcept
313       { return _M_b.operator=(__p); }
314
315       __pointer_type
316       operator++(int) noexcept
317       { return _M_b++; }
318
319       __pointer_type
320       operator++(int) volatile noexcept
321       { return _M_b++; }
322
323       __pointer_type
324       operator--(int) noexcept
325       { return _M_b--; }
326
327       __pointer_type
328       operator--(int) volatile noexcept
329       { return _M_b--; }
330
331       __pointer_type
332       operator++() noexcept
333       { return ++_M_b; }
334
335       __pointer_type
336       operator++() volatile noexcept
337       { return ++_M_b; }
338
339       __pointer_type
340       operator--() noexcept
341       { return --_M_b; }
342
343       __pointer_type
344       operator--() volatile noexcept
345       { return --_M_b; }
346
347       __pointer_type
348       operator+=(ptrdiff_t __d) noexcept
349       { return _M_b.operator+=(__d); }
350
351       __pointer_type
352       operator+=(ptrdiff_t __d) volatile noexcept
353       { return _M_b.operator+=(__d); }
354
355       __pointer_type
356       operator-=(ptrdiff_t __d) noexcept
357       { return _M_b.operator-=(__d); }
358
359       __pointer_type
360       operator-=(ptrdiff_t __d) volatile noexcept
361       { return _M_b.operator-=(__d); }
362
363       bool
364       is_lock_free() const noexcept
365       { return _M_b.is_lock_free(); }
366
367       bool
368       is_lock_free() const volatile noexcept
369       { return _M_b.is_lock_free(); }
370
371       void
372       store(__pointer_type __p,
373             memory_order __m = memory_order_seq_cst) noexcept
374       { return _M_b.store(__p, __m); }
375
376       void
377       store(__pointer_type __p,
378             memory_order __m = memory_order_seq_cst) volatile noexcept
379       { return _M_b.store(__p, __m); }
380
381       __pointer_type
382       load(memory_order __m = memory_order_seq_cst) const noexcept
383       { return _M_b.load(__m); }
384
385       __pointer_type
386       load(memory_order __m = memory_order_seq_cst) const volatile noexcept
387       { return _M_b.load(__m); }
388
389       __pointer_type
390       exchange(__pointer_type __p,
391                memory_order __m = memory_order_seq_cst) noexcept
392       { return _M_b.exchange(__p, __m); }
393
394       __pointer_type
395       exchange(__pointer_type __p,
396                memory_order __m = memory_order_seq_cst) volatile noexcept
397       { return _M_b.exchange(__p, __m); }
398
399       bool
400       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
401                             memory_order __m1, memory_order __m2) noexcept
402       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
403
404       bool
405       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
406                             memory_order __m1,
407                             memory_order __m2) volatile noexcept
408       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
409
410       bool
411       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
412                             memory_order __m = memory_order_seq_cst) noexcept
413       {
414         return compare_exchange_weak(__p1, __p2, __m,
415                                      __cmpexch_failure_order(__m));
416       }
417
418       bool
419       compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
420                     memory_order __m = memory_order_seq_cst) volatile noexcept
421       {
422         return compare_exchange_weak(__p1, __p2, __m,
423                                      __cmpexch_failure_order(__m));
424       }
425
426       bool
427       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
428                               memory_order __m1, memory_order __m2) noexcept
429       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
430
431       bool
432       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
433                               memory_order __m1,
434                               memory_order __m2) volatile noexcept
435       { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
436
437       bool
438       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
439                               memory_order __m = memory_order_seq_cst) noexcept
440       {
441         return _M_b.compare_exchange_strong(__p1, __p2, __m,
442                                             __cmpexch_failure_order(__m));
443       }
444
445       bool
446       compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
447                     memory_order __m = memory_order_seq_cst) volatile noexcept
448       {
449         return _M_b.compare_exchange_strong(__p1, __p2, __m,
450                                             __cmpexch_failure_order(__m));
451       }
452
453       __pointer_type
454       fetch_add(ptrdiff_t __d,
455                 memory_order __m = memory_order_seq_cst) noexcept
456       { return _M_b.fetch_add(__d, __m); }
457
458       __pointer_type
459       fetch_add(ptrdiff_t __d,
460                 memory_order __m = memory_order_seq_cst) volatile noexcept
461       { return _M_b.fetch_add(__d, __m); }
462
463       __pointer_type
464       fetch_sub(ptrdiff_t __d,
465                 memory_order __m = memory_order_seq_cst) noexcept
466       { return _M_b.fetch_sub(__d, __m); }
467
468       __pointer_type
469       fetch_sub(ptrdiff_t __d,
470                 memory_order __m = memory_order_seq_cst) volatile noexcept
471       { return _M_b.fetch_sub(__d, __m); }
472     };
473
474
475   /// Explicit specialization for bool.
476   template<>
477     struct atomic<bool> : public atomic_bool
478     {
479       typedef bool                      __integral_type;
480       typedef atomic_bool               __base_type;
481
482       atomic() noexcept = default;
483       ~atomic() noexcept = default;
484       atomic(const atomic&) = delete;
485       atomic& operator=(const atomic&) = delete;
486       atomic& operator=(const atomic&) volatile = delete;
487
488       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
489
490       using __base_type::operator __integral_type;
491       using __base_type::operator=;
492     };
493
494   /// Explicit specialization for char.
495   template<>
496     struct atomic<char> : public atomic_char
497     {
498       typedef char                      __integral_type;
499       typedef atomic_char               __base_type;
500
501       atomic() noexcept = default;
502       ~atomic() noexcept = default;
503       atomic(const atomic&) = delete;
504       atomic& operator=(const atomic&) = delete;
505       atomic& operator=(const atomic&) volatile = delete;
506
507       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
508
509       using __base_type::operator __integral_type;
510       using __base_type::operator=;
511     };
512
513   /// Explicit specialization for signed char.
514   template<>
515     struct atomic<signed char> : public atomic_schar
516     {
517       typedef signed char               __integral_type;
518       typedef atomic_schar              __base_type;
519
520       atomic() noexcept= default;
521       ~atomic() noexcept = default;
522       atomic(const atomic&) = delete;
523       atomic& operator=(const atomic&) = delete;
524       atomic& operator=(const atomic&) volatile = delete;
525
526       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
527
528       using __base_type::operator __integral_type;
529       using __base_type::operator=;
530     };
531
532   /// Explicit specialization for unsigned char.
533   template<>
534     struct atomic<unsigned char> : public atomic_uchar
535     {
536       typedef unsigned char             __integral_type;
537       typedef atomic_uchar              __base_type;
538
539       atomic() noexcept= default;
540       ~atomic() noexcept = default;
541       atomic(const atomic&) = delete;
542       atomic& operator=(const atomic&) = delete;
543       atomic& operator=(const atomic&) volatile = delete;
544
545       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
546
547       using __base_type::operator __integral_type;
548       using __base_type::operator=;
549     };
550
551   /// Explicit specialization for short.
552   template<>
553     struct atomic<short> : public atomic_short
554     {
555       typedef short                     __integral_type;
556       typedef atomic_short              __base_type;
557
558       atomic() noexcept = default;
559       ~atomic() noexcept = default;
560       atomic(const atomic&) = delete;
561       atomic& operator=(const atomic&) = delete;
562       atomic& operator=(const atomic&) volatile = delete;
563
564       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
565
566       using __base_type::operator __integral_type;
567       using __base_type::operator=;
568     };
569
570   /// Explicit specialization for unsigned short.
571   template<>
572     struct atomic<unsigned short> : public atomic_ushort
573     {
574       typedef unsigned short            __integral_type;
575       typedef atomic_ushort             __base_type;
576
577       atomic() noexcept = default;
578       ~atomic() noexcept = default;
579       atomic(const atomic&) = delete;
580       atomic& operator=(const atomic&) = delete;
581       atomic& operator=(const atomic&) volatile = delete;
582
583       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
584
585       using __base_type::operator __integral_type;
586       using __base_type::operator=;
587     };
588
589   /// Explicit specialization for int.
590   template<>
591     struct atomic<int> : atomic_int
592     {
593       typedef int                       __integral_type;
594       typedef atomic_int                __base_type;
595
596       atomic() noexcept = default;
597       ~atomic() noexcept = default;
598       atomic(const atomic&) = delete;
599       atomic& operator=(const atomic&) = delete;
600       atomic& operator=(const atomic&) volatile = delete;
601
602       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
603
604       using __base_type::operator __integral_type;
605       using __base_type::operator=;
606     };
607
608   /// Explicit specialization for unsigned int.
609   template<>
610     struct atomic<unsigned int> : public atomic_uint
611     {
612       typedef unsigned int              __integral_type;
613       typedef atomic_uint               __base_type;
614
615       atomic() noexcept = default;
616       ~atomic() noexcept = default;
617       atomic(const atomic&) = delete;
618       atomic& operator=(const atomic&) = delete;
619       atomic& operator=(const atomic&) volatile = delete;
620
621       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
622
623       using __base_type::operator __integral_type;
624       using __base_type::operator=;
625     };
626
627   /// Explicit specialization for long.
628   template<>
629     struct atomic<long> : public atomic_long
630     {
631       typedef long                      __integral_type;
632       typedef atomic_long               __base_type;
633
634       atomic() noexcept = default;
635       ~atomic() noexcept = default;
636       atomic(const atomic&) = delete;
637       atomic& operator=(const atomic&) = delete;
638       atomic& operator=(const atomic&) volatile = delete;
639
640       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
641
642       using __base_type::operator __integral_type;
643       using __base_type::operator=;
644     };
645
646   /// Explicit specialization for unsigned long.
647   template<>
648     struct atomic<unsigned long> : public atomic_ulong
649     {
650       typedef unsigned long             __integral_type;
651       typedef atomic_ulong              __base_type;
652
653       atomic() noexcept = default;
654       ~atomic() noexcept = default;
655       atomic(const atomic&) = delete;
656       atomic& operator=(const atomic&) = delete;
657       atomic& operator=(const atomic&) volatile = delete;
658
659       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
660
661       using __base_type::operator __integral_type;
662       using __base_type::operator=;
663     };
664
665   /// Explicit specialization for long long.
666   template<>
667     struct atomic<long long> : public atomic_llong
668     {
669       typedef long long                 __integral_type;
670       typedef atomic_llong              __base_type;
671
672       atomic() noexcept = default;
673       ~atomic() noexcept = default;
674       atomic(const atomic&) = delete;
675       atomic& operator=(const atomic&) = delete;
676       atomic& operator=(const atomic&) volatile = delete;
677
678       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
679
680       using __base_type::operator __integral_type;
681       using __base_type::operator=;
682     };
683
684   /// Explicit specialization for unsigned long long.
685   template<>
686     struct atomic<unsigned long long> : public atomic_ullong
687     {
688       typedef unsigned long long        __integral_type;
689       typedef atomic_ullong             __base_type;
690
691       atomic() noexcept = default;
692       ~atomic() noexcept = default;
693       atomic(const atomic&) = delete;
694       atomic& operator=(const atomic&) = delete;
695       atomic& operator=(const atomic&) volatile = delete;
696
697       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
698
699       using __base_type::operator __integral_type;
700       using __base_type::operator=;
701     };
702
703   /// Explicit specialization for wchar_t.
704   template<>
705     struct atomic<wchar_t> : public atomic_wchar_t
706     {
707       typedef wchar_t                   __integral_type;
708       typedef atomic_wchar_t            __base_type;
709
710       atomic() noexcept = default;
711       ~atomic() noexcept = default;
712       atomic(const atomic&) = delete;
713       atomic& operator=(const atomic&) = delete;
714       atomic& operator=(const atomic&) volatile = delete;
715
716       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
717
718       using __base_type::operator __integral_type;
719       using __base_type::operator=;
720     };
721
722   /// Explicit specialization for char16_t.
723   template<>
724     struct atomic<char16_t> : public atomic_char16_t
725     {
726       typedef char16_t                  __integral_type;
727       typedef atomic_char16_t           __base_type;
728
729       atomic() noexcept = default;
730       ~atomic() noexcept = default;
731       atomic(const atomic&) = delete;
732       atomic& operator=(const atomic&) = delete;
733       atomic& operator=(const atomic&) volatile = delete;
734
735       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
736
737       using __base_type::operator __integral_type;
738       using __base_type::operator=;
739     };
740
741   /// Explicit specialization for char32_t.
742   template<>
743     struct atomic<char32_t> : public atomic_char32_t
744     {
745       typedef char32_t                  __integral_type;
746       typedef atomic_char32_t           __base_type;
747
748       atomic() noexcept = default;
749       ~atomic() noexcept = default;
750       atomic(const atomic&) = delete;
751       atomic& operator=(const atomic&) = delete;
752       atomic& operator=(const atomic&) volatile = delete;
753
754       constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
755
756       using __base_type::operator __integral_type;
757       using __base_type::operator=;
758     };
759
760
761   // Function definitions, atomic_flag operations.
762   inline bool
763   atomic_flag_test_and_set_explicit(atomic_flag* __a,
764                                     memory_order __m) noexcept
765   { return __a->test_and_set(__m); }
766
767   inline bool
768   atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
769                                     memory_order __m) noexcept
770   { return __a->test_and_set(__m); }
771
772   inline void
773   atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
774   { __a->clear(__m); }
775
776   inline void
777   atomic_flag_clear_explicit(volatile atomic_flag* __a,
778                              memory_order __m) noexcept
779   { __a->clear(__m); }
780
781   inline bool
782   atomic_flag_test_and_set(atomic_flag* __a) noexcept
783   { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
784
785   inline bool
786   atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
787   { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
788
789   inline void
790   atomic_flag_clear(atomic_flag* __a) noexcept
791   { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
792
793   inline void
794   atomic_flag_clear(volatile atomic_flag* __a) noexcept
795   { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
796
797
798   // Function templates generally applicable to atomic types.
799   template<typename _ITp>
800     inline bool
801     atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
802     { return __a->is_lock_free(); }
803
804   template<typename _ITp>
805     inline bool
806     atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
807     { return __a->is_lock_free(); }
808
809   template<typename _ITp>
810     inline void
811     atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
812
813   template<typename _ITp>
814     inline void
815     atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept;
816
817   template<typename _ITp>
818     inline void
819     atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
820                           memory_order __m) noexcept
821     { __a->store(__i, __m); }
822
823   template<typename _ITp>
824     inline void
825     atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
826                           memory_order __m) noexcept
827     { __a->store(__i, __m); }
828
829   template<typename _ITp>
830     inline _ITp
831     atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
832     { return __a->load(__m); }
833
834   template<typename _ITp>
835     inline _ITp
836     atomic_load_explicit(const volatile atomic<_ITp>* __a,
837                          memory_order __m) noexcept
838     { return __a->load(__m); }
839
840   template<typename _ITp>
841     inline _ITp
842     atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
843                              memory_order __m) noexcept
844     { return __a->exchange(__i, __m); }
845
846   template<typename _ITp>
847     inline _ITp
848     atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
849                              memory_order __m) noexcept
850     { return __a->exchange(__i, __m); }
851
852   template<typename _ITp>
853     inline bool
854     atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
855                                           _ITp* __i1, _ITp __i2,
856                                           memory_order __m1,
857                                           memory_order __m2) noexcept
858     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
859
860   template<typename _ITp>
861     inline bool
862     atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
863                                           _ITp* __i1, _ITp __i2,
864                                           memory_order __m1,
865                                           memory_order __m2) noexcept
866     { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
867
868   template<typename _ITp>
869     inline bool
870     atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
871                                             _ITp* __i1, _ITp __i2,
872                                             memory_order __m1,
873                                             memory_order __m2) noexcept
874     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
875
876   template<typename _ITp>
877     inline bool
878     atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
879                                             _ITp* __i1, _ITp __i2,
880                                             memory_order __m1,
881                                             memory_order __m2) noexcept
882     { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
883
884
885   template<typename _ITp>
886     inline void
887     atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
888     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
889
890   template<typename _ITp>
891     inline void
892     atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
893     { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
894
895   template<typename _ITp>
896     inline _ITp
897     atomic_load(const atomic<_ITp>* __a) noexcept
898     { return atomic_load_explicit(__a, memory_order_seq_cst); }
899
900   template<typename _ITp>
901     inline _ITp
902     atomic_load(const volatile atomic<_ITp>* __a) noexcept
903     { return atomic_load_explicit(__a, memory_order_seq_cst); }
904
905   template<typename _ITp>
906     inline _ITp
907     atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
908     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
909
910   template<typename _ITp>
911     inline _ITp
912     atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
913     { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
914
915   template<typename _ITp>
916     inline bool
917     atomic_compare_exchange_weak(atomic<_ITp>* __a,
918                                  _ITp* __i1, _ITp __i2) noexcept
919     {
920       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
921                                                    memory_order_seq_cst,
922                                                    memory_order_seq_cst);
923     }
924
925   template<typename _ITp>
926     inline bool
927     atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
928                                  _ITp* __i1, _ITp __i2) noexcept
929     {
930       return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
931                                                    memory_order_seq_cst,
932                                                    memory_order_seq_cst);
933     }
934
935   template<typename _ITp>
936     inline bool
937     atomic_compare_exchange_strong(atomic<_ITp>* __a,
938                                    _ITp* __i1, _ITp __i2) noexcept
939     {
940       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
941                                                      memory_order_seq_cst,
942                                                      memory_order_seq_cst);
943     }
944
945   template<typename _ITp>
946     inline bool
947     atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
948                                    _ITp* __i1, _ITp __i2) noexcept
949     {
950       return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
951                                                      memory_order_seq_cst,
952                                                      memory_order_seq_cst);
953     }
954
955   // Function templates for atomic_integral operations only, using
956   // __atomic_base. Template argument should be constricted to
957   // intergral types as specified in the standard, excluding address
958   // types.
959   template<typename _ITp>
960     inline _ITp
961     atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
962                               memory_order __m) noexcept
963     { return __a->fetch_add(__i, __m); }
964
965   template<typename _ITp>
966     inline _ITp
967     atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
968                               memory_order __m) noexcept
969     { return __a->fetch_add(__i, __m); }
970
971   template<typename _ITp>
972     inline _ITp
973     atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
974                               memory_order __m) noexcept
975     { return __a->fetch_sub(__i, __m); }
976
977   template<typename _ITp>
978     inline _ITp
979     atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
980                               memory_order __m) noexcept
981     { return __a->fetch_sub(__i, __m); }
982
983   template<typename _ITp>
984     inline _ITp
985     atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
986                               memory_order __m) noexcept
987     { return __a->fetch_and(__i, __m); }
988
989   template<typename _ITp>
990     inline _ITp
991     atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
992                               memory_order __m) noexcept
993     { return __a->fetch_and(__i, __m); }
994
995   template<typename _ITp>
996     inline _ITp
997     atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
998                              memory_order __m) noexcept
999     { return __a->fetch_or(__i, __m); }
1000
1001   template<typename _ITp>
1002     inline _ITp
1003     atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1004                              memory_order __m) noexcept
1005     { return __a->fetch_or(__i, __m); }
1006
1007   template<typename _ITp>
1008     inline _ITp
1009     atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
1010                               memory_order __m) noexcept
1011     { return __a->fetch_xor(__i, __m); }
1012
1013   template<typename _ITp>
1014     inline _ITp
1015     atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
1016                               memory_order __m) noexcept
1017     { return __a->fetch_xor(__i, __m); }
1018
1019   template<typename _ITp>
1020     inline _ITp
1021     atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1022     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1023
1024   template<typename _ITp>
1025     inline _ITp
1026     atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1027     { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1028
1029   template<typename _ITp>
1030     inline _ITp
1031     atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1032     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1033
1034   template<typename _ITp>
1035     inline _ITp
1036     atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1037     { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1038
1039   template<typename _ITp>
1040     inline _ITp
1041     atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1042     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1043
1044   template<typename _ITp>
1045     inline _ITp
1046     atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1047     { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1048
1049   template<typename _ITp>
1050     inline _ITp
1051     atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1052     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1053
1054   template<typename _ITp>
1055     inline _ITp
1056     atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1057     { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1058
1059   template<typename _ITp>
1060     inline _ITp
1061     atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
1062     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1063
1064   template<typename _ITp>
1065     inline _ITp
1066     atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
1067     { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1068
1069
1070   // Partial specializations for pointers.
1071   template<typename _ITp>
1072     inline _ITp*
1073     atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1074                               memory_order __m) noexcept
1075     { return __a->fetch_add(__d, __m); }
1076
1077   template<typename _ITp>
1078     inline _ITp*
1079     atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
1080                               memory_order __m) noexcept
1081     { return __a->fetch_add(__d, __m); }
1082
1083   template<typename _ITp>
1084     inline _ITp*
1085     atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1086     { return __a->fetch_add(__d); }
1087
1088   template<typename _ITp>
1089     inline _ITp*
1090     atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1091     { return __a->fetch_add(__d); }
1092
1093   template<typename _ITp>
1094     inline _ITp*
1095     atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
1096                               ptrdiff_t __d, memory_order __m) noexcept
1097     { return __a->fetch_sub(__d, __m); }
1098
1099   template<typename _ITp>
1100     inline _ITp*
1101     atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
1102                               memory_order __m) noexcept
1103     { return __a->fetch_sub(__d, __m); }
1104
1105   template<typename _ITp>
1106     inline _ITp*
1107     atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1108     { return __a->fetch_sub(__d); }
1109
1110   template<typename _ITp>
1111     inline _ITp*
1112     atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
1113     { return __a->fetch_sub(__d); }
1114   // @} group atomics
1115
1116 _GLIBCXX_END_NAMESPACE_VERSION
1117 } // namespace
1118
1119 #endif