/stdatomic.h
Last active Apr 23, 2019
A portable version of stdatomic.h extracted from the FreeBSD libc, for Clang 3.1+ and GCC 4.7+.
| /* | |
| * An implementation of C11 stdatomic.h directly borrowed from FreeBSD | |
| * (original copyright follows), with minor modifications for | |
| * portability to other systems. Works for recent Clang (that | |
| * implement the feature c_atomic) and GCC 4.7+; includes | |
| * compatibility for GCC below 4.7 but I wouldn't recommend it. | |
| * | |
| * Caveats and limitations: | |
| * - Only the ``_Atomic parentheses'' notation is implemented, while | |
| * the ``_Atomic space'' one is not. | |
| * - _Atomic types must be typedef'ed, or programs using them will | |
| * not type check correctly (incompatible anonymous structure | |
| * types). | |
| * - Non-scalar _Atomic types would require runtime support for | |
| * runtime locking, which, as far as I know, is not currently | |
| * available on any system. | |
| */ | |
| /*- | |
| * 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: src/include/stdatomic.h,v 1.10.2.2 2012/05/30 19:21:54 theraven Exp $ | |
| */ | |
| #ifndef _STDATOMIC_H_ | |
| #define _STDATOMIC_H_ | |
| #include <stddef.h> | |
| #include <stdint.h> | |
| #if !defined(__has_feature) | |
| #define __has_feature(x) 0 | |
| #endif | |
| #if !defined(__has_builtin) | |
| #define __has_builtin(x) 0 | |
| #endif | |
| #if !defined(__GNUC_PREREQ__) | |
| #if defined(__GNUC__) && defined(__GNUC_MINOR__) | |
| #define __GNUC_PREREQ__(maj, min) \ | |
| ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) | |
| #else | |
| #define __GNUC_PREREQ__(maj, min) 0 | |
| #endif | |
| #endif | |
| #if !defined(__CLANG_ATOMICS) && !defined(__GNUC_ATOMICS) | |
| #if __has_feature(c_atomic) | |
| #define __CLANG_ATOMICS | |
| #elif __GNUC_PREREQ__(4, 7) | |
| #define __GNUC_ATOMICS | |
| #elif !defined(__GNUC__) | |
| #error "stdatomic.h does not support your compiler" | |
| #endif | |
| #endif | |
| #if !defined(__CLANG_ATOMICS) | |
| #define _Atomic(T) struct { volatile __typeof__(T) __val; } | |
| #endif | |
| /* | |
| * 7.17.2 Initialization. | |
| */ | |
| #if defined(__CLANG_ATOMICS) | |
| #define ATOMIC_VAR_INIT(value) (value) | |
| #define atomic_init(obj, value) __c11_atomic_init(obj, value) | |
| #else | |
| #define ATOMIC_VAR_INIT(value) { .__val = (value) } | |
| #define atomic_init(obj, value) do { \ | |
| (obj)->__val = (value); \ | |
| } while (0) | |
| #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 | |
| #define __ATOMIC_RELAXED 0 | |
| #endif | |
| #ifndef __ATOMIC_CONSUME | |
| #define __ATOMIC_CONSUME 1 | |
| #endif | |
| #ifndef __ATOMIC_ACQUIRE | |
| #define __ATOMIC_ACQUIRE 2 | |
| #endif | |
| #ifndef __ATOMIC_RELEASE | |
| #define __ATOMIC_RELEASE 3 | |
| #endif | |
| #ifndef __ATOMIC_ACQ_REL | |
| #define __ATOMIC_ACQ_REL 4 | |
| #endif | |
| #ifndef __ATOMIC_SEQ_CST | |
| #define __ATOMIC_SEQ_CST 5 | |
| #endif | |
| /* | |
| * 7.17.3 Order and consistency. | |
| * | |
| * The memory_order_* constants that denote the barrier behaviour of the | |
| * atomic operations. | |
| */ | |
| 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 | |
| }; | |
| typedef enum memory_order memory_order; | |
| /* | |
| * 7.17.4 Fences. | |
| */ | |
| #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) | |
| #define atomic_thread_fence(order) __atomic_thread_fence(order) | |
| #define atomic_signal_fence(order) __atomic_signal_fence(order) | |
| #else | |
| #define atomic_thread_fence(order) __sync_synchronize() | |
| #define atomic_signal_fence(order) __asm volatile ("" : : : "memory") | |
| #endif | |
| /* | |
| * 7.17.5 Lock-free property. | |
| */ | |
| #if defined(__CLANG_ATOMICS) | |
| #define atomic_is_lock_free(obj) \ | |
| __c11_atomic_is_lock_free(sizeof(obj)) | |
| #elif defined(__GNUC_ATOMICS) | |
| #define atomic_is_lock_free(obj) \ | |
| __atomic_is_lock_free(sizeof((obj)->__val)) | |
| #else | |
| #define atomic_is_lock_free(obj) \ | |
| (sizeof((obj)->__val) <= sizeof(void *)) | |
| #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) \ | |
| __c11_atomic_compare_exchange_strong(object, expected, desired, \ | |
| success, failure) | |
| #define atomic_compare_exchange_weak_explicit(object, expected, \ | |
| desired, success, failure) \ | |
| __c11_atomic_compare_exchange_weak(object, expected, desired, \ | |
| success, failure) | |
| #define atomic_exchange_explicit(object, desired, order) \ | |
| __c11_atomic_exchange(object, desired, order) | |
| #define atomic_fetch_add_explicit(object, operand, order) \ | |
| __c11_atomic_fetch_add(object, operand, order) | |
| #define atomic_fetch_and_explicit(object, operand, order) \ | |
| __c11_atomic_fetch_and(object, operand, order) | |
| #define atomic_fetch_or_explicit(object, operand, order) \ | |
| __c11_atomic_fetch_or(object, operand, order) | |
| #define atomic_fetch_sub_explicit(object, operand, order) \ | |
| __c11_atomic_fetch_sub(object, operand, order) | |
| #define atomic_fetch_xor_explicit(object, operand, order) \ | |
| __c11_atomic_fetch_xor(object, operand, order) | |
| #define atomic_load_explicit(object, order) \ | |
| __c11_atomic_load(object, order) | |
| #define atomic_store_explicit(object, desired, order) \ | |
| __c11_atomic_store(object, desired, order) | |
| #elif defined(__GNUC_ATOMICS) | |
| #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 | |
| #define atomic_compare_exchange_strong_explicit(object, expected, \ | |
| desired, success, failure) ({ \ | |
| __typeof__((object)->__val) __v; \ | |
| _Bool __r; \ | |
| __v = __sync_val_compare_and_swap(&(object)->__val, \ | |
| *(expected), desired); \ | |
| __r = *(expected) == __v; \ | |
| *(expected) = __v; \ | |
| __r; \ | |
| }) | |
| #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. */ | |
| #define atomic_exchange_explicit(object, desired, order) \ | |
| __sync_swap(&(object)->__val, desired) | |
| #else | |
| /* | |
| * __sync_lock_test_and_set() is only an acquire barrier in theory (although in | |
| * practice it is usually a full barrier) so we need an explicit barrier after | |
| * it. | |
| */ | |
| #define atomic_exchange_explicit(object, desired, order) ({ \ | |
| __typeof__((object)->__val) __v; \ | |
| __v = __sync_lock_test_and_set(&(object)->__val, desired); \ | |
| __sync_synchronize(); \ | |
| __v; \ | |
| }) | |
| #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) | |
| #define atomic_store_explicit(object, desired, order) do { \ | |
| __sync_synchronize(); \ | |
| (object)->__val = (desired); \ | |
| __sync_synchronize(); \ | |
| } while (0) | |
| #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. | |
| */ | |
| typedef atomic_bool atomic_flag; | |
| #define ATOMIC_FLAG_INIT ATOMIC_VAR_INIT(0) | |
| #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) \ | |
| atomic_flag_clear_explicit(object, memory_order_seq_cst) | |
| #define atomic_flag_test_and_set(object) \ | |
| atomic_flag_test_and_set_explicit(object, memory_order_seq_cst) | |
| #endif /* !_STDATOMIC_H_ */ |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment