Mark all atomic functions as Q_DECL_NOTHROW

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>

1 files changed, 27 insertions, 27 deletions

diff --git a/src/corelib/arch/qatomic_cxx11.h b/src/corelib/arch/qatomic_cxx11.h
index ec6b3e369f..98e8e7043e 100644
--- a/src/corelib/arch/qatomic_cxx11.h
+++ b/src/corelib/arch/qatomic_cxx11.h
@@ -109,126 +109,126 @@ template <typename T> struct QAtomicOps
     static const int AddScale = QAtomicAdditiveType<T>::AddScale;
 
     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);
     }
 
     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);
     }
 
     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);
     }
 
     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);
     }
 
     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);
     }
 
     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);
     }
 
-    static inline bool isReferenceCountingNative() { return true; }
-    static inline bool isReferenceCountingWaitFree() { return false; }
+    static inline bool isReferenceCountingNative() Q_DECL_NOTHROW { return true; }
+    static inline bool isReferenceCountingWaitFree() Q_DECL_NOTHROW { return false; }
     static inline bool ref(Type &_q_value)
     {
         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;
     }
 
-    static inline bool isTestAndSetNative() { return false; }
-    static inline bool isTestAndSetWaitFree() { return false; }
+    static inline bool isTestAndSetNative() Q_DECL_NOTHROW { return false; }
+    static inline bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; }
 
     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);
     }
 
-    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);
     }
 
-    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);
     }
 
-    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);
     }
 
-    static inline bool isFetchAndStoreNative() { return false; }
-    static inline bool isFetchAndStoreWaitFree() { return false; }
+    static inline bool isFetchAndStoreNative() Q_DECL_NOTHROW { 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);
     }
 
-    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);
     }
 
-    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);
     }
 
-    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);
     }
 
-    static inline bool isFetchAndAddNative() { return false; }
-    static inline bool isFetchAndAddWaitFree() { return false; }
+    static inline bool isFetchAndAddNative() Q_DECL_NOTHROW { return false; }
+    static inline bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return false; }
 
     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,
                                   std::memory_order_relaxed);
     }
 
     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,
                                   std::memory_order_acquire);
     }
 
     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,
                                   std::memory_order_release);
     }
 
     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,
                                   std::memory_order_acq_rel);