Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /*===---- stdatomic.h - Standard header for atomic types and operations -----===
  2.  *
  3.  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4.  * See https://llvm.org/LICENSE.txt for license information.
  5.  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6.  *
  7.  *===-----------------------------------------------------------------------===
  8.  */
  9.  
  10. #ifndef __CLANG_STDATOMIC_H
  11. #define __CLANG_STDATOMIC_H
  12.  
  13. /* If we're hosted, fall back to the system's stdatomic.h. FreeBSD, for
  14.  * example, already has a Clang-compatible stdatomic.h header.
  15.  *
  16.  * Exclude the MSVC path as well as the MSVC header as of the 14.31.30818
  17.  * explicitly disallows `stdatomic.h` in the C mode via an `#error`.  Fallback
  18.  * to the clang resource header until that is fully supported.  The
  19.  * `stdatomic.h` header requires C++ 23 or newer.
  20.  */
  21. #if __STDC_HOSTED__ &&                                                         \
  22.     __has_include_next(<stdatomic.h>) &&                                       \
  23.     (!defined(_MSC_VER) || (defined(__cplusplus) && __cplusplus >= 202002L))
  24. # include_next <stdatomic.h>
  25. #else
  26.  
  27. #include <stddef.h>
  28. #include <stdint.h>
  29.  
  30. #ifdef __cplusplus
  31. extern "C" {
  32. #endif
  33.  
  34. /* 7.17.1 Introduction */
  35.  
  36. #define ATOMIC_BOOL_LOCK_FREE       __CLANG_ATOMIC_BOOL_LOCK_FREE
  37. #define ATOMIC_CHAR_LOCK_FREE       __CLANG_ATOMIC_CHAR_LOCK_FREE
  38. #define ATOMIC_CHAR16_T_LOCK_FREE   __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
  39. #define ATOMIC_CHAR32_T_LOCK_FREE   __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
  40. #define ATOMIC_WCHAR_T_LOCK_FREE    __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
  41. #define ATOMIC_SHORT_LOCK_FREE      __CLANG_ATOMIC_SHORT_LOCK_FREE
  42. #define ATOMIC_INT_LOCK_FREE        __CLANG_ATOMIC_INT_LOCK_FREE
  43. #define ATOMIC_LONG_LOCK_FREE       __CLANG_ATOMIC_LONG_LOCK_FREE
  44. #define ATOMIC_LLONG_LOCK_FREE      __CLANG_ATOMIC_LLONG_LOCK_FREE
  45. #define ATOMIC_POINTER_LOCK_FREE    __CLANG_ATOMIC_POINTER_LOCK_FREE
  46.  
  47. /* 7.17.2 Initialization */
  48.  
  49. #define ATOMIC_VAR_INIT(value) (value)
  50. #if ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201710L) ||             \
  51.      (defined(__cplusplus) && __cplusplus >= 202002L)) &&                      \
  52.     !defined(_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS)
  53. /* ATOMIC_VAR_INIT was deprecated in C17 and C++20. */
  54. #pragma clang deprecated(ATOMIC_VAR_INIT)
  55. #endif
  56. #define atomic_init __c11_atomic_init
  57.  
  58. /* 7.17.3 Order and consistency */
  59.  
  60. typedef enum memory_order {
  61.   memory_order_relaxed = __ATOMIC_RELAXED,
  62.   memory_order_consume = __ATOMIC_CONSUME,
  63.   memory_order_acquire = __ATOMIC_ACQUIRE,
  64.   memory_order_release = __ATOMIC_RELEASE,
  65.   memory_order_acq_rel = __ATOMIC_ACQ_REL,
  66.   memory_order_seq_cst = __ATOMIC_SEQ_CST
  67. } memory_order;
  68.  
  69. #define kill_dependency(y) (y)
  70.  
  71. /* 7.17.4 Fences */
  72.  
  73. /* These should be provided by the libc implementation. */
  74. void atomic_thread_fence(memory_order);
  75. void atomic_signal_fence(memory_order);
  76.  
  77. #define atomic_thread_fence(order) __c11_atomic_thread_fence(order)
  78. #define atomic_signal_fence(order) __c11_atomic_signal_fence(order)
  79.  
  80. /* 7.17.5 Lock-free property */
  81.  
  82. #define atomic_is_lock_free(obj) __c11_atomic_is_lock_free(sizeof(*(obj)))
  83.  
  84. /* 7.17.6 Atomic integer types */
  85.  
  86. #ifdef __cplusplus
  87. typedef _Atomic(bool)               atomic_bool;
  88. #else
  89. typedef _Atomic(_Bool)              atomic_bool;
  90. #endif
  91. typedef _Atomic(char)               atomic_char;
  92. typedef _Atomic(signed char)        atomic_schar;
  93. typedef _Atomic(unsigned char)      atomic_uchar;
  94. typedef _Atomic(short)              atomic_short;
  95. typedef _Atomic(unsigned short)     atomic_ushort;
  96. typedef _Atomic(int)                atomic_int;
  97. typedef _Atomic(unsigned int)       atomic_uint;
  98. typedef _Atomic(long)               atomic_long;
  99. typedef _Atomic(unsigned long)      atomic_ulong;
  100. typedef _Atomic(long long)          atomic_llong;
  101. typedef _Atomic(unsigned long long) atomic_ullong;
  102. typedef _Atomic(uint_least16_t)     atomic_char16_t;
  103. typedef _Atomic(uint_least32_t)     atomic_char32_t;
  104. typedef _Atomic(wchar_t)            atomic_wchar_t;
  105. typedef _Atomic(int_least8_t)       atomic_int_least8_t;
  106. typedef _Atomic(uint_least8_t)      atomic_uint_least8_t;
  107. typedef _Atomic(int_least16_t)      atomic_int_least16_t;
  108. typedef _Atomic(uint_least16_t)     atomic_uint_least16_t;
  109. typedef _Atomic(int_least32_t)      atomic_int_least32_t;
  110. typedef _Atomic(uint_least32_t)     atomic_uint_least32_t;
  111. typedef _Atomic(int_least64_t)      atomic_int_least64_t;
  112. typedef _Atomic(uint_least64_t)     atomic_uint_least64_t;
  113. typedef _Atomic(int_fast8_t)        atomic_int_fast8_t;
  114. typedef _Atomic(uint_fast8_t)       atomic_uint_fast8_t;
  115. typedef _Atomic(int_fast16_t)       atomic_int_fast16_t;
  116. typedef _Atomic(uint_fast16_t)      atomic_uint_fast16_t;
  117. typedef _Atomic(int_fast32_t)       atomic_int_fast32_t;
  118. typedef _Atomic(uint_fast32_t)      atomic_uint_fast32_t;
  119. typedef _Atomic(int_fast64_t)       atomic_int_fast64_t;
  120. typedef _Atomic(uint_fast64_t)      atomic_uint_fast64_t;
  121. typedef _Atomic(intptr_t)           atomic_intptr_t;
  122. typedef _Atomic(uintptr_t)          atomic_uintptr_t;
  123. typedef _Atomic(size_t)             atomic_size_t;
  124. typedef _Atomic(ptrdiff_t)          atomic_ptrdiff_t;
  125. typedef _Atomic(intmax_t)           atomic_intmax_t;
  126. typedef _Atomic(uintmax_t)          atomic_uintmax_t;
  127.  
  128. /* 7.17.7 Operations on atomic types */
  129.  
  130. #define atomic_store(object, desired) __c11_atomic_store(object, desired, __ATOMIC_SEQ_CST)
  131. #define atomic_store_explicit __c11_atomic_store
  132.  
  133. #define atomic_load(object) __c11_atomic_load(object, __ATOMIC_SEQ_CST)
  134. #define atomic_load_explicit __c11_atomic_load
  135.  
  136. #define atomic_exchange(object, desired) __c11_atomic_exchange(object, desired, __ATOMIC_SEQ_CST)
  137. #define atomic_exchange_explicit __c11_atomic_exchange
  138.  
  139. #define atomic_compare_exchange_strong(object, expected, desired) __c11_atomic_compare_exchange_strong(object, expected, desired, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
  140. #define atomic_compare_exchange_strong_explicit __c11_atomic_compare_exchange_strong
  141.  
  142. #define atomic_compare_exchange_weak(object, expected, desired) __c11_atomic_compare_exchange_weak(object, expected, desired, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
  143. #define atomic_compare_exchange_weak_explicit __c11_atomic_compare_exchange_weak
  144.  
  145. #define atomic_fetch_add(object, operand) __c11_atomic_fetch_add(object, operand, __ATOMIC_SEQ_CST)
  146. #define atomic_fetch_add_explicit __c11_atomic_fetch_add
  147.  
  148. #define atomic_fetch_sub(object, operand) __c11_atomic_fetch_sub(object, operand, __ATOMIC_SEQ_CST)
  149. #define atomic_fetch_sub_explicit __c11_atomic_fetch_sub
  150.  
  151. #define atomic_fetch_or(object, operand) __c11_atomic_fetch_or(object, operand, __ATOMIC_SEQ_CST)
  152. #define atomic_fetch_or_explicit __c11_atomic_fetch_or
  153.  
  154. #define atomic_fetch_xor(object, operand) __c11_atomic_fetch_xor(object, operand, __ATOMIC_SEQ_CST)
  155. #define atomic_fetch_xor_explicit __c11_atomic_fetch_xor
  156.  
  157. #define atomic_fetch_and(object, operand) __c11_atomic_fetch_and(object, operand, __ATOMIC_SEQ_CST)
  158. #define atomic_fetch_and_explicit __c11_atomic_fetch_and
  159.  
  160. /* 7.17.8 Atomic flag type and operations */
  161.  
  162. typedef struct atomic_flag { atomic_bool _Value; } atomic_flag;
  163.  
  164. #define ATOMIC_FLAG_INIT { 0 }
  165.  
  166. /* These should be provided by the libc implementation. */
  167. #ifdef __cplusplus
  168. bool atomic_flag_test_and_set(volatile atomic_flag *);
  169. bool atomic_flag_test_and_set_explicit(volatile atomic_flag *, memory_order);
  170. #else
  171. _Bool atomic_flag_test_and_set(volatile atomic_flag *);
  172. _Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *, memory_order);
  173. #endif
  174. void atomic_flag_clear(volatile atomic_flag *);
  175. void atomic_flag_clear_explicit(volatile atomic_flag *, memory_order);
  176.  
  177. #define atomic_flag_test_and_set(object) __c11_atomic_exchange(&(object)->_Value, 1, __ATOMIC_SEQ_CST)
  178. #define atomic_flag_test_and_set_explicit(object, order) __c11_atomic_exchange(&(object)->_Value, 1, order)
  179.  
  180. #define atomic_flag_clear(object) __c11_atomic_store(&(object)->_Value, 0, __ATOMIC_SEQ_CST)
  181. #define atomic_flag_clear_explicit(object, order) __c11_atomic_store(&(object)->_Value, 0, order)
  182.  
  183. #ifdef __cplusplus
  184. }
  185. #endif
  186.  
  187. #endif /* __STDC_HOSTED__ */
  188. #endif /* __CLANG_STDATOMIC_H */
  189.  
  190.