compiler_gcc.h

// Copyright (c) Electronic Arts Inc. All rights reserved.
 
 
#ifndef EASTL_ATOMIC_INTERNAL_COMPILER_GCC_H
#define EASTL_ATOMIC_INTERNAL_COMPILER_GCC_H
 
#if defined(EA_PRAGMA_ONCE_SUPPORTED)
    #pragma once
#endif
 
 
#if 0
static_assert(__atomic_always_lock_free(1, 0), "eastl::atomic<T> where sizeof(T) == 1 must be lock-free!");
static_assert(__atomic_always_lock_free(2, 0), "eastl::atomic<T> where sizeof(T) == 2 must be lock-free!");
static_assert(__atomic_always_lock_free(4, 0), "eastl::atomic<T> where sizeof(T) == 4 must be lock-free!");
#endif
#if EA_PLATFORM_PTR_SIZE == 8
    static_assert(__atomic_always_lock_free(8, 0), "eastl::atomic<T> where sizeof(T) == 8 must be lock-free!");
#endif
 
 
 
#define EASTL_COMPILER_ATOMIC_HAS_8BIT
#define EASTL_COMPILER_ATOMIC_HAS_16BIT
#define EASTL_COMPILER_ATOMIC_HAS_32BIT
#define EASTL_COMPILER_ATOMIC_HAS_64BIT
 
#if EA_PLATFORM_PTR_SIZE == 8
    #define EASTL_COMPILER_ATOMIC_HAS_128BIT
#endif
 
 
 
 
#define EASTL_COMPILER_ATOMIC_FIXED_WIDTH_TYPE_8 uint8_t
#define EASTL_COMPILER_ATOMIC_FIXED_WIDTH_TYPE_16 uint16_t
#define EASTL_COMPILER_ATOMIC_FIXED_WIDTH_TYPE_32 uint32_t
#define EASTL_COMPILER_ATOMIC_FIXED_WIDTH_TYPE_64 uint64_t
#define EASTL_COMPILER_ATOMIC_FIXED_WIDTH_TYPE_128 __uint128_t
 
 
 
 
#define EASTL_GCC_ATOMIC_FETCH_INTRIN_N(integralType, fetchIntrinsic, type, ret, ptr, val, gccMemoryOrder) \
    {                                                                   \
        integralType retIntegral;                                       \
        integralType valIntegral = EASTL_ATOMIC_TYPE_PUN_CAST(integralType, (val)); \
                                                                        \
        retIntegral = fetchIntrinsic(EASTL_ATOMIC_VOLATILE_INTEGRAL_CAST(integralType, (ptr)), valIntegral, gccMemoryOrder); \
                                                                        \
        ret = EASTL_ATOMIC_TYPE_PUN_CAST(type, retIntegral);            \
    }
 
#define EASTL_GCC_ATOMIC_CMPXCHG_INTRIN_N(integralType, type, ret, ptr, expected, desired, weak, successOrder, failOrder) \
    ret = __atomic_compare_exchange(EASTL_ATOMIC_VOLATILE_INTEGRAL_CAST(integralType, (ptr)),                             \
                                    EASTL_ATOMIC_INTEGRAL_CAST(integralType, (expected)),                                 \
                                    EASTL_ATOMIC_INTEGRAL_CAST(integralType, &(desired)),                                 \
                                    weak, successOrder, failOrder)
 
#define EASTL_GCC_ATOMIC_EXCHANGE_INTRIN_N(integralType, type, ret, ptr, val, gccMemoryOrder) \
    {                                                                   \
        integralType retIntegral;                                       \
        integralType valIntegral = EASTL_ATOMIC_TYPE_PUN_CAST(integralType, (val)); \
                                                                        \
        __atomic_exchange(EASTL_ATOMIC_VOLATILE_INTEGRAL_CAST(integralType, (ptr)), \
                          &valIntegral, &retIntegral, gccMemoryOrder);  \
                                                                        \
        ret = EASTL_ATOMIC_TYPE_PUN_CAST(type, retIntegral);            \
    }
 
 
 
 
#include "compiler_gcc_fetch_add.h"
#include "compiler_gcc_fetch_sub.h"
 
#include "compiler_gcc_fetch_and.h"
#include "compiler_gcc_fetch_xor.h"
#include "compiler_gcc_fetch_or.h"
 
#include "compiler_gcc_add_fetch.h"
#include "compiler_gcc_sub_fetch.h"
 
#include "compiler_gcc_and_fetch.h"
#include "compiler_gcc_xor_fetch.h"
#include "compiler_gcc_or_fetch.h"
 
#include "compiler_gcc_exchange.h"
 
#include "compiler_gcc_cmpxchg_weak.h"
#include "compiler_gcc_cmpxchg_strong.h"
 
#include "compiler_gcc_load.h"
#include "compiler_gcc_store.h"
 
#include "compiler_gcc_barrier.h"
 
#include "compiler_gcc_cpu_pause.h"
 
#include "compiler_gcc_signal_fence.h"
 
#include "compiler_gcc_thread_fence.h"
 
 
#endif /* EASTL_ATOMIC_INTERNAL_COMPILER_GCC_H */