gcc/ginclude/stdatomic.h

   1 /* Copyright (C) 2013-2022 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 #ifdef __CHAR8_TYPE__
  53 typedef _Atomic __CHAR8_TYPE__ atomic_char8_t;
  54 #endif
  55 typedef _Atomic __CHAR16_TYPE__ atomic_char16_t;
  56 typedef _Atomic __CHAR32_TYPE__ atomic_char32_t;
  57 typedef _Atomic __WCHAR_TYPE__ atomic_wchar_t;
  58 typedef _Atomic __INT_LEAST8_TYPE__ atomic_int_least8_t;
  59 typedef _Atomic __UINT_LEAST8_TYPE__ atomic_uint_least8_t;
  60 typedef _Atomic __INT_LEAST16_TYPE__ atomic_int_least16_t;
  61 typedef _Atomic __UINT_LEAST16_TYPE__ atomic_uint_least16_t;
  62 typedef _Atomic __INT_LEAST32_TYPE__ atomic_int_least32_t;
  63 typedef _Atomic __UINT_LEAST32_TYPE__ atomic_uint_least32_t;
  64 typedef _Atomic __INT_LEAST64_TYPE__ atomic_int_least64_t;
  65 typedef _Atomic __UINT_LEAST64_TYPE__ atomic_uint_least64_t;
  66 typedef _Atomic __INT_FAST8_TYPE__ atomic_int_fast8_t;
  67 typedef _Atomic __UINT_FAST8_TYPE__ atomic_uint_fast8_t;
  68 typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t;
  69 typedef _Atomic __UINT_FAST16_TYPE__ atomic_uint_fast16_t;
  70 typedef _Atomic __INT_FAST32_TYPE__ atomic_int_fast32_t;
  71 typedef _Atomic __UINT_FAST32_TYPE__ atomic_uint_fast32_t;
  72 typedef _Atomic __INT_FAST64_TYPE__ atomic_int_fast64_t;
  73 typedef _Atomic __UINT_FAST64_TYPE__ atomic_uint_fast64_t;
  74 typedef _Atomic __INTPTR_TYPE__ atomic_intptr_t;
  75 typedef _Atomic __UINTPTR_TYPE__ atomic_uintptr_t;
  76 typedef _Atomic __SIZE_TYPE__ atomic_size_t;
  77 typedef _Atomic __PTRDIFF_TYPE__ atomic_ptrdiff_t;
  78 typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t;
  79 typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t;
  80
  81
  82 #if !(defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L)
  83 #define ATOMIC_VAR_INIT(VALUE)  (VALUE)
  84 #endif
  85
  86 /* Initialize an atomic object pointed to by PTR with VAL.  */
  87 #define atomic_init(PTR, VAL)                           \
  88   atomic_store_explicit (PTR, VAL, __ATOMIC_RELAXED)
  89
  90 #define kill_dependency(Y)                      \
  91   __extension__                                 \
  92   ({                                            \
  93     __auto_type __kill_dependency_tmp = (Y);    \
  94     __kill_dependency_tmp;                      \
  95   })
  96
  97 extern void atomic_thread_fence (memory_order);
  98 #define atomic_thread_fence(MO) __atomic_thread_fence (MO)
  99 extern void atomic_signal_fence (memory_order);
 100 #define atomic_signal_fence(MO) __atomic_signal_fence  (MO)
 101 #define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ))
 102
 103 #define ATOMIC_BOOL_LOCK_FREE           __GCC_ATOMIC_BOOL_LOCK_FREE
 104 #define ATOMIC_CHAR_LOCK_FREE           __GCC_ATOMIC_CHAR_LOCK_FREE
 105 #ifdef __GCC_ATOMIC_CHAR8_T_LOCK_FREE
 106 #define ATOMIC_CHAR8_T_LOCK_FREE        __GCC_ATOMIC_CHAR8_T_LOCK_FREE
 107 #endif
 108 #define ATOMIC_CHAR16_T_LOCK_FREE       __GCC_ATOMIC_CHAR16_T_LOCK_FREE
 109 #define ATOMIC_CHAR32_T_LOCK_FREE       __GCC_ATOMIC_CHAR32_T_LOCK_FREE
 110 #define ATOMIC_WCHAR_T_LOCK_FREE        __GCC_ATOMIC_WCHAR_T_LOCK_FREE
 111 #define ATOMIC_SHORT_LOCK_FREE          __GCC_ATOMIC_SHORT_LOCK_FREE
 112 #define ATOMIC_INT_LOCK_FREE            __GCC_ATOMIC_INT_LOCK_FREE
 113 #define ATOMIC_LONG_LOCK_FREE           __GCC_ATOMIC_LONG_LOCK_FREE
 114 #define ATOMIC_LLONG_LOCK_FREE          __GCC_ATOMIC_LLONG_LOCK_FREE
 115 #define ATOMIC_POINTER_LOCK_FREE        __GCC_ATOMIC_POINTER_LOCK_FREE
 116
 117
 118 /* Note that these macros require __auto_type to remove
 119    _Atomic qualifiers (and const qualifiers, if those are valid on
 120    macro operands).
 121
 122    Also note that the header file uses the generic form of __atomic
 123    builtins, which requires the address to be taken of the value
 124    parameter, and then we pass that value on.  This allows the macros
 125    to work for any type, and the compiler is smart enough to convert
 126    these to lock-free _N variants if possible, and throw away the
 127    temps.  */
 128
 129 #define atomic_store_explicit(PTR, VAL, MO)                             \
 130   __extension__                                                         \
 131   ({                                                                    \
 132     __auto_type __atomic_store_ptr = (PTR);                             \
 133     __typeof__ ((void)0, *__atomic_store_ptr) __atomic_store_tmp = (VAL);       \
 134     __atomic_store (__atomic_store_ptr, &__atomic_store_tmp, (MO));     \
 135   })
 136
 137 #define atomic_store(PTR, VAL)                          \
 138   atomic_store_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
 139
 140
 141 #define atomic_load_explicit(PTR, MO)                                   \
 142   __extension__                                                         \
 143   ({                                                                    \
 144     __auto_type __atomic_load_ptr = (PTR);                              \
 145     __typeof__ ((void)0, *__atomic_load_ptr) __atomic_load_tmp;                 \
 146     __atomic_load (__atomic_load_ptr, &__atomic_load_tmp, (MO));        \
 147     __atomic_load_tmp;                                                  \
 148   })
 149
 150 #define atomic_load(PTR)  atomic_load_explicit (PTR, __ATOMIC_SEQ_CST)
 151
 152
 153 #define atomic_exchange_explicit(PTR, VAL, MO)                          \
 154   __extension__                                                         \
 155   ({                                                                    \
 156     __auto_type __atomic_exchange_ptr = (PTR);                          \
 157     __typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_val = (VAL); \
 158     __typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_tmp;         \
 159     __atomic_exchange (__atomic_exchange_ptr, &__atomic_exchange_val,   \
 160                        &__atomic_exchange_tmp, (MO));                   \
 161     __atomic_exchange_tmp;                                              \
 162   })
 163
 164 #define atomic_exchange(PTR, VAL)                       \
 165   atomic_exchange_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
 166
 167
 168 #define atomic_compare_exchange_strong_explicit(PTR, VAL, DES, SUC, FAIL) \
 169   __extension__                                                         \
 170   ({                                                                    \
 171     __auto_type __atomic_compare_exchange_ptr = (PTR);                  \
 172     __typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
 173       = (DES);                                                          \
 174     __atomic_compare_exchange (__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     __auto_type __atomic_compare_exchange_ptr = (PTR);                  \
 187     __typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
 188       = (DES);                                                          \
 189     __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL),    \
 190                                &__atomic_compare_exchange_tmp, 1,       \
 191                                (SUC), (FAIL));                          \
 192   })
 193
 194 #define atomic_compare_exchange_weak(PTR, VAL, DES)                     \
 195   atomic_compare_exchange_weak_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
 196                                          __ATOMIC_SEQ_CST)
 197
 198
 199
 200 #define atomic_fetch_add(PTR, VAL) __atomic_fetch_add ((PTR), (VAL),    \
 201                                                        __ATOMIC_SEQ_CST)
 202 #define atomic_fetch_add_explicit(PTR, VAL, MO)                         \
 203                           __atomic_fetch_add ((PTR), (VAL), (MO))
 204
 205 #define atomic_fetch_sub(PTR, VAL) __atomic_fetch_sub ((PTR), (VAL),    \
 206                                                        __ATOMIC_SEQ_CST)
 207 #define atomic_fetch_sub_explicit(PTR, VAL, MO)                         \
 208                           __atomic_fetch_sub ((PTR), (VAL), (MO))
 209
 210 #define atomic_fetch_or(PTR, VAL) __atomic_fetch_or ((PTR), (VAL),      \
 211                                                        __ATOMIC_SEQ_CST)
 212 #define atomic_fetch_or_explicit(PTR, VAL, MO)                  \
 213                           __atomic_fetch_or ((PTR), (VAL), (MO))
 214
 215 #define atomic_fetch_xor(PTR, VAL) __atomic_fetch_xor ((PTR), (VAL),    \
 216                                                        __ATOMIC_SEQ_CST)
 217 #define atomic_fetch_xor_explicit(PTR, VAL, MO)                         \
 218                           __atomic_fetch_xor ((PTR), (VAL), (MO))
 219
 220 #define atomic_fetch_and(PTR, VAL) __atomic_fetch_and ((PTR), (VAL),    \
 221                                                        __ATOMIC_SEQ_CST)
 222 #define atomic_fetch_and_explicit(PTR, VAL, MO)                         \
 223                           __atomic_fetch_and ((PTR), (VAL), (MO))
 224
 225
 226 typedef _Atomic struct
 227 {
 228 #if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
 229   _Bool __val;
 230 #else
 231   unsigned char __val;
 232 #endif
 233 } atomic_flag;
 234
 235 #define ATOMIC_FLAG_INIT        { 0 }
 236
 237
 238 extern _Bool atomic_flag_test_and_set (volatile atomic_flag *);
 239 #define atomic_flag_test_and_set(PTR)                                   \
 240                         __atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST)
 241 extern _Bool atomic_flag_test_and_set_explicit (volatile atomic_flag *,
 242                                                 memory_order);
 243 #define atomic_flag_test_and_set_explicit(PTR, MO)                      \
 244                         __atomic_test_and_set ((PTR), (MO))
 245
 246 extern void atomic_flag_clear (volatile atomic_flag *);
 247 #define atomic_flag_clear(PTR)  __atomic_clear ((PTR), __ATOMIC_SEQ_CST)
 248 extern void atomic_flag_clear_explicit (volatile atomic_flag *, memory_order);
 249 #define atomic_flag_clear_explicit(PTR, MO)   __atomic_clear ((PTR), (MO))
 250
 251 #endif  /* _STDATOMIC_H */