d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a4b20c5eba
freebsd-dev/include/stdatomic.h

341 lines
12 KiB
C
Raw Normal View History

Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
/*-
* Copyright (c) 2011 Ed Schouten <ed@FreeBSD.org>
* David Chisnall <theraven@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#ifndef _STDATOMIC_H_
#define _STDATOMIC_H_
#include <sys/cdefs.h>
#include <sys/_types.h>
Properly enable Clang-style atomics when available. In addition to testing against cxx_atomic, we must check c_atomic. The former is only set when building C++ code. Also use __has_extension instead of __has_feature. This allows us to use the atomics outside of C11. Reported by: Ariane van der Steldt <ariane stack nl> PR: threads/170073
2012-08-31 22:22:14 +00:00
#if __has_extension(c_atomic) || __has_extension(cxx_atomic)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define __CLANG_ATOMICS
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#elif __GNUC_PREREQ__(4, 7)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define __GNUC_ATOMICS
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#elif !defined(__GNUC__)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#error "stdatomic.h does not support your compiler"
#endif
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#if !defined(__CLANG_ATOMICS)
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define _Atomic(T) struct { volatile T __val; }
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
/*
* 7.17.2 Initialization.
*/
#if defined(__CLANG_ATOMICS)
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define ATOMIC_VAR_INIT(value) (value)
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
#define atomic_init(obj, value) __c11_atomic_init(obj, value)
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#else
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define ATOMIC_VAR_INIT(value) { .__val = (value) }
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
#define atomic_init(obj, value) ((void)((obj)->__val = (value)))
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
/*
* Clang and recent GCC both provide predefined macros for the memory
* orderings. If we are using a compiler that doesn't define them, use the
* clang values - these will be ignored in the fallback path.
*/
#ifndef __ATOMIC_RELAXED
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define __ATOMIC_RELAXED 0
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
#ifndef __ATOMIC_CONSUME
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define __ATOMIC_CONSUME 1
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
#ifndef __ATOMIC_ACQUIRE
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define __ATOMIC_ACQUIRE 2
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
#ifndef __ATOMIC_RELEASE
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define __ATOMIC_RELEASE 3
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
#ifndef __ATOMIC_ACQ_REL
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define __ATOMIC_ACQ_REL 4
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
#ifndef __ATOMIC_SEQ_CST
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define __ATOMIC_SEQ_CST 5
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
/*
* 7.17.3 Order and consistency.
*
* The memory_order_* constants that denote the barrier behaviour of the
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
* atomic operations.
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
*/
enum memory_order {
memory_order_relaxed = __ATOMIC_RELAXED,
memory_order_consume = __ATOMIC_CONSUME,
memory_order_acquire = __ATOMIC_ACQUIRE,
memory_order_release = __ATOMIC_RELEASE,
memory_order_acq_rel = __ATOMIC_ACQ_REL,
memory_order_seq_cst = __ATOMIC_SEQ_CST
};
/*
* 7.17.4 Fences.
*/
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
#ifdef __CLANG_ATOMICS
#define atomic_thread_fence(order) __c11_atomic_thread_fence(order)
#define atomic_signal_fence(order) __c11_atomic_signal_fence(order)
#elif defined(__GNUC_ATOMICS)
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#define atomic_thread_fence(order) __atomic_thread_fence(order)
#define atomic_signal_fence(order) __atomic_signal_fence(order)
#else
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
#define atomic_thread_fence(order) ((void)(order), __sync_synchronize())
#define atomic_signal_fence(order) __extension__ ({ \
(void)(order); \
__asm volatile ("" ::: "memory"); \
(void)0; \
})
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#endif
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
/*
* 7.17.5 Lock-free property.
*/
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
#if defined(__CLANG_ATOMICS) || defined(__GNUC_ATOMICS)
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#define atomic_is_lock_free(obj) \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
__atomic_is_lock_free(sizeof((obj)->__val), &(obj)->val)
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#else
#define atomic_is_lock_free(obj) \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
((void)(obj), sizeof((obj)->__val) <= sizeof(void *))
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
/*
* 7.17.6 Atomic integer types.
*/
typedef _Atomic(_Bool) atomic_bool;
typedef _Atomic(char) atomic_char;
typedef _Atomic(signed char) atomic_schar;
typedef _Atomic(unsigned char) atomic_uchar;
typedef _Atomic(short) atomic_short;
typedef _Atomic(unsigned short) atomic_ushort;
typedef _Atomic(int) atomic_int;
typedef _Atomic(unsigned int) atomic_uint;
typedef _Atomic(long) atomic_long;
typedef _Atomic(unsigned long) atomic_ulong;
typedef _Atomic(long long) atomic_llong;
typedef _Atomic(unsigned long long) atomic_ullong;
#if 0
typedef _Atomic(__char16_t) atomic_char16_t;
typedef _Atomic(__char32_t) atomic_char32_t;
#endif
typedef _Atomic(__wchar_t) atomic_wchar_t;
typedef _Atomic(__int_least8_t) atomic_int_least8_t;
typedef _Atomic(__uint_least8_t) atomic_uint_least8_t;
typedef _Atomic(__int_least16_t) atomic_int_least16_t;
typedef _Atomic(__uint_least16_t) atomic_uint_least16_t;
typedef _Atomic(__int_least32_t) atomic_int_least32_t;
typedef _Atomic(__uint_least32_t) atomic_uint_least32_t;
typedef _Atomic(__int_least64_t) atomic_int_least64_t;
typedef _Atomic(__uint_least64_t) atomic_uint_least64_t;
typedef _Atomic(__int_fast8_t) atomic_int_fast8_t;
typedef _Atomic(__uint_fast8_t) atomic_uint_fast8_t;
typedef _Atomic(__int_fast16_t) atomic_int_fast16_t;
typedef _Atomic(__uint_fast16_t) atomic_uint_fast16_t;
typedef _Atomic(__int_fast32_t) atomic_int_fast32_t;
typedef _Atomic(__uint_fast32_t) atomic_uint_fast32_t;
typedef _Atomic(__int_fast64_t) atomic_int_fast64_t;
typedef _Atomic(__uint_fast64_t) atomic_uint_fast64_t;
typedef _Atomic(__intptr_t) atomic_intptr_t;
typedef _Atomic(__uintptr_t) atomic_uintptr_t;
typedef _Atomic(__size_t) atomic_size_t;
typedef _Atomic(__ptrdiff_t) atomic_ptrdiff_t;
typedef _Atomic(__intmax_t) atomic_intmax_t;
typedef _Atomic(__uintmax_t) atomic_uintmax_t;
/*
* 7.17.7 Operations on atomic types.
*/
/*
* Compiler-specific operations.
*/
#if defined(__CLANG_ATOMICS)
#define atomic_compare_exchange_strong_explicit(object, expected, \
desired, success, failure) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_compare_exchange_strong(object, expected, desired, \
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
success, failure)
#define atomic_compare_exchange_weak_explicit(object, expected, \
desired, success, failure) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_compare_exchange_weak(object, expected, desired, \
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
success, failure)
#define atomic_exchange_explicit(object, desired, order) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_exchange(object, desired, order)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_fetch_add_explicit(object, operand, order) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_fetch_add(object, operand, order)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_fetch_and_explicit(object, operand, order) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_fetch_and(object, operand, order)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_fetch_or_explicit(object, operand, order) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_fetch_or(object, operand, order)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_fetch_sub_explicit(object, operand, order) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_fetch_sub(object, operand, order)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_fetch_xor_explicit(object, operand, order) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_fetch_xor(object, operand, order)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_load_explicit(object, order) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_load(object, order)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_store_explicit(object, desired, order) \
Fix <stdatomic.h> after clang decided to rename all of its builtins to include a c11 prefix to disambiguate them from the one provided by GCC. Note: Clang 3.1 also supports the GCC builtins for libstdc++ 4.7 compatibility, but I don't recommend using them because they are very poorly designed. MFC after: 2 weeks
2012-05-03 15:54:06 +00:00
__c11_atomic_store(object, desired, order)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#elif defined(__GNUC_ATOMICS)
Extend <stdatomic.h> to support GCC 4.7's __atomic. The development version of GCC also supports an atomics interface similar to Clang's. Change the header file to work as follows: - __CLANG_ATOMICS: Use Clang's new atomics interface, - __GNUC_ATOMICS: Use GCC's new atomics interface, - else: fall back to GCC's __sync interface.
2011-12-30 01:37:25 +00:00
#define atomic_compare_exchange_strong_explicit(object, expected, \
desired, success, failure) \
__atomic_compare_exchange_n(&(object)->__val, expected, \
desired, 0, success, failure)
#define atomic_compare_exchange_weak_explicit(object, expected, \
desired, success, failure) \
__atomic_compare_exchange_n(&(object)->__val, expected, \
desired, 1, success, failure)
#define atomic_exchange_explicit(object, desired, order) \
__atomic_exchange_n(&(object)->__val, desired, order)
#define atomic_fetch_add_explicit(object, operand, order) \
__atomic_fetch_add(&(object)->__val, operand, order)
#define atomic_fetch_and_explicit(object, operand, order) \
__atomic_fetch_and(&(object)->__val, operand, order)
#define atomic_fetch_or_explicit(object, operand, order) \
__atomic_fetch_or(&(object)->__val, operand, order)
#define atomic_fetch_sub_explicit(object, operand, order) \
__atomic_fetch_sub(&(object)->__val, operand, order)
#define atomic_fetch_xor_explicit(object, operand, order) \
__atomic_fetch_xor(&(object)->__val, operand, order)
#define atomic_load_explicit(object, order) \
__atomic_load_n(&(object)->__val, order)
#define atomic_store_explicit(object, desired, order) \
__atomic_store_n(&(object)->__val, desired, order)
#else
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_compare_exchange_strong_explicit(object, expected, \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
desired, success, failure) __extension__ ({ \
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
__typeof__((object)->__val) __v; \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
__typeof__(expected) __e; \
Fix some bugs in <stdatomic.h>. - Make atomic_init() work for GCC, as assigning to structs doesn't work. - Fix misplaced parenthesis in atomic_is_lock_free() for GCC. - Make atomic_compare_exchange_strong() for GCC return the proper boolean value, whether object == expected. - Fix argument passing in atomic_exchange_explicit() for GCC.
2011-12-26 23:33:41 +00:00
_Bool __r; \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
__e = (expected); \
(void)(success); \
(void)(failure); \
Fix some bugs in <stdatomic.h>. - Make atomic_init() work for GCC, as assigning to structs doesn't work. - Fix misplaced parenthesis in atomic_is_lock_free() for GCC. - Make atomic_compare_exchange_strong() for GCC return the proper boolean value, whether object == expected. - Fix argument passing in atomic_exchange_explicit() for GCC.
2011-12-26 23:33:41 +00:00
__v = __sync_val_compare_and_swap(&(object)->__val, \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
*__e, (desired)); \
__r = (*__e == __v); \
*__e = __v; \
Fix some bugs in <stdatomic.h>. - Make atomic_init() work for GCC, as assigning to structs doesn't work. - Fix misplaced parenthesis in atomic_is_lock_free() for GCC. - Make atomic_compare_exchange_strong() for GCC return the proper boolean value, whether object == expected. - Fix argument passing in atomic_exchange_explicit() for GCC.
2011-12-26 23:33:41 +00:00
__r; \
})
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_compare_exchange_weak_explicit(object, expected, \
desired, success, failure) \
atomic_compare_exchange_strong_explicit(object, expected, \
desired, success, failure)
#if __has_builtin(__sync_swap)
/* Clang provides a full-barrier atomic exchange - use it if available. */
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
#define atomic_exchange_explicit(object, desired, order) \
((void)(order), __sync_swap(&(object)->__val, desired))
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#else
/*
* __sync_lock_test_and_set() is only an acquire barrier in theory (although in
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
* practice it is usually a full barrier) so we need an explicit barrier before
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
* it.
*/
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
#define atomic_exchange_explicit(object, desired, order) \
__extension__ ({ \
__typeof__(object) __o = (object); \
__typeof__(desired) __d = (desired); \
(void)(order); \
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
__sync_synchronize(); \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
__sync_lock_test_and_set(&(__o)->__val, __d); \
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
})
#endif
#define atomic_fetch_add_explicit(object, operand, order) \
__sync_fetch_and_add(&(object)->__val, operand)
#define atomic_fetch_and_explicit(object, operand, order) \
__sync_fetch_and_and(&(object)->__val, operand)
#define atomic_fetch_or_explicit(object, operand, order) \
__sync_fetch_and_or(&(object)->__val, operand)
#define atomic_fetch_sub_explicit(object, operand, order) \
__sync_fetch_and_sub(&(object)->__val, operand)
#define atomic_fetch_xor_explicit(object, operand, order) \
__sync_fetch_and_xor(&(object)->__val, operand)
#define atomic_load_explicit(object, order) \
__sync_fetch_and_add(&(object)->__val, 0)
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
#define atomic_store_explicit(object, desired, order) __extension__ ({ \
__typeof__(object) __o = (object); \
__typeof__(desired) __d = (desired); \
(void)(order); \
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
__sync_synchronize(); \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
__o->__val = __d; \
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
__sync_synchronize(); \
- Make C11 atomic macros usable in expressions: - Replace do-while statements with void expressions. - Wrap __asm statements in statement expressions. - Make the macros function-like: - Evaluate all arguments exactly once. - Make sure there's a sequence point between evaluation of the arguments and the function body. Arguments should be evaluated before any memory barriers. - Fix use of __atomic_is_lock_free built-in. It requires the address of an atomic variable as second argument. Use this built-in on clang as well because clang's __c11_atomic_is_lock_free only takes the size of the variable into account. - In atomic_exchange_explicit put the barrier before instead of after the __sync_lock_test_and_set call. Reviewed by: theraven
2012-09-26 19:49:22 +00:00
})
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif
/*
* Convenience functions.
*/
#define atomic_compare_exchange_strong(object, expected, desired) \
atomic_compare_exchange_strong_explicit(object, expected, \
desired, memory_order_seq_cst, memory_order_seq_cst)
#define atomic_compare_exchange_weak(object, expected, desired) \
atomic_compare_exchange_weak_explicit(object, expected, \
desired, memory_order_seq_cst, memory_order_seq_cst)
#define atomic_exchange(object, desired) \
atomic_exchange_explicit(object, desired, memory_order_seq_cst)
#define atomic_fetch_add(object, operand) \
atomic_fetch_add_explicit(object, operand, memory_order_seq_cst)
#define atomic_fetch_and(object, operand) \
atomic_fetch_and_explicit(object, operand, memory_order_seq_cst)
#define atomic_fetch_or(object, operand) \
atomic_fetch_or_explicit(object, operand, memory_order_seq_cst)
#define atomic_fetch_sub(object, operand) \
atomic_fetch_sub_explicit(object, operand, memory_order_seq_cst)
#define atomic_fetch_xor(object, operand) \
atomic_fetch_xor_explicit(object, operand, memory_order_seq_cst)
#define atomic_load(object) \
atomic_load_explicit(object, memory_order_seq_cst)
#define atomic_store(object, desired) \
atomic_store_explicit(object, desired, memory_order_seq_cst)
/*
* 7.17.8 Atomic flag type and operations.
*/
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
typedef atomic_bool atomic_flag;
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
Make white space in this file a bit more consistent. Remove trailing whitespace and place all macro definitions at the same column.
2011-12-25 21:05:35 +00:00
#define ATOMIC_FLAG_INIT ATOMIC_VAR_INIT(0)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_flag_clear_explicit(object, order) \
atomic_store_explicit(object, 0, order)
#define atomic_flag_test_and_set_explicit(object, order) \
atomic_compare_exchange_strong_explicit(object, 0, 1, order, order)
#define atomic_flag_clear(object) \
Correct mistake in atomic_flag macros. The _explicit versions only have two parameters, namely the object and the order. There is no need to pass the values of the atomic variable.
2012-01-13 16:01:34 +00:00
atomic_flag_clear_explicit(object, memory_order_seq_cst)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#define atomic_flag_test_and_set(object) \
Correct mistake in atomic_flag macros. The _explicit versions only have two parameters, namely the object and the order. There is no need to pass the values of the atomic variable.
2012-01-13 16:01:34 +00:00
atomic_flag_test_and_set_explicit(object, memory_order_seq_cst)
Initial implementation of stdatomic.h. Works (at least in the parts that were tested) with clang and gcc, and more efficiently with clang+a big out-of-tree diff that I need to commit soon (once it's been tidied and reviewed a bit). Large portions by: ed Reviewed by: ed Approved by: dim (mentor)
2011-12-24 15:17:01 +00:00
#endif /* !_STDATOMIC_H_ */
Reference in New Issue Copy Permalink