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

/* Copyright (C) 2013-2014 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;
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;        


#define ATOMIC_VAR_INIT(VALUE)	(VALUE)
#define atomic_init(PTR, VAL)			\
  do						\
    {						\
      *(PTR) = (VAL);				\
    }						\
  while (0)

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

#define atomic_thread_fence(MO)	__atomic_thread_fence (MO)
#define atomic_signal_fence(MO)	__atomic_signal_fence  (MO)
#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ))

#define __atomic_type_lock_free(T)				\
  (__atomic_always_lock_free (sizeof (T), (void *) 0)		\
   ? 2								\
   : (__atomic_is_lock_free (sizeof (T), (void *) 0) ? 1 : 0))
#define ATOMIC_BOOL_LOCK_FREE			\
  __atomic_type_lock_free (atomic_bool)
#define ATOMIC_CHAR_LOCK_FREE			\
  __atomic_type_lock_free (atomic_char)
#define ATOMIC_CHAR16_T_LOCK_FREE		\
  __atomic_type_lock_free (atomic_char16_t)
#define ATOMIC_CHAR32_T_LOCK_FREE		\
  __atomic_type_lock_free (atomic_char32_t)
#define ATOMIC_WCHAR_T_LOCK_FREE		\
  __atomic_type_lock_free (atomic_wchar_t)
#define ATOMIC_SHORT_LOCK_FREE 			\
  __atomic_type_lock_free (atomic_short)
#define ATOMIC_INT_LOCK_FREE 			\
  __atomic_type_lock_free (atomic_int)
#define ATOMIC_LONG_LOCK_FREE			\
  __atomic_type_lock_free (atomic_long)
#define ATOMIC_LLONG_LOCK_FREE			\
  __atomic_type_lock_free (atomic_llong)
#define ATOMIC_POINTER_LOCK_FREE		\
  __atomic_type_lock_free (void * _Atomic)


/* Note that these macros require __typeof__ and __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__ (*__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__ (*__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__ (*__atomic_exchange_ptr) __atomic_exchange_val = (VAL);	\
    __typeof__ (*__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__ (*__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__ (*__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 }


#define atomic_flag_test_and_set(PTR) 					\
			__atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST)
#define atomic_flag_test_and_set_explicit(PTR, MO)			\
			__atomic_test_and_set ((PTR), (MO))

#define atomic_flag_clear(PTR)	__atomic_clear ((PTR), __ATOMIC_SEQ_CST)
#define atomic_flag_clear_explicit(PTR, MO)   __atomic_clear ((PTR), (MO))

#endif  /* _STDATOMIC_H */
Commit	Line	Data
23a5b65a	1	/* Copyright (C) 2013-2014 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;
	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	({ \
38b7bc7f	90	__auto_type __kill_dependency_tmp = (Y); \
39b2468c JM	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
38b7bc7f JM	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).
39b2468c JM	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
38b7bc7f JM	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)); \
39b2468c JM	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	({ \
38b7bc7f JM	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)); \
39b2468c JM	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	({ \
38b7bc7f JM	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, \
39b2468c JM	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	({ \
38b7bc7f JM	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), \
39b2468c JM	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	({ \
38b7bc7f JM	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), \
39b2468c JM	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
	232	typedef _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 */