#include "shell/sys/linux/vsf_linux_cfg.h"
#include "../sys/types.h"
#include "hal/arch/vsf_arch.h"

Macros
#define	ATOMIC_VAR_INIT(__VALUE) (__VALUE)

#define	atomic_init(object, value) atomic_store_explicit(object, value, memory_order_relaxed)

#define	atomic_store_explicit(object, desired, order)

#define	atomic_store(object, desired) atomic_store_explicit(object, desired, memory_order_seq_cst)

#define	atomic_load_explicit(object, order)

#define	atomic_load(object) atomic_load_explicit(object, memory_order_seq_cst)

#define	atomic_exchange_explicit(object, desired, order)

#define	atomic_exchange(object, desired) atomic_exchange_explicit(object, desired, memory_order_seq_cst)

#define	atomic_compare_exchange_strong_explicit(object, expected, desired, order_success, order_fail)

#define	atomic_compare_exchange_strong(object, expected, desired) atomic_compare_exchange_strong_explicit(object, expected, desired, memory_order_seq_cst, memory_order_seq_cst)

#define	atomic_compare_exchange_weak_explicit(object, expected, desired, order_success, order_fail)

#define	atomic_compare_exchange_weak(object, expected, desired) atomic_compare_exchange_weak_explicit(object, expected, desired, memory_order_seq_cst, memory_order_seq_cst)

#define	atomic_fetch_add_explicit(object, operand, order)

#define	atomic_fetch_add(object, operand) atomic_fetch_add_explicit(object, operand, memory_order_seq_cst)

#define	atomic_fetch_sub_explicit(object, operand, order)

#define	atomic_fetch_sub(object, operand) atomic_fetch_sub_explicit(object, operand, memory_order_seq_cst)

#define	atomic_fetch_or_explicit(object, operand, order)

#define	atomic_fetch_or(object, operand) atomic_fetch_or_explicit(object, operand, memory_order_seq_cst)

#define	atomic_fetch_xor_explicit(object, operand, order)

#define	atomic_fetch_xor(object, operand) atomic_fetch_xor_explicit(object, operand, memory_order_seq_cst)

#define	atomic_fetch_and_explicit(object, operand, order)

#define	atomic_fetch_and(object, operand) atomic_fetch_and_explicit(object, operand, memory_order_seq_cst)

Typedefs
typedef bool	atomic_bool

typedef char	atomic_char

typedef signed char	atomic_schar

typedef unsigned char	atomic_uchar

typedef short	atomic_short

typedef unsigned short	atomic_ushort

typedef int	atomic_int

typedef unsigned int	atomic_uint

typedef long	atomic_long

typedef unsigned long	atomic_ulong

typedef long long	atomic_llong

typedef unsigned long long	atomic_ullong

typedef uint_least16_t	atomic_char16_t

typedef uint_least32_t	atomic_char32_t

typedef wchar_t	atomic_wchar_t

typedef int_least8_t	atomic_int_least8_t

typedef uint_least8_t	atomic_uint_least8_t

typedef int_least16_t	atomic_int_least16_t

typedef uint_least16_t	atomic_uint_least16_t

typedef int_least32_t	atomic_int_least32_t

typedef uint_least32_t	atomic_uint_least32_t

typedef int_least64_t	atomic_int_least64_t

typedef uint_least64_t	atomic_uint_least64_t

typedef int_fast8_t	atomic_int_fast8_t

typedef uint_fast8_t	atomic_uint_fast8_t

typedef int_fast16_t	atomic_int_fast16_t

typedef uint_fast16_t	atomic_uint_fast16_t

typedef int_fast32_t	atomic_int_fast32_t

typedef uint_fast32_t	atomic_uint_fast32_t

typedef int_fast64_t	atomic_int_fast64_t

typedef uint_fast64_t	atomic_uint_fast64_t

typedef intptr_t	atomic_intptr_t

typedef uintptr_t	atomic_uintptr_t

typedef size_t	atomic_size_t

typedef ptrdiff_t	atomic_ptrdiff_t

typedef intmax_t	atomic_intmax_t

typedef uintmax_t	atomic_uintmax_t

Enumerations
enum	memory_order { memory_order_relaxed , memory_order_consume , memory_order_acquire , memory_order_release , memory_order_acq_rel , memory_order_seq_cst }

Macro Definition Documentation

◆ ATOMIC_VAR_INIT

#define ATOMIC_VAR_INIT ( __VALUE ) (__VALUE)

◆ atomic_init

#define atomic_init	(	object,
		value
	)	atomic_store_explicit(object, value, memory_order_relaxed)

◆ atomic_store_explicit

#define atomic_store_explicit	(	object,
		desired,
		order
	)

Value:

            ({                                                                  \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    *(object) = desired;                                        \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
            })

◆ atomic_store

#define atomic_store	(	object,
		desired
	)	atomic_store_explicit(object, desired, memory_order_seq_cst)

◆ atomic_load_explicit

#define atomic_load_explicit	(	object,
		order
	)

Value:

            ({                                                                  \
                typeof(*object) VSF_MACRO_SAFE_NAME(tmp);                       \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    VSF_MACRO_SAFE_NAME(tmp) = *(object);                       \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
                VSF_MACRO_SAFE_NAME(tmp);                                       \
            })

◆ atomic_load

#define atomic_load ( object ) atomic_load_explicit(object, memory_order_seq_cst)

◆ atomic_exchange_explicit

#define atomic_exchange_explicit	(	object,
		desired,
		order
	)

Value:

            ({                                                                  \
                typeof(*object) VSF_MACRO_SAFE_NAME(tmp);                       \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    VSF_MACRO_SAFE_NAME(tmp) = *(object);                       \
                    *(object) = desired;                                        \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
                VSF_MACRO_SAFE_NAME(tmp);                                       \
            })

◆ atomic_exchange

#define atomic_exchange	(	object,
		desired
	)	atomic_exchange_explicit(object, desired, memory_order_seq_cst)

◆ atomic_compare_exchange_strong_explicit

#define atomic_compare_exchange_strong_explicit	(	object,
		expected,
		desired,
		order_success,
		order_fail
	)

Value:

            ({                                                                  \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    if (*(object) == *(expected)) {                             \
                        *(object) = desired;                                    \
                    } else {                                                    \
                        *(expected) = *(object);                                \
                    }                                                           \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
            })

◆ atomic_compare_exchange_strong

#define atomic_compare_exchange_strong	(	object,
		expected,
		desired
	)	atomic_compare_exchange_strong_explicit(object, expected, desired, memory_order_seq_cst, memory_order_seq_cst)

◆ atomic_compare_exchange_weak_explicit

#define atomic_compare_exchange_weak_explicit	(	object,
		expected,
		desired,
		order_success,
		order_fail
	)

Value:

            ({                                                                  \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    if (*(object) == *(expected)) {                             \
                        *(object) = desired;                                    \
                    } else {                                                    \
                        *(expected) = *(object);                                \
                    }                                                           \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
            })

◆ atomic_compare_exchange_weak

#define atomic_compare_exchange_weak	(	object,
		expected,
		desired
	)	atomic_compare_exchange_weak_explicit(object, expected, desired, memory_order_seq_cst, memory_order_seq_cst)

◆ atomic_fetch_add_explicit

#define atomic_fetch_add_explicit	(	object,
		operand,
		order
	)

Value:

            ({                                                                  \
                typeof(*object) VSF_MACRO_SAFE_NAME(__tmp);                     \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    VSF_MACRO_SAFE_NAME(__tmp) = *(object);                     \
                    *(object) += operand;                                       \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
                VSF_MACRO_SAFE_NAME(__tmp);                                     \
            })

◆ atomic_fetch_add

#define atomic_fetch_add	(	object,
		operand
	)	atomic_fetch_add_explicit(object, operand, memory_order_seq_cst)

◆ atomic_fetch_sub_explicit

#define atomic_fetch_sub_explicit	(	object,
		operand,
		order
	)

Value:

            ({                                                                  \
                typeof(*object) VSF_MACRO_SAFE_NAME(tmp);                       \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    VSF_MACRO_SAFE_NAME(tmp) = *(object);                       \
                    *(object) -= operand;                                       \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
                VSF_MACRO_SAFE_NAME(tmp);                                       \
            })

◆ atomic_fetch_sub

#define atomic_fetch_sub	(	object,
		operand
	)	atomic_fetch_sub_explicit(object, operand, memory_order_seq_cst)

◆ atomic_fetch_or_explicit

#define atomic_fetch_or_explicit	(	object,
		operand,
		order
	)

Value:

            ({                                                                  \
                typeof(*object) VSF_MACRO_SAFE_NAME(tmp);                       \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    VSF_MACRO_SAFE_NAME(tmp) = *(object);                       \
                    *(object) |= operand;                                       \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
                VSF_MACRO_SAFE_NAME(tmp);                                       \
            })

◆ atomic_fetch_or

#define atomic_fetch_or	(	object,
		operand
	)	atomic_fetch_or_explicit(object, operand, memory_order_seq_cst)

◆ atomic_fetch_xor_explicit

#define atomic_fetch_xor_explicit	(	object,
		operand,
		order
	)

Value:

            ({                                                                  \
                typeof(*object) VSF_MACRO_SAFE_NAME(tmp);                       \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    VSF_MACRO_SAFE_NAME(tmp) = *(object);                       \
                    *(object) ^= operand;                                       \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
                VSF_MACRO_SAFE_NAME(tmp);                                       \
            })

◆ atomic_fetch_xor

#define atomic_fetch_xor	(	object,
		operand
	)	atomic_fetch_xor_explicit(object, operand, memory_order_seq_cst)

◆ atomic_fetch_and_explicit

#define atomic_fetch_and_explicit	(	object,
		operand,
		order
	)

Value:

            ({                                                                  \
                typeof(*object) VSF_MACRO_SAFE_NAME(tmp);                       \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect) = vsf_protect_int(); \
                    VSF_MACRO_SAFE_NAME(tmp) = *(object);                       \
                    *(object) &= operand;                                       \
                vsf_unprotect_int(VSF_MACRO_SAFE_NAME(protect));                \
                VSF_MACRO_SAFE_NAME(tmp);                                       \
            })