The GCC 4.9 ships its own <stdatomic.h> which is not C++ compatible. The suggested solution was to include <atomic> in case C++ is used. This works at least with GCC 4.9. See also:
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60932 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60940 --- cpukit/score/include/rtems/score/atomic.h | 458 ++++-------------- cpukit/score/include/rtems/score/cpustdatomic.h | 580 ++++++++--------------- 2 files changed, 294 insertions(+), 744 deletions(-) diff --git a/cpukit/score/include/rtems/score/atomic.h b/cpukit/score/include/rtems/score/atomic.h index da5b48d..8f02901 100644 --- a/cpukit/score/include/rtems/score/atomic.h +++ b/cpukit/score/include/rtems/score/atomic.h @@ -1,10 +1,9 @@ /** - * @file rtems/score/atomic.h - * - * This include file defines the interface for all the atomic - * operations which can be used in the synchronization primitives - * or in the lock-less algorithms. You should not use these API - * in the other components directly. + * @file + * + * @ingroup ScoreAtomic + * + * @brief Atomic Operations API */ /* @@ -20,400 +19,131 @@ #include <rtems/score/cpuatomic.h> -#ifdef __cplusplus -extern "C" { -#endif - /** - * @defgroup RTEMS atomic interface + * @defgroup ScoreAtomic Atomic Operations + * + * @ingroup Score * + * @brief Support for atomic operations. + * + * All atomic operations are defined in terms of ISO/IEC 9899:2011. + * + * @{ */ -/**@{*/ +typedef CPU_atomic_Uint Atomic_Uint; -/** - * @brief atomic data initializer for static initialization. - */ -#define ATOMIC_INITIALIZER_UINT(value) CPU_ATOMIC_INITIALIZER_UINT(value) -#define ATOMIC_INITIALIZER_ULONG(value) CPU_ATOMIC_INITIALIZER_ULONG(value) -#define ATOMIC_INITIALIZER_PTR(value) CPU_ATOMIC_INITIALIZER_PTR(value) +typedef CPU_atomic_Ulong Atomic_Ulong; + +typedef CPU_atomic_Pointer Atomic_Pointer; + +typedef CPU_atomic_Flag Atomic_Flag; + +#define ATOMIC_ORDER_RELAXED CPU_ATOMIC_ORDER_RELAXED + +#define ATOMIC_ORDER_ACQUIRE CPU_ATOMIC_ORDER_ACQUIRE + +#define ATOMIC_ORDER_RELEASE CPU_ATOMIC_ORDER_RELEASE + +#define ATOMIC_ORDER_SEQ_CST CPU_ATOMIC_ORDER_SEQ_CST + +#define ATOMIC_INITIALIZER_UINT( value ) CPU_ATOMIC_INITIALIZER_UINT( value ) + +#define ATOMIC_INITIALIZER_ULONG( value ) CPU_ATOMIC_INITIALIZER_ULONG( value ) + +#define ATOMIC_INITIALIZER_PTR( value ) CPU_ATOMIC_INITIALIZER_PTR( value ) -/** - * @brief Initializes an atomic flag object to the cleared state. - */ #define ATOMIC_INITIALIZER_FLAG CPU_ATOMIC_INITIALIZER_FLAG -static inline void _Atomic_Fence( - Atomic_Order order -) -{ - _CPU_atomic_Fence( order ); -} +#define _Atomic_Fence( order ) _CPU_atomic_Fence( order ) -/** - * @brief Initializes an atomic type value into a atomic object. - * - * @param object an atomic type pointer of object. - * @param pointer a pointer to be stored into object. - */ -static inline void _Atomic_Init_uint( - volatile Atomic_Uint *object, - unsigned int value -) -{ - _CPU_atomic_Init_uint(object, value); -} +#define _Atomic_Init_uint( obj, desired ) \ + _CPU_atomic_Init_uint( obj, desired ) -static inline void _Atomic_Init_ulong( - volatile Atomic_Ulong *object, - unsigned long value -) -{ - _CPU_atomic_Init_ulong(object, value); -} +#define _Atomic_Init_ulong( obj, desired ) \ + _CPU_atomic_Init_ulong( obj, desired ) -static inline void _Atomic_Init_ptr( - volatile Atomic_Pointer *object, - void *pointer -) -{ - _CPU_atomic_Init_ptr(object, pointer); -} +#define _Atomic_Init_ptr( obj, desired ) \ + _CPU_atomic_Init_ptr( obj, desired ) -/** - * @brief Atomically load an atomic type value from atomic object. - * - * @param object an atomic type pointer of object. - * @param order a type of Atomic_Order. - * - * The order shall not be ATOMIC_ORDER_RELEASE. - */ -static inline unsigned int _Atomic_Load_uint( - volatile Atomic_Uint *object, - Atomic_Order order -) -{ - return _CPU_atomic_Load_uint( object, order ); -} +#define _Atomic_Load_uint( obj, order ) \ + _CPU_atomic_Load_uint( obj, order ) -static inline unsigned long _Atomic_Load_ulong( - volatile Atomic_Ulong *object, - Atomic_Order order -) -{ - return _CPU_atomic_Load_ulong( object, order ); -} +#define _Atomic_Load_ulong( obj, order ) \ + _CPU_atomic_Load_ulong( obj, order ) -static inline void *_Atomic_Load_ptr( - volatile Atomic_Pointer *object, - Atomic_Order order -) -{ - return _CPU_atomic_Load_ptr( object, order ); -} +#define _Atomic_Load_ptr( obj, order ) \ + _CPU_atomic_Load_ptr( obj, order ) -/** - * @brief Atomically store an atomic type value into a atomic object. - * - * @param object an atomic type pointer of object. - * @param value a value to be stored into object. - * @param order a type of Atomic_Order. - * - * The order shall not be ATOMIC_ORDER_ACQUIRE. - */ -static inline void _Atomic_Store_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - _CPU_atomic_Store_uint( object, value, order ); -} +#define _Atomic_Store_uint( obj, desr, order ) \ + _CPU_atomic_Store_uint( obj, desr, order ) -static inline void _Atomic_Store_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - _CPU_atomic_Store_ulong( object, value, order ); -} +#define _Atomic_Store_ulong( obj, desr, order ) \ + _CPU_atomic_Store_ulong( obj, desr, order ) -static inline void _Atomic_Store_ptr( - volatile Atomic_Pointer *object, - void *pointer, - Atomic_Order order -) -{ - _CPU_atomic_Store_ptr( object, pointer, order ); -} +#define _Atomic_Store_ptr( obj, desr, order ) \ + _CPU_atomic_Store_ptr( obj, desr, order ) -/** - * @brief Atomically load-add-store an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to be add and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before add ops. - */ -static inline unsigned int _Atomic_Fetch_add_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_add_uint( object, value, order ); -} +#define _Atomic_Fetch_add_uint( obj, arg, order ) \ + _CPU_atomic_Fetch_add_uint( obj, arg, order ) -static inline unsigned long _Atomic_Fetch_add_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_add_ulong( object, value, order ); -} +#define _Atomic_Fetch_add_ulong( obj, arg, order ) \ + _CPU_atomic_Fetch_add_ulong( obj, arg, order ) -static inline uintptr_t _Atomic_Fetch_add_ptr( - volatile Atomic_Pointer *object, - uintptr_t value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_add_ptr( object, value, order ); -} +#define _Atomic_Fetch_add_ptr( obj, arg, order ) \ + _CPU_atomic_Fetch_add_ptr( obj, arg, order ) -/** - * @brief Atomically load-sub-store an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to be sub and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before sub ops. - */ -static inline unsigned int _Atomic_Fetch_sub_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_sub_uint( object, value, order ); -} +#define _Atomic_Fetch_sub_uint( obj, arg, order ) \ + _CPU_atomic_Fetch_sub_uint( obj, arg, order ) -static inline unsigned long _Atomic_Fetch_sub_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_sub_ulong( object, value, order ); -} +#define _Atomic_Fetch_sub_ulong( obj, arg, order ) \ + _CPU_atomic_Fetch_sub_ulong( obj, arg, order ) -static inline uintptr_t _Atomic_Fetch_sub_ptr( - volatile Atomic_Pointer *object, - uintptr_t value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_sub_ptr( object, value, order ); -} +#define _Atomic_Fetch_sub_ptr( obj, arg, order ) \ + _CPU_atomic_Fetch_sub_ptr( obj, arg, order ) -/** - * @brief Atomically load-or-store an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to be or and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before or ops. - */ -static inline unsigned int _Atomic_Fetch_or_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_or_uint( object, value, order ); -} +#define _Atomic_Fetch_or_uint( obj, arg, order ) \ + _CPU_atomic_Fetch_or_uint( obj, arg, order ) -static inline unsigned long _Atomic_Fetch_or_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_or_ulong( object, value, order ); -} +#define _Atomic_Fetch_or_ulong( obj, arg, order ) \ + _CPU_atomic_Fetch_or_ulong( obj, arg, order ) -static inline uintptr_t _Atomic_Fetch_or_ptr( - volatile Atomic_Pointer *object, - uintptr_t value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_or_ptr( object, value, order ); -} +#define _Atomic_Fetch_or_ptr( obj, arg, order ) \ + _CPU_atomic_Fetch_or_ptr( obj, arg, order ) -/** - * @brief Atomically load-and-store an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to be and and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before and ops. - */ -static inline unsigned int _Atomic_Fetch_and_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_and_uint( object, value, order ); -} +#define _Atomic_Fetch_and_uint( obj, arg, order ) \ + _CPU_atomic_Fetch_and_uint( obj, arg, order ) -static inline unsigned long _Atomic_Fetch_and_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_and_ulong( object, value, order ); -} +#define _Atomic_Fetch_and_ulong( obj, arg, order ) \ + _CPU_atomic_Fetch_add_ulong( obj, arg, order ) -static inline uintptr_t _Atomic_Fetch_and_ptr( - volatile Atomic_Pointer *object, - uintptr_t value, - Atomic_Order order -) -{ - return _CPU_atomic_Fetch_and_ptr( object, value, order ); -} +#define _Atomic_Fetch_and_ptr( obj, arg, order ) \ + _CPU_atomic_Fetch_and_ptr( obj, arg, order ) -/** - * @brief Atomically exchange an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to exchange and and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before exchange ops. - */ -static inline unsigned int _Atomic_Exchange_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return _CPU_atomic_Exchange_uint( object, value, order ); -} +#define _Atomic_Exchange_uint( obj, desr, order ) \ + _CPU_atomic_Exchange_uint( obj, desr, order ) -static inline unsigned long _Atomic_Exchange_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return _CPU_atomic_Exchange_ulong( object, value, order ); -} +#define _Atomic_Exchange_ulong( obj, desr, order ) \ + _CPU_atomic_Fetch_add_ulong( obj, desr, order ) -static inline void *_Atomic_Exchange_ptr( - volatile Atomic_Pointer *object, - void *pointer, - Atomic_Order order -) -{ - return _CPU_atomic_Exchange_ptr( object, pointer, order ); -} +#define _Atomic_Exchange_ptr( obj, desr, order ) \ + _CPU_atomic_Exchange_ptr( obj, desr, order ) -/** - * @brief Atomically compare the value stored at object with a - * old_value and if the two values are equal, update the value of a - * address with a new_value - * - * @param object a atomic type pointer of object. - * @param old_value pointer of a value. - * @param new_value a atomic type value. - * @param order_succ a type of Atomic_Order for successful exchange. - * @param order_fail a type of Atomic_Order for failed exchange. - * - * @retval true if the compare exchange successully. - * @retval false if the compare exchange failed. - */ -static inline bool _Atomic_Compare_exchange_uint( - volatile Atomic_Uint *object, - unsigned int *old_value, - unsigned int new_value, - Atomic_Order order_succ, - Atomic_Order order_fail -) -{ - return _CPU_atomic_Compare_exchange_uint( object, old_value, new_value, - order_succ, order_fail ); -} +#define _Atomic_Compare_exchange_uint( obj, expected, desired, succ, fail ) \ + _CPU_atomic_Compare_exchange_uint( obj, expected, desired, succ, fail ) -static inline bool _Atomic_Compare_exchange_ulong( - volatile Atomic_Ulong *object, - unsigned long *old_value, - unsigned long new_value, - Atomic_Order order_succ, - Atomic_Order order_fail -) -{ - return _CPU_atomic_Compare_exchange_ulong( object, old_value, new_value, - order_succ, order_fail ); -} +#define _Atomic_Compare_exchange_ulong( obj, expected, desired, succ, fail ) \ + _CPU_atomic_Compare_exchange_ulong( obj, expected, desired, succ, fail ) -static inline bool _Atomic_Compare_exchange_ptr( - volatile Atomic_Pointer *object, - void **old_pointer, - void *new_pointer, - Atomic_Order order_succ, - Atomic_Order order_fail -) -{ - return _CPU_atomic_Compare_exchange_ptr( object, old_pointer, new_pointer, - order_succ, order_fail ); -} +#define _Atomic_Compare_exchange_ptr( obj, expected, desired, succ, fail ) \ + _CPU_atomic_Compare_exchange_ptr( obj, expected, desired, succ, fail ) -/** - * @brief Atomically clears an atomic flag. - * - * @param[in, out] object Pointer to the atomic flag object. - * @param[in] order The atomic memory order. - * - */ -static inline void _Atomic_Flag_clear( - volatile Atomic_Flag *object, - Atomic_Order order -) -{ - _CPU_atomic_Flag_clear( object, order ); -} +#define _Atomic_Flag_clear( obj, order ) \ + _CPU_atomic_Flag_clear( obj, order ) -/** - * @brief Atomically tests and sets an atomic flag. - * - * @param[in, out] object Pointer to the atomic flag object. - * @param[in] order The atomic memory order. - * - * @retval true The atomic flag was already set. - * @retval false Otherwise. - */ -static inline bool _Atomic_Flag_test_and_set( - volatile Atomic_Flag *object, - Atomic_Order order -) -{ - return _CPU_atomic_Flag_test_and_set( object, order ); -} +#define _Atomic_Flag_test_and_set( obj, order ) \ + _CPU_atomic_Flag_test_and_set( obj, order ) -#ifdef __cplusplus -} -#endif +/** @} */ -/**@}*/ -#endif -/* end of include file */ +#endif /* _RTEMS_SCORE_ATOMIC_H */ diff --git a/cpukit/score/include/rtems/score/cpustdatomic.h b/cpukit/score/include/rtems/score/cpustdatomic.h index a663a06..4d2871a 100644 --- a/cpukit/score/include/rtems/score/cpustdatomic.h +++ b/cpukit/score/include/rtems/score/cpustdatomic.h @@ -1,10 +1,7 @@ /** - * @file rtems/score/cpustdatomic.h + * @file * - * This include file defines the generic data struct and implementation - * based on stdatomic.h for all the support architectures. You should not - * include this header file directly, because it will be used by atomic.h - * which should be included by score components + * @brief Atomic Operations CPU API */ /* @@ -15,424 +12,247 @@ * http://www.rtems.org/license/LICENSE. */ -#ifndef _RTEMS_SCORE_GENERAL_STDATOMIC_CPU_H_ -#define _RTEMS_SCORE_GENERAL_STDATOMIC_CPU_H_ +#ifndef _RTEMS_SCORE_CPUSTDATOMIC_H +#define _RTEMS_SCORE_CPUSTDATOMIC_H -#include <stdatomic.h> -#include <stdbool.h> #include <stdint.h> -#ifdef __cplusplus -extern "C" { -#endif +#if defined(__cplusplus) -/** - * @defgroup RTEMS general stdatomic data type and implementation. - * - */ +#include <atomic> -/**@{*/ +typedef std::atomic_uint CPU_atomic_Uint; -/** - * @brief atomic operation unsigned integer type - */ -typedef atomic_uint Atomic_Uint; +typedef std::atomic_ulong CPU_atomic_Ulong; -/** - * @brief atomic operation unsigned long integer type - */ -typedef atomic_ulong Atomic_Ulong; +typedef std::atomic_uintptr_t CPU_atomic_Pointer; -/** - * @brief atomic operation unsigned integer the size of a pointer type - */ -typedef atomic_uintptr_t Atomic_Pointer; +typedef std::atomic_flag CPU_atomic_Flag; -/** - * @brief atomic operation flag type - */ -typedef atomic_flag Atomic_Flag; +#define CPU_ATOMIC_ORDER_RELAXED std::memory_order_relaxed -/** - * @brief Memory order according to ISO/IEC 9899:2011. - */ -typedef enum { - ATOMIC_ORDER_RELAXED = memory_order_relaxed, - ATOMIC_ORDER_ACQUIRE = memory_order_acquire, - ATOMIC_ORDER_RELEASE = memory_order_release, - ATOMIC_ORDER_SEQ_CST = memory_order_seq_cst -} Atomic_Order; +#define CPU_ATOMIC_ORDER_ACQUIRE std::memory_order_acquire +#define CPU_ATOMIC_ORDER_RELEASE std::memory_order_release -/** - * @brief atomic data initializer for static initialization. - */ -#define CPU_ATOMIC_INITIALIZER_UINT(value) ATOMIC_VAR_INIT(value) -#define CPU_ATOMIC_INITIALIZER_ULONG(value) ATOMIC_VAR_INIT(value) -#define CPU_ATOMIC_INITIALIZER_PTR(pointer) \ - ATOMIC_VAR_INIT((uintptr_t) pointer) +#define CPU_ATOMIC_ORDER_SEQ_CST std::memory_order_seq_cst + +#define CPU_ATOMIC_INITIALIZER_UINT( value ) ATOMIC_VAR_INIT( value ) + +#define CPU_ATOMIC_INITIALIZER_ULONG( value ) ATOMIC_VAR_INIT( value ) + +#define CPU_ATOMIC_INITIALIZER_PTR( value ) \ + ATOMIC_VAR_INIT( (uintptr_t) (value) ) #define CPU_ATOMIC_INITIALIZER_FLAG ATOMIC_FLAG_INIT -static inline void _CPU_atomic_Fence( - Atomic_Order order -) -{ - atomic_thread_fence( (memory_order) order ); -} +#define _CPU_atomic_Fence( order ) atomic_thread_fence( order ) -/** - * @brief Initializes an atomic type value into a atomic object. - * - * @param object an atomic type pointer of object. - * @param value a value to be stored into object. - */ -static inline void _CPU_atomic_Init_uint( - volatile Atomic_Uint *object, - unsigned int value -) -{ - atomic_init( object, value ); -} +#define _CPU_atomic_Init_uint( obj, desired ) \ + (obj)->store( desired ) -static inline void _CPU_atomic_Init_ulong( - volatile Atomic_Ulong *object, - unsigned long value -) -{ - atomic_init( object, value ); -} +#define _CPU_atomic_Init_ulong( obj, desired ) \ + (obj)->store( desired ) -static inline void _CPU_atomic_Init_ptr( - volatile Atomic_Pointer *object, - void *pointer -) -{ - atomic_init( object, (uintptr_t) pointer ); -} +#define _CPU_atomic_Init_ptr( obj, desired ) \ + (obj)->store( desired ) -/** - * @brief Atomically load an atomic type value from atomic object. - * - * @param object an atomic type pointer of object. - * @param order a type of Atomic_Order. - * - * The order shall not be ATOMIC_ORDER_RELEASE. - */ -static inline unsigned int _CPU_atomic_Load_uint( - volatile Atomic_Uint *object, - Atomic_Order order -) -{ - return atomic_load_explicit( object, (memory_order) order ); -} +#define _CPU_atomic_Load_uint( obj, order ) \ + (obj)->load( order ) -static inline unsigned long _CPU_atomic_Load_ulong( - volatile Atomic_Ulong *object, - Atomic_Order order -) -{ - return atomic_load_explicit( object, (memory_order) order ); -} +#define _CPU_atomic_Load_ulong( obj, order ) \ + (obj)->load( order ) -static inline void *_CPU_atomic_Load_ptr( - volatile Atomic_Pointer *object, - Atomic_Order order -) -{ - return (void *) atomic_load_explicit( object, (memory_order) order ); -} +#define _CPU_atomic_Load_ptr( obj, order ) \ + (void *) (obj)->load( order ) -/** - * @brief Atomically store an atomic type value into a atomic object. - * - * @param object an atomic type pointer of object. - * @param value a value to be stored into object. - * @param order a type of Atomic_Order. - * - * The order shall not be ATOMIC_ORDER_ACQUIRE. - */ -static inline void _CPU_atomic_Store_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - atomic_store_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Store_uint( obj, desr, order ) \ + (obj)->store( desr, order ) -static inline void _CPU_atomic_Store_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - atomic_store_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Store_ulong( obj, desr, order ) \ + (obj)->store( desr, order ) -static inline void _CPU_atomic_Store_ptr( - volatile Atomic_Pointer *object, - void *pointer, - Atomic_Order order -) -{ - atomic_store_explicit( object, pointer, (memory_order) order ); -} +#define _CPU_atomic_Store_ptr( obj, desr, order ) \ + (obj)->store( (uintptr_t) desr, order ) -/** - * @brief Atomically load-add-store an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to be add and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before add ops. - */ -static inline unsigned int _CPU_atomic_Fetch_add_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return atomic_fetch_add_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_add_uint( obj, arg, order ) \ + (obj)->fetch_add( arg, order ) -static inline unsigned long _CPU_atomic_Fetch_add_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return atomic_fetch_add_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_add_ulong( obj, arg, order ) \ + (obj)->fetch_add( arg, order ) -static inline uintptr_t _CPU_atomic_Fetch_add_ptr( - volatile Atomic_Pointer *object, - uintptr_t value, - Atomic_Order order -) -{ - return atomic_fetch_add_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_add_ptr( obj, arg, order ) \ + (obj)->fetch_add( arg, (uintptr_t) order ) -/** - * @brief Atomically load-sub-store an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to be sub and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before sub ops. - */ -static inline unsigned int _CPU_atomic_Fetch_sub_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return atomic_fetch_sub_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_sub_uint( obj, arg, order ) \ + (obj)->fetch_sub( arg, order ) -static inline unsigned long _CPU_atomic_Fetch_sub_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return atomic_fetch_sub_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_sub_ulong( obj, arg, order ) \ + (obj)->fetch_sub( arg, order ) -static inline uintptr_t _CPU_atomic_Fetch_sub_ptr( - volatile Atomic_Pointer *object, - uintptr_t value, - Atomic_Order order -) -{ - return atomic_fetch_sub_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_sub_ptr( obj, arg, order ) \ + (obj)->fetch_sub( arg, (uintptr_t) order ) -/** - * @brief Atomically load-or-store an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to be or and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before or ops. - */ -static inline unsigned int _CPU_atomic_Fetch_or_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return atomic_fetch_or_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_or_uint( obj, arg, order ) \ + (obj)->fetch_or( arg, order ) -static inline unsigned long _CPU_atomic_Fetch_or_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return atomic_fetch_or_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_or_ulong( obj, arg, order ) \ + (obj)->fetch_or( arg, order ) -static inline uintptr_t _CPU_atomic_Fetch_or_ptr( - volatile Atomic_Pointer *object, - uintptr_t value, - Atomic_Order order -) -{ - return atomic_fetch_or_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_or_ptr( obj, arg, order ) \ + (obj)->fetch_or( arg, (uintptr_t) order ) -/** - * @brief Atomically load-and-store an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to be and and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before and ops. - */ -static inline unsigned int _CPU_atomic_Fetch_and_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return atomic_fetch_and_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_and_uint( obj, arg, order ) \ + (obj)->fetch_and( arg, order ) -static inline unsigned long _CPU_atomic_Fetch_and_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return atomic_fetch_and_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_and_ulong( obj, arg, order ) \ + (obj)->fetch_and( arg, order ) -static inline uintptr_t _CPU_atomic_Fetch_and_ptr( - volatile Atomic_Pointer *object, - uintptr_t value, - Atomic_Order order -) -{ - return atomic_fetch_and_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Fetch_and_ptr( obj, arg, order ) \ + (obj)->fetch_and( arg, (uintptr_t) order ) -/** - * @brief Atomically exchange an atomic type value into object - * - * @param object a atomic type pointer of object. - * @param value a value to exchange and and store into object. - * @param order a type of Atomic_Order. - * - * @retval a result value before exchange ops. - */ -static inline unsigned int _CPU_atomic_Exchange_uint( - volatile Atomic_Uint *object, - unsigned int value, - Atomic_Order order -) -{ - return atomic_exchange_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Exchange_uint( obj, desr, order ) \ + (obj)->exchange( desr, order ) -static inline unsigned long _CPU_atomic_Exchange_ulong( - volatile Atomic_Ulong *object, - unsigned long value, - Atomic_Order order -) -{ - return atomic_exchange_explicit( object, value, (memory_order) order ); -} +#define _CPU_atomic_Exchange_ulong( obj, desr, order ) \ + (obj)->exchange( desr, order ) -static inline void *_CPU_atomic_Exchange_ptr( - volatile Atomic_Pointer *object, - void *pointer, - Atomic_Order order -) -{ - return (void *) atomic_exchange_explicit( - object, - (uintptr_t) pointer, - (memory_order) order - ); -} +#define _CPU_atomic_Exchange_ptr( obj, desr, order ) \ + (void *) (obj)->exchange( desr, (uintptr_t) order ) -/** - * @brief Atomically compare the value stored at object with a - * old_value and if the two values are equal, update the value of a - * address with a new_value - * - * @param object a atomic type pointer of object. - * @param old_value pointer of a value. - * @param new_value a atomic type value. - * @param order_succ a type of Atomic_Order for successful exchange. - * @param order_fail a type of Atomic_Order for failed exchange. - * - * @retval true if the compare exchange successully. - * @retval false if the compare exchange failed. - */ -static inline bool _CPU_atomic_Compare_exchange_uint( - volatile Atomic_Uint *object, - unsigned int *old_value, - unsigned int new_value, - Atomic_Order order_succ, - Atomic_Order order_fail -) -{ - return atomic_compare_exchange_strong_explicit( object, old_value, - new_value, order_succ, order_fail ); -} +#define _CPU_atomic_Compare_exchange_uint( obj, expected, desired, succ, fail ) \ + (obj)->compare_exchange_strong( expected, desired, succ, fail ) + +#define _CPU_atomic_Compare_exchange_ulong( obj, expected, desired, succ, fail ) \ + (obj)->compare_exchange_strong( expected, desired, succ, fail ) + +#define _CPU_atomic_Compare_exchange_ptr( obj, expected, desired, succ, fail ) \ + (obj)->compare_exchange_strong( (void **) expected, (uintptr_t) desired, succ, fail ) + +#define _CPU_atomic_Flag_clear( obj, order ) \ + (obj)->clear( order ) + +#define _CPU_atomic_Flag_test_and_set( obj, order ) \ + (obj)->test_and_set( order ) + +#else /* __cplusplus */ + +#include <stdatomic.h> + +typedef atomic_uint CPU_atomic_Uint; + +typedef atomic_ulong CPU_atomic_Ulong; + +typedef atomic_uintptr_t CPU_atomic_Pointer; + +typedef atomic_flag CPU_atomic_Flag; + +#define CPU_ATOMIC_ORDER_RELAXED memory_order_relaxed + +#define CPU_ATOMIC_ORDER_ACQUIRE memory_order_acquire + +#define CPU_ATOMIC_ORDER_RELEASE memory_order_release + +#define CPU_ATOMIC_ORDER_SEQ_CST memory_order_seq_cst + +#define CPU_ATOMIC_INITIALIZER_UINT( value ) ATOMIC_VAR_INIT( value ) + +#define CPU_ATOMIC_INITIALIZER_ULONG( value ) ATOMIC_VAR_INIT( value ) + +#define CPU_ATOMIC_INITIALIZER_PTR( value ) \ + ATOMIC_VAR_INIT( (uintptr_t) (value) ) + +#define CPU_ATOMIC_INITIALIZER_FLAG ATOMIC_FLAG_INIT + +#define _CPU_atomic_Fence( order ) atomic_thread_fence( order ) + +#define _CPU_atomic_Init_uint( obj, desired ) \ + atomic_init( obj, desired ) + +#define _CPU_atomic_Init_ulong( obj, desired ) \ + atomic_init( obj, desired ) + +#define _CPU_atomic_Init_ptr( obj, desired ) \ + atomic_init( obj, (uintptr_t) desired ) + +#define _CPU_atomic_Load_uint( obj, order ) \ + atomic_load_explicit( obj, order ) + +#define _CPU_atomic_Load_ulong( obj, order ) \ + atomic_load_explicit( obj, order ) + +#define _CPU_atomic_Load_ptr( obj, order ) \ + (void *) atomic_load_explicit( obj, order ) + +#define _CPU_atomic_Store_uint( obj, desr, order ) \ + atomic_store_explicit( obj, desr, order ) + +#define _CPU_atomic_Store_ulong( obj, desr, order ) \ + atomic_store_explicit( obj, desr, order ) + +#define _CPU_atomic_Store_ptr( obj, desr, order ) \ + atomic_store_explicit( obj, desr, order ) + +#define _CPU_atomic_Fetch_add_uint( obj, arg, order ) \ + atomic_fetch_add_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_add_ulong( obj, arg, order ) \ + atomic_fetch_add_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_add_ptr( obj, arg, order ) \ + atomic_fetch_add_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_sub_uint( obj, arg, order ) \ + atomic_fetch_sub_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_sub_ulong( obj, arg, order ) \ + atomic_fetch_sub_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_sub_ptr( obj, arg, order ) \ + atomic_fetch_sub_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_or_uint( obj, arg, order ) \ + atomic_fetch_or_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_or_ulong( obj, arg, order ) \ + atomic_fetch_or_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_or_ptr( obj, arg, order ) \ + atomic_fetch_or_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_and_uint( obj, arg, order ) \ + atomic_fetch_and_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_and_ulong( obj, arg, order ) \ + atomic_fetch_and_explicit( obj, arg, order ) + +#define _CPU_atomic_Fetch_and_ptr( obj, arg, order ) \ + atomic_fetch_and_explicit( obj, arg, order ) + +#define _CPU_atomic_Exchange_uint( obj, desr, order ) \ + atomic_exchange_explicit( obj, desr, order ) + +#define _CPU_atomic_Exchange_ulong( obj, desr, order ) \ + atomic_exchange_explicit( obj, desr, order ) + +#define _CPU_atomic_Exchange_ptr( obj, desr, order ) \ + atomic_exchange_explicit( obj, desr, order ) + +#define _CPU_atomic_Compare_exchange_uint( obj, expected, desired, succ, fail ) \ + atomic_compare_exchange_strong_explicit( obj, expected, desired, succ, fail ) -static inline bool _CPU_atomic_Compare_exchange_ulong( - volatile Atomic_Ulong *object, - unsigned long *old_value, - unsigned long new_value, - Atomic_Order order_succ, - Atomic_Order order_fail -) -{ - return atomic_compare_exchange_strong_explicit( object, old_value, - new_value, order_succ, order_fail ); -} +#define _CPU_atomic_Compare_exchange_ulong( obj, expected, desired, succ, fail ) \ + atomic_compare_exchange_strong_explicit( obj, expected, desired, succ, fail ) -static inline bool _CPU_atomic_Compare_exchange_ptr( - volatile Atomic_Pointer *object, - void **old_pointer, - void *new_pointer, - Atomic_Order order_succ, - Atomic_Order order_fail -) -{ - return atomic_compare_exchange_strong_explicit( object, old_pointer, - new_pointer, order_succ, order_fail ); -} +#define _CPU_atomic_Compare_exchange_ptr( obj, expected, desired, succ, fail ) \ + atomic_compare_exchange_strong_explicit( obj, expected, desired, succ, fail ) -static inline void _CPU_atomic_Flag_clear( - volatile Atomic_Flag *object, - Atomic_Order order -) -{ - return atomic_flag_clear_explicit( object, (memory_order) order ); -} +#define _CPU_atomic_Flag_clear( obj, order ) \ + atomic_flag_clear_explicit( obj, order ) -static inline bool _CPU_atomic_Flag_test_and_set( - volatile Atomic_Flag *object, - Atomic_Order order -) -{ - return atomic_flag_test_and_set_explicit( object, (memory_order) order ); -} +#define _CPU_atomic_Flag_test_and_set( obj, order ) \ + atomic_flag_test_and_set_explicit( obj, order ) -#ifdef __cplusplus -} -#endif +#endif /* __cplusplus */ -/**@}*/ -#endif -/* end of include file */ +#endif /* _RTEMS_SCORE_CPUSTDATOMIC_H */ -- 1.7.7 _______________________________________________ devel mailing list devel@rtems.org http://lists.rtems.org/mailman/listinfo/devel
