1/* Copyright (C) 2013-2014 Free Software Foundation, Inc. 2 3This file is part of GCC. 4 5GCC is free software; you can redistribute it and/or modify 6it under the terms of the GNU General Public License as published by 7the Free Software Foundation; either version 3, or (at your option) 8any later version. 9 10GCC is distributed in the hope that it will be useful, 11but WITHOUT ANY WARRANTY; without even the implied warranty of 12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13GNU General Public License for more details. 14 15Under Section 7 of GPL version 3, you are granted additional 16permissions described in the GCC Runtime Library Exception, version 173.1, as published by the Free Software Foundation. 18 19You should have received a copy of the GNU General Public License and 20a copy of the GCC Runtime Library Exception along with this program; 21see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 22<http://www.gnu.org/licenses/>. */ 23 24/* ISO C11 Standard: 7.17 Atomics <stdatomic.h>. */ 25 26#ifndef _STDATOMIC_H 27#define _STDATOMIC_H 28 29typedef enum 30 { 31 memory_order_relaxed = __ATOMIC_RELAXED, 32 memory_order_consume = __ATOMIC_CONSUME, 33 memory_order_acquire = __ATOMIC_ACQUIRE, 34 memory_order_release = __ATOMIC_RELEASE, 35 memory_order_acq_rel = __ATOMIC_ACQ_REL, 36 memory_order_seq_cst = __ATOMIC_SEQ_CST 37 } memory_order; 38 39 40typedef _Atomic _Bool atomic_bool; 41typedef _Atomic char atomic_char; 42typedef _Atomic signed char atomic_schar; 43typedef _Atomic unsigned char atomic_uchar; 44typedef _Atomic short atomic_short; 45typedef _Atomic unsigned short atomic_ushort; 46typedef _Atomic int atomic_int; 47typedef _Atomic unsigned int atomic_uint; 48typedef _Atomic long atomic_long; 49typedef _Atomic unsigned long atomic_ulong; 50typedef _Atomic long long atomic_llong; 51typedef _Atomic unsigned long long atomic_ullong; 52typedef _Atomic __CHAR16_TYPE__ atomic_char16_t; 53typedef _Atomic __CHAR32_TYPE__ atomic_char32_t; 54typedef _Atomic __WCHAR_TYPE__ atomic_wchar_t; 55typedef _Atomic __INT_LEAST8_TYPE__ atomic_int_least8_t; 56typedef _Atomic __UINT_LEAST8_TYPE__ atomic_uint_least8_t; 57typedef _Atomic __INT_LEAST16_TYPE__ atomic_int_least16_t; 58typedef _Atomic __UINT_LEAST16_TYPE__ atomic_uint_least16_t; 59typedef _Atomic __INT_LEAST32_TYPE__ atomic_int_least32_t; 60typedef _Atomic __UINT_LEAST32_TYPE__ atomic_uint_least32_t; 61typedef _Atomic __INT_LEAST64_TYPE__ atomic_int_least64_t; 62typedef _Atomic __UINT_LEAST64_TYPE__ atomic_uint_least64_t; 63typedef _Atomic __INT_FAST8_TYPE__ atomic_int_fast8_t; 64typedef _Atomic __UINT_FAST8_TYPE__ atomic_uint_fast8_t; 65typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t; 66typedef _Atomic __UINT_FAST16_TYPE__ atomic_uint_fast16_t; 67typedef _Atomic __INT_FAST32_TYPE__ atomic_int_fast32_t; 68typedef _Atomic __UINT_FAST32_TYPE__ atomic_uint_fast32_t; 69typedef _Atomic __INT_FAST64_TYPE__ atomic_int_fast64_t; 70typedef _Atomic __UINT_FAST64_TYPE__ atomic_uint_fast64_t; 71typedef _Atomic __INTPTR_TYPE__ atomic_intptr_t; 72typedef _Atomic __UINTPTR_TYPE__ atomic_uintptr_t; 73typedef _Atomic __SIZE_TYPE__ atomic_size_t; 74typedef _Atomic __PTRDIFF_TYPE__ atomic_ptrdiff_t; 75typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t; 76typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t; 77 78 79#define ATOMIC_VAR_INIT(VALUE) (VALUE) 80#define atomic_init(PTR, VAL) \ 81 do \ 82 { \ 83 *(PTR) = (VAL); \ 84 } \ 85 while (0) 86 87#define kill_dependency(Y) \ 88 __extension__ \ 89 ({ \ 90 __auto_type __kill_dependency_tmp = (Y); \ 91 __kill_dependency_tmp; \ 92 }) 93 94#define atomic_thread_fence(MO) __atomic_thread_fence (MO) 95#define atomic_signal_fence(MO) __atomic_signal_fence (MO) 96#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ)) 97 98#define __atomic_type_lock_free(T) \ 99 (__atomic_always_lock_free (sizeof (T), (void *) 0) \ 100 ? 2 \ 101 : (__atomic_is_lock_free (sizeof (T), (void *) 0) ? 1 : 0)) 102#define ATOMIC_BOOL_LOCK_FREE \ 103 __atomic_type_lock_free (atomic_bool) 104#define ATOMIC_CHAR_LOCK_FREE \ 105 __atomic_type_lock_free (atomic_char) 106#define ATOMIC_CHAR16_T_LOCK_FREE \ 107 __atomic_type_lock_free (atomic_char16_t) 108#define ATOMIC_CHAR32_T_LOCK_FREE \ 109 __atomic_type_lock_free (atomic_char32_t) 110#define ATOMIC_WCHAR_T_LOCK_FREE \ 111 __atomic_type_lock_free (atomic_wchar_t) 112#define ATOMIC_SHORT_LOCK_FREE \ 113 __atomic_type_lock_free (atomic_short) 114#define ATOMIC_INT_LOCK_FREE \ 115 __atomic_type_lock_free (atomic_int) 116#define ATOMIC_LONG_LOCK_FREE \ 117 __atomic_type_lock_free (atomic_long) 118#define ATOMIC_LLONG_LOCK_FREE \ 119 __atomic_type_lock_free (atomic_llong) 120#define ATOMIC_POINTER_LOCK_FREE \ 121 __atomic_type_lock_free (void * _Atomic) 122 123 124/* Note that these macros require __typeof__ and __auto_type to remove 125 _Atomic qualifiers (and const qualifiers, if those are valid on 126 macro operands). 127 128 Also note that the header file uses the generic form of __atomic 129 builtins, which requires the address to be taken of the value 130 parameter, and then we pass that value on. This allows the macros 131 to work for any type, and the compiler is smart enough to convert 132 these to lock-free _N variants if possible, and throw away the 133 temps. */ 134 135#define atomic_store_explicit(PTR, VAL, MO) \ 136 __extension__ \ 137 ({ \ 138 __auto_type __atomic_store_ptr = (PTR); \ 139 __typeof__ (*__atomic_store_ptr) __atomic_store_tmp = (VAL); \ 140 __atomic_store (__atomic_store_ptr, &__atomic_store_tmp, (MO)); \ 141 }) 142 143#define atomic_store(PTR, VAL) \ 144 atomic_store_explicit (PTR, VAL, __ATOMIC_SEQ_CST) 145 146 147#define atomic_load_explicit(PTR, MO) \ 148 __extension__ \ 149 ({ \ 150 __auto_type __atomic_load_ptr = (PTR); \ 151 __typeof__ (*__atomic_load_ptr) __atomic_load_tmp; \ 152 __atomic_load (__atomic_load_ptr, &__atomic_load_tmp, (MO)); \ 153 __atomic_load_tmp; \ 154 }) 155 156#define atomic_load(PTR) atomic_load_explicit (PTR, __ATOMIC_SEQ_CST) 157 158 159#define atomic_exchange_explicit(PTR, VAL, MO) \ 160 __extension__ \ 161 ({ \ 162 __auto_type __atomic_exchange_ptr = (PTR); \ 163 __typeof__ (*__atomic_exchange_ptr) __atomic_exchange_val = (VAL); \ 164 __typeof__ (*__atomic_exchange_ptr) __atomic_exchange_tmp; \ 165 __atomic_exchange (__atomic_exchange_ptr, &__atomic_exchange_val, \ 166 &__atomic_exchange_tmp, (MO)); \ 167 __atomic_exchange_tmp; \ 168 }) 169 170#define atomic_exchange(PTR, VAL) \ 171 atomic_exchange_explicit (PTR, VAL, __ATOMIC_SEQ_CST) 172 173 174#define atomic_compare_exchange_strong_explicit(PTR, VAL, DES, SUC, FAIL) \ 175 __extension__ \ 176 ({ \ 177 __auto_type __atomic_compare_exchange_ptr = (PTR); \ 178 __typeof__ (*__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \ 179 = (DES); \ 180 __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL), \ 181 &__atomic_compare_exchange_tmp, 0, \ 182 (SUC), (FAIL)); \ 183 }) 184 185#define atomic_compare_exchange_strong(PTR, VAL, DES) \ 186 atomic_compare_exchange_strong_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \ 187 __ATOMIC_SEQ_CST) 188 189#define atomic_compare_exchange_weak_explicit(PTR, VAL, DES, SUC, FAIL) \ 190 __extension__ \ 191 ({ \ 192 __auto_type __atomic_compare_exchange_ptr = (PTR); \ 193 __typeof__ (*__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \ 194 = (DES); \ 195 __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL), \ 196 &__atomic_compare_exchange_tmp, 1, \ 197 (SUC), (FAIL)); \ 198 }) 199 200#define atomic_compare_exchange_weak(PTR, VAL, DES) \ 201 atomic_compare_exchange_weak_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \ 202 __ATOMIC_SEQ_CST) 203 204 205 206#define atomic_fetch_add(PTR, VAL) __atomic_fetch_add ((PTR), (VAL), \ 207 __ATOMIC_SEQ_CST) 208#define atomic_fetch_add_explicit(PTR, VAL, MO) \ 209 __atomic_fetch_add ((PTR), (VAL), (MO)) 210 211#define atomic_fetch_sub(PTR, VAL) __atomic_fetch_sub ((PTR), (VAL), \ 212 __ATOMIC_SEQ_CST) 213#define atomic_fetch_sub_explicit(PTR, VAL, MO) \ 214 __atomic_fetch_sub ((PTR), (VAL), (MO)) 215 216#define atomic_fetch_or(PTR, VAL) __atomic_fetch_or ((PTR), (VAL), \ 217 __ATOMIC_SEQ_CST) 218#define atomic_fetch_or_explicit(PTR, VAL, MO) \ 219 __atomic_fetch_or ((PTR), (VAL), (MO)) 220 221#define atomic_fetch_xor(PTR, VAL) __atomic_fetch_xor ((PTR), (VAL), \ 222 __ATOMIC_SEQ_CST) 223#define atomic_fetch_xor_explicit(PTR, VAL, MO) \ 224 __atomic_fetch_xor ((PTR), (VAL), (MO)) 225 226#define atomic_fetch_and(PTR, VAL) __atomic_fetch_and ((PTR), (VAL), \ 227 __ATOMIC_SEQ_CST) 228#define atomic_fetch_and_explicit(PTR, VAL, MO) \ 229 __atomic_fetch_and ((PTR), (VAL), (MO)) 230 231 232typedef _Atomic struct 233{ 234#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1 235 _Bool __val; 236#else 237 unsigned char __val; 238#endif 239} atomic_flag; 240 241#define ATOMIC_FLAG_INIT { 0 } 242 243 244#define atomic_flag_test_and_set(PTR) \ 245 __atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST) 246#define atomic_flag_test_and_set_explicit(PTR, MO) \ 247 __atomic_test_and_set ((PTR), (MO)) 248 249#define atomic_flag_clear(PTR) __atomic_clear ((PTR), __ATOMIC_SEQ_CST) 250#define atomic_flag_clear_explicit(PTR, MO) __atomic_clear ((PTR), (MO)) 251 252#endif /* _STDATOMIC_H */ 253