OSDN Git Service

2008-04-10 Benjamin Kosnik <bkoz@redhat.com>
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / c_global / cstdatomic
1 // -*- C++ -*- header.
2
3 // Copyright (C) 2008
4 // Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library.  This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
10 // any later version.
11
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License
18 // along with this library; see the file COPYING.  If not, write to
19 // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 // Boston, MA 02110-1301, USA.
21
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction.  Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License.  This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 /** @file cstdatomic
32  *  This is a Standard C++ Library file.  You should @c #include this file
33  *  in your programs, rather than any of the "*.h" implementation files.
34  *
35  *  This is the C++ version of the Standard C Library header @c stdatomic.h,
36  *  and its contents are (mostly) the same as that header, but are all
37  *  contained in the namespace @c std (except for names which are defined
38  *  as macros in C).
39  */
40
41 // Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
42 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
43
44 #ifndef _GLIBCXX_STDATOMIC
45 #define _GLIBCXX_STDATOMIC 1
46
47 #pragma GCC system_header
48
49 #ifndef __GXX_EXPERIMENTAL_CXX0X__
50 # include <c++0x_warning.h>
51 #endif
52
53 #include <stdatomic.h>
54 #include <cstddef>
55
56 _GLIBCXX_BEGIN_NAMESPACE(std)
57
58   // Can either subclass or encapsulate "C" functionality, and here
59   // encapsulating works with C++2003's version of POD and so is
60   // portable across C++2003/200x. 
61   // Both end up being sub-optimal in terms of a constructor
62   // initialization list, but oh well.
63
64   /// atomic_flag
65   struct atomic_flag 
66   {
67     __atomic_flag_base _M_base;
68
69     bool 
70     test_and_set(memory_order __x = memory_order_seq_cst) volatile
71     { return atomic_flag_test_and_set_explicit(this, __x); }
72
73     void 
74     clear(memory_order __x = memory_order_seq_cst) volatile
75     { atomic_flag_clear_explicit(this, __x); }
76
77     void 
78     fence(memory_order __x) const volatile
79     { atomic_flag_fence(this, __x); }
80
81 #if _GLIBCXX_USE_STANDARD_LAYOUT
82     // Add in non-trivial default constructor that correctly
83     // initializes member "as if" by ATOMIC_FLAG_INIT.
84     atomic_flag() { _M_base._M_b = false; }
85
86   private:
87     atomic_flag(const atomic_flag&);
88     atomic_flag& operator=(const atomic_flag&);
89 #endif
90   };
91
92   /// 29.4.2, address types
93   typedef struct atomic_address
94   {
95     __atomic_address_base _M_base;
96
97     bool 
98     is_lock_free() const volatile;
99
100     void 
101     store(void*, memory_order = memory_order_seq_cst) volatile;
102
103     void* 
104     load(memory_order = memory_order_seq_cst) volatile;
105
106     void* 
107     swap(void*, memory_order = memory_order_seq_cst) volatile;
108
109     bool 
110     compare_swap(void*&, void*, memory_order, memory_order) volatile;
111
112     bool 
113     compare_swap(void*&, void*, memory_order = memory_order_seq_cst) volatile;
114
115     void 
116     fence(memory_order) const volatile;
117
118     void* 
119     fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
120
121     void* 
122     fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
123
124     void* 
125     operator=(void* __v) volatile
126     { store(__v); return __v; }
127
128     void* 
129     operator+=(ptrdiff_t __v) volatile
130     { return fetch_add(__v); }
131
132     void* 
133     operator-=(ptrdiff_t __v) volatile
134     { return fetch_sub(__v); }
135
136     friend void 
137     atomic_store_explicit(volatile atomic_address*, void*, memory_order);
138
139     friend void* 
140     atomic_load_explicit(volatile atomic_address*, memory_order);
141
142     friend void* 
143     atomic_swap_explicit(volatile atomic_address*, void*, memory_order);
144
145     friend bool 
146     atomic_compare_swap_explicit(volatile atomic_address*, void**, void*, 
147                                  memory_order, memory_order);
148
149     friend void 
150     atomic_fence(const volatile atomic_address*, memory_order);
151
152     friend void* 
153     atomic_fetch_add_explicit(volatile atomic_address*, ptrdiff_t, 
154                               memory_order);
155
156     friend void* 
157     atomic_fetch_sub_explicit(volatile atomic_address*, ptrdiff_t, 
158                               memory_order);
159
160     atomic_address() { }
161
162     explicit atomic_address(void* __v)
163     { _M_base._M_i = __v; }
164
165   private:
166     atomic_address(const atomic_address&);
167     atomic_address& operator=(const atomic_address &);
168   };
169
170
171   // 29.4.1 atomic integral types
172   // For each of the integral types, define atomic_[integral type] struct
173   // 
174   // atomic_bool     bool
175   // atomic_char     char
176   // atomic_schar    signed char
177   // atomic_uchar    unsigned char
178   // atomic_short    short
179   // atomic_ushort   unsigned short
180   // atomic_int      int
181   // atomic_uint     unsigned int
182   // atomic_long     long
183   // atomic_ulong    unsigned long
184   // atomic_llong    long long
185   // atomic_ullong   unsigned long long
186   // atomic_char16_t char16_t
187   // atomic_char32_t char32_t
188   // atomic_wchar_t  wchar_t
189
190   /// atomic_bool
191   struct atomic_bool
192   {
193     __atomic_bool_base _M_base;
194
195     bool 
196     is_lock_free() const volatile;
197
198     void 
199     store(bool, memory_order = memory_order_seq_cst) volatile;
200
201     bool 
202     load(memory_order = memory_order_seq_cst) volatile;
203
204     bool 
205     swap(bool, memory_order = memory_order_seq_cst) volatile;
206
207     bool 
208     compare_swap(bool&, bool, memory_order, memory_order) volatile;
209
210     bool 
211     compare_swap(bool&, bool, memory_order = memory_order_seq_cst) volatile;
212
213     void 
214     fence(memory_order) const volatile;
215
216     bool
217     operator=(bool __v) volatile { store(__v); return __v; }
218
219     friend void 
220     atomic_store_explicit(volatile atomic_bool*, bool, memory_order);
221
222     friend bool 
223     atomic_load_explicit(volatile atomic_bool*, memory_order);
224
225     friend bool 
226     atomic_swap_explicit(volatile atomic_bool*, bool, memory_order);
227
228     friend bool 
229     atomic_compare_swap_explicit(volatile atomic_bool*, bool*, bool,
230                                  memory_order, memory_order);
231     friend void 
232     atomic_fence(const volatile atomic_bool*, memory_order);
233
234     atomic_bool() { }
235
236     explicit atomic_bool(bool __v) { _M_base._M_i = __v; }
237
238   private:
239     atomic_bool(const atomic_bool&);
240     atomic_bool& operator=(const atomic_bool&);
241   };
242
243   /// atomic_char
244   struct atomic_char
245   {
246     __atomic_char_base _M_base;
247
248     bool 
249     is_lock_free() const volatile;
250
251     void 
252     store(char, memory_order = memory_order_seq_cst) volatile;
253
254     char 
255     load(memory_order = memory_order_seq_cst) volatile;
256
257     char 
258     swap(char, memory_order = memory_order_seq_cst) volatile;
259
260     bool 
261     compare_swap(char&, char, memory_order, memory_order) volatile;
262
263     bool 
264     compare_swap(char&, char, memory_order = memory_order_seq_cst) volatile;
265
266     void 
267     fence(memory_order) const volatile;
268
269     char 
270     fetch_add(char, memory_order = memory_order_seq_cst) volatile;
271
272     char 
273     fetch_sub(char, memory_order = memory_order_seq_cst) volatile;
274
275     char 
276     fetch_and(char, memory_order = memory_order_seq_cst) volatile;
277
278     char 
279     fetch_or(char, memory_order = memory_order_seq_cst) volatile;
280
281     char 
282     fetch_xor(char, memory_order = memory_order_seq_cst) volatile;
283
284     char 
285     operator=(char __v) volatile { store(__v); return __v; }
286
287     char 
288     operator++(int) volatile { return fetch_add(1); }
289
290     char 
291     operator--(int) volatile { return fetch_sub(1); }
292
293     char 
294     operator++() volatile { return fetch_add(1) + 1; }
295
296     char 
297     operator--() volatile { return fetch_sub(1) - 1; }
298
299     char 
300     operator+=(char __v) volatile { return fetch_add(__v) + __v; }
301
302     char 
303     operator-=(char __v) volatile { return fetch_sub(__v) - __v; }
304
305     char 
306     operator&=(char __v) volatile { return fetch_and(__v) & __v; }
307
308     char 
309     operator|=(char __v) volatile { return fetch_or(__v) | __v; }
310
311     char 
312     operator^=(char __v) volatile { return fetch_xor(__v) ^ __v; }
313
314     friend void 
315     atomic_store_explicit(volatile atomic_char*, char, memory_order);
316
317     friend char 
318     atomic_load_explicit(volatile atomic_char*, memory_order);
319
320     friend char 
321     atomic_swap_explicit(volatile atomic_char*, char, memory_order);
322
323     friend bool 
324     atomic_compare_swap_explicit(volatile atomic_char*, char*, char, 
325                                  memory_order, memory_order);
326
327     friend void 
328     atomic_fence(const volatile atomic_char*, memory_order);
329
330     friend char 
331     atomic_fetch_add_explicit(volatile atomic_char*, char, memory_order);
332
333     friend char 
334     atomic_fetch_sub_explicit(volatile atomic_char*, char, memory_order);
335
336     friend char 
337     atomic_fetch_and_explicit(volatile atomic_char*, char, memory_order);
338
339     friend char 
340     atomic_fetch_or_explicit( volatile atomic_char*, char, memory_order);
341
342     friend char 
343     atomic_fetch_xor_explicit(volatile atomic_char*, char, memory_order);
344
345     atomic_char() { }
346
347     atomic_char(char __v) { _M_base._M_i = __v; }
348
349   private:
350     atomic_char(const atomic_char&);
351     atomic_char& operator=(const atomic_char&);
352   };
353
354   /// atomic_schar
355   struct atomic_schar
356   {
357     __atomic_schar_base _M_base;
358
359     bool 
360     is_lock_free() const volatile;
361
362     void 
363     store(signed char, memory_order = memory_order_seq_cst) volatile;
364
365     signed char 
366     load(memory_order = memory_order_seq_cst) volatile;
367
368     signed char 
369     swap(signed char, memory_order = memory_order_seq_cst) volatile;
370
371     bool 
372     compare_swap(signed char&, signed char, memory_order, 
373                  memory_order) volatile;
374
375     bool 
376     compare_swap(signed char&, signed char, 
377                  memory_order = memory_order_seq_cst) volatile;
378
379     void 
380     fence(memory_order) const volatile;
381
382     signed char 
383     fetch_add(signed char, memory_order = memory_order_seq_cst) volatile;
384
385     signed char 
386     fetch_sub(signed char, memory_order = memory_order_seq_cst) volatile;
387
388     signed char 
389     fetch_and(signed char, memory_order = memory_order_seq_cst) volatile;
390
391     signed char 
392     fetch_or(signed char, memory_order = memory_order_seq_cst) volatile;
393
394     signed char 
395     fetch_xor(signed char, memory_order = memory_order_seq_cst) volatile;
396
397     signed char 
398     operator=(signed char __v) volatile { store(__v); return __v; }
399
400     signed char 
401     operator++(int) volatile { return fetch_add(1); }
402
403     signed char 
404     operator--(int) volatile { return fetch_sub(1); }
405
406     signed char 
407     operator++() volatile { return fetch_add(1) + 1; }
408
409     signed char 
410     operator--() volatile { return fetch_sub(1) - 1; }
411
412     signed char 
413     operator+=(signed char __v) volatile { return fetch_add(__v) + __v; }
414
415     signed char 
416     operator-=(signed char __v) volatile { return fetch_sub(__v) - __v; }
417
418     signed char 
419     operator&=(signed char __v) volatile { return fetch_and(__v) & __v; }
420
421     signed char 
422     operator|=(signed char __v) volatile { return fetch_or(__v) | __v; }
423
424     signed char 
425     operator^=(signed char __v) volatile { return fetch_xor(__v) ^ __v; }
426
427     friend void 
428     atomic_store_explicit(volatile atomic_schar*, signed char, memory_order);
429
430     friend signed char 
431     atomic_load_explicit(volatile atomic_schar*, memory_order);
432
433     friend signed char 
434     atomic_swap_explicit(volatile atomic_schar*, signed char, memory_order);
435
436     friend bool 
437     atomic_compare_swap_explicit(volatile atomic_schar*, signed char*, 
438                                  signed char, memory_order, memory_order);
439
440     friend void 
441     atomic_fence(const volatile atomic_schar*, memory_order);
442
443     friend signed char 
444     atomic_fetch_add_explicit(volatile atomic_schar*, 
445                               signed char, memory_order);
446
447     friend signed char 
448     atomic_fetch_sub_explicit(volatile atomic_schar*, signed char, 
449                               memory_order);
450
451     friend signed char 
452     atomic_fetch_and_explicit(volatile atomic_schar*, signed char, 
453                               memory_order);
454
455     friend signed char 
456     atomic_fetch_or_explicit(volatile atomic_schar*, signed char, 
457                               memory_order);
458
459     friend signed char 
460     atomic_fetch_xor_explicit(volatile atomic_schar*, signed char, 
461                               memory_order);
462
463     atomic_schar() { }
464
465     atomic_schar(signed char __v) { _M_base._M_i = __v; }
466
467   private:
468     atomic_schar(const atomic_schar&);
469     atomic_schar& operator=(const atomic_schar&);
470   };
471
472   /// atomic_uchar
473   struct atomic_uchar
474   {
475     __atomic_uchar_base _M_base;
476
477     bool 
478     is_lock_free() const volatile;
479
480     void 
481     store(unsigned char, memory_order = memory_order_seq_cst) volatile;
482
483     unsigned char 
484     load(memory_order = memory_order_seq_cst) volatile;
485
486     unsigned char 
487     swap(unsigned char, memory_order = memory_order_seq_cst) volatile;
488
489     bool 
490     compare_swap(unsigned char&, unsigned char, memory_order, 
491                  memory_order) volatile;
492
493     bool 
494     compare_swap(unsigned char&, unsigned char, 
495                  memory_order = memory_order_seq_cst) volatile;
496
497     void 
498     fence(memory_order) const volatile;
499
500     unsigned char 
501     fetch_add(unsigned char, memory_order = memory_order_seq_cst) volatile;
502
503     unsigned char 
504     fetch_sub(unsigned char, memory_order = memory_order_seq_cst) volatile;
505
506     unsigned char 
507     fetch_and(unsigned char, memory_order = memory_order_seq_cst) volatile;
508
509     unsigned char 
510     fetch_or(unsigned char, memory_order = memory_order_seq_cst) volatile;
511
512     unsigned char 
513     fetch_xor(unsigned char, memory_order = memory_order_seq_cst) volatile;
514
515     unsigned char 
516     operator=(unsigned char __v) volatile { store(__v); return __v; }
517
518     unsigned char 
519     operator++(int) volatile { return fetch_add(1); }
520
521     unsigned char 
522     operator--(int) volatile { return fetch_sub(1); }
523
524     unsigned char 
525     operator++() volatile { return fetch_add(1) + 1; }
526
527     unsigned char 
528     operator--() volatile { return fetch_sub(1) - 1; }
529
530     unsigned char 
531     operator+=(unsigned char __v) volatile { return fetch_add(__v) + __v; }
532
533     unsigned char 
534     operator-=(unsigned char __v) volatile { return fetch_sub(__v) - __v; }
535
536     unsigned char 
537     operator&=(unsigned char __v) volatile { return fetch_and(__v) & __v; }
538
539     unsigned char 
540     operator|=(unsigned char __v) volatile { return fetch_or(__v) | __v; }
541
542     unsigned char 
543     operator^=(unsigned char __v) volatile { return fetch_xor(__v) ^ __v; }
544
545     friend void 
546     atomic_store_explicit(volatile atomic_uchar*, unsigned char, memory_order);
547
548     friend unsigned char 
549     atomic_load_explicit(volatile atomic_uchar*, memory_order);
550
551     friend unsigned char 
552     atomic_swap_explicit(volatile atomic_uchar*, unsigned char, memory_order);
553
554     friend bool 
555     atomic_compare_swap_explicit(volatile atomic_uchar*, unsigned char*, 
556                                  unsigned char, memory_order, memory_order);
557
558     friend void 
559     atomic_fence(const volatile atomic_uchar*, memory_order);
560
561     friend unsigned char 
562     atomic_fetch_add_explicit(volatile atomic_uchar*, unsigned char, 
563                               memory_order);
564
565     friend unsigned char 
566     atomic_fetch_sub_explicit(volatile atomic_uchar*, unsigned char, 
567                               memory_order);
568
569     friend unsigned char 
570     atomic_fetch_and_explicit(volatile atomic_uchar*, 
571                               unsigned char, memory_order);
572
573     friend unsigned char 
574     atomic_fetch_or_explicit( volatile atomic_uchar*, unsigned char, 
575                               memory_order);
576
577     friend unsigned char 
578     atomic_fetch_xor_explicit(volatile atomic_uchar*, unsigned char, 
579                               memory_order);
580
581     atomic_uchar() { }
582
583     atomic_uchar(unsigned char __v) { _M_base._M_i = __v; }
584
585   private:
586     atomic_uchar(const atomic_uchar&);
587     atomic_uchar& operator=(const atomic_uchar&);
588   };
589
590
591   /// atomic_short
592   struct atomic_short
593   {
594     __atomic_short_base _M_base;
595
596     bool 
597     is_lock_free() const volatile;
598
599     void 
600     store(short, memory_order = memory_order_seq_cst) volatile;
601
602     short 
603     load(memory_order = memory_order_seq_cst) volatile;
604
605     short 
606     swap(short, memory_order = memory_order_seq_cst) volatile;
607
608     bool 
609     compare_swap(short&, short, memory_order, memory_order) volatile;
610
611     bool 
612     compare_swap(short&, short, memory_order = memory_order_seq_cst) volatile;
613
614     void 
615     fence(memory_order) const volatile;
616     
617     short 
618     fetch_add(short, memory_order = memory_order_seq_cst) volatile;
619
620     short 
621     fetch_sub(short, memory_order = memory_order_seq_cst) volatile;
622
623     short 
624     fetch_and(short, memory_order = memory_order_seq_cst) volatile;
625
626     short 
627     fetch_or(short, memory_order = memory_order_seq_cst) volatile;
628
629     short 
630     fetch_xor(short, memory_order = memory_order_seq_cst) volatile;
631
632     short 
633     operator=(short __v) volatile { store(__v); return __v; }
634
635     short 
636     operator++(int) volatile { return fetch_add(1); }
637
638     short 
639     operator--(int) volatile { return fetch_sub(1); }
640
641     short 
642     operator++() volatile { return fetch_add(1) + 1; }
643
644     short 
645     operator--() volatile { return fetch_sub(1) - 1; }
646
647     short 
648     operator+=(short __v) volatile { return fetch_add(__v) + __v; }
649
650     short 
651     operator-=(short __v) volatile { return fetch_sub(__v) - __v; }
652
653     short 
654     operator&=(short __v) volatile { return fetch_and(__v) & __v; }
655
656     short 
657     operator|=(short __v) volatile { return fetch_or(__v) | __v; }
658
659     short 
660     operator^=(short __v) volatile { return fetch_xor(__v) ^ __v; }
661
662     friend void 
663     atomic_store_explicit(volatile atomic_short*, short, memory_order);
664
665     friend short 
666     atomic_load_explicit(volatile atomic_short*, memory_order);
667
668     friend short 
669     atomic_swap_explicit(volatile atomic_short*, short, memory_order);
670
671     friend bool 
672     atomic_compare_swap_explicit(volatile atomic_short*, short*, short, 
673                                  memory_order, memory_order);
674
675     friend void 
676     atomic_fence(const volatile atomic_short*, memory_order);
677
678     friend short 
679     atomic_fetch_add_explicit(volatile atomic_short*, short, memory_order);
680
681     friend short 
682     atomic_fetch_sub_explicit(volatile atomic_short*, short, memory_order);
683
684     friend short 
685     atomic_fetch_and_explicit(volatile atomic_short*, short, memory_order);
686
687     friend short 
688     atomic_fetch_or_explicit( volatile atomic_short*, short, memory_order);
689
690     friend short 
691     atomic_fetch_xor_explicit(volatile atomic_short*, short, memory_order);
692
693     atomic_short() { }
694
695     atomic_short(short __v) { _M_base._M_i = __v; }
696
697   private:
698     atomic_short(const atomic_short&);
699     atomic_short& operator=(const atomic_short&);
700   };
701
702   /// atomic_ushort
703   struct atomic_ushort
704   {
705     __atomic_ushort_base _M_base;
706
707     bool 
708     is_lock_free() const volatile;
709
710     void 
711     store(unsigned short, memory_order = memory_order_seq_cst) volatile;
712
713     unsigned short 
714     load(memory_order = memory_order_seq_cst) volatile;
715
716     unsigned short 
717     swap(unsigned short, memory_order = memory_order_seq_cst) volatile;
718
719     bool 
720     compare_swap(unsigned short&, unsigned short, memory_order, 
721                  memory_order) volatile;
722
723     bool 
724     compare_swap(unsigned short&, unsigned short, 
725                  memory_order = memory_order_seq_cst) volatile;
726
727     void 
728     fence(memory_order) const volatile;
729
730     unsigned short 
731     fetch_add(unsigned short, memory_order = memory_order_seq_cst) volatile;
732
733     unsigned short 
734     fetch_sub(unsigned short, memory_order = memory_order_seq_cst) volatile;
735
736     unsigned short 
737     fetch_and(unsigned short, memory_order = memory_order_seq_cst) volatile;
738
739     unsigned short 
740     fetch_or(unsigned short, memory_order = memory_order_seq_cst) volatile;
741
742     unsigned short 
743     fetch_xor(unsigned short, memory_order = memory_order_seq_cst) volatile;
744
745     unsigned short 
746     operator=(unsigned short __v) volatile { store(__v); return __v; }
747
748     unsigned short 
749     operator++(int) volatile { return fetch_add(1); }
750
751     unsigned short 
752     operator--(int) volatile { return fetch_sub(1); }
753
754     unsigned short 
755     operator++() volatile { return fetch_add(1) + 1; }
756
757     unsigned short 
758     operator--() volatile { return fetch_sub(1) - 1; }
759
760     unsigned short 
761     operator+=(unsigned short __v) volatile { return fetch_add(__v) + __v; }
762
763     unsigned short 
764     operator-=(unsigned short __v) volatile { return fetch_sub(__v) - __v; }
765
766     unsigned short 
767     operator&=(unsigned short __v) volatile { return fetch_and(__v) & __v; }
768
769     unsigned short 
770     operator|=(unsigned short __v) volatile { return fetch_or(__v) | __v; }
771
772     unsigned short 
773     operator^=(unsigned short __v) volatile { return fetch_xor(__v) ^ __v; }
774
775     friend void 
776     atomic_store_explicit(volatile atomic_ushort*, unsigned short, 
777                           memory_order);
778
779     friend unsigned short 
780     atomic_load_explicit(volatile atomic_ushort*, memory_order);
781
782     friend unsigned short 
783     atomic_swap_explicit(volatile atomic_ushort*, unsigned short, memory_order);
784
785     friend bool 
786     atomic_compare_swap_explicit(volatile atomic_ushort*, unsigned short*, 
787                                  unsigned short, memory_order, memory_order);
788
789     friend void 
790     atomic_fence(const volatile atomic_ushort*, memory_order);
791
792     friend unsigned short 
793     atomic_fetch_add_explicit(volatile atomic_ushort*, unsigned short, 
794                               memory_order);
795
796     friend unsigned short 
797     atomic_fetch_sub_explicit(volatile atomic_ushort*, unsigned short, 
798                               memory_order);
799
800     friend unsigned short 
801     atomic_fetch_and_explicit(volatile atomic_ushort*, unsigned short, 
802                               memory_order);
803
804     friend unsigned short 
805     atomic_fetch_or_explicit( volatile atomic_ushort*, unsigned short, 
806                               memory_order);
807
808     friend unsigned short 
809     atomic_fetch_xor_explicit(volatile atomic_ushort*, unsigned short, 
810                               memory_order);
811
812     atomic_ushort() { }
813
814     atomic_ushort(unsigned short __v) { _M_base._M_i = __v; }
815
816   private:
817     atomic_ushort(const atomic_ushort&);
818     atomic_ushort& operator=(const atomic_ushort&);
819   };
820
821   /// atomic_int
822   struct atomic_int
823   {
824     __atomic_int_base _M_base;
825
826     bool 
827     is_lock_free() const volatile;
828
829     void 
830     store(int, memory_order = memory_order_seq_cst) volatile;
831
832     int 
833     load(memory_order = memory_order_seq_cst) volatile;
834
835     int 
836     swap(int, memory_order = memory_order_seq_cst) volatile;
837
838     bool 
839     compare_swap(int&, int, memory_order, memory_order) volatile;
840
841     bool 
842     compare_swap(int&, int, memory_order = memory_order_seq_cst) volatile;
843
844     void 
845     fence(memory_order) const volatile;
846
847     int 
848     fetch_add(int, memory_order = memory_order_seq_cst) volatile;
849
850     int 
851     fetch_sub(int, memory_order = memory_order_seq_cst) volatile;
852
853     int 
854     fetch_and(int, memory_order = memory_order_seq_cst) volatile;
855
856     int 
857     fetch_or(int, memory_order = memory_order_seq_cst) volatile;
858
859     int 
860     fetch_xor(int, memory_order = memory_order_seq_cst) volatile;
861
862     int 
863     operator=(int __v) volatile { store(__v); return __v; }
864
865     int 
866     operator++(int) volatile { return fetch_add(1); }
867
868     int 
869     operator--(int) volatile { return fetch_sub(1); }
870
871     int 
872     operator++() volatile { return fetch_add(1) + 1; }
873
874     int 
875     operator--() volatile { return fetch_sub(1) - 1; }
876
877     int 
878     operator+=(int __v) volatile { return fetch_add(__v) + __v; }
879
880     int 
881     operator-=(int __v) volatile { return fetch_sub(__v) - __v; }
882
883     int 
884     operator&=(int __v) volatile { return fetch_and(__v) & __v; }
885
886     int 
887     operator|=(int __v) volatile { return fetch_or(__v) | __v; }
888
889     int 
890     operator^=(int __v) volatile { return fetch_xor(__v) ^ __v; }
891
892     friend void 
893     atomic_store_explicit(volatile atomic_int*, int, memory_order);
894
895     friend int 
896     atomic_load_explicit(volatile atomic_int*, memory_order);
897
898     friend int 
899     atomic_swap_explicit(volatile atomic_int*, int, memory_order);
900
901     friend bool 
902     atomic_compare_swap_explicit(volatile atomic_int*, int*, int, 
903                                  memory_order, memory_order);
904
905     friend void 
906     atomic_fence(const volatile atomic_int*, memory_order);
907
908     friend int 
909     atomic_fetch_add_explicit(volatile atomic_int*, int, memory_order);
910
911     friend int 
912     atomic_fetch_sub_explicit(volatile atomic_int*, int, memory_order);
913
914     friend int 
915     atomic_fetch_and_explicit(volatile atomic_int*, int, memory_order);
916
917     friend int 
918     atomic_fetch_or_explicit( volatile atomic_int*, int, memory_order);
919
920     friend int 
921     atomic_fetch_xor_explicit(volatile atomic_int*, int, memory_order);
922
923     atomic_int() { }
924
925     atomic_int(int __v) { _M_base._M_i = __v; }
926     
927   private:
928     atomic_int(const atomic_int&);
929     atomic_int& operator=(const atomic_int&);
930   };
931
932   /// atomic_uint
933   struct atomic_uint
934   {
935     __atomic_uint_base _M_base;
936
937     bool 
938     is_lock_free() const volatile;
939
940     void 
941     store(unsigned int, memory_order = memory_order_seq_cst) volatile;
942
943     unsigned int 
944     load(memory_order = memory_order_seq_cst) volatile;
945
946     unsigned int 
947     swap(unsigned int, memory_order = memory_order_seq_cst) volatile;
948
949     bool 
950     compare_swap(unsigned int&, unsigned int, memory_order, 
951                  memory_order) volatile;
952
953     bool 
954     compare_swap(unsigned int&, unsigned int, 
955                  memory_order = memory_order_seq_cst) volatile;
956
957     void 
958     fence(memory_order) const volatile;
959
960     unsigned int 
961     fetch_add(unsigned int, memory_order = memory_order_seq_cst) volatile;
962
963     unsigned int 
964     fetch_sub(unsigned int, memory_order = memory_order_seq_cst) volatile;
965
966     unsigned int 
967     fetch_and(unsigned int, memory_order = memory_order_seq_cst) volatile;
968  
969     unsigned int 
970     fetch_or(unsigned int, memory_order = memory_order_seq_cst) volatile;
971
972     unsigned int 
973     fetch_xor(unsigned int, memory_order = memory_order_seq_cst) volatile;
974
975     unsigned int 
976     operator=(unsigned int __v) volatile { store(__v); return __v; }
977
978     unsigned int 
979     operator++(int) volatile { return fetch_add(1); }
980
981     unsigned int 
982     operator--(int) volatile { return fetch_sub(1); }
983
984     unsigned int 
985     operator++() volatile { return fetch_add(1) + 1; }
986
987     unsigned int 
988     operator--() volatile { return fetch_sub(1) - 1; }
989
990     unsigned int 
991     operator+=(unsigned int __v) volatile { return fetch_add(__v) + __v; }
992
993     unsigned int 
994     operator-=(unsigned int __v) volatile { return fetch_sub(__v) - __v; }
995
996     unsigned int 
997     operator&=(unsigned int __v) volatile { return fetch_and(__v) & __v; }
998
999     unsigned int 
1000     operator|=(unsigned int __v) volatile { return fetch_or(__v) | __v; }
1001
1002     unsigned int 
1003     operator^=(unsigned int __v) volatile { return fetch_xor(__v) ^ __v; }
1004
1005     friend void 
1006     atomic_store_explicit(volatile atomic_uint*, unsigned int, memory_order);
1007
1008     friend unsigned int 
1009     atomic_load_explicit(volatile atomic_uint*, memory_order);
1010
1011     friend unsigned int 
1012     atomic_swap_explicit(volatile atomic_uint*, unsigned int, memory_order);
1013
1014     friend bool 
1015     atomic_compare_swap_explicit(volatile atomic_uint*, unsigned int*, 
1016                                  unsigned int, memory_order, memory_order);
1017
1018     friend void 
1019     atomic_fence(const volatile atomic_uint*, memory_order);
1020
1021     friend unsigned int 
1022     atomic_fetch_add_explicit(volatile atomic_uint*, unsigned int, 
1023                               memory_order);
1024
1025     friend unsigned int 
1026     atomic_fetch_sub_explicit(volatile atomic_uint*, unsigned int, 
1027                               memory_order);
1028
1029     friend unsigned int 
1030     atomic_fetch_and_explicit(volatile atomic_uint*, unsigned int, 
1031                               memory_order);
1032
1033     friend unsigned int 
1034     atomic_fetch_or_explicit( volatile atomic_uint*, unsigned int, 
1035                               memory_order);
1036
1037     friend unsigned int 
1038     atomic_fetch_xor_explicit(volatile atomic_uint*, unsigned int, 
1039                               memory_order);
1040
1041     atomic_uint() { }
1042
1043     atomic_uint(unsigned int __v) { _M_base._M_i = __v; }
1044
1045   private:
1046     atomic_uint(const atomic_uint&);
1047     atomic_uint& operator=(const atomic_uint&);
1048   };
1049
1050   /// atomic_long
1051   struct atomic_long
1052   {
1053     __atomic_long_base _M_base;
1054
1055     bool 
1056     is_lock_free() const volatile;
1057
1058     void 
1059     store(long, memory_order = memory_order_seq_cst) volatile;
1060
1061     long 
1062     load(memory_order = memory_order_seq_cst) volatile;
1063     
1064     long 
1065     swap(long, memory_order = memory_order_seq_cst) volatile;
1066
1067     bool 
1068     compare_swap(long&, long, memory_order, memory_order) volatile;
1069
1070     bool 
1071     compare_swap(long&, long, memory_order = memory_order_seq_cst) volatile;
1072
1073     void 
1074     fence(memory_order) const volatile;
1075
1076     long 
1077     fetch_add(long, memory_order = memory_order_seq_cst) volatile;
1078
1079     long 
1080     fetch_sub(long, memory_order = memory_order_seq_cst) volatile;
1081
1082     long 
1083     fetch_and(long, memory_order = memory_order_seq_cst) volatile;
1084
1085     long 
1086     fetch_or(long, memory_order = memory_order_seq_cst) volatile;
1087
1088     long 
1089     fetch_xor(long, memory_order = memory_order_seq_cst) volatile;
1090
1091     long 
1092     operator=(long __v) volatile { store(__v); return __v; }
1093
1094     long 
1095     operator++(int) volatile { return fetch_add(1); }
1096
1097     long 
1098     operator--(int) volatile { return fetch_sub(1); }
1099
1100     long 
1101     operator++() volatile { return fetch_add(1) + 1; }
1102
1103     long 
1104     operator--() volatile { return fetch_sub(1) - 1; }
1105
1106     long 
1107     operator+=(long __v) volatile { return fetch_add(__v) + __v; }
1108
1109     long 
1110     operator-=(long __v) volatile { return fetch_sub(__v) - __v; }
1111
1112     long 
1113     operator&=(long __v) volatile { return fetch_and(__v) & __v; }
1114
1115     long 
1116     operator|=(long __v) volatile { return fetch_or(__v) | __v; }
1117
1118     long 
1119     operator^=(long __v) volatile { return fetch_xor(__v) ^ __v; }
1120
1121     friend void 
1122     atomic_store_explicit(volatile atomic_long*, long, memory_order);
1123
1124     friend long 
1125     atomic_load_explicit(volatile atomic_long*, memory_order);
1126
1127     friend long 
1128     atomic_swap_explicit(volatile atomic_long*, long, memory_order);
1129
1130     friend bool 
1131     atomic_compare_swap_explicit(volatile atomic_long*, long*, long, 
1132                                  memory_order, memory_order);
1133
1134     friend void 
1135     atomic_fence(const volatile atomic_long*, memory_order);
1136
1137     friend long 
1138     atomic_fetch_add_explicit(volatile atomic_long*, long, memory_order);
1139
1140     friend long 
1141     atomic_fetch_sub_explicit(volatile atomic_long*, long, memory_order);
1142
1143     friend long 
1144     atomic_fetch_and_explicit(volatile atomic_long*, long, memory_order);
1145
1146     friend long 
1147     atomic_fetch_or_explicit( volatile atomic_long*, long, memory_order);
1148
1149     friend long 
1150     atomic_fetch_xor_explicit(volatile atomic_long*, long, memory_order);
1151
1152     atomic_long() { }
1153
1154     atomic_long(long __v) { _M_base._M_i = __v; }
1155
1156   private:
1157     atomic_long(const atomic_long&);
1158     atomic_long& operator=(const atomic_long&);
1159   };
1160
1161   /// atomic_ulong
1162   struct atomic_ulong
1163   {
1164     __atomic_ulong_base _M_base;
1165
1166     bool 
1167     is_lock_free() const volatile;
1168
1169     void 
1170     store(unsigned long, memory_order = memory_order_seq_cst) volatile;
1171
1172     unsigned long 
1173     load(memory_order = memory_order_seq_cst) volatile;
1174
1175     unsigned long 
1176     swap(unsigned long, memory_order = memory_order_seq_cst) volatile;
1177
1178     bool 
1179     compare_swap(unsigned long&, unsigned long, memory_order, 
1180                  memory_order) volatile;
1181
1182     bool 
1183     compare_swap(unsigned long&, unsigned long, 
1184                  memory_order = memory_order_seq_cst) volatile;
1185
1186     void 
1187     fence(memory_order) const volatile;
1188
1189     unsigned long 
1190     fetch_add(unsigned long, memory_order = memory_order_seq_cst) volatile;
1191
1192     unsigned long 
1193     fetch_sub(unsigned long, memory_order = memory_order_seq_cst) volatile;
1194
1195     unsigned long 
1196     fetch_and(unsigned long, memory_order = memory_order_seq_cst) volatile;
1197
1198     unsigned long 
1199     fetch_or(unsigned long, memory_order = memory_order_seq_cst) volatile;
1200
1201     unsigned long 
1202     fetch_xor(unsigned long, memory_order = memory_order_seq_cst) volatile;
1203
1204     unsigned long 
1205     operator=(unsigned long __v) volatile { store(__v); return __v; }
1206
1207     unsigned long 
1208     operator++(int) volatile { return fetch_add(1); }
1209
1210     unsigned long 
1211     operator--(int) volatile { return fetch_sub(1); }
1212
1213     unsigned long 
1214     operator++() volatile { return fetch_add(1) + 1; }
1215
1216     unsigned long 
1217     operator--() volatile { return fetch_sub(1) - 1; }
1218
1219     unsigned long 
1220     operator+=(unsigned long __v) volatile { return fetch_add(__v) + __v; }
1221
1222     unsigned long 
1223     operator-=(unsigned long __v) volatile { return fetch_sub(__v) - __v; }
1224
1225     unsigned long 
1226     operator&=(unsigned long __v) volatile { return fetch_and(__v) & __v; }
1227
1228     unsigned long 
1229     operator|=(unsigned long __v) volatile { return fetch_or(__v) | __v; }
1230
1231     unsigned long 
1232     operator^=(unsigned long __v) volatile { return fetch_xor(__v) ^ __v; }
1233
1234     friend void 
1235     atomic_store_explicit(volatile atomic_ulong*, unsigned long, memory_order);
1236
1237     friend unsigned long 
1238     atomic_load_explicit(volatile atomic_ulong*, memory_order);
1239
1240     friend unsigned long 
1241     atomic_swap_explicit(volatile atomic_ulong*, unsigned long, memory_order);
1242
1243     friend bool 
1244     atomic_compare_swap_explicit(volatile atomic_ulong*, unsigned long*, 
1245                                  unsigned long, memory_order, memory_order);
1246
1247     friend void 
1248     atomic_fence(const volatile atomic_ulong*, memory_order);
1249
1250     friend unsigned long 
1251     atomic_fetch_add_explicit(volatile atomic_ulong*, unsigned long, 
1252                               memory_order);
1253
1254     friend unsigned long 
1255     atomic_fetch_sub_explicit(volatile atomic_ulong*, unsigned long, 
1256                               memory_order);
1257
1258     friend unsigned long 
1259     atomic_fetch_and_explicit(volatile atomic_ulong*, unsigned long, 
1260                               memory_order);
1261     friend unsigned long 
1262     atomic_fetch_or_explicit(volatile atomic_ulong*, unsigned long, 
1263                              memory_order);
1264
1265     friend unsigned long 
1266     atomic_fetch_xor_explicit(volatile atomic_ulong*, unsigned long, 
1267                               memory_order);
1268
1269     atomic_ulong() { }
1270
1271     atomic_ulong(unsigned long __v) { _M_base._M_i = __v; }
1272
1273   private:
1274     atomic_ulong(const atomic_ulong&);
1275     atomic_ulong& operator=(const atomic_ulong&);
1276   };
1277
1278   /// atomic_llong
1279   struct atomic_llong
1280   {
1281     __atomic_llong_base _M_base;
1282
1283     bool 
1284     is_lock_free() const volatile;
1285
1286     void 
1287     store(long long, memory_order = memory_order_seq_cst) volatile;
1288
1289     long long 
1290     load(memory_order = memory_order_seq_cst) volatile;
1291
1292     long long 
1293     swap(long long, memory_order = memory_order_seq_cst) volatile;
1294
1295     bool 
1296     compare_swap(long long&, long long, memory_order, memory_order) volatile;
1297
1298     bool 
1299     compare_swap(long long&, long long, 
1300                  memory_order = memory_order_seq_cst) volatile;
1301
1302     void 
1303     fence(memory_order) const volatile;
1304
1305     long long 
1306     fetch_add(long long, memory_order = memory_order_seq_cst) volatile;
1307
1308     long long 
1309     fetch_sub(long long, memory_order = memory_order_seq_cst) volatile;
1310
1311     long long 
1312     fetch_and(long long, memory_order = memory_order_seq_cst) volatile;
1313
1314     long long 
1315     fetch_or(long long, memory_order = memory_order_seq_cst) volatile;
1316
1317     long long 
1318     fetch_xor(long long, memory_order = memory_order_seq_cst) volatile;
1319
1320     long long 
1321     operator=(long long __v) volatile { store(__v); return __v; }
1322
1323     long long 
1324     operator++(int) volatile { return fetch_add(1); }
1325
1326     long long 
1327     operator--(int) volatile { return fetch_sub(1); }
1328
1329     long long 
1330     operator++() volatile { return fetch_add(1) + 1; }
1331
1332     long long 
1333     operator--() volatile { return fetch_sub(1) - 1; }
1334
1335     long long 
1336     operator+=(long long __v) volatile { return fetch_add(__v) + __v; }
1337
1338     long long 
1339     operator-=(long long __v) volatile { return fetch_sub(__v) - __v; }
1340
1341     long long 
1342     operator&=(long long __v) volatile { return fetch_and(__v) & __v; }
1343
1344     long long 
1345     operator|=(long long __v) volatile { return fetch_or(__v) | __v; }
1346
1347     long long 
1348     operator^=(long long __v) volatile { return fetch_xor(__v) ^ __v; }
1349
1350     friend void 
1351     atomic_store_explicit(volatile atomic_llong*, long long, memory_order);
1352
1353     friend long long 
1354     atomic_load_explicit(volatile atomic_llong*, memory_order);
1355
1356     friend long long 
1357     atomic_swap_explicit(volatile atomic_llong*, long long, memory_order);
1358
1359     friend bool 
1360     atomic_compare_swap_explicit(volatile atomic_llong*, long long*, 
1361                                  long long, memory_order, memory_order);
1362
1363     friend void 
1364     atomic_fence(const volatile atomic_llong*, memory_order);
1365
1366     friend long long 
1367     atomic_fetch_add_explicit(volatile atomic_llong*, long long, memory_order);
1368
1369     friend long long 
1370     atomic_fetch_sub_explicit(volatile atomic_llong*, long long, memory_order);
1371
1372     friend long long 
1373     atomic_fetch_and_explicit(volatile atomic_llong*, long long, memory_order);
1374
1375     friend long long 
1376     atomic_fetch_or_explicit(volatile atomic_llong*, long long, memory_order);
1377
1378     friend long long 
1379     atomic_fetch_xor_explicit(volatile atomic_llong*, long long, memory_order);
1380
1381     atomic_llong() { }
1382
1383     atomic_llong(long long __v) { _M_base._M_i = __v; }
1384
1385   private:    
1386     atomic_llong(const atomic_llong&);
1387     atomic_llong& operator=(const atomic_llong&);
1388   };
1389
1390   /// atomic_ullong
1391   struct atomic_ullong
1392   {
1393     __atomic_ullong_base _M_base;
1394
1395     bool 
1396     is_lock_free() const volatile;
1397
1398     void 
1399     store(unsigned long long, memory_order = memory_order_seq_cst) volatile;
1400
1401     unsigned long long 
1402     load(memory_order = memory_order_seq_cst) volatile;
1403
1404     unsigned long long 
1405     swap(unsigned long long, memory_order = memory_order_seq_cst) volatile;
1406
1407     bool 
1408     compare_swap(unsigned long long&, unsigned long long, memory_order, 
1409                  memory_order) volatile;
1410
1411     bool 
1412     compare_swap(unsigned long long&, unsigned long long, 
1413                  memory_order = memory_order_seq_cst) volatile;
1414
1415     void 
1416     fence(memory_order) const volatile;
1417
1418     unsigned long long 
1419     fetch_add(unsigned long long, memory_order = memory_order_seq_cst) volatile;
1420
1421     unsigned long long 
1422     fetch_sub(unsigned long long, memory_order = memory_order_seq_cst) volatile;
1423
1424     unsigned long long 
1425     fetch_and(unsigned long long, memory_order = memory_order_seq_cst) volatile;
1426
1427     unsigned long long 
1428     fetch_or(unsigned long long, memory_order = memory_order_seq_cst) volatile;
1429
1430     unsigned long long 
1431     fetch_xor(unsigned long long, memory_order = memory_order_seq_cst) volatile;
1432
1433     unsigned long long 
1434     operator=(unsigned long long __v) volatile
1435     { store(__v); return __v; }
1436
1437     unsigned long long 
1438     operator++(int) volatile
1439     { return fetch_add(1); }
1440
1441     unsigned long long 
1442     operator--(int) volatile
1443     { return fetch_sub(1); }
1444
1445     unsigned long long 
1446     operator++() volatile
1447     { return fetch_add(1) + 1; }
1448
1449     unsigned long long 
1450     operator--() volatile
1451     { return fetch_sub(1) - 1; }
1452
1453     unsigned long long 
1454     operator+=(unsigned long long __v) volatile
1455     { return fetch_add(__v) + __v; }
1456
1457     unsigned long long 
1458     operator-=(unsigned long long __v) volatile
1459     { return fetch_sub(__v) - __v; }
1460
1461     unsigned long long 
1462     operator&=(unsigned long long __v) volatile
1463     { return fetch_and(__v) & __v; }
1464
1465     unsigned long long 
1466     operator|=(unsigned long long __v) volatile
1467     { return fetch_or(__v) | __v; }
1468
1469     unsigned long long 
1470     operator^=(unsigned long long __v) volatile
1471     { return fetch_xor(__v) ^ __v; }
1472
1473     friend void 
1474     atomic_store_explicit(volatile atomic_ullong*, unsigned long long,
1475                                        memory_order);
1476     friend unsigned long long 
1477     atomic_load_explicit(volatile atomic_ullong*, memory_order);
1478
1479     friend unsigned long long 
1480     atomic_swap_explicit(volatile atomic_ullong*, unsigned long long, 
1481                          memory_order);
1482
1483     friend bool 
1484     atomic_compare_swap_explicit(volatile atomic_ullong*, unsigned long long*, 
1485                                  unsigned long long, memory_order, 
1486                                  memory_order);
1487
1488     friend void 
1489     atomic_fence(const volatile atomic_ullong*, memory_order);
1490
1491     friend unsigned long long 
1492     atomic_fetch_add_explicit(volatile atomic_ullong*, unsigned long long, 
1493                               memory_order);
1494
1495     friend unsigned long long 
1496     atomic_fetch_sub_explicit(volatile atomic_ullong*, unsigned long long, 
1497                               memory_order);
1498
1499     friend unsigned long long 
1500     atomic_fetch_and_explicit(volatile atomic_ullong*, unsigned long long, 
1501                               memory_order);
1502
1503     friend unsigned long long 
1504     atomic_fetch_or_explicit(volatile atomic_ullong*, unsigned long long, 
1505                              memory_order);
1506
1507     friend unsigned long long 
1508     atomic_fetch_xor_explicit(volatile atomic_ullong*, unsigned long long, 
1509                               memory_order);
1510
1511     atomic_ullong() { }
1512
1513     atomic_ullong(unsigned long long __v) { _M_base._M_i = __v; }
1514
1515   private:
1516     atomic_ullong(const atomic_ullong&);
1517     atomic_ullong& operator=(const atomic_ullong&);
1518   };
1519
1520   /// atomic_wchar_t
1521   struct atomic_wchar_t
1522   {
1523     __atomic_wchar_t_base _M_base;
1524
1525     bool 
1526     is_lock_free() const volatile;
1527
1528     void 
1529     store(wchar_t, memory_order = memory_order_seq_cst) volatile;
1530
1531     wchar_t 
1532     load(memory_order = memory_order_seq_cst) volatile;
1533
1534     wchar_t 
1535     swap(wchar_t, memory_order = memory_order_seq_cst) volatile;
1536
1537     bool 
1538     compare_swap(wchar_t&, wchar_t, memory_order, memory_order) volatile;
1539
1540     bool 
1541     compare_swap(wchar_t&, wchar_t, 
1542                  memory_order = memory_order_seq_cst) volatile;
1543
1544     void 
1545     fence(memory_order) const volatile;
1546
1547     wchar_t 
1548     fetch_add(wchar_t, memory_order = memory_order_seq_cst) volatile;
1549
1550     wchar_t 
1551     fetch_sub(wchar_t, memory_order = memory_order_seq_cst) volatile;
1552
1553     wchar_t 
1554     fetch_and(wchar_t, memory_order = memory_order_seq_cst) volatile;
1555
1556     wchar_t 
1557     fetch_or(wchar_t, memory_order = memory_order_seq_cst) volatile;
1558
1559     wchar_t 
1560     fetch_xor(wchar_t, memory_order = memory_order_seq_cst) volatile;
1561
1562     wchar_t 
1563     operator=(wchar_t __v) volatile
1564     { store(__v); return __v; }
1565
1566     wchar_t 
1567     operator++(int) volatile
1568     { return fetch_add(1); }
1569
1570     wchar_t 
1571     operator--(int) volatile
1572     { return fetch_sub(1); }
1573
1574     wchar_t 
1575     operator++() volatile
1576     { return fetch_add(1) + 1; }
1577
1578     wchar_t 
1579     operator--() volatile
1580     { return fetch_sub(1) - 1; }
1581
1582     wchar_t 
1583     operator+=(wchar_t __v) volatile
1584     { return fetch_add(__v) + __v; }
1585
1586     wchar_t 
1587     operator-=(wchar_t __v) volatile
1588     { return fetch_sub(__v) - __v; }
1589
1590     wchar_t 
1591     operator&=(wchar_t __v) volatile
1592     { return fetch_and(__v) & __v; }
1593
1594     wchar_t 
1595     operator|=(wchar_t __v) volatile
1596     { return fetch_or(__v) | __v; }
1597
1598     wchar_t 
1599     operator^=(wchar_t __v) volatile
1600     { return fetch_xor(__v) ^ __v; }
1601
1602     friend void 
1603     atomic_store_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
1604
1605     friend wchar_t 
1606     atomic_load_explicit(volatile atomic_wchar_t*, memory_order);
1607
1608     friend wchar_t 
1609     atomic_swap_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
1610
1611     friend bool 
1612     atomic_compare_swap_explicit(volatile atomic_wchar_t*,
1613                                  wchar_t*, wchar_t, memory_order, memory_order);
1614
1615     friend void 
1616     atomic_fence(const volatile atomic_wchar_t*, memory_order);
1617
1618     friend wchar_t 
1619     atomic_fetch_add_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
1620
1621     friend wchar_t 
1622     atomic_fetch_sub_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
1623
1624     friend wchar_t 
1625     atomic_fetch_and_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
1626
1627     friend wchar_t 
1628     atomic_fetch_or_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
1629
1630     friend wchar_t 
1631     atomic_fetch_xor_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
1632
1633     atomic_wchar_t() { }
1634
1635     atomic_wchar_t(wchar_t __v) { _M_base._M_i = __v; }
1636
1637   private:
1638     atomic_wchar_t(const atomic_wchar_t&);
1639     atomic_wchar_t& operator=(const atomic_wchar_t&);
1640   };
1641
1642
1643   /// atomic
1644   /// 29.4.3, Generic atomic type, primary class template.
1645   template<typename _Tp>
1646     struct atomic
1647     {
1648       bool 
1649       is_lock_free() const volatile;
1650
1651       void 
1652       store(_Tp, memory_order = memory_order_seq_cst) volatile;
1653
1654       _Tp 
1655       load(memory_order = memory_order_seq_cst) volatile;
1656
1657       _Tp 
1658       swap(_Tp __v, memory_order = memory_order_seq_cst) volatile;
1659
1660       bool 
1661       compare_swap(_Tp&, _Tp, memory_order, memory_order) volatile;
1662
1663       bool 
1664       compare_swap(_Tp&, _Tp, memory_order = memory_order_seq_cst) volatile;
1665
1666       void 
1667       fence(memory_order) const volatile;
1668
1669       _Tp 
1670       operator=(_Tp __v) volatile { store(__v); return __v; }
1671
1672       atomic() { }
1673
1674       explicit atomic(_Tp __v) : __f(__v) { }
1675
1676     private:
1677       atomic(const atomic&);
1678       atomic& operator=(const atomic&);
1679
1680       _Tp __f;
1681     };
1682
1683   /// Partial specialization for pointer types.
1684   template<typename _Tp> 
1685     struct atomic<_Tp*> : atomic_address
1686     {
1687       _Tp* 
1688       load(memory_order = memory_order_seq_cst) volatile;
1689
1690       _Tp* 
1691       swap(_Tp*, memory_order = memory_order_seq_cst) volatile;
1692
1693       bool 
1694       compare_swap(_Tp*&, _Tp*, memory_order, memory_order) volatile;
1695
1696       bool 
1697       compare_swap(_Tp*&, _Tp*, memory_order = memory_order_seq_cst) volatile;
1698
1699       _Tp* 
1700       fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
1701
1702       _Tp* 
1703       fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
1704
1705       _Tp* 
1706       operator=(_Tp* __v) volatile { store(__v); return __v; }
1707
1708       _Tp* 
1709       operator++(int) volatile { return fetch_add(1); }
1710
1711       _Tp* 
1712       operator--(int) volatile { return fetch_sub(1); }
1713
1714       _Tp* 
1715       operator++() volatile { return fetch_add(1) + 1; }
1716
1717       _Tp* 
1718       operator--() volatile { return fetch_sub(1) - 1; }
1719
1720       _Tp* 
1721       operator+=(ptrdiff_t __v) volatile 
1722       { return fetch_add(__v) + __v; }
1723
1724       _Tp* 
1725       operator-=(ptrdiff_t __v) volatile 
1726       { return fetch_sub(__v) - __v; }
1727
1728       atomic() { }
1729
1730       explicit atomic(_Tp* __v) : atomic_address(__v) { }
1731
1732     private:
1733       atomic(const atomic&);
1734       atomic& operator=(const atomic&);
1735     };
1736
1737   /// Explicit specialization for bool.
1738   template<> 
1739     struct atomic<bool> : atomic_bool
1740     {
1741       atomic() { }
1742
1743       explicit atomic(bool __v) : atomic_bool(__v) { }
1744       
1745       bool 
1746       operator=(bool __v) volatile { store(__v); return __v; }
1747       
1748     private:
1749       atomic(const atomic&);
1750       atomic& operator=(const atomic&);
1751     };
1752
1753   /// Explicit specialization for void*
1754   template<> 
1755     struct atomic<void*> : atomic_address
1756     {
1757       atomic() { }
1758
1759       explicit atomic(void* __v) : atomic_address(__v) { }
1760       
1761       void* 
1762       operator=(void* __v) volatile { store(__v); return __v; }
1763       
1764     private:
1765       atomic(const atomic&);      
1766       atomic& operator=(const atomic&);
1767     };
1768
1769   /// Explicit specialization for char.
1770   template<> 
1771     struct atomic<char> : atomic_char
1772     {
1773       atomic() { }
1774
1775       explicit atomic(char __v) : atomic_char(__v) { }
1776       
1777       char 
1778       operator=(char __v) volatile { store(__v); return __v; }
1779       
1780     private:
1781       atomic(const atomic&);
1782       atomic& operator=(const atomic&);
1783     };
1784
1785
1786   /// Explicit specialization for signed char.
1787   template<> 
1788     struct atomic<signed char> : atomic_schar
1789     { 
1790       atomic() { }
1791
1792       explicit atomic(signed char __v) : atomic_schar(__v) { }
1793       
1794       signed char 
1795       operator=(signed char __v) volatile { store(__v); return __v; }
1796       
1797     private:
1798       atomic(const atomic&);      
1799       atomic& operator=(const atomic&);
1800   };
1801
1802   /// Explicit specialization for unsigned char.
1803   template<> 
1804     struct atomic<unsigned char> : atomic_uchar
1805     {
1806       atomic() { }
1807
1808       explicit atomic(unsigned char __v) : atomic_uchar(__v) { }
1809       
1810       unsigned char 
1811       operator=(unsigned char __v) volatile { store(__v); return __v; }
1812       
1813     private:
1814       atomic(const atomic&);
1815       atomic& 
1816       operator=(const atomic&);
1817     };
1818
1819   /// Explicit specialization for short.
1820   template<> 
1821     struct atomic<short> : atomic_short
1822     {
1823       atomic() { }
1824
1825       explicit atomic(short __v) : atomic_short(__v) { }
1826       
1827       short 
1828       operator=(short __v) volatile { store(__v); return __v; }
1829       
1830     private:
1831       atomic(const atomic&);
1832       atomic& operator=(const atomic&);
1833   };
1834
1835   /// Explicit specialization for unsigned short.
1836   template<> 
1837     struct atomic<unsigned short> : atomic_ushort
1838     {
1839       atomic() { }
1840
1841       explicit atomic(unsigned short __v) : atomic_ushort(__v) { }
1842       
1843       unsigned short 
1844       operator=(unsigned short __v) volatile { store(__v); return __v; }
1845       
1846     private:
1847       atomic(const atomic&);      
1848       atomic& operator=(const atomic&);
1849     };
1850
1851   /// Explicit specialization for int.
1852   template<> 
1853     struct atomic<int> : atomic_int
1854     {
1855       atomic() { }
1856
1857       explicit atomic(int __v) : atomic_int(__v) { }
1858       
1859       int 
1860       operator=(int __v) volatile { store(__v); return __v; }
1861       
1862     private:
1863       atomic(const atomic&);
1864       atomic& operator=(const atomic&);
1865     };
1866
1867   /// Explicit specialization for unsigned int.
1868   template<> 
1869     struct atomic<unsigned int> : atomic_uint
1870     {
1871       atomic() { }
1872
1873       explicit atomic(unsigned int __v) : atomic_uint(__v) { }
1874       
1875       unsigned int 
1876       operator=(unsigned int __v) volatile { store(__v); return __v; }
1877       
1878     private:
1879       atomic(const atomic&);      
1880       atomic& operator=(const atomic&);
1881     };
1882
1883   /// Explicit specialization for long.
1884   template<> 
1885     struct atomic<long> : atomic_long
1886     {
1887       atomic() { }
1888
1889       explicit atomic(long __v) : atomic_long(__v) { }
1890       
1891       long 
1892       operator=(long __v) volatile { store(__v); return __v; }
1893       
1894     private:
1895       atomic(const atomic&);      
1896       atomic& operator=(const atomic&);
1897     };
1898
1899   /// Explicit specialization for unsigned long.
1900   template<> 
1901     struct atomic<unsigned long> : atomic_ulong
1902     {
1903       atomic() { }
1904
1905       explicit atomic(unsigned long __v) : atomic_ulong(__v) { }
1906       
1907       unsigned long 
1908       operator=(unsigned long __v) volatile
1909       { store(__v); return __v; }
1910       
1911     private:
1912       atomic(const atomic&);
1913       atomic& operator=(const atomic&);
1914     };
1915
1916   /// Explicit specialization for long long.
1917   template<> 
1918     struct atomic<long long> : atomic_llong
1919     {
1920       atomic() { }
1921
1922       explicit atomic(long long __v) : atomic_llong(__v) { }
1923       
1924       long long 
1925       operator=(long long __v) volatile { store(__v); return __v; }
1926       
1927     private:
1928       atomic(const atomic&);      
1929       atomic& operator=(const atomic&);
1930     };
1931
1932   /// Explicit specialization for unsigned long long.
1933   template<> 
1934     struct atomic<unsigned long long> : atomic_ullong
1935     {
1936       atomic() { }
1937
1938       explicit atomic(unsigned long long __v) : atomic_ullong(__v) { }
1939       
1940       unsigned long long 
1941       operator=(unsigned long long __v) volatile { store(__v); return __v; }
1942       
1943     private:
1944       atomic(const atomic&);
1945       atomic& operator=(const atomic&);
1946     };
1947
1948   /// Explicit specialization for wchar_t.
1949   template<> 
1950     struct atomic<wchar_t> : atomic_wchar_t
1951     {
1952       atomic() { }
1953
1954       explicit atomic(wchar_t __v) : atomic_wchar_t(__v) { }
1955       
1956       wchar_t 
1957       operator=(wchar_t __v) volatile { store(__v); return __v; }
1958       
1959     private:
1960       atomic(const atomic&);
1961       atomic& operator=(const atomic&);
1962     };
1963
1964   inline bool 
1965   atomic_is_lock_free(const volatile atomic_bool* __a)
1966   { return false; }
1967
1968   inline bool 
1969   atomic_load_explicit(volatile atomic_bool* __a, memory_order __x)
1970   { return _ATOMIC_LOAD_(__a, __x); }
1971
1972   inline bool 
1973   atomic_load(volatile atomic_bool* __a)
1974   { return atomic_load_explicit(__a, memory_order_seq_cst); }
1975
1976   inline void 
1977   atomic_store_explicit(volatile atomic_bool* __a, bool __m, memory_order __x)
1978   { _ATOMIC_STORE_(__a, __m, __x); }
1979
1980   inline void 
1981   atomic_store(volatile atomic_bool* __a, bool __m)
1982   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
1983
1984   inline bool 
1985   atomic_swap_explicit(volatile atomic_bool* __a, bool __m, memory_order __x)
1986   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
1987
1988   inline bool 
1989   atomic_swap(volatile atomic_bool* __a, bool __m)
1990   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
1991
1992   inline bool 
1993   atomic_compare_swap_explicit(volatile atomic_bool* __a, bool* __e, bool __m,
1994                                memory_order __x, memory_order __y)
1995   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
1996
1997   inline bool 
1998   atomic_compare_swap(volatile atomic_bool* __a, bool* __e, bool __m)
1999   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2000                                         memory_order_seq_cst); }
2001
2002   inline void 
2003   atomic_fence(const volatile atomic_bool* __a, memory_order __x)
2004   { _ATOMIC_FENCE_(__a, __x); }
2005
2006   inline bool 
2007   atomic_is_lock_free(const volatile atomic_address* __a)
2008   { return false; }
2009
2010   inline void* 
2011   atomic_load_explicit(volatile atomic_address* __a, memory_order __x)
2012   { return _ATOMIC_LOAD_(__a, __x); }
2013
2014   inline void* 
2015   atomic_load(volatile atomic_address* __a)
2016   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2017
2018   inline void 
2019   atomic_store_explicit(volatile atomic_address* __a, void* __m, 
2020                         memory_order __x)
2021   { _ATOMIC_STORE_(__a, __m, __x); }
2022
2023   inline void 
2024   atomic_store(volatile atomic_address* __a, void* __m)
2025   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2026
2027   inline void* 
2028   atomic_swap_explicit(volatile atomic_address* __a, void* __m, 
2029                        memory_order __x)
2030   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2031
2032   inline void* 
2033   atomic_swap(volatile atomic_address* __a, void* __m)
2034   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2035
2036   inline bool 
2037   atomic_compare_swap_explicit(volatile atomic_address* __a, void** __e, 
2038                                void* __m, memory_order __x, memory_order __y)
2039   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2040
2041   inline bool 
2042   atomic_compare_swap(volatile atomic_address* __a, void** __e, void* __m)
2043   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2044                                         memory_order_seq_cst); }
2045
2046   inline void 
2047   atomic_fence(const volatile atomic_address* __a, memory_order __x)
2048   { _ATOMIC_FENCE_(__a, __x); }
2049
2050
2051   inline bool 
2052   atomic_is_lock_free(const volatile atomic_char* __a)
2053   { return false; }
2054
2055   inline char 
2056   atomic_load_explicit(volatile atomic_char* __a, memory_order __x)
2057   { return _ATOMIC_LOAD_(__a, __x); }
2058
2059   inline char 
2060   atomic_load(volatile atomic_char* __a)
2061   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2062
2063   inline void 
2064   atomic_store_explicit(volatile atomic_char* __a, char __m, memory_order __x)
2065   { _ATOMIC_STORE_(__a, __m, __x); }
2066
2067   inline void 
2068   atomic_store(volatile atomic_char* __a, char __m)
2069   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2070
2071   inline char 
2072   atomic_swap_explicit(volatile atomic_char* __a, char __m, memory_order __x)
2073   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2074
2075   inline char 
2076   atomic_swap(volatile atomic_char* __a, char __m)
2077   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2078
2079   inline bool 
2080   atomic_compare_swap_explicit(volatile atomic_char* __a, char* __e, char __m,
2081                                memory_order __x, memory_order __y)
2082   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2083
2084   inline bool 
2085   atomic_compare_swap(volatile atomic_char* __a, char* __e, char __m)
2086   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2087                                         memory_order_seq_cst); }
2088
2089   inline void 
2090   atomic_fence(const volatile atomic_char* __a, memory_order __x)
2091   { _ATOMIC_FENCE_(__a, __x); }
2092
2093
2094   inline bool 
2095   atomic_is_lock_free(const volatile atomic_schar* __a)
2096   { return false; }
2097
2098   inline signed char 
2099   atomic_load_explicit(volatile atomic_schar* __a, memory_order __x)
2100   { return _ATOMIC_LOAD_(__a, __x); }
2101
2102   inline signed char 
2103   atomic_load(volatile atomic_schar* __a)
2104   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2105
2106   inline void 
2107   atomic_store_explicit(volatile atomic_schar* __a, signed char __m, 
2108                         memory_order __x)
2109   { _ATOMIC_STORE_(__a, __m, __x); }
2110
2111   inline void 
2112   atomic_store(volatile atomic_schar* __a, signed char __m)
2113   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2114
2115   inline signed char 
2116   atomic_swap_explicit(volatile atomic_schar* __a, signed char __m, 
2117                        memory_order __x)
2118   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2119
2120   inline signed char 
2121   atomic_swap(volatile atomic_schar* __a, signed char __m)
2122   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2123
2124   inline bool 
2125   atomic_compare_swap_explicit(volatile atomic_schar* __a, signed char* __e, 
2126                                signed char __m, memory_order __x, 
2127                                memory_order __y)
2128   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2129
2130   inline bool 
2131   atomic_compare_swap(volatile atomic_schar* __a, signed char* __e, 
2132                       signed char __m)
2133   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2134                                         memory_order_seq_cst); }
2135
2136   inline void 
2137   atomic_fence(const volatile atomic_schar* __a, memory_order __x)
2138   { _ATOMIC_FENCE_(__a, __x); }
2139
2140
2141   inline bool 
2142   atomic_is_lock_free(const volatile atomic_uchar* __a)
2143   { return false; }
2144
2145   inline unsigned char 
2146   atomic_load_explicit(volatile atomic_uchar* __a, memory_order __x)
2147   { return _ATOMIC_LOAD_(__a, __x); }
2148
2149   inline unsigned char 
2150   atomic_load(volatile atomic_uchar* __a)
2151   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2152
2153   inline void 
2154   atomic_store_explicit(volatile atomic_uchar* __a, unsigned char __m, 
2155                         memory_order __x)
2156   { _ATOMIC_STORE_(__a, __m, __x); }
2157
2158   inline void 
2159   atomic_store(volatile atomic_uchar* __a, unsigned char __m)
2160   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2161
2162   inline unsigned char 
2163   atomic_swap_explicit(volatile atomic_uchar* __a, unsigned char __m, 
2164                        memory_order __x)
2165   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2166
2167   inline unsigned char 
2168   atomic_swap(volatile atomic_uchar* __a, unsigned char __m)
2169   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2170
2171   inline bool 
2172   atomic_compare_swap_explicit(volatile atomic_uchar* __a, unsigned char* __e,
2173                                unsigned char __m, memory_order __x, 
2174                                memory_order __y)
2175   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2176
2177   inline bool 
2178   atomic_compare_swap(volatile atomic_uchar* __a, unsigned char* __e, 
2179                       unsigned char __m)
2180   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2181                                         memory_order_seq_cst); }
2182
2183   inline void 
2184   atomic_fence(const volatile atomic_uchar* __a, memory_order __x)
2185   { _ATOMIC_FENCE_(__a, __x); }
2186
2187
2188   inline bool 
2189   atomic_is_lock_free(const volatile atomic_short* __a)
2190   { return false; }
2191
2192   inline short 
2193   atomic_load_explicit(volatile atomic_short* __a, memory_order __x)
2194   { return _ATOMIC_LOAD_(__a, __x); }
2195
2196   inline short 
2197   atomic_load(volatile atomic_short* __a)
2198   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2199
2200   inline void 
2201   atomic_store_explicit(volatile atomic_short* __a, short __m, 
2202                         memory_order __x)
2203   { _ATOMIC_STORE_(__a, __m, __x); }
2204
2205   inline void 
2206   atomic_store(volatile atomic_short* __a, short __m)
2207   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2208
2209   inline short 
2210   atomic_swap_explicit(volatile atomic_short* __a, short __m, memory_order __x)
2211   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2212
2213   inline short 
2214   atomic_swap(volatile atomic_short* __a, short __m)
2215   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2216
2217   inline bool 
2218   atomic_compare_swap_explicit(volatile atomic_short* __a, short* __e, 
2219                                short __m, memory_order __x, memory_order __y)
2220   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2221
2222   inline bool 
2223   atomic_compare_swap(volatile atomic_short* __a, short* __e, short __m)
2224   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2225                                         memory_order_seq_cst); }
2226
2227   inline void 
2228   atomic_fence(const volatile atomic_short* __a, memory_order __x)
2229   { _ATOMIC_FENCE_(__a, __x); }
2230
2231
2232   inline bool 
2233   atomic_is_lock_free(const volatile atomic_ushort* __a)
2234   { return false; }
2235
2236   inline unsigned short 
2237   atomic_load_explicit(volatile atomic_ushort* __a, memory_order __x)
2238   { return _ATOMIC_LOAD_(__a, __x); }
2239
2240   inline unsigned short 
2241   atomic_load(volatile atomic_ushort* __a)
2242   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2243
2244   inline void 
2245   atomic_store_explicit(volatile atomic_ushort* __a, unsigned short __m, 
2246                         memory_order __x)
2247   { _ATOMIC_STORE_(__a, __m, __x); }
2248
2249   inline void 
2250   atomic_store(volatile atomic_ushort* __a, unsigned short __m)
2251   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2252
2253   inline unsigned short 
2254   atomic_swap_explicit(volatile atomic_ushort* __a, unsigned short __m, 
2255                        memory_order __x)
2256   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2257
2258   inline unsigned short 
2259   atomic_swap(volatile atomic_ushort* __a, unsigned short __m)
2260   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2261
2262   inline bool 
2263   atomic_compare_swap_explicit(volatile atomic_ushort* __a, 
2264                                unsigned short* __e, unsigned short __m,
2265                                memory_order __x, memory_order __y)
2266   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2267
2268   inline bool 
2269   atomic_compare_swap(volatile atomic_ushort* __a, unsigned short* __e, 
2270                       unsigned short __m)
2271   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2272                                         memory_order_seq_cst); }
2273
2274   inline void 
2275   atomic_fence(const volatile atomic_ushort* __a, memory_order __x)
2276   { _ATOMIC_FENCE_(__a, __x); }
2277
2278
2279   inline bool 
2280   atomic_is_lock_free(const volatile atomic_int* __a)
2281   { return false; }
2282
2283   inline int 
2284   atomic_load_explicit(volatile atomic_int* __a, memory_order __x)
2285   { return _ATOMIC_LOAD_(__a, __x); }
2286
2287   inline int 
2288   atomic_load(volatile atomic_int* __a)
2289   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2290
2291   inline void 
2292   atomic_store_explicit(volatile atomic_int* __a, int __m, memory_order __x)
2293   { _ATOMIC_STORE_(__a, __m, __x); }
2294
2295   inline void 
2296   atomic_store(volatile atomic_int* __a, int __m)
2297   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2298
2299   inline int 
2300   atomic_swap_explicit(volatile atomic_int* __a, int __m, memory_order __x)
2301   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2302
2303   inline int 
2304   atomic_swap(volatile atomic_int* __a, int __m)
2305   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2306
2307   inline bool 
2308   atomic_compare_swap_explicit(volatile atomic_int* __a, int* __e, int __m,
2309                                memory_order __x, memory_order __y)
2310   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2311
2312   inline bool 
2313   atomic_compare_swap(volatile atomic_int* __a, int* __e, int __m)
2314   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2315                                         memory_order_seq_cst); }
2316
2317   inline void 
2318   atomic_fence(const volatile atomic_int* __a, memory_order __x)
2319   { _ATOMIC_FENCE_(__a, __x); }
2320
2321
2322   inline bool 
2323   atomic_is_lock_free(const volatile atomic_uint* __a)
2324   { return false; }
2325
2326   inline unsigned int 
2327   atomic_load_explicit(volatile atomic_uint* __a, memory_order __x)
2328   { return _ATOMIC_LOAD_(__a, __x); }
2329
2330   inline unsigned int 
2331   atomic_load(volatile atomic_uint* __a)
2332   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2333
2334   inline void 
2335   atomic_store_explicit(volatile atomic_uint* __a, unsigned int __m, 
2336                         memory_order __x)
2337   { _ATOMIC_STORE_(__a, __m, __x); }
2338
2339   inline void 
2340   atomic_store(volatile atomic_uint* __a, unsigned int __m)
2341   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2342
2343   inline unsigned int 
2344   atomic_swap_explicit(volatile atomic_uint* __a, unsigned int __m, 
2345                        memory_order __x)
2346   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2347
2348   inline unsigned int 
2349   atomic_swap(volatile atomic_uint* __a, unsigned int __m)
2350   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2351
2352   inline bool 
2353   atomic_compare_swap_explicit(volatile atomic_uint* __a, unsigned int* __e, 
2354                                unsigned int __m, memory_order __x, 
2355                                memory_order __y)
2356   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2357
2358   inline bool 
2359   atomic_compare_swap(volatile atomic_uint* __a, unsigned int* __e, 
2360                       unsigned int __m)
2361   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2362                                         memory_order_seq_cst); }
2363
2364   inline void 
2365   atomic_fence(const volatile atomic_uint* __a, memory_order __x)
2366   { _ATOMIC_FENCE_(__a, __x); }
2367
2368
2369   inline bool 
2370   atomic_is_lock_free(const volatile atomic_long* __a)
2371   { return false; }
2372
2373   inline long 
2374   atomic_load_explicit(volatile atomic_long* __a, memory_order __x)
2375   { return _ATOMIC_LOAD_(__a, __x); }
2376
2377   inline long 
2378   atomic_load(volatile atomic_long* __a)
2379   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2380
2381   inline void 
2382   atomic_store_explicit(volatile atomic_long* __a, long __m, memory_order __x)
2383   { _ATOMIC_STORE_(__a, __m, __x); }
2384
2385   inline void 
2386   atomic_store(volatile atomic_long* __a, long __m)
2387   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2388
2389   inline long 
2390   atomic_swap_explicit(volatile atomic_long* __a, long __m, memory_order __x)
2391   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2392
2393   inline long 
2394   atomic_swap(volatile atomic_long* __a, long __m)
2395   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2396
2397   inline bool 
2398   atomic_compare_swap_explicit(volatile atomic_long* __a, long* __e, long __m,
2399                                memory_order __x, memory_order __y)
2400   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2401
2402   inline bool 
2403   atomic_compare_swap(volatile atomic_long* __a, long* __e, long __m)
2404   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2405                                         memory_order_seq_cst); }
2406
2407   inline void 
2408   atomic_fence(const volatile atomic_long* __a, memory_order __x)
2409   { _ATOMIC_FENCE_(__a, __x); }
2410
2411
2412   inline bool 
2413   atomic_is_lock_free(const volatile atomic_ulong* __a)
2414   { return false; }
2415
2416   inline unsigned long 
2417   atomic_load_explicit(volatile atomic_ulong* __a, memory_order __x)
2418   { return _ATOMIC_LOAD_(__a, __x); }
2419
2420   inline unsigned long 
2421   atomic_load(volatile atomic_ulong* __a)
2422   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2423
2424   inline void 
2425   atomic_store_explicit(volatile atomic_ulong* __a, unsigned long __m, 
2426                         memory_order __x)
2427   { _ATOMIC_STORE_(__a, __m, __x); }
2428
2429   inline void 
2430   atomic_store(volatile atomic_ulong* __a, unsigned long __m)
2431   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2432
2433   inline unsigned long 
2434   atomic_swap_explicit(volatile atomic_ulong* __a, unsigned long __m, 
2435                        memory_order __x)
2436   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2437
2438   inline unsigned long 
2439   atomic_swap(volatile atomic_ulong* __a, unsigned long __m)
2440   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2441
2442   inline bool 
2443   atomic_compare_swap_explicit(volatile atomic_ulong* __a, unsigned long* __e,
2444                                unsigned long __m, memory_order __x, 
2445                                memory_order __y)
2446   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2447
2448   inline bool 
2449   atomic_compare_swap(volatile atomic_ulong* __a, unsigned long* __e, 
2450                       unsigned long __m)
2451   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2452                                         memory_order_seq_cst); }
2453
2454   inline void 
2455   atomic_fence(const volatile atomic_ulong* __a, memory_order __x)
2456   { _ATOMIC_FENCE_(__a, __x); }
2457
2458
2459   inline bool 
2460   atomic_is_lock_free(const volatile atomic_llong* __a)
2461   { return false; }
2462
2463   inline long long 
2464   atomic_load_explicit(volatile atomic_llong* __a, memory_order __x)
2465   { return _ATOMIC_LOAD_(__a, __x); }
2466
2467   inline long long 
2468   atomic_load(volatile atomic_llong* __a)
2469   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2470
2471   inline void 
2472   atomic_store_explicit(volatile atomic_llong* __a, long long __m, 
2473                         memory_order __x)
2474   { _ATOMIC_STORE_(__a, __m, __x); }
2475
2476   inline void 
2477   atomic_store(volatile atomic_llong* __a, long long __m)
2478   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2479
2480   inline long long 
2481   atomic_swap_explicit(volatile atomic_llong* __a, long long __m, 
2482                        memory_order __x)
2483   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2484
2485   inline long long 
2486   atomic_swap(volatile atomic_llong* __a, long long __m)
2487   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2488
2489   inline bool 
2490   atomic_compare_swap_explicit(volatile atomic_llong* __a, long long* __e, 
2491                                long long __m, memory_order __x, 
2492                                memory_order __y)
2493   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2494
2495   inline bool 
2496   atomic_compare_swap(volatile atomic_llong* __a, long long* __e, 
2497                       long long __m)
2498   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2499                                         memory_order_seq_cst); }
2500
2501   inline void 
2502   atomic_fence(const volatile atomic_llong* __a, memory_order __x)
2503   { _ATOMIC_FENCE_(__a, __x); }
2504
2505
2506   inline bool 
2507   atomic_is_lock_free(const volatile atomic_ullong* __a)
2508   { return false; }
2509
2510   inline unsigned long long 
2511   atomic_load_explicit(volatile atomic_ullong* __a, memory_order __x)
2512   { return _ATOMIC_LOAD_(__a, __x); }
2513
2514   inline unsigned long long 
2515   atomic_load(volatile atomic_ullong* __a)
2516   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2517
2518   inline void 
2519   atomic_store_explicit(volatile atomic_ullong* __a, unsigned long long __m, 
2520                         memory_order __x)
2521   { _ATOMIC_STORE_(__a, __m, __x); }
2522
2523   inline void 
2524   atomic_store(volatile atomic_ullong* __a, unsigned long long __m)
2525   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2526
2527   inline unsigned long long 
2528   atomic_swap_explicit(volatile atomic_ullong* __a, unsigned long long __m, 
2529                        memory_order __x)
2530   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2531
2532   inline unsigned long long 
2533   atomic_swap(volatile atomic_ullong* __a, unsigned long long __m)
2534   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2535
2536   inline bool 
2537   atomic_compare_swap_explicit(volatile atomic_ullong* __a, 
2538                                unsigned long long* __e, unsigned long long __m,
2539                                memory_order __x, memory_order __y)
2540   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2541
2542   inline bool 
2543   atomic_compare_swap(volatile atomic_ullong* __a, unsigned long long* __e, 
2544                       unsigned long long __m)
2545   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2546                                         memory_order_seq_cst); }
2547
2548   inline void 
2549   atomic_fence(const volatile atomic_ullong* __a, memory_order __x)
2550   { _ATOMIC_FENCE_(__a, __x); }
2551
2552   inline bool 
2553   atomic_is_lock_free(const volatile atomic_wchar_t* __a)
2554   { return false; }
2555
2556   inline wchar_t 
2557   atomic_load_explicit(volatile atomic_wchar_t* __a, memory_order __x)
2558   { return _ATOMIC_LOAD_(__a, __x); }
2559
2560   inline wchar_t 
2561   atomic_load(volatile atomic_wchar_t* __a)
2562   { return atomic_load_explicit(__a, memory_order_seq_cst); }
2563
2564
2565   inline void 
2566   atomic_store_explicit(volatile atomic_wchar_t* __a, wchar_t __m, 
2567                         memory_order __x)
2568   { _ATOMIC_STORE_(__a, __m, __x); }
2569
2570   inline void 
2571   atomic_store(volatile atomic_wchar_t* __a, wchar_t __m)
2572   { atomic_store_explicit(__a, __m, memory_order_seq_cst); }
2573
2574   inline wchar_t 
2575   atomic_swap_explicit(volatile atomic_wchar_t* __a, wchar_t __m, 
2576                        memory_order __x)
2577   { return _ATOMIC_MODIFY_(__a, =, __m, __x); }
2578
2579   inline wchar_t 
2580   atomic_swap(volatile atomic_wchar_t* __a, wchar_t __m)
2581   { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); }
2582
2583   inline bool 
2584   atomic_compare_swap_explicit(volatile atomic_wchar_t* __a, wchar_t* __e, 
2585                                wchar_t __m, memory_order __x, memory_order __y)
2586   { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); }
2587
2588   inline bool 
2589   atomic_compare_swap(volatile atomic_wchar_t* __a, wchar_t* __e, wchar_t __m)
2590   { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, 
2591                                         memory_order_seq_cst); }
2592
2593   inline void 
2594   atomic_fence(const volatile atomic_wchar_t* __a, memory_order __x)
2595   { _ATOMIC_FENCE_(__a, __x); }
2596
2597   inline void* 
2598   atomic_fetch_add_explicit(volatile atomic_address* __a, ptrdiff_t __m, 
2599                             memory_order __x)
2600   { 
2601     void* volatile* __p = &((__a)->_M_base._M_i);
2602     volatile atomic_flag* __g = __atomic_flag_for_address(__p);
2603     __atomic_flag_wait_explicit(__g, __x);
2604     void* __r = *__p;
2605     *__p = (void*)((char*)(*__p) + __m);
2606     atomic_flag_clear_explicit(__g, __x);
2607     return __r; 
2608   }
2609
2610   inline void* 
2611   atomic_fetch_add(volatile atomic_address* __a, ptrdiff_t __m)
2612   { return atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2613
2614
2615   inline void* 
2616   atomic_fetch_sub_explicit(volatile atomic_address* __a, ptrdiff_t __m, 
2617                             memory_order __x)
2618   { 
2619     void* volatile* __p = &((__a)->_M_base._M_i);
2620     volatile atomic_flag* __g = __atomic_flag_for_address(__p);
2621     __atomic_flag_wait_explicit(__g, __x);
2622     void* __r = *__p;
2623     *__p = (void*)((char*)(*__p) - __m);
2624     atomic_flag_clear_explicit(__g, __x);
2625     return __r; 
2626   }
2627
2628   inline void* 
2629   atomic_fetch_sub(volatile atomic_address* __a, ptrdiff_t __m)
2630   { return atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2631
2632
2633   inline char 
2634   atomic_fetch_add_explicit(volatile atomic_char* __a, char __m, 
2635                             memory_order __x)
2636   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
2637
2638   inline char 
2639   atomic_fetch_add(volatile atomic_char* __a, char __m)
2640   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2641
2642   inline char 
2643   atomic_fetch_sub_explicit(volatile atomic_char* __a, char __m, 
2644                             memory_order __x)
2645   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
2646
2647   inline char 
2648   atomic_fetch_sub(volatile atomic_char* __a, char __m)
2649   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2650
2651   inline char 
2652   atomic_fetch_and_explicit(volatile atomic_char* __a, char __m, 
2653                             memory_order __x)
2654   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
2655
2656   inline char 
2657   atomic_fetch_and(volatile atomic_char* __a, char __m)
2658   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
2659
2660   inline char 
2661   atomic_fetch_or_explicit(volatile atomic_char* __a, char __m, 
2662                            memory_order __x)
2663   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
2664
2665   inline char 
2666   atomic_fetch_or(volatile atomic_char* __a, char __m)
2667   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
2668
2669   inline char 
2670   atomic_fetch_xor_explicit(volatile atomic_char* __a, char __m, 
2671                             memory_order __x)
2672   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
2673
2674   inline char 
2675   atomic_fetch_xor(volatile atomic_char* __a, char __m)
2676   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
2677
2678
2679   inline signed char 
2680   atomic_fetch_add_explicit(volatile atomic_schar* __a, signed char __m, 
2681                             memory_order __x)
2682   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
2683
2684   inline signed char 
2685   atomic_fetch_add(volatile atomic_schar* __a, signed char __m)
2686   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2687
2688   inline signed char 
2689   atomic_fetch_sub_explicit(volatile atomic_schar* __a, signed char __m, 
2690                             memory_order __x)
2691   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
2692
2693   inline signed char 
2694   atomic_fetch_sub(volatile atomic_schar* __a, signed char __m)
2695   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2696
2697   inline signed char 
2698   atomic_fetch_and_explicit(volatile atomic_schar* __a, signed char __m, 
2699                             memory_order __x)
2700   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
2701
2702   inline signed char 
2703   atomic_fetch_and(volatile atomic_schar* __a, signed char __m)
2704   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
2705
2706   inline signed char 
2707   atomic_fetch_or_explicit(volatile atomic_schar* __a, signed char __m, 
2708                            memory_order __x)
2709   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
2710
2711   inline signed char 
2712   atomic_fetch_or(volatile atomic_schar* __a, signed char __m)
2713   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
2714
2715
2716   inline signed char 
2717   atomic_fetch_xor_explicit(volatile atomic_schar* __a, signed char __m, 
2718                             memory_order __x)
2719   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
2720
2721   inline signed char 
2722   atomic_fetch_xor(volatile atomic_schar* __a, signed char __m)
2723   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
2724
2725
2726   inline unsigned char 
2727   atomic_fetch_add_explicit(volatile atomic_uchar* __a, unsigned char __m, 
2728                             memory_order __x)
2729   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
2730
2731   inline unsigned char 
2732   atomic_fetch_add(volatile atomic_uchar* __a, unsigned char __m)
2733   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2734
2735   inline unsigned char 
2736   atomic_fetch_sub_explicit(volatile atomic_uchar* __a, unsigned char __m, 
2737                             memory_order __x)
2738   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
2739
2740   inline unsigned char 
2741   atomic_fetch_sub(volatile atomic_uchar* __a, unsigned char __m)
2742   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2743
2744
2745   inline unsigned char 
2746   atomic_fetch_and_explicit(volatile atomic_uchar* __a, unsigned char __m, 
2747                             memory_order __x)
2748   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
2749
2750   inline unsigned char 
2751   atomic_fetch_and(volatile atomic_uchar* __a, unsigned char __m)
2752   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
2753
2754   inline unsigned char 
2755   atomic_fetch_or_explicit(volatile atomic_uchar* __a, unsigned char __m, 
2756                            memory_order __x)
2757   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
2758
2759   inline unsigned char 
2760   atomic_fetch_or(volatile atomic_uchar* __a, unsigned char __m)
2761   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
2762
2763   inline unsigned char 
2764   atomic_fetch_xor_explicit(volatile atomic_uchar* __a, 
2765                             unsigned char __m, memory_order __x)
2766   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
2767
2768   inline unsigned char 
2769   atomic_fetch_xor(volatile atomic_uchar* __a, unsigned char __m)
2770   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
2771
2772
2773   inline short 
2774   atomic_fetch_add_explicit(volatile atomic_short* __a, short __m, 
2775                             memory_order __x)
2776   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
2777
2778   inline short 
2779   atomic_fetch_add(volatile atomic_short* __a, short __m)
2780   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2781
2782   inline short 
2783   atomic_fetch_sub_explicit(volatile atomic_short* __a, short __m, 
2784                             memory_order __x)
2785   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
2786
2787   inline short 
2788   atomic_fetch_sub(volatile atomic_short* __a, short __m)
2789   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2790
2791   inline short 
2792   atomic_fetch_and_explicit(volatile atomic_short* __a, short __m, 
2793                             memory_order __x)
2794   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
2795
2796   inline short 
2797   atomic_fetch_and(volatile atomic_short* __a, short __m)
2798   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
2799
2800   inline short 
2801   atomic_fetch_or_explicit(volatile atomic_short* __a, short __m, 
2802                            memory_order __x)
2803   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
2804
2805   inline short 
2806   atomic_fetch_or(volatile atomic_short* __a, short __m)
2807   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
2808
2809   inline short 
2810   atomic_fetch_xor_explicit(volatile atomic_short* __a, short __m, 
2811                             memory_order __x)
2812   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
2813
2814   inline short 
2815   atomic_fetch_xor(volatile atomic_short* __a, short __m)
2816   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
2817
2818
2819   inline unsigned short 
2820   atomic_fetch_add_explicit(volatile atomic_ushort* __a, unsigned short __m, 
2821                             memory_order __x)
2822   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
2823
2824   inline unsigned short 
2825   atomic_fetch_add(volatile atomic_ushort* __a, unsigned short __m)
2826   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2827
2828   inline unsigned short 
2829   atomic_fetch_sub_explicit(volatile atomic_ushort* __a, unsigned short __m, 
2830                             memory_order __x)
2831   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
2832
2833   inline unsigned short 
2834   atomic_fetch_sub(volatile atomic_ushort* __a, unsigned short __m)
2835   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2836
2837   inline unsigned short 
2838   atomic_fetch_and_explicit(volatile atomic_ushort* __a, unsigned short __m, 
2839                             memory_order __x)
2840   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
2841
2842   inline unsigned short 
2843   atomic_fetch_and(volatile atomic_ushort* __a, unsigned short __m)
2844   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
2845
2846   inline unsigned short 
2847   atomic_fetch_or_explicit(volatile atomic_ushort* __a, unsigned short __m, 
2848                            memory_order __x)
2849   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
2850
2851   inline unsigned short 
2852   atomic_fetch_or(volatile atomic_ushort* __a, unsigned short __m)
2853   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
2854
2855   inline unsigned short 
2856   atomic_fetch_xor_explicit(volatile atomic_ushort* __a, unsigned short __m, 
2857                             memory_order __x)
2858   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
2859
2860   inline unsigned short 
2861   atomic_fetch_xor(volatile atomic_ushort* __a, unsigned short __m)
2862   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
2863
2864
2865   inline int 
2866   atomic_fetch_add_explicit(volatile atomic_int* __a, int __m, 
2867                             memory_order __x)
2868   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
2869
2870   inline int 
2871   atomic_fetch_add(volatile atomic_int* __a, int __m)
2872   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2873
2874   inline int 
2875   atomic_fetch_sub_explicit(volatile atomic_int* __a, int __m, 
2876                             memory_order __x)
2877   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
2878
2879   inline int 
2880   atomic_fetch_sub(volatile atomic_int* __a, int __m)
2881   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2882
2883   inline int 
2884   atomic_fetch_and_explicit(volatile atomic_int* __a, int __m, 
2885                             memory_order __x)
2886   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
2887
2888   inline int 
2889   atomic_fetch_and(volatile atomic_int* __a, int __m)
2890   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
2891
2892   inline int 
2893   atomic_fetch_or_explicit(volatile atomic_int* __a, int __m, 
2894                            memory_order __x)
2895   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
2896
2897   inline int 
2898   atomic_fetch_or(volatile atomic_int* __a, int __m)
2899   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
2900
2901   inline int 
2902   atomic_fetch_xor_explicit(volatile atomic_int* __a, int __m, 
2903                             memory_order __x)
2904   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
2905
2906   inline int 
2907   atomic_fetch_xor(volatile atomic_int* __a, int __m)
2908   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
2909
2910
2911   inline unsigned int 
2912   atomic_fetch_add_explicit(volatile atomic_uint* __a, unsigned int __m, 
2913                             memory_order __x)
2914   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
2915
2916   inline unsigned int 
2917   atomic_fetch_add(volatile atomic_uint* __a, unsigned int __m)
2918   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2919
2920   inline unsigned int 
2921   atomic_fetch_sub_explicit(volatile atomic_uint* __a, unsigned int __m, 
2922                             memory_order __x)
2923   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
2924
2925   inline unsigned int 
2926   atomic_fetch_sub(volatile atomic_uint* __a, unsigned int __m)
2927   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2928
2929   inline unsigned int 
2930   atomic_fetch_and_explicit(volatile atomic_uint* __a, unsigned int __m, 
2931                             memory_order __x)
2932   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
2933
2934   inline unsigned int 
2935   atomic_fetch_and(volatile atomic_uint* __a, unsigned int __m)
2936   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
2937
2938   inline unsigned int 
2939   atomic_fetch_or_explicit(volatile atomic_uint* __a, unsigned int __m, 
2940                            memory_order __x)
2941   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
2942
2943   inline unsigned int 
2944   atomic_fetch_or(volatile atomic_uint* __a, unsigned int __m)
2945   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
2946
2947   inline unsigned int 
2948   atomic_fetch_xor_explicit(volatile atomic_uint* __a, unsigned int __m, 
2949                             memory_order __x)
2950   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
2951
2952   inline unsigned int 
2953   atomic_fetch_xor(volatile atomic_uint* __a, unsigned int __m)
2954   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
2955
2956
2957   inline long 
2958   atomic_fetch_add_explicit(volatile atomic_long* __a, long __m, 
2959                             memory_order __x)
2960   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
2961
2962   inline long 
2963   atomic_fetch_add(volatile atomic_long* __a, long __m)
2964   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
2965
2966   inline long 
2967   atomic_fetch_sub_explicit(volatile atomic_long* __a, long __m, 
2968                             memory_order __x)
2969   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
2970
2971   inline long 
2972   atomic_fetch_sub(volatile atomic_long* __a, long __m)
2973   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
2974
2975   inline long 
2976   atomic_fetch_and_explicit(volatile atomic_long* __a, long __m, 
2977                             memory_order __x)
2978   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
2979
2980   inline long 
2981   atomic_fetch_and(volatile atomic_long* __a, long __m)
2982   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
2983
2984   inline long 
2985   atomic_fetch_or_explicit(volatile atomic_long* __a, long __m, 
2986                            memory_order __x)
2987   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
2988
2989   inline long 
2990   atomic_fetch_or(volatile atomic_long* __a, long __m)
2991   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
2992
2993   inline long 
2994   atomic_fetch_xor_explicit(volatile atomic_long* __a, long __m, 
2995                             memory_order __x)
2996   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
2997
2998   inline long 
2999   atomic_fetch_xor(volatile atomic_long* __a, long __m)
3000   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
3001
3002
3003   inline unsigned long 
3004   atomic_fetch_add_explicit(volatile atomic_ulong* __a, unsigned long __m, 
3005                             memory_order __x)
3006   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
3007
3008   inline unsigned long 
3009   atomic_fetch_add(volatile atomic_ulong* __a, unsigned long __m)
3010   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
3011
3012   inline unsigned long 
3013   atomic_fetch_sub_explicit(volatile atomic_ulong* __a, unsigned long __m, 
3014                             memory_order __x)
3015   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
3016
3017   inline unsigned long 
3018   atomic_fetch_sub(volatile atomic_ulong* __a, unsigned long __m)
3019   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
3020
3021   inline unsigned long 
3022   atomic_fetch_and_explicit(volatile atomic_ulong* __a, unsigned long __m, 
3023                             memory_order __x)
3024   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
3025
3026   inline unsigned long 
3027   atomic_fetch_and(volatile atomic_ulong* __a, unsigned long __m)
3028   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
3029
3030   inline unsigned long 
3031   atomic_fetch_or_explicit(volatile atomic_ulong* __a, unsigned long __m, 
3032                            memory_order __x)
3033   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
3034
3035   inline unsigned long 
3036   atomic_fetch_or(volatile atomic_ulong* __a, unsigned long __m)
3037   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
3038
3039   inline unsigned long 
3040   atomic_fetch_xor_explicit(volatile atomic_ulong* __a, unsigned long __m, 
3041                             memory_order __x)
3042   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
3043
3044   inline unsigned long 
3045   atomic_fetch_xor(volatile atomic_ulong* __a, unsigned long __m)
3046   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
3047
3048
3049   inline long long 
3050   atomic_fetch_add_explicit(volatile atomic_llong* __a, long long __m, 
3051                             memory_order __x)
3052   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
3053
3054   inline long long 
3055   atomic_fetch_add(volatile atomic_llong* __a, long long __m)
3056   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
3057
3058   inline long long 
3059   atomic_fetch_sub_explicit(volatile atomic_llong* __a, long long __m, 
3060                             memory_order __x)
3061   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
3062
3063   inline long long 
3064   atomic_fetch_sub(volatile atomic_llong* __a, long long __m)
3065   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
3066
3067   inline long long 
3068   atomic_fetch_and_explicit(volatile atomic_llong* __a, 
3069                             long long __m, memory_order __x)
3070   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
3071
3072   inline long long 
3073   atomic_fetch_and(volatile atomic_llong* __a, long long __m)
3074   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
3075
3076   inline long long 
3077   atomic_fetch_or_explicit(volatile atomic_llong* __a, 
3078                            long long __m, memory_order __x)
3079   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
3080
3081   inline long long 
3082   atomic_fetch_or(volatile atomic_llong* __a, long long __m)
3083   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
3084
3085   inline long long 
3086   atomic_fetch_xor_explicit(volatile atomic_llong* __a, 
3087                             long long __m, memory_order __x)
3088   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
3089
3090   inline long long 
3091   atomic_fetch_xor(volatile atomic_llong* __a, long long __m)
3092   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
3093
3094
3095   inline unsigned long long 
3096   atomic_fetch_add_explicit(volatile atomic_ullong* __a, 
3097                             unsigned long long __m, memory_order __x)
3098   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
3099
3100   inline unsigned long long 
3101   atomic_fetch_add(volatile atomic_ullong* __a, unsigned long long __m)
3102   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
3103
3104   inline unsigned long long 
3105   atomic_fetch_sub_explicit(volatile atomic_ullong* __a, 
3106                             unsigned long long __m, memory_order __x)
3107   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
3108
3109   inline unsigned long long 
3110   atomic_fetch_sub(volatile atomic_ullong* __a, unsigned long long __m)
3111   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
3112
3113   inline unsigned long long 
3114   atomic_fetch_and_explicit(volatile atomic_ullong* __a, 
3115                             unsigned long long __m, memory_order __x)
3116   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
3117
3118   inline unsigned long long 
3119   atomic_fetch_and(volatile atomic_ullong* __a, unsigned long long __m)
3120   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
3121
3122   inline unsigned long long 
3123   atomic_fetch_or_explicit(volatile atomic_ullong* __a, 
3124                            unsigned long long __m, memory_order __x)
3125   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
3126
3127   inline unsigned long long 
3128   atomic_fetch_or(volatile atomic_ullong* __a, unsigned long long __m)
3129   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
3130
3131   inline unsigned long long 
3132   atomic_fetch_xor_explicit(volatile atomic_ullong* __a, 
3133                             unsigned long long __m, memory_order __x)
3134   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
3135
3136   inline unsigned long long 
3137   atomic_fetch_xor(volatile atomic_ullong* __a, unsigned long long __m)
3138   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
3139
3140
3141   inline wchar_t 
3142   atomic_fetch_add_explicit(volatile atomic_wchar_t* __a, wchar_t __m, 
3143                             memory_order __x)
3144   { return _ATOMIC_MODIFY_(__a, +=, __m, __x); }
3145
3146   inline wchar_t 
3147   atomic_fetch_add(volatile atomic_wchar_t* __a, wchar_t __m)
3148   { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); }
3149
3150   inline wchar_t 
3151   atomic_fetch_sub_explicit(volatile atomic_wchar_t* __a, wchar_t __m, 
3152                             memory_order __x)
3153   { return _ATOMIC_MODIFY_(__a, -=, __m, __x); }
3154
3155   inline wchar_t 
3156   atomic_fetch_sub(volatile atomic_wchar_t* __a, wchar_t __m)
3157   { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); }
3158
3159   inline wchar_t 
3160   atomic_fetch_and_explicit(volatile atomic_wchar_t* __a, wchar_t __m, 
3161                             memory_order __x)
3162   { return _ATOMIC_MODIFY_(__a, &=, __m, __x); }
3163
3164   inline wchar_t 
3165   atomic_fetch_and(volatile atomic_wchar_t* __a, wchar_t __m)
3166   { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); }
3167
3168   inline wchar_t 
3169   atomic_fetch_or_explicit(volatile atomic_wchar_t* __a, wchar_t __m, 
3170                            memory_order __x)
3171   { return _ATOMIC_MODIFY_(__a, |=, __m, __x); }
3172
3173   inline wchar_t 
3174   atomic_fetch_or(volatile atomic_wchar_t* __a, wchar_t __m)
3175   { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); }
3176
3177   inline wchar_t 
3178   atomic_fetch_xor_explicit(volatile atomic_wchar_t* __a, wchar_t __m, 
3179                             memory_order __x)
3180   { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); }
3181
3182   inline wchar_t 
3183   atomic_fetch_xor(volatile atomic_wchar_t* __a, wchar_t __m)
3184   { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); }
3185
3186   inline bool 
3187   atomic_bool::is_lock_free() const volatile
3188   { return false; }
3189
3190   inline void 
3191   atomic_bool::store(bool __m, memory_order __x) volatile
3192   { atomic_store_explicit(this, __m, __x); }
3193
3194   inline bool 
3195   atomic_bool::load(memory_order __x) volatile
3196   { return atomic_load_explicit(this, __x); }
3197
3198   inline bool 
3199   atomic_bool::swap(bool __m, memory_order __x) volatile
3200   { return atomic_swap_explicit(this, __m, __x); }
3201
3202   inline bool 
3203   atomic_bool::compare_swap(bool& __e, bool __m, memory_order __x, 
3204                             memory_order __y) volatile
3205   { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); }
3206
3207   inline bool 
3208   atomic_bool::compare_swap(bool& __e, bool __m, memory_order __x) volatile
3209   {
3210     const bool __cond1 = __x == memory_order_release;
3211     const bool __cond2 = __x == memory_order_acq_rel;
3212     memory_order __mo1(__cond1 ? memory_order_relaxed : __x);
3213     memory_order __mo2(__cond2 ? memory_order_acquire : __mo1);
3214     return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2);
3215   }
3216
3217   inline void 
3218   atomic_bool::fence(memory_order __x) const volatile
3219   { return atomic_fence(this, __x); }
3220
3221
3222   inline bool 
3223   atomic_char::is_lock_free() const volatile
3224   { return false; }
3225
3226   inline void 
3227   atomic_char::store(char __m, memory_order __x) volatile
3228   { atomic_store_explicit(this, __m, __x); }
3229
3230   inline char 
3231   atomic_char::load(memory_order __x) volatile
3232   { return atomic_load_explicit(this, __x); }
3233
3234   inline char 
3235   atomic_char::swap(char __m, memory_order __x) volatile
3236   { return atomic_swap_explicit(this, __m, __x); }
3237
3238   inline bool 
3239   atomic_char::compare_swap(char& __e, char __m,
3240                             memory_order __x, memory_order __y) volatile
3241   { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); }
3242
3243   inline bool 
3244   atomic_char::compare_swap(char& __e, char __m, memory_order __x) volatile
3245   {
3246     const bool __cond1 = __x == memory_order_release;
3247     const bool __cond2 = __x == memory_order_acq_rel;
3248     memory_order __mo1(__cond1 ? memory_order_relaxed : __x);
3249     memory_order __mo2(__cond2 ? memory_order_acquire : __mo1);
3250     return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2);
3251   }
3252
3253   inline void 
3254   atomic_char::fence(memory_order __x) const volatile
3255   { return atomic_fence(this, __x); }
3256
3257
3258   inline bool 
3259   atomic_schar::is_lock_free() const volatile
3260   { return false; }
3261
3262   inline void 
3263   atomic_schar::store(signed char __m, memory_order __x) volatile
3264   { atomic_store_explicit(this, __m, __x); }
3265
3266   inline signed char 
3267   atomic_schar::load(memory_order __x) volatile
3268   { return atomic_load_explicit(this, __x); }
3269
3270   inline signed char 
3271   atomic_schar::swap(signed char __m, memory_order __x) volatile
3272   { return atomic_swap_explicit(this, __m, __x); }
3273
3274   inline bool 
3275   atomic_schar::compare_swap(signed char& __e, signed char __m,
3276                              memory_order __x, memory_order __y) volatile
3277   { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); }
3278
3279   inline bool 
3280   atomic_schar::compare_swap(signed char& __e, signed char __m, 
3281                              memory_order __x) volatile
3282   {
3283     const bool __cond1 = __x == memory_order_release;
3284     const bool __cond2 = __x == memory_order_acq_rel;
3285     memory_order __mo1(__cond1 ? memory_order_relaxed : __x);
3286     memory_order __mo2(__cond2 ? memory_order_acquire : __mo1);
3287     return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2);
3288   }
3289
3290   inline void 
3291   atomic_schar::fence(memory_order __x) const volatile
3292   { return atomic_fence(this, __x); }
3293
3294   inline bool 
3295   atomic_uchar::is_lock_free() const volatile
3296   { return false; }
3297
3298   inline void 
3299   atomic_uchar::store(unsigned char __m, memory_order __x) volatile
3300   { atomic_store_explicit(this, __m, __x); }
3301
3302   inline unsigned char 
3303   atomic_uchar::load(memory_order __x) volatile
3304   { return atomic_load_explicit(this, __x); }
3305
3306   inline unsigned char 
3307   atomic_uchar::swap(unsigned char __m, memory_order __x) volatile
3308   { return atomic_swap_explicit(this, __m, __x); }
3309
3310   inline bool 
3311   atomic_uchar::compare_swap(unsigned char& __e, unsigned char __m,
3312                              memory_order __x, memory_order __y) volatile
3313   { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); }
3314
3315   inline bool 
3316   atomic_uchar::compare_swap(unsigned char& __e, unsigned char __m, 
3317                              memory_order __x) volatile
3318   {
3319     const bool __cond1 = __x == memory_order_release;
3320     const bool __cond2 = __x == memory_order_acq_rel;
3321     memory_order __mo1(__cond1 ? memory_order_relaxed : __x);
3322     memory_order __mo2(__cond2 ? memory_order_acquire : __mo1);
3323     return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2);
3324   }
3325
3326   inline void 
3327   atomic_uchar::fence(memory_order __x) const volatile
3328   { return atomic_fence(this, __x); }
3329
3330
3331   inline bool 
3332   atomic_short::is_lock_free() const volatile
3333   { return false; }
3334
3335   inline void 
3336   atomic_short::store(short __m, memory_order __x) volatile
3337   { atomic_store_explicit(this, __m, __x); }
3338
3339   inline short 
3340   atomic_short::load(memory_order __x) volatile
3341   { return atomic_load_explicit(this, __x); }
3342
3343   inline short 
3344   atomic_short::swap(short __m, memory_order __x) volatile
3345   { return atomic_swap_explicit(this, __m, __x); }
3346
3347   inline bool 
3348   atomic_short::compare_swap(short& __e, short __m,
3349                              memory_order __x, memory_order __y) volatile
3350   { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); }
3351
3352   inline bool 
3353   atomic_short::compare_swap(short& __e, short __m, memory_order __x) volatile
3354   {
3355     const bool __cond1 = __x == memory_order_release;
3356     const bool __cond2 = __x == memory_order_acq_rel;
3357     memory_order __mo1(__cond1 ? memory_order_relaxed : __x);
3358     memory_order __mo2(__cond2 ? memory_order_acquire : __mo1);
3359     return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2);
3360   }
3361
3362   inline void 
3363   atomic_short::fence(memory_order __x) const volatile
3364   { return atomic_fence(this, __x); }
3365