4101 lines
118 KiB
C++
4101 lines
118 KiB
C++
// -*- 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
|
|
|
|
|