gcc/ginclude/stdatomic.h

   1 /* Copyright (C) 2013 Free Software Foundation, Inc.
   2
   3 This file is part of GCC.
   4
   5 GCC is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 3, or (at your option)
   8 any later version.
   9
  10 GCC is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 Under Section 7 of GPL version 3, you are granted additional
  16 permissions described in the GCC Runtime Library Exception, version
  17 3.1, as published by the Free Software Foundation.
  18
  19 You should have received a copy of the GNU General Public License and
  20 a copy of the GCC Runtime Library Exception along with this program;
  21 see 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
  29 typedef 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
  40 typedef _Atomic _Bool atomic_bool;
  41 typedef _Atomic char atomic_char;
  42 typedef _Atomic signed char atomic_schar;
  43 typedef _Atomic unsigned char atomic_uchar;
  44 typedef _Atomic short atomic_short;
  45 typedef _Atomic unsigned short atomic_ushort;
  46 typedef _Atomic int atomic_int;
  47 typedef _Atomic unsigned int atomic_uint;
  48 typedef _Atomic long atomic_long;
  49 typedef _Atomic unsigned long atomic_ulong;
  50 typedef _Atomic long long atomic_llong;
  51 typedef _Atomic unsigned long long atomic_ullong;
  52 typedef _Atomic __CHAR16_TYPE__ atomic_char16_t;
  53 typedef _Atomic __CHAR32_TYPE__ atomic_char32_t;
  54 typedef _Atomic __WCHAR_TYPE__ atomic_wchar_t;
  55 typedef _Atomic __INT_LEAST8_TYPE__ atomic_int_least8_t;
  56 typedef _Atomic __UINT_LEAST8_TYPE__ atomic_uint_least8_t;
  57 typedef _Atomic __INT_LEAST16_TYPE__ atomic_int_least16_t;
  58 typedef _Atomic __UINT_LEAST16_TYPE__ atomic_uint_least16_t;
  59 typedef _Atomic __INT_LEAST32_TYPE__ atomic_int_least32_t;
  60 typedef _Atomic __UINT_LEAST32_TYPE__ atomic_uint_least32_t;
  61 typedef _Atomic __INT_LEAST64_TYPE__ atomic_int_least64_t;
  62 typedef _Atomic __UINT_LEAST64_TYPE__ atomic_uint_least64_t;
  63 typedef _Atomic __INT_FAST8_TYPE__ atomic_int_fast8_t;
  64 typedef _Atomic __UINT_FAST8_TYPE__ atomic_uint_fast8_t;
  65 typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t;
  66 typedef _Atomic __UINT_FAST16_TYPE__ atomic_uint_fast16_t;
  67 typedef _Atomic __INT_FAST32_TYPE__ atomic_int_fast32_t;
  68 typedef _Atomic __UINT_FAST32_TYPE__ atomic_uint_fast32_t;
  69 typedef _Atomic __INT_FAST64_TYPE__ atomic_int_fast64_t;
  70 typedef _Atomic __UINT_FAST64_TYPE__ atomic_uint_fast64_t;
  71 typedef _Atomic __INTPTR_TYPE__ atomic_intptr_t;
  72 typedef _Atomic __UINTPTR_TYPE__ atomic_uintptr_t;
  73 typedef _Atomic __SIZE_TYPE__ atomic_size_t;
  74 typedef _Atomic __PTRDIFF_TYPE__ atomic_ptrdiff_t;
  75 typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t;
  76 typedef _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     __typeof__ (Y) __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__ to remove _Atomic
 125    qualifiers (and const qualifiers, if those are valid on macro
 126    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     __typeof__ (*(PTR)) __atomic_store_tmp = (VAL);     \
 139     __atomic_store ((PTR), &__atomic_store_tmp, (MO));  \
 140   })
 141
 142 #define atomic_store(PTR, VAL)                          \
 143   atomic_store_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
 144
 145
 146 #define atomic_load_explicit(PTR, MO)                                   \
 147   __extension__                                                         \
 148   ({                                                                    \
 149     __typeof__ (*(PTR)) __atomic_load_tmp;                              \
 150     __atomic_load ((PTR), &__atomic_load_tmp, (MO));                    \
 151     __atomic_load_tmp;                                                  \
 152   })
 153
 154 #define atomic_load(PTR)  atomic_load_explicit (PTR, __ATOMIC_SEQ_CST)
 155
 156
 157 #define atomic_exchange_explicit(PTR, VAL, MO)                          \
 158   __extension__                                                         \
 159   ({                                                                    \
 160     __typeof__ (*(PTR)) __atomic_exchange_val = (VAL), __atomic_exchange_tmp; \
 161     __atomic_exchange ((PTR), &__atomic_exchange_val,                   \
 162                        &__atomic_exchange_tmp, (MO));                   \
 163     __atomic_exchange_tmp;                                              \
 164   })
 165
 166 #define atomic_exchange(PTR, VAL)                       \
 167   atomic_exchange_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
 168
 169
 170 #define atomic_compare_exchange_strong_explicit(PTR, VAL, DES, SUC, FAIL) \
 171   __extension__                                                         \
 172   ({                                                                    \
 173     __typeof__ (*(PTR)) __atomic_compare_exchange_tmp = (DES);          \
 174     __atomic_compare_exchange ((PTR), (VAL),                            \
 175                                &__atomic_compare_exchange_tmp, 0,       \
 176                                (SUC), (FAIL));                          \
 177   })
 178
 179 #define atomic_compare_exchange_strong(PTR, VAL, DES)                      \
 180   atomic_compare_exchange_strong_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
 181                                            __ATOMIC_SEQ_CST)
 182
 183 #define atomic_compare_exchange_weak_explicit(PTR, VAL, DES, SUC, FAIL) \
 184   __extension__                                                         \
 185   ({                                                                    \
 186     __typeof__ (*(PTR)) __atomic_compare_exchange_tmp = (DES);          \
 187     __atomic_compare_exchange ((PTR), (VAL),                            \
 188                                &__atomic_compare_exchange_tmp, 1,       \
 189                                (SUC), (FAIL));                          \
 190   })
 191
 192 #define atomic_compare_exchange_weak(PTR, VAL, DES)                     \
 193   atomic_compare_exchange_weak_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
 194                                          __ATOMIC_SEQ_CST)
 195
 196
 197
 198 #define atomic_fetch_add(PTR, VAL) __atomic_fetch_add ((PTR), (VAL),    \
 199                                                        __ATOMIC_SEQ_CST)
 200 #define atomic_fetch_add_explicit(PTR, VAL, MO)                         \
 201                           __atomic_fetch_add ((PTR), (VAL), (MO))
 202
 203 #define atomic_fetch_sub(PTR, VAL) __atomic_fetch_sub ((PTR), (VAL),    \
 204                                                        __ATOMIC_SEQ_CST)
 205 #define atomic_fetch_sub_explicit(PTR, VAL, MO)                         \
 206                           __atomic_fetch_sub ((PTR), (VAL), (MO))
 207
 208 #define atomic_fetch_or(PTR, VAL) __atomic_fetch_or ((PTR), (VAL),      \
 209                                                        __ATOMIC_SEQ_CST)
 210 #define atomic_fetch_or_explicit(PTR, VAL, MO)                  \
 211                           __atomic_fetch_or ((PTR), (VAL), (MO))
 212
 213 #define atomic_fetch_xor(PTR, VAL) __atomic_fetch_xor ((PTR), (VAL),    \
 214                                                        __ATOMIC_SEQ_CST)
 215 #define atomic_fetch_xor_explicit(PTR, VAL, MO)                         \
 216                           __atomic_fetch_xor ((PTR), (VAL), (MO))
 217
 218 #define atomic_fetch_and(PTR, VAL) __atomic_fetch_and ((PTR), (VAL),    \
 219                                                        __ATOMIC_SEQ_CST)
 220 #define atomic_fetch_and_explicit(PTR, VAL, MO)                         \
 221                           __atomic_fetch_and ((PTR), (VAL), (MO))
 222
 223
 224 typedef _Atomic struct
 225 {
 226 #if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
 227   _Bool __val;
 228 #else
 229   unsigned char __val;
 230 #endif
 231 } atomic_flag;
 232
 233 #define ATOMIC_FLAG_INIT        { 0 }
 234
 235
 236 #define atomic_flag_test_and_set(PTR)                                   \
 237                         __atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST)
 238 #define atomic_flag_test_and_set_explicit(PTR, MO)                      \
 239                         __atomic_test_and_set ((PTR), (MO))
 240
 241 #define atomic_flag_clear(PTR)  __atomic_clear ((PTR), __ATOMIC_SEQ_CST)
 242 #define atomic_flag_clear_explicit(PTR, MO)   __atomic_clear ((PTR), (MO))
 243
 244 #endif  /* _STDATOMIC_H */