388 lines
11 KiB
C++
388 lines
11 KiB
C++
// -*- 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
|