libc/include/stdatomic.h - platform/bionic - Git at Google


            
            /*-

            
             * Copyright (c) 2011 Ed Schouten <ed@FreeBSD.org>

            
             *                    David Chisnall <theraven@FreeBSD.org>

            
             * All rights reserved.

            
             *

            
             * Redistribution and use in source and binary forms, with or without

            
             * modification, are permitted provided that the following conditions

            
             * are met:

            
             * 1. Redistributions of source code must retain the above copyright

            
             *    notice, this list of conditions and the following disclaimer.

            
             * 2. Redistributions in binary form must reproduce the above copyright

            
             *    notice, this list of conditions and the following disclaimer in the

            
             *    documentation and/or other materials provided with the distribution.

            
             *

            
             * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

            
             * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

            
             * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

            
             * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

            
             * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

            
             * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

            
             * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

            
             * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

            
             * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

            
             * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

            
             * SUCH DAMAGE.

            
             *

            
             * $FreeBSD$

            
             */


            #ifndef _STDATOMIC_H_

            
            #define	_STDATOMIC_H_


            #include <sys/cdefs.h>


            #if defined(__cplusplus) && __cplusplus >= 201103L && __has_include(<atomic>)

            
            # if __has_feature(cxx_atomic)

            
            #  define _STDATOMIC_HAVE_ATOMIC

            
            # endif

            
            #endif


            #ifdef _STDATOMIC_HAVE_ATOMIC


            /* We have a usable C++ <atomic>; use it instead.  */


            #include <atomic>


            #undef _Atomic

            
                    /* Also defined by <atomic> for gcc.  But not used in macros. */

            
                    /* Also a clang intrinsic.                                    */

            
                    /* Should not be used by client code before this file is      */

            
                    /* included.  The definitions in <atomic> themselves see      */

            
                    /* the old definition, as they should.                        */

            
                    /* Client code sees the following definition.                 */


            #define _Atomic(t) std::atomic<t>


            using std::atomic_is_lock_free;

            
            using std::atomic_init;

            
            using std::atomic_store;

            
            using std::atomic_store_explicit;

            
            using std::atomic_load;

            
            using std::atomic_load_explicit;

            
            using std::atomic_exchange;

            
            using std::atomic_exchange_explicit;

            
            using std::atomic_compare_exchange_strong;

            
            using std::atomic_compare_exchange_strong_explicit;

            
            using std::atomic_compare_exchange_weak;

            
            using std::atomic_compare_exchange_weak_explicit;

            
            using std::atomic_fetch_add;

            
            using std::atomic_fetch_add_explicit;

            
            using std::atomic_fetch_sub;

            
            using std::atomic_fetch_sub_explicit;

            
            using std::atomic_fetch_or;

            
            using std::atomic_fetch_or_explicit;

            
            using std::atomic_fetch_xor;

            
            using std::atomic_fetch_xor_explicit;

            
            using std::atomic_fetch_and;

            
            using std::atomic_fetch_and_explicit;

            
            using std::atomic_thread_fence;

            
            using std::atomic_signal_fence;


            using std::memory_order;

            
            using std::memory_order_relaxed;

            
            using std::memory_order_consume;

            
            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_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_char16_t;

            
            using std::atomic_char32_t;

            
            using std::atomic_wchar_t;

            
            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_ptrdiff_t;

            
            using std::atomic_intmax_t;

            
            using std::atomic_uintmax_t;


            #else /* <atomic> unavailable, possibly because this is C, not C++ */


            /* Actual implementation is in bits/stdatomic.h since our test code is C++. */

            
            #include <bits/stdatomic.h>


            #endif /* <atomic> unavailable */


            #endif /* !_STDATOMIC_H_ */
	/*-
	* Copyright (c) 2011 Ed Schouten <ed@FreeBSD.org>
	* David Chisnall <theraven@FreeBSD.org>
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	*
	* $FreeBSD$
	*/

	#ifndef _STDATOMIC_H_
	#define _STDATOMIC_H_

	#include <sys/cdefs.h>

	#if defined(__cplusplus) && __cplusplus >= 201103L && __has_include(<atomic>)
	# if __has_feature(cxx_atomic)
	# define _STDATOMIC_HAVE_ATOMIC
	# endif
	#endif

	#ifdef _STDATOMIC_HAVE_ATOMIC

	/* We have a usable C++ <atomic>; use it instead. */

	#include <atomic>

	#undef _Atomic
	/* Also defined by <atomic> for gcc. But not used in macros. */
	/* Also a clang intrinsic. */
	/* Should not be used by client code before this file is */
	/* included. The definitions in <atomic> themselves see */
	/* the old definition, as they should. */
	/* Client code sees the following definition. */

	#define _Atomic(t) std::atomic<t>

	using std::atomic_is_lock_free;
	using std::atomic_init;
	using std::atomic_store;
	using std::atomic_store_explicit;
	using std::atomic_load;
	using std::atomic_load_explicit;
	using std::atomic_exchange;
	using std::atomic_exchange_explicit;
	using std::atomic_compare_exchange_strong;
	using std::atomic_compare_exchange_strong_explicit;
	using std::atomic_compare_exchange_weak;
	using std::atomic_compare_exchange_weak_explicit;
	using std::atomic_fetch_add;
	using std::atomic_fetch_add_explicit;
	using std::atomic_fetch_sub;
	using std::atomic_fetch_sub_explicit;
	using std::atomic_fetch_or;
	using std::atomic_fetch_or_explicit;
	using std::atomic_fetch_xor;
	using std::atomic_fetch_xor_explicit;
	using std::atomic_fetch_and;
	using std::atomic_fetch_and_explicit;
	using std::atomic_thread_fence;
	using std::atomic_signal_fence;

	using std::memory_order;
	using std::memory_order_relaxed;
	using std::memory_order_consume;
	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_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_char16_t;
	using std::atomic_char32_t;
	using std::atomic_wchar_t;
	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_ptrdiff_t;
	using std::atomic_intmax_t;
	using std::atomic_uintmax_t;

	#else /* <atomic> unavailable, possibly because this is C, not C++ */

	/* Actual implementation is in bits/stdatomic.h since our test code is C++. */
	#include <bits/stdatomic.h>

	#endif /* <atomic> unavailable */

	#endif /* !_STDATOMIC_H_ */