atomic_utils.h

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Otto-von-Guericke-Universität Magdeburg
 *
 * This file is subject to the terms and conditions of the GNU Lesser General
 * Public License v2.1. See the file LICENSE in the top level directory for more
 * details.
 */

#ifndef ATOMIC_UTILS_H
#define ATOMIC_UTILS_H

#include <stdint.h>

#include "irq.h"
#include "atomic_utils_arch.h"

#ifdef __cplusplus
extern "C" {
#endif

/* Declarations and documentation: */

#if !defined(HAS_ATOMIC_BIT) || defined(DOXYGEN)

typedef struct {
    volatile uint8_t *dest;     
    uint8_t mask;               
} atomic_bit_u8_t;

typedef struct {
    volatile uint16_t *dest;    
    uint16_t mask;              
} atomic_bit_u16_t;

typedef struct {
    volatile uint32_t *dest;    
    uint32_t mask;              
} atomic_bit_u32_t;

typedef struct {
    volatile uint64_t *dest;    
    uint64_t mask;              
} atomic_bit_u64_t;
#endif /* HAS_ATOMIC_BIT */

static inline uint8_t atomic_load_u8(const volatile uint8_t *var);
static inline uint16_t atomic_load_u16(const volatile uint16_t *var);
static inline uint32_t atomic_load_u32(const volatile uint32_t *var);
static inline uint64_t atomic_load_u64(const volatile uint64_t *var);
static inline void atomic_store_u8(volatile uint8_t *dest, uint8_t val);
static inline void atomic_store_u16(volatile uint16_t *dest, uint16_t val);
static inline void atomic_store_u32(volatile uint32_t *dest, uint32_t val);
static inline void atomic_store_u64(volatile uint64_t *dest, uint64_t val);
static inline uint8_t atomic_fetch_add_u8(volatile uint8_t *dest,
                                          uint8_t summand);
static inline uint16_t atomic_fetch_add_u16(volatile uint16_t *dest,
                                            uint16_t summand);
static inline uint32_t atomic_fetch_add_u32(volatile uint32_t *dest,
                                            uint32_t summand);
static inline uint64_t atomic_fetch_add_u64(volatile uint64_t *dest,
                                            uint64_t summand);
static inline uint8_t atomic_fetch_sub_u8(volatile uint8_t *dest,
                                          uint8_t subtrahend);
static inline uint16_t atomic_fetch_sub_u16(volatile uint16_t *dest,
                                            uint16_t subtrahend);
static inline uint32_t atomic_fetch_sub_u32(volatile uint32_t *dest,
                                            uint32_t subtrahend);
static inline uint64_t atomic_fetch_sub_u64(volatile uint64_t *dest,
                                            uint64_t subtrahend);
static inline uint8_t atomic_fetch_or_u8(volatile uint8_t *dest, uint8_t val);
static inline uint16_t atomic_fetch_or_u16(volatile uint16_t *dest,
                                           uint16_t val);
static inline uint32_t atomic_fetch_or_u32(volatile uint32_t *dest,
                                           uint32_t val);
static inline uint64_t atomic_fetch_or_u64(volatile uint64_t *dest,
                                           uint64_t val);
static inline uint8_t atomic_fetch_xor_u8(volatile uint8_t *dest, uint8_t val);
static inline uint16_t atomic_fetch_xor_u16(volatile uint16_t *dest,
                                            uint16_t val);
static inline uint32_t atomic_fetch_xor_u32(volatile uint32_t *dest,
                                            uint32_t val);
static inline uint64_t atomic_fetch_xor_u64(volatile uint64_t *dest,
                                            uint64_t val);
static inline uint8_t atomic_fetch_and_u8(volatile uint8_t *dest, uint8_t val);
static inline uint16_t atomic_fetch_and_u16(volatile uint16_t *dest,
                                            uint16_t val);
static inline uint32_t atomic_fetch_and_u32(volatile uint32_t *dest,
                                            uint32_t val);
static inline uint64_t atomic_fetch_and_u64(volatile uint64_t *dest,
                                            uint64_t val);
static inline atomic_bit_u8_t atomic_bit_u8(volatile uint8_t *dest,
                                            uint8_t bit);

static inline atomic_bit_u16_t atomic_bit_u16(volatile uint16_t *dest,
                                              uint8_t bit);

static inline atomic_bit_u32_t atomic_bit_u32(volatile uint32_t *dest,
                                              uint8_t bit);

static inline atomic_bit_u64_t atomic_bit_u64(volatile uint64_t *dest,
                                              uint8_t bit);
static inline void atomic_set_bit_u8(atomic_bit_u8_t bit);
static inline void atomic_set_bit_u16(atomic_bit_u16_t bit);
static inline void atomic_set_bit_u32(atomic_bit_u32_t bit);
static inline void atomic_set_bit_u64(atomic_bit_u64_t bit);
static inline void atomic_clear_bit_u8(atomic_bit_u8_t bit);
static inline void atomic_clear_bit_u16(atomic_bit_u16_t bit);
static inline void atomic_clear_bit_u32(atomic_bit_u32_t bit);
static inline void atomic_clear_bit_u64(atomic_bit_u64_t bit);
static inline uint8_t semi_atomic_fetch_add_u8(volatile uint8_t *dest,
                                               uint8_t summand);
static inline uint16_t semi_atomic_fetch_add_u16(volatile uint16_t *dest,
                                                 uint16_t summand);
static inline uint32_t semi_atomic_fetch_add_u32(volatile uint32_t *dest,
                                                 uint32_t summand);
static inline uint64_t semi_atomic_fetch_add_u64(volatile uint64_t *dest,
                                                 uint64_t summand);
static inline uint8_t semi_atomic_fetch_sub_u8(volatile uint8_t *dest,
                                               uint8_t subtrahend);
static inline uint16_t semi_atomic_fetch_sub_u16(volatile uint16_t *dest,
                                                 uint16_t subtrahend);
static inline uint32_t semi_atomic_fetch_sub_u32(volatile uint32_t *dest,
                                                 uint32_t subtrahend);
static inline uint64_t semi_atomic_fetch_sub_u64(volatile uint64_t *dest,
                                                 uint64_t subtrahend);
static inline uint8_t semi_atomic_fetch_or_u8(volatile uint8_t *dest, uint8_t val);
static inline uint16_t semi_atomic_fetch_or_u16(volatile uint16_t *dest,
                                                uint16_t val);
static inline uint32_t semi_atomic_fetch_or_u32(volatile uint32_t *dest,
                                                uint32_t val);
static inline uint64_t semi_atomic_fetch_or_u64(volatile uint64_t *dest,
                                                uint64_t val);
static inline uint8_t semi_atomic_fetch_xor_u8(volatile uint8_t *dest,
                                               uint8_t val);
static inline uint16_t semi_atomic_fetch_xor_u16(volatile uint16_t *dest,
                                                 uint16_t val);
static inline uint32_t semi_atomic_fetch_xor_u32(volatile uint32_t *dest,
                                                 uint32_t val);
static inline uint64_t semi_atomic_fetch_xor_u64(volatile uint64_t *dest,
                                                 uint64_t val);
static inline uint8_t semi_atomic_fetch_and_u8(volatile uint8_t *dest,
                                               uint8_t val);
static inline uint16_t semi_atomic_fetch_and_u16(volatile uint16_t *dest,
                                                 uint16_t val);
static inline uint32_t semi_atomic_fetch_and_u32(volatile uint32_t *dest,
                                                 uint32_t val);
static inline uint64_t semi_atomic_fetch_and_u64(volatile uint64_t *dest,
                                                 uint64_t val);
/* Fallback implementations of atomic utility functions: */

#define CONCAT(a, b) a ## b

#define CONCAT4(a, b, c, d) a ## b ## c ## d

#define ATOMIC_LOAD_IMPL(name, type)                                           \
    static inline type CONCAT(atomic_load_, name)(const volatile type *var)    \
    {                                                                          \
        unsigned state = irq_disable();                                        \
        type result = *var;                                                    \
        irq_restore(state);                                                    \
        return result;                                                         \
    }

#ifndef HAS_ATOMIC_LOAD_U8
ATOMIC_LOAD_IMPL(u8, uint8_t)
#endif
#ifndef HAS_ATOMIC_LOAD_U16
ATOMIC_LOAD_IMPL(u16, uint16_t)
#endif
#ifndef HAS_ATOMIC_LOAD_U32
ATOMIC_LOAD_IMPL(u32, uint32_t)
#endif
#ifndef HAS_ATOMIC_LOAD_U64
ATOMIC_LOAD_IMPL(u64, uint64_t)
#endif

#define ATOMIC_STORE_IMPL(name, type)                                          \
    static inline void CONCAT(atomic_store_, name)                             \
            (volatile type *dest, type val)                                    \
    {                                                                          \
        unsigned state = irq_disable();                                        \
        *dest = val;                                                           \
        irq_restore(state);                                                    \
    }

#ifndef HAS_ATOMIC_STORE_U8
ATOMIC_STORE_IMPL(u8, uint8_t)
#endif
#ifndef HAS_ATOMIC_STORE_U16
ATOMIC_STORE_IMPL(u16, uint16_t)
#endif
#ifndef HAS_ATOMIC_STORE_U32
ATOMIC_STORE_IMPL(u32, uint32_t)
#endif
#ifndef HAS_ATOMIC_STORE_U64
ATOMIC_STORE_IMPL(u64, uint64_t)
#endif

#define ATOMIC_FETCH_OP_IMPL(opname, op, name, type)                           \
    static inline type CONCAT4(atomic_fetch_, opname, _, name)                 \
            (volatile type *dest, type val)                                    \
    {                                                                          \
        unsigned state = irq_disable();                                        \
        const type result = *dest;                                             \
        *dest = result op val;                                                 \
        irq_restore(state);                                                    \
        return result;                                                         \
    }

#ifndef HAS_ATOMIC_FETCH_ADD_U8
ATOMIC_FETCH_OP_IMPL(add, +, u8, uint8_t)
#endif
#ifndef HAS_ATOMIC_FETCH_ADD_U16
ATOMIC_FETCH_OP_IMPL(add, +, u16, uint16_t)
#endif
#ifndef HAS_ATOMIC_FETCH_ADD_U32
ATOMIC_FETCH_OP_IMPL(add, +, u32, uint32_t)
#endif
#ifndef HAS_ATOMIC_FETCH_ADD_U64
ATOMIC_FETCH_OP_IMPL(add, +, u64, uint64_t)
#endif

#ifndef HAS_ATOMIC_FETCH_SUB_U8
ATOMIC_FETCH_OP_IMPL(sub, -, u8, uint8_t)
#endif
#ifndef HAS_ATOMIC_FETCH_SUB_U16
ATOMIC_FETCH_OP_IMPL(sub, -, u16, uint16_t)
#endif
#ifndef HAS_ATOMIC_FETCH_SUB_U32
ATOMIC_FETCH_OP_IMPL(sub, -, u32, uint32_t)
#endif
#ifndef HAS_ATOMIC_FETCH_SUB_U64
ATOMIC_FETCH_OP_IMPL(sub, -, u64, uint64_t)
#endif

#ifndef HAS_ATOMIC_FETCH_OR_U8
ATOMIC_FETCH_OP_IMPL(or, |, u8, uint8_t)
#endif
#ifndef HAS_ATOMIC_FETCH_OR_U16
ATOMIC_FETCH_OP_IMPL(or, |, u16, uint16_t)
#endif
#ifndef HAS_ATOMIC_FETCH_OR_U32
ATOMIC_FETCH_OP_IMPL(or, |, u32, uint32_t)
#endif
#ifndef HAS_ATOMIC_FETCH_OR_U64
ATOMIC_FETCH_OP_IMPL(or, |, u64, uint64_t)
#endif

#ifndef HAS_ATOMIC_FETCH_XOR_U8
ATOMIC_FETCH_OP_IMPL(xor, ^, u8, uint8_t)
#endif
#ifndef HAS_ATOMIC_FETCH_XOR_U16
ATOMIC_FETCH_OP_IMPL(xor, ^, u16, uint16_t)
#endif
#ifndef HAS_ATOMIC_FETCH_XOR_U32
ATOMIC_FETCH_OP_IMPL(xor, ^, u32, uint32_t)
#endif
#ifndef HAS_ATOMIC_FETCH_XOR_U64
ATOMIC_FETCH_OP_IMPL(xor, ^, u64, uint64_t)
#endif

#ifndef HAS_ATOMIC_FETCH_AND_U8
ATOMIC_FETCH_OP_IMPL(and, &, u8, uint8_t)
#endif
#ifndef HAS_ATOMIC_FETCH_AND_U16
ATOMIC_FETCH_OP_IMPL(and, &, u16, uint16_t)
#endif
#ifndef HAS_ATOMIC_FETCH_AND_U32
ATOMIC_FETCH_OP_IMPL(and, &, u32, uint32_t)
#endif
#ifndef HAS_ATOMIC_FETCH_AND_U64
ATOMIC_FETCH_OP_IMPL(and, &, u64, uint64_t)
#endif

#ifndef HAS_ATOMIC_BIT
static inline atomic_bit_u8_t atomic_bit_u8(volatile uint8_t *dest,
                                            uint8_t bit)
{
    atomic_bit_u8_t result = { .dest = dest, .mask = 1U << bit };
    return result;
}
static inline atomic_bit_u16_t atomic_bit_u16(volatile uint16_t *dest,
                                              uint8_t bit)
{
    atomic_bit_u16_t result = { .dest = dest, .mask = 1U << bit };
    return result;
}
static inline atomic_bit_u32_t atomic_bit_u32(volatile uint32_t *dest,
                                              uint8_t bit)
{
    atomic_bit_u32_t result = { .dest = dest, .mask = 1UL << bit };
    return result;
}
static inline atomic_bit_u64_t atomic_bit_u64(volatile uint64_t *dest,
                                              uint8_t bit)
{
    atomic_bit_u64_t result = { .dest = dest, .mask = 1ULL << bit };
    return result;
}
static inline void atomic_set_bit_u8(atomic_bit_u8_t bit)
{
    atomic_fetch_or_u8(bit.dest, bit.mask);
}
static inline void atomic_set_bit_u16(atomic_bit_u16_t bit)
{
    atomic_fetch_or_u16(bit.dest, bit.mask);
}
static inline void atomic_set_bit_u32(atomic_bit_u32_t bit)
{
    atomic_fetch_or_u32(bit.dest, bit.mask);
}
static inline void atomic_set_bit_u64(atomic_bit_u64_t bit)
{
    atomic_fetch_or_u64(bit.dest, bit.mask);
}
static inline void atomic_clear_bit_u8(atomic_bit_u8_t bit)
{
    atomic_fetch_and_u8(bit.dest, ~bit.mask);
}
static inline void atomic_clear_bit_u16(atomic_bit_u16_t bit)
{
    atomic_fetch_and_u16(bit.dest, ~bit.mask);
}
static inline void atomic_clear_bit_u32(atomic_bit_u32_t bit)
{
    atomic_fetch_and_u32(bit.dest, ~bit.mask);
}
static inline void atomic_clear_bit_u64(atomic_bit_u64_t bit)
{
    atomic_fetch_and_u64(bit.dest, ~bit.mask);
}
#endif

/* Provide semi_atomic_*() functions on top.
 *
 * - If atomic_<FOO>() is provided: Use this for semi_atomic_<FOO>() as well
 * - Else:
 *      - If matching `atomic_store_u<BITS>()` is provided: Only make final
 *        store atomic, as we can avoid touching the IRQ state register that
 *        way
 *      - Else: We need to disable and re-enable IRQs anyway, we just use the
 *        fallback implementation of `atomic_<FOO>()` for `semi_atomic<FOO>()`
 *        as well
 */

/* FETCH_ADD */
#if defined(HAS_ATOMIC_FETCH_ADD_U8) || !defined(HAS_ATOMIC_STORE_U8)
static inline uint8_t semi_atomic_fetch_add_u8(volatile uint8_t *dest,
                                               uint8_t val)
{
    return atomic_fetch_add_u8(dest, val);
}
#else
static inline uint8_t semi_atomic_fetch_add_u8(volatile uint8_t *dest,
                                               uint8_t val)
{
    uint8_t result = atomic_load_u8(dest);
    atomic_store_u8(dest, result + val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_ADD_U8 || !HAS_ATOMIC_STORE_U8 */

#if defined(HAS_ATOMIC_FETCH_ADD_U16) || !defined(HAS_ATOMIC_STORE_U16)
static inline uint16_t semi_atomic_fetch_add_u16(volatile uint16_t *dest,
                                                 uint16_t val)
{
    return atomic_fetch_add_u16(dest, val);
}
#else
static inline uint16_t semi_atomic_fetch_add_u16(volatile uint16_t *dest,
                                                 uint16_t val)
{
    uint16_t result = atomic_load_u16(dest);
    atomic_store_u16(dest, result + val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_ADD_U16 || !HAS_ATOMIC_STORE_U16 */

#if defined(HAS_ATOMIC_FETCH_ADD_U32) || !defined(HAS_ATOMIC_STORE_U32)
static inline uint32_t semi_atomic_fetch_add_u32(volatile uint32_t *dest,
                                                 uint32_t val)
{
    return atomic_fetch_add_u32(dest, val);
}
#else
static inline uint32_t semi_atomic_fetch_add_u32(volatile uint32_t *dest,
                                                 uint32_t val)
{
    uint32_t result = atomic_load_u32(dest);
    atomic_store_u32(dest, result + val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_ADD_U32 || !HAS_ATOMIC_STORE_U32 */

#if defined(HAS_ATOMIC_FETCH_ADD_U64) || !defined(HAS_ATOMIC_STORE_U64)
static inline uint64_t semi_atomic_fetch_add_u64(volatile uint64_t *dest,
                                                 uint64_t val)
{
    return atomic_fetch_add_u64(dest, val);
}
#else
static inline uint64_t semi_atomic_fetch_add_u64(volatile uint64_t *dest,
                                                 uint64_t val)
{
    atomic_store_u64(dest, *dest + val);
}
#endif /* HAS_ATOMIC_FETCH_ADD_U32 || !HAS_ATOMIC_STORE_U32 */

/* FETCH_SUB */
#if defined(HAS_ATOMIC_FETCH_SUB_U8) || !defined(HAS_ATOMIC_STORE_U8)
static inline uint8_t semi_atomic_fetch_sub_u8(volatile uint8_t *dest,
                                               uint8_t val)
{
    return atomic_fetch_sub_u8(dest, val);
}
#else
static inline uint8_t semi_atomic_fetch_sub_u8(volatile uint8_t *dest,
                                               uint8_t val)
{
    uint8_t result = atomic_load_u8(dest);
    atomic_store_u8(dest, result - val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_SUB_U8 || !HAS_ATOMIC_STORE_U8 */

#if defined(HAS_ATOMIC_FETCH_SUB_U16) || !defined(HAS_ATOMIC_STORE_U16)
static inline uint16_t semi_atomic_fetch_sub_u16(volatile uint16_t *dest,
                                                 uint16_t val)
{
    return atomic_fetch_sub_u16(dest, val);
}
#else
static inline uint16_t semi_atomic_fetch_sub_u16(volatile uint16_t *dest,
                                                 uint16_t val)
{
    uint16_t result = atomic_load_u16(dest);
    atomic_store_u16(dest, result - val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_SUB_U16 || !HAS_ATOMIC_STORE_U16 */

#if defined(HAS_ATOMIC_FETCH_SUB_U32) || !defined(HAS_ATOMIC_STORE_U32)
static inline uint32_t semi_atomic_fetch_sub_u32(volatile uint32_t *dest,
                                                 uint32_t val)
{
    return atomic_fetch_sub_u32(dest, val);
}
#else
static inline uint32_t semi_atomic_fetch_sub_u32(volatile uint32_t *dest,
                                                 uint32_t val)
{
    uint32_t result = atomic_load_u32(dest);
    atomic_store_u32(dest, result - val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_SUB_U32 || !HAS_ATOMIC_STORE_U64 */

#if defined(HAS_ATOMIC_FETCH_SUB_U64) || !defined(HAS_ATOMIC_STORE_U64)
static inline uint64_t semi_atomic_fetch_sub_u64(volatile uint64_t *dest,
                                                 uint64_t val)
{
    return atomic_fetch_sub_u64(dest, val);
}
#else
static inline uint64_t semi_atomic_fetch_sub_u64(volatile uint64_t *dest,
                                                 uint64_t val)
{
    uint64_t result = atomic_load_u64(dest);
    atomic_store_u64(dest, result - val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_SUB_U64 || !HAS_ATOMIC_STORE_U64 */

/* FETCH_OR */
#if defined(HAS_ATOMIC_FETCH_OR_U8) || !defined(HAS_ATOMIC_STORE_U8)
static inline uint8_t semi_atomic_fetch_or_u8(volatile uint8_t *dest,
                                              uint8_t val)
{
    return atomic_fetch_or_u8(dest, val);
}
#else
static inline uint8_t semi_atomic_fetch_or_u8(volatile uint8_t *dest,
                                              uint8_t val)
{
    uint8_t result = atomic_load_u8(dest);
    atomic_store_u8(dest, result | val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_OR_U8 || !HAS_ATOMIC_STORE_U8 */

#if defined(HAS_ATOMIC_FETCH_OR_U16) || !defined(HAS_ATOMIC_STORE_U16)
static inline uint16_t semi_atomic_fetch_or_u16(volatile uint16_t *dest,
                                                uint16_t val)
{
    return atomic_fetch_or_u16(dest, val);
}
#else
static inline uint16_t semi_atomic_fetch_or_u16(volatile uint16_t *dest,
                                                uint16_t val)
{
    uint16_t result = atomic_load_u16(dest);
    atomic_store_u16(dest, result | val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_OR_U16 || !HAS_ATOMIC_STORE_U16 */

#if defined(HAS_ATOMIC_FETCH_OR_U32) || !defined(HAS_ATOMIC_STORE_U32)
static inline uint32_t semi_atomic_fetch_or_u32(volatile uint32_t *dest,
                                                uint32_t val)
{
    return atomic_fetch_or_u32(dest, val);
}
#else
static inline uint32_t semi_atomic_fetch_or_u32(volatile uint32_t *dest,
                                                uint32_t val)
{
    uint32_t result = atomic_load_u32(dest);
    atomic_store_u32(dest, result | val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_OR_U32 || !HAS_ATOMIC_STORE_U32 */

#if defined(HAS_ATOMIC_FETCH_OR_U64) || !defined(HAS_ATOMIC_STORE_U64)
static inline uint64_t semi_atomic_fetch_or_u64(volatile uint64_t *dest,
                                                uint64_t val)
{
    return atomic_fetch_or_u64(dest, val);
}
#else
static inline uint64_t semi_atomic_fetch_or_u64(volatile uint64_t *dest,
                                                uint64_t val)
{
    uint64_t result = atomic_load_u64(dest);
    atomic_store_u64(dest, result | val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_OR_U64 || !HAS_ATOMIC_STORE_U64 */

/* FETCH_XOR */
#if defined(HAS_ATOMIC_FETCH_XOR_U8) || !defined(HAS_ATOMIC_STORE_U8)
static inline uint8_t semi_atomic_fetch_xor_u8(volatile uint8_t *dest,
                                               uint8_t val)
{
    return atomic_fetch_xor_u8(dest, val);
}
#else
static inline uint8_t semi_atomic_fetch_xor_u8(volatile uint8_t *dest,
                                               uint8_t val)
{
    uint8_t result = atomic_load_u8(dest);
    atomic_store_u8(dest, result ^ val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_XOR_U8 || !HAS_ATOMIC_STORE_U8 */

#if defined(HAS_ATOMIC_FETCH_XOR_U16) || !defined(HAS_ATOMIC_STORE_U16)
static inline uint16_t semi_atomic_fetch_xor_u16(volatile uint16_t *dest,
                                                 uint16_t val)
{
    return atomic_fetch_xor_u16(dest, val);
}
#else
static inline uint16_t semi_atomic_fetch_xor_u16(volatile uint16_t *dest,
                                                 uint16_t val)
{
    uint16_t result = atomic_load_u16(dest);
    atomic_store_u16(dest, result ^ val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_XOR_U16 || !HAS_ATOMIC_STORE_U16 */

#if defined(HAS_ATOMIC_FETCH_XOR_U32) || !defined(HAS_ATOMIC_STORE_U32)
static inline uint32_t semi_atomic_fetch_xor_u32(volatile uint32_t *dest,
                                                 uint32_t val)
{
    return atomic_fetch_xor_u32(dest, val);
}
#else
static inline uint32_t semi_atomic_fetch_xor_u32(volatile uint32_t *dest,
                                                 uint32_t val)
{
    uint32_t result = atomic_load_u32(dest);
    atomic_store_u32(dest, result ^ val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_XOR_U32 || !HAS_ATOMIC_STORE_U32 */

#if defined(HAS_ATOMIC_FETCH_XOR_U64) || !defined(HAS_ATOMIC_STORE_U64)
static inline uint64_t semi_atomic_fetch_xor_u64(volatile uint64_t *dest,
                                                 uint64_t val)
{
    return atomic_fetch_xor_u64(dest, val);
}
#else
static inline uint64_t semi_atomic_fetch_xor_u64(volatile uint64_t *dest,
                                                 uint64_t val)
{
    uint64_t result = atomic_load_u64(dest);
    atomic_store_u64(dest, result ^ val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_XOR_U64 || !HAS_ATOMIC_STORE_U64 */

/* FETCH_AND */
#if defined(HAS_ATOMIC_FETCH_AND_U8) || !defined(HAS_ATOMIC_STORE_U8)
static inline uint8_t semi_atomic_fetch_and_u8(volatile uint8_t *dest,
                                               uint8_t val)
{
    return atomic_fetch_and_u8(dest, val);
}
#else
static inline uint8_t semi_atomic_fetch_and_u8(volatile uint8_t *dest,
                                               uint8_t val)
{
    uint8_t result = atomic_load_u8(dest);
    atomic_store_u8(dest, result & val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_AND_U8 || !HAS_ATOMIC_STORE_U8 */

#if defined(HAS_ATOMIC_FETCH_AND_U16) || !defined(HAS_ATOMIC_STORE_U16)
static inline uint16_t semi_atomic_fetch_and_u16(volatile uint16_t *dest,
                                                 uint16_t val)
{
    return atomic_fetch_and_u16(dest, val);
}
#else
static inline uint16_t semi_atomic_fetch_and_u16(volatile uint16_t *dest,
                                                 uint16_t val)
{
    uint16_t result = atomic_load_u16(dest);
    atomic_store_u16(dest, result & val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_AND_U16 || !HAS_ATOMIC_STORE_U16 */

#if defined(HAS_ATOMIC_FETCH_AND_U32) || !defined(HAS_ATOMIC_STORE_U32)
static inline uint32_t semi_atomic_fetch_and_u32(volatile uint32_t *dest,
                                                 uint32_t val)
{
    return atomic_fetch_and_u32(dest, val);
}
#else
static inline uint32_t semi_atomic_fetch_and_u32(volatile uint32_t *dest,
                                                 uint32_t val)
{
    uint32_t result = atomic_load_u32(dest);
    atomic_store_u32(dest, result & val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_AND_U32 || !HAS_ATOMIC_STORE_U32 */

#if defined(HAS_ATOMIC_FETCH_AND_U64) || !defined(HAS_ATOMIC_STORE_U64)
static inline uint64_t semi_atomic_fetch_and_u64(volatile uint64_t *dest,
                                                 uint64_t val)
{
    return atomic_fetch_and_u64(dest, val);
}
#else
static inline uint64_t semi_atomic_fetch_and_u64(volatile uint64_t *dest,
                                                 uint64_t val)
{
    uint64_t result = atomic_load_u64(dest);
    atomic_store_u64(dest, result & val);
    return result;
}
#endif /* HAS_ATOMIC_FETCH_AND_U64 || !HAS_ATOMIC_STORE_U64 */

#ifdef __cplusplus
}
#endif

#endif /* ATOMIC_UTILS_H */