Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.1

0.6.1 / src / ak / atomic.lucb

#==============================================================================================
#
#   atomic - the AK atomic free functions over luce-base `@T` atomics
#
#   DESCRIPTION:
#       Port of the free functions of AK/Atomic.h (lines 1-150). The donor's `T volatile*`
#       templates wrap the __atomic builtins; here a plain `T*` location is viewed as `(@T)*`
#       (language §5.9, §15.1) and the operation is the atomic's method. The templates are
#       instantiated per type with the type as a suffix (`atomic_fetch_add_u32`); the pointer
#       overloads (`T volatile**`) are generic over the pointee. AK::MemoryOrder maps onto
#       atomics.Ordering (memory_order_consume is acquire, as compilers implement it).
#       The Atomic<T> class template is not in the phase-1 closure: `@T` fields replace it.
#
#==============================================================================================

# mark: Memory orders ===========================================================================

# AK::MemoryOrder as luce-base's atomics.Ordering.
func atomic_ordering(order: MemoryOrder) -> atomics.Ordering:
    return match order:
        .memory_order_relaxed => atomics.Ordering.relaxed
        .memory_order_consume => atomics.Ordering.acquire
        .memory_order_acquire => atomics.Ordering.acquire
        .memory_order_release => atomics.Ordering.release
        .memory_order_acq_rel => atomics.Ordering.acq_rel
        _ => atomics.Ordering.seq_cst

# atomic_compare_exchange_strong's success order: release for acq_rel and release.
func atomic_cas_success_order(order: MemoryOrder) -> atomics.Ordering:
    if order == MemoryOrder.memory_order_acq_rel or order == MemoryOrder.memory_order_release:
        return atomics.Ordering.release
    return atomic_ordering(order)

# atomic_compare_exchange_strong's failure order: acquire for acq_rel and release.
func atomic_cas_failure_order(order: MemoryOrder) -> atomics.Ordering:
    if order == MemoryOrder.memory_order_acq_rel or order == MemoryOrder.memory_order_release:
        return atomics.Ordering.acquire
    return atomic_ordering(order)

# mark: Fences ==================================================================================

## Ported from AK/Atomic.h:15 AK::atomic_signal_fence.
# luce-base has no signal-only fence in this revision; a thread fence is at least as strong.
pub func atomic_signal_fence(order: MemoryOrder):
    atomics.fence(atomic_ordering(order))

## Ported from AK/Atomic.h:20 AK::atomic_thread_fence.
pub func atomic_thread_fence(order: MemoryOrder):
    atomics.fence(atomic_ordering(order))

## Ported from AK/Atomic.h:25 AK::full_memory_barrier.
pub func full_memory_barrier():
    atomic_signal_fence(MemoryOrder.memory_order_acq_rel)
    atomic_thread_fence(MemoryOrder.memory_order_acq_rel)

# mark: Scalar locations ========================================================================

# The atomic view of a plain `u8` location.
type AtomicU8Ptr = (@u8)*

# The atomic view of a plain `u16` location.
type AtomicU16Ptr = (@u16)*

# The atomic view of a plain `u32` location.
type AtomicU32Ptr = (@u32)*

# The atomic view of a plain `u64` location.
type AtomicU64Ptr = (@u64)*

# The atomic view of a plain `usize` location.
type AtomicUsizePtr = (@usize)*

# The atomic view of a plain `i32` location.
type AtomicI32Ptr = (@i32)*

# The atomic view of a plain `i64` location.
type AtomicI64Ptr = (@i64)*

# The atomic view of a plain `bool` location.
type AtomicBoolPtr = (@bool)*

## Ported from AK/Atomic.h:32 AK::atomic_exchange, for u8.
pub func atomic_exchange_u8(var_: u8*, desired: u8, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u8:
    return ((AtomicU8Ptr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:32 AK::atomic_exchange, for u16.
pub func atomic_exchange_u16(var_: u16*, desired: u16, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u16:
    return ((AtomicU16Ptr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:32 AK::atomic_exchange, for u32.
pub func atomic_exchange_u32(var_: u32*, desired: u32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u32:
    return ((AtomicU32Ptr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:32 AK::atomic_exchange, for u64.
pub func atomic_exchange_u64(var_: u64*, desired: u64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u64:
    return ((AtomicU64Ptr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:32 AK::atomic_exchange, for usize.
pub func atomic_exchange_usize(var_: usize*, desired: usize, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> usize:
    return ((AtomicUsizePtr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:32 AK::atomic_exchange, for i32.
pub func atomic_exchange_i32(var_: i32*, desired: i32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i32:
    return ((AtomicI32Ptr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:32 AK::atomic_exchange, for i64.
pub func atomic_exchange_i64(var_: i64*, desired: i64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i64:
    return ((AtomicI64Ptr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:32 AK::atomic_exchange, for bool.
pub func atomic_exchange_bool(var_: bool*, desired: bool, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    return ((AtomicBoolPtr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:50 AK::atomic_compare_exchange_strong, for u8.
pub func atomic_compare_exchange_strong_u8(var_: u8*, expected: u8*, desired: u8, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicU8Ptr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    # __atomic_compare_exchange_n writes the observed value back into `expected` on failure.
    if not exchanged:
        *expected = observed
    return exchanged

## Ported from AK/Atomic.h:50 AK::atomic_compare_exchange_strong, for u16.
pub func atomic_compare_exchange_strong_u16(var_: u16*, expected: u16*, desired: u16, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicU16Ptr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    # __atomic_compare_exchange_n writes the observed value back into `expected` on failure.
    if not exchanged:
        *expected = observed
    return exchanged

## Ported from AK/Atomic.h:50 AK::atomic_compare_exchange_strong, for u32.
pub func atomic_compare_exchange_strong_u32(var_: u32*, expected: u32*, desired: u32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicU32Ptr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    # __atomic_compare_exchange_n writes the observed value back into `expected` on failure.
    if not exchanged:
        *expected = observed
    return exchanged

## Ported from AK/Atomic.h:50 AK::atomic_compare_exchange_strong, for u64.
pub func atomic_compare_exchange_strong_u64(var_: u64*, expected: u64*, desired: u64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicU64Ptr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    # __atomic_compare_exchange_n writes the observed value back into `expected` on failure.
    if not exchanged:
        *expected = observed
    return exchanged

## Ported from AK/Atomic.h:50 AK::atomic_compare_exchange_strong, for usize.
pub func atomic_compare_exchange_strong_usize(var_: usize*, expected: usize*, desired: usize, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicUsizePtr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    # __atomic_compare_exchange_n writes the observed value back into `expected` on failure.
    if not exchanged:
        *expected = observed
    return exchanged

## Ported from AK/Atomic.h:50 AK::atomic_compare_exchange_strong, for i32.
pub func atomic_compare_exchange_strong_i32(var_: i32*, expected: i32*, desired: i32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicI32Ptr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    # __atomic_compare_exchange_n writes the observed value back into `expected` on failure.
    if not exchanged:
        *expected = observed
    return exchanged

## Ported from AK/Atomic.h:50 AK::atomic_compare_exchange_strong, for i64.
pub func atomic_compare_exchange_strong_i64(var_: i64*, expected: i64*, desired: i64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicI64Ptr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    # __atomic_compare_exchange_n writes the observed value back into `expected` on failure.
    if not exchanged:
        *expected = observed
    return exchanged

## Ported from AK/Atomic.h:50 AK::atomic_compare_exchange_strong, for bool.
pub func atomic_compare_exchange_strong_bool(var_: bool*, expected: bool*, desired: bool, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicBoolPtr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    # __atomic_compare_exchange_n writes the observed value back into `expected` on failure.
    if not exchanged:
        *expected = observed
    return exchanged

## Ported from AK/Atomic.h:104 AK::atomic_load, for u8.
pub func atomic_load_u8(var_: u8*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u8:
    return ((AtomicU8Ptr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:104 AK::atomic_load, for u16.
pub func atomic_load_u16(var_: u16*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u16:
    return ((AtomicU16Ptr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:104 AK::atomic_load, for u32.
pub func atomic_load_u32(var_: u32*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u32:
    return ((AtomicU32Ptr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:104 AK::atomic_load, for u64.
pub func atomic_load_u64(var_: u64*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u64:
    return ((AtomicU64Ptr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:104 AK::atomic_load, for usize.
pub func atomic_load_usize(var_: usize*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> usize:
    return ((AtomicUsizePtr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:104 AK::atomic_load, for i32.
pub func atomic_load_i32(var_: i32*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i32:
    return ((AtomicI32Ptr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:104 AK::atomic_load, for i64.
pub func atomic_load_i64(var_: i64*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i64:
    return ((AtomicI64Ptr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:104 AK::atomic_load, for bool.
pub func atomic_load_bool(var_: bool*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    return ((AtomicBoolPtr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:125 AK::atomic_store, for u8.
pub func atomic_store_u8(var_: u8*, desired: u8, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicU8Ptr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:125 AK::atomic_store, for u16.
pub func atomic_store_u16(var_: u16*, desired: u16, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicU16Ptr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:125 AK::atomic_store, for u32.
pub func atomic_store_u32(var_: u32*, desired: u32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicU32Ptr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:125 AK::atomic_store, for u64.
pub func atomic_store_u64(var_: u64*, desired: u64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicU64Ptr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:125 AK::atomic_store, for usize.
pub func atomic_store_usize(var_: usize*, desired: usize, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicUsizePtr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:125 AK::atomic_store, for i32.
pub func atomic_store_i32(var_: i32*, desired: i32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicI32Ptr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:125 AK::atomic_store, for i64.
pub func atomic_store_i64(var_: i64*, desired: i64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicI64Ptr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:125 AK::atomic_store, for bool.
pub func atomic_store_bool(var_: bool*, desired: bool, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicBoolPtr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:74 AK::atomic_fetch_add, for u8.
pub func atomic_fetch_add_u8(var_: u8*, val: u8, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u8:
    return ((AtomicU8Ptr)(void*)var_).add(val, atomic_ordering(order))

## Ported from AK/Atomic.h:74 AK::atomic_fetch_add, for u16.
pub func atomic_fetch_add_u16(var_: u16*, val: u16, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u16:
    return ((AtomicU16Ptr)(void*)var_).add(val, atomic_ordering(order))

## Ported from AK/Atomic.h:74 AK::atomic_fetch_add, for u32.
pub func atomic_fetch_add_u32(var_: u32*, val: u32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u32:
    return ((AtomicU32Ptr)(void*)var_).add(val, atomic_ordering(order))

## Ported from AK/Atomic.h:74 AK::atomic_fetch_add, for u64.
pub func atomic_fetch_add_u64(var_: u64*, val: u64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u64:
    return ((AtomicU64Ptr)(void*)var_).add(val, atomic_ordering(order))

## Ported from AK/Atomic.h:74 AK::atomic_fetch_add, for usize.
pub func atomic_fetch_add_usize(var_: usize*, val: usize, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> usize:
    return ((AtomicUsizePtr)(void*)var_).add(val, atomic_ordering(order))

## Ported from AK/Atomic.h:74 AK::atomic_fetch_add, for i32.
pub func atomic_fetch_add_i32(var_: i32*, val: i32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i32:
    return ((AtomicI32Ptr)(void*)var_).add(val, atomic_ordering(order))

## Ported from AK/Atomic.h:74 AK::atomic_fetch_add, for i64.
pub func atomic_fetch_add_i64(var_: i64*, val: i64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i64:
    return ((AtomicI64Ptr)(void*)var_).add(val, atomic_ordering(order))

## Ported from AK/Atomic.h:80 AK::atomic_fetch_sub, for u8.
pub func atomic_fetch_sub_u8(var_: u8*, val: u8, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u8:
    return ((AtomicU8Ptr)(void*)var_).sub(val, atomic_ordering(order))

## Ported from AK/Atomic.h:80 AK::atomic_fetch_sub, for u16.
pub func atomic_fetch_sub_u16(var_: u16*, val: u16, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u16:
    return ((AtomicU16Ptr)(void*)var_).sub(val, atomic_ordering(order))

## Ported from AK/Atomic.h:80 AK::atomic_fetch_sub, for u32.
pub func atomic_fetch_sub_u32(var_: u32*, val: u32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u32:
    return ((AtomicU32Ptr)(void*)var_).sub(val, atomic_ordering(order))

## Ported from AK/Atomic.h:80 AK::atomic_fetch_sub, for u64.
pub func atomic_fetch_sub_u64(var_: u64*, val: u64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u64:
    return ((AtomicU64Ptr)(void*)var_).sub(val, atomic_ordering(order))

## Ported from AK/Atomic.h:80 AK::atomic_fetch_sub, for usize.
pub func atomic_fetch_sub_usize(var_: usize*, val: usize, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> usize:
    return ((AtomicUsizePtr)(void*)var_).sub(val, atomic_ordering(order))

## Ported from AK/Atomic.h:80 AK::atomic_fetch_sub, for i32.
pub func atomic_fetch_sub_i32(var_: i32*, val: i32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i32:
    return ((AtomicI32Ptr)(void*)var_).sub(val, atomic_ordering(order))

## Ported from AK/Atomic.h:80 AK::atomic_fetch_sub, for i64.
pub func atomic_fetch_sub_i64(var_: i64*, val: i64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i64:
    return ((AtomicI64Ptr)(void*)var_).sub(val, atomic_ordering(order))

## Ported from AK/Atomic.h:86 AK::atomic_fetch_and, for u8.
pub func atomic_fetch_and_u8(var_: u8*, val: u8, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u8:
    return ((AtomicU8Ptr)(void*)var_).clear(~val, atomic_ordering(order))

## Ported from AK/Atomic.h:86 AK::atomic_fetch_and, for u16.
pub func atomic_fetch_and_u16(var_: u16*, val: u16, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u16:
    return ((AtomicU16Ptr)(void*)var_).clear(~val, atomic_ordering(order))

## Ported from AK/Atomic.h:86 AK::atomic_fetch_and, for u32.
pub func atomic_fetch_and_u32(var_: u32*, val: u32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u32:
    return ((AtomicU32Ptr)(void*)var_).clear(~val, atomic_ordering(order))

## Ported from AK/Atomic.h:86 AK::atomic_fetch_and, for u64.
pub func atomic_fetch_and_u64(var_: u64*, val: u64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u64:
    return ((AtomicU64Ptr)(void*)var_).clear(~val, atomic_ordering(order))

## Ported from AK/Atomic.h:86 AK::atomic_fetch_and, for usize.
pub func atomic_fetch_and_usize(var_: usize*, val: usize, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> usize:
    return ((AtomicUsizePtr)(void*)var_).clear(~val, atomic_ordering(order))

## Ported from AK/Atomic.h:86 AK::atomic_fetch_and, for i32.
pub func atomic_fetch_and_i32(var_: i32*, val: i32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i32:
    return ((AtomicI32Ptr)(void*)var_).clear(~val, atomic_ordering(order))

## Ported from AK/Atomic.h:86 AK::atomic_fetch_and, for i64.
pub func atomic_fetch_and_i64(var_: i64*, val: i64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i64:
    return ((AtomicI64Ptr)(void*)var_).clear(~val, atomic_ordering(order))

## Ported from AK/Atomic.h:92 AK::atomic_fetch_or, for u8.
pub func atomic_fetch_or_u8(var_: u8*, val: u8, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u8:
    return ((AtomicU8Ptr)(void*)var_).set(val, atomic_ordering(order))

## Ported from AK/Atomic.h:92 AK::atomic_fetch_or, for u16.
pub func atomic_fetch_or_u16(var_: u16*, val: u16, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u16:
    return ((AtomicU16Ptr)(void*)var_).set(val, atomic_ordering(order))

## Ported from AK/Atomic.h:92 AK::atomic_fetch_or, for u32.
pub func atomic_fetch_or_u32(var_: u32*, val: u32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u32:
    return ((AtomicU32Ptr)(void*)var_).set(val, atomic_ordering(order))

## Ported from AK/Atomic.h:92 AK::atomic_fetch_or, for u64.
pub func atomic_fetch_or_u64(var_: u64*, val: u64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u64:
    return ((AtomicU64Ptr)(void*)var_).set(val, atomic_ordering(order))

## Ported from AK/Atomic.h:92 AK::atomic_fetch_or, for usize.
pub func atomic_fetch_or_usize(var_: usize*, val: usize, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> usize:
    return ((AtomicUsizePtr)(void*)var_).set(val, atomic_ordering(order))

## Ported from AK/Atomic.h:92 AK::atomic_fetch_or, for i32.
pub func atomic_fetch_or_i32(var_: i32*, val: i32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i32:
    return ((AtomicI32Ptr)(void*)var_).set(val, atomic_ordering(order))

## Ported from AK/Atomic.h:92 AK::atomic_fetch_or, for i64.
pub func atomic_fetch_or_i64(var_: i64*, val: i64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i64:
    return ((AtomicI64Ptr)(void*)var_).set(val, atomic_ordering(order))

## Ported from AK/Atomic.h:98 AK::atomic_fetch_xor, for u8.
pub func atomic_fetch_xor_u8(var_: u8*, val: u8, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u8:
    return ((AtomicU8Ptr)(void*)var_).flip(val, atomic_ordering(order))

## Ported from AK/Atomic.h:98 AK::atomic_fetch_xor, for u16.
pub func atomic_fetch_xor_u16(var_: u16*, val: u16, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u16:
    return ((AtomicU16Ptr)(void*)var_).flip(val, atomic_ordering(order))

## Ported from AK/Atomic.h:98 AK::atomic_fetch_xor, for u32.
pub func atomic_fetch_xor_u32(var_: u32*, val: u32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u32:
    return ((AtomicU32Ptr)(void*)var_).flip(val, atomic_ordering(order))

## Ported from AK/Atomic.h:98 AK::atomic_fetch_xor, for u64.
pub func atomic_fetch_xor_u64(var_: u64*, val: u64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> u64:
    return ((AtomicU64Ptr)(void*)var_).flip(val, atomic_ordering(order))

## Ported from AK/Atomic.h:98 AK::atomic_fetch_xor, for usize.
pub func atomic_fetch_xor_usize(var_: usize*, val: usize, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> usize:
    return ((AtomicUsizePtr)(void*)var_).flip(val, atomic_ordering(order))

## Ported from AK/Atomic.h:98 AK::atomic_fetch_xor, for i32.
pub func atomic_fetch_xor_i32(var_: i32*, val: i32, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i32:
    return ((AtomicI32Ptr)(void*)var_).flip(val, atomic_ordering(order))

## Ported from AK/Atomic.h:98 AK::atomic_fetch_xor, for i64.
pub func atomic_fetch_xor_i64(var_: i64*, val: i64, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> i64:
    return ((AtomicI64Ptr)(void*)var_).flip(val, atomic_ordering(order))

## Ported from AK/Atomic.h:143 AK::atomic_is_lock_free, for u8: every luce-base `@T` is lock-free.
pub func atomic_is_lock_free_u8(ptr: u8*? = none) -> bool:
    _ = ptr
    return true

## Ported from AK/Atomic.h:143 AK::atomic_is_lock_free, for u16: every luce-base `@T` is lock-free.
pub func atomic_is_lock_free_u16(ptr: u16*? = none) -> bool:
    _ = ptr
    return true

## Ported from AK/Atomic.h:143 AK::atomic_is_lock_free, for u32: every luce-base `@T` is lock-free.
pub func atomic_is_lock_free_u32(ptr: u32*? = none) -> bool:
    _ = ptr
    return true

## Ported from AK/Atomic.h:143 AK::atomic_is_lock_free, for u64: every luce-base `@T` is lock-free.
pub func atomic_is_lock_free_u64(ptr: u64*? = none) -> bool:
    _ = ptr
    return true

## Ported from AK/Atomic.h:143 AK::atomic_is_lock_free, for usize: every luce-base `@T` is lock-free.
pub func atomic_is_lock_free_usize(ptr: usize*? = none) -> bool:
    _ = ptr
    return true

## Ported from AK/Atomic.h:143 AK::atomic_is_lock_free, for i32: every luce-base `@T` is lock-free.
pub func atomic_is_lock_free_i32(ptr: i32*? = none) -> bool:
    _ = ptr
    return true

## Ported from AK/Atomic.h:143 AK::atomic_is_lock_free, for i64: every luce-base `@T` is lock-free.
pub func atomic_is_lock_free_i64(ptr: i64*? = none) -> bool:
    _ = ptr
    return true

# mark: Pointer locations =======================================================================

# The atomic view of a plain pointer location.
type AtomicPointerPtr = (@void*?)*

## Ported from AK/Atomic.h:38 AK::atomic_exchange (T volatile**, V*).
pub func atomic_exchange_v[V](var_: (V*?)*, desired: V*?, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> V*?:
    return (V*?)((AtomicPointerPtr)(void*)var_).swap(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:44 AK::atomic_exchange (T volatile**, nullptr_t).
pub func atomic_exchange_void[V](var_: (V*?)*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> V*?:
    return (V*?)((AtomicPointerPtr)(void*)var_).swap(none, atomic_ordering(order))

## Ported from AK/Atomic.h:58 AK::atomic_compare_exchange_strong (T volatile**, V*&, V*).
pub func atomic_compare_exchange_strong_v_v[V](var_: (V*?)*, expected: (V*?)*, desired: V*?, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    let a = (AtomicPointerPtr)(void*)var_
    let (exchanged, observed) = a.cas(*expected, desired, atomic_cas_success_order(order), atomic_cas_failure_order(order))
    if not exchanged:
        *expected = (V*?)observed
    return exchanged

## Ported from AK/Atomic.h:66 AK::atomic_compare_exchange_strong (T volatile**, V*&, nullptr_t).
pub func atomic_compare_exchange_strong_v_void[V](var_: (V*?)*, expected: (V*?)*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> bool:
    return atomic_compare_exchange_strong_v_v(var_, expected, none, order)

## Ported from AK/Atomic.h:110 AK::atomic_load (T volatile**).
pub func atomic_load_2[V](var_: (V*?)*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst) -> V*?:
    return (V*?)((AtomicPointerPtr)(void*)var_).load(atomic_ordering(order))

## Ported from AK/Atomic.h:131 AK::atomic_store (T volatile**, V*).
pub func atomic_store_v[V](var_: (V*?)*, desired: V*?, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicPointerPtr)(void*)var_).store(desired, atomic_ordering(order))

## Ported from AK/Atomic.h:137 AK::atomic_store (T volatile**, nullptr_t).
pub func atomic_store_void[V](var_: (V*?)*, order: MemoryOrder = MemoryOrder.memory_order_seq_cst):
    ((AtomicPointerPtr)(void*)var_).store(none, atomic_ordering(order))

# mark: atomic_pause ============================================================================

## Ported from AK/Atomic.h:115 AK::atomic_pause.
pub func atomic_pause():
    thread.pause()