OSDN Git Service

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