sync.stdatomic: fix bug with add() and sub() returning the new values, add voidptr support, add swap() and compare_and_swap() (#24685)

Author: kbkpbot

thirdparty/stdatomic/nix/atomic.h

@@ -693,35 +693,35 @@ extern inline unsigned long long __aarch64_ldeor8_relax(unsigned long long*ptr,
 
 // Since V might be confused with "generic" C functions either we provide special versions
 // for gcc/clang, too
-static inline unsigned long long atomic_load_u64(unsigned long long* x) {
-	return atomic_load_explicit((_Atomic (unsigned long long)*)x, memory_order_seq_cst);
+static inline unsigned long long atomic_load_u64(uint64_t* x) {
+	return atomic_load_explicit((_Atomic (uint64_t)*)x, memory_order_seq_cst);
 }
-static inline void atomic_store_u64(unsigned long long* x, unsigned long long y) {
-	atomic_store_explicit((_Atomic(unsigned long long)*)x, y, memory_order_seq_cst);
+static inline void atomic_store_u64(uint64_t* x, uint64_t y) {
+	atomic_store_explicit((_Atomic(uint64_t)*)x, y, memory_order_seq_cst);
 }
-static inline int atomic_compare_exchange_weak_u64(unsigned long long* x, unsigned long long* expected, unsigned long long y) {
-	return (int)atomic_compare_exchange_weak_explicit((_Atomic(unsigned long long)*)x, expected, y, memory_order_seq_cst, memory_order_seq_cst);
+static inline int atomic_compare_exchange_weak_u64(uint64_t* x, uint64_t* expected, uint64_t y) {
+	return (int)atomic_compare_exchange_weak_explicit((_Atomic(uint64_t)*)x, expected, y, memory_order_seq_cst, memory_order_seq_cst);
 }
-static inline int atomic_compare_exchange_strong_u64(unsigned long long* x, unsigned long long* expected, unsigned long long y) {
-	return (int)atomic_compare_exchange_strong_explicit((_Atomic(unsigned long long)*)x, expected, y, memory_order_seq_cst, memory_order_seq_cst);
+static inline int atomic_compare_exchange_strong_u64(uint64_t* x, uint64_t* expected, uint64_t y) {
+	return (int)atomic_compare_exchange_strong_explicit((_Atomic(uint64_t)*)x, expected, y, memory_order_seq_cst, memory_order_seq_cst);
 }
-static inline unsigned long long atomic_exchange_u64(unsigned long long* x, unsigned long long y) {
-	return atomic_exchange_explicit((_Atomic(unsigned long long)*)x, y, memory_order_seq_cst);
+static inline unsigned long long atomic_exchange_u64(uint64_t* x, uint64_t y) {
+	return atomic_exchange_explicit((_Atomic(uint64_t)*)x, y, memory_order_seq_cst);
 }
-static inline unsigned long long atomic_fetch_add_u64(unsigned long long* x, unsigned long long y) {
-	return atomic_fetch_add_explicit((_Atomic(unsigned long long)*)x, y, memory_order_seq_cst);
+static inline unsigned long long atomic_fetch_add_u64(uint64_t* x, uint64_t y) {
+	return atomic_fetch_add_explicit((_Atomic(uint64_t)*)x, y, memory_order_seq_cst);
 }
-static inline unsigned long long atomic_fetch_sub_u64(unsigned long long* x, unsigned long long y) {
-	return atomic_fetch_sub_explicit((_Atomic(unsigned long long)*)x, y, memory_order_seq_cst);
+static inline unsigned long long atomic_fetch_sub_u64(uint64_t* x, uint64_t y) {
+	return atomic_fetch_sub_explicit((_Atomic(uint64_t)*)x, y, memory_order_seq_cst);
 }
-static inline unsigned long long atomic_fetch_and_u64(unsigned long long* x, unsigned long long y) {
-	return atomic_fetch_and_explicit((_Atomic(unsigned long long)*)x, y, memory_order_seq_cst);
+static inline unsigned long long atomic_fetch_and_u64(uint64_t* x, uint64_t y) {
+	return atomic_fetch_and_explicit((_Atomic(uint64_t)*)x, y, memory_order_seq_cst);
 }
-static inline unsigned long long atomic_fetch_or_u64(unsigned long long* x, unsigned long long y) {
-	return atomic_fetch_or_explicit((_Atomic(unsigned long long)*)x, y, memory_order_seq_cst);
+static inline unsigned long long atomic_fetch_or_u64(uint64_t* x, uint64_t y) {
+	return atomic_fetch_or_explicit((_Atomic(uint64_t)*)x, y, memory_order_seq_cst);
 }
-static inline unsigned long long atomic_fetch_xor_u64(unsigned long long* x, unsigned long long y) {
-	return atomic_fetch_xor_explicit((_Atomic(unsigned long long)*)x, y, memory_order_seq_cst);
+static inline unsigned long long atomic_fetch_xor_u64(uint64_t* x, uint64_t y) {
+	return atomic_fetch_xor_explicit((_Atomic(uint64_t)*)x, y, memory_order_seq_cst);
 }
 
 

thirdparty/stdatomic/win/atomic.h

@@ -294,8 +294,20 @@ static inline int atomic_compare_exchange_strong_u32(unsigned volatile * object,
 
 #else
 
+#define InterlockedExchange16 ManualInterlockedExchange16
 #define InterlockedExchangeAdd16 ManualInterlockedExchangeAdd16
 
+static inline uint16_t ManualInterlockedExchange16(volatile uint16_t* object, uint16_t desired) {
+    __asm__ __volatile__ (
+        "xchgw %0, %1"
+        : "+r" (desired),
+          "+m" (*object)
+        :
+        : "memory"
+    );
+    return desired;
+}
+
 static inline unsigned short ManualInterlockedExchangeAdd16(unsigned short volatile* Addend, unsigned short Value) {
     __asm__ __volatile__ (
         "lock xaddw %w[value], %[mem]"
@@ -385,12 +397,23 @@ static inline int atomic_compare_exchange_strong_u16(unsigned short volatile * o
 
 #else
 
+#define InterlockedExchange8 ManualInterlockedExchange8
 #define InterlockedCompareExchange8 ManualInterlockedCompareExchange8
 #define InterlockedExchangeAdd8 ManualInterlockedExchangeAdd8
 #define InterlockedOr8 ManualInterlockedOr8
 #define InterlockedXor8 ManualInterlockedXor8
 #define InterlockedAnd8 ManualInterlockedAnd8
 
+static inline char ManualInterlockedExchange8(char volatile* object, char desired) {
+    __asm__ __volatile__ (
+        "xchgb %0, %1"
+        : "+q" (desired), "+m" (*object)
+        :
+        : "memory"
+    );
+    return desired;
+}
+
 static inline unsigned char ManualInterlockedCompareExchange8(unsigned char volatile * dest, unsigned char exchange, unsigned char comparand) {
    unsigned char result;
 

vlib/sync/stdatomic/atomic.c.v

@@ -69,8 +69,6 @@ pub struct AtomicVal[T] {
 // new_atomic creates a new atomic value of `T` type
 @[inline]
 pub fn new_atomic[T](val T) &AtomicVal[T] {
-	// can't use `$if T is $int || T is bool` with $compile_error() now
-	// see issue #24562
 	$if T is $int {
 		return &AtomicVal[T]{
 			val: val
@@ -79,8 +77,12 @@ pub fn new_atomic[T](val T) &AtomicVal[T] {
 		return &AtomicVal[T]{
 			val: val
 		}
+	} $else $if T is voidptr {
+		return &AtomicVal[T]{
+			val: val
+		}
 	} $else {
-		$compile_error('atomic: only support number and bool types')
+		$compile_error('atomic: only support number, bool, and voidptr types')
 	}
 	return unsafe { nil }
 }
@@ -99,19 +101,24 @@ pub fn (mut a AtomicVal[T]) load() T {
 	} $else $if T is u64 || T is i64 {
 		return T(C.atomic_load_u64(voidptr(&a.val)))
 	} $else $if T is int {
-		// TODO: remove this test or a compile time support $if sizeof() ==
 		if sizeof(int) == 4 {
 			return int(C.atomic_load_u32(voidptr(&a.val)))
 		} else {
 			return int(C.atomic_load_u64(voidptr(&a.val)))
 		}
 	} $else $if T is isize || T is usize {
-		// TODO: remove this test or a compile time support $if sizeof() ==
 		if sizeof(isize) == 4 {
 			return T(C.atomic_load_u32(voidptr(&a.val)))
 		} else {
 			return T(C.atomic_load_u64(voidptr(&a.val)))
 		}
+	} $else $if T is voidptr {
+		// TODO: this should be $if sizeof(T) == 4
+		$if x32 {
+			return T(C.atomic_load_u32(voidptr(&a.val)))
+		} $else {
+			return T(C.atomic_load_u64(voidptr(&a.val)))
+		}
 	}
 	return a.val
 }
@@ -120,90 +127,207 @@ pub fn (mut a AtomicVal[T]) load() T {
 @[inline]
 pub fn (mut a AtomicVal[T]) store(val T) {
 	$if T is bool {
-		C.atomic_store_byte(voidptr(&a.val), val)
+		C.atomic_store_byte(voidptr(&a.val), u8(val))
 	} $else $if T is u8 || T is i8 {
-		C.atomic_store_byte(voidptr(&a.val), val)
+		C.atomic_store_byte(voidptr(&a.val), u8(val))
 	} $else $if T is u16 || T is i16 {
-		C.atomic_store_u16(voidptr(&a.val), val)
+		C.atomic_store_u16(voidptr(&a.val), u16(val))
 	} $else $if T is u32 || T is i32 {
-		C.atomic_store_u32(voidptr(&a.val), val)
+		C.atomic_store_u32(voidptr(&a.val), u32(val))
 	} $else $if T is u64 || T is i64 {
-		C.atomic_store_u64(voidptr(&a.val), val)
+		C.atomic_store_u64(voidptr(&a.val), u64(val))
 	} $else $if T is int {
-		// TODO: remove this test or a compile time support $if sizeof() ==
 		if sizeof(int) == 4 {
-			C.atomic_store_u32(voidptr(&a.val), val)
+			C.atomic_store_u32(voidptr(&a.val), u32(val))
 		} else {
-			C.atomic_store_u64(voidptr(&a.val), val)
+			C.atomic_store_u64(voidptr(&a.val), u64(val))
 		}
 	} $else $if T is isize || T is usize {
-		// TODO: remove this test or a compile time support $if sizeof() ==
 		if sizeof(isize) == 4 {
-			C.atomic_store_u32(voidptr(&a.val), val)
+			C.atomic_store_u32(voidptr(&a.val), u32(val))
 		} else {
-			C.atomic_store_u64(voidptr(&a.val), val)
+			C.atomic_store_u64(voidptr(&a.val), u64(val))
+		}
+	} $else $if T is voidptr {
+		// TODO: this should be $if sizeof(T) == 4
+		$if x32 {
+			C.atomic_store_u32(voidptr(&a.val), u32(val))
+		} $else {
+			C.atomic_store_u64(voidptr(&a.val), u64(val))
 		}
 	}
 }
 
-// add adds the atomic value with `delta`
+// add adds the atomic value with `delta` and returns the previous value
 @[inline]
 pub fn (mut a AtomicVal[T]) add(delta T) T {
 	$if T is bool {
-		panic('atomic: can not add() a bool type')
+		panic('atomic: add() not supported for bool type')
+	} $else $if T is voidptr {
+		panic('atomic: add() not supported for voidptr type')
 	} $else $if T is u8 || T is i8 {
-		C.atomic_fetch_add_byte(voidptr(&a.val), delta)
+		old := C.atomic_fetch_add_byte(voidptr(&a.val), u8(delta))
+		return T(old)
 	} $else $if T is u16 || T is i16 {
-		C.atomic_fetch_add_u16(voidptr(&a.val), delta)
+		old := C.atomic_fetch_add_u16(voidptr(&a.val), u16(delta))
+		return T(old)
 	} $else $if T is u32 || T is i32 {
-		C.atomic_fetch_add_u32(voidptr(&a.val), delta)
+		old := C.atomic_fetch_add_u32(voidptr(&a.val), u32(delta))
+		return T(old)
 	} $else $if T is u64 || T is i64 {
-		C.atomic_fetch_add_u64(voidptr(&a.val), delta)
+		old := C.atomic_fetch_add_u64(voidptr(&a.val), u64(delta))
+		return T(old)
 	} $else $if T is int {
-		// TODO: remove this test or a compile time support $if sizeof() ==
 		if sizeof(int) == 4 {
-			C.atomic_fetch_add_u32(voidptr(&a.val), delta)
+			old := C.atomic_fetch_add_u32(voidptr(&a.val), u32(delta))
+			return T(old)
 		} else {
-			C.atomic_fetch_add_u64(voidptr(&a.val), delta)
+			old := C.atomic_fetch_add_u64(voidptr(&a.val), u64(delta))
+			return T(old)
 		}
 	} $else $if T is isize || T is usize {
-		// TODO: remove this test or a compile time support $if sizeof() ==
 		if sizeof(isize) == 4 {
-			C.atomic_fetch_add_u32(voidptr(&a.val), delta)
+			old := C.atomic_fetch_add_u32(voidptr(&a.val), u32(delta))
+			return T(old)
 		} else {
-			C.atomic_fetch_add_u64(voidptr(&a.val), delta)
+			old := C.atomic_fetch_add_u64(voidptr(&a.val), u64(delta))
+			return T(old)
 		}
 	}
-	return T(a.val)
+	panic('unreachable')
 }
 
-// sub subs the atomic value with `delta`
+// sub subtracts the atomic value with `delta` and returns the previous value
 @[inline]
 pub fn (mut a AtomicVal[T]) sub(delta T) T {
 	$if T is bool {
-		panic('atomic: can not sub() a bool type')
+		panic('atomic: sub() not supported for bool type')
+	} $else $if T is voidptr {
+		panic('atomic: sub() not supported for voidptr type')
 	} $else $if T is u8 || T is i8 {
-		C.atomic_fetch_sub_byte(voidptr(&a.val), delta)
+		old := C.atomic_fetch_sub_byte(voidptr(&a.val), u8(delta))
+		return T(old)
 	} $else $if T is u16 || T is i16 {
-		C.atomic_fetch_sub_u16(voidptr(&a.val), delta)
+		old := C.atomic_fetch_sub_u16(voidptr(&a.val), u16(delta))
+		return T(old)
 	} $else $if T is u32 || T is i32 {
-		C.atomic_fetch_sub_u32(voidptr(&a.val), delta)
+		old := C.atomic_fetch_sub_u32(voidptr(&a.val), u32(delta))
+		return T(old)
 	} $else $if T is u64 || T is i64 {
-		C.atomic_fetch_sub_u64(voidptr(&a.val), delta)
+		old := C.atomic_fetch_sub_u64(voidptr(&a.val), u64(delta))
+		return T(old)
 	} $else $if T is int {
-		// TODO: remove this test or a compile time support $if sizeof() ==
 		if sizeof(int) == 4 {
-			C.atomic_fetch_sub_u32(voidptr(&a.val), delta)
+			old := C.atomic_fetch_sub_u32(voidptr(&a.val), u32(delta))
+			return T(old)
 		} else {
-			C.atomic_fetch_sub_u64(voidptr(&a.val), delta)
+			old := C.atomic_fetch_sub_u64(voidptr(&a.val), u64(delta))
+			return T(old)
 		}
 	} $else $if T is isize || T is usize {
-		// TODO: remove this test or a compile time support $if sizeof() ==
 		if sizeof(isize) == 4 {
-			C.atomic_fetch_sub_u32(voidptr(&a.val), delta)
+			old := C.atomic_fetch_sub_u32(voidptr(&a.val), u32(delta))
+			return T(old)
+		} else {
+			old := C.atomic_fetch_sub_u64(voidptr(&a.val), u64(delta))
+			return T(old)
+		}
+	}
+	panic('unreachable')
+}
+
+// swap sets the `new` value and returns the previous value
+@[inline]
+pub fn (mut a AtomicVal[T]) swap(new T) T {
+	$if T is bool {
+		old := C.atomic_exchange_byte(voidptr(&a.val), u8(new))
+		return old != 0
+	} $else $if T is u8 || T is i8 {
+		old := C.atomic_exchange_byte(voidptr(&a.val), u8(new))
+		return T(old)
+	} $else $if T is u16 || T is i16 {
+		old := C.atomic_exchange_u16(voidptr(&a.val), u16(new))
+		return T(old)
+	} $else $if T is u32 || T is i32 {
+		old := C.atomic_exchange_u32(voidptr(&a.val), u32(new))
+		return T(old)
+	} $else $if T is u64 || T is i64 {
+		old := C.atomic_exchange_u64(voidptr(&a.val), u64(new))
+		return T(old)
+	} $else $if T is int {
+		if sizeof(int) == 4 {
+			old := C.atomic_exchange_u32(voidptr(&a.val), u32(new))
+			return T(old)
 		} else {
-			C.atomic_fetch_sub_u64(voidptr(&a.val), delta)
+			old := C.atomic_exchange_u64(voidptr(&a.val), u64(new))
+			return T(old)
+		}
+	} $else $if T is isize || T is usize {
+		if sizeof(isize) == 4 {
+			old := C.atomic_exchange_u32(voidptr(&a.val), u32(new))
+			return T(old)
+		} else {
+			old := C.atomic_exchange_u64(voidptr(&a.val), u64(new))
+			return T(old)
+		}
+	} $else $if T is voidptr {
+		// TODO: this should be $if sizeof(T) == 4
+		$if x32 {
+			old := C.atomic_exchange_u32(voidptr(&a.val), u32(new))
+			return T(old)
+		} $else {
+			old := C.atomic_exchange_u64(voidptr(&a.val), u64(new))
+			return T(old)
+		}
+	}
+	panic('unreachable')
+}
+
+// compare_and_swap executes the compare-and-swap(CAS) operation
+// if atomic value == `expected`, then it will be set to `new`, and return true
+// else return false, and the atomic value remains unchanged
+@[inline]
+pub fn (mut a AtomicVal[T]) compare_and_swap(expected T, new T) bool {
+	$if T is bool {
+		mut exp := u8(expected)
+		return C.atomic_compare_exchange_strong_byte(voidptr(&a.val), &exp, u8(new))
+	} $else $if T is u8 || T is i8 {
+		mut exp := u8(expected)
+		return C.atomic_compare_exchange_strong_byte(voidptr(&a.val), &exp, u8(new))
+	} $else $if T is u16 || T is i16 {
+		mut exp := u16(expected)
+		return C.atomic_compare_exchange_strong_u16(voidptr(&a.val), &exp, u16(new))
+	} $else $if T is u32 || T is i32 {
+		mut exp := u32(expected)
+		return C.atomic_compare_exchange_strong_u32(voidptr(&a.val), &exp, u32(new))
+	} $else $if T is u64 || T is i64 {
+		mut exp := u64(expected)
+		return C.atomic_compare_exchange_strong_u64(voidptr(&a.val), &exp, u64(new))
+	} $else $if T is int {
+		if sizeof(int) == 4 {
+			mut exp := u32(expected)
+			return C.atomic_compare_exchange_strong_u32(voidptr(&a.val), &exp, u32(new))
+		} else {
+			mut exp := u64(expected)
+			return C.atomic_compare_exchange_strong_u64(voidptr(&a.val), &exp, u64(new))
+		}
+	} $else $if T is isize || T is usize {
+		if sizeof(isize) == 4 {
+			mut exp := u32(expected)
+			return C.atomic_compare_exchange_strong_u32(voidptr(&a.val), &exp, u32(new))
+		} else {
+			mut exp := u64(expected)
+			return C.atomic_compare_exchange_strong_u64(voidptr(&a.val), &exp, u64(new))
+		}
+	} $else $if T is voidptr {
+		// TODO: this should be $if sizeof(T) == 4
+		$if x32 {
+			mut exp := u32(expected)
+			return C.atomic_compare_exchange_strong_u32(voidptr(&a.val), &exp, u32(new))
+		} $else {
+			mut exp := u64(expected)
+			return C.atomic_compare_exchange_strong_u64(voidptr(&a.val), &exp, u64(new))
 		}
 	}
-	return T(a.val)
+	panic('unreachable')
 }