AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Mark all atomic functions as Q_DECL_NOTHROW

Browse Source 
Actually, only the "new" atomics are marked. The old implementation,
based on qoldbasicatomic.h is unchanged, but should still work without a
problem.

The following configurations were tested and do work:
 - x86 64-bit
 - x86 32-bit
 - generic GCC
 - generic C++11 std::atomic
 - bootstrap
 - ARMv6 and 7
 - MIPS
 - MSVC 2010 32-bit
 - MSVC 2010 64-bit

The only two configurations untested are IA-64 and ARMv5. Except for
MSVC, all configurations were tested with GCC 4.6 (MIPS and ARM) and 4.7
(x86 and generics).

Change-Id: Iecbfeacd9d20b535453e91335165e9a221e0b47e
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
This commit is contained in:
Thiago Macieira 2012-08-06 17:48:42 +02:00 committed by Qt by Nokia
parent 2d9c2c0562
commit 6bf4e448fe
12 changed files with 307 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/corelib/arch/qatomic_armv5.h
View File

@ -82,13 +82,13 @@ template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<si
{ {
// kernel places a restartable cmpxchg implementation at a fixed address // kernel places a restartable cmpxchg implementation at a fixed address
template <typename T> template <typename T>
static int _q_cmpxchg(T oldval, T newval, volatile T *ptr) static int _q_cmpxchg(T oldval, T newval, volatile T *ptr) Q_DECL_NOTHROW
{ {
typedef int (* kernel_cmpxchg_t)(T oldval, T newval, volatile T *ptr); typedef int (* kernel_cmpxchg_t)(T oldval, T newval, volatile T *ptr);
kernel_cmpxchg_t kernel_cmpxchg = *reinterpret_cast<kernel_cmpxchg_t>(0xffff0fc0); kernel_cmpxchg_t kernel_cmpxchg = *reinterpret_cast<kernel_cmpxchg_t>(0xffff0fc0);
return kernel_cmpxchg(oldval, newval, ptr); return kernel_cmpxchg(oldval, newval, ptr);
} }
static void _q_dmb() static void _q_dmb() Q_DECL_NOTHROW
{ {
typedef void (* kernel_dmb_t)(); typedef void (* kernel_dmb_t)();
kernel_dmb_t kernel_dmb = *reinterpret_cast<kernel_dmb_t>(0xffff0fa0); kernel_dmb_t kernel_dmb = *reinterpret_cast<kernel_dmb_t>(0xffff0fa0);
@ -96,17 +96,17 @@ template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<si
} }
template <typename T> template <typename T>
static void orderedMemoryFence(const T &) { _q_dmb(); } static void orderedMemoryFence(const T &) Q_DECL_NOTHROW { _q_dmb(); }
template <typename T> static bool ref(T &_q_value); template <typename T> static bool ref(T &_q_value) Q_DECL_NOTHROW;
template <typename T> static bool deref(T &_q_value); template <typename T> static bool deref(T &_q_value) Q_DECL_NOTHROW;
static bool isTestAndSetNative() { return false; } static bool isTestAndSetNative() Q_DECL_NOTHROW { return false; }
static bool isTestAndSetWaitFree() { return false; } static bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue); template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW;
template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue); template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW;
template <typename T> static template <typename T> static
T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd); T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
}; };
template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)> template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
@ -115,7 +115,7 @@ template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
}; };
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::ref(T &_q_value) bool QBasicAtomicOps<4>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -127,7 +127,7 @@ bool QBasicAtomicOps<4>::ref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::deref(T &_q_value) bool QBasicAtomicOps<4>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -139,7 +139,7 @@ bool QBasicAtomicOps<4>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
do { do {
@ -153,7 +153,7 @@ bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newVa
// Fetch and store for integers // Fetch and store for integers
#ifdef Q_CC_RVCT #ifdef Q_CC_RVCT
template<> template <typename T> inline template<> template <typename T> inline
__asm T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) __asm T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
add r2, pc, #0 add r2, pc, #0
bx r2 bx r2
@ -165,7 +165,7 @@ __asm T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
#else #else
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
T originalValue; T originalValue;
asm volatile("swp %0,%2,[%3]" asm volatile("swp %0,%2,[%3]"
@ -177,7 +177,7 @@ T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue)
#endif // Q_CC_RVCT #endif // Q_CC_RVCT
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;

80
src/corelib/arch/qatomic_armv6.h
View File

@ -78,22 +78,22 @@ template<> struct QAtomicIntegerTraits<unsigned int> { enum { IsInteger = 1 }; }
template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> > template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> >
{ {
template <typename T> template <typename T>
static void orderedMemoryFence(const T &); static void orderedMemoryFence(const T &) Q_DECL_NOTHROW;
static inline bool isReferenceCountingNative() { return true; } static inline bool isReferenceCountingNative() Q_DECL_NOTHROW { return true; }
template <typename T> static bool ref(T &_q_value); template <typename T> static bool ref(T &_q_value) Q_DECL_NOTHROW;
template <typename T> static bool deref(T &_q_value); template <typename T> static bool deref(T &_q_value) Q_DECL_NOTHROW;
static inline bool isTestAndSetNative() { return true; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return true; }
static inline bool isTestAndSetWaitFree() { return false; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue); template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndStoreNative() { return true; } static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { return true; }
template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue); template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndAddNative() { return true; } static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return true; }
template <typename T> static template <typename T> static
T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd); T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
}; };
template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)> template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
@ -111,7 +111,7 @@ template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
#endif #endif
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::ref(T &_q_value) bool QBasicAtomicOps<4>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
register T newValue; register T newValue;
register int result; register int result;
@ -130,7 +130,7 @@ bool QBasicAtomicOps<4>::ref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::deref(T &_q_value) bool QBasicAtomicOps<4>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
register T newValue; register T newValue;
register int result; register int result;
@ -149,7 +149,7 @@ bool QBasicAtomicOps<4>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
register int result; register int result;
asm volatile("0:\n" asm volatile("0:\n"
@ -169,7 +169,7 @@ bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register int result; register int result;
@ -188,7 +188,7 @@ T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -245,7 +245,7 @@ template<> struct QAtomicIntegerTraits<unsigned long long> { enum { IsInteger =
#define Q_ATOMIC_INT64_FETCH_AND_ADD_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT64_FETCH_AND_ADD_IS_ALWAYS_NATIVE
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<1>::ref(T &_q_value) bool QBasicAtomicOps<1>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
register T newValue; register T newValue;
register int result; register int result;
@ -264,7 +264,7 @@ bool QBasicAtomicOps<1>::ref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<1>::deref(T &_q_value) bool QBasicAtomicOps<1>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
register T newValue; register T newValue;
register int result; register int result;
@ -283,7 +283,7 @@ bool QBasicAtomicOps<1>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<1>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<1>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
register T result; register T result;
asm volatile("0:\n" asm volatile("0:\n"
@ -303,7 +303,7 @@ bool QBasicAtomicOps<1>::testAndSetRelaxed(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<1>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register int result; register int result;
@ -322,7 +322,7 @@ T QBasicAtomicOps<1>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -344,7 +344,7 @@ T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<2>::ref(T &_q_value) bool QBasicAtomicOps<2>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
register T newValue; register T newValue;
register int result; register int result;
@ -363,7 +363,7 @@ bool QBasicAtomicOps<2>::ref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<2>::deref(T &_q_value) bool QBasicAtomicOps<2>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
register T newValue; register T newValue;
register int result; register int result;
@ -382,7 +382,7 @@ bool QBasicAtomicOps<2>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<2>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<2>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
register T result; register T result;
asm volatile("0:\n" asm volatile("0:\n"
@ -402,7 +402,7 @@ bool QBasicAtomicOps<2>::testAndSetRelaxed(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<2>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<2>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register int result; register int result;
@ -421,7 +421,7 @@ T QBasicAtomicOps<2>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -451,7 +451,7 @@ T QBasicAtomicOps<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveTy
// If this is a little-endian build, H and R are the same; otherwise, H and Q are the same. // If this is a little-endian build, H and R are the same; otherwise, H and Q are the same.
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<8>::ref(T &_q_value) bool QBasicAtomicOps<8>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
register T newValue; register T newValue;
register int result; register int result;
@ -471,7 +471,7 @@ bool QBasicAtomicOps<8>::ref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<8>::deref(T &_q_value) bool QBasicAtomicOps<8>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
register T newValue; register T newValue;
register int result; register int result;
@ -491,7 +491,7 @@ bool QBasicAtomicOps<8>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
register T result; register T result;
asm volatile("0:\n" asm volatile("0:\n"
@ -513,7 +513,7 @@ bool QBasicAtomicOps<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<8>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register int result; register int result;
@ -532,7 +532,7 @@ T QBasicAtomicOps<8>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -577,7 +577,7 @@ T QBasicAtomicOps<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveTy
# define Q_COMPILER_MEMORY_BARRIER __schedule_barrier() # define Q_COMPILER_MEMORY_BARRIER __schedule_barrier()
#endif #endif
inline bool QBasicAtomicInt::ref() inline bool QBasicAtomicInt::ref() Q_DECL_NOTHROW
{ {
register int newValue; register int newValue;
register int result; register int result;
@ -592,7 +592,7 @@ inline bool QBasicAtomicInt::ref()
return newValue != 0; return newValue != 0;
} }
inline bool QBasicAtomicInt::deref() inline bool QBasicAtomicInt::deref() Q_DECL_NOTHROW
{ {
register int newValue; register int newValue;
register int result; register int result;
@ -607,7 +607,7 @@ inline bool QBasicAtomicInt::deref()
return newValue != 0; return newValue != 0;
} }
inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) Q_DECL_NOTHROW
{ {
register int result; register int result;
retry: retry:
@ -621,7 +621,7 @@ inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
return result == 0; return result == 0;
} }
inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) Q_DECL_NOTHROW
{ {
register int originalValue; register int originalValue;
register int result; register int result;
@ -635,7 +635,7 @@ inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
return originalValue; return originalValue;
} }
inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) Q_DECL_NOTHROW
{ {
register int originalValue; register int originalValue;
register int newValue; register int newValue;
@ -652,7 +652,7 @@ inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
} }
template <typename T> template <typename T>
Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue) Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue) Q_DECL_NOTHROW
{ {
register T *result; register T *result;
retry: retry:
@ -667,7 +667,7 @@ Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValu
} }
template <typename T> template <typename T>
Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue) Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue) Q_DECL_NOTHROW
{ {
register T *originalValue; register T *originalValue;
register int result; register int result;
@ -682,7 +682,7 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
} }
template <typename T> template <typename T>
Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd) Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd) Q_DECL_NOTHROW
{ {
register T *originalValue; register T *originalValue;
register T *newValue; register T *newValue;
@ -707,7 +707,7 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueTo
// common code // common code
template <int size> template <typename T> inline template <int size> template <typename T> inline
void QBasicAtomicOps<size>::orderedMemoryFence(const T &) void QBasicAtomicOps<size>::orderedMemoryFence(const T &) Q_DECL_NOTHROW
{ {
Q_DATA_MEMORY_BARRIER; Q_DATA_MEMORY_BARRIER;
} }

10
src/corelib/arch/qatomic_bootstrap.h
View File

@ -62,16 +62,16 @@ template <typename T> struct QAtomicOps: QGenericAtomicOps<QAtomicOps<T> >
{ {
typedef T Type; typedef T Type;
static bool ref(T &_q_value) static bool ref(T &_q_value) Q_DECL_NOTHROW
{ {
return ++_q_value != 0; return ++_q_value != 0;
} }
static bool deref(T &_q_value) static bool deref(T &_q_value) Q_DECL_NOTHROW
{ {
return --_q_value != 0; return --_q_value != 0;
} }
static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
if (_q_value == expectedValue) { if (_q_value == expectedValue) {
_q_value = newValue; _q_value = newValue;
@ -80,7 +80,7 @@ template <typename T> struct QAtomicOps: QGenericAtomicOps<QAtomicOps<T> >
return false; return false;
} }
static T fetchAndStoreRelaxed(T &_q_value, T newValue) static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
T tmp = _q_value; T tmp = _q_value;
_q_value = newValue; _q_value = newValue;
@ -88,7 +88,7 @@ template <typename T> struct QAtomicOps: QGenericAtomicOps<QAtomicOps<T> >
} }
static static
T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T returnValue = _q_value; T returnValue = _q_value;
_q_value += valueToAdd; _q_value += valueToAdd;

54
src/corelib/arch/qatomic_cxx11.h
View File

@ -109,126 +109,126 @@ template <typename T> struct QAtomicOps
static const int AddScale = QAtomicAdditiveType<T>::AddScale; static const int AddScale = QAtomicAdditiveType<T>::AddScale;
static inline static inline
T load(const Type &_q_value) T load(const Type &_q_value) Q_DECL_NOTHROW
{ {
return _q_value.load(std::memory_order_relaxed); return _q_value.load(std::memory_order_relaxed);
} }
static inline static inline
T load(const volatile Type &_q_value) T load(const volatile Type &_q_value) Q_DECL_NOTHROW
{ {
return _q_value.load(std::memory_order_relaxed); return _q_value.load(std::memory_order_relaxed);
} }
static inline static inline
T loadAcquire(const Type &_q_value) T loadAcquire(const Type &_q_value) Q_DECL_NOTHROW
{ {
return _q_value.load(std::memory_order_acquire); return _q_value.load(std::memory_order_acquire);
} }
static inline static inline
T loadAcquire(const volatile Type &_q_value) T loadAcquire(const volatile Type &_q_value) Q_DECL_NOTHROW
{ {
return _q_value.load(std::memory_order_acquire); return _q_value.load(std::memory_order_acquire);
} }
static inline static inline
void store(Type &_q_value, T newValue) void store(Type &_q_value, T newValue) Q_DECL_NOTHROW
{ {
_q_value.store(newValue, std::memory_order_relaxed); _q_value.store(newValue, std::memory_order_relaxed);
} }
static inline static inline
void storeRelease(Type &_q_value, T newValue) void storeRelease(Type &_q_value, T newValue) Q_DECL_NOTHROW
{ {
_q_value.store(newValue, std::memory_order_release); _q_value.store(newValue, std::memory_order_release);
} }
static inline bool isReferenceCountingNative() { return true; } static inline bool isReferenceCountingNative() Q_DECL_NOTHROW { return true; }
static inline bool isReferenceCountingWaitFree() { return false; } static inline bool isReferenceCountingWaitFree() Q_DECL_NOTHROW { return false; }
static inline bool ref(Type &_q_value) static inline bool ref(Type &_q_value)
{ {
return ++_q_value != 0; return ++_q_value != 0;
} }
static inline bool deref(Type &_q_value) static inline bool deref(Type &_q_value) Q_DECL_NOTHROW
{ {
return --_q_value != 0; return --_q_value != 0;
} }
static inline bool isTestAndSetNative() { return false; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return false; }
static inline bool isTestAndSetWaitFree() { return false; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
static static
bool testAndSetRelaxed(Type &_q_value, T expectedValue, T newValue) bool testAndSetRelaxed(Type &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
return _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_relaxed); return _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_relaxed);
} }
static bool testAndSetAcquire(Type &_q_value, T expectedValue, T newValue) static bool testAndSetAcquire(Type &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
return _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acquire); return _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acquire);
} }
static bool testAndSetRelease(Type &_q_value, T expectedValue, T newValue) static bool testAndSetRelease(Type &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
return _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_release); return _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_release);
} }
static bool testAndSetOrdered(Type &_q_value, T expectedValue, T newValue) static bool testAndSetOrdered(Type &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
return _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acq_rel); return _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acq_rel);
} }
static inline bool isFetchAndStoreNative() { return false; } static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { return false; }
static inline bool isFetchAndStoreWaitFree() { return false; } static inline bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return false; }
static T fetchAndStoreRelaxed(Type &_q_value, T newValue) static T fetchAndStoreRelaxed(Type &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return _q_value.exchange(newValue, std::memory_order_relaxed); return _q_value.exchange(newValue, std::memory_order_relaxed);
} }
static T fetchAndStoreAcquire(Type &_q_value, T newValue) static T fetchAndStoreAcquire(Type &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return _q_value.exchange(newValue, std::memory_order_acquire); return _q_value.exchange(newValue, std::memory_order_acquire);
} }
static T fetchAndStoreRelease(Type &_q_value, T newValue) static T fetchAndStoreRelease(Type &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return _q_value.exchange(newValue, std::memory_order_release); return _q_value.exchange(newValue, std::memory_order_release);
} }
static T fetchAndStoreOrdered(Type &_q_value, T newValue) static T fetchAndStoreOrdered(Type &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return _q_value.exchange(newValue, std::memory_order_acq_rel); return _q_value.exchange(newValue, std::memory_order_acq_rel);
} }
static inline bool isFetchAndAddNative() { return false; } static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return false; }
static inline bool isFetchAndAddWaitFree() { return false; } static inline bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return false; }
static static
T fetchAndAddRelaxed(Type &_q_value, _AdditiveType valueToAdd) T fetchAndAddRelaxed(Type &_q_value, _AdditiveType valueToAdd) Q_DECL_NOTHROW
{ {
return _q_value.fetch_add(valueToAdd * AddScale, return _q_value.fetch_add(valueToAdd * AddScale,
std::memory_order_relaxed); std::memory_order_relaxed);
} }
static static
T fetchAndAddAcquire(Type &_q_value, _AdditiveType valueToAdd) T fetchAndAddAcquire(Type &_q_value, _AdditiveType valueToAdd) Q_DECL_NOTHROW
{ {
return _q_value.fetch_add(valueToAdd * AddScale, return _q_value.fetch_add(valueToAdd * AddScale,
std::memory_order_acquire); std::memory_order_acquire);
} }
static static
T fetchAndAddRelease(Type &_q_value, _AdditiveType valueToAdd) T fetchAndAddRelease(Type &_q_value, _AdditiveType valueToAdd) Q_DECL_NOTHROW
{ {
return _q_value.fetch_add(valueToAdd * AddScale, return _q_value.fetch_add(valueToAdd * AddScale,
std::memory_order_release); std::memory_order_release);
} }
static static
T fetchAndAddOrdered(Type &_q_value, _AdditiveType valueToAdd) T fetchAndAddOrdered(Type &_q_value, _AdditiveType valueToAdd) Q_DECL_NOTHROW
{ {
return _q_value.fetch_add(valueToAdd * AddScale, return _q_value.fetch_add(valueToAdd * AddScale,
std::memory_order_acq_rel); std::memory_order_acq_rel);

18
src/corelib/arch/qatomic_gcc.h
View File

@ -84,45 +84,45 @@ template <typename T> struct QAtomicOps: QGenericAtomicOps<QAtomicOps<T> >
typedef T Type; typedef T Type;
#ifndef __ia64__ #ifndef __ia64__
static T loadAcquire(const T &_q_value) static T loadAcquire(const T &_q_value) Q_DECL_NOTHROW
{ {
T tmp = _q_value; T tmp = _q_value;
__sync_synchronize(); __sync_synchronize();
return tmp; return tmp;
} }
static void storeRelease(T &_q_value, T newValue) static void storeRelease(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
__sync_synchronize(); __sync_synchronize();
_q_value = newValue; _q_value = newValue;
} }
#endif #endif
static bool isTestAndSetNative() { return false; } static bool isTestAndSetNative() Q_DECL_NOTHROW { return false; }
static bool isTestAndSetWaitFree() { return false; } static bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
return __sync_bool_compare_and_swap(&_q_value, expectedValue, newValue); return __sync_bool_compare_and_swap(&_q_value, expectedValue, newValue);
} }
static T fetchAndStoreRelaxed(T &_q_value, T newValue) static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return __sync_lock_test_and_set(&_q_value, newValue); return __sync_lock_test_and_set(&_q_value, newValue);
} }
static T fetchAndStoreRelease(T &_q_value, T newValue) static T fetchAndStoreRelease(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
__sync_synchronize(); __sync_synchronize();
return __sync_lock_test_and_set(&_q_value, newValue); return __sync_lock_test_and_set(&_q_value, newValue);
} }
static T fetchAndStoreOrdered(T &_q_value, T newValue) static T fetchAndStoreOrdered(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return fetchAndStoreRelease(_q_value, newValue); return fetchAndStoreRelease(_q_value, newValue);
} }
static static
T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
return __sync_fetch_and_add(&_q_value, valueToAdd * QAtomicAdditiveType<T>::AddScale); return __sync_fetch_and_add(&_q_value, valueToAdd * QAtomicAdditiveType<T>::AddScale);
} }

168
src/corelib/arch/qatomic_ia64.h
View File

@ -141,48 +141,48 @@ template<> struct QAtomicIntegerTraits<unsigned long long> { enum { IsInteger =
template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> > template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> >
{ {
template <typename T> template <typename T>
static void orderedMemoryFence(const T &); static void orderedMemoryFence(const T &) Q_DECL_NOTHROW;
template <typename T> static inline template <typename T> static inline
T loadAcquire(const T &_q_value) T loadAcquire(const T &_q_value) Q_DECL_NOTHROW
{ {
return *static_cast<const volatile T *>(&_q_value); return *static_cast<const volatile T *>(&_q_value);
} }
template <typename T> static inline template <typename T> static inline
void storeRelease(T &_q_value, T newValue) void storeRelease(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
*static_cast<volatile T *>(&_q_value) = newValue; *static_cast<volatile T *>(&_q_value) = newValue;
} }
static inline bool isReferenceCountingNative() { return true; } static inline bool isReferenceCountingNative() Q_DECL_NOTHROW { return true; }
static inline bool isReferenceCountingWaitFree() { return size == 4 || size == 8; } static inline bool isReferenceCountingWaitFree() Q_DECL_NOTHROW { return size == 4 || size == 8; }
template <typename T> static bool ref(T &_q_value); template <typename T> static bool ref(T &_q_value) Q_DECL_NOTHROW;
template <typename T> static bool deref(T &_q_value); template <typename T> static bool deref(T &_q_value) Q_DECL_NOTHROW;
static inline bool isTestAndSetNative() { return true; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return true; }
static inline bool isTestAndSetWaitFree() { return true; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return true; }
template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue); template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW;
template <typename T> static bool testAndSetAcquire(T &_q_value, T expectedValue, T newValue); template <typename T> static bool testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW;
template <typename T> static bool testAndSetRelease(T &_q_value, T expectedValue, T newValue); template <typename T> static bool testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW;
template <typename T> static bool testAndSetOrdered(T &_q_value, T expectedValue, T newValue); template <typename T> static bool testAndSetOrdered(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndStoreNative() { return true; } static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { return true; }
static inline bool isFetchAndStoreWaitFree() { return true; } static inline bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return true; }
template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue); template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW;
template <typename T> static T fetchAndStoreAcquire(T &_q_value, T newValue); template <typename T> static T fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW;
template <typename T> static T fetchAndStoreRelease(T &_q_value, T newValue); template <typename T> static T fetchAndStoreRelease(T &_q_value, T newValue) Q_DECL_NOTHROW;
template <typename T> static T fetchAndStoreOrdered(T &_q_value, T newValue); template <typename T> static T fetchAndStoreOrdered(T &_q_value, T newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndAddNative() { return true; } static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return true; }
static inline bool isFetchAndAddWaitFree() { return false; } static inline bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return false; }
template <typename T> static template <typename T> static
T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd); T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
template <typename T> static template <typename T> static
T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd); T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
template <typename T> static template <typename T> static
T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd); T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
template <typename T> static template <typename T> static
T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd); T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
}; };
template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)> template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
@ -334,13 +334,13 @@ Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueTo
#elif defined(Q_CC_GNU) #elif defined(Q_CC_GNU)
template<int size> template <typename T> inline template<int size> template <typename T> inline
void QBasicAtomicOps<size>::orderedMemoryFence(const T &) void QBasicAtomicOps<size>::orderedMemoryFence(const T &) Q_DECL_NOTHROW
{ {
asm volatile("mf" ::: "memory"); asm volatile("mf" ::: "memory");
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::ref(T &_q_value) bool QBasicAtomicOps<4>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("fetchadd4.acq %0=%1,1\n" asm volatile("fetchadd4.acq %0=%1,1\n"
@ -351,7 +351,7 @@ bool QBasicAtomicOps<4>::ref(T &_q_value)
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::deref(T &_q_value) bool QBasicAtomicOps<4>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("fetchadd4.rel %0=%1,-1\n" asm volatile("fetchadd4.rel %0=%1,-1\n"
@ -362,7 +362,7 @@ bool QBasicAtomicOps<4>::deref(T &_q_value)
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<8>::ref(T &_q_value) bool QBasicAtomicOps<8>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("fetchadd8.acq %0=%1,1\n" asm volatile("fetchadd8.acq %0=%1,1\n"
@ -373,7 +373,7 @@ bool QBasicAtomicOps<8>::ref(T &_q_value)
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<8>::deref(T &_q_value) bool QBasicAtomicOps<8>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("fetchadd8.rel %0=%1,-1\n" asm volatile("fetchadd8.rel %0=%1,-1\n"
@ -384,7 +384,7 @@ bool QBasicAtomicOps<8>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<1>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<1>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("mov ar.ccv=%2\n" asm volatile("mov ar.ccv=%2\n"
@ -397,7 +397,7 @@ bool QBasicAtomicOps<1>::testAndSetAcquire(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<1>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<1>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("mov ar.ccv=%2\n" asm volatile("mov ar.ccv=%2\n"
@ -410,7 +410,7 @@ bool QBasicAtomicOps<1>::testAndSetRelease(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<2>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<2>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("mov ar.ccv=%2\n" asm volatile("mov ar.ccv=%2\n"
@ -423,7 +423,7 @@ bool QBasicAtomicOps<2>::testAndSetAcquire(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<2>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<2>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("mov ar.ccv=%2\n" asm volatile("mov ar.ccv=%2\n"
@ -436,7 +436,7 @@ bool QBasicAtomicOps<2>::testAndSetRelease(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<4>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("mov ar.ccv=%2\n" asm volatile("mov ar.ccv=%2\n"
@ -449,7 +449,7 @@ bool QBasicAtomicOps<4>::testAndSetAcquire(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<4>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("mov ar.ccv=%2\n" asm volatile("mov ar.ccv=%2\n"
@ -462,7 +462,7 @@ bool QBasicAtomicOps<4>::testAndSetRelease(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<8>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<8>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("mov ar.ccv=%2\n" asm volatile("mov ar.ccv=%2\n"
@ -475,7 +475,7 @@ bool QBasicAtomicOps<8>::testAndSetAcquire(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<8>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<8>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("mov ar.ccv=%2\n" asm volatile("mov ar.ccv=%2\n"
@ -488,7 +488,7 @@ bool QBasicAtomicOps<8>::testAndSetRelease(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndStoreAcquire(T &_q_value, T newValue) T QBasicAtomicOps<1>::fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("xchg1 %0=%1,%2\n" asm volatile("xchg1 %0=%1,%2\n"
@ -499,7 +499,7 @@ T QBasicAtomicOps<1>::fetchAndStoreAcquire(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<2>::fetchAndStoreAcquire(T &_q_value, T newValue) T QBasicAtomicOps<2>::fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("xchg2 %0=%1,%2\n" asm volatile("xchg2 %0=%1,%2\n"
@ -510,7 +510,7 @@ T QBasicAtomicOps<2>::fetchAndStoreAcquire(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndStoreAcquire(T &_q_value, T newValue) T QBasicAtomicOps<4>::fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("xchg4 %0=%1,%2\n" asm volatile("xchg4 %0=%1,%2\n"
@ -521,7 +521,7 @@ T QBasicAtomicOps<4>::fetchAndStoreAcquire(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndStoreAcquire(T &_q_value, T newValue) T QBasicAtomicOps<8>::fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
T ret; T ret;
asm volatile("xchg8 %0=%1,%2\n" asm volatile("xchg8 %0=%1,%2\n"
@ -532,7 +532,7 @@ T QBasicAtomicOps<8>::fetchAndStoreAcquire(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<1>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T ret; T ret;
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
@ -555,7 +555,7 @@ T QBasicAtomicOps<1>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<1>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T ret; T ret;
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
@ -578,7 +578,7 @@ T QBasicAtomicOps<1>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<2>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<2>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T ret; T ret;
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
@ -601,7 +601,7 @@ T QBasicAtomicOps<2>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<2>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<2>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T ret; T ret;
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
@ -624,7 +624,7 @@ T QBasicAtomicOps<2>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<4>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T ret; T ret;
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
@ -659,7 +659,7 @@ T QBasicAtomicOps<4>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<4>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T ret; T ret;
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
@ -694,7 +694,7 @@ T QBasicAtomicOps<4>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<8>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T ret; T ret;
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
@ -729,7 +729,7 @@ T QBasicAtomicOps<8>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<8>::fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T ret; T ret;
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
@ -772,41 +772,41 @@ QT_END_INCLUDE_NAMESPACE
#define FENCE (_Asm_fence)(_UP_CALL_FENCE | _UP_SYS_FENCE | _DOWN_CALL_FENCE | _DOWN_SYS_FENCE) #define FENCE (_Asm_fence)(_UP_CALL_FENCE | _UP_SYS_FENCE | _DOWN_CALL_FENCE | _DOWN_SYS_FENCE)
template <int size> inline template <int size> inline
void QBasicAtomicOps<size>::orderedMemoryFence() void QBasicAtomicOps<size>::orderedMemoryFence() Q_DECL_NOTHROW
{ {
_Asm_mf(FENCE); _Asm_mf(FENCE);
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::ref(T &_q_value) bool QBasicAtomicOps<4>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
return (T)_Asm_fetchadd((_Asm_fasz)_FASZ_W, (_Asm_sem)_SEM_ACQ, return (T)_Asm_fetchadd((_Asm_fasz)_FASZ_W, (_Asm_sem)_SEM_ACQ,
&_q_value, 1, (_Asm_ldhint)_LDHINT_NONE, FENCE) != -1; &_q_value, 1, (_Asm_ldhint)_LDHINT_NONE, FENCE) != -1;
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::deref(T &_q_value) bool QBasicAtomicOps<4>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
return (T)_Asm_fetchadd((_Asm_fasz)_FASZ_W, (_Asm_sem)_SEM_REL, return (T)_Asm_fetchadd((_Asm_fasz)_FASZ_W, (_Asm_sem)_SEM_REL,
&_q_value, -1, (_Asm_ldhint)_LDHINT_NONE, FENCE) != 1; &_q_value, -1, (_Asm_ldhint)_LDHINT_NONE, FENCE) != 1;
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<8>::ref(T &_q_value) bool QBasicAtomicOps<8>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
return (T)_Asm_fetchadd((_Asm_fasz)_FASZ_D, (_Asm_sem)_SEM_ACQ, return (T)_Asm_fetchadd((_Asm_fasz)_FASZ_D, (_Asm_sem)_SEM_ACQ,
&_q_value, 1, (_Asm_ldhint)_LDHINT_NONE, FENCE) != -1; &_q_value, 1, (_Asm_ldhint)_LDHINT_NONE, FENCE) != -1;
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<8>::deref(T &_q_value) bool QBasicAtomicOps<8>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
return (T)_Asm_fetchadd((_Asm_fasz)_FASZ_D, (_Asm_sem)_SEM_REL, return (T)_Asm_fetchadd((_Asm_fasz)_FASZ_D, (_Asm_sem)_SEM_REL,
&_q_value, -1, (_Asm_ldhint)_LDHINT_NONE, FENCE) != 1; &_q_value, -1, (_Asm_ldhint)_LDHINT_NONE, FENCE) != 1;
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<1>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<1>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
_Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint8)expectedValue, FENCE); _Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint8)expectedValue, FENCE);
T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_B, (_Asm_sem)_SEM_ACQ, T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_B, (_Asm_sem)_SEM_ACQ,
@ -815,7 +815,7 @@ bool QBasicAtomicOps<1>::testAndSetAcquire(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<1>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<1>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
_Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint8)expectedValue, FENCE); _Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint8)expectedValue, FENCE);
T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_B, (_Asm_sem)_SEM_REL, T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_B, (_Asm_sem)_SEM_REL,
@ -824,7 +824,7 @@ bool QBasicAtomicOps<1>::testAndSetRelease(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<2>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<2>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
_Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint16)expectedValue, FENCE); _Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint16)expectedValue, FENCE);
T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_H, (_Asm_sem)_SEM_ACQ, T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_H, (_Asm_sem)_SEM_ACQ,
@ -833,7 +833,7 @@ bool QBasicAtomicOps<2>::testAndSetAcquire(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<2>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<2>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
_Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint16)expectedValue, FENCE); _Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint16)expectedValue, FENCE);
T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_H, (_Asm_sem)_SEM_REL, T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_H, (_Asm_sem)_SEM_REL,
@ -842,7 +842,7 @@ bool QBasicAtomicOps<2>::testAndSetRelease(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<4>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
_Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (unsigned)expectedValue, FENCE); _Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (unsigned)expectedValue, FENCE);
T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_W, (_Asm_sem)_SEM_ACQ, T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_W, (_Asm_sem)_SEM_ACQ,
@ -851,7 +851,7 @@ bool QBasicAtomicOps<4>::testAndSetAcquire(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<4>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
_Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (unsigned)expectedValue, FENCE); _Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (unsigned)expectedValue, FENCE);
T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_W, (_Asm_sem)_SEM_REL, T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_W, (_Asm_sem)_SEM_REL,
@ -860,7 +860,7 @@ bool QBasicAtomicOps<4>::testAndSetRelease(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<8>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<8>::testAndSetAcquire(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
_Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint64)expectedValue, FENCE); _Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint64)expectedValue, FENCE);
T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_D, (_Asm_sem)_SEM_ACQ, T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_D, (_Asm_sem)_SEM_ACQ,
@ -869,7 +869,7 @@ bool QBasicAtomicOps<8>::testAndSetAcquire(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<8>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<8>::testAndSetRelease(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
_Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint64)expectedValue, FENCE); _Asm_mov_to_ar((_Asm_app_reg)_AREG_CCV, (quint64)expectedValue, FENCE);
T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_D, (_Asm_sem)_SEM_REL, T ret = (T)_Asm_cmpxchg((_Asm_sz)_SZ_D, (_Asm_sem)_SEM_REL,
@ -878,35 +878,35 @@ bool QBasicAtomicOps<8>::testAndSetRelease(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndStoreAcquire(T &_q_value, T newValue) T QBasicAtomicOps<1>::fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return (T)_Asm_xchg((_Asm_sz)_SZ_B, &_q_value, (quint8)newValue, return (T)_Asm_xchg((_Asm_sz)_SZ_B, &_q_value, (quint8)newValue,
(_Asm_ldhint)_LDHINT_NONE, FENCE); (_Asm_ldhint)_LDHINT_NONE, FENCE);
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<2>::fetchAndStoreAcquire(T &_q_value, T newValue) T QBasicAtomicOps<2>::fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return (T)_Asm_xchg((_Asm_sz)_SZ_H, &_q_value, (quint16)newValue, return (T)_Asm_xchg((_Asm_sz)_SZ_H, &_q_value, (quint16)newValue,
(_Asm_ldhint)_LDHINT_NONE, FENCE); (_Asm_ldhint)_LDHINT_NONE, FENCE);
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndStoreAcquire(T &_q_value, T newValue) T QBasicAtomicOps<4>::fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return (T)_Asm_xchg((_Asm_sz)_SZ_W, &_q_value, (unsigned)newValue, return (T)_Asm_xchg((_Asm_sz)_SZ_W, &_q_value, (unsigned)newValue,
(_Asm_ldhint)_LDHINT_NONE, FENCE); (_Asm_ldhint)_LDHINT_NONE, FENCE);
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndStoreAcquire(T &_q_value, T newValue) T QBasicAtomicOps<8>::fetchAndStoreAcquire(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return (T)_Asm_xchg((_Asm_sz)_SZ_D, &_q_value, (quint64)newValue, return (T)_Asm_xchg((_Asm_sz)_SZ_D, &_q_value, (quint64)newValue,
(_Asm_ldhint)_LDHINT_NONE, FENCE); (_Asm_ldhint)_LDHINT_NONE, FENCE);
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<1>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
// implement the test-and-set loop // implement the test-and-set loop
@ -921,7 +921,7 @@ T QBasicAtomicOps<1>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
// implement the test-and-set loop // implement the test-and-set loop
register T old, ret; register T old, ret;
@ -935,7 +935,7 @@ T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<2>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<2>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
// implement the test-and-set loop // implement the test-and-set loop
@ -950,7 +950,7 @@ T QBasicAtomicOps<2>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
// implement the test-and-set loop // implement the test-and-set loop
register T old, ret; register T old, ret;
@ -964,7 +964,7 @@ T QBasicAtomicOps<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<4>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
// implement the test-and-set loop // implement the test-and-set loop
@ -979,7 +979,7 @@ T QBasicAtomicOps<4>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
// implement the test-and-set loop // implement the test-and-set loop
register T old, ret; register T old, ret;
@ -993,7 +993,7 @@ T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<8>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
valueToAdd *= QAtomicAdditiveType<T>::AddScale; valueToAdd *= QAtomicAdditiveType<T>::AddScale;
// implement the test-and-set loop // implement the test-and-set loop
@ -1008,7 +1008,7 @@ T QBasicAtomicOps<8>::fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveTy
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
// implement the test-and-set loop // implement the test-and-set loop
register T old, ret; register T old, ret;
@ -1024,59 +1024,59 @@ T QBasicAtomicOps<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveTy
#endif #endif
template<int size> template<typename T> inline template<int size> template<typename T> inline
bool QBasicAtomicOps<size>::ref(T &_q_value) bool QBasicAtomicOps<size>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
// no fetchadd for 1 or 2 bytes // no fetchadd for 1 or 2 bytes
return fetchAndAddRelaxed(_q_value, 1) == -1; return fetchAndAddRelaxed(_q_value, 1) == -1;
} }
template<int size> template<typename T> inline template<int size> template<typename T> inline
bool QBasicAtomicOps<size>::deref(T &_q_value) bool QBasicAtomicOps<size>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
// no fetchadd for 1 or 2 bytes // no fetchadd for 1 or 2 bytes
return fetchAndAddRelaxed(_q_value, -1) == 1; return fetchAndAddRelaxed(_q_value, -1) == 1;
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
bool QBasicAtomicOps<size>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<size>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
return testAndSetAcquire(_q_value, expectedValue, newValue); return testAndSetAcquire(_q_value, expectedValue, newValue);
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
bool QBasicAtomicOps<size>::testAndSetOrdered(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<size>::testAndSetOrdered(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
orderedMemoryFence(_q_value); orderedMemoryFence(_q_value);
return testAndSetAcquire(_q_value, expectedValue, newValue); return testAndSetAcquire(_q_value, expectedValue, newValue);
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
T QBasicAtomicOps<size>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<size>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return fetchAndStoreAcquire(_q_value, newValue); return fetchAndStoreAcquire(_q_value, newValue);
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
T QBasicAtomicOps<size>::fetchAndStoreRelease(T &_q_value, T newValue) T QBasicAtomicOps<size>::fetchAndStoreRelease(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
orderedMemoryFence(_q_value); orderedMemoryFence(_q_value);
return fetchAndStoreAcquire(_q_value, newValue); return fetchAndStoreAcquire(_q_value, newValue);
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
T QBasicAtomicOps<size>::fetchAndStoreOrdered(T &_q_value, T newValue) T QBasicAtomicOps<size>::fetchAndStoreOrdered(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
return fetchAndStoreRelease(_q_value, newValue); return fetchAndStoreRelease(_q_value, newValue);
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
T QBasicAtomicOps<size>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<size>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
return fetchAndAddAcquire(_q_value, valueToAdd); return fetchAndAddAcquire(_q_value, valueToAdd);
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
T QBasicAtomicOps<size>::fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<size>::fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
orderedMemoryFence(_q_value); orderedMemoryFence(_q_value);
return fetchAndAddRelease(_q_value, valueToAdd); return fetchAndAddRelease(_q_value, valueToAdd);

52
src/corelib/arch/qatomic_mips.h
View File

@ -78,26 +78,26 @@ template<> struct QAtomicIntegerTraits<unsigned int> { enum { IsInteger = 1 }; }
template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> > template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> >
{ {
template <typename T> template <typename T>
static void acquireMemoryFence(const T &); static void acquireMemoryFence(const T &) Q_DECL_NOTHROW;
template <typename T> template <typename T>
static void releaseMemoryFence(const T &); static void releaseMemoryFence(const T &) Q_DECL_NOTHROW;
template <typename T> template <typename T>
static void orderedMemoryFence(const T &); static void orderedMemoryFence(const T &) Q_DECL_NOTHROW;
static inline bool isReferenceCountingNative() { return true; } static inline bool isReferenceCountingNative() Q_DECL_NOTHROW { return true; }
template <typename T> static bool ref(T &_q_value); template <typename T> static bool ref(T &_q_value) Q_DECL_NOTHROW;
template <typename T> static bool deref(T &_q_value); template <typename T> static bool deref(T &_q_value) Q_DECL_NOTHROW;
static inline bool isTestAndSetNative() { return true; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return true; }
static inline bool isTestAndSetWaitFree() { return false; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue); template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndStoreNative() { return true; } static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { return true; }
template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue); template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndAddNative() { return true; } static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return true; }
template <typename T> static template <typename T> static
T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd); T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
}; };
template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)> template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
@ -113,25 +113,25 @@ template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
#endif #endif
template <int size> template <typename T> inline template <int size> template <typename T> inline
void QBasicAtomicOps<size>::acquireMemoryFence(const T &) void QBasicAtomicOps<size>::acquireMemoryFence(const T &) Q_DECL_NOTHROW
{ {
asm volatile ("sync 0x11" ::: "memory"); asm volatile ("sync 0x11" ::: "memory");
} }
template <int size> template <typename T> inline template <int size> template <typename T> inline
void QBasicAtomicOps<size>::releaseMemoryFence(const T &) void QBasicAtomicOps<size>::releaseMemoryFence(const T &) Q_DECL_NOTHROW
{ {
asm volatile ("sync 0x12" ::: "memory"); asm volatile ("sync 0x12" ::: "memory");
} }
template <int size> template <typename T> inline template <int size> template <typename T> inline
void QBasicAtomicOps<size>::orderedMemoryFence(const T &) void QBasicAtomicOps<size>::orderedMemoryFence(const T &) Q_DECL_NOTHROW
{ {
asm volatile ("sync 0" ::: "memory"); asm volatile ("sync 0" ::: "memory");
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::ref(T &_q_value) bool QBasicAtomicOps<4>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -150,7 +150,7 @@ bool QBasicAtomicOps<4>::ref(T &_q_value)
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::deref(T &_q_value) bool QBasicAtomicOps<4>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -169,7 +169,7 @@ bool QBasicAtomicOps<4>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
register T result; register T result;
register T tempValue; register T tempValue;
@ -193,7 +193,7 @@ bool QBasicAtomicOps<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T tempValue; register T tempValue;
@ -212,7 +212,7 @@ T QBasicAtomicOps<4>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -242,7 +242,7 @@ template<> struct QAtomicIntegerTraits<long long> { enum { IsInteger = 1 }; };
template<> struct QAtomicIntegerTraits<unsigned long long > { enum { IsInteger = 1 }; }; template<> struct QAtomicIntegerTraits<unsigned long long > { enum { IsInteger = 1 }; };
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<8>::ref(T &_q_value) bool QBasicAtomicOps<8>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -261,7 +261,7 @@ bool QBasicAtomicOps<8>::ref(T &_q_value)
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<8>::deref(T &_q_value) bool QBasicAtomicOps<8>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;
@ -280,7 +280,7 @@ bool QBasicAtomicOps<8>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
register T result; register T result;
register T tempValue; register T tempValue;
@ -304,7 +304,7 @@ bool QBasicAtomicOps<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newVa
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<8>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T tempValue; register T tempValue;
@ -323,7 +323,7 @@ T QBasicAtomicOps<8>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
register T originalValue; register T originalValue;
register T newValue; register T newValue;

60
src/corelib/arch/qatomic_msvc.h
View File

@ -276,49 +276,49 @@ struct QAtomicOpsBySize<4> : QGenericAtomicOps<QAtomicOpsBySize<4> >
// The 32-bit Interlocked*() API takes parameters as longs. // The 32-bit Interlocked*() API takes parameters as longs.
typedef long Type; typedef long Type;
static inline bool isReferenceCountingNative() { return true; } static inline bool isReferenceCountingNative() Q_DECL_NOTHROW { return true; }
static inline bool isReferenceCountingWaitFree() { return true; } static inline bool isReferenceCountingWaitFree() Q_DECL_NOTHROW { return true; }
static bool ref(long &_q_value); static bool ref(long &_q_value) Q_DECL_NOTHROW;
static bool deref(long &_q_value); static bool deref(long &_q_value) Q_DECL_NOTHROW;
static inline bool isTestAndSetNative() { return true; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return true; }
static inline bool isTestAndSetWaitFree() { return true; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return true; }
static bool testAndSetRelaxed(long &_q_value, long expectedValue, long newValue); static bool testAndSetRelaxed(long &_q_value, long expectedValue, long newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndStoreNative() { return true; } static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { return true; }
static inline bool isFetchAndStoreWaitFree() { return true; } static inline bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return true; }
static long fetchAndStoreRelaxed(long &_q_value, long newValue); static long fetchAndStoreRelaxed(long &_q_value, long newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndAddNative() { return true; } static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return true; }
static inline bool isFetchAndAddWaitFree() { return true; } static inline bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return true; }
static long fetchAndAddRelaxed(long &_q_value, QAtomicAdditiveType<long>::AdditiveT valueToAdd); static long fetchAndAddRelaxed(long &_q_value, QAtomicAdditiveType<long>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
}; };
template <typename T> template <typename T>
struct QAtomicOps : QAtomicOpsBySize<sizeof(T)> struct QAtomicOps : QAtomicOpsBySize<sizeof(T)>
{ }; { };
inline bool QAtomicOpsBySize<4>::ref(long &_q_value) inline bool QAtomicOpsBySize<4>::ref(long &_q_value) Q_DECL_NOTHROW
{ {
return QT_INTERLOCKED_INCREMENT(&_q_value) != 0; return QT_INTERLOCKED_INCREMENT(&_q_value) != 0;
} }
inline bool QAtomicOpsBySize<4>::deref(long &_q_value) inline bool QAtomicOpsBySize<4>::deref(long &_q_value) Q_DECL_NOTHROW
{ {
return QT_INTERLOCKED_DECREMENT(&_q_value) != 0; return QT_INTERLOCKED_DECREMENT(&_q_value) != 0;
} }
inline bool QAtomicOpsBySize<4>::testAndSetRelaxed(long &_q_value, long expectedValue, long newValue) inline bool QAtomicOpsBySize<4>::testAndSetRelaxed(long &_q_value, long expectedValue, long newValue) Q_DECL_NOTHROW
{ {
return QT_INTERLOCKED_COMPARE_EXCHANGE(&_q_value, newValue, expectedValue) == expectedValue; return QT_INTERLOCKED_COMPARE_EXCHANGE(&_q_value, newValue, expectedValue) == expectedValue;
} }
inline long QAtomicOpsBySize<4>::fetchAndStoreRelaxed(long &_q_value, long newValue) inline long QAtomicOpsBySize<4>::fetchAndStoreRelaxed(long &_q_value, long newValue) Q_DECL_NOTHROW
{ {
return QT_INTERLOCKED_EXCHANGE(&_q_value, newValue); return QT_INTERLOCKED_EXCHANGE(&_q_value, newValue);
} }
inline long QAtomicOpsBySize<4>::fetchAndAddRelaxed(long &_q_value, QAtomicAdditiveType<long>::AdditiveT valueToAdd) inline long QAtomicOpsBySize<4>::fetchAndAddRelaxed(long &_q_value, QAtomicAdditiveType<long>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
return QT_INTERLOCKED_EXCHANGE_ADD(&_q_value, valueToAdd * QAtomicAdditiveType<long>::AddScale); return QT_INTERLOCKED_EXCHANGE_ADD(&_q_value, valueToAdd * QAtomicAdditiveType<long>::AddScale);
} }
@ -329,33 +329,33 @@ struct QAtomicOps<T *> : QGenericAtomicOps<QAtomicOps<T *> >
{ {
typedef T *Type; typedef T *Type;
static inline bool isTestAndSetNative() { return true; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return true; }
static inline bool isTestAndSetWaitFree() { return true; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return true; }
static bool testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue); static bool testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndStoreNative() { return true; } static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { return true; }
static inline bool isFetchAndStoreWaitFree() { return true; } static inline bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return true; }
static T *fetchAndStoreRelaxed(T *&_q_value, T *newValue); static T *fetchAndStoreRelaxed(T *&_q_value, T *newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndAddNative() { return true; } static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return true; }
static inline bool isFetchAndAddWaitFree() { return true; } static inline bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return true; }
static T *fetchAndAddRelaxed(T *&_q_value, qptrdiff valueToAdd); static T *fetchAndAddRelaxed(T *&_q_value, qptrdiff valueToAdd) Q_DECL_NOTHROW;
}; };
template <typename T> template <typename T>
inline bool QAtomicOps<T *>::testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) inline bool QAtomicOps<T *>::testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) Q_DECL_NOTHROW
{ {
return QT_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&_q_value, newValue, expectedValue) == expectedValue; return QT_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&_q_value, newValue, expectedValue) == expectedValue;
} }
template <typename T> template <typename T>
inline T *QAtomicOps<T *>::fetchAndStoreRelaxed(T *&_q_value, T *newValue) inline T *QAtomicOps<T *>::fetchAndStoreRelaxed(T *&_q_value, T *newValue) Q_DECL_NOTHROW
{ {
return reinterpret_cast<T *>(QT_INTERLOCKED_EXCHANGE_POINTER(&_q_value, newValue)); return reinterpret_cast<T *>(QT_INTERLOCKED_EXCHANGE_POINTER(&_q_value, newValue));
} }
template <typename T> template <typename T>
inline T *QAtomicOps<T *>::fetchAndAddRelaxed(T *&_q_value, qptrdiff valueToAdd) inline T *QAtomicOps<T *>::fetchAndAddRelaxed(T *&_q_value, qptrdiff valueToAdd) Q_DECL_NOTHROW
{ {
return reinterpret_cast<T *>(QT_INTERLOCKED_EXCHANGE_ADD_POINTER(&_q_value, valueToAdd * sizeof(T))); return reinterpret_cast<T *>(QT_INTERLOCKED_EXCHANGE_ADD_POINTER(&_q_value, valueToAdd * sizeof(T)));
} }

4
src/corelib/arch/qatomic_unix.cpp
View File

@ -52,7 +52,7 @@ QT_BEGIN_NAMESPACE
static pthread_mutex_t qAtomicMutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t qAtomicMutex = PTHREAD_MUTEX_INITIALIZER;
Q_CORE_EXPORT Q_CORE_EXPORT
bool QAtomicOps<int>::testAndSetRelaxed(int &_q_value, int expectedValue, int newValue) bool QAtomicOps<int>::testAndSetRelaxed(int &_q_value, int expectedValue, int newValue) Q_DECL_NOTHROW
{ {
bool returnValue = false; bool returnValue = false;
pthread_mutex_lock(&qAtomicMutex); pthread_mutex_lock(&qAtomicMutex);
@ -65,7 +65,7 @@ bool QAtomicOps<int>::testAndSetRelaxed(int &_q_value, int expectedValue, int ne
} }
Q_CORE_EXPORT Q_CORE_EXPORT
bool QAtomicOps<void *>::testAndSetRelaxed(void *&_q_value, void *expectedValue, void *newValue) bool QAtomicOps<void *>::testAndSetRelaxed(void *&_q_value, void *expectedValue, void *newValue) Q_DECL_NOTHROW
{ {
bool returnValue = false; bool returnValue = false;
pthread_mutex_lock(&qAtomicMutex); pthread_mutex_lock(&qAtomicMutex);

18
src/corelib/arch/qatomic_unix.h
View File

@ -76,9 +76,9 @@ struct QAtomicOps<int> : QGenericAtomicOps<QAtomicOps<int> >
{ {
typedef int Type; typedef int Type;
static inline bool isTestAndSetNative() { return false; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return false; }
static inline bool isTestAndSetWaitFree() { return false; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
Q_CORE_EXPORT static bool testAndSetRelaxed(int &_q_value, int expectedValue, int newValue); Q_CORE_EXPORT static bool testAndSetRelaxed(int &_q_value, int expectedValue, int newValue) Q_DECL_NOTHROW;
}; };
template <> template <>
@ -86,9 +86,9 @@ struct QAtomicOps<void *> : QGenericAtomicOps<QAtomicOps<void *> >
{ {
typedef void *Type; typedef void *Type;
static inline bool isTestAndSetNative() { return false; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return false; }
static inline bool isTestAndSetWaitFree() { return false; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
Q_CORE_EXPORT static bool testAndSetRelaxed(void *&_q_value, void *expectedValue, void *newValue); Q_CORE_EXPORT static bool testAndSetRelaxed(void *&_q_value, void *expectedValue, void *newValue) Q_DECL_NOTHROW;
}; };
template <typename T> template <typename T>
@ -99,9 +99,9 @@ struct QAtomicOps<T *> : QGenericAtomicOps<QAtomicOps<T *> >
// helper to strip cv qualifiers // helper to strip cv qualifiers
static inline void *nocv(const T *p) { return const_cast<void *>(static_cast<const volatile void *>(p)); } static inline void *nocv(const T *p) { return const_cast<void *>(static_cast<const volatile void *>(p)); }
static inline bool isTestAndSetNative() { return false; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return false; }
static inline bool isTestAndSetWaitFree() { return false; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
static inline bool testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) static inline bool testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) Q_DECL_NOTHROW
{ {
// forward to the void* specialization // forward to the void* specialization
void *voidp = nocv(_q_value); void *voidp = nocv(_q_value);

60
src/corelib/arch/qatomic_x86.h
View File

@ -97,23 +97,23 @@ template<> struct QAtomicIntegerTraits<unsigned int> { enum { IsInteger = 1 }; }
template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> > template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> >
{ {
static inline bool isReferenceCountingNative() { return true; } static inline bool isReferenceCountingNative() Q_DECL_NOTHROW { return true; }
static inline bool isReferenceCountingWaitFree() { return true; } static inline bool isReferenceCountingWaitFree() Q_DECL_NOTHROW { return true; }
template <typename T> static bool ref(T &_q_value); template <typename T> static bool ref(T &_q_value) Q_DECL_NOTHROW;
template <typename T> static bool deref(T &_q_value); template <typename T> static bool deref(T &_q_value) Q_DECL_NOTHROW;
static inline bool isTestAndSetNative() { return true; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return true; }
static inline bool isTestAndSetWaitFree() { return true; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return true; }
template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue); template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndStoreNative() { return true; } static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { return true; }
static inline bool isFetchAndStoreWaitFree() { return true; } static inline bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return true; }
template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue); template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW;
static inline bool isFetchAndAddNative() { return true; } static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return true; }
static inline bool isFetchAndAddWaitFree() { return true; } static inline bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return true; }
template <typename T> static template <typename T> static
T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd); T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW;
}; };
template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)> template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
@ -162,7 +162,7 @@ template<> struct QAtomicIntegerTraits<unsigned long long> { enum { IsInteger =
*/ */
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<1>::ref(T &_q_value) bool QBasicAtomicOps<1>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -175,7 +175,7 @@ bool QBasicAtomicOps<1>::ref(T &_q_value)
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<2>::ref(T &_q_value) bool QBasicAtomicOps<2>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -188,7 +188,7 @@ bool QBasicAtomicOps<2>::ref(T &_q_value)
} }
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<4>::ref(T &_q_value) bool QBasicAtomicOps<4>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -201,7 +201,7 @@ bool QBasicAtomicOps<4>::ref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<1>::deref(T &_q_value) bool QBasicAtomicOps<1>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -214,7 +214,7 @@ bool QBasicAtomicOps<1>::deref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<2>::deref(T &_q_value) bool QBasicAtomicOps<2>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -226,7 +226,7 @@ bool QBasicAtomicOps<2>::deref(T &_q_value)
return ret != 0; return ret != 0;
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<4>::deref(T &_q_value) bool QBasicAtomicOps<4>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -239,7 +239,7 @@ bool QBasicAtomicOps<4>::deref(T &_q_value)
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
bool QBasicAtomicOps<size>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<size>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -252,7 +252,7 @@ bool QBasicAtomicOps<size>::testAndSetRelaxed(T &_q_value, T expectedValue, T ne
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<1>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool QBasicAtomicOps<1>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -265,7 +265,7 @@ bool QBasicAtomicOps<1>::testAndSetRelaxed(T &_q_value, T expectedValue, T newVa
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
T QBasicAtomicOps<size>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<size>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
asm volatile("xchg %0,%1" asm volatile("xchg %0,%1"
: "=r" (newValue), "+m" (_q_value) : "=r" (newValue), "+m" (_q_value)
@ -275,7 +275,7 @@ T QBasicAtomicOps<size>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndStoreRelaxed(T &_q_value, T newValue) T QBasicAtomicOps<1>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW
{ {
asm volatile("xchg %0,%1" asm volatile("xchg %0,%1"
: "=q" (newValue), "+m" (_q_value) : "=q" (newValue), "+m" (_q_value)
@ -285,7 +285,7 @@ T QBasicAtomicOps<1>::fetchAndStoreRelaxed(T &_q_value, T newValue)
} }
template<int size> template <typename T> inline template<int size> template <typename T> inline
T QBasicAtomicOps<size>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<size>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T result; T result;
asm volatile("lock\n" asm volatile("lock\n"
@ -297,7 +297,7 @@ T QBasicAtomicOps<size>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiv
} }
template<> template <typename T> inline template<> template <typename T> inline
T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T result; T result;
asm volatile("lock\n" asm volatile("lock\n"
@ -353,7 +353,7 @@ T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveTy
#ifdef Q_PROCESSOR_X86_64 #ifdef Q_PROCESSOR_X86_64
// native support for 64-bit types // native support for 64-bit types
template<> template<typename T> inline template<> template<typename T> inline
bool QBasicAtomicOps<8>::ref(T &_q_value) bool QBasicAtomicOps<8>::ref(T &_q_value) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -366,7 +366,7 @@ bool QBasicAtomicOps<8>::ref(T &_q_value)
} }
template<> template <typename T> inline template<> template <typename T> inline
bool QBasicAtomicOps<8>::deref(T &_q_value) bool QBasicAtomicOps<8>::deref(T &_q_value) Q_DECL_NOTHROW
{ {
unsigned char ret; unsigned char ret;
asm volatile("lock\n" asm volatile("lock\n"
@ -381,10 +381,10 @@ bool QBasicAtomicOps<8>::deref(T &_q_value)
// i386 architecture, emulate 64-bit support via cmpxchg8b // i386 architecture, emulate 64-bit support via cmpxchg8b
template <> struct QBasicAtomicOps<8>: QGenericAtomicOps<QBasicAtomicOps<8> > template <> struct QBasicAtomicOps<8>: QGenericAtomicOps<QBasicAtomicOps<8> >
{ {
static inline bool isTestAndSetNative() { return true; } static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return true; }
static inline bool isTestAndSetWaitFree() { return true; } static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return true; }
template <typename T> static inline template <typename T> static inline
bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW
{ {
#ifdef __PIC__ #ifdef __PIC__
# define EBX_reg "r" # define EBX_reg "r"

58
src/corelib/thread/qgenericatomic.h
View File

@ -80,32 +80,32 @@ template <typename BaseClass> struct QGenericAtomicOps
{ {
template <typename T> struct AtomicType { typedef T Type; typedef T *PointerType; }; template <typename T> struct AtomicType { typedef T Type; typedef T *PointerType; };
template <typename T> static void acquireMemoryFence(const T &_q_value) template <typename T> static void acquireMemoryFence(const T &_q_value) Q_DECL_NOTHROW
{ {
BaseClass::orderedMemoryFence(_q_value); BaseClass::orderedMemoryFence(_q_value);
} }
template <typename T> static void releaseMemoryFence(const T &_q_value) template <typename T> static void releaseMemoryFence(const T &_q_value) Q_DECL_NOTHROW
{ {
BaseClass::orderedMemoryFence(_q_value); BaseClass::orderedMemoryFence(_q_value);
} }
template <typename T> static void orderedMemoryFence(const T &) template <typename T> static void orderedMemoryFence(const T &) Q_DECL_NOTHROW
{ {
} }
template <typename T> static inline always_inline template <typename T> static inline always_inline
T load(const T &_q_value) T load(const T &_q_value) Q_DECL_NOTHROW
{ {
return _q_value; return _q_value;
} }
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
void store(T &_q_value, X newValue) void store(T &_q_value, X newValue) Q_DECL_NOTHROW
{ {
_q_value = newValue; _q_value = newValue;
} }
template <typename T> static inline always_inline template <typename T> static inline always_inline
T loadAcquire(const T &_q_value) T loadAcquire(const T &_q_value) Q_DECL_NOTHROW
{ {
T tmp = *static_cast<const volatile T *>(&_q_value); T tmp = *static_cast<const volatile T *>(&_q_value);
BaseClass::acquireMemoryFence(_q_value); BaseClass::acquireMemoryFence(_q_value);
@ -113,24 +113,24 @@ template <typename BaseClass> struct QGenericAtomicOps
} }
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
void storeRelease(T &_q_value, X newValue) void storeRelease(T &_q_value, X newValue) Q_DECL_NOTHROW
{ {
BaseClass::releaseMemoryFence(_q_value); BaseClass::releaseMemoryFence(_q_value);
*static_cast<volatile T *>(&_q_value) = newValue; *static_cast<volatile T *>(&_q_value) = newValue;
} }
static inline bool isReferenceCountingNative() static inline bool isReferenceCountingNative() Q_DECL_NOTHROW
{ return BaseClass::isFetchAndAddNative(); } { return BaseClass::isFetchAndAddNative(); }
static inline bool isReferenceCountingWaitFree() static inline bool isReferenceCountingWaitFree() Q_DECL_NOTHROW
{ return BaseClass::isFetchAndAddWaitFree(); } { return BaseClass::isFetchAndAddWaitFree(); }
template <typename T> static inline always_inline template <typename T> static inline always_inline
bool ref(T &_q_value) bool ref(T &_q_value) Q_DECL_NOTHROW
{ {
return BaseClass::fetchAndAddRelaxed(_q_value, 1) != T(-1); return BaseClass::fetchAndAddRelaxed(_q_value, 1) != T(-1);
} }
template <typename T> static inline always_inline template <typename T> static inline always_inline
bool deref(T &_q_value) bool deref(T &_q_value) Q_DECL_NOTHROW
{ {
return BaseClass::fetchAndAddRelaxed(_q_value, -1) != 1; return BaseClass::fetchAndAddRelaxed(_q_value, -1) != 1;
} }
@ -138,14 +138,14 @@ template <typename BaseClass> struct QGenericAtomicOps
#if 0 #if 0
// These functions have no default implementation // These functions have no default implementation
// Archictectures must implement them // Archictectures must implement them
static inline bool isTestAndSetNative(); static inline bool isTestAndSetNative() Q_DECL_NOTHROW;
static inline bool isTestAndSetWaitFree(); static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW;
template <typename T, typename X> static inline template <typename T, typename X> static inline
bool testAndSetRelaxed(T &_q_value, X expectedValue, X newValue); bool testAndSetRelaxed(T &_q_value, X expectedValue, X newValue) Q_DECL_NOTHROW;
#endif #endif
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue) bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue) Q_DECL_NOTHROW
{ {
bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue); bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
BaseClass::acquireMemoryFence(_q_value); BaseClass::acquireMemoryFence(_q_value);
@ -153,24 +153,24 @@ template <typename BaseClass> struct QGenericAtomicOps
} }
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
bool testAndSetRelease(T &_q_value, X expectedValue, X newValue) bool testAndSetRelease(T &_q_value, X expectedValue, X newValue) Q_DECL_NOTHROW
{ {
BaseClass::releaseMemoryFence(_q_value); BaseClass::releaseMemoryFence(_q_value);
return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue); return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
} }
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue) bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue) Q_DECL_NOTHROW
{ {
BaseClass::orderedMemoryFence(_q_value); BaseClass::orderedMemoryFence(_q_value);
return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue); return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
} }
static inline bool isFetchAndStoreNative() { return false; } static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { return false; }
static inline bool isFetchAndStoreWaitFree() { return false; } static inline bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return false; }
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
T fetchAndStoreRelaxed(T &_q_value, X newValue) T fetchAndStoreRelaxed(T &_q_value, X newValue) Q_DECL_NOTHROW
{ {
// implement fetchAndStore on top of testAndSet // implement fetchAndStore on top of testAndSet
Q_FOREVER { Q_FOREVER {
@ -181,7 +181,7 @@ template <typename BaseClass> struct QGenericAtomicOps
} }
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
T fetchAndStoreAcquire(T &_q_value, X newValue) T fetchAndStoreAcquire(T &_q_value, X newValue) Q_DECL_NOTHROW
{ {
T tmp = BaseClass::fetchAndStoreRelaxed(_q_value, newValue); T tmp = BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
BaseClass::acquireMemoryFence(_q_value); BaseClass::acquireMemoryFence(_q_value);
@ -189,23 +189,23 @@ template <typename BaseClass> struct QGenericAtomicOps
} }
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
T fetchAndStoreRelease(T &_q_value, X newValue) T fetchAndStoreRelease(T &_q_value, X newValue) Q_DECL_NOTHROW
{ {
BaseClass::releaseMemoryFence(_q_value); BaseClass::releaseMemoryFence(_q_value);
return BaseClass::fetchAndStoreRelaxed(_q_value, newValue); return BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
} }
template <typename T, typename X> static inline always_inline template <typename T, typename X> static inline always_inline
T fetchAndStoreOrdered(T &_q_value, X newValue) T fetchAndStoreOrdered(T &_q_value, X newValue) Q_DECL_NOTHROW
{ {
BaseClass::orderedMemoryFence(_q_value); BaseClass::orderedMemoryFence(_q_value);
return BaseClass::fetchAndStoreRelaxed(_q_value, newValue); return BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
} }
static inline bool isFetchAndAddNative() { return false; } static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return false; }
static inline bool isFetchAndAddWaitFree() { return false; } static inline bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return false; }
template <typename T> static inline always_inline template <typename T> static inline always_inline
T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
// implement fetchAndAdd on top of testAndSet // implement fetchAndAdd on top of testAndSet
Q_FOREVER { Q_FOREVER {
@ -216,7 +216,7 @@ template <typename BaseClass> struct QGenericAtomicOps
} }
template <typename T> static inline always_inline template <typename T> static inline always_inline
T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
T tmp = BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd); T tmp = BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
BaseClass::acquireMemoryFence(_q_value); BaseClass::acquireMemoryFence(_q_value);
@ -224,14 +224,14 @@ template <typename BaseClass> struct QGenericAtomicOps
} }
template <typename T> static inline always_inline template <typename T> static inline always_inline
T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
BaseClass::releaseMemoryFence(_q_value); BaseClass::releaseMemoryFence(_q_value);
return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd); return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
} }
template <typename T> static inline always_inline template <typename T> static inline always_inline
T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) Q_DECL_NOTHROW
{ {
BaseClass::orderedMemoryFence(_q_value); BaseClass::orderedMemoryFence(_q_value);
return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd); return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);