libplatform-254.40.4.tar.gz

[apple/libplatform.git] / include / libkern / OSAtomicDeprecated.h

/*
 * Copyright (c) 2004-2016 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#ifndef _OSATOMIC_DEPRECATED_H_
#define _OSATOMIC_DEPRECATED_H_

/*! @header
 * These are deprecated legacy interfaces for atomic operations.
 * The C11 interfaces in <stdatomic.h> resp. C++11 interfaces in <atomic>
 * should be used instead.
 *
 * Define OSATOMIC_USE_INLINED=1 to get inline implementations of these
 * interfaces in terms of the <stdatomic.h> resp. <atomic> primitives.
 * This is intended as a transition convenience, direct use of those primitives
 * is preferred.
 */

#include    <Availability.h>

#if !(defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED)

#include    <sys/cdefs.h>
#include    <stddef.h>
#include    <stdint.h>
#include    <stdbool.h>

#ifndef OSATOMIC_DEPRECATED
#define OSATOMIC_DEPRECATED 1
#ifndef __cplusplus
#define OSATOMIC_BARRIER_DEPRECATED_MSG(_r) \
                "Use " #_r "() from <stdatomic.h> instead"
#define OSATOMIC_DEPRECATED_MSG(_r) \
                "Use " #_r "_explicit(memory_order_relaxed) from <stdatomic.h> instead"
#else
#define OSATOMIC_BARRIER_DEPRECATED_MSG(_r) \
                "Use std::" #_r "() from <atomic> instead"
#define OSATOMIC_DEPRECATED_MSG(_r) \
                "Use std::" #_r "_explicit(std::memory_order_relaxed) from <atomic> instead"
#endif
#define OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(_r) \
        __OS_AVAILABILITY_MSG(macosx, deprecated=10.12, OSATOMIC_BARRIER_DEPRECATED_MSG(_r)) \
        __OS_AVAILABILITY_MSG(ios, deprecated=10.0, OSATOMIC_BARRIER_DEPRECATED_MSG(_r)) \
        __OS_AVAILABILITY_MSG(tvos, deprecated=10.0, OSATOMIC_BARRIER_DEPRECATED_MSG(_r)) \
        __OS_AVAILABILITY_MSG(watchos, deprecated=3.0, OSATOMIC_BARRIER_DEPRECATED_MSG(_r))
#define OSATOMIC_DEPRECATED_REPLACE_WITH(_r) \
        __OS_AVAILABILITY_MSG(macosx, deprecated=10.12, OSATOMIC_DEPRECATED_MSG(_r)) \
        __OS_AVAILABILITY_MSG(ios, deprecated=10.0, OSATOMIC_DEPRECATED_MSG(_r)) \
        __OS_AVAILABILITY_MSG(tvos, deprecated=10.0, OSATOMIC_DEPRECATED_MSG(_r)) \
        __OS_AVAILABILITY_MSG(watchos, deprecated=3.0, OSATOMIC_DEPRECATED_MSG(_r))
#else
#undef OSATOMIC_DEPRECATED
#define OSATOMIC_DEPRECATED 0
#define OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(_r)
#define OSATOMIC_DEPRECATED_REPLACE_WITH(_r)
#endif

/*
 * WARNING: all addresses passed to these functions must be "naturally aligned",
 * i.e. <code>int32_t</code> pointers must be 32-bit aligned (low 2 bits of
 * address are zeroes), and <code>int64_t</code> pointers must be 64-bit
 * aligned (low 3 bits of address are zeroes.).
 * Note that this is not the default alignment of the <code>int64_t</code> type
 * in the iOS ARMv7 ABI, see
 * {@link //apple_ref/doc/uid/TP40009021-SW8 iPhoneOSABIReference}
 *
 * Note that some versions of the atomic functions incorporate memory barriers
 * and some do not.  Barriers strictly order memory access on weakly-ordered
 * architectures such as ARM.  All loads and stores that appear (in sequential
 * program order) before the barrier are guaranteed to complete before any
 * load or store that appears after the barrier.
 *
 * The barrier operation is typically a no-op on uniprocessor systems and
 * fully enabled on multiprocessor systems. On some platforms, such as ARM,
 * the barrier can be quite expensive.
 *
 * Most code should use the barrier functions to ensure that memory shared
 * between threads is properly synchronized.  For example, if you want to
 * initialize a shared data structure and then atomically increment a variable
 * to indicate that the initialization is complete, you must use
 * {@link OSAtomicIncrement32Barrier} to ensure that the stores to your data
 * structure complete before the atomic increment.
 *
 * Likewise, the consumer of that data structure must use
 * {@link OSAtomicDecrement32Barrier},
 * in order to ensure that their loads of the structure are not executed before
 * the atomic decrement.  On the other hand, if you are simply incrementing a
 * global counter, then it is safe and potentially faster to use
 * {@link OSAtomicIncrement32}.
 *
 * If you are unsure which version to use, prefer the barrier variants as they
 * are safer.
 *
 * For the kernel-space version of this header, see
 * {@link //apple_ref/doc/header/OSAtomic.h OSAtomic.h (Kernel Framework)}
 *
 * @apiuid //apple_ref/doc/header/user_space_OSAtomic.h
 */

__BEGIN_DECLS

/*! @typedef OSAtomic_int64_aligned64_t
 * 64-bit aligned <code>int64_t</code> type.
 * Use for variables whose addresses are passed to OSAtomic*64() functions to
 * get the compiler to generate the required alignment.
 */

#if __has_attribute(aligned)
typedef int64_t __attribute__((__aligned__((sizeof(int64_t)))))
                OSAtomic_int64_aligned64_t;
#else
typedef int64_t OSAtomic_int64_aligned64_t;
#endif

/*! @group Arithmetic functions
    All functions in this group return the new value.
 */

/*! @abstract Atomically adds two 32-bit values.
    @discussion
        This function adds the value given by <code>__theAmount</code> to the
        value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int32_t OSAtomicAdd32( int32_t __theAmount, volatile int32_t *__theValue );


/*! @abstract Atomically adds two 32-bit values.
    @discussion
        This function adds the value given by <code>__theAmount</code> to the
        value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.

        This function is equivalent to {@link OSAtomicAdd32}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int32_t OSAtomicAdd32Barrier( int32_t __theAmount, volatile int32_t *__theValue );


#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1 || TARGET_OS_DRIVERKIT

/*! @abstract Atomically increments a 32-bit value.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
int32_t OSAtomicIncrement32( volatile int32_t *__theValue );


/*! @abstract Atomically increments a 32-bit value with a barrier.
    @discussion
        This function is equivalent to {@link OSAtomicIncrement32}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
int32_t OSAtomicIncrement32Barrier( volatile int32_t *__theValue );


/*! @abstract Atomically decrements a 32-bit value.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_sub)
__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
int32_t OSAtomicDecrement32( volatile int32_t *__theValue );


/*! @abstract Atomically decrements a 32-bit value with a barrier.
    @discussion
        This function is equivalent to {@link OSAtomicDecrement32}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_sub)
__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
int32_t OSAtomicDecrement32Barrier( volatile int32_t *__theValue );

#else
__inline static
int32_t OSAtomicIncrement32( volatile int32_t *__theValue )
            { return OSAtomicAdd32(  1, __theValue); }

__inline static
int32_t OSAtomicIncrement32Barrier( volatile int32_t *__theValue )
            { return OSAtomicAdd32Barrier(  1, __theValue); }

__inline static
int32_t OSAtomicDecrement32( volatile int32_t *__theValue )
            { return OSAtomicAdd32( -1, __theValue); }

__inline static
int32_t OSAtomicDecrement32Barrier( volatile int32_t *__theValue )
            { return OSAtomicAdd32Barrier( -1, __theValue); }
#endif


/*! @abstract Atomically adds two 64-bit values.
    @discussion
        This function adds the value given by <code>__theAmount</code> to the
        value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int64_t OSAtomicAdd64( int64_t __theAmount,
                volatile OSAtomic_int64_aligned64_t *__theValue );


/*! @abstract Atomically adds two 64-bit values with a barrier.
    @discussion
        This function adds the value given by <code>__theAmount</code> to the
        value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.

        This function is equivalent to {@link OSAtomicAdd64}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_3_2)
int64_t OSAtomicAdd64Barrier( int64_t __theAmount,
                volatile OSAtomic_int64_aligned64_t *__theValue );


#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1 || TARGET_OS_DRIVERKIT

/*! @abstract Atomically increments a 64-bit value.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
int64_t OSAtomicIncrement64( volatile OSAtomic_int64_aligned64_t *__theValue );


/*! @abstract Atomically increments a 64-bit value with a barrier.
    @discussion
        This function is equivalent to {@link OSAtomicIncrement64}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
int64_t OSAtomicIncrement64Barrier( volatile OSAtomic_int64_aligned64_t *__theValue );


/*! @abstract Atomically decrements a 64-bit value.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_sub)
__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
int64_t OSAtomicDecrement64( volatile OSAtomic_int64_aligned64_t *__theValue );


/*! @abstract Atomically decrements a 64-bit value with a barrier.
    @discussion
        This function is equivalent to {@link OSAtomicDecrement64}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_sub)
__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
int64_t OSAtomicDecrement64Barrier( volatile OSAtomic_int64_aligned64_t *__theValue );

#else
__inline static
int64_t OSAtomicIncrement64( volatile OSAtomic_int64_aligned64_t *__theValue )
            { return OSAtomicAdd64(  1, __theValue); }

__inline static
int64_t OSAtomicIncrement64Barrier( volatile OSAtomic_int64_aligned64_t *__theValue )
            { return OSAtomicAdd64Barrier(  1, __theValue); }

__inline static
int64_t OSAtomicDecrement64( volatile OSAtomic_int64_aligned64_t *__theValue )
            { return OSAtomicAdd64( -1, __theValue); }

__inline static
int64_t OSAtomicDecrement64Barrier( volatile OSAtomic_int64_aligned64_t *__theValue )
            { return OSAtomicAdd64Barrier( -1, __theValue); }
#endif


/*! @group Boolean functions (AND, OR, XOR)
 *
 * @discussion Functions in this group come in four variants for each operation:
 * with and without barriers, and functions that return the original value or
 * the result value of the operation.
 *
 * The "Orig" versions return the original value, (before the operation); the non-Orig
 * versions return the value after the operation.  All are layered on top of
 * {@link OSAtomicCompareAndSwap32} and similar.
 */

/*! @abstract Atomic bitwise OR of two 32-bit values.
    @discussion
        This function performs the bitwise OR of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int32_t OSAtomicOr32( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise OR of two 32-bit values with barrier.
    @discussion
        This function performs the bitwise OR of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.

        This function is equivalent to {@link OSAtomicOr32}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int32_t OSAtomicOr32Barrier( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise OR of two 32-bit values returning original.
    @discussion
        This function performs the bitwise OR of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.
    @result Returns the original value referenced by <code>__theValue</code>.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
int32_t OSAtomicOr32Orig( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise OR of two 32-bit values returning original with barrier.
    @discussion
        This function performs the bitwise OR of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.

        This function is equivalent to {@link OSAtomicOr32Orig}
        except that it also introduces a barrier.
    @result Returns the original value referenced by <code>__theValue</code>.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
int32_t OSAtomicOr32OrigBarrier( uint32_t __theMask, volatile uint32_t *__theValue );




/*! @abstract Atomic bitwise AND of two 32-bit values.
    @discussion
        This function performs the bitwise AND of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int32_t OSAtomicAnd32( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise AND of two 32-bit values with barrier.
    @discussion
        This function performs the bitwise AND of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.

        This function is equivalent to {@link OSAtomicAnd32}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int32_t OSAtomicAnd32Barrier( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise AND of two 32-bit values returning original.
    @discussion
        This function performs the bitwise AND of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.
    @result Returns the original value referenced by <code>__theValue</code>.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
int32_t OSAtomicAnd32Orig( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise AND of two 32-bit values returning original with barrier.
    @discussion
        This function performs the bitwise AND of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.

        This function is equivalent to {@link OSAtomicAnd32Orig}
        except that it also introduces a barrier.
    @result Returns the original value referenced by <code>__theValue</code>.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
int32_t OSAtomicAnd32OrigBarrier( uint32_t __theMask, volatile uint32_t *__theValue );




/*! @abstract Atomic bitwise XOR of two 32-bit values.
    @discussion
        This function performs the bitwise XOR of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.
    @result Returns the new value.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int32_t OSAtomicXor32( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise XOR of two 32-bit values with barrier.
    @discussion
        This function performs the bitwise XOR of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.

        This function is equivalent to {@link OSAtomicXor32}
        except that it also introduces a barrier.
    @result Returns the new value.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
int32_t OSAtomicXor32Barrier( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise XOR of two 32-bit values returning original.
    @discussion
        This function performs the bitwise XOR of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.
    @result Returns the original value referenced by <code>__theValue</code>.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
int32_t OSAtomicXor32Orig( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @abstract Atomic bitwise XOR of two 32-bit values returning original with barrier.
    @discussion
        This function performs the bitwise XOR of the value given by <code>__theMask</code>
        with the value in the memory location referenced by <code>__theValue</code>,
        storing the result back to that memory location atomically.

        This function is equivalent to {@link OSAtomicXor32Orig}
        except that it also introduces a barrier.
    @result Returns the original value referenced by <code>__theValue</code>.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
int32_t OSAtomicXor32OrigBarrier( uint32_t __theMask, volatile uint32_t *__theValue );


/*! @group Compare and swap
 * Functions in this group return true if the swap occured.  There are several versions,
 * depending on data type and on whether or not a barrier is used.
 */


/*! @abstract Compare and swap for 32-bit values.
    @discussion
        This function compares the value in <code>__oldValue</code> to the value
        in the memory location referenced by <code>__theValue</code>.  If the values
        match, this function stores the value from <code>__newValue</code> into
        that memory location atomically.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
bool    OSAtomicCompareAndSwap32( int32_t __oldValue, int32_t __newValue, volatile int32_t *__theValue );


/*! @abstract Compare and swap for 32-bit values with barrier.
    @discussion
        This function compares the value in <code>__oldValue</code> to the value
        in the memory location referenced by <code>__theValue</code>.  If the values
        match, this function stores the value from <code>__newValue</code> into
        that memory location atomically.

        This function is equivalent to {@link OSAtomicCompareAndSwap32}
        except that it also introduces a barrier.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
bool    OSAtomicCompareAndSwap32Barrier( int32_t __oldValue, int32_t __newValue, volatile int32_t *__theValue );


/*! @abstract Compare and swap pointers.
    @discussion
        This function compares the pointer stored in <code>__oldValue</code> to the pointer
        in the memory location referenced by <code>__theValue</code>.  If the pointers
        match, this function stores the pointer from <code>__newValue</code> into
        that memory location atomically.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
bool    OSAtomicCompareAndSwapPtr( void *__oldValue, void *__newValue, void * volatile *__theValue );


/*! @abstract Compare and swap pointers with barrier.
    @discussion
        This function compares the pointer stored in <code>__oldValue</code> to the pointer
        in the memory location referenced by <code>__theValue</code>.  If the pointers
        match, this function stores the pointer from <code>__newValue</code> into
        that memory location atomically.

        This function is equivalent to {@link OSAtomicCompareAndSwapPtr}
        except that it also introduces a barrier.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
bool    OSAtomicCompareAndSwapPtrBarrier( void *__oldValue, void *__newValue, void * volatile *__theValue );


/*! @abstract Compare and swap for <code>int</code> values.
    @discussion
        This function compares the value in <code>__oldValue</code> to the value
        in the memory location referenced by <code>__theValue</code>.  If the values
        match, this function stores the value from <code>__newValue</code> into
        that memory location atomically.

        This function is equivalent to {@link OSAtomicCompareAndSwap32}.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
bool    OSAtomicCompareAndSwapInt( int __oldValue, int __newValue, volatile int *__theValue );


/*! @abstract Compare and swap for <code>int</code> values.
    @discussion
        This function compares the value in <code>__oldValue</code> to the value
        in the memory location referenced by <code>__theValue</code>.  If the values
        match, this function stores the value from <code>__newValue</code> into
        that memory location atomically.

        This function is equivalent to {@link OSAtomicCompareAndSwapInt}
        except that it also introduces a barrier.

        This function is equivalent to {@link OSAtomicCompareAndSwap32Barrier}.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
bool    OSAtomicCompareAndSwapIntBarrier( int __oldValue, int __newValue, volatile int *__theValue );


/*! @abstract Compare and swap for <code>long</code> values.
    @discussion
        This function compares the value in <code>__oldValue</code> to the value
        in the memory location referenced by <code>__theValue</code>.  If the values
        match, this function stores the value from <code>__newValue</code> into
        that memory location atomically.

        This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures,
        or {@link OSAtomicCompareAndSwap64} on 64-bit architectures.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
bool    OSAtomicCompareAndSwapLong( long __oldValue, long __newValue, volatile long *__theValue );


/*! @abstract Compare and swap for <code>long</code> values.
    @discussion
        This function compares the value in <code>__oldValue</code> to the value
        in the memory location referenced by <code>__theValue</code>.  If the values
        match, this function stores the value from <code>__newValue</code> into
        that memory location atomically.

        This function is equivalent to {@link OSAtomicCompareAndSwapLong}
        except that it also introduces a barrier.

        This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures,
        or {@link OSAtomicCompareAndSwap64} on 64-bit architectures.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
bool    OSAtomicCompareAndSwapLongBarrier( long __oldValue, long __newValue, volatile long *__theValue );


/*! @abstract Compare and swap for <code>uint64_t</code> values.
    @discussion
        This function compares the value in <code>__oldValue</code> to the value
        in the memory location referenced by <code>__theValue</code>.  If the values
        match, this function stores the value from <code>__newValue</code> into
        that memory location atomically.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
bool    OSAtomicCompareAndSwap64( int64_t __oldValue, int64_t __newValue,
                volatile OSAtomic_int64_aligned64_t *__theValue );


/*! @abstract Compare and swap for <code>uint64_t</code> values.
    @discussion
        This function compares the value in <code>__oldValue</code> to the value
        in the memory location referenced by <code>__theValue</code>.  If the values
        match, this function stores the value from <code>__newValue</code> into
        that memory location atomically.

        This function is equivalent to {@link OSAtomicCompareAndSwap64}
        except that it also introduces a barrier.
    @result Returns TRUE on a match, FALSE otherwise.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_3_2)
bool    OSAtomicCompareAndSwap64Barrier( int64_t __oldValue, int64_t __newValue,
                volatile OSAtomic_int64_aligned64_t *__theValue );


/* Test and set.
 * They return the original value of the bit, and operate on bit (0x80>>(n&7))
 * in byte ((char*)theAddress + (n>>3)).
 */
/*! @abstract Atomic test and set
    @discussion
        This function tests a bit in the value referenced by
        <code>__theAddress</code> and if it is not set, sets it.

        The bit is chosen by the value of <code>__n</code> such that the
        operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
        of byte <code>((char *)__theAddress + (n >> 3))</code>.

        For example, if <code>__theAddress</code> points to a 64-bit value,
        to compare the value of the most significant bit, you would specify
        <code>56</code> for <code>__n</code>.
    @result
        Returns the original value of the bit being tested.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
bool    OSAtomicTestAndSet( uint32_t __n, volatile void *__theAddress );


/*! @abstract Atomic test and set with barrier
    @discussion
        This function tests a bit in the value referenced by <code>__theAddress</code>
        and if it is not set, sets it.

        The bit is chosen by the value of <code>__n</code> such that the
        operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
        of byte <code>((char *)__theAddress + (n >> 3))</code>.

        For example, if <code>__theAddress</code> points to a 64-bit value,
        to compare the value of the most significant bit, you would specify
        <code>56</code> for <code>__n</code>.

        This function is equivalent to {@link OSAtomicTestAndSet}
        except that it also introduces a barrier.
    @result
        Returns the original value of the bit being tested.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
bool    OSAtomicTestAndSetBarrier( uint32_t __n, volatile void *__theAddress );



/*! @abstract Atomic test and clear
    @discussion
        This function tests a bit in the value referenced by <code>__theAddress</code>
        and if it is not cleared, clears it.

        The bit is chosen by the value of <code>__n</code> such that the
        operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
        of byte <code>((char *)__theAddress + (n >> 3))</code>.

        For example, if <code>__theAddress</code> points to a 64-bit value,
        to compare the value of the most significant bit, you would specify
        <code>56</code> for <code>__n</code>.

    @result
        Returns the original value of the bit being tested.
 */
OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
bool    OSAtomicTestAndClear( uint32_t __n, volatile void *__theAddress );


/*! @abstract Atomic test and clear
    @discussion
        This function tests a bit in the value referenced by <code>__theAddress</code>
        and if it is not cleared, clears it.

        The bit is chosen by the value of <code>__n</code> such that the
        operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
        of byte <code>((char *)__theAddress + (n >> 3))</code>.

        For example, if <code>__theAddress</code> points to a 64-bit value,
        to compare the value of the most significant bit, you would specify
        <code>56</code> for <code>__n</code>.

        This function is equivalent to {@link OSAtomicTestAndSet}
        except that it also introduces a barrier.
    @result
        Returns the original value of the bit being tested.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
bool    OSAtomicTestAndClearBarrier( uint32_t __n, volatile void *__theAddress );


/*! @group Memory barriers */

/*! @abstract Memory barrier.
    @discussion
        This function serves as both a read and write barrier.
 */
OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_thread_fence)
__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
void    OSMemoryBarrier( void );

__END_DECLS

#else // defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED

/*
 * Inline implementations of the legacy OSAtomic interfaces in terms of
 * C11 <stdatomic.h> resp. C++11 <atomic> primitives.
 * Direct use of those primitives is preferred.
 */

#include <sys/cdefs.h>

#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C++" {
#if !(__has_include(<atomic>) && __has_extension(cxx_atomic))
#error Cannot use inlined OSAtomic without <atomic> and C++11 atomics
#endif
#include <atomic>
typedef std::atomic<uint8_t> _OSAtomic_uint8_t;
typedef std::atomic<int32_t> _OSAtomic_int32_t;
typedef std::atomic<uint32_t> _OSAtomic_uint32_t;
typedef std::atomic<int64_t> _OSAtomic_int64_t;
typedef std::atomic<void*> _OSAtomic_void_ptr_t;
#define OSATOMIC_STD(_a) std::_a
__BEGIN_DECLS
#else
#if !(__has_include(<stdatomic.h>) && __has_extension(c_atomic))
#error Cannot use inlined OSAtomic without <stdatomic.h> and C11 atomics
#endif
#include <stdatomic.h>
typedef _Atomic(uint8_t) _OSAtomic_uint8_t;
typedef _Atomic(int32_t) _OSAtomic_int32_t;
typedef _Atomic(uint32_t) _OSAtomic_uint32_t;
typedef _Atomic(int64_t) _OSAtomic_int64_t;
typedef _Atomic(void*) _OSAtomic_void_ptr_t;
#define OSATOMIC_STD(_a) _a
#endif

#if __has_extension(c_alignof) && __has_attribute(aligned)
typedef int64_t __attribute__((__aligned__(_Alignof(_OSAtomic_int64_t))))
                OSAtomic_int64_aligned64_t;
#elif __has_attribute(aligned)
typedef int64_t __attribute__((__aligned__((sizeof(_OSAtomic_int64_t)))))
                OSAtomic_int64_aligned64_t;
#else
typedef int64_t OSAtomic_int64_aligned64_t;
#endif

#if __has_attribute(always_inline)
#define OSATOMIC_INLINE static __inline __attribute__((__always_inline__))
#else
#define OSATOMIC_INLINE static __inline
#endif

OSATOMIC_INLINE
int32_t
OSAtomicAdd32(int32_t __theAmount, volatile int32_t *__theValue)
{
        return (OSATOMIC_STD(atomic_fetch_add_explicit)(
                        (volatile _OSAtomic_int32_t*) __theValue, __theAmount,
                        OSATOMIC_STD(memory_order_relaxed)) + __theAmount);
}

OSATOMIC_INLINE
int32_t
OSAtomicAdd32Barrier(int32_t __theAmount, volatile int32_t *__theValue)
{
        return (OSATOMIC_STD(atomic_fetch_add_explicit)(
                        (volatile _OSAtomic_int32_t*) __theValue, __theAmount,
                        OSATOMIC_STD(memory_order_seq_cst)) + __theAmount);
}

OSATOMIC_INLINE
int32_t
OSAtomicIncrement32(volatile int32_t *__theValue)
{
        return OSAtomicAdd32(1, __theValue);
}

OSATOMIC_INLINE
int32_t
OSAtomicIncrement32Barrier(volatile int32_t *__theValue)
{
        return OSAtomicAdd32Barrier(1, __theValue);
}

OSATOMIC_INLINE
int32_t
OSAtomicDecrement32(volatile int32_t *__theValue)
{
        return OSAtomicAdd32(-1, __theValue);
}

OSATOMIC_INLINE
int32_t
OSAtomicDecrement32Barrier(volatile int32_t *__theValue)
{
        return OSAtomicAdd32Barrier(-1, __theValue);
}

OSATOMIC_INLINE
int64_t
OSAtomicAdd64(int64_t __theAmount,
                volatile OSAtomic_int64_aligned64_t *__theValue)
{
        return (OSATOMIC_STD(atomic_fetch_add_explicit)(
                        (volatile _OSAtomic_int64_t*) __theValue, __theAmount,
                        OSATOMIC_STD(memory_order_relaxed)) + __theAmount);
}

OSATOMIC_INLINE
int64_t
OSAtomicAdd64Barrier(int64_t __theAmount,
                volatile OSAtomic_int64_aligned64_t *__theValue)
{
        return (OSATOMIC_STD(atomic_fetch_add_explicit)(
                        (volatile _OSAtomic_int64_t*) __theValue, __theAmount,
                        OSATOMIC_STD(memory_order_seq_cst)) + __theAmount);
}

OSATOMIC_INLINE
int64_t
OSAtomicIncrement64(volatile OSAtomic_int64_aligned64_t *__theValue)
{
        return OSAtomicAdd64(1, __theValue);
}

OSATOMIC_INLINE
int64_t
OSAtomicIncrement64Barrier(volatile OSAtomic_int64_aligned64_t *__theValue)
{
        return OSAtomicAdd64Barrier(1, __theValue);
}

OSATOMIC_INLINE
int64_t
OSAtomicDecrement64(volatile OSAtomic_int64_aligned64_t *__theValue)
{
        return OSAtomicAdd64(-1, __theValue);
}

OSATOMIC_INLINE
int64_t
OSAtomicDecrement64Barrier(volatile OSAtomic_int64_aligned64_t *__theValue)
{
        return OSAtomicAdd64Barrier(-1, __theValue);
}

OSATOMIC_INLINE
int32_t
OSAtomicOr32(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_or_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_relaxed)) | __theMask);
}

OSATOMIC_INLINE
int32_t
OSAtomicOr32Barrier(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_or_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_seq_cst)) | __theMask);
}

OSATOMIC_INLINE
int32_t
OSAtomicOr32Orig(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_or_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
int32_t
OSAtomicOr32OrigBarrier(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_or_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_seq_cst)));
}

OSATOMIC_INLINE
int32_t
OSAtomicAnd32(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_and_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_relaxed)) & __theMask);
}

OSATOMIC_INLINE
int32_t
OSAtomicAnd32Barrier(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_and_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_seq_cst)) & __theMask);
}

OSATOMIC_INLINE
int32_t
OSAtomicAnd32Orig(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_and_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
int32_t
OSAtomicAnd32OrigBarrier(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_and_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_seq_cst)));
}

OSATOMIC_INLINE
int32_t
OSAtomicXor32(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_xor_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_relaxed)) ^ __theMask);
}

OSATOMIC_INLINE
int32_t
OSAtomicXor32Barrier(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_xor_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_seq_cst)) ^ __theMask);
}

OSATOMIC_INLINE
int32_t
OSAtomicXor32Orig(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_xor_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
int32_t
OSAtomicXor32OrigBarrier(uint32_t __theMask, volatile uint32_t *__theValue)
{
        return (int32_t)(OSATOMIC_STD(atomic_fetch_xor_explicit)(
                        (volatile _OSAtomic_uint32_t*)__theValue, __theMask,
                        OSATOMIC_STD(memory_order_seq_cst)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwap32(int32_t __oldValue, int32_t __newValue,
                volatile int32_t *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile _OSAtomic_int32_t*)__theValue, &__oldValue, __newValue,
                        OSATOMIC_STD(memory_order_relaxed),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwap32Barrier(int32_t __oldValue, int32_t __newValue,
                volatile int32_t *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile _OSAtomic_int32_t*)__theValue, &__oldValue, __newValue,
                        OSATOMIC_STD(memory_order_seq_cst),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwapPtr(void *__oldValue, void *__newValue,
                void * volatile *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile _OSAtomic_void_ptr_t*)__theValue, &__oldValue, __newValue,
                        OSATOMIC_STD(memory_order_relaxed),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwapPtrBarrier(void *__oldValue, void *__newValue,
                void * volatile *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile _OSAtomic_void_ptr_t*)__theValue, &__oldValue, __newValue,
                        OSATOMIC_STD(memory_order_seq_cst),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwapInt(int __oldValue, int __newValue,
                volatile int *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile OSATOMIC_STD(atomic_int)*)__theValue, &__oldValue,
                        __newValue, OSATOMIC_STD(memory_order_relaxed),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwapIntBarrier(int __oldValue, int __newValue,
                volatile int *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile OSATOMIC_STD(atomic_int)*)__theValue, &__oldValue,
                        __newValue, OSATOMIC_STD(memory_order_seq_cst),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwapLong(long __oldValue, long __newValue,
                volatile long *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile OSATOMIC_STD(atomic_long)*)__theValue, &__oldValue,
                        __newValue, OSATOMIC_STD(memory_order_relaxed),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwapLongBarrier(long __oldValue, long __newValue,
                volatile long *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile OSATOMIC_STD(atomic_long)*)__theValue, &__oldValue,
                        __newValue, OSATOMIC_STD(memory_order_seq_cst),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwap64(int64_t __oldValue, int64_t __newValue,
                volatile OSAtomic_int64_aligned64_t *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile _OSAtomic_int64_t*)__theValue, &__oldValue, __newValue,
                        OSATOMIC_STD(memory_order_relaxed),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicCompareAndSwap64Barrier(int64_t __oldValue, int64_t __newValue,
                volatile OSAtomic_int64_aligned64_t *__theValue)
{
        return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
                        (volatile _OSAtomic_int64_t*)__theValue, &__oldValue, __newValue,
                        OSATOMIC_STD(memory_order_seq_cst),
                        OSATOMIC_STD(memory_order_relaxed)));
}

OSATOMIC_INLINE
bool
OSAtomicTestAndSet(uint32_t __n, volatile void *__theAddress)
{
        uintptr_t a = (uintptr_t)__theAddress + (__n >> 3);
        uint8_t v = (0x80u >> (__n & 7));
        return (OSATOMIC_STD(atomic_fetch_or_explicit)((_OSAtomic_uint8_t*)a, v,
                        OSATOMIC_STD(memory_order_relaxed)) & v);
}

OSATOMIC_INLINE
bool
OSAtomicTestAndSetBarrier(uint32_t __n, volatile void *__theAddress)
{
        uintptr_t a = (uintptr_t)__theAddress + (__n >> 3);
        uint8_t v = (0x80u >> (__n & 7));
        return (OSATOMIC_STD(atomic_fetch_or_explicit)((_OSAtomic_uint8_t*)a, v,
                        OSATOMIC_STD(memory_order_seq_cst)) & v);
}

OSATOMIC_INLINE
bool
OSAtomicTestAndClear(uint32_t __n, volatile void *__theAddress)
{
        uintptr_t a = (uintptr_t)__theAddress + (__n >> 3);
        uint8_t v = (0x80u >> (__n & 7));
        return (OSATOMIC_STD(atomic_fetch_and_explicit)((_OSAtomic_uint8_t*)a,
                        (uint8_t)~v, OSATOMIC_STD(memory_order_relaxed)) & v);
}

OSATOMIC_INLINE
bool
OSAtomicTestAndClearBarrier(uint32_t __n, volatile void *__theAddress)
{
        uintptr_t a = (uintptr_t)__theAddress + (__n >> 3);
        uint8_t v = (0x80u >> (__n & 7));
        return (OSATOMIC_STD(atomic_fetch_and_explicit)((_OSAtomic_uint8_t*)a,
                        (uint8_t)~v, OSATOMIC_STD(memory_order_seq_cst)) & v);
}

OSATOMIC_INLINE
void
OSMemoryBarrier(void)
{
        OSATOMIC_STD(atomic_thread_fence)(OSATOMIC_STD(memory_order_seq_cst));
}

#undef OSATOMIC_INLINE
#undef OSATOMIC_STD
#ifdef __cplusplus
__END_DECLS
} // extern "C++"
#endif

#endif // defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED

#if TARGET_OS_OSX || TARGET_OS_DRIVERKIT

__BEGIN_DECLS

/*! @group Lockless atomic fifo enqueue and dequeue
 * These routines manipulate singly-linked FIFO lists.
 *
 * This API is deprecated and no longer recommended
 */

/*! @abstract The data structure for a fifo queue head.
    @discussion
        You should always initialize a fifo queue head structure with the
        initialization vector {@link OS_ATOMIC_FIFO_QUEUE_INIT} before use.
 */
#if defined(__LP64__)

typedef volatile struct {
        void    *opaque1;
        void    *opaque2;
        int      opaque3;
} __attribute__ ((aligned (16))) OSFifoQueueHead;

#else

typedef volatile struct {
        void    *opaque1;
        void    *opaque2;
        int      opaque3;
} OSFifoQueueHead;

#endif
/*! @abstract The initialization vector for a fifo queue head. */
#define OS_ATOMIC_FIFO_QUEUE_INIT   { NULL, NULL, 0 }

/*! @abstract Enqueue an element onto a list.
    @discussion
        Memory barriers are incorporated as needed to permit thread-safe access
        to the queue element.
    @param __list
        The list on which you want to enqueue the element.
    @param __new
        The element to add.
    @param __offset
        The "offset" parameter is the offset (in bytes) of the link field
        from the beginning of the data structure being queued (<code>__new</code>).
        The link field should be a pointer type.
        The <code>__offset</code> value needs to be same for all enqueuing and
        dequeuing operations on the same list, even if different structure types
        are enqueued on that list.  The use of <code>offsetset()</code>, defined in
        <code>stddef.h</code> is the common way to specify the <code>__offset</code>
        value.

        @note
        This API is deprecated and no longer recommended
 */
__API_DEPRECATED("No longer supported", macos(10.7, 10.16))
void  OSAtomicFifoEnqueue( OSFifoQueueHead *__list, void *__new, size_t __offset);

/*! @abstract Dequeue an element from a list.
    @discussion
        Memory barriers are incorporated as needed to permit thread-safe access
        to the queue element.
    @param __list
        The list from which you want to dequeue an element.
    @param __offset
        The "offset" parameter is the offset (in bytes) of the link field
        from the beginning of the data structure being dequeued (<code>__new</code>).
        The link field should be a pointer type.
        The <code>__offset</code> value needs to be same for all enqueuing and
        dequeuing operations on the same list, even if different structure types
        are enqueued on that list.  The use of <code>offsetset()</code>, defined in
        <code>stddef.h</code> is the common way to specify the <code>__offset</code>
        value.
    @result
        Returns the oldest enqueued element, or <code>NULL</code> if the
        list is empty.

        @note
        This API is deprecated and no longer recommended
 */
__API_DEPRECATED("No longer supported", macos(10.7, 10.16))
void* OSAtomicFifoDequeue( OSFifoQueueHead *__list, size_t __offset);

__END_DECLS

#endif /* TARGET_OS_OSX || TARGET_OS_DRIVERKIT */

#endif /* _OSATOMIC_DEPRECATED_H_ */