diff options
51 files changed, 6402 insertions, 74 deletions
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 27bf89d22fc..3877bc30ac1 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,5 +1,93 @@ 2008-04-10 Benjamin Kosnik <bkoz@redhat.com> + * include/c_global/cstdatomic: C++ types only, format, doxygen markup. + * include/c_compatibility/stdatomic.h: "C" only, format, doxygen markup. + * src/atomic.c: Format, doxygen markup, edits. + + * include/Makefile.am (cstdatomic, stdatomic.h): Add. + * src/Makefile.am (atomic.c): Add. + * acinclude.m4 (GLIBCXX_CHECK_STANDARD_LAYOUT): New. + * configure.ac: Call it. + * include/Makefile.in: Regenerate. + * src/Makefile.in: Same. + * Makefile.in: Same. + * doc/Makefile.in: Same. + * po/Makefile.in: Same. + * libmath/Makefile.in: Same. + * include/Makefile.in: Same. + * testsuite/Makefile.in: Same. + * libsupc++/Makefile.in: Same. + * config.h.in: Same. + * configure: Same. + + * config/abi/pre/gnu.ver: Add atomics exports. + + * include/ext/typelist.h (apply_generator): New. + * include/bits/c++config (_GLIBCXX_BEGIN_EXTERN_C): New. + (_GLIBCXX_END_EXTERN_C): New. + Deal with _GLIBCXX_BEGIN_NAMESPACE, _GLIBCXX_END_NAMESPACE when + compiling as C. + * testsuite/lib/libstdc++.exp (v3_target_compile_as_c): Add -L + flag for libstdc++. + * testsuite/util/testsuite_common_types.h (integral_types): New + typelist. + (atomics, atomics_tl): Same. + (assignable, default_constructible, copy_constructible, + explicit_value_constructible): New. + * testsuite/17_intro/headers/c++200x/all.cc: Test new headers. + * testsuite/29_atomics: New. + * testsuite/29_atomics/atomic_address: Same. + * testsuite/29_atomics/atomic_address/cons: Same. + * testsuite/29_atomics/atomic_address/cons/explicit_value.cc: Same. + * testsuite/29_atomics/atomic_address/cons/assign_neg.cc: Same. + * testsuite/29_atomics/atomic_address/cons/copy_neg.cc: Same. + * testsuite/29_atomics/atomic_address/cons/default.cc: Same. + * testsuite/29_atomics/atomic_address/cons/aggregate.cc: Same. + * testsuite/29_atomics/atomic_flag: Same. + * testsuite/29_atomics/atomic_flag/cons: Same. + * testsuite/29_atomics/atomic_flag/cons/assign_neg.cc: Same. + * testsuite/29_atomics/atomic_flag/cons/copy_neg.cc: Same. + * testsuite/29_atomics/atomic_flag/cons/default.cc: Same. + * testsuite/29_atomics/atomic_flag/cons/aggregate.cc: Same. + * testsuite/29_atomics/atomic_flag/requirements: Same. + * testsuite/29_atomics/atomic_flag/requirements/standard_layout.cc: + Same. + * testsuite/29_atomics/atomic_flag/ + atomic_global_fence_compatibility.cc: Same. + * testsuite/29_atomics/atomic_flag/test_and_set: Same. + * testsuite/29_atomics/atomic_flag/test_and_set/explicit.c: Same. + * testsuite/29_atomics/atomic_flag/test_and_set/explicit.cc: Same. + * testsuite/29_atomics/atomic_flag/test_and_set/implicit.c: Same. + * testsuite/29_atomics/atomic_flag/test_and_set/implicit.cc: Same. + * testsuite/29_atomics/headers: Same. + * testsuite/29_atomics/headers/cstdatomic: Same. + * testsuite/29_atomics/headers/cstdatomic/types_std_c++0x.cc: Same. + * testsuite/29_atomics/headers/cstdatomic/functions_std_c++0x.cc: Same. + * testsuite/29_atomics/headers/cstdatomic/std_c++0x_neg.cc: Same. + * testsuite/29_atomics/headers/cstdatomic/macros.cc: Same. + * testsuite/29_atomics/headers/stdatomic.h: Same. + * testsuite/29_atomics/headers/stdatomic.h/macros.c: Same. + * testsuite/29_atomics/headers/stdatomic.h/types.c: Same. + * testsuite/29_atomics/headers/stdatomic.h/functions.c: Same. + * testsuite/29_atomics/atomic: Same. + * testsuite/29_atomics/atomic/cons: Same. + * testsuite/29_atomics/atomic/cons/explicit_value.cc: Same. + * testsuite/29_atomics/atomic/cons/assign_neg.cc: Same. + * testsuite/29_atomics/atomic/cons/copy_neg.cc: Same. + * testsuite/29_atomics/atomic/cons/default.cc: Same. + * testsuite/29_atomics/atomic/requirements: Same. + * testsuite/29_atomics/atomic/requirements/explicit_instantiation: Same. + * testsuite/29_atomics/atomic/requirements/explicit_instantiation/ + 1.cc: Same. + +2008-04-10 Lawrence Crowl <crowl@google.com> + + * include/c_global/cstdatomic: New. + * include/c_compatibility/stdatomic.h: New. + * src/atomic.c: New. + +2008-04-10 Benjamin Kosnik <bkoz@redhat.com> + * include/std/tuple: Consistency check for include guard, doxygen file markup. * include/std/date_time: Same. @@ -165,6 +253,7 @@ * doc/xml/manual/parallel_mode.xml: Correct configuration documentation. * doc/html/manual/bk01pt12ch31s04.html: Regenerate. +>>>>>>> .r133664 2008-03-18 Benjamin Kosnik <bkoz@redhat.com> * configure.ac (libtool_VERSION): To 6:11:0. diff --git a/libstdc++-v3/Makefile.in b/libstdc++-v3/Makefile.in index 76397b3b914..146704405ff 100644 --- a/libstdc++-v3/Makefile.in +++ b/libstdc++-v3/Makefile.in @@ -54,6 +54,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/enable.m4 \ $(top_srcdir)/../config/lib-prefix.m4 \ $(top_srcdir)/../config/multi.m4 \ $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/proginstall.m4 \ $(top_srcdir)/../config/unwind_ipinfo.m4 \ $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \ $(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \ diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4 index 92c70b29079..e1712b77d80 100644 --- a/libstdc++-v3/acinclude.m4 +++ b/libstdc++-v3/acinclude.m4 @@ -1477,6 +1477,46 @@ AC_DEFUN([GLIBCXX_CHECK_SYSTEM_ERROR], [ ]) dnl +dnl Check whether C++200x's standard layout types are supported. +dnl +AC_DEFUN([GLIBCXX_CHECK_STANDARD_LAYOUT], [ + + AC_MSG_CHECKING([for ISO C++200x standard layout type support]) + AC_CACHE_VAL(ac_standard_layout, [ + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS='-std=gnu++0x' + + AC_TRY_COMPILE([struct b + { + bool t; + + // Need standard layout relaxation from POD + private: + b& operator=(const b&); + b(const b&); + }; + + int main() + { + b tst1 = { false }; + return 0; + }],, + [ac_standard_layout=yes], [ac_standard_layout=no]) + + CXXFLAGS="$ac_save_CXXFLAGS" + AC_LANG_RESTORE + ]) + AC_MSG_RESULT($ac_standard_layout) + if test x"$ac_standard_layout" = x"yes"; then + AC_DEFINE(_GLIBCXX_USE_STANDARD_LAYOUT, 1, + [Define if standard layout types are supported in C++200x.]) + fi +]) + +dnl dnl Check for what type of C headers to use. dnl dnl --enable-cheaders= [does stuff]. diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in index 39ce4a9305c..52acd2c2f0d 100644 --- a/libstdc++-v3/config.h.in +++ b/libstdc++-v3/config.h.in @@ -815,6 +815,9 @@ TR1 (Chapter 5.1). */ #undef _GLIBCXX_USE_RANDOM_TR1 +/* Define if standard layout types are supported in C++200x. */ +#undef _GLIBCXX_USE_STANDARD_LAYOUT + /* Define if code specialized for wchar_t should be used. */ #undef _GLIBCXX_USE_WCHAR_T diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver index 1d35bfbbd37..3e5a9240513 100644 --- a/libstdc++-v3/config/abi/pre/gnu.ver +++ b/libstdc++-v3/config/abi/pre/gnu.ver @@ -26,7 +26,11 @@ GLIBCXX_3.4 { # Names inside the 'extern' block are demangled names. extern "C++" { - std::[A-Za]*; + std::[A-Z]*; + std::a[a-c]*; + std::ad[a-n]*; + std::ad[p-z]*; + std::a[e-z]*; # std::ba[a-r]*; std::basic_[a-e]*; std::basic_f[a-r]*; @@ -61,7 +65,9 @@ GLIBCXX_3.4 { std::c[i-s]*; std::c[u-z]*; # std::[d-g]*; - std::[d-e]*; + std::d[a-d]*; + std::d[f-z]*; + std::e*; std::gslice*; std::h[^a]*; std::i[a-n]*; @@ -120,7 +126,6 @@ GLIBCXX_3.4 { std::_List_node_base::unhook*; std::_List_node_base::reverse*; std::_List_node_base::transfer*; - std::__throw_*; std::__timepunct*; std::__numeric_limits_base*; std::__num_base::_S_format_float*; @@ -135,23 +140,6 @@ GLIBCXX_3.4 { # Names not in an 'extern' block are mangled names. - # __gnu_debug::_Safe_sequence_base and _Safe_iterator_base - _ZN11__gnu_debug19_Safe_sequence_base13_M_detach_allEv; - _ZN11__gnu_debug19_Safe_sequence_base18_M_detach_singularEv; - _ZN11__gnu_debug19_Safe_sequence_base22_M_revalidate_singularEv; - _ZN11__gnu_debug19_Safe_sequence_base7_M_swapERS0_; - _ZN11__gnu_debug19_Safe_iterator_base9_M_attachEPNS_19_Safe_sequence_baseEb; - _ZN11__gnu_debug19_Safe_iterator_base9_M_detachEv; - _ZNK11__gnu_debug19_Safe_iterator_base11_M_singularEv; - _ZNK11__gnu_debug19_Safe_iterator_base14_M_can_compareERKS0_; - - # __gnu_debug::_Error_formatter - _ZNK11__gnu_debug16_Error_formatter10_M_message*; - _ZNK11__gnu_debug16_Error_formatter10_Parameter*; - _ZNK11__gnu_debug16_Error_formatter13_M_print_word*; - _ZNK11__gnu_debug16_Error_formatter15_M_print_string*; - _ZNK11__gnu_debug16_Error_formatter8_M_error*; - # std::string _ZNSsC*; _ZNSsD*; @@ -436,6 +424,39 @@ GLIBCXX_3.4 { _ZN10__gnu_norm15_List_node_base7reverseEv; _ZN10__gnu_norm15_List_node_base8transfer*; + # __gnu_debug::_Safe_sequence_base and _Safe_iterator_base + _ZN11__gnu_debug19_Safe_sequence_base13_M_detach_allEv; + _ZN11__gnu_debug19_Safe_sequence_base18_M_detach_singularEv; + _ZN11__gnu_debug19_Safe_sequence_base22_M_revalidate_singularEv; + _ZN11__gnu_debug19_Safe_sequence_base7_M_swapERS0_; + _ZN11__gnu_debug19_Safe_iterator_base9_M_attachEPNS_19_Safe_sequence_baseEb; + _ZN11__gnu_debug19_Safe_iterator_base9_M_detachEv; + _ZNK11__gnu_debug19_Safe_iterator_base11_M_singularEv; + _ZNK11__gnu_debug19_Safe_iterator_base14_M_can_compareERKS0_; + + # __gnu_debug::_Error_formatter + _ZNK11__gnu_debug16_Error_formatter10_M_message*; + _ZNK11__gnu_debug16_Error_formatter10_Parameter*; + _ZNK11__gnu_debug16_Error_formatter13_M_print_word*; + _ZNK11__gnu_debug16_Error_formatter15_M_print_string*; + _ZNK11__gnu_debug16_Error_formatter8_M_error*; + + # exceptions as functions + _ZSt16__throw_bad_castv; + _ZSt17__throw_bad_allocv; + _ZSt18__throw_bad_typeidv; + _ZSt19__throw_ios_failurePKc; + _ZSt19__throw_logic_errorPKc; + _ZSt19__throw_range_errorPKc; + _ZSt20__throw_domain_errorPKc; + _ZSt20__throw_length_errorPKc; + _ZSt20__throw_out_of_rangePKc; + _ZSt21__throw_bad_exceptionv; + _ZSt21__throw_runtime_errorPKc; + _ZSt22__throw_overflow_errorPKc; + _ZSt23__throw_underflow_errorPKc; + _ZSt24__throw_invalid_argumentPKc; + # operator new(size_t) _Znw[jm]; # operator new(size_t, std::nothrow_t const&) @@ -464,7 +485,10 @@ GLIBCXX_3.4 { # _ZTVSt[0-9][0-9][A-Za-z]*; _ZTVSt[0-9][0-9][A-Z]*; _ZTVSt[0-9][0-9][a-d]*; - _ZTVSt[0-9][0-9][f-r]*; + _ZTVSt[0-9][0-9][f-k]*; + _ZTVSt11logic_error; + _ZTVSt12length_error; + _ZTVSt[0-9][0-9][m-r]*; _ZTVSt[0-9][0-9][t-z]*; _ZTVSt[0-9][0-9]e[^r]*; _ZTVSt[0-9][0-9]s[^y]*; @@ -484,7 +508,10 @@ GLIBCXX_3.4 { # _ZTISt[0-9][0-9][A-Za-z]*; _ZTISt[0-9][0-9][A-Z]*; _ZTISt[0-9][0-9][a-d]*; - _ZTISt[0-9][0-9][f-r]*; + _ZTISt[0-9][0-9][f-k]*; + _ZTISt11logic_error; + _ZTISt12length_error; + _ZTISt[0-9][0-9][m-r]*; _ZTISt[0-9][0-9][t-z]*; _ZTISt[0-9][0-9]e[^r]*; _ZTISt[0-9][0-9]s[^y]*; @@ -508,7 +535,10 @@ GLIBCXX_3.4 { # _ZTSSt[0-9][0-9][A-Za-z]*; _ZTSSt[0-9][0-9][A-Z]*; _ZTSSt[0-9][0-9][a-d]*; - _ZTSSt[0-9][0-9][f-r]*; + _ZTSSt[0-9][0-9][f-k]*; + _ZTSSt11logic_error; + _ZTSSt12length_error; + _ZTSSt[0-9][0-9][m-r]*; _ZTSSt[0-9][0-9][t-z]*; _ZTSSt[0-9][0-9]e[^r]*; _ZTSSt[0-9][0-9]s[^y]*; @@ -785,13 +815,23 @@ GLIBCXX_3.4.10 { _ZNSt15basic_streambufI[cw]St11char_traitsI[cw]EE6stosscEv; - _ZN9__gnu_cxx18stdio_sync_filebufI[cw]St11char_traitsI[cw]EE4syncEv; _ZN9__gnu_cxx18stdio_sync_filebufI[cw]St11char_traitsI[cw]EE[5-9CD]*; } GLIBCXX_3.4.9; GLIBCXX_3.4.11 { + + # atomic + __atomic_flag_for_address; + __atomic_flag_wait_explicit; + atomic_flag_clear; + atomic_flag_clear_explicit; + atomic_flag_fence; + atomic_flag_test_and_set; + atomic_flag_test_and_set_explicit; + atomic_global_fence_compatibility; + # system_error _ZSt15system_category; diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure index 9a6ec5256bb..6e6e1996e62 100755 --- a/libstdc++-v3/configure +++ b/libstdc++-v3/configure @@ -17947,6 +17947,106 @@ _ACEOF fi + + echo "$as_me:$LINENO: checking for ISO C++200x standard layout type support" >&5 +echo $ECHO_N "checking for ISO C++200x standard layout type support... $ECHO_C" >&6 + if test "${ac_standard_layout+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + + + + ac_ext=cc +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS='-std=gnu++0x' + + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +struct b + { + bool t; + + // Need standard layout relaxation from POD + private: + b& operator=(const b&); + b(const b&); + }; + + int main() + { + b tst1 = { false }; + return 0; + } +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_cxx_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_standard_layout=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_standard_layout=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + + CXXFLAGS="$ac_save_CXXFLAGS" + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +fi + + echo "$as_me:$LINENO: result: $ac_standard_layout" >&5 +echo "${ECHO_T}$ac_standard_layout" >&6 + if test x"$ac_standard_layout" = x"yes"; then + +cat >>confdefs.h <<\_ACEOF +#define _GLIBCXX_USE_STANDARD_LAYOUT 1 +_ACEOF + + fi + + # No surprises, no surprises... echo "$as_me:$LINENO: checking for thread model used by GCC" >&5 @@ -17988,7 +18088,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu # Fake what AC_TRY_COMPILE does. XXX Look at redoing this new-style. cat > conftest.$ac_ext << EOF -#line 17991 "configure" +#line 18091 "configure" int main() { // NB: _Atomic_word not necessarily int. diff --git a/libstdc++-v3/configure.ac b/libstdc++-v3/configure.ac index 1760aebdf0d..1930189ab5d 100644 --- a/libstdc++-v3/configure.ac +++ b/libstdc++-v3/configure.ac @@ -113,6 +113,7 @@ GLIBCXX_ENABLE_FULLY_DYNAMIC_STRING([no]) # Checks for operating systems support that don't require linking. GLIBCXX_CHECK_SYSTEM_ERROR +GLIBCXX_CHECK_STANDARD_LAYOUT # No surprises, no surprises... GLIBCXX_ENABLE_THREADS diff --git a/libstdc++-v3/doc/Makefile.in b/libstdc++-v3/doc/Makefile.in index b40e51059af..da58aa6abf0 100644 --- a/libstdc++-v3/doc/Makefile.in +++ b/libstdc++-v3/doc/Makefile.in @@ -49,6 +49,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/enable.m4 \ $(top_srcdir)/../config/lib-prefix.m4 \ $(top_srcdir)/../config/multi.m4 \ $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/proginstall.m4 \ $(top_srcdir)/../config/unwind_ipinfo.m4 \ $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \ $(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \ diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 68e8e35b3de..0d002273c57 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -620,6 +620,7 @@ c_base_headers = \ ${c_base_srcdir}/csetjmp \ ${c_base_srcdir}/csignal \ ${c_base_srcdir}/cstdarg \ + ${c_base_srcdir}/cstdatomic \ ${c_base_srcdir}/cstdbool \ ${c_base_srcdir}/cstddef \ ${c_base_srcdir}/cstdint \ @@ -643,7 +644,8 @@ if GLIBCXX_C_HEADERS_C_GLOBAL c_compatibility_headers = \ ${c_compatibility_srcdir}/complex.h \ ${c_compatibility_srcdir}/fenv.h \ - ${c_compatibility_srcdir}/tgmath.h + ${c_compatibility_srcdir}/tgmath.h \ + ${c_compatibility_srcdir}/stdatomic.h endif if GLIBCXX_C_HEADERS_C diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 94038f8435f..9bd5091f132 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -49,6 +49,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/enable.m4 \ $(top_srcdir)/../config/lib-prefix.m4 \ $(top_srcdir)/../config/multi.m4 \ $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/proginstall.m4 \ $(top_srcdir)/../config/unwind_ipinfo.m4 \ $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \ $(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \ @@ -867,6 +868,7 @@ c_base_headers = \ ${c_base_srcdir}/csetjmp \ ${c_base_srcdir}/csignal \ ${c_base_srcdir}/cstdarg \ + ${c_base_srcdir}/cstdatomic \ ${c_base_srcdir}/cstdbool \ ${c_base_srcdir}/cstddef \ ${c_base_srcdir}/cstdint \ @@ -885,7 +887,8 @@ c_compatibility_builddir = . @GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@c_compatibility_headers = \ @GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/complex.h \ @GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/fenv.h \ -@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/tgmath.h +@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/tgmath.h \ +@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/stdatomic.h @GLIBCXX_C_HEADERS_C_STD_TRUE@c_compatibility_headers = @GLIBCXX_C_HEADERS_C_TRUE@c_compatibility_headers = \ diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config index d42cb9feb47..e38cfe05184 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -1,7 +1,7 @@ // Predefined symbols and macros -*- C++ -*- // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, -// 2006, 2007 Free Software Foundation, Inc. +// 2006, 2007, 2008 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -216,6 +216,20 @@ namespace std } #endif +// Defines for C compatibility. In particular, define extern "C" +// linkage only when using C++, same with namespaces. +#if __cplusplus +# define _GLIBCXX_BEGIN_EXTERN_C extern "C" { +# define _GLIBCXX_END_EXTERN_C } +#else +# define _GLIBCXX_BEGIN_EXTERN_C +# define _GLIBCXX_END_EXTERN_C +# undef _GLIBCXX_BEGIN_NAMESPACE +# undef _GLIBCXX_END_NAMESPACE +# define _GLIBCXX_BEGIN_NAMESPACE(X) +# define _GLIBCXX_END_NAMESPACE +#endif + // Define if compatibility should be provided for -mlong-double-64. #undef _GLIBCXX_LONG_DOUBLE_COMPAT diff --git a/libstdc++-v3/include/c_compatibility/stdatomic.h b/libstdc++-v3/include/c_compatibility/stdatomic.h new file mode 100644 index 00000000000..e5f7dcfe6c1 --- /dev/null +++ b/libstdc++-v3/include/c_compatibility/stdatomic.h @@ -0,0 +1,387 @@ +// -*- C++ -*- compatibility header. + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02110-1301, USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file stdatomic.h + * This is a Standard C++ Library header. + */ + +#include <bits/c++config.h> +#include <stddef.h> +#include <stdbool.h> // XXX need to define bool w/o stdbool.h in tr1/cstdbool + +#ifndef _GLIBCXX_STDATOMIC_H +#define _GLIBCXX_STDATOMIC_H 1 + +_GLIBCXX_BEGIN_NAMESPACE(std) +_GLIBCXX_BEGIN_EXTERN_C + + /// Enumeration for memory_order + typedef enum memory_order + { + memory_order_relaxed, + memory_order_acquire, + memory_order_release, + memory_order_acq_rel, + memory_order_seq_cst + } memory_order; + + + // Base for atomic_flag. + struct __atomic_flag_base + { + bool _M_b; + }; + + // Base for atomic_address + struct __atomic_address_base + { + void* _M_i; + }; + + // POD base classes for atomic intgral types. + struct __atomic_bool_base + { + bool _M_i; + }; + + struct __atomic_char_base + { + char _M_i; + }; + + struct __atomic_schar_base + { + signed char _M_i; + }; + + struct __atomic_uchar_base + { + unsigned char _M_i; + }; + + struct __atomic_short_base + { + short _M_i; + }; + + struct __atomic_ushort_base + { + unsigned short _M_i; + }; + + struct __atomic_int_base + { + int _M_i; + }; + + struct __atomic_uint_base + { + unsigned int _M_i; + }; + + struct __atomic_long_base + { + long _M_i; + }; + + struct __atomic_ulong_base + { + unsigned long _M_i; + }; + + struct __atomic_llong_base + { + long long _M_i; + }; + + struct __atomic_ullong_base + { + unsigned long long _M_i; + }; + + struct __atomic_wchar_t_base + { + wchar_t _M_i; + }; + + // Switch atomic integral base types based on C or C++. In + // addition, for "C" only provide type-generic macros for atomic + // operations. (As C++ accomplishes the same thing with sets of + // overloaded functions. +#ifdef __cplusplus + +#define ATOMIC_FLAG_INIT { { false } } +#define _ATOMIC_MEMBER_ ((__a)->_M_base._M_i) + +extern "C++" +{ + struct atomic_flag; + struct atomic_address; + struct atomic_bool; + struct atomic_char; + struct atomic_schar; + struct atomic_uchar; + struct atomic_short; + struct atomic_ushort; + struct atomic_int; + struct atomic_uint; + struct atomic_long; + struct atomic_ulong; + struct atomic_llong; + struct atomic_ullong; + struct atomic_wchar_t; + template<typename _Tp> + struct atomic; +} +#else + +#define ATOMIC_FLAG_INIT { false } +#define _ATOMIC_MEMBER_ ((__a)->_M_i) + + typedef struct __atomic_flag_base atomic_flag; + typedef struct __atomic_address_base atomic_address; + typedef struct __atomic_bool_base atomic_bool; + typedef struct __atomic_char_base atomic_char; + typedef struct __atomic_schar_base atomic_schar; + typedef struct __atomic_uchar_base atomic_uchar; + typedef struct __atomic_short_base atomic_short; + typedef struct __atomic_ushort_base atomic_ushort; + typedef struct __atomic_int_base atomic_int; + typedef struct __atomic_uint_base atomic_uint; + typedef struct __atomic_long_base atomic_long; + typedef struct __atomic_ulong_base atomic_ulong; + typedef struct __atomic_llong_base atomic_llong; + typedef struct __atomic_ullong_base atomic_ullong; + typedef struct __atomic_wchar_t_base atomic_wchar_t; + +#define atomic_is_lock_free(__a) \ + false + +#define atomic_load(__a) \ + _ATOMIC_LOAD_(__a, memory_order_seq_cst) + +#define atomic_load_explicit(__a, __x) \ + _ATOMIC_LOAD_(__a, __x) + +#define atomic_store(__a, __m) \ + _ATOMIC_STORE_(__a, __m, memory_order_seq_cst) + +#define atomic_store_explicit(__a, __m, __x) \ + _ATOMIC_STORE_(__a, __m, __x) + +#define atomic_swap(__a, __m) \ + _ATOMIC_MODIFY_(__a, =, __m, memory_order_seq_cst) + +#define atomic_swap_explicit(__a, __m, __x) \ + _ATOMIC_MODIFY_(__a, =, __m, __x) + +#define atomic_compare_swap(__a, __e, __m) \ + _ATOMIC_CMPSWP_(__a, __e, __m, memory_order_seq_cst) + +#define atomic_compare_swap_explicit(__a, __e, __m, __x, __y) \ + _ATOMIC_CMPSWP_(__a, __e, __m, __x) + +#define atomic_fence(__a, __x) \ + ({ _ATOMIC_FENCE_(__a, __x); }) + +#define atomic_fetch_add_explicit(__a, __m, __x) \ + _ATOMIC_MODIFY_(__a, +=, __m, __x) + +#define atomic_fetch_add(__a, __m) \ + _ATOMIC_MODIFY_(__a, +=, __m, memory_order_seq_cst) + +#define atomic_fetch_sub_explicit(__a, __m, __x) \ + _ATOMIC_MODIFY_(__a, -=, __m, __x) + +#define atomic_fetch_sub(__a, __m) \ + _ATOMIC_MODIFY_(__a, -=, __m, memory_order_seq_cst) + +#define atomic_fetch_and_explicit(__a, __m, __x) \ + _ATOMIC_MODIFY_(__a, &=, __m, __x) + +#define atomic_fetch_and(__a, __m) \ + _ATOMIC_MODIFY_(__a, &=, __m, memory_order_seq_cst) + +#define atomic_fetch_or_explicit(__a, __m, __x) \ + _ATOMIC_MODIFY_(__a, |=, __m, __x) + +#define atomic_fetch_or(__a, __m) \ + _ATOMIC_MODIFY_(__a, |=, __m, memory_order_seq_cst) + +#define atomic_fetch_xor_explicit(__a, __m, __x) \ + _ATOMIC_MODIFY_(__a, ^=, __m, __x) + +#define atomic_fetch_xor(__a, __m) \ + _ATOMIC_MODIFY_(__a, ^=, __m, memory_order_seq_cst) + +#endif + + // Typedefs for other atomic integral types. + typedef atomic_schar atomic_int_least8_t; + typedef atomic_uchar atomic_uint_least8_t; + typedef atomic_short atomic_int_least16_t; + typedef atomic_ushort atomic_uint_least16_t; + typedef atomic_int atomic_int_least32_t; + typedef atomic_uint atomic_uint_least32_t; + typedef atomic_llong atomic_int_least64_t; + typedef atomic_ullong atomic_uint_least64_t; + + typedef atomic_schar atomic_int_fast8_t; + typedef atomic_uchar atomic_uint_fast8_t; + typedef atomic_short atomic_int_fast16_t; + typedef atomic_ushort atomic_uint_fast16_t; + typedef atomic_int atomic_int_fast32_t; + typedef atomic_uint atomic_uint_fast32_t; + typedef atomic_llong atomic_int_fast64_t; + typedef atomic_ullong atomic_uint_fast64_t; + + typedef atomic_long atomic_intptr_t; + typedef atomic_ulong atomic_uintptr_t; + + typedef atomic_long atomic_ssize_t; + typedef atomic_ulong atomic_size_t; + + typedef atomic_llong atomic_intmax_t; + typedef atomic_ullong atomic_uintmax_t; + + typedef atomic_long atomic_ptrdiff_t; + + typedef atomic_int_least16_t atomic_char16_t; + typedef atomic_int_least32_t atomic_char32_t; + + // Accessor functions for atomic_flag. + extern bool + atomic_flag_test_and_set(volatile atomic_flag*); + + extern bool + atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order); + + extern void + atomic_flag_clear(volatile atomic_flag*); + + extern void + atomic_flag_clear_explicit(volatile atomic_flag*, memory_order); + + extern void + atomic_flag_fence(const volatile atomic_flag*, memory_order); + + extern void + __atomic_flag_wait_explicit(volatile atomic_flag*, memory_order); + + extern volatile atomic_flag* + __atomic_flag_for_address(const volatile void* __z) __attribute__((const)); + + // External object. + extern const atomic_flag atomic_global_fence_compatibility; + + /// 29.2 Lock-free Property +#define ATOMIC_INTEGRAL_LOCK_FREE 0 +#define ATOMIC_ADDRESS_LOCK_FREE 0 + + // Implementation specific defines. +#define _ATOMIC_LOAD_(__a, __x) \ + ({ volatile __typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + volatile atomic_flag* __g = __atomic_flag_for_address(__p); \ + __atomic_flag_wait_explicit(__g, __x); \ + __typeof__ _ATOMIC_MEMBER_ __r = *__p; \ + atomic_flag_clear_explicit(__g, __x); \ + __r; }) + +#define _ATOMIC_STORE_(__a, __m, __x) \ + ({ volatile __typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + __typeof__(__m) __v = (__m); \ + volatile atomic_flag* __g = __atomic_flag_for_address(__p); \ + __atomic_flag_wait_explicit(__g, __x); \ + *__p = __v; \ + atomic_flag_clear_explicit(__g, __x); \ + __v; }) + +#define _ATOMIC_MODIFY_(__a, __o, __m, __x) \ + ({ volatile __typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + __typeof__(__m) __v = (__m); \ + volatile atomic_flag* __g = __atomic_flag_for_address(__p); \ + __atomic_flag_wait_explicit(__g, __x); \ + __typeof__ _ATOMIC_MEMBER_ __r = *__p; \ + *__p __o __v; \ + atomic_flag_clear_explicit(__g, __x); \ + __r; }) + +#define _ATOMIC_CMPSWP_(__a, __e, __m, __x) \ + ({ volatile __typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + __typeof__(__e) __q = (__e); \ + __typeof__(__m) __v = (__m); \ + bool __r; \ + volatile atomic_flag* __g = __atomic_flag_for_address(__p); \ + __atomic_flag_wait_explicit(__g, __x); \ + __typeof__ _ATOMIC_MEMBER_ __t__ = *__p; \ + if (__t__ == *__q) { *__p = __v; __r = true; } \ + else { *__q = __t__; __r = false; } \ + atomic_flag_clear_explicit(__g, __x); \ + __r; }) + +#define _ATOMIC_FENCE_(__a, __x) \ + ({ volatile __typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + volatile atomic_flag* __g = __atomic_flag_for_address(__p); \ + atomic_flag_fence(__g, __x); \ + }) + +_GLIBCXX_END_EXTERN_C +_GLIBCXX_END_NAMESPACE + +#ifdef __cplusplus +// Inject into global namespace iff C++. +using std::memory_order; +using std::memory_order_relaxed; +using std::memory_order_acquire; +using std::memory_order_release; +using std::memory_order_acq_rel; +using std::memory_order_seq_cst; + +using std::atomic_flag; + +using std::atomic_bool; +using std::atomic_char; +using std::atomic_schar; +using std::atomic_uchar; +using std::atomic_short; +using std::atomic_ushort; +using std::atomic_int; +using std::atomic_uint; +using std::atomic_long; +using std::atomic_ulong; +using std::atomic_llong; +using std::atomic_ullong; +using std::atomic_wchar_t; + +using std::atomic_address; +using std::atomic; + +#endif + +#endif diff --git a/libstdc++-v3/include/c_global/cstdatomic b/libstdc++-v3/include/c_global/cstdatomic new file mode 100644 index 00000000000..22fde89603b --- /dev/null +++ b/libstdc++-v3/include/c_global/cstdatomic @@ -0,0 +1,4100 @@ +// -*- C++ -*- header. + +// Copyright (C) 2008 +// Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02110-1301, USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file cstdatomic + * This is a Standard C++ Library file. You should @c #include this file + * in your programs, rather than any of the "*.h" implementation files. + * + * This is the C++ version of the Standard C Library header @c stdatomic.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl. +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html + +#ifndef _GLIBCXX_STDATOMIC +#define _GLIBCXX_STDATOMIC 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <c++0x_warning.h> +#endif + +#include <stdatomic.h> +#include <cstddef> + +_GLIBCXX_BEGIN_NAMESPACE(std) + + // Can either subclass or encapsulate "C" functionality, and here + // encapsulating works with C++2003's version of POD and so is + // portable across C++2003/200x. + // Both end up being sub-optimal in terms of a constructor + // initialization list, but oh well. + + /// atomic_flag + struct atomic_flag + { + __atomic_flag_base _M_base; + + bool + test_and_set(memory_order __x = memory_order_seq_cst) volatile + { return atomic_flag_test_and_set_explicit(this, __x); } + + void + clear(memory_order __x = memory_order_seq_cst) volatile + { atomic_flag_clear_explicit(this, __x); } + + void + fence(memory_order __x) const volatile + { atomic_flag_fence(this, __x); } + +#if _GLIBCXX_USE_STANDARD_LAYOUT + // Add in non-trivial default constructor that correctly + // initializes member "as if" by ATOMIC_FLAG_INIT. + atomic_flag() { _M_base._M_b = false; } + + private: + atomic_flag(const atomic_flag&); + atomic_flag& operator=(const atomic_flag&); +#endif + }; + + /// 29.4.2, address types + typedef struct atomic_address + { + __atomic_address_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(void*, memory_order = memory_order_seq_cst) volatile; + + void* + load(memory_order = memory_order_seq_cst) volatile; + + void* + swap(void*, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(void*&, void*, memory_order, memory_order) volatile; + + bool + compare_swap(void*&, void*, memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + void* + fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile; + + void* + fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile; + + void* + operator=(void* __v) volatile + { store(__v); return __v; } + + void* + operator+=(ptrdiff_t __v) volatile + { return fetch_add(__v); } + + void* + operator-=(ptrdiff_t __v) volatile + { return fetch_sub(__v); } + + friend void + atomic_store_explicit(volatile atomic_address*, void*, memory_order); + + friend void* + atomic_load_explicit(volatile atomic_address*, memory_order); + + friend void* + atomic_swap_explicit(volatile atomic_address*, void*, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_address*, void**, void*, + memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_address*, memory_order); + + friend void* + atomic_fetch_add_explicit(volatile atomic_address*, ptrdiff_t, + memory_order); + + friend void* + atomic_fetch_sub_explicit(volatile atomic_address*, ptrdiff_t, + memory_order); + + atomic_address() { } + + explicit atomic_address(void* __v) + { _M_base._M_i = __v; } + + private: + atomic_address(const atomic_address&); + atomic_address& operator=(const atomic_address &); + }; + + + // 29.4.1 atomic integral types + // For each of the integral types, define atomic_[integral type] struct + // + // atomic_bool bool + // atomic_char char + // atomic_schar signed char + // atomic_uchar unsigned char + // atomic_short short + // atomic_ushort unsigned short + // atomic_int int + // atomic_uint unsigned int + // atomic_long long + // atomic_ulong unsigned long + // atomic_llong long long + // atomic_ullong unsigned long long + // atomic_char16_t char16_t + // atomic_char32_t char32_t + // atomic_wchar_t wchar_t + + /// atomic_bool + struct atomic_bool + { + __atomic_bool_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(bool, memory_order = memory_order_seq_cst) volatile; + + bool + load(memory_order = memory_order_seq_cst) volatile; + + bool + swap(bool, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(bool&, bool, memory_order, memory_order) volatile; + + bool + compare_swap(bool&, bool, memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + bool + operator=(bool __v) volatile { store(__v); return __v; } + + friend void + atomic_store_explicit(volatile atomic_bool*, bool, memory_order); + + friend bool + atomic_load_explicit(volatile atomic_bool*, memory_order); + + friend bool + atomic_swap_explicit(volatile atomic_bool*, bool, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_bool*, bool*, bool, + memory_order, memory_order); + friend void + atomic_fence(const volatile atomic_bool*, memory_order); + + atomic_bool() { } + + explicit atomic_bool(bool __v) { _M_base._M_i = __v; } + + private: + atomic_bool(const atomic_bool&); + atomic_bool& operator=(const atomic_bool&); + }; + + /// atomic_char + struct atomic_char + { + __atomic_char_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(char, memory_order = memory_order_seq_cst) volatile; + + char + load(memory_order = memory_order_seq_cst) volatile; + + char + swap(char, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(char&, char, memory_order, memory_order) volatile; + + bool + compare_swap(char&, char, memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + char + fetch_add(char, memory_order = memory_order_seq_cst) volatile; + + char + fetch_sub(char, memory_order = memory_order_seq_cst) volatile; + + char + fetch_and(char, memory_order = memory_order_seq_cst) volatile; + + char + fetch_or(char, memory_order = memory_order_seq_cst) volatile; + + char + fetch_xor(char, memory_order = memory_order_seq_cst) volatile; + + char + operator=(char __v) volatile { store(__v); return __v; } + + char + operator++(int) volatile { return fetch_add(1); } + + char + operator--(int) volatile { return fetch_sub(1); } + + char + operator++() volatile { return fetch_add(1) + 1; } + + char + operator--() volatile { return fetch_sub(1) - 1; } + + char + operator+=(char __v) volatile { return fetch_add(__v) + __v; } + + char + operator-=(char __v) volatile { return fetch_sub(__v) - __v; } + + char + operator&=(char __v) volatile { return fetch_and(__v) & __v; } + + char + operator|=(char __v) volatile { return fetch_or(__v) | __v; } + + char + operator^=(char __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_char*, char, memory_order); + + friend char + atomic_load_explicit(volatile atomic_char*, memory_order); + + friend char + atomic_swap_explicit(volatile atomic_char*, char, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_char*, char*, char, + memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_char*, memory_order); + + friend char + atomic_fetch_add_explicit(volatile atomic_char*, char, memory_order); + + friend char + atomic_fetch_sub_explicit(volatile atomic_char*, char, memory_order); + + friend char + atomic_fetch_and_explicit(volatile atomic_char*, char, memory_order); + + friend char + atomic_fetch_or_explicit( volatile atomic_char*, char, memory_order); + + friend char + atomic_fetch_xor_explicit(volatile atomic_char*, char, memory_order); + + atomic_char() { } + + atomic_char(char __v) { _M_base._M_i = __v; } + + private: + atomic_char(const atomic_char&); + atomic_char& operator=(const atomic_char&); + }; + + /// atomic_schar + struct atomic_schar + { + __atomic_schar_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(signed char, memory_order = memory_order_seq_cst) volatile; + + signed char + load(memory_order = memory_order_seq_cst) volatile; + + signed char + swap(signed char, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(signed char&, signed char, memory_order, + memory_order) volatile; + + bool + compare_swap(signed char&, signed char, + memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + signed char + fetch_add(signed char, memory_order = memory_order_seq_cst) volatile; + + signed char + fetch_sub(signed char, memory_order = memory_order_seq_cst) volatile; + + signed char + fetch_and(signed char, memory_order = memory_order_seq_cst) volatile; + + signed char + fetch_or(signed char, memory_order = memory_order_seq_cst) volatile; + + signed char + fetch_xor(signed char, memory_order = memory_order_seq_cst) volatile; + + signed char + operator=(signed char __v) volatile { store(__v); return __v; } + + signed char + operator++(int) volatile { return fetch_add(1); } + + signed char + operator--(int) volatile { return fetch_sub(1); } + + signed char + operator++() volatile { return fetch_add(1) + 1; } + + signed char + operator--() volatile { return fetch_sub(1) - 1; } + + signed char + operator+=(signed char __v) volatile { return fetch_add(__v) + __v; } + + signed char + operator-=(signed char __v) volatile { return fetch_sub(__v) - __v; } + + signed char + operator&=(signed char __v) volatile { return fetch_and(__v) & __v; } + + signed char + operator|=(signed char __v) volatile { return fetch_or(__v) | __v; } + + signed char + operator^=(signed char __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_schar*, signed char, memory_order); + + friend signed char + atomic_load_explicit(volatile atomic_schar*, memory_order); + + friend signed char + atomic_swap_explicit(volatile atomic_schar*, signed char, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_schar*, signed char*, + signed char, memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_schar*, memory_order); + + friend signed char + atomic_fetch_add_explicit(volatile atomic_schar*, + signed char, memory_order); + + friend signed char + atomic_fetch_sub_explicit(volatile atomic_schar*, signed char, + memory_order); + + friend signed char + atomic_fetch_and_explicit(volatile atomic_schar*, signed char, + memory_order); + + friend signed char + atomic_fetch_or_explicit(volatile atomic_schar*, signed char, + memory_order); + + friend signed char + atomic_fetch_xor_explicit(volatile atomic_schar*, signed char, + memory_order); + + atomic_schar() { } + + atomic_schar(signed char __v) { _M_base._M_i = __v; } + + private: + atomic_schar(const atomic_schar&); + atomic_schar& operator=(const atomic_schar&); + }; + + /// atomic_uchar + struct atomic_uchar + { + __atomic_uchar_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(unsigned char, memory_order = memory_order_seq_cst) volatile; + + unsigned char + load(memory_order = memory_order_seq_cst) volatile; + + unsigned char + swap(unsigned char, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(unsigned char&, unsigned char, memory_order, + memory_order) volatile; + + bool + compare_swap(unsigned char&, unsigned char, + memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + unsigned char + fetch_add(unsigned char, memory_order = memory_order_seq_cst) volatile; + + unsigned char + fetch_sub(unsigned char, memory_order = memory_order_seq_cst) volatile; + + unsigned char + fetch_and(unsigned char, memory_order = memory_order_seq_cst) volatile; + + unsigned char + fetch_or(unsigned char, memory_order = memory_order_seq_cst) volatile; + + unsigned char + fetch_xor(unsigned char, memory_order = memory_order_seq_cst) volatile; + + unsigned char + operator=(unsigned char __v) volatile { store(__v); return __v; } + + unsigned char + operator++(int) volatile { return fetch_add(1); } + + unsigned char + operator--(int) volatile { return fetch_sub(1); } + + unsigned char + operator++() volatile { return fetch_add(1) + 1; } + + unsigned char + operator--() volatile { return fetch_sub(1) - 1; } + + unsigned char + operator+=(unsigned char __v) volatile { return fetch_add(__v) + __v; } + + unsigned char + operator-=(unsigned char __v) volatile { return fetch_sub(__v) - __v; } + + unsigned char + operator&=(unsigned char __v) volatile { return fetch_and(__v) & __v; } + + unsigned char + operator|=(unsigned char __v) volatile { return fetch_or(__v) | __v; } + + unsigned char + operator^=(unsigned char __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_uchar*, unsigned char, memory_order); + + friend unsigned char + atomic_load_explicit(volatile atomic_uchar*, memory_order); + + friend unsigned char + atomic_swap_explicit(volatile atomic_uchar*, unsigned char, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_uchar*, unsigned char*, + unsigned char, memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_uchar*, memory_order); + + friend unsigned char + atomic_fetch_add_explicit(volatile atomic_uchar*, unsigned char, + memory_order); + + friend unsigned char + atomic_fetch_sub_explicit(volatile atomic_uchar*, unsigned char, + memory_order); + + friend unsigned char + atomic_fetch_and_explicit(volatile atomic_uchar*, + unsigned char, memory_order); + + friend unsigned char + atomic_fetch_or_explicit( volatile atomic_uchar*, unsigned char, + memory_order); + + friend unsigned char + atomic_fetch_xor_explicit(volatile atomic_uchar*, unsigned char, + memory_order); + + atomic_uchar() { } + + atomic_uchar(unsigned char __v) { _M_base._M_i = __v; } + + private: + atomic_uchar(const atomic_uchar&); + atomic_uchar& operator=(const atomic_uchar&); + }; + + + /// atomic_short + struct atomic_short + { + __atomic_short_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(short, memory_order = memory_order_seq_cst) volatile; + + short + load(memory_order = memory_order_seq_cst) volatile; + + short + swap(short, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(short&, short, memory_order, memory_order) volatile; + + bool + compare_swap(short&, short, memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + short + fetch_add(short, memory_order = memory_order_seq_cst) volatile; + + short + fetch_sub(short, memory_order = memory_order_seq_cst) volatile; + + short + fetch_and(short, memory_order = memory_order_seq_cst) volatile; + + short + fetch_or(short, memory_order = memory_order_seq_cst) volatile; + + short + fetch_xor(short, memory_order = memory_order_seq_cst) volatile; + + short + operator=(short __v) volatile { store(__v); return __v; } + + short + operator++(int) volatile { return fetch_add(1); } + + short + operator--(int) volatile { return fetch_sub(1); } + + short + operator++() volatile { return fetch_add(1) + 1; } + + short + operator--() volatile { return fetch_sub(1) - 1; } + + short + operator+=(short __v) volatile { return fetch_add(__v) + __v; } + + short + operator-=(short __v) volatile { return fetch_sub(__v) - __v; } + + short + operator&=(short __v) volatile { return fetch_and(__v) & __v; } + + short + operator|=(short __v) volatile { return fetch_or(__v) | __v; } + + short + operator^=(short __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_short*, short, memory_order); + + friend short + atomic_load_explicit(volatile atomic_short*, memory_order); + + friend short + atomic_swap_explicit(volatile atomic_short*, short, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_short*, short*, short, + memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_short*, memory_order); + + friend short + atomic_fetch_add_explicit(volatile atomic_short*, short, memory_order); + + friend short + atomic_fetch_sub_explicit(volatile atomic_short*, short, memory_order); + + friend short + atomic_fetch_and_explicit(volatile atomic_short*, short, memory_order); + + friend short + atomic_fetch_or_explicit( volatile atomic_short*, short, memory_order); + + friend short + atomic_fetch_xor_explicit(volatile atomic_short*, short, memory_order); + + atomic_short() { } + + atomic_short(short __v) { _M_base._M_i = __v; } + + private: + atomic_short(const atomic_short&); + atomic_short& operator=(const atomic_short&); + }; + + /// atomic_ushort + struct atomic_ushort + { + __atomic_ushort_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(unsigned short, memory_order = memory_order_seq_cst) volatile; + + unsigned short + load(memory_order = memory_order_seq_cst) volatile; + + unsigned short + swap(unsigned short, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(unsigned short&, unsigned short, memory_order, + memory_order) volatile; + + bool + compare_swap(unsigned short&, unsigned short, + memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + unsigned short + fetch_add(unsigned short, memory_order = memory_order_seq_cst) volatile; + + unsigned short + fetch_sub(unsigned short, memory_order = memory_order_seq_cst) volatile; + + unsigned short + fetch_and(unsigned short, memory_order = memory_order_seq_cst) volatile; + + unsigned short + fetch_or(unsigned short, memory_order = memory_order_seq_cst) volatile; + + unsigned short + fetch_xor(unsigned short, memory_order = memory_order_seq_cst) volatile; + + unsigned short + operator=(unsigned short __v) volatile { store(__v); return __v; } + + unsigned short + operator++(int) volatile { return fetch_add(1); } + + unsigned short + operator--(int) volatile { return fetch_sub(1); } + + unsigned short + operator++() volatile { return fetch_add(1) + 1; } + + unsigned short + operator--() volatile { return fetch_sub(1) - 1; } + + unsigned short + operator+=(unsigned short __v) volatile { return fetch_add(__v) + __v; } + + unsigned short + operator-=(unsigned short __v) volatile { return fetch_sub(__v) - __v; } + + unsigned short + operator&=(unsigned short __v) volatile { return fetch_and(__v) & __v; } + + unsigned short + operator|=(unsigned short __v) volatile { return fetch_or(__v) | __v; } + + unsigned short + operator^=(unsigned short __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_ushort*, unsigned short, + memory_order); + + friend unsigned short + atomic_load_explicit(volatile atomic_ushort*, memory_order); + + friend unsigned short + atomic_swap_explicit(volatile atomic_ushort*, unsigned short, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_ushort*, unsigned short*, + unsigned short, memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_ushort*, memory_order); + + friend unsigned short + atomic_fetch_add_explicit(volatile atomic_ushort*, unsigned short, + memory_order); + + friend unsigned short + atomic_fetch_sub_explicit(volatile atomic_ushort*, unsigned short, + memory_order); + + friend unsigned short + atomic_fetch_and_explicit(volatile atomic_ushort*, unsigned short, + memory_order); + + friend unsigned short + atomic_fetch_or_explicit( volatile atomic_ushort*, unsigned short, + memory_order); + + friend unsigned short + atomic_fetch_xor_explicit(volatile atomic_ushort*, unsigned short, + memory_order); + + atomic_ushort() { } + + atomic_ushort(unsigned short __v) { _M_base._M_i = __v; } + + private: + atomic_ushort(const atomic_ushort&); + atomic_ushort& operator=(const atomic_ushort&); + }; + + /// atomic_int + struct atomic_int + { + __atomic_int_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(int, memory_order = memory_order_seq_cst) volatile; + + int + load(memory_order = memory_order_seq_cst) volatile; + + int + swap(int, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(int&, int, memory_order, memory_order) volatile; + + bool + compare_swap(int&, int, memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + int + fetch_add(int, memory_order = memory_order_seq_cst) volatile; + + int + fetch_sub(int, memory_order = memory_order_seq_cst) volatile; + + int + fetch_and(int, memory_order = memory_order_seq_cst) volatile; + + int + fetch_or(int, memory_order = memory_order_seq_cst) volatile; + + int + fetch_xor(int, memory_order = memory_order_seq_cst) volatile; + + int + operator=(int __v) volatile { store(__v); return __v; } + + int + operator++(int) volatile { return fetch_add(1); } + + int + operator--(int) volatile { return fetch_sub(1); } + + int + operator++() volatile { return fetch_add(1) + 1; } + + int + operator--() volatile { return fetch_sub(1) - 1; } + + int + operator+=(int __v) volatile { return fetch_add(__v) + __v; } + + int + operator-=(int __v) volatile { return fetch_sub(__v) - __v; } + + int + operator&=(int __v) volatile { return fetch_and(__v) & __v; } + + int + operator|=(int __v) volatile { return fetch_or(__v) | __v; } + + int + operator^=(int __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_int*, int, memory_order); + + friend int + atomic_load_explicit(volatile atomic_int*, memory_order); + + friend int + atomic_swap_explicit(volatile atomic_int*, int, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_int*, int*, int, + memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_int*, memory_order); + + friend int + atomic_fetch_add_explicit(volatile atomic_int*, int, memory_order); + + friend int + atomic_fetch_sub_explicit(volatile atomic_int*, int, memory_order); + + friend int + atomic_fetch_and_explicit(volatile atomic_int*, int, memory_order); + + friend int + atomic_fetch_or_explicit( volatile atomic_int*, int, memory_order); + + friend int + atomic_fetch_xor_explicit(volatile atomic_int*, int, memory_order); + + atomic_int() { } + + atomic_int(int __v) { _M_base._M_i = __v; } + + private: + atomic_int(const atomic_int&); + atomic_int& operator=(const atomic_int&); + }; + + /// atomic_uint + struct atomic_uint + { + __atomic_uint_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(unsigned int, memory_order = memory_order_seq_cst) volatile; + + unsigned int + load(memory_order = memory_order_seq_cst) volatile; + + unsigned int + swap(unsigned int, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(unsigned int&, unsigned int, memory_order, + memory_order) volatile; + + bool + compare_swap(unsigned int&, unsigned int, + memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + unsigned int + fetch_add(unsigned int, memory_order = memory_order_seq_cst) volatile; + + unsigned int + fetch_sub(unsigned int, memory_order = memory_order_seq_cst) volatile; + + unsigned int + fetch_and(unsigned int, memory_order = memory_order_seq_cst) volatile; + + unsigned int + fetch_or(unsigned int, memory_order = memory_order_seq_cst) volatile; + + unsigned int + fetch_xor(unsigned int, memory_order = memory_order_seq_cst) volatile; + + unsigned int + operator=(unsigned int __v) volatile { store(__v); return __v; } + + unsigned int + operator++(int) volatile { return fetch_add(1); } + + unsigned int + operator--(int) volatile { return fetch_sub(1); } + + unsigned int + operator++() volatile { return fetch_add(1) + 1; } + + unsigned int + operator--() volatile { return fetch_sub(1) - 1; } + + unsigned int + operator+=(unsigned int __v) volatile { return fetch_add(__v) + __v; } + + unsigned int + operator-=(unsigned int __v) volatile { return fetch_sub(__v) - __v; } + + unsigned int + operator&=(unsigned int __v) volatile { return fetch_and(__v) & __v; } + + unsigned int + operator|=(unsigned int __v) volatile { return fetch_or(__v) | __v; } + + unsigned int + operator^=(unsigned int __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_uint*, unsigned int, memory_order); + + friend unsigned int + atomic_load_explicit(volatile atomic_uint*, memory_order); + + friend unsigned int + atomic_swap_explicit(volatile atomic_uint*, unsigned int, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_uint*, unsigned int*, + unsigned int, memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_uint*, memory_order); + + friend unsigned int + atomic_fetch_add_explicit(volatile atomic_uint*, unsigned int, + memory_order); + + friend unsigned int + atomic_fetch_sub_explicit(volatile atomic_uint*, unsigned int, + memory_order); + + friend unsigned int + atomic_fetch_and_explicit(volatile atomic_uint*, unsigned int, + memory_order); + + friend unsigned int + atomic_fetch_or_explicit( volatile atomic_uint*, unsigned int, + memory_order); + + friend unsigned int + atomic_fetch_xor_explicit(volatile atomic_uint*, unsigned int, + memory_order); + + atomic_uint() { } + + atomic_uint(unsigned int __v) { _M_base._M_i = __v; } + + private: + atomic_uint(const atomic_uint&); + atomic_uint& operator=(const atomic_uint&); + }; + + /// atomic_long + struct atomic_long + { + __atomic_long_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(long, memory_order = memory_order_seq_cst) volatile; + + long + load(memory_order = memory_order_seq_cst) volatile; + + long + swap(long, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(long&, long, memory_order, memory_order) volatile; + + bool + compare_swap(long&, long, memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + long + fetch_add(long, memory_order = memory_order_seq_cst) volatile; + + long + fetch_sub(long, memory_order = memory_order_seq_cst) volatile; + + long + fetch_and(long, memory_order = memory_order_seq_cst) volatile; + + long + fetch_or(long, memory_order = memory_order_seq_cst) volatile; + + long + fetch_xor(long, memory_order = memory_order_seq_cst) volatile; + + long + operator=(long __v) volatile { store(__v); return __v; } + + long + operator++(int) volatile { return fetch_add(1); } + + long + operator--(int) volatile { return fetch_sub(1); } + + long + operator++() volatile { return fetch_add(1) + 1; } + + long + operator--() volatile { return fetch_sub(1) - 1; } + + long + operator+=(long __v) volatile { return fetch_add(__v) + __v; } + + long + operator-=(long __v) volatile { return fetch_sub(__v) - __v; } + + long + operator&=(long __v) volatile { return fetch_and(__v) & __v; } + + long + operator|=(long __v) volatile { return fetch_or(__v) | __v; } + + long + operator^=(long __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_long*, long, memory_order); + + friend long + atomic_load_explicit(volatile atomic_long*, memory_order); + + friend long + atomic_swap_explicit(volatile atomic_long*, long, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_long*, long*, long, + memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_long*, memory_order); + + friend long + atomic_fetch_add_explicit(volatile atomic_long*, long, memory_order); + + friend long + atomic_fetch_sub_explicit(volatile atomic_long*, long, memory_order); + + friend long + atomic_fetch_and_explicit(volatile atomic_long*, long, memory_order); + + friend long + atomic_fetch_or_explicit( volatile atomic_long*, long, memory_order); + + friend long + atomic_fetch_xor_explicit(volatile atomic_long*, long, memory_order); + + atomic_long() { } + + atomic_long(long __v) { _M_base._M_i = __v; } + + private: + atomic_long(const atomic_long&); + atomic_long& operator=(const atomic_long&); + }; + + /// atomic_ulong + struct atomic_ulong + { + __atomic_ulong_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(unsigned long, memory_order = memory_order_seq_cst) volatile; + + unsigned long + load(memory_order = memory_order_seq_cst) volatile; + + unsigned long + swap(unsigned long, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(unsigned long&, unsigned long, memory_order, + memory_order) volatile; + + bool + compare_swap(unsigned long&, unsigned long, + memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + unsigned long + fetch_add(unsigned long, memory_order = memory_order_seq_cst) volatile; + + unsigned long + fetch_sub(unsigned long, memory_order = memory_order_seq_cst) volatile; + + unsigned long + fetch_and(unsigned long, memory_order = memory_order_seq_cst) volatile; + + unsigned long + fetch_or(unsigned long, memory_order = memory_order_seq_cst) volatile; + + unsigned long + fetch_xor(unsigned long, memory_order = memory_order_seq_cst) volatile; + + unsigned long + operator=(unsigned long __v) volatile { store(__v); return __v; } + + unsigned long + operator++(int) volatile { return fetch_add(1); } + + unsigned long + operator--(int) volatile { return fetch_sub(1); } + + unsigned long + operator++() volatile { return fetch_add(1) + 1; } + + unsigned long + operator--() volatile { return fetch_sub(1) - 1; } + + unsigned long + operator+=(unsigned long __v) volatile { return fetch_add(__v) + __v; } + + unsigned long + operator-=(unsigned long __v) volatile { return fetch_sub(__v) - __v; } + + unsigned long + operator&=(unsigned long __v) volatile { return fetch_and(__v) & __v; } + + unsigned long + operator|=(unsigned long __v) volatile { return fetch_or(__v) | __v; } + + unsigned long + operator^=(unsigned long __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_ulong*, unsigned long, memory_order); + + friend unsigned long + atomic_load_explicit(volatile atomic_ulong*, memory_order); + + friend unsigned long + atomic_swap_explicit(volatile atomic_ulong*, unsigned long, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_ulong*, unsigned long*, + unsigned long, memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_ulong*, memory_order); + + friend unsigned long + atomic_fetch_add_explicit(volatile atomic_ulong*, unsigned long, + memory_order); + + friend unsigned long + atomic_fetch_sub_explicit(volatile atomic_ulong*, unsigned long, + memory_order); + + friend unsigned long + atomic_fetch_and_explicit(volatile atomic_ulong*, unsigned long, + memory_order); + friend unsigned long + atomic_fetch_or_explicit(volatile atomic_ulong*, unsigned long, + memory_order); + + friend unsigned long + atomic_fetch_xor_explicit(volatile atomic_ulong*, unsigned long, + memory_order); + + atomic_ulong() { } + + atomic_ulong(unsigned long __v) { _M_base._M_i = __v; } + + private: + atomic_ulong(const atomic_ulong&); + atomic_ulong& operator=(const atomic_ulong&); + }; + + /// atomic_llong + struct atomic_llong + { + __atomic_llong_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(long long, memory_order = memory_order_seq_cst) volatile; + + long long + load(memory_order = memory_order_seq_cst) volatile; + + long long + swap(long long, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(long long&, long long, memory_order, memory_order) volatile; + + bool + compare_swap(long long&, long long, + memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + long long + fetch_add(long long, memory_order = memory_order_seq_cst) volatile; + + long long + fetch_sub(long long, memory_order = memory_order_seq_cst) volatile; + + long long + fetch_and(long long, memory_order = memory_order_seq_cst) volatile; + + long long + fetch_or(long long, memory_order = memory_order_seq_cst) volatile; + + long long + fetch_xor(long long, memory_order = memory_order_seq_cst) volatile; + + long long + operator=(long long __v) volatile { store(__v); return __v; } + + long long + operator++(int) volatile { return fetch_add(1); } + + long long + operator--(int) volatile { return fetch_sub(1); } + + long long + operator++() volatile { return fetch_add(1) + 1; } + + long long + operator--() volatile { return fetch_sub(1) - 1; } + + long long + operator+=(long long __v) volatile { return fetch_add(__v) + __v; } + + long long + operator-=(long long __v) volatile { return fetch_sub(__v) - __v; } + + long long + operator&=(long long __v) volatile { return fetch_and(__v) & __v; } + + long long + operator|=(long long __v) volatile { return fetch_or(__v) | __v; } + + long long + operator^=(long long __v) volatile { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_llong*, long long, memory_order); + + friend long long + atomic_load_explicit(volatile atomic_llong*, memory_order); + + friend long long + atomic_swap_explicit(volatile atomic_llong*, long long, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_llong*, long long*, + long long, memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_llong*, memory_order); + + friend long long + atomic_fetch_add_explicit(volatile atomic_llong*, long long, memory_order); + + friend long long + atomic_fetch_sub_explicit(volatile atomic_llong*, long long, memory_order); + + friend long long + atomic_fetch_and_explicit(volatile atomic_llong*, long long, memory_order); + + friend long long + atomic_fetch_or_explicit(volatile atomic_llong*, long long, memory_order); + + friend long long + atomic_fetch_xor_explicit(volatile atomic_llong*, long long, memory_order); + + atomic_llong() { } + + atomic_llong(long long __v) { _M_base._M_i = __v; } + + private: + atomic_llong(const atomic_llong&); + atomic_llong& operator=(const atomic_llong&); + }; + + /// atomic_ullong + struct atomic_ullong + { + __atomic_ullong_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(unsigned long long, memory_order = memory_order_seq_cst) volatile; + + unsigned long long + load(memory_order = memory_order_seq_cst) volatile; + + unsigned long long + swap(unsigned long long, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(unsigned long long&, unsigned long long, memory_order, + memory_order) volatile; + + bool + compare_swap(unsigned long long&, unsigned long long, + memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + unsigned long long + fetch_add(unsigned long long, memory_order = memory_order_seq_cst) volatile; + + unsigned long long + fetch_sub(unsigned long long, memory_order = memory_order_seq_cst) volatile; + + unsigned long long + fetch_and(unsigned long long, memory_order = memory_order_seq_cst) volatile; + + unsigned long long + fetch_or(unsigned long long, memory_order = memory_order_seq_cst) volatile; + + unsigned long long + fetch_xor(unsigned long long, memory_order = memory_order_seq_cst) volatile; + + unsigned long long + operator=(unsigned long long __v) volatile + { store(__v); return __v; } + + unsigned long long + operator++(int) volatile + { return fetch_add(1); } + + unsigned long long + operator--(int) volatile + { return fetch_sub(1); } + + unsigned long long + operator++() volatile + { return fetch_add(1) + 1; } + + unsigned long long + operator--() volatile + { return fetch_sub(1) - 1; } + + unsigned long long + operator+=(unsigned long long __v) volatile + { return fetch_add(__v) + __v; } + + unsigned long long + operator-=(unsigned long long __v) volatile + { return fetch_sub(__v) - __v; } + + unsigned long long + operator&=(unsigned long long __v) volatile + { return fetch_and(__v) & __v; } + + unsigned long long + operator|=(unsigned long long __v) volatile + { return fetch_or(__v) | __v; } + + unsigned long long + operator^=(unsigned long long __v) volatile + { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_ullong*, unsigned long long, + memory_order); + friend unsigned long long + atomic_load_explicit(volatile atomic_ullong*, memory_order); + + friend unsigned long long + atomic_swap_explicit(volatile atomic_ullong*, unsigned long long, + memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_ullong*, unsigned long long*, + unsigned long long, memory_order, + memory_order); + + friend void + atomic_fence(const volatile atomic_ullong*, memory_order); + + friend unsigned long long + atomic_fetch_add_explicit(volatile atomic_ullong*, unsigned long long, + memory_order); + + friend unsigned long long + atomic_fetch_sub_explicit(volatile atomic_ullong*, unsigned long long, + memory_order); + + friend unsigned long long + atomic_fetch_and_explicit(volatile atomic_ullong*, unsigned long long, + memory_order); + + friend unsigned long long + atomic_fetch_or_explicit(volatile atomic_ullong*, unsigned long long, + memory_order); + + friend unsigned long long + atomic_fetch_xor_explicit(volatile atomic_ullong*, unsigned long long, + memory_order); + + atomic_ullong() { } + + atomic_ullong(unsigned long long __v) { _M_base._M_i = __v; } + + private: + atomic_ullong(const atomic_ullong&); + atomic_ullong& operator=(const atomic_ullong&); + }; + + /// atomic_wchar_t + struct atomic_wchar_t + { + __atomic_wchar_t_base _M_base; + + bool + is_lock_free() const volatile; + + void + store(wchar_t, memory_order = memory_order_seq_cst) volatile; + + wchar_t + load(memory_order = memory_order_seq_cst) volatile; + + wchar_t + swap(wchar_t, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(wchar_t&, wchar_t, memory_order, memory_order) volatile; + + bool + compare_swap(wchar_t&, wchar_t, + memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + wchar_t + fetch_add(wchar_t, memory_order = memory_order_seq_cst) volatile; + + wchar_t + fetch_sub(wchar_t, memory_order = memory_order_seq_cst) volatile; + + wchar_t + fetch_and(wchar_t, memory_order = memory_order_seq_cst) volatile; + + wchar_t + fetch_or(wchar_t, memory_order = memory_order_seq_cst) volatile; + + wchar_t + fetch_xor(wchar_t, memory_order = memory_order_seq_cst) volatile; + + wchar_t + operator=(wchar_t __v) volatile + { store(__v); return __v; } + + wchar_t + operator++(int) volatile + { return fetch_add(1); } + + wchar_t + operator--(int) volatile + { return fetch_sub(1); } + + wchar_t + operator++() volatile + { return fetch_add(1) + 1; } + + wchar_t + operator--() volatile + { return fetch_sub(1) - 1; } + + wchar_t + operator+=(wchar_t __v) volatile + { return fetch_add(__v) + __v; } + + wchar_t + operator-=(wchar_t __v) volatile + { return fetch_sub(__v) - __v; } + + wchar_t + operator&=(wchar_t __v) volatile + { return fetch_and(__v) & __v; } + + wchar_t + operator|=(wchar_t __v) volatile + { return fetch_or(__v) | __v; } + + wchar_t + operator^=(wchar_t __v) volatile + { return fetch_xor(__v) ^ __v; } + + friend void + atomic_store_explicit(volatile atomic_wchar_t*, wchar_t, memory_order); + + friend wchar_t + atomic_load_explicit(volatile atomic_wchar_t*, memory_order); + + friend wchar_t + atomic_swap_explicit(volatile atomic_wchar_t*, wchar_t, memory_order); + + friend bool + atomic_compare_swap_explicit(volatile atomic_wchar_t*, + wchar_t*, wchar_t, memory_order, memory_order); + + friend void + atomic_fence(const volatile atomic_wchar_t*, memory_order); + + friend wchar_t + atomic_fetch_add_explicit(volatile atomic_wchar_t*, wchar_t, memory_order); + + friend wchar_t + atomic_fetch_sub_explicit(volatile atomic_wchar_t*, wchar_t, memory_order); + + friend wchar_t + atomic_fetch_and_explicit(volatile atomic_wchar_t*, wchar_t, memory_order); + + friend wchar_t + atomic_fetch_or_explicit(volatile atomic_wchar_t*, wchar_t, memory_order); + + friend wchar_t + atomic_fetch_xor_explicit(volatile atomic_wchar_t*, wchar_t, memory_order); + + atomic_wchar_t() { } + + atomic_wchar_t(wchar_t __v) { _M_base._M_i = __v; } + + private: + atomic_wchar_t(const atomic_wchar_t&); + atomic_wchar_t& operator=(const atomic_wchar_t&); + }; + + + /// atomic + /// 29.4.3, Generic atomic type, primary class template. + template<typename _Tp> + struct atomic + { + bool + is_lock_free() const volatile; + + void + store(_Tp, memory_order = memory_order_seq_cst) volatile; + + _Tp + load(memory_order = memory_order_seq_cst) volatile; + + _Tp + swap(_Tp __v, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(_Tp&, _Tp, memory_order, memory_order) volatile; + + bool + compare_swap(_Tp&, _Tp, memory_order = memory_order_seq_cst) volatile; + + void + fence(memory_order) const volatile; + + _Tp + operator=(_Tp __v) volatile { store(__v); return __v; } + + atomic() { } + + explicit atomic(_Tp __v) : __f(__v) { } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + + _Tp __f; + }; + + /// Partial specialization for pointer types. + template<typename _Tp> + struct atomic<_Tp*> : atomic_address + { + _Tp* + load(memory_order = memory_order_seq_cst) volatile; + + _Tp* + swap(_Tp*, memory_order = memory_order_seq_cst) volatile; + + bool + compare_swap(_Tp*&, _Tp*, memory_order, memory_order) volatile; + + bool + compare_swap(_Tp*&, _Tp*, memory_order = memory_order_seq_cst) volatile; + + _Tp* + fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile; + + _Tp* + fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile; + + _Tp* + operator=(_Tp* __v) volatile { store(__v); return __v; } + + _Tp* + operator++(int) volatile { return fetch_add(1); } + + _Tp* + operator--(int) volatile { return fetch_sub(1); } + + _Tp* + operator++() volatile { return fetch_add(1) + 1; } + + _Tp* + operator--() volatile { return fetch_sub(1) - 1; } + + _Tp* + operator+=(ptrdiff_t __v) volatile + { return fetch_add(__v) + __v; } + + _Tp* + operator-=(ptrdiff_t __v) volatile + { return fetch_sub(__v) - __v; } + + atomic() { } + + explicit atomic(_Tp* __v) : atomic_address(__v) { } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for bool. + template<> + struct atomic<bool> : atomic_bool + { + atomic() { } + + explicit atomic(bool __v) : atomic_bool(__v) { } + + bool + operator=(bool __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for void* + template<> + struct atomic<void*> : atomic_address + { + atomic() { } + + explicit atomic(void* __v) : atomic_address(__v) { } + + void* + operator=(void* __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for char. + template<> + struct atomic<char> : atomic_char + { + atomic() { } + + explicit atomic(char __v) : atomic_char(__v) { } + + char + operator=(char __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + + /// Explicit specialization for signed char. + template<> + struct atomic<signed char> : atomic_schar + { + atomic() { } + + explicit atomic(signed char __v) : atomic_schar(__v) { } + + signed char + operator=(signed char __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for unsigned char. + template<> + struct atomic<unsigned char> : atomic_uchar + { + atomic() { } + + explicit atomic(unsigned char __v) : atomic_uchar(__v) { } + + unsigned char + operator=(unsigned char __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& + operator=(const atomic&); + }; + + /// Explicit specialization for short. + template<> + struct atomic<short> : atomic_short + { + atomic() { } + + explicit atomic(short __v) : atomic_short(__v) { } + + short + operator=(short __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for unsigned short. + template<> + struct atomic<unsigned short> : atomic_ushort + { + atomic() { } + + explicit atomic(unsigned short __v) : atomic_ushort(__v) { } + + unsigned short + operator=(unsigned short __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for int. + template<> + struct atomic<int> : atomic_int + { + atomic() { } + + explicit atomic(int __v) : atomic_int(__v) { } + + int + operator=(int __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for unsigned int. + template<> + struct atomic<unsigned int> : atomic_uint + { + atomic() { } + + explicit atomic(unsigned int __v) : atomic_uint(__v) { } + + unsigned int + operator=(unsigned int __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for long. + template<> + struct atomic<long> : atomic_long + { + atomic() { } + + explicit atomic(long __v) : atomic_long(__v) { } + + long + operator=(long __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for unsigned long. + template<> + struct atomic<unsigned long> : atomic_ulong + { + atomic() { } + + explicit atomic(unsigned long __v) : atomic_ulong(__v) { } + + unsigned long + operator=(unsigned long __v) volatile + { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for long long. + template<> + struct atomic<long long> : atomic_llong + { + atomic() { } + + explicit atomic(long long __v) : atomic_llong(__v) { } + + long long + operator=(long long __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for unsigned long long. + template<> + struct atomic<unsigned long long> : atomic_ullong + { + atomic() { } + + explicit atomic(unsigned long long __v) : atomic_ullong(__v) { } + + unsigned long long + operator=(unsigned long long __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + /// Explicit specialization for wchar_t. + template<> + struct atomic<wchar_t> : atomic_wchar_t + { + atomic() { } + + explicit atomic(wchar_t __v) : atomic_wchar_t(__v) { } + + wchar_t + operator=(wchar_t __v) volatile { store(__v); return __v; } + + private: + atomic(const atomic&); + atomic& operator=(const atomic&); + }; + + inline bool + atomic_is_lock_free(const volatile atomic_bool* __a) + { return false; } + + inline bool + atomic_load_explicit(volatile atomic_bool* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline bool + atomic_load(volatile atomic_bool* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_bool* __a, bool __m, memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_bool* __a, bool __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_swap_explicit(volatile atomic_bool* __a, bool __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline bool + atomic_swap(volatile atomic_bool* __a, bool __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_bool* __a, bool* __e, bool __m, + memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_bool* __a, bool* __e, bool __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_bool* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + inline bool + atomic_is_lock_free(const volatile atomic_address* __a) + { return false; } + + inline void* + atomic_load_explicit(volatile atomic_address* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline void* + atomic_load(volatile atomic_address* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_address* __a, void* __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_address* __a, void* __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline void* + atomic_swap_explicit(volatile atomic_address* __a, void* __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline void* + atomic_swap(volatile atomic_address* __a, void* __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_address* __a, void** __e, + void* __m, memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_address* __a, void** __e, void* __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_address* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_char* __a) + { return false; } + + inline char + atomic_load_explicit(volatile atomic_char* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline char + atomic_load(volatile atomic_char* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_char* __a, char __m, memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_char* __a, char __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline char + atomic_swap_explicit(volatile atomic_char* __a, char __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline char + atomic_swap(volatile atomic_char* __a, char __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_char* __a, char* __e, char __m, + memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_char* __a, char* __e, char __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_char* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_schar* __a) + { return false; } + + inline signed char + atomic_load_explicit(volatile atomic_schar* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline signed char + atomic_load(volatile atomic_schar* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_schar* __a, signed char __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_schar* __a, signed char __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline signed char + atomic_swap_explicit(volatile atomic_schar* __a, signed char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline signed char + atomic_swap(volatile atomic_schar* __a, signed char __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_schar* __a, signed char* __e, + signed char __m, memory_order __x, + memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_schar* __a, signed char* __e, + signed char __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_schar* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_uchar* __a) + { return false; } + + inline unsigned char + atomic_load_explicit(volatile atomic_uchar* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline unsigned char + atomic_load(volatile atomic_uchar* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_uchar* __a, unsigned char __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_uchar* __a, unsigned char __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned char + atomic_swap_explicit(volatile atomic_uchar* __a, unsigned char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline unsigned char + atomic_swap(volatile atomic_uchar* __a, unsigned char __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_uchar* __a, unsigned char* __e, + unsigned char __m, memory_order __x, + memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_uchar* __a, unsigned char* __e, + unsigned char __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_uchar* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_short* __a) + { return false; } + + inline short + atomic_load_explicit(volatile atomic_short* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline short + atomic_load(volatile atomic_short* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_short* __a, short __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_short* __a, short __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline short + atomic_swap_explicit(volatile atomic_short* __a, short __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline short + atomic_swap(volatile atomic_short* __a, short __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_short* __a, short* __e, + short __m, memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_short* __a, short* __e, short __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_short* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_ushort* __a) + { return false; } + + inline unsigned short + atomic_load_explicit(volatile atomic_ushort* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline unsigned short + atomic_load(volatile atomic_ushort* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_ushort* __a, unsigned short __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_ushort* __a, unsigned short __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned short + atomic_swap_explicit(volatile atomic_ushort* __a, unsigned short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline unsigned short + atomic_swap(volatile atomic_ushort* __a, unsigned short __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_ushort* __a, + unsigned short* __e, unsigned short __m, + memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_ushort* __a, unsigned short* __e, + unsigned short __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_ushort* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_int* __a) + { return false; } + + inline int + atomic_load_explicit(volatile atomic_int* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline int + atomic_load(volatile atomic_int* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_int* __a, int __m, memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_int* __a, int __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline int + atomic_swap_explicit(volatile atomic_int* __a, int __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline int + atomic_swap(volatile atomic_int* __a, int __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_int* __a, int* __e, int __m, + memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_int* __a, int* __e, int __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_int* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_uint* __a) + { return false; } + + inline unsigned int + atomic_load_explicit(volatile atomic_uint* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline unsigned int + atomic_load(volatile atomic_uint* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_uint* __a, unsigned int __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_uint* __a, unsigned int __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned int + atomic_swap_explicit(volatile atomic_uint* __a, unsigned int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline unsigned int + atomic_swap(volatile atomic_uint* __a, unsigned int __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_uint* __a, unsigned int* __e, + unsigned int __m, memory_order __x, + memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_uint* __a, unsigned int* __e, + unsigned int __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_uint* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_long* __a) + { return false; } + + inline long + atomic_load_explicit(volatile atomic_long* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline long + atomic_load(volatile atomic_long* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_long* __a, long __m, memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_long* __a, long __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline long + atomic_swap_explicit(volatile atomic_long* __a, long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline long + atomic_swap(volatile atomic_long* __a, long __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_long* __a, long* __e, long __m, + memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_long* __a, long* __e, long __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_long* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_ulong* __a) + { return false; } + + inline unsigned long + atomic_load_explicit(volatile atomic_ulong* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline unsigned long + atomic_load(volatile atomic_ulong* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_ulong* __a, unsigned long __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_ulong* __a, unsigned long __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long + atomic_swap_explicit(volatile atomic_ulong* __a, unsigned long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline unsigned long + atomic_swap(volatile atomic_ulong* __a, unsigned long __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_ulong* __a, unsigned long* __e, + unsigned long __m, memory_order __x, + memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_ulong* __a, unsigned long* __e, + unsigned long __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_ulong* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_llong* __a) + { return false; } + + inline long long + atomic_load_explicit(volatile atomic_llong* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline long long + atomic_load(volatile atomic_llong* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_llong* __a, long long __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_llong* __a, long long __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline long long + atomic_swap_explicit(volatile atomic_llong* __a, long long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline long long + atomic_swap(volatile atomic_llong* __a, long long __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_llong* __a, long long* __e, + long long __m, memory_order __x, + memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_llong* __a, long long* __e, + long long __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_llong* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + + inline bool + atomic_is_lock_free(const volatile atomic_ullong* __a) + { return false; } + + inline unsigned long long + atomic_load_explicit(volatile atomic_ullong* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline unsigned long long + atomic_load(volatile atomic_ullong* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_store_explicit(volatile atomic_ullong* __a, unsigned long long __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_ullong* __a, unsigned long long __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long long + atomic_swap_explicit(volatile atomic_ullong* __a, unsigned long long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline unsigned long long + atomic_swap(volatile atomic_ullong* __a, unsigned long long __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_ullong* __a, + unsigned long long* __e, unsigned long long __m, + memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_ullong* __a, unsigned long long* __e, + unsigned long long __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_ullong* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + inline bool + atomic_is_lock_free(const volatile atomic_wchar_t* __a) + { return false; } + + inline wchar_t + atomic_load_explicit(volatile atomic_wchar_t* __a, memory_order __x) + { return _ATOMIC_LOAD_(__a, __x); } + + inline wchar_t + atomic_load(volatile atomic_wchar_t* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + + inline void + atomic_store_explicit(volatile atomic_wchar_t* __a, wchar_t __m, + memory_order __x) + { _ATOMIC_STORE_(__a, __m, __x); } + + inline void + atomic_store(volatile atomic_wchar_t* __a, wchar_t __m) + { atomic_store_explicit(__a, __m, memory_order_seq_cst); } + + inline wchar_t + atomic_swap_explicit(volatile atomic_wchar_t* __a, wchar_t __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, =, __m, __x); } + + inline wchar_t + atomic_swap(volatile atomic_wchar_t* __a, wchar_t __m) + { return atomic_swap_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_compare_swap_explicit(volatile atomic_wchar_t* __a, wchar_t* __e, + wchar_t __m, memory_order __x, memory_order __y) + { return _ATOMIC_CMPSWP_(__a, __e, __m, __x); } + + inline bool + atomic_compare_swap(volatile atomic_wchar_t* __a, wchar_t* __e, wchar_t __m) + { return atomic_compare_swap_explicit(__a, __e, __m, memory_order_seq_cst, + memory_order_seq_cst); } + + inline void + atomic_fence(const volatile atomic_wchar_t* __a, memory_order __x) + { _ATOMIC_FENCE_(__a, __x); } + + inline void* + atomic_fetch_add_explicit(volatile atomic_address* __a, ptrdiff_t __m, + memory_order __x) + { + void* volatile* __p = &((__a)->_M_base._M_i); + volatile atomic_flag* __g = __atomic_flag_for_address(__p); + __atomic_flag_wait_explicit(__g, __x); + void* __r = *__p; + *__p = (void*)((char*)(*__p) + __m); + atomic_flag_clear_explicit(__g, __x); + return __r; + } + + inline void* + atomic_fetch_add(volatile atomic_address* __a, ptrdiff_t __m) + { return atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + + inline void* + atomic_fetch_sub_explicit(volatile atomic_address* __a, ptrdiff_t __m, + memory_order __x) + { + void* volatile* __p = &((__a)->_M_base._M_i); + volatile atomic_flag* __g = __atomic_flag_for_address(__p); + __atomic_flag_wait_explicit(__g, __x); + void* __r = *__p; + *__p = (void*)((char*)(*__p) - __m); + atomic_flag_clear_explicit(__g, __x); + return __r; + } + + inline void* + atomic_fetch_sub(volatile atomic_address* __a, ptrdiff_t __m) + { return atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + + inline char + atomic_fetch_add_explicit(volatile atomic_char* __a, char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline char + atomic_fetch_add(volatile atomic_char* __a, char __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline char + atomic_fetch_sub_explicit(volatile atomic_char* __a, char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline char + atomic_fetch_sub(volatile atomic_char* __a, char __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline char + atomic_fetch_and_explicit(volatile atomic_char* __a, char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline char + atomic_fetch_and(volatile atomic_char* __a, char __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline char + atomic_fetch_or_explicit(volatile atomic_char* __a, char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline char + atomic_fetch_or(volatile atomic_char* __a, char __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline char + atomic_fetch_xor_explicit(volatile atomic_char* __a, char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline char + atomic_fetch_xor(volatile atomic_char* __a, char __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline signed char + atomic_fetch_add_explicit(volatile atomic_schar* __a, signed char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline signed char + atomic_fetch_add(volatile atomic_schar* __a, signed char __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline signed char + atomic_fetch_sub_explicit(volatile atomic_schar* __a, signed char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline signed char + atomic_fetch_sub(volatile atomic_schar* __a, signed char __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline signed char + atomic_fetch_and_explicit(volatile atomic_schar* __a, signed char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline signed char + atomic_fetch_and(volatile atomic_schar* __a, signed char __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline signed char + atomic_fetch_or_explicit(volatile atomic_schar* __a, signed char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline signed char + atomic_fetch_or(volatile atomic_schar* __a, signed char __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + + inline signed char + atomic_fetch_xor_explicit(volatile atomic_schar* __a, signed char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline signed char + atomic_fetch_xor(volatile atomic_schar* __a, signed char __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline unsigned char + atomic_fetch_add_explicit(volatile atomic_uchar* __a, unsigned char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline unsigned char + atomic_fetch_add(volatile atomic_uchar* __a, unsigned char __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned char + atomic_fetch_sub_explicit(volatile atomic_uchar* __a, unsigned char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline unsigned char + atomic_fetch_sub(volatile atomic_uchar* __a, unsigned char __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + + inline unsigned char + atomic_fetch_and_explicit(volatile atomic_uchar* __a, unsigned char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline unsigned char + atomic_fetch_and(volatile atomic_uchar* __a, unsigned char __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned char + atomic_fetch_or_explicit(volatile atomic_uchar* __a, unsigned char __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline unsigned char + atomic_fetch_or(volatile atomic_uchar* __a, unsigned char __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned char + atomic_fetch_xor_explicit(volatile atomic_uchar* __a, + unsigned char __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline unsigned char + atomic_fetch_xor(volatile atomic_uchar* __a, unsigned char __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline short + atomic_fetch_add_explicit(volatile atomic_short* __a, short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline short + atomic_fetch_add(volatile atomic_short* __a, short __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline short + atomic_fetch_sub_explicit(volatile atomic_short* __a, short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline short + atomic_fetch_sub(volatile atomic_short* __a, short __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline short + atomic_fetch_and_explicit(volatile atomic_short* __a, short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline short + atomic_fetch_and(volatile atomic_short* __a, short __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline short + atomic_fetch_or_explicit(volatile atomic_short* __a, short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline short + atomic_fetch_or(volatile atomic_short* __a, short __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline short + atomic_fetch_xor_explicit(volatile atomic_short* __a, short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline short + atomic_fetch_xor(volatile atomic_short* __a, short __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline unsigned short + atomic_fetch_add_explicit(volatile atomic_ushort* __a, unsigned short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline unsigned short + atomic_fetch_add(volatile atomic_ushort* __a, unsigned short __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned short + atomic_fetch_sub_explicit(volatile atomic_ushort* __a, unsigned short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline unsigned short + atomic_fetch_sub(volatile atomic_ushort* __a, unsigned short __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned short + atomic_fetch_and_explicit(volatile atomic_ushort* __a, unsigned short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline unsigned short + atomic_fetch_and(volatile atomic_ushort* __a, unsigned short __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned short + atomic_fetch_or_explicit(volatile atomic_ushort* __a, unsigned short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline unsigned short + atomic_fetch_or(volatile atomic_ushort* __a, unsigned short __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned short + atomic_fetch_xor_explicit(volatile atomic_ushort* __a, unsigned short __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline unsigned short + atomic_fetch_xor(volatile atomic_ushort* __a, unsigned short __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline int + atomic_fetch_add_explicit(volatile atomic_int* __a, int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline int + atomic_fetch_add(volatile atomic_int* __a, int __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline int + atomic_fetch_sub_explicit(volatile atomic_int* __a, int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline int + atomic_fetch_sub(volatile atomic_int* __a, int __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline int + atomic_fetch_and_explicit(volatile atomic_int* __a, int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline int + atomic_fetch_and(volatile atomic_int* __a, int __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline int + atomic_fetch_or_explicit(volatile atomic_int* __a, int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline int + atomic_fetch_or(volatile atomic_int* __a, int __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline int + atomic_fetch_xor_explicit(volatile atomic_int* __a, int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline int + atomic_fetch_xor(volatile atomic_int* __a, int __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline unsigned int + atomic_fetch_add_explicit(volatile atomic_uint* __a, unsigned int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline unsigned int + atomic_fetch_add(volatile atomic_uint* __a, unsigned int __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned int + atomic_fetch_sub_explicit(volatile atomic_uint* __a, unsigned int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline unsigned int + atomic_fetch_sub(volatile atomic_uint* __a, unsigned int __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned int + atomic_fetch_and_explicit(volatile atomic_uint* __a, unsigned int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline unsigned int + atomic_fetch_and(volatile atomic_uint* __a, unsigned int __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned int + atomic_fetch_or_explicit(volatile atomic_uint* __a, unsigned int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline unsigned int + atomic_fetch_or(volatile atomic_uint* __a, unsigned int __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned int + atomic_fetch_xor_explicit(volatile atomic_uint* __a, unsigned int __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline unsigned int + atomic_fetch_xor(volatile atomic_uint* __a, unsigned int __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline long + atomic_fetch_add_explicit(volatile atomic_long* __a, long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline long + atomic_fetch_add(volatile atomic_long* __a, long __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline long + atomic_fetch_sub_explicit(volatile atomic_long* __a, long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline long + atomic_fetch_sub(volatile atomic_long* __a, long __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline long + atomic_fetch_and_explicit(volatile atomic_long* __a, long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline long + atomic_fetch_and(volatile atomic_long* __a, long __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline long + atomic_fetch_or_explicit(volatile atomic_long* __a, long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline long + atomic_fetch_or(volatile atomic_long* __a, long __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline long + atomic_fetch_xor_explicit(volatile atomic_long* __a, long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline long + atomic_fetch_xor(volatile atomic_long* __a, long __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline unsigned long + atomic_fetch_add_explicit(volatile atomic_ulong* __a, unsigned long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline unsigned long + atomic_fetch_add(volatile atomic_ulong* __a, unsigned long __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long + atomic_fetch_sub_explicit(volatile atomic_ulong* __a, unsigned long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline unsigned long + atomic_fetch_sub(volatile atomic_ulong* __a, unsigned long __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long + atomic_fetch_and_explicit(volatile atomic_ulong* __a, unsigned long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline unsigned long + atomic_fetch_and(volatile atomic_ulong* __a, unsigned long __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long + atomic_fetch_or_explicit(volatile atomic_ulong* __a, unsigned long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline unsigned long + atomic_fetch_or(volatile atomic_ulong* __a, unsigned long __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long + atomic_fetch_xor_explicit(volatile atomic_ulong* __a, unsigned long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline unsigned long + atomic_fetch_xor(volatile atomic_ulong* __a, unsigned long __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline long long + atomic_fetch_add_explicit(volatile atomic_llong* __a, long long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline long long + atomic_fetch_add(volatile atomic_llong* __a, long long __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline long long + atomic_fetch_sub_explicit(volatile atomic_llong* __a, long long __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline long long + atomic_fetch_sub(volatile atomic_llong* __a, long long __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline long long + atomic_fetch_and_explicit(volatile atomic_llong* __a, + long long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline long long + atomic_fetch_and(volatile atomic_llong* __a, long long __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline long long + atomic_fetch_or_explicit(volatile atomic_llong* __a, + long long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline long long + atomic_fetch_or(volatile atomic_llong* __a, long long __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline long long + atomic_fetch_xor_explicit(volatile atomic_llong* __a, + long long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline long long + atomic_fetch_xor(volatile atomic_llong* __a, long long __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline unsigned long long + atomic_fetch_add_explicit(volatile atomic_ullong* __a, + unsigned long long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline unsigned long long + atomic_fetch_add(volatile atomic_ullong* __a, unsigned long long __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long long + atomic_fetch_sub_explicit(volatile atomic_ullong* __a, + unsigned long long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline unsigned long long + atomic_fetch_sub(volatile atomic_ullong* __a, unsigned long long __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long long + atomic_fetch_and_explicit(volatile atomic_ullong* __a, + unsigned long long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline unsigned long long + atomic_fetch_and(volatile atomic_ullong* __a, unsigned long long __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long long + atomic_fetch_or_explicit(volatile atomic_ullong* __a, + unsigned long long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline unsigned long long + atomic_fetch_or(volatile atomic_ullong* __a, unsigned long long __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline unsigned long long + atomic_fetch_xor_explicit(volatile atomic_ullong* __a, + unsigned long long __m, memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline unsigned long long + atomic_fetch_xor(volatile atomic_ullong* __a, unsigned long long __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + + inline wchar_t + atomic_fetch_add_explicit(volatile atomic_wchar_t* __a, wchar_t __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, +=, __m, __x); } + + inline wchar_t + atomic_fetch_add(volatile atomic_wchar_t* __a, wchar_t __m) + { atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst); } + + inline wchar_t + atomic_fetch_sub_explicit(volatile atomic_wchar_t* __a, wchar_t __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, -=, __m, __x); } + + inline wchar_t + atomic_fetch_sub(volatile atomic_wchar_t* __a, wchar_t __m) + { atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst); } + + inline wchar_t + atomic_fetch_and_explicit(volatile atomic_wchar_t* __a, wchar_t __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, &=, __m, __x); } + + inline wchar_t + atomic_fetch_and(volatile atomic_wchar_t* __a, wchar_t __m) + { atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst); } + + inline wchar_t + atomic_fetch_or_explicit(volatile atomic_wchar_t* __a, wchar_t __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, |=, __m, __x); } + + inline wchar_t + atomic_fetch_or(volatile atomic_wchar_t* __a, wchar_t __m) + { atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst); } + + inline wchar_t + atomic_fetch_xor_explicit(volatile atomic_wchar_t* __a, wchar_t __m, + memory_order __x) + { return _ATOMIC_MODIFY_(__a, ^=, __m, __x); } + + inline wchar_t + atomic_fetch_xor(volatile atomic_wchar_t* __a, wchar_t __m) + { atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst); } + + inline bool + atomic_bool::is_lock_free() const volatile + { return false; } + + inline void + atomic_bool::store(bool __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline bool + atomic_bool::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline bool + atomic_bool::swap(bool __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_bool::compare_swap(bool& __e, bool __m, memory_order __x, + memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_bool::compare_swap(bool& __e, bool __m, memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_bool::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_char::is_lock_free() const volatile + { return false; } + + inline void + atomic_char::store(char __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline char + atomic_char::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline char + atomic_char::swap(char __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_char::compare_swap(char& __e, char __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_char::compare_swap(char& __e, char __m, memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_char::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_schar::is_lock_free() const volatile + { return false; } + + inline void + atomic_schar::store(signed char __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline signed char + atomic_schar::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline signed char + atomic_schar::swap(signed char __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_schar::compare_swap(signed char& __e, signed char __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_schar::compare_swap(signed char& __e, signed char __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_schar::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + inline bool + atomic_uchar::is_lock_free() const volatile + { return false; } + + inline void + atomic_uchar::store(unsigned char __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline unsigned char + atomic_uchar::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline unsigned char + atomic_uchar::swap(unsigned char __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_uchar::compare_swap(unsigned char& __e, unsigned char __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_uchar::compare_swap(unsigned char& __e, unsigned char __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_uchar::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_short::is_lock_free() const volatile + { return false; } + + inline void + atomic_short::store(short __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline short + atomic_short::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline short + atomic_short::swap(short __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_short::compare_swap(short& __e, short __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_short::compare_swap(short& __e, short __m, memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_short::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_ushort::is_lock_free() const volatile + { return false; } + + inline void + atomic_ushort::store(unsigned short __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline unsigned short + atomic_ushort::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline unsigned short + atomic_ushort::swap(unsigned short __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_ushort::compare_swap(unsigned short& __e, unsigned short __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_ushort::compare_swap(unsigned short& __e, unsigned short __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_ushort::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_int::is_lock_free() const volatile + { return false; } + + inline void + atomic_int::store(int __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline int + atomic_int::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline int + atomic_int::swap(int __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_int::compare_swap(int& __e, int __m, memory_order __x, + memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_int::compare_swap(int& __e, int __m, memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_int::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_uint::is_lock_free() const volatile + { return false; } + + inline void + atomic_uint::store(unsigned int __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline unsigned int + atomic_uint::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline unsigned int + atomic_uint::swap(unsigned int __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_uint::compare_swap(unsigned int& __e, unsigned int __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_uint::compare_swap(unsigned int& __e, unsigned int __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_uint::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_long::is_lock_free() const volatile + { return false; } + + inline void + atomic_long::store(long __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline long + atomic_long::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline long + atomic_long::swap(long __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_long::compare_swap(long& __e, long __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_long::compare_swap(long& __e, long __m, memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_long::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_ulong::is_lock_free() const volatile + { return false; } + + inline void + atomic_ulong::store(unsigned long __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline unsigned long + atomic_ulong::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline unsigned long + atomic_ulong::swap(unsigned long __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_ulong::compare_swap(unsigned long& __e, unsigned long __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_ulong::compare_swap(unsigned long& __e, unsigned long __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_ulong::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_llong::is_lock_free() const volatile + { return false; } + + inline void + atomic_llong::store(long long __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline long long + atomic_llong::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline long long + atomic_llong::swap(long long __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_llong::compare_swap(long long& __e, long long __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_llong::compare_swap(long long& __e, long long __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_llong::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_ullong::is_lock_free() const volatile + { return false; } + + inline void + atomic_ullong::store(unsigned long long __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline unsigned long long + atomic_ullong::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline unsigned long long + atomic_ullong::swap(unsigned long long __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_ullong::compare_swap(unsigned long long& __e, unsigned long long __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_ullong::compare_swap(unsigned long long& __e, unsigned long long __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_ullong::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline bool + atomic_wchar_t::is_lock_free() const volatile + { return false; } + + inline void + atomic_wchar_t::store(wchar_t __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline wchar_t + atomic_wchar_t::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline wchar_t + atomic_wchar_t::swap(wchar_t __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_wchar_t::compare_swap(wchar_t& __e, wchar_t __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_wchar_t::compare_swap(wchar_t& __e, wchar_t __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_wchar_t::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + inline void* + atomic_address::fetch_add(ptrdiff_t __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + inline void* + atomic_address::fetch_sub(ptrdiff_t __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline char + atomic_char::fetch_add(char __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline char + atomic_char::fetch_sub(char __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline char + atomic_char::fetch_and(char __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline char + atomic_char::fetch_or(char __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline char + atomic_char::fetch_xor(char __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline signed char + atomic_schar::fetch_add(signed char __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline signed char + atomic_schar::fetch_sub(signed char __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline signed char + atomic_schar::fetch_and(signed char __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline signed char + atomic_schar::fetch_or(signed char __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline signed char + atomic_schar::fetch_xor(signed char __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline unsigned char + atomic_uchar::fetch_add(unsigned char __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline unsigned char + atomic_uchar::fetch_sub(unsigned char __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline unsigned char + atomic_uchar::fetch_and(unsigned char __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline unsigned char + atomic_uchar::fetch_or(unsigned char __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline unsigned char + atomic_uchar::fetch_xor(unsigned char __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline short + atomic_short::fetch_add(short __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline short + atomic_short::fetch_sub(short __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline short + atomic_short::fetch_and(short __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline short + atomic_short::fetch_or(short __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline short + atomic_short::fetch_xor(short __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline unsigned short + atomic_ushort::fetch_add(unsigned short __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline unsigned short + atomic_ushort::fetch_sub(unsigned short __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline unsigned short + atomic_ushort::fetch_and(unsigned short __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline unsigned short + atomic_ushort::fetch_or(unsigned short __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline unsigned short + atomic_ushort::fetch_xor(unsigned short __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline int + atomic_int::fetch_add(int __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline int + atomic_int::fetch_sub(int __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline int + atomic_int::fetch_and(int __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline int + atomic_int::fetch_or(int __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline int + atomic_int::fetch_xor(int __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline unsigned int + atomic_uint::fetch_add(unsigned int __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline unsigned int + atomic_uint::fetch_sub(unsigned int __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline unsigned int + atomic_uint::fetch_and(unsigned int __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline unsigned int + atomic_uint::fetch_or(unsigned int __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline unsigned int + atomic_uint::fetch_xor(unsigned int __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline long + atomic_long::fetch_add(long __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline long + atomic_long::fetch_sub(long __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline long + atomic_long::fetch_and(long __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline long + atomic_long::fetch_or(long __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline long + atomic_long::fetch_xor(long __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline unsigned long + atomic_ulong::fetch_add(unsigned long __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline unsigned long + atomic_ulong::fetch_sub(unsigned long __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline unsigned long + atomic_ulong::fetch_and(unsigned long __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline unsigned long + atomic_ulong::fetch_or(unsigned long __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline unsigned long + atomic_ulong::fetch_xor(unsigned long __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline long long + atomic_llong::fetch_add(long long __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline long long + atomic_llong::fetch_sub(long long __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline long long + atomic_llong::fetch_and(long long __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline long long + atomic_llong::fetch_or(long long __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline long long + atomic_llong::fetch_xor(long long __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline unsigned long long + atomic_ullong::fetch_add(unsigned long long __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline unsigned long long + atomic_ullong::fetch_sub(unsigned long long __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline unsigned long long + atomic_ullong::fetch_and(unsigned long long __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline unsigned long long + atomic_ullong::fetch_or(unsigned long long __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline unsigned long long + atomic_ullong::fetch_xor(unsigned long long __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline wchar_t + atomic_wchar_t::fetch_add(wchar_t __m, memory_order __x) volatile + { return atomic_fetch_add_explicit(this, __m, __x); } + + + inline wchar_t + atomic_wchar_t::fetch_sub(wchar_t __m, memory_order __x) volatile + { return atomic_fetch_sub_explicit(this, __m, __x); } + + + inline wchar_t + atomic_wchar_t::fetch_and(wchar_t __m, memory_order __x) volatile + { return atomic_fetch_and_explicit(this, __m, __x); } + + + inline wchar_t + atomic_wchar_t::fetch_or(wchar_t __m, memory_order __x) volatile + { return atomic_fetch_or_explicit(this, __m, __x); } + + + inline wchar_t + atomic_wchar_t::fetch_xor(wchar_t __m, memory_order __x) volatile + { return atomic_fetch_xor_explicit(this, __m, __x); } + + + inline bool + atomic_address::is_lock_free() const volatile + { return false; } + + inline void + atomic_address::store(void* __m, memory_order __x) volatile + { atomic_store_explicit(this, __m, __x); } + + inline void* + atomic_address::load(memory_order __x) volatile + { return atomic_load_explicit(this, __x); } + + inline void* + atomic_address::swap(void* __m, memory_order __x) volatile + { return atomic_swap_explicit(this, __m, __x); } + + inline bool + atomic_address::compare_swap(void*& __e, void* __m, + memory_order __x, memory_order __y) volatile + { return atomic_compare_swap_explicit(this, &__e, __m, __x, __y); } + + inline bool + atomic_address::compare_swap(void*& __e, void* __m, + memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return atomic_compare_swap_explicit(this, &__e, __m, __x, __mo2); + } + + inline void + atomic_address::fence(memory_order __x) const volatile + { return atomic_fence(this, __x); } + + + template<typename _Tp> + inline bool + atomic<_Tp>::is_lock_free() const volatile + { return false; } + + template<typename _Tp> + inline void + atomic<_Tp>::store(_Tp __v, memory_order __x) volatile + // XXX + // { _ATOMIC_STORE_(this, __v, __x); } + { } + + template<typename _Tp> + inline _Tp + atomic<_Tp>::load(memory_order __x) volatile + // XXX + // { return _ATOMIC_LOAD_(this, __x); } + { } + + template<typename _Tp> + inline _Tp + atomic<_Tp>::swap(_Tp __v, memory_order __x) volatile + // XXX + // { return _ATOMIC_MODIFY_(this, =, __v, __x); } + { } + + template<typename _Tp> + inline bool + atomic<_Tp>::compare_swap(_Tp& __r, _Tp __v, memory_order __x, + memory_order __y) volatile + // XXX + // { return _ATOMIC_CMPSWP_(this, &__r, __v, __x); } + { } + + template<typename _Tp> + inline bool + atomic<_Tp>::compare_swap(_Tp& __r, _Tp __v, memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return compare_swap(__r, __v, __x, __mo2); + } + + template<typename _Tp> + _Tp* + atomic<_Tp*>::load(memory_order __x) volatile + { return static_cast<_Tp*>(atomic_address::load(__x)); } + + template<typename _Tp> + _Tp* + atomic<_Tp*>::swap(_Tp* __v, memory_order __x) volatile + { return static_cast<_Tp*>(atomic_address::swap(__v, __x)); } + + template<typename _Tp> + bool + atomic<_Tp*>::compare_swap(_Tp*& __r, _Tp* __v, memory_order __x, + memory_order __y) volatile + { return atomic_address::compare_swap(*reinterpret_cast<void**>(&__r), + static_cast<void*>(__v), __x, __y); } + + template<typename _Tp> + bool + atomic<_Tp*>::compare_swap(_Tp*& __r, _Tp* __v, memory_order __x) volatile + { + const bool __cond1 = __x == memory_order_release; + const bool __cond2 = __x == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __x); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return compare_swap(__r, __v, __x, __mo2); + } + + template<typename _Tp> + _Tp* + atomic<_Tp*>::fetch_add(ptrdiff_t __v, memory_order __x) volatile + { + void* __p = atomic_fetch_add_explicit(this, sizeof(_Tp) * __v, __x); + return static_cast<_Tp*>(__p); + } + + template<typename _Tp> + _Tp* + atomic<_Tp*>::fetch_sub(ptrdiff_t __v, memory_order __x) volatile + { + void* __p = atomic_fetch_sub_explicit(this, sizeof(_Tp) * __v, __x); + return static_cast<_Tp*>(__p); + } + +_GLIBCXX_END_NAMESPACE + +#endif + + diff --git a/libstdc++-v3/include/ext/typelist.h b/libstdc++-v3/include/ext/typelist.h index b7cd95434e6..03f28a78323 100644 --- a/libstdc++-v3/include/ext/typelist.h +++ b/libstdc++-v3/include/ext/typelist.h @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2008 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -71,10 +71,21 @@ namespace typelist typedef Typelist tail; }; - template<typename Fn, class Typelist> + // Apply all typelist types to unary functor. + template<typename Fn, typename Typelist> void apply(Fn&, Typelist); + /// Apply all typelist types to generator functor. + template<typename Gn, typename Typelist> + void + apply_generator(Gn&, Typelist); + + // Apply all typelist types and values to generator functor. + template<typename Gn, typename TypelistT, typename TypelistV> + void + apply_generator(Gn&, TypelistT, TypelistV); + template<typename Typelist0, typename Typelist1> struct append; @@ -135,20 +146,64 @@ namespace detail struct apply_<Fn, chain<Hd, Tl> > { void - operator() (Fn& f) + operator()(Fn& f) { f.operator()(Hd()); apply_<Fn, Tl> next; next(f); } - }; + }; template<typename Fn> struct apply_<Fn, null_type> { void operator()(Fn&) { } - }; + }; + + template<typename Gn, typename Typelist_Chain> + struct apply_generator1_; + + template<typename Gn, typename Hd, typename Tl> + struct apply_generator1_<Gn, chain<Hd, Tl> > + { + void + operator()(Gn& g) + { + g.template operator()<Hd>(); + apply_generator1_<Gn, Tl> next; + next(g); + } + }; + + template<typename Gn> + struct apply_generator1_<Gn, null_type> + { + void + operator()(Gn&) { } + }; + + template<typename Gn, typename TypelistT_Chain, typename TypelistV_Chain> + struct apply_generator2_; + + template<typename Gn, typename Hd1, typename TlT, typename Hd2, typename TlV> + struct apply_generator2_<Gn, chain<Hd1, TlT>, chain<Hd2, TlV> > + { + void + operator()(Gn& g) + { + g.template operator()<Hd1, Hd2>(); + apply_generator2_<Gn, TlT, TlV> next; + next(g); + } + }; + + template<typename Gn> + struct apply_generator2_<Gn, null_type, null_type> + { + void + operator()(Gn&) { } + }; template<typename Typelist_Chain0, typename Typelist_Chain1> struct append_; @@ -294,20 +349,20 @@ namespace detail struct chain_flatten_; template<typename Hd_Tl> - struct chain_flatten_<chain<Hd_Tl, null_type> > - { - typedef typename Hd_Tl::root type; - }; + struct chain_flatten_<chain<Hd_Tl, null_type> > + { + typedef typename Hd_Tl::root type; + }; template<typename Hd_Typelist, class Tl_Typelist> - struct chain_flatten_<chain<Hd_Typelist, Tl_Typelist> > - { - private: - typedef typename chain_flatten_<Tl_Typelist>::type rest_type; - typedef append<Hd_Typelist, node<rest_type> > append_type; - public: - typedef typename append_type::type::root type; - }; + struct chain_flatten_<chain<Hd_Typelist, Tl_Typelist> > + { + private: + typedef typename chain_flatten_<Tl_Typelist>::type rest_type; + typedef append<Hd_Typelist, node<rest_type> > append_type; + public: + typedef typename append_type::type::root type; + }; } // namespace detail } // namespace typelist @@ -333,7 +388,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) namespace typelist { - template<typename Fn, class Typelist> + template<typename Fn, typename Typelist> void apply(Fn& fn, Typelist) { @@ -341,6 +396,24 @@ namespace typelist a(fn); } + template<typename Fn, typename Typelist> + void + apply_generator(Fn& fn, Typelist) + { + detail::apply_generator1_<Fn, typename Typelist::root> a; + a(fn); + } + + template<typename Fn, typename TypelistT, typename TypelistV> + void + apply_generator(Fn& fn, TypelistT, TypelistV) + { + typedef typename TypelistT::root rootT; + typedef typename TypelistV::root rootV; + detail::apply_generator2_<Fn, rootT, rootV> a; + a(fn); + } + template<typename Typelist0, typename Typelist1> struct append { diff --git a/libstdc++-v3/libmath/Makefile.in b/libstdc++-v3/libmath/Makefile.in index f423f83e53e..c2302be25a7 100644 --- a/libstdc++-v3/libmath/Makefile.in +++ b/libstdc++-v3/libmath/Makefile.in @@ -49,6 +49,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/enable.m4 \ $(top_srcdir)/../config/lib-prefix.m4 \ $(top_srcdir)/../config/multi.m4 \ $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/proginstall.m4 \ $(top_srcdir)/../config/unwind_ipinfo.m4 \ $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \ $(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \ diff --git a/libstdc++-v3/libsupc++/Makefile.in b/libstdc++-v3/libsupc++/Makefile.in index 7453d3da8f1..631a3f3fa0d 100644 --- a/libstdc++-v3/libsupc++/Makefile.in +++ b/libstdc++-v3/libsupc++/Makefile.in @@ -51,6 +51,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/enable.m4 \ $(top_srcdir)/../config/lib-prefix.m4 \ $(top_srcdir)/../config/multi.m4 \ $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/proginstall.m4 \ $(top_srcdir)/../config/unwind_ipinfo.m4 \ $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \ $(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \ diff --git a/libstdc++-v3/po/Makefile.in b/libstdc++-v3/po/Makefile.in index e6a32044d1f..c7ce1cafb32 100644 --- a/libstdc++-v3/po/Makefile.in +++ b/libstdc++-v3/po/Makefile.in @@ -49,6 +49,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/enable.m4 \ $(top_srcdir)/../config/lib-prefix.m4 \ $(top_srcdir)/../config/multi.m4 \ $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/proginstall.m4 \ $(top_srcdir)/../config/unwind_ipinfo.m4 \ $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \ $(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \ diff --git a/libstdc++-v3/src/Makefile.am b/libstdc++-v3/src/Makefile.am index 7bd12aa1f60..e6c0aad184a 100644 --- a/libstdc++-v3/src/Makefile.am +++ b/libstdc++-v3/src/Makefile.am @@ -134,6 +134,7 @@ endif # Sources present in the src directory. sources = \ + atomic.cc \ bitmap_allocator.cc \ pool_allocator.cc \ mt_allocator.cc \ @@ -248,6 +249,11 @@ date_time.lo: date_time.cc date_time.o: date_time.cc $(CXXCOMPILE) -std=gnu++0x -c $< +atomic.lo: atomic.cc + $(LTCXXCOMPILE) -x c++ -std=gnu++0x -c $< +atomic.o: atomic.cc + $(CXXCOMPILE) -x c++ -std=gnu++0x -c $< + if GLIBCXX_LDBL_COMPAT # Use special rules for compatibility-ldbl.cc compilation, as we need to # pass -mlong-double-64. diff --git a/libstdc++-v3/src/Makefile.in b/libstdc++-v3/src/Makefile.in index 450e97f9538..744833f75c2 100644 --- a/libstdc++-v3/src/Makefile.in +++ b/libstdc++-v3/src/Makefile.in @@ -50,6 +50,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/enable.m4 \ $(top_srcdir)/../config/lib-prefix.m4 \ $(top_srcdir)/../config/multi.m4 \ $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/proginstall.m4 \ $(top_srcdir)/../config/unwind_ipinfo.m4 \ $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \ $(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \ @@ -69,18 +70,18 @@ am__strip_dir = `echo $$p | sed -e 's|^.*/||'`; am__installdirs = "$(DESTDIR)$(toolexeclibdir)" toolexeclibLTLIBRARIES_INSTALL = $(INSTALL) LTLIBRARIES = $(toolexeclib_LTLIBRARIES) -am__libstdc___la_SOURCES_DIST = bitmap_allocator.cc pool_allocator.cc \ - mt_allocator.cc codecvt.cc compatibility.cc complex_io.cc \ - ctype.cc date_time.cc debug.cc functexcept.cc hash.cc \ - hash_c++0x.cc globals_io.cc hashtable.cc hashtable_c++0x.cc \ - ios.cc ios_failure.cc ios_init.cc ios_locale.cc limits.cc \ - list.cc debug_list.cc locale.cc locale_init.cc \ - locale_facets.cc localename.cc stdexcept.cc strstream.cc \ - system_error.cc tree.cc allocator-inst.cc concept-inst.cc \ - fstream-inst.cc ext-inst.cc ios-inst.cc iostream-inst.cc \ - istream-inst.cc istream.cc locale-inst.cc misc-inst.cc \ - ostream-inst.cc sstream-inst.cc streambuf-inst.cc streambuf.cc \ - string-inst.cc valarray-inst.cc wlocale-inst.cc \ +am__libstdc___la_SOURCES_DIST = atomic.cc bitmap_allocator.cc \ + pool_allocator.cc mt_allocator.cc codecvt.cc compatibility.cc \ + complex_io.cc ctype.cc date_time.cc debug.cc functexcept.cc \ + hash.cc hash_c++0x.cc globals_io.cc hashtable.cc \ + hashtable_c++0x.cc ios.cc ios_failure.cc ios_init.cc \ + ios_locale.cc limits.cc list.cc debug_list.cc locale.cc \ + locale_init.cc locale_facets.cc localename.cc stdexcept.cc \ + strstream.cc system_error.cc tree.cc allocator-inst.cc \ + concept-inst.cc fstream-inst.cc ext-inst.cc ios-inst.cc \ + iostream-inst.cc istream-inst.cc istream.cc locale-inst.cc \ + misc-inst.cc ostream-inst.cc sstream-inst.cc streambuf-inst.cc \ + streambuf.cc string-inst.cc valarray-inst.cc wlocale-inst.cc \ wstring-inst.cc atomicity.cc codecvt_members.cc \ collate_members.cc ctype_members.cc messages_members.cc \ monetary_members.cc numeric_members.cc time_members.cc \ @@ -94,19 +95,19 @@ am__objects_1 = atomicity.lo codecvt_members.lo collate_members.lo \ @ENABLE_PARALLEL_TRUE@ parallel_settings.lo am__objects_4 = basic_file.lo c++locale.lo $(am__objects_2) \ $(am__objects_3) -am__objects_5 = bitmap_allocator.lo pool_allocator.lo mt_allocator.lo \ - codecvt.lo compatibility.lo complex_io.lo ctype.lo \ - date_time.lo debug.lo functexcept.lo hash.lo hash_c++0x.lo \ - globals_io.lo hashtable.lo hashtable_c++0x.lo ios.lo \ - ios_failure.lo ios_init.lo ios_locale.lo limits.lo list.lo \ - debug_list.lo locale.lo locale_init.lo locale_facets.lo \ - localename.lo stdexcept.lo strstream.lo system_error.lo \ - tree.lo allocator-inst.lo concept-inst.lo fstream-inst.lo \ - ext-inst.lo ios-inst.lo iostream-inst.lo istream-inst.lo \ - istream.lo locale-inst.lo misc-inst.lo ostream-inst.lo \ - sstream-inst.lo streambuf-inst.lo streambuf.lo string-inst.lo \ - valarray-inst.lo wlocale-inst.lo wstring-inst.lo \ - $(am__objects_1) $(am__objects_4) +am__objects_5 = atomic.lo bitmap_allocator.lo pool_allocator.lo \ + mt_allocator.lo codecvt.lo compatibility.lo complex_io.lo \ + ctype.lo date_time.lo debug.lo functexcept.lo hash.lo \ + hash_c++0x.lo globals_io.lo hashtable.lo hashtable_c++0x.lo \ + ios.lo ios_failure.lo ios_init.lo ios_locale.lo limits.lo \ + list.lo debug_list.lo locale.lo locale_init.lo \ + locale_facets.lo localename.lo stdexcept.lo strstream.lo \ + system_error.lo tree.lo allocator-inst.lo concept-inst.lo \ + fstream-inst.lo ext-inst.lo ios-inst.lo iostream-inst.lo \ + istream-inst.lo istream.lo locale-inst.lo misc-inst.lo \ + ostream-inst.lo sstream-inst.lo streambuf-inst.lo streambuf.lo \ + string-inst.lo valarray-inst.lo wlocale-inst.lo \ + wstring-inst.lo $(am__objects_1) $(am__objects_4) am_libstdc___la_OBJECTS = $(am__objects_5) libstdc___la_OBJECTS = $(am_libstdc___la_OBJECTS) DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir) @@ -367,6 +368,7 @@ host_sources_extra = \ # Sources present in the src directory. sources = \ + atomic.cc \ bitmap_allocator.cc \ pool_allocator.cc \ mt_allocator.cc \ @@ -839,6 +841,11 @@ date_time.lo: date_time.cc date_time.o: date_time.cc $(CXXCOMPILE) -std=gnu++0x -c $< +atomic.lo: atomic.cc + $(LTCXXCOMPILE) -x c++ -std=gnu++0x -c $< +atomic.o: atomic.cc + $(CXXCOMPILE) -x c++ -std=gnu++0x -c $< + # Use special rules for compatibility-ldbl.cc compilation, as we need to # pass -mlong-double-64. @GLIBCXX_LDBL_COMPAT_TRUE@compatibility-ldbl.lo: compatibility-ldbl.cc diff --git a/libstdc++-v3/src/atomic.cc b/libstdc++-v3/src/atomic.cc new file mode 100644 index 00000000000..e43733332db --- /dev/null +++ b/libstdc++-v3/src/atomic.cc @@ -0,0 +1,116 @@ +// Support for atomic operations -*- C++ -*- + +// Copyright (C) 2008 +// Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02110-1301, USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <stdint.h> +#include <cstdatomic> + +#define LOGSIZE 4 + +namespace +{ + atomic_flag volatile __atomic_flag_anon_table__[ 1 << LOGSIZE ] = + { + ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, + ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, + ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, + ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, ATOMIC_FLAG_INIT, + }; +} // anonymous namespace + +namespace std +{ + extern "C" { + + const atomic_flag atomic_global_fence_compatibility = ATOMIC_FLAG_INIT; + + bool + atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, + memory_order __x) + { +#ifdef _GLIBCXX_ATOMIC_BUILTINS + if (__x >= memory_order_acq_rel) + __sync_synchronize(); + return __sync_lock_test_and_set(&(__a->_M_base._M_b), 1); +#else + bool result = __a->_M_base._M_b; + __a->_M_base._M_b = true; + return result; +#endif + } + + bool + atomic_flag_test_and_set(volatile atomic_flag* __a) + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } + + void + atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __x) + { +#ifdef _GLIBCXX_ATOMIC_BUILTINS + __sync_lock_release(&(__a->_M_base._M_b)); + if (__x >= memory_order_acq_rel) + __sync_synchronize(); +#else + __a->_M_base._M_b = false; +#endif + } + + void + atomic_flag_clear(volatile atomic_flag* __a) + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + void + atomic_flag_fence(const volatile atomic_flag*, memory_order) + { +#ifdef _GLIBCXX_ATOMIC_BUILTINS + __sync_synchronize(); +#endif + } + + void + __atomic_flag_wait_explicit(volatile atomic_flag* __a, memory_order __x) + { + while (atomic_flag_test_and_set_explicit(__a, __x)) + { }; + } + + volatile atomic_flag* + __atomic_flag_for_address(const volatile void* __z) + { + uintptr_t __u = reinterpret_cast<uintptr_t>(__z); + __u += (__u >> 2) + (__u << 4); + __u += (__u >> 7) + (__u << 5); + __u += (__u >> 17) + (__u << 13); + if (sizeof(uintptr_t) > 4) __u += (__u >> 31); + __u &= ~((~uintptr_t(0)) << LOGSIZE); + return __atomic_flag_anon_table__ + __u; + } + + } // extern "C" +} // namespace std diff --git a/libstdc++-v3/testsuite/17_intro/headers/c++200x/all.cc b/libstdc++-v3/testsuite/17_intro/headers/c++200x/all.cc index 1bc1e6acd7a..6c30410bb6f 100644 --- a/libstdc++-v3/testsuite/17_intro/headers/c++200x/all.cc +++ b/libstdc++-v3/testsuite/17_intro/headers/c++200x/all.cc @@ -36,6 +36,7 @@ #include <csetjmp> #include <csignal> #include <cstdarg> +#include <cstdatomic> #include <cstdbool> #include <cstddef> #include <cstdint> @@ -67,6 +68,7 @@ #include <math.h> #include <setjmp.h> #include <signal.h> +#include <stdatomic.h> #include <stdarg.h> #ifdef _GLIBCXX_HAVE_STDBOOL_H #include <stdbool.h> diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/cons/assign_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic/cons/assign_neg.cc new file mode 100644 index 00000000000..435309860a3 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic/cons/assign_neg.cc @@ -0,0 +1,55 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::assignable test; + __gnu_cxx::typelist::apply_generator(test, __gnu_test::atomics_tl()); + return 0; +} + +// { dg-error "within this context" "" { target *-*-* } 310 } +// { dg-error "is private" "" { target *-*-* } 1750 } +// { dg-error "is private" "" { target *-*-* } 1782 } +// { dg-error "is private" "" { target *-*-* } 1799 } +// { dg-error "is private" "" { target *-*-* } 1816 } +// { dg-error "is private" "" { target *-*-* } 1832 } +// { dg-error "is private" "" { target *-*-* } 1848 } +// { dg-error "is private" "" { target *-*-* } 1864 } +// { dg-error "is private" "" { target *-*-* } 1880 } +// { dg-error "is private" "" { target *-*-* } 1896 } +// { dg-error "is private" "" { target *-*-* } 1913 } +// { dg-error "is private" "" { target *-*-* } 1929 } +// { dg-error "is private" "" { target *-*-* } 1945 } +// { dg-error "is private" "" { target *-*-* } 1961 } +// { dg-excess-errors "In member function" } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/cons/copy_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic/cons/copy_neg.cc new file mode 100644 index 00000000000..011933a8eb8 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic/cons/copy_neg.cc @@ -0,0 +1,55 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::copy_constructible test; + __gnu_cxx::typelist::apply_generator(test, __gnu_test::atomics_tl()); + return 0; +} + +// { dg-error "within this context" "" { target *-*-* } 333 } +// { dg-error "is private" "" { target *-*-* } 1749 } +// { dg-error "is private" "" { target *-*-* } 1781 } +// { dg-error "is private" "" { target *-*-* } 1798 } +// { dg-error "is private" "" { target *-*-* } 1814 } +// { dg-error "is private" "" { target *-*-* } 1831 } +// { dg-error "is private" "" { target *-*-* } 1847 } +// { dg-error "is private" "" { target *-*-* } 1863 } +// { dg-error "is private" "" { target *-*-* } 1879 } +// { dg-error "is private" "" { target *-*-* } 1895 } +// { dg-error "is private" "" { target *-*-* } 1912 } +// { dg-error "is private" "" { target *-*-* } 1928 } +// { dg-error "is private" "" { target *-*-* } 1944 } +// { dg-error "is private" "" { target *-*-* } 1960 } +// { dg-excess-errors "In member function" } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/cons/default.cc b/libstdc++-v3/testsuite/29_atomics/atomic/cons/default.cc new file mode 100644 index 00000000000..c8af19ad2ed --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic/cons/default.cc @@ -0,0 +1,38 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::default_constructible test; + __gnu_cxx::typelist::apply_generator(test, __gnu_test::atomics_tl()); + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/cons/explicit_value.cc b/libstdc++-v3/testsuite/29_atomics/atomic/cons/explicit_value.cc new file mode 100644 index 00000000000..da91e26a55d --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic/cons/explicit_value.cc @@ -0,0 +1,39 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::explicit_value_constructible test; + __gnu_cxx::typelist::apply_generator(test, __gnu_test::atomics_tl(), + __gnu_test::integral_types::type()); + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/requirements/explicit_instantiation/1.cc b/libstdc++-v3/testsuite/29_atomics/atomic/requirements/explicit_instantiation/1.cc new file mode 100644 index 00000000000..5dafd093a01 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic/requirements/explicit_instantiation/1.cc @@ -0,0 +1,37 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +// This file tests explicit instantiation of basic_string + +#include <cstdatomic> +#include <testsuite_character.h> + +template class std::atomic<__gnu_test::pod_char>; +template class std::atomic<__gnu_test::pod_char*>; diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/aggregate.cc b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/aggregate.cc new file mode 100644 index 00000000000..f6aee27ce51 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/aggregate.cc @@ -0,0 +1,37 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile { xfail *-*-* } } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +int main() +{ + std::atomic_address a = { { NULL } }; // { dg-excess-errors "braces around" } + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/assign_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/assign_neg.cc new file mode 100644 index 00000000000..ef50b9ed38f --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/assign_neg.cc @@ -0,0 +1,42 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +void test01() +{ + // Assign. + typedef std::atomic_address test_type; + test_type t1; + test_type t2; + t1 = t2; +} +// { dg-error "within this context" "" { target *-*-* } 39 } +// { dg-error "is private" "" { target *-*-* } 167 } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/copy_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/copy_neg.cc new file mode 100644 index 00000000000..57732d83335 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/copy_neg.cc @@ -0,0 +1,41 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +void test01() +{ + // Copy. + typedef std::atomic_address test_type; + test_type t1; + test_type t2(t1); +} +// { dg-error "within this context" "" { target *-*-* } 38 } +// { dg-error "is private" "" { target *-*-* } 166 } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/default.cc b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/default.cc new file mode 100644 index 00000000000..1d2c6cba50b --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/default.cc @@ -0,0 +1,37 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +int main() +{ + // Default constructor. + std::atomic_address a; + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/explicit_value.cc b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/explicit_value.cc new file mode 100644 index 00000000000..b455bf667cd --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/explicit_value.cc @@ -0,0 +1,38 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +int main() +{ + // Explicit value constructor. + void* v = NULL; + std::atomic_address a(v); + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/atomic_global_fence_compatibility.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/atomic_global_fence_compatibility.cc new file mode 100644 index 00000000000..7ee633ebb32 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/atomic_global_fence_compatibility.cc @@ -0,0 +1,39 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +int main() +{ + using namespace std; + atomic_flag_fence(&atomic_global_fence_compatibility, memory_order_acquire); + atomic_global_fence_compatibility.fence(memory_order_release); + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/aggregate.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/aggregate.cc new file mode 100644 index 00000000000..151d85fc050 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/aggregate.cc @@ -0,0 +1,38 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +int main() +{ + // Only safe usage. + std::atomic_flag guard = ATOMIC_FLAG_INIT; + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/assign_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/assign_neg.cc new file mode 100644 index 00000000000..5f8ff15dc52 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/assign_neg.cc @@ -0,0 +1,42 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +void test01() +{ + // Assign. + typedef std::atomic_flag test_type; + test_type t1; + test_type t2; + t1 = t2; +} +// { dg-error "within this context" "" { xfail *-*-* } 39 } +// { dg-error "is private" "" { xfail *-*-* } 89 } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/copy_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/copy_neg.cc new file mode 100644 index 00000000000..3480d8c5e16 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/copy_neg.cc @@ -0,0 +1,41 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +void test01() +{ + // Copy. + typedef std::atomic_flag test_type; + test_type t1; + test_type t2(t1); +} +// { dg-error "within this context" "" { xfail *-*-* } 38 } +// { dg-error "is private" "" { xfail *-*-* } 88 } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/default.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/default.cc new file mode 100644 index 00000000000..b4fa3a755b2 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/default.cc @@ -0,0 +1,37 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +int main() +{ + // Default constructor. + std::atomic_flag a; + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/requirements/standard_layout.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/requirements/standard_layout.cc new file mode 100644 index 00000000000..351df912fff --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/requirements/standard_layout.cc @@ -0,0 +1,43 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> +#include <type_traits> +#include <testsuite_hooks.h> + +int main() +{ + bool test __attribute__((unused)) = true; + + typedef std::atomic_flag test_type; + VERIFY( std::has_trivial_default_constructor<test_type>::value ); + VERIFY( std::has_trivial_destructor<test_type>::value ); + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/explicit.c b/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/explicit.c new file mode 100644 index 00000000000..9401af4d13b --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/explicit.c @@ -0,0 +1,40 @@ +// { dg-options "-x c -lstdc++" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <stdatomic.h> + +int main() +{ + atomic_flag af = ATOMIC_FLAG_INIT; + + if (!atomic_flag_test_and_set_explicit(&af, memory_order_acquire)) + atomic_flag_clear_explicit(&af, memory_order_release); + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/explicit.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/explicit.cc new file mode 100644 index 00000000000..c81a75aa99a --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/explicit.cc @@ -0,0 +1,41 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +int main() +{ + using namespace std; + atomic_flag af = ATOMIC_FLAG_INIT; + + if (!af.test_and_set(memory_order_acquire)) + af.clear(memory_order_release); + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/implicit.c b/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/implicit.c new file mode 100644 index 00000000000..727421bd12f --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/implicit.c @@ -0,0 +1,40 @@ +// { dg-options "-x c -lstdc++" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <stdatomic.h> + +int main() +{ + atomic_flag af = ATOMIC_FLAG_INIT; + + if (!atomic_flag_test_and_set(&af)) + atomic_flag_clear(&af); + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/implicit.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/implicit.cc new file mode 100644 index 00000000000..82961767e86 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/implicit.cc @@ -0,0 +1,41 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include <cstdatomic> + +int main() +{ + using namespace std; + atomic_flag af = ATOMIC_FLAG_INIT; + + if (!af.test_and_set()) + af.clear(); + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/functions_std_c++0x.cc b/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/functions_std_c++0x.cc new file mode 100644 index 00000000000..5444d71f378 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/functions_std_c++0x.cc @@ -0,0 +1,50 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <cstdatomic> + +namespace gnu +{ + using std::atomic_flag_test_and_set; + using std::atomic_flag_test_and_set_explicit; + using std::atomic_flag_clear; + using std::atomic_flag_clear_explicit; + using std::atomic_flag_fence; + + using std::atomic_global_fence_compatibility; + + // Sloppy testing for integral types (en masse). + using std::atomic_is_lock_free; + using std::atomic_store; + using std::atomic_store_explicit; + using std::atomic_load; + using std::atomic_load_explicit; + using std::atomic_swap; + using std::atomic_swap_explicit; + using std::atomic_compare_swap; + using std::atomic_compare_swap_explicit; + using std::atomic_fence; + + using std::atomic_fetch_add; + using std::atomic_fetch_add_explicit; + using std::atomic_fetch_sub; + using std::atomic_fetch_sub_explicit; +} diff --git a/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/macros.cc b/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/macros.cc new file mode 100644 index 00000000000..62f76ab1f0e --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/macros.cc @@ -0,0 +1,37 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <cstdatomic> + +namespace gnu +{ +#ifndef ATOMIC_INTEGRAL_LOCK_FREE + #error "ATOMIC_INTEGRAL_LOCK_FREE_must_be_a_macro" +#endif + +#ifndef ATOMIC_ADDRESS_LOCK_FREE + #error "ATOMIC_ADDRESS_LOCK_FREE_must_be_a_macro" +#endif + +#ifndef ATOMIC_FLAG_INIT + #error "ATOMIC_FLAG_INIT_must_be_a_macro" +#endif +} diff --git a/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/std_c++0x_neg.cc b/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/std_c++0x_neg.cc new file mode 100644 index 00000000000..f72e8136a58 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/std_c++0x_neg.cc @@ -0,0 +1,27 @@ +// { dg-do compile } +// { dg-options "-std=gnu++98" } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <cstdatomic> // { dg-excess-errors "In file included from" } + +// { dg-error "upcoming ISO" "" { target *-*-* } 36 } + + + diff --git a/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/types_std_c++0x.cc b/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/types_std_c++0x.cc new file mode 100644 index 00000000000..31b32c13813 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/headers/cstdatomic/types_std_c++0x.cc @@ -0,0 +1,80 @@ +// { dg-options "-std=gnu++0x" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <cstdatomic> + +void test01() +{ + using std::memory_order; + using std::memory_order_relaxed; + using std::memory_order_acquire; + using std::memory_order_release; + using std::memory_order_acq_rel; + using std::memory_order_seq_cst; + + using std::atomic_flag; + + // atomics for builtins types + using std::atomic_bool; + using std::atomic_char; + using std::atomic_schar; + using std::atomic_uchar; + using std::atomic_short; + using std::atomic_ushort; + using std::atomic_int; + using std::atomic_uint; + using std::atomic_long; + using std::atomic_ulong; + using std::atomic_llong; + using std::atomic_ullong; + using std::atomic_wchar_t; + using std::atomic_char16_t; + using std::atomic_char32_t; + + // atomics for standard typedefs + using std::atomic_int_least8_t; + using std::atomic_uint_least8_t; + using std::atomic_int_least16_t; + using std::atomic_uint_least16_t; + using std::atomic_int_least32_t; + using std::atomic_uint_least32_t; + using std::atomic_int_least64_t; + using std::atomic_uint_least64_t; + using std::atomic_int_fast8_t; + using std::atomic_uint_fast8_t; + using std::atomic_int_fast16_t; + using std::atomic_uint_fast16_t; + using std::atomic_int_fast32_t; + using std::atomic_uint_fast32_t; + using std::atomic_int_fast64_t; + using std::atomic_uint_fast64_t; + using std::atomic_intptr_t; + using std::atomic_uintptr_t; + using std::atomic_size_t; + using std::atomic_ssize_t; + using std::atomic_ptrdiff_t; + using std::atomic_intmax_t; + using std::atomic_uintmax_t; + + using std::atomic_address; + + &std::atomic_global_fence_compatibility; +} diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/functions.c b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/functions.c new file mode 100644 index 00000000000..1282c0df906 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/functions.c @@ -0,0 +1,38 @@ +// { dg-options "-x c" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <stdatomic.h> + +int main() +{ + volatile atomic_flag f; + volatile atomic_flag* p = &f; + memory_order m = memory_order_relaxed; + + // For position only. + atomic_flag_test_and_set(p); + atomic_flag_test_and_set_explicit(p, m); + atomic_flag_clear(p); + atomic_flag_clear_explicit(p, m); + atomic_flag_fence(p, m); + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/macros.c b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/macros.c new file mode 100644 index 00000000000..30368a06bf4 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/macros.c @@ -0,0 +1,119 @@ +// { dg-options "-x c" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <stdatomic.h> + +int main() +{ +#ifndef ATOMIC_INTEGRAL_LOCK_FREE + #error "ATOMIC_INTEGRAL_LOCK_FREE_must_be_a_macro" +#endif + +#ifndef ATOMIC_ADDRESS_LOCK_FREE + #error "ATOMIC_ADDRESS_LOCK_FREE_must_be_a_macro" +#endif + +#ifndef ATOMIC_FLAG_INIT + #error "ATOMIC_FLAG_INIT_must_be_a_macro" +#endif + +#ifndef atomic_is_lock_free + #error "atomic_is_lock_free_must_be_a_macro" +#endif + +#ifndef atomic_load + #error "atomic_load_must_be_a_macro" +#endif + +#ifndef atomic_load_explicit + #error "atomic_load_explicit_must_be_a_macro" +#endif + +#ifndef atomic_store_explicit + #error "atomic_store_explicit_must_be_a_macro" +#endif + +#ifndef atomic_store + #error "atomic_store_must_be_a_macro" +#endif + +#ifndef atomic_swap_explicit + #error "atomic_swap_explicit_must_be_a_macro" +#endif + +#ifndef atomic_swap + #error "atomic_swap_must_be_a_macro" +#endif + +#ifndef atomic_compare_swap + #error "atomic_compare_swap_must_be_a_macro" +#endif + +#ifndef atomic_compare_swap_explicit + #error "atomic_compare_swap_explicit_must_be_a_macro" +#endif + +#ifndef atomic_fence + #error "atomic_fence_must_be_a_macro" +#endif + +#ifndef atomic_fetch_add_explicit + #error "atomic_fetch_add_explicit_must_be_a_macro" +#endif + +#ifndef atomic_fetch_add + #error "atomic_fetch_add_must_be_a_macro" +#endif + +#ifndef atomic_fetch_sub_explicit + #error "atomic_fetch_sub_explicit_must_be_a_macro" +#endif + +#ifndef atomic_fetch_sub + #error "atomic_fetch_sub_must_be_a_macro" +#endif + +#ifndef atomic_fetch_and_explicit + #error "atomic_fetch_and_explicit_must_be_a_macro" +#endif + +#ifndef atomic_fetch_and + #error "atomic_fetch_and_must_be_a_macro" +#endif + +#ifndef atomic_fetch_or_explicit + #error "atomic_fetch_or_explicit_must_be_a_macro" +#endif + +#ifndef atomic_fetch_or + #error "atomic_fetch_or_must_be_a_macro" +#endif + +#ifndef atomic_fetch_xor_explicit + #error "atomic_fetch_xor_explicit_must_be_a_macro" +#endif + +#ifndef atomic_fetch_xor + #error "atomic_fetch_xor_must_be_a_macro" +#endif + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/types.c b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/types.c new file mode 100644 index 00000000000..8e9cfd56e01 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/types.c @@ -0,0 +1,80 @@ +// { dg-options "-x c" } +// { dg-do compile } + +// Copyright (C) 2008 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, +// USA. + +#include <stdatomic.h> + +void test01() +{ + typedef memory_order t_01; + memory_order t_02 = memory_order_relaxed; + memory_order t_03 = memory_order_acquire; + memory_order t_04 = memory_order_release; + memory_order t_05 = memory_order_acq_rel; + memory_order t_06 = memory_order_seq_cst; + + typedef atomic_flag t_07; + + // atomics for builtins types + typedef atomic_bool t_08; + typedef atomic_char t_09; + typedef atomic_schar t_10; + typedef atomic_uchar t_11; + typedef atomic_short t_12; + typedef atomic_ushort t_13; + typedef atomic_int t_14; + typedef atomic_uint t_15; + typedef atomic_long t_16; + typedef atomic_ulong t_17; + typedef atomic_llong t_18; + typedef atomic_ullong t_19; + typedef atomic_wchar_t t_20; + typedef atomic_char16_t t_21; + typedef atomic_char32_t t_22; + + // atomics for standard typedefs + typedef atomic_int_least8_t t_23; + typedef atomic_uint_least8_t t_24; + typedef atomic_int_least16_t t_25; + typedef atomic_uint_least16_t t_26; + typedef atomic_int_least32_t t_27; + typedef atomic_uint_least32_t t_28; + typedef atomic_int_least64_t t_29; + typedef atomic_uint_least64_t t_30; + typedef atomic_int_fast8_t t_31; + typedef atomic_uint_fast8_t t_32; + typedef atomic_int_fast16_t t_33; + typedef atomic_uint_fast16_t t_34; + typedef atomic_int_fast32_t t_35; + typedef atomic_uint_fast32_t t_36; + typedef atomic_int_fast64_t t_37; + typedef atomic_uint_fast64_t t_38; + typedef atomic_intptr_t t_39; + typedef atomic_uintptr_t t_40; + typedef atomic_size_t t_41; + typedef atomic_ssize_t t_42; + typedef atomic_ptrdiff_t t_43; + typedef atomic_intmax_t t_44; + typedef atomic_uintmax_t t_45; + + typedef atomic_address t_46; + + &atomic_global_fence_compatibility; +} diff --git a/libstdc++-v3/testsuite/Makefile.in b/libstdc++-v3/testsuite/Makefile.in index 44749597aef..63d92370dcb 100644 --- a/libstdc++-v3/testsuite/Makefile.in +++ b/libstdc++-v3/testsuite/Makefile.in @@ -49,6 +49,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../config/enable.m4 \ $(top_srcdir)/../config/lib-prefix.m4 \ $(top_srcdir)/../config/multi.m4 \ $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/proginstall.m4 \ $(top_srcdir)/../config/unwind_ipinfo.m4 \ $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \ $(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \ diff --git a/libstdc++-v3/testsuite/lib/libstdc++.exp b/libstdc++-v3/testsuite/lib/libstdc++.exp index b482bf58d20..5f68d789d6d 100644 --- a/libstdc++-v3/testsuite/lib/libstdc++.exp +++ b/libstdc++-v3/testsuite/lib/libstdc++.exp @@ -443,12 +443,13 @@ proc v3_target_compile_as_c { source dest type options } { set includestarget "${includesbase}/${machine}" set cc_final [concat $cc_final "-I$includesbase -I$includestarget"] - set libsup "${comp_base_dir}/lib" + set libdir "-L${comp_base_dir}/lib" } else { - set libsup "${blddir}/libsupc++/.libs" + set libdir "-L${blddir}/libsupc++/.libs" + set libdir [concat $libdir "-L${blddir}/src/.libs"] } - set cc_final [concat $cc_final "-L$libsup"] + set cc_final [concat $cc_final "$libdir"] lappend options "compiler=$cc_final" lappend options "timeout=600" diff --git a/libstdc++-v3/testsuite/util/testsuite_common_types.h b/libstdc++-v3/testsuite/util/testsuite_common_types.h index 78fe1fe7fca..bd9e76d4e2e 100644 --- a/libstdc++-v3/testsuite/util/testsuite_common_types.h +++ b/libstdc++-v3/testsuite/util/testsuite_common_types.h @@ -53,6 +53,10 @@ #include <tr1/unordered_map> #include <tr1/unordered_set> +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <cstdatomic> +#endif + namespace __gnu_test { using __gnu_cxx::typelist::node; @@ -260,6 +264,88 @@ namespace __gnu_test typedef typename append<a1, a2>::type type; }; + // A typelist of all integral types. + struct integral_types + { + typedef bool a1; + typedef char a2; + typedef signed char a3; + typedef unsigned char a4; + typedef short a5; + typedef unsigned short a6; + typedef int a7; + typedef unsigned int a8; + typedef long a9; + typedef unsigned long a10; + typedef long long a11; + typedef unsigned long long a12; + typedef wchar_t a13; + // typedef char16_t a14; + // typedef char16_t a15; + + typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9, + a10, a11, a12, a13)> type; + }; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename Tp> + struct atomics + { + typedef Tp value_type; + typedef std::atomic<value_type> type; + }; + + typedef transform<integral_types::type, atomics>::type atomics_tl; +#endif + + // Generator to test assignment operator. + struct assignable + { + template<typename _T> + void + operator()() + { + _T v1; + _T v2; + v1 = v2; + } + }; + + // Generator to test default constructor. + struct default_constructible + { + template<typename _T> + void + operator()() + { + _T v; + } + }; + + // Generator to test copy constructor. + struct copy_constructible + { + template<typename _T> + void + operator()() + { + _T v1; + _T v2(v1); + } + }; + + // Generator to test explicit value constructor. + struct explicit_value_constructible + { + template<typename _Ttype, typename _Tvalue> + void + operator()() + { + _Tvalue a; + _Ttype v(a); + } + }; + } // namespace __gnu_test |