Compiler Explorer

Source code

#![no_std]
#![allow(unused, internal_features)]
#![feature(cfg_target_has_atomic, core_intrinsics)]

/*
macro_rules! atomic_update {
 ($t:ident) => {
 mod $t {
 pub(crate) use core::sync::atomic::Ordering;
 #[inline(always)]
 pub(crate) unsafe fn atomic_update<F>(dst: *mut $t, order: Ordering, mut f: F) -> $t
 where
 F: FnMut($t) -> $t,
 {
 // This is a private function and all instances of `f` only operate on the value
 // loaded, so there is no need to synchronize the first load/failed CAS.
 let mut old = core::intrinsics::atomic_load_relaxed(dst);
 loop {
 let next = f(old);
 let (x, ok) = match order {
 Ordering::Relaxed => core::intrinsics::atomic_cxchgweak_relaxed_relaxed(dst, old, next),
 Ordering::Acquire => core::intrinsics::atomic_cxchgweak_acquire_relaxed(dst, old, next),
 Ordering::Release => core::intrinsics::atomic_cxchgweak_release_relaxed(dst, old, next),
 Ordering::AcqRel => core::intrinsics::atomic_cxchgweak_acqrel_relaxed(dst, old, next),
 Ordering::SeqCst => core::intrinsics::atomic_cxchgweak_seqcst_relaxed(dst, old, next),
 _ => unreachable!(),
 };
 if ok {
 return x;
 }
 old = x;
 }
 }
 }
 };
}
#[cfg(target_has_atomic = "8")]
atomic_update!(u8);
#[cfg(target_has_atomic = "16")]
atomic_update!(u16);
#[cfg(target_has_atomic = "32")]
atomic_update!(u32);
#[cfg(target_has_atomic = "64")]
atomic_update!(u64);
#[cfg(any(
 target_arch = "aarch64",
 all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
 target_arch = "s390x",
 all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
))]
atomic_update!(u128);
*/

pub mod load {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A) -> T {
                    core::intrinsics::atomic_load_relaxed(a)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A) -> T {
                    core::intrinsics::atomic_load_acquire(a)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A) -> T {
                    core::intrinsics::atomic_load_seqcst(a)
                }
            }
        };
    }
    #[cfg(target_has_atomic_load_store = "8")]
    t!(u8);
    #[cfg(target_has_atomic_load_store = "16")]
    t!(u16);
    #[cfg(target_has_atomic_load_store = "32")]
    t!(u32);
    #[cfg(target_has_atomic_load_store = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

pub mod store {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) {
                    core::intrinsics::atomic_store_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) {
                    core::intrinsics::atomic_store_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) {
                    core::intrinsics::atomic_store_seqcst(a, val)
                }
            }
        }
    }
    #[cfg(target_has_atomic_load_store = "8")]
    t!(u8);
    #[cfg(target_has_atomic_load_store = "16")]
    t!(u16);
    #[cfg(target_has_atomic_load_store = "32")]
    t!(u32);
    #[cfg(target_has_atomic_load_store = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

pub mod swap {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_xchg_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_xchg_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_xchg_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_xchg_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_xchg_seqcst(a, val)
                }
            }
        }
    }
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

/*
pub mod compare_exchange {
 macro_rules! t {
 ($t:ident) => {
 pub mod $t {
 type T = $t;
 type A = *mut T;
 #[inline(never)]
 pub unsafe fn relaxed_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_relaxed_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn relaxed_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_relaxed_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn relaxed_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_relaxed_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn acquire_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_acquire_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn acquire_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_acquire_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn acquire_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_acquire_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn release_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_release_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn release_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_release_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn release_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_release_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn acqrel_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_acqrel_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn acqrel_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_acqrel_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn acqrel_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_acqrel_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn seqcst_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_seqcst_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn seqcst_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_seqcst_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 #[inline(never)]
 pub unsafe fn seqcst_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchg_seqcst_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 }
 }
 }
 #[cfg(target_has_atomic = "8")]
 t!(u8);
 #[cfg(target_has_atomic = "16")]
 t!(u16);
 #[cfg(target_has_atomic = "32")]
 t!(u32);
 #[cfg(target_has_atomic = "64")]
 t!(u64);
 #[cfg(any(
 target_arch = "aarch64",
 all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
 target_arch = "s390x",
 all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
 ))]
 t!(u128);
}

pub mod compare_exchange_weak {
 macro_rules! t {
 ($t:ident) => {
 pub mod $t {
 type T = $t;
 type A = *mut T;
 // #[inline(never)]
 pub unsafe fn relaxed_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_relaxed_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn relaxed_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_relaxed_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn relaxed_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_relaxed_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn acquire_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_acquire_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn acquire_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_acquire_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn acquire_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_acquire_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn release_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_release_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn release_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_release_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn release_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_release_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn acqrel_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_acqrel_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn acqrel_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_acqrel_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn acqrel_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_acqrel_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn seqcst_relaxed(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_seqcst_relaxed(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn seqcst_acquire(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_seqcst_acquire(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 // #[inline(never)]
 pub unsafe fn seqcst_seqcst(a: A, old: T, new: T) -> Result<T, T> {
 let (val, ok) = core::intrinsics::atomic_cxchgweak_seqcst_seqcst(a, old, new);
 if ok { Ok(val) } else { Err(val) }
 }
 }
 }
 }
 #[cfg(target_has_atomic = "8")]
 t!(u8);
 #[cfg(target_has_atomic = "16")]
 t!(u16);
 #[cfg(target_has_atomic = "32")]
 t!(u32);
 #[cfg(target_has_atomic = "64")]
 t!(u64);
 #[cfg(any(
 target_arch = "aarch64",
 all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
 target_arch = "s390x",
 all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
 ))]
 t!(u128);
}
*/

pub mod fetch_add {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_xadd_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_xadd_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_xadd_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_xadd_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_xadd_seqcst(a, val)
                }
            }
        }
    }
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

pub mod fetch_sub {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_xsub_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_xsub_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_xsub_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_xsub_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_xsub_seqcst(a, val)
                }
            }
        }
    }
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

pub mod fetch_and {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_and_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_and_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_and_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_and_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_and_seqcst(a, val)
                }
            }
        }
    }
    #[cfg(target_has_atomic = "8")]
    t!(i8);
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(target_has_atomic = "16")]
    t!(i16);
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

/*
pub mod fetch_nand {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_nand_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_nand_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_nand_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_nand_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_nand_seqcst(a, val)
                }
            }
        }
    }
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}
*/

pub mod fetch_or {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_or_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_or_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_or_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_or_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_or_seqcst(a, val)
                }
            }
        }
    }
    #[cfg(target_has_atomic = "8")]
    t!(i8);
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(target_has_atomic = "16")]
    t!(i16);
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

pub mod fetch_xor {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_xor_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_xor_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_xor_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_xor_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_xor_seqcst(a, val)
                }
            }
        }
    }
    #[cfg(target_has_atomic = "8")]
    t!(i8);
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(target_has_atomic = "16")]
    t!(i16);
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

pub mod fetch_not {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A) -> T {
                    core::intrinsics::atomic_xor_relaxed(a, T::MAX)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A) -> T {
                    core::intrinsics::atomic_xor_acquire(a, T::MAX)
                }
                #[inline(never)]
                pub unsafe fn release(a: A) -> T {
                    core::intrinsics::atomic_xor_release(a, T::MAX)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A) -> T {
                    core::intrinsics::atomic_xor_acqrel(a, T::MAX)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A) -> T {
                    core::intrinsics::atomic_xor_seqcst(a, T::MAX)
                }
            }
        }
    }
    #[cfg(target_has_atomic = "8")]
    t!(i8);
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(target_has_atomic = "16")]
    t!(i16);
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
}

/*
pub mod fetch_neg {
    macro_rules! u {
        ($t:ident) => {
            pub mod $t {
                use crate::$t::*;
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A) -> T {
                    atomic_update(a, Ordering::Relaxed, $t::wrapping_neg)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A) -> T {
                    atomic_update(a, Ordering::Acquire, $t::wrapping_neg)
                }
                #[inline(never)]
                pub unsafe fn release(a: A) -> T {
                    atomic_update(a, Ordering::Release, $t::wrapping_neg)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A) -> T {
                    atomic_update(a, Ordering::AcqRel, $t::wrapping_neg)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A) -> T {
                    atomic_update(a, Ordering::SeqCst, $t::wrapping_neg)
                }
            }
        }
    }
    #[cfg(target_has_atomic = "8")]
    u!(u8);
    #[cfg(target_has_atomic = "16")]
    u!(u16);
    #[cfg(target_has_atomic = "32")]
    u!(u32);
    #[cfg(target_has_atomic = "64")]
    u!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    u!(u128);
}
*/

pub mod fetch_max {
 macro_rules! t {
 ($t:ident) => {
 pub mod $t {
 type T = $t;
 type A = *mut T;
 #[inline(never)]
 pub unsafe fn relaxed(a: A, val: T) -> T {
 core::intrinsics::atomic_max_relaxed(a, val)
 }
 #[inline(never)]
 pub unsafe fn acquire(a: A, val: T) -> T {
 core::intrinsics::atomic_max_acquire(a, val)
 }
 #[inline(never)]
 pub unsafe fn release(a: A, val: T) -> T {
 core::intrinsics::atomic_max_release(a, val)
 }
 #[inline(never)]
 pub unsafe fn acqrel(a: A, val: T) -> T {
 core::intrinsics::atomic_max_acqrel(a, val)
 }
 #[inline(never)]
 pub unsafe fn seqcst(a: A, val: T) -> T {
 core::intrinsics::atomic_max_seqcst(a, val)
 }
 }
 }
 }
 macro_rules! u {
 ($t:ident, $u:ident) => {
 pub mod $t {
 use crate::$u::*;
 type T = $t;
 type U = $u;
 type A = *mut T;
 #[inline(never)]
 pub unsafe fn relaxed(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::Relaxed, |x| core::cmp::max(x as T, val) as U) as T
 }
 #[inline(never)]
 pub unsafe fn acquire(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::Acquire, |x| core::cmp::max(x as T, val) as U) as T
 }
 #[inline(never)]
 pub unsafe fn release(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::Release, |x| core::cmp::max(x as T, val) as U) as T
 }
 #[inline(never)]
 pub unsafe fn acqrel(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::AcqRel, |x| core::cmp::max(x as T, val) as U) as T
 }
 #[inline(never)]
 pub unsafe fn seqcst(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::SeqCst, |x| core::cmp::max(x as T, val) as U) as T
 }
 }
 }
 }
 #[cfg(portable_atomic_target_feature = "zabha")]
 #[cfg(target_has_atomic = "8")]
 t!(i8);
 #[cfg(portable_atomic_target_feature = "zabha")]
 #[cfg(target_has_atomic = "16")]
 t!(i16);
 #[cfg(target_has_atomic = "32")]
 t!(i32);
 #[cfg(target_has_atomic = "64")]
 t!(i64);
 #[cfg(any(
 target_arch = "aarch64",
 // all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
 target_arch = "s390x",
 all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
 ))]
 t!(i128);
 #[cfg(all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")))]
 u!(i128, u128);
}

pub mod fetch_umax {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_umax_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_umax_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_umax_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_umax_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_umax_seqcst(a, val)
                }
            }
        }
    }
    macro_rules! u {
        ($t:ident) => {
            pub mod $t {
                use crate::$t::*;
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    atomic_update(a, Ordering::Relaxed, |x| core::cmp::max(x, val))
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    atomic_update(a, Ordering::Acquire, |x| core::cmp::max(x, val))
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    atomic_update(a, Ordering::Release, |x| core::cmp::max(x, val))
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    atomic_update(a, Ordering::AcqRel, |x| core::cmp::max(x, val))
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    atomic_update(a, Ordering::SeqCst, |x| core::cmp::max(x, val))
                }
            }
        }
    }
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        // all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
    #[cfg(all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")))]
    u!(u128);
}

pub mod fetch_min {
 macro_rules! t {
 ($t:ident) => {
 pub mod $t {
 type T = $t;
 type A = *mut T;
 #[inline(never)]
 pub unsafe fn relaxed(a: A, val: T) -> T {
 core::intrinsics::atomic_min_relaxed(a, val)
 }
 #[inline(never)]
 pub unsafe fn acquire(a: A, val: T) -> T {
 core::intrinsics::atomic_min_acquire(a, val)
 }
 #[inline(never)]
 pub unsafe fn release(a: A, val: T) -> T {
 core::intrinsics::atomic_min_release(a, val)
 }
 #[inline(never)]
 pub unsafe fn acqrel(a: A, val: T) -> T {
 core::intrinsics::atomic_min_acqrel(a, val)
 }
 #[inline(never)]
 pub unsafe fn seqcst(a: A, val: T) -> T {
 core::intrinsics::atomic_min_seqcst(a, val)
 }
 }
 }
 }
 macro_rules! u {
 ($t:ident, $u:ident) => {
 pub mod $t {
 use crate::$u::*;
 type T = $t;
 type U = $u;
 type A = *mut T;
 #[inline(never)]
 pub unsafe fn relaxed(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::Relaxed, |x| core::cmp::min(x as T, val) as U) as T
 }
 #[inline(never)]
 pub unsafe fn acquire(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::Acquire, |x| core::cmp::min(x as T, val) as U) as T
 }
 #[inline(never)]
 pub unsafe fn release(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::Release, |x| core::cmp::min(x as T, val) as U) as T
 }
 #[inline(never)]
 pub unsafe fn acqrel(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::AcqRel, |x| core::cmp::min(x as T, val) as U) as T
 }
 #[inline(never)]
 pub unsafe fn seqcst(a: A, val: T) -> T {
 atomic_update(a.cast::(), Ordering::SeqCst, |x| core::cmp::min(x as T, val) as U) as T
 }
 }
 }
 }
 #[cfg(portable_atomic_target_feature = "zabha")]
 #[cfg(target_has_atomic = "8")]
 t!(i8);
 #[cfg(portable_atomic_target_feature = "zabha")]
 #[cfg(target_has_atomic = "16")]
 t!(i16);
 #[cfg(target_has_atomic = "32")]
 t!(i32);
 #[cfg(target_has_atomic = "64")]
 t!(i64);
 #[cfg(any(
 target_arch = "aarch64",
 // all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
 target_arch = "s390x",
 all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
 ))]
 t!(i128);
 #[cfg(all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")))]
 u!(i128, u128);
}

pub mod fetch_umin {
    macro_rules! t {
        ($t:ident) => {
            pub mod $t {
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    core::intrinsics::atomic_umin_relaxed(a, val)
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    core::intrinsics::atomic_umin_acquire(a, val)
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    core::intrinsics::atomic_umin_release(a, val)
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    core::intrinsics::atomic_umin_acqrel(a, val)
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    core::intrinsics::atomic_umin_seqcst(a, val)
                }
            }
        }
    }
    macro_rules! u {
        ($t:ident) => {
            pub mod $t {
                use crate::$t::*;
                type T = $t;
                type A = *mut T;
                #[inline(never)]
                pub unsafe fn relaxed(a: A, val: T) -> T {
                    atomic_update(a, Ordering::Relaxed, |x| core::cmp::min(x, val))
                }
                #[inline(never)]
                pub unsafe fn acquire(a: A, val: T) -> T {
                    atomic_update(a, Ordering::Acquire, |x| core::cmp::min(x, val))
                }
                #[inline(never)]
                pub unsafe fn release(a: A, val: T) -> T {
                    atomic_update(a, Ordering::Release, |x| core::cmp::min(x, val))
                }
                #[inline(never)]
                pub unsafe fn acqrel(a: A, val: T) -> T {
                    atomic_update(a, Ordering::AcqRel, |x| core::cmp::min(x, val))
                }
                #[inline(never)]
                pub unsafe fn seqcst(a: A, val: T) -> T {
                    atomic_update(a, Ordering::SeqCst, |x| core::cmp::min(x, val))
                }
            }
        }
    }
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "8")]
    t!(u8);
    #[cfg(portable_atomic_target_feature = "zabha")]
    #[cfg(target_has_atomic = "16")]
    t!(u16);
    #[cfg(target_has_atomic = "32")]
    t!(u32);
    #[cfg(target_has_atomic = "64")]
    t!(u64);
    #[cfg(any(
        target_arch = "aarch64",
        // all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")),
        target_arch = "s390x",
        all(target_arch = "x86_64", target_feature = "cmpxchg16b"),
    ))]
    t!(u128);
    #[cfg(all(target_arch = "powerpc64", any(portable_atomic_target_feature = "quadword-atomics", atomic_maybe_uninit_target_feature = "quadword-atomics")))]
    u!(u128);
}

Source code

#![no_std]
#![allow(unused, internal_features)]
#![feature(cfg_target_has_atomic, core_intrinsics)]