From 00d60125df8a853bafe76b970138dfb75083d628 Mon Sep 17 00:00:00 2001
From: Pedro J. Estébanez
Date: Tue, 11 Jul 2017 17:41:53 +0200
Subject: Implement add & subtract atomics

---
 core/safe_refcount.cpp | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)

(limited to 'core/safe_refcount.cpp')

diff --git a/core/safe_refcount.cpp b/core/safe_refcount.cpp
index 4a57c09f1..1bd16f9e4 100644
--- a/core/safe_refcount.cpp
+++ b/core/safe_refcount.cpp
@@ -62,6 +62,22 @@ static _ALWAYS_INLINE_T _atomic_increment_impl(register T *pw) {
 	return *pw;
 }
 
+template <class T>
+static _ALWAYS_INLINE_ T _atomic_sub_impl(register T *pw, register T val) {
+
+	(*pw) -= val;
+
+	return *pw;
+}
+
+template <class T>
+static _ALWAYS_INLINE_T _atomic_add_impl(register T *pw, register T val) {
+
+	(*pw) += val;
+
+	return *pw;
+}
+
 #elif defined(__GNUC__)
 
 /* Implementation for GCC & Clang */
@@ -93,6 +109,18 @@ static _ALWAYS_INLINE_ T _atomic_increment_impl(register T *pw) {
 	return __sync_add_and_fetch(pw, 1);
 }
 
+template <class T>
+static _ALWAYS_INLINE_ T _atomic_sub_impl(register T *pw, register T val) {
+
+	return __sync_sub_and_fetch(pw, val);
+}
+
+template <class T>
+static _ALWAYS_INLINE_ T _atomic_add_impl(register T *pw, register T val) {
+
+	return __sync_add_and_fetch(pw, val);
+}
+
 #elif defined(_MSC_VER)
 
 /* Implementation for MSVC-Windows */
@@ -126,6 +154,20 @@ static _ALWAYS_INLINE_ uint32_t _atomic_increment_impl(register uint32_t *pw) {
 	return InterlockedIncrement((LONG volatile *)pw);
 }
 
+static _ALWAYS_INLINE_ uint32_t _atomic_sub_impl(register uint32_t *pw, register uint32_t val) {
+
+#if _WIN32_WINNT >= 0x0601 // Windows 7+
+	return InterlockedExchangeSubtract(pw, val) - val;
+#else
+	return InterlockedExchangeAdd((LONG volatile *)pw, -(int32_t)val) - val;
+#endif
+}
+
+static _ALWAYS_INLINE_ uint32_t _atomic_add_impl(register uint32_t *pw, register uint32_t val) {
+
+	return InterlockedAdd((LONG volatile *)pw, val);
+}
+
 static _ALWAYS_INLINE_ uint64_t _atomic_conditional_increment_impl(register uint64_t *pw) {
 
 	ATOMIC_CONDITIONAL_INCREMENT_BODY(pw, LONGLONG, InterlockedCompareExchange64, uint64_t)
@@ -141,6 +183,20 @@ static _ALWAYS_INLINE_ uint64_t _atomic_increment_impl(register uint64_t *pw) {
 	return InterlockedIncrement64((LONGLONG volatile *)pw);
 }
 
+static _ALWAYS_INLINE_ uint64_t _atomic_sub_impl(register uint64_t *pw, register uint64_t val) {
+
+#if _WIN32_WINNT >= 0x0601 // Windows 7+
+	return InterlockedExchangeSubtract64(pw, val) - val;
+#else
+	return InterlockedExchangeAdd64((LONGLONG volatile *)pw, -(int64_t)val) - val;
+#endif
+}
+
+static _ALWAYS_INLINE_ uint64_t _atomic_add_impl(register uint64_t *pw, register uint64_t val) {
+
+	return InterlockedAdd64((LONGLONG volatile *)pw, val);
+}
+
 #else
 
 //no threads supported?
@@ -162,6 +218,14 @@ uint32_t atomic_increment(register uint32_t *pw) {
 	return _atomic_increment_impl(pw);
 }
 
+uint32_t atomic_sub(register uint32_t *pw, register uint32_t val) {
+	return _atomic_sub_impl(pw, val);
+}
+
+uint32_t atomic_add(register uint32_t *pw, register uint32_t val) {
+	return _atomic_add_impl(pw, val);
+}
+
 uint64_t atomic_conditional_increment(register uint64_t *counter) {
 	return _atomic_conditional_increment_impl(counter);
 }
@@ -173,3 +237,11 @@ uint64_t atomic_decrement(register uint64_t *pw) {
 uint64_t atomic_increment(register uint64_t *pw) {
 	return _atomic_increment_impl(pw);
 }
+
+uint64_t atomic_sub(register uint64_t *pw, register uint64_t val) {
+	return _atomic_sub_impl(pw, val);
+}
+
+uint64_t atomic_add(register uint64_t *pw, register uint64_t val) {
+	return _atomic_add_impl(pw, val);
+}
-- 
cgit v1.2.3-70-g09d2