[thirdparty/gcc.git] / gcc / ginclude / stdatomic.h

/* Copyright (C) 2013-2023 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */

/* ISO C11 Standard:  7.17  Atomics <stdatomic.h>.  */

#ifndef _STDATOMIC_H
#define _STDATOMIC_H

typedef enum
  {
    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
  } memory_order;


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;
#ifdef __CHAR8_TYPE__
typedef _Atomic __CHAR8_TYPE__ atomic_char8_t;
#endif
typedef _Atomic __CHAR16_TYPE__ atomic_char16_t;
typedef _Atomic __CHAR32_TYPE__ atomic_char32_t;
typedef _Atomic __WCHAR_TYPE__ atomic_wchar_t;
typedef _Atomic __INT_LEAST8_TYPE__ atomic_int_least8_t;
typedef _Atomic __UINT_LEAST8_TYPE__ atomic_uint_least8_t;
typedef _Atomic __INT_LEAST16_TYPE__ atomic_int_least16_t;
typedef _Atomic __UINT_LEAST16_TYPE__ atomic_uint_least16_t;
typedef _Atomic __INT_LEAST32_TYPE__ atomic_int_least32_t;
typedef _Atomic __UINT_LEAST32_TYPE__ atomic_uint_least32_t;
typedef _Atomic __INT_LEAST64_TYPE__ atomic_int_least64_t;
typedef _Atomic __UINT_LEAST64_TYPE__ atomic_uint_least64_t;
typedef _Atomic __INT_FAST8_TYPE__ atomic_int_fast8_t;
typedef _Atomic __UINT_FAST8_TYPE__ atomic_uint_fast8_t;
typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t;
typedef _Atomic __UINT_FAST16_TYPE__ atomic_uint_fast16_t;
typedef _Atomic __INT_FAST32_TYPE__ atomic_int_fast32_t;
typedef _Atomic __UINT_FAST32_TYPE__ atomic_uint_fast32_t;
typedef _Atomic __INT_FAST64_TYPE__ atomic_int_fast64_t;
typedef _Atomic __UINT_FAST64_TYPE__ atomic_uint_fast64_t;
typedef _Atomic __INTPTR_TYPE__ atomic_intptr_t;
typedef _Atomic __UINTPTR_TYPE__ atomic_uintptr_t;
typedef _Atomic __SIZE_TYPE__ atomic_size_t;
typedef _Atomic __PTRDIFF_TYPE__ atomic_ptrdiff_t;
typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t;
typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t;        


#if !(defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L)
#define ATOMIC_VAR_INIT(VALUE)	(VALUE)
#endif

/* Initialize an atomic object pointed to by PTR with VAL.  */
#define atomic_init(PTR, VAL)                           \
  atomic_store_explicit (PTR, VAL, __ATOMIC_RELAXED)

#define kill_dependency(Y)			\
  __extension__					\
  ({						\
    __auto_type __kill_dependency_tmp = (Y);	\
    __kill_dependency_tmp;			\
  })

extern void atomic_thread_fence (memory_order);
#define atomic_thread_fence(MO)	__atomic_thread_fence (MO)
extern void atomic_signal_fence (memory_order);
#define atomic_signal_fence(MO)	__atomic_signal_fence  (MO)
#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ))

#define ATOMIC_BOOL_LOCK_FREE		__GCC_ATOMIC_BOOL_LOCK_FREE
#define ATOMIC_CHAR_LOCK_FREE		__GCC_ATOMIC_CHAR_LOCK_FREE
#ifdef __GCC_ATOMIC_CHAR8_T_LOCK_FREE
#define ATOMIC_CHAR8_T_LOCK_FREE	__GCC_ATOMIC_CHAR8_T_LOCK_FREE
#endif
#define ATOMIC_CHAR16_T_LOCK_FREE	__GCC_ATOMIC_CHAR16_T_LOCK_FREE
#define ATOMIC_CHAR32_T_LOCK_FREE	__GCC_ATOMIC_CHAR32_T_LOCK_FREE
#define ATOMIC_WCHAR_T_LOCK_FREE	__GCC_ATOMIC_WCHAR_T_LOCK_FREE
#define ATOMIC_SHORT_LOCK_FREE		__GCC_ATOMIC_SHORT_LOCK_FREE
#define ATOMIC_INT_LOCK_FREE		__GCC_ATOMIC_INT_LOCK_FREE
#define ATOMIC_LONG_LOCK_FREE		__GCC_ATOMIC_LONG_LOCK_FREE
#define ATOMIC_LLONG_LOCK_FREE		__GCC_ATOMIC_LLONG_LOCK_FREE
#define ATOMIC_POINTER_LOCK_FREE	__GCC_ATOMIC_POINTER_LOCK_FREE


/* Note that these macros require __auto_type to remove
   _Atomic qualifiers (and const qualifiers, if those are valid on
   macro operands).
   
   Also note that the header file uses the generic form of __atomic
   builtins, which requires the address to be taken of the value
   parameter, and then we pass that value on.  This allows the macros
   to work for any type, and the compiler is smart enough to convert
   these to lock-free _N variants if possible, and throw away the
   temps.  */

#define atomic_store_explicit(PTR, VAL, MO)				\
  __extension__								\
  ({									\
    __auto_type __atomic_store_ptr = (PTR);				\
    __typeof__ ((void)0, *__atomic_store_ptr) __atomic_store_tmp = (VAL);	\
    __atomic_store (__atomic_store_ptr, &__atomic_store_tmp, (MO));	\
  })

#define atomic_store(PTR, VAL)				\
  atomic_store_explicit (PTR, VAL, __ATOMIC_SEQ_CST)


#define atomic_load_explicit(PTR, MO)					\
  __extension__								\
  ({									\
    __auto_type __atomic_load_ptr = (PTR);				\
    __typeof__ ((void)0, *__atomic_load_ptr) __atomic_load_tmp;			\
    __atomic_load (__atomic_load_ptr, &__atomic_load_tmp, (MO));	\
    __atomic_load_tmp;							\
  })

#define atomic_load(PTR)  atomic_load_explicit (PTR, __ATOMIC_SEQ_CST)


#define atomic_exchange_explicit(PTR, VAL, MO)				\
  __extension__								\
  ({									\
    __auto_type __atomic_exchange_ptr = (PTR);				\
    __typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_val = (VAL);	\
    __typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_tmp;		\
    __atomic_exchange (__atomic_exchange_ptr, &__atomic_exchange_val,	\
		       &__atomic_exchange_tmp, (MO));			\
    __atomic_exchange_tmp;						\
  })

#define atomic_exchange(PTR, VAL) 			\
  atomic_exchange_explicit (PTR, VAL, __ATOMIC_SEQ_CST)


#define atomic_compare_exchange_strong_explicit(PTR, VAL, DES, SUC, FAIL) \
  __extension__								\
  ({									\
    __auto_type __atomic_compare_exchange_ptr = (PTR);			\
    __typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
      = (DES);								\
    __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL),	\
			       &__atomic_compare_exchange_tmp, 0,	\
			       (SUC), (FAIL));				\
  })

#define atomic_compare_exchange_strong(PTR, VAL, DES) 			   \
  atomic_compare_exchange_strong_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
					   __ATOMIC_SEQ_CST)

#define atomic_compare_exchange_weak_explicit(PTR, VAL, DES, SUC, FAIL) \
  __extension__								\
  ({									\
    __auto_type __atomic_compare_exchange_ptr = (PTR);			\
    __typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
      = (DES);								\
    __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL),	\
			       &__atomic_compare_exchange_tmp, 1,	\
			       (SUC), (FAIL));				\
  })

#define atomic_compare_exchange_weak(PTR, VAL, DES)			\
  atomic_compare_exchange_weak_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
					 __ATOMIC_SEQ_CST)


#define atomic_fetch_add(PTR, VAL) __atomic_fetch_add ((PTR), (VAL), 	\
						       __ATOMIC_SEQ_CST)
#define atomic_fetch_add_explicit(PTR, VAL, MO) 			\
			  __atomic_fetch_add ((PTR), (VAL), (MO))

#define atomic_fetch_sub(PTR, VAL) __atomic_fetch_sub ((PTR), (VAL), 	\
						       __ATOMIC_SEQ_CST)
#define atomic_fetch_sub_explicit(PTR, VAL, MO) 			\
			  __atomic_fetch_sub ((PTR), (VAL), (MO))

#define atomic_fetch_or(PTR, VAL) __atomic_fetch_or ((PTR), (VAL), 	\
						       __ATOMIC_SEQ_CST)
#define atomic_fetch_or_explicit(PTR, VAL, MO) 			\
			  __atomic_fetch_or ((PTR), (VAL), (MO))

#define atomic_fetch_xor(PTR, VAL) __atomic_fetch_xor ((PTR), (VAL), 	\
						       __ATOMIC_SEQ_CST)
#define atomic_fetch_xor_explicit(PTR, VAL, MO) 			\
			  __atomic_fetch_xor ((PTR), (VAL), (MO))

#define atomic_fetch_and(PTR, VAL) __atomic_fetch_and ((PTR), (VAL), 	\
						       __ATOMIC_SEQ_CST)
#define atomic_fetch_and_explicit(PTR, VAL, MO) 			\
			  __atomic_fetch_and ((PTR), (VAL), (MO))


typedef _Atomic struct
{
#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
  _Bool __val;
#else
  unsigned char __val;
#endif
} atomic_flag;

#define ATOMIC_FLAG_INIT	{ 0 }


extern _Bool atomic_flag_test_and_set (volatile atomic_flag *);
#define atomic_flag_test_and_set(PTR) 					\
			__atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST)
extern _Bool atomic_flag_test_and_set_explicit (volatile atomic_flag *,
						memory_order);
#define atomic_flag_test_and_set_explicit(PTR, MO)			\
			__atomic_test_and_set ((PTR), (MO))

extern void atomic_flag_clear (volatile atomic_flag *);
#define atomic_flag_clear(PTR)	__atomic_clear ((PTR), __ATOMIC_SEQ_CST)
extern void atomic_flag_clear_explicit (volatile atomic_flag *, memory_order);
#define atomic_flag_clear_explicit(PTR, MO)   __atomic_clear ((PTR), (MO))

#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
#define __STDC_VERSION_STDATOMIC_H__	202311L
#endif

#endif  /* _STDATOMIC_H */
Commit	Line	Data
83ffe9cd	1	/* Copyright (C) 2013-2023 Free Software Foundation, Inc.
39b2468c JM	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;
703837b2 TH	52	#ifdef __CHAR8_TYPE__
	53	typedef _Atomic __CHAR8_TYPE__ atomic_char8_t;
	54	#endif
39b2468c JM	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
2e7bc76d	82	#if !(defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L)
39b2468c	83	#define ATOMIC_VAR_INIT(VALUE) (VALUE)
2e7bc76d	84	#endif
7585d94f MS	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)
39b2468c JM	89
	90	#define kill_dependency(Y) \
	91	__extension__ \
	92	({ \
38b7bc7f	93	__auto_type __kill_dependency_tmp = (Y); \
39b2468c JM	94	__kill_dependency_tmp; \
	95	})
	96
c29c36ad	97	extern void atomic_thread_fence (memory_order);
39b2468c	98	#define atomic_thread_fence(MO) __atomic_thread_fence (MO)
c29c36ad	99	extern void atomic_signal_fence (memory_order);
39b2468c JM	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
0ee9c843 MP	103	#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
0ee9c843 MP	104	#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
703837b2 TH	105	#ifdef __GCC_ATOMIC_CHAR8_T_LOCK_FREE
	106	#define ATOMIC_CHAR8_T_LOCK_FREE __GCC_ATOMIC_CHAR8_T_LOCK_FREE
	107	#endif
0ee9c843 MP	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
39b2468c JM	116
39b2468c JM	117
768ce4f0	118	/* Note that these macros require __auto_type to remove
38b7bc7f JM	119	_Atomic qualifiers (and const qualifiers, if those are valid on
38b7bc7f JM	120	macro operands).
39b2468c JM	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
38b7bc7f JM	129	#define atomic_store_explicit(PTR, VAL, MO) \
	130	__extension__ \
	131	({ \
	132	__auto_type __atomic_store_ptr = (PTR); \
768ce4f0	133	__typeof__ ((void)0, *__atomic_store_ptr) __atomic_store_tmp = (VAL); \
38b7bc7f	134	__atomic_store (__atomic_store_ptr, &__atomic_store_tmp, (MO)); \
39b2468c JM	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	({ \
38b7bc7f	144	__auto_type __atomic_load_ptr = (PTR); \
768ce4f0	145	__typeof__ ((void)0, *__atomic_load_ptr) __atomic_load_tmp; \
38b7bc7f	146	__atomic_load (__atomic_load_ptr, &__atomic_load_tmp, (MO)); \
39b2468c JM	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	({ \
38b7bc7f	156	__auto_type __atomic_exchange_ptr = (PTR); \
768ce4f0 MU	157	__typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_val = (VAL); \
768ce4f0 MU	158	__typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_tmp; \
38b7bc7f	159	__atomic_exchange (__atomic_exchange_ptr, &__atomic_exchange_val, \
39b2468c JM	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	({ \
38b7bc7f	171	__auto_type __atomic_compare_exchange_ptr = (PTR); \
768ce4f0	172	__typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
38b7bc7f JM	173	= (DES); \
38b7bc7f JM	174	__atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL), \
39b2468c JM	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	({ \
38b7bc7f	186	__auto_type __atomic_compare_exchange_ptr = (PTR); \
768ce4f0	187	__typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
38b7bc7f JM	188	= (DES); \
38b7bc7f JM	189	__atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL), \
39b2468c JM	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
c29c36ad	238	extern _Bool atomic_flag_test_and_set (volatile atomic_flag *);
39b2468c JM	239	#define atomic_flag_test_and_set(PTR) \
39b2468c JM	240	__atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST)
c29c36ad JM	241	extern _Bool atomic_flag_test_and_set_explicit (volatile atomic_flag *,
c29c36ad JM	242	memory_order);
39b2468c JM	243	#define atomic_flag_test_and_set_explicit(PTR, MO) \
	244	__atomic_test_and_set ((PTR), (MO))
	245
c29c36ad	246	extern void atomic_flag_clear (volatile atomic_flag *);
39b2468c	247	#define atomic_flag_clear(PTR) __atomic_clear ((PTR), __ATOMIC_SEQ_CST)
c29c36ad	248	extern void atomic_flag_clear_explicit (volatile atomic_flag *, memory_order);
39b2468c JM	249	#define atomic_flag_clear_explicit(PTR, MO) __atomic_clear ((PTR), (MO))
39b2468c JM	250
9a265c97 JM	251	#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
	252	#define __STDC_VERSION_STDATOMIC_H__ 202311L
	253	#endif
	254
39b2468c	255	#endif /* _STDATOMIC_H */