From a1e62e7ba14b00ac7c361936a18e7bc42bf1286d Mon Sep 17 00:00:00 2001 From: Allan Sandfeld Jensen Date: Tue, 2 Apr 2019 10:54:54 +0200 Subject: Replace Q_DECL_NOEXCEPT with noexcept in corelib In preparation of Qt6 move away from pre-C++11 macros. Change-Id: I44126693c20c18eca5620caab4f7e746218e0ce3 Reviewed-by: Thiago Macieira --- src/corelib/thread/qatomic.h | 18 +-- src/corelib/thread/qatomic_bootstrap.h | 10 +- src/corelib/thread/qatomic_cxx11.h | 86 ++++++------- src/corelib/thread/qatomic_msvc.h | 94 +++++++------- src/corelib/thread/qbasicatomic.h | 194 ++++++++++++++--------------- src/corelib/thread/qfutex_p.h | 2 +- src/corelib/thread/qgenericatomic.h | 98 +++++++-------- src/corelib/thread/qmutex.cpp | 14 +-- src/corelib/thread/qmutex.h | 54 ++++---- src/corelib/thread/qmutex_linux.cpp | 8 +- src/corelib/thread/qmutex_mac.cpp | 2 +- src/corelib/thread/qmutex_p.h | 4 +- src/corelib/thread/qmutex_unix.cpp | 4 +- src/corelib/thread/qmutex_win.cpp | 2 +- src/corelib/thread/qorderedmutexlocker_p.h | 2 +- src/corelib/thread/qreadwritelock.h | 36 +++--- src/corelib/thread/qsemaphore.h | 14 +-- src/corelib/thread/qthread.cpp | 4 +- src/corelib/thread/qthread.h | 4 +- src/corelib/thread/qthread_p.h | 4 +- src/corelib/thread/qthread_unix.cpp | 4 +- src/corelib/thread/qthread_win.cpp | 8 +- 22 files changed, 333 insertions(+), 333 deletions(-) (limited to 'src/corelib/thread') diff --git a/src/corelib/thread/qatomic.h b/src/corelib/thread/qatomic.h index f842534c38..280ce96b76 100644 --- a/src/corelib/thread/qatomic.h +++ b/src/corelib/thread/qatomic.h @@ -57,15 +57,15 @@ class QAtomicInteger : public QBasicAtomicInteger public: // Non-atomic API #ifdef QT_BASIC_ATOMIC_HAS_CONSTRUCTORS - constexpr QAtomicInteger(T value = 0) Q_DECL_NOTHROW : QBasicAtomicInteger(value) {} + constexpr QAtomicInteger(T value = 0) noexcept : QBasicAtomicInteger(value) {} #else - inline QAtomicInteger(T value = 0) Q_DECL_NOTHROW + inline QAtomicInteger(T value = 0) noexcept { this->_q_value = value; } #endif - inline QAtomicInteger(const QAtomicInteger &other) Q_DECL_NOTHROW + inline QAtomicInteger(const QAtomicInteger &other) noexcept #ifdef QT_BASIC_ATOMIC_HAS_CONSTRUCTORS : QBasicAtomicInteger() #endif @@ -73,7 +73,7 @@ public: this->storeRelease(other.loadAcquire()); } - inline QAtomicInteger &operator=(const QAtomicInteger &other) Q_DECL_NOTHROW + inline QAtomicInteger &operator=(const QAtomicInteger &other) noexcept { this->storeRelease(other.loadAcquire()); return *this; @@ -159,7 +159,7 @@ public: #ifdef QT_BASIC_ATOMIC_HAS_CONSTRUCTORS constexpr #endif - QAtomicInt(int value = 0) Q_DECL_NOTHROW : QAtomicInteger(value) {} + QAtomicInt(int value = 0) noexcept : QAtomicInteger(value) {} }; // High-level atomic pointer operations @@ -168,14 +168,14 @@ class QAtomicPointer : public QBasicAtomicPointer { public: #ifdef QT_BASIC_ATOMIC_HAS_CONSTRUCTORS - constexpr QAtomicPointer(T *value = nullptr) Q_DECL_NOTHROW : QBasicAtomicPointer(value) {} + constexpr QAtomicPointer(T *value = nullptr) noexcept : QBasicAtomicPointer(value) {} #else - inline QAtomicPointer(T *value = nullptr) Q_DECL_NOTHROW + inline QAtomicPointer(T *value = nullptr) noexcept { this->store(value); } #endif - inline QAtomicPointer(const QAtomicPointer &other) Q_DECL_NOTHROW + inline QAtomicPointer(const QAtomicPointer &other) noexcept #ifdef QT_BASIC_ATOMIC_HAS_CONSTRUCTORS : QBasicAtomicPointer() #endif @@ -183,7 +183,7 @@ public: this->storeRelease(other.loadAcquire()); } - inline QAtomicPointer &operator=(const QAtomicPointer &other) Q_DECL_NOTHROW + inline QAtomicPointer &operator=(const QAtomicPointer &other) noexcept { this->storeRelease(other.loadAcquire()); return *this; diff --git a/src/corelib/thread/qatomic_bootstrap.h b/src/corelib/thread/qatomic_bootstrap.h index 27a67fb2ee..c4279ee7b1 100644 --- a/src/corelib/thread/qatomic_bootstrap.h +++ b/src/corelib/thread/qatomic_bootstrap.h @@ -56,16 +56,16 @@ template struct QAtomicOps: QGenericAtomicOps > { typedef T Type; - static bool ref(T &_q_value) Q_DECL_NOTHROW + static bool ref(T &_q_value) noexcept { return ++_q_value != 0; } - static bool deref(T &_q_value) Q_DECL_NOTHROW + static bool deref(T &_q_value) noexcept { return --_q_value != 0; } - static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) Q_DECL_NOTHROW + static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept { if (currentValue) *currentValue = _q_value; @@ -76,7 +76,7 @@ template struct QAtomicOps: QGenericAtomicOps > return false; } - static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW + static T fetchAndStoreRelaxed(T &_q_value, T newValue) noexcept { T tmp = _q_value; _q_value = newValue; @@ -84,7 +84,7 @@ template struct QAtomicOps: QGenericAtomicOps > } template static - T fetchAndAddRelaxed(T &_q_value, AdditiveType valueToAdd) Q_DECL_NOTHROW + T fetchAndAddRelaxed(T &_q_value, AdditiveType valueToAdd) noexcept { T returnValue = _q_value; _q_value += valueToAdd; diff --git a/src/corelib/thread/qatomic_cxx11.h b/src/corelib/thread/qatomic_cxx11.h index 2fc0bf5419..32d27734fc 100644 --- a/src/corelib/thread/qatomic_cxx11.h +++ b/src/corelib/thread/qatomic_cxx11.h @@ -222,43 +222,43 @@ template struct QAtomicOps typedef std::atomic Type; template static inline - T load(const std::atomic &_q_value) Q_DECL_NOTHROW + T load(const std::atomic &_q_value) noexcept { return _q_value.load(std::memory_order_relaxed); } template static inline - T load(const volatile std::atomic &_q_value) Q_DECL_NOTHROW + T load(const volatile std::atomic &_q_value) noexcept { return _q_value.load(std::memory_order_relaxed); } template static inline - T loadAcquire(const std::atomic &_q_value) Q_DECL_NOTHROW + T loadAcquire(const std::atomic &_q_value) noexcept { return _q_value.load(std::memory_order_acquire); } template static inline - T loadAcquire(const volatile std::atomic &_q_value) Q_DECL_NOTHROW + T loadAcquire(const volatile std::atomic &_q_value) noexcept { return _q_value.load(std::memory_order_acquire); } template static inline - void store(std::atomic &_q_value, T newValue) Q_DECL_NOTHROW + void store(std::atomic &_q_value, T newValue) noexcept { _q_value.store(newValue, std::memory_order_relaxed); } template static inline - void storeRelease(std::atomic &_q_value, T newValue) Q_DECL_NOTHROW + void storeRelease(std::atomic &_q_value, T newValue) noexcept { _q_value.store(newValue, std::memory_order_release); } - static inline Q_DECL_CONSTEXPR bool isReferenceCountingNative() Q_DECL_NOTHROW { return isTestAndSetNative(); } - static inline Q_DECL_CONSTEXPR bool isReferenceCountingWaitFree() Q_DECL_NOTHROW { return false; } + static inline Q_DECL_CONSTEXPR bool isReferenceCountingNative() noexcept { return isTestAndSetNative(); } + static inline Q_DECL_CONSTEXPR bool isReferenceCountingWaitFree() noexcept { return false; } template static inline bool ref(std::atomic &_q_value) { @@ -266,17 +266,17 @@ template struct QAtomicOps } template - static inline bool deref(std::atomic &_q_value) Q_DECL_NOTHROW + static inline bool deref(std::atomic &_q_value) noexcept { return --_q_value != 0; } - static inline Q_DECL_CONSTEXPR bool isTestAndSetNative() Q_DECL_NOTHROW + static inline Q_DECL_CONSTEXPR bool isTestAndSetNative() noexcept { return QAtomicTraits::isLockFree(); } - static inline Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return false; } + static inline Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() noexcept { return false; } template - static bool testAndSetRelaxed(std::atomic &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) Q_DECL_NOTHROW + static bool testAndSetRelaxed(std::atomic &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept { bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_relaxed, std::memory_order_relaxed); if (currentValue) @@ -285,7 +285,7 @@ template struct QAtomicOps } template - static bool testAndSetAcquire(std::atomic &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) Q_DECL_NOTHROW + static bool testAndSetAcquire(std::atomic &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept { bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acquire, std::memory_order_acquire); if (currentValue) @@ -294,7 +294,7 @@ template struct QAtomicOps } template - static bool testAndSetRelease(std::atomic &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) Q_DECL_NOTHROW + static bool testAndSetRelease(std::atomic &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept { bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_release, std::memory_order_relaxed); if (currentValue) @@ -303,7 +303,7 @@ template struct QAtomicOps } template - static bool testAndSetOrdered(std::atomic &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) Q_DECL_NOTHROW + static bool testAndSetOrdered(std::atomic &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept { bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acq_rel, std::memory_order_acquire); if (currentValue) @@ -311,152 +311,152 @@ template struct QAtomicOps return tmp; } - static inline Q_DECL_CONSTEXPR bool isFetchAndStoreNative() Q_DECL_NOTHROW { return isTestAndSetNative(); } - static inline Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return false; } + static inline Q_DECL_CONSTEXPR bool isFetchAndStoreNative() noexcept { return isTestAndSetNative(); } + static inline Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() noexcept { return false; } template - static T fetchAndStoreRelaxed(std::atomic &_q_value, T newValue) Q_DECL_NOTHROW + static T fetchAndStoreRelaxed(std::atomic &_q_value, T newValue) noexcept { return _q_value.exchange(newValue, std::memory_order_relaxed); } template - static T fetchAndStoreAcquire(std::atomic &_q_value, T newValue) Q_DECL_NOTHROW + static T fetchAndStoreAcquire(std::atomic &_q_value, T newValue) noexcept { return _q_value.exchange(newValue, std::memory_order_acquire); } template - static T fetchAndStoreRelease(std::atomic &_q_value, T newValue) Q_DECL_NOTHROW + static T fetchAndStoreRelease(std::atomic &_q_value, T newValue) noexcept { return _q_value.exchange(newValue, std::memory_order_release); } template - static T fetchAndStoreOrdered(std::atomic &_q_value, T newValue) Q_DECL_NOTHROW + static T fetchAndStoreOrdered(std::atomic &_q_value, T newValue) noexcept { return _q_value.exchange(newValue, std::memory_order_acq_rel); } - static inline Q_DECL_CONSTEXPR bool isFetchAndAddNative() Q_DECL_NOTHROW { return isTestAndSetNative(); } - static inline Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return false; } + static inline Q_DECL_CONSTEXPR bool isFetchAndAddNative() noexcept { return isTestAndSetNative(); } + static inline Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() noexcept { return false; } template static inline - T fetchAndAddRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAddRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_add(valueToAdd, std::memory_order_relaxed); } template static inline - T fetchAndAddAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAddAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_add(valueToAdd, std::memory_order_acquire); } template static inline - T fetchAndAddRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAddRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_add(valueToAdd, std::memory_order_release); } template static inline - T fetchAndAddOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAddOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_add(valueToAdd, std::memory_order_acq_rel); } template static inline - T fetchAndSubRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndSubRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_sub(valueToAdd, std::memory_order_relaxed); } template static inline - T fetchAndSubAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndSubAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_sub(valueToAdd, std::memory_order_acquire); } template static inline - T fetchAndSubRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndSubRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_sub(valueToAdd, std::memory_order_release); } template static inline - T fetchAndSubOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndSubOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_sub(valueToAdd, std::memory_order_acq_rel); } template static inline - T fetchAndAndRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAndRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_and(valueToAdd, std::memory_order_relaxed); } template static inline - T fetchAndAndAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAndAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_and(valueToAdd, std::memory_order_acquire); } template static inline - T fetchAndAndRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAndRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_and(valueToAdd, std::memory_order_release); } template static inline - T fetchAndAndOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAndOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_and(valueToAdd, std::memory_order_acq_rel); } template static inline - T fetchAndOrRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndOrRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_or(valueToAdd, std::memory_order_relaxed); } template static inline - T fetchAndOrAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndOrAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_or(valueToAdd, std::memory_order_acquire); } template static inline - T fetchAndOrRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndOrRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_or(valueToAdd, std::memory_order_release); } template static inline - T fetchAndOrOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndOrOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_or(valueToAdd, std::memory_order_acq_rel); } template static inline - T fetchAndXorRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndXorRelaxed(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_xor(valueToAdd, std::memory_order_relaxed); } template static inline - T fetchAndXorAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndXorAcquire(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_xor(valueToAdd, std::memory_order_acquire); } template static inline - T fetchAndXorRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndXorRelease(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_xor(valueToAdd, std::memory_order_release); } template static inline - T fetchAndXorOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndXorOrdered(std::atomic &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return _q_value.fetch_xor(valueToAdd, std::memory_order_acq_rel); } diff --git a/src/corelib/thread/qatomic_msvc.h b/src/corelib/thread/qatomic_msvc.h index 5eae2bdc48..67b5224cd7 100644 --- a/src/corelib/thread/qatomic_msvc.h +++ b/src/corelib/thread/qatomic_msvc.h @@ -269,24 +269,24 @@ template <> struct QAtomicWindowsType<4> { typedef long Type; }; template struct QAtomicOpsBySize : QGenericAtomicOps > { - static inline Q_DECL_CONSTEXPR bool isReferenceCountingNative() Q_DECL_NOTHROW { return true; } - static inline Q_DECL_CONSTEXPR bool isReferenceCountingWaitFree() Q_DECL_NOTHROW { return true; } - template static bool ref(T &_q_value) Q_DECL_NOTHROW; - template static bool deref(T &_q_value) Q_DECL_NOTHROW; - - static inline Q_DECL_CONSTEXPR bool isTestAndSetNative() Q_DECL_NOTHROW { return true; } - static inline Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return true; } - template static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW; + static inline Q_DECL_CONSTEXPR bool isReferenceCountingNative() noexcept { return true; } + static inline Q_DECL_CONSTEXPR bool isReferenceCountingWaitFree() noexcept { return true; } + template static bool ref(T &_q_value) noexcept; + template static bool deref(T &_q_value) noexcept; + + static inline Q_DECL_CONSTEXPR bool isTestAndSetNative() noexcept { return true; } + static inline Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() noexcept { return true; } + template static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) noexcept; template - static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue) Q_DECL_NOTHROW; + static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue) noexcept; - static inline Q_DECL_CONSTEXPR bool isFetchAndStoreNative() Q_DECL_NOTHROW { return true; } - static inline Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return true; } - template static T fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW; + static inline Q_DECL_CONSTEXPR bool isFetchAndStoreNative() noexcept { return true; } + static inline Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() noexcept { return true; } + template static T fetchAndStoreRelaxed(T &_q_value, T newValue) noexcept; - static inline Q_DECL_CONSTEXPR bool isFetchAndAddNative() Q_DECL_NOTHROW { return true; } - static inline Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return true; } - template static T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW; + static inline Q_DECL_CONSTEXPR bool isFetchAndAddNative() noexcept { return true; } + static inline Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() noexcept { return true; } + template static T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept; private: typedef typename QAtomicWindowsType::Type Type; @@ -303,76 +303,76 @@ struct QAtomicOps : QAtomicOpsBySize }; template<> template -inline bool QAtomicOpsBySize<4>::ref(T &_q_value) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<4>::ref(T &_q_value) noexcept { return QT_INTERLOCKED_FUNCTION(Increment)(atomic(&_q_value)) != 0; } template<> template -inline bool QAtomicOpsBySize<4>::deref(T &_q_value) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<4>::deref(T &_q_value) noexcept { return QT_INTERLOCKED_FUNCTION(Decrement)(atomic(&_q_value)) != 0; } template<> template -inline bool QAtomicOpsBySize<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) noexcept { return QT_INTERLOCKED_FUNCTION(CompareExchange)(atomic(&_q_value), value(newValue), value(expectedValue)) == value(expectedValue); } template<> template -inline bool QAtomicOpsBySize<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<4>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue) noexcept { *currentValue = T(QT_INTERLOCKED_FUNCTION(CompareExchange)(atomic(&_q_value), newValue, expectedValue)); return *currentValue == expectedValue; } template<> template -inline T QAtomicOpsBySize<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW +inline T QAtomicOpsBySize<4>::fetchAndStoreRelaxed(T &_q_value, T newValue) noexcept { return QT_INTERLOCKED_FUNCTION(Exchange)(atomic(&_q_value), value(newValue)); } template<> template -inline T QAtomicOpsBySize<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW +inline T QAtomicOpsBySize<4>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return QT_INTERLOCKED_FUNCTION(ExchangeAdd)(atomic(&_q_value), value(valueToAdd * QAtomicAdditiveType::AddScale)); } #ifdef Q_ATOMIC_INT16_IS_SUPPORTED template<> template -inline bool QAtomicOpsBySize<2>::ref(T &_q_value) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<2>::ref(T &_q_value) noexcept { return QT_INTERLOCKED_FUNCTION(Increment16)(atomic(&_q_value)) != 0; } template<> template -inline bool QAtomicOpsBySize<2>::deref(T &_q_value) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<2>::deref(T &_q_value) noexcept { return QT_INTERLOCKED_FUNCTION(Decrement16)(atomic(&_q_value)) != 0; } template<> template -inline bool QAtomicOpsBySize<2>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<2>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) noexcept { return QT_INTERLOCKED_FUNCTION(CompareExchange16)(atomic(&_q_value), value(newValue), value(expectedValue)) == value(expectedValue); } template<> template -inline bool QAtomicOpsBySize<2>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<2>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue) noexcept { *currentValue = T(QT_INTERLOCKED_FUNCTION(CompareExchange16)(atomic(&_q_value), newValue, expectedValue)); return *currentValue == expectedValue; } template<> template -inline T QAtomicOpsBySize<2>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW +inline T QAtomicOpsBySize<2>::fetchAndStoreRelaxed(T &_q_value, T newValue) noexcept { return QT_INTERLOCKED_FUNCTION(Exchange16)(atomic(&_q_value), value(newValue)); } template<> template -inline T QAtomicOpsBySize<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW +inline T QAtomicOpsBySize<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return QT_INTERLOCKED_FUNCTION(ExchangeAdd16)(atomic(&_q_value), value(valueToAdd * QAtomicAdditiveType::AddScale)); } @@ -380,38 +380,38 @@ inline T QAtomicOpsBySize<2>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAd #ifdef Q_ATOMIC_INT64_IS_SUPPORTED template<> template -inline bool QAtomicOpsBySize<8>::ref(T &_q_value) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<8>::ref(T &_q_value) noexcept { return QT_INTERLOCKED_FUNCTION(Increment64)(atomic(&_q_value)) != 0; } template<> template -inline bool QAtomicOpsBySize<8>::deref(T &_q_value) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<8>::deref(T &_q_value) noexcept { return QT_INTERLOCKED_FUNCTION(Decrement64)(atomic(&_q_value)) != 0; } template<> template -inline bool QAtomicOpsBySize<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue) noexcept { return QT_INTERLOCKED_FUNCTION(CompareExchange64)(atomic(&_q_value), value(newValue), value(expectedValue)) == value(expectedValue); } template<> template -inline bool QAtomicOpsBySize<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue) Q_DECL_NOTHROW +inline bool QAtomicOpsBySize<8>::testAndSetRelaxed(T &_q_value, T expectedValue, T newValue, T *currentValue) noexcept { *currentValue = T(QT_INTERLOCKED_FUNCTION(CompareExchange64)(atomic(&_q_value), newValue, expectedValue)); return *currentValue == expectedValue; } template<> template -inline T QAtomicOpsBySize<8>::fetchAndStoreRelaxed(T &_q_value, T newValue) Q_DECL_NOTHROW +inline T QAtomicOpsBySize<8>::fetchAndStoreRelaxed(T &_q_value, T newValue) noexcept { return QT_INTERLOCKED_FUNCTION(Exchange64)(atomic(&_q_value), value(newValue)); } template<> template -inline T QAtomicOpsBySize<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW +inline T QAtomicOpsBySize<8>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { return QT_INTERLOCKED_FUNCTION(ExchangeAdd64)(atomic(&_q_value), value(valueToAdd * QAtomicAdditiveType::AddScale)); } @@ -423,41 +423,41 @@ struct QAtomicOps : QGenericAtomicOps > { typedef T *Type; - static inline Q_DECL_CONSTEXPR bool isTestAndSetNative() Q_DECL_NOTHROW { return true; } - static inline Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return true; } - static bool testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) Q_DECL_NOTHROW; - static bool testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue, T **currentValue) Q_DECL_NOTHROW; + static inline Q_DECL_CONSTEXPR bool isTestAndSetNative() noexcept { return true; } + static inline Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() noexcept { return true; } + static bool testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) noexcept; + static bool testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue, T **currentValue) noexcept; - static inline Q_DECL_CONSTEXPR bool isFetchAndStoreNative() Q_DECL_NOTHROW { return true; } - static inline Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return true; } - static T *fetchAndStoreRelaxed(T *&_q_value, T *newValue) Q_DECL_NOTHROW; + static inline Q_DECL_CONSTEXPR bool isFetchAndStoreNative() noexcept { return true; } + static inline Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() noexcept { return true; } + static T *fetchAndStoreRelaxed(T *&_q_value, T *newValue) noexcept; - static inline Q_DECL_CONSTEXPR bool isFetchAndAddNative() Q_DECL_NOTHROW { return true; } - static inline Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return true; } - static T *fetchAndAddRelaxed(T *&_q_value, qptrdiff valueToAdd) Q_DECL_NOTHROW; + static inline Q_DECL_CONSTEXPR bool isFetchAndAddNative() noexcept { return true; } + static inline Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() noexcept { return true; } + static T *fetchAndAddRelaxed(T *&_q_value, qptrdiff valueToAdd) noexcept; }; template -inline bool QAtomicOps::testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) Q_DECL_NOTHROW +inline bool QAtomicOps::testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue) noexcept { return QT_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&_q_value, newValue, expectedValue) == expectedValue; } template -inline bool QAtomicOps::testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue, T **currentValue) Q_DECL_NOTHROW +inline bool QAtomicOps::testAndSetRelaxed(T *&_q_value, T *expectedValue, T *newValue, T **currentValue) noexcept { *currentValue = reinterpret_cast(QT_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&_q_value, newValue, expectedValue)); return *currentValue == expectedValue; } template -inline T *QAtomicOps::fetchAndStoreRelaxed(T *&_q_value, T *newValue) Q_DECL_NOTHROW +inline T *QAtomicOps::fetchAndStoreRelaxed(T *&_q_value, T *newValue) noexcept { return reinterpret_cast(QT_INTERLOCKED_EXCHANGE_POINTER(&_q_value, newValue)); } template -inline T *QAtomicOps::fetchAndAddRelaxed(T *&_q_value, qptrdiff valueToAdd) Q_DECL_NOTHROW +inline T *QAtomicOps::fetchAndAddRelaxed(T *&_q_value, qptrdiff valueToAdd) noexcept { return reinterpret_cast(QT_INTERLOCKED_EXCHANGE_ADD_POINTER(&_q_value, valueToAdd * sizeof(T))); } diff --git a/src/corelib/thread/qbasicatomic.h b/src/corelib/thread/qbasicatomic.h index a0304697b8..ad6cba04dd 100644 --- a/src/corelib/thread/qbasicatomic.h +++ b/src/corelib/thread/qbasicatomic.h @@ -100,125 +100,125 @@ public: // Everything below is either implemented in ../arch/qatomic_XXX.h or (as fallback) in qgenericatomic.h - T load() const Q_DECL_NOTHROW { return Ops::load(_q_value); } - void store(T newValue) Q_DECL_NOTHROW { Ops::store(_q_value, newValue); } + T load() const noexcept { return Ops::load(_q_value); } + void store(T newValue) noexcept { Ops::store(_q_value, newValue); } - T loadAcquire() const Q_DECL_NOTHROW { return Ops::loadAcquire(_q_value); } - void storeRelease(T newValue) Q_DECL_NOTHROW { Ops::storeRelease(_q_value, newValue); } - operator T() const Q_DECL_NOTHROW { return loadAcquire(); } - T operator=(T newValue) Q_DECL_NOTHROW { storeRelease(newValue); return newValue; } + T loadAcquire() const noexcept { return Ops::loadAcquire(_q_value); } + void storeRelease(T newValue) noexcept { Ops::storeRelease(_q_value, newValue); } + operator T() const noexcept { return loadAcquire(); } + T operator=(T newValue) noexcept { storeRelease(newValue); return newValue; } - static Q_DECL_CONSTEXPR bool isReferenceCountingNative() Q_DECL_NOTHROW { return Ops::isReferenceCountingNative(); } - static Q_DECL_CONSTEXPR bool isReferenceCountingWaitFree() Q_DECL_NOTHROW { return Ops::isReferenceCountingWaitFree(); } + static Q_DECL_CONSTEXPR bool isReferenceCountingNative() noexcept { return Ops::isReferenceCountingNative(); } + static Q_DECL_CONSTEXPR bool isReferenceCountingWaitFree() noexcept { return Ops::isReferenceCountingWaitFree(); } - bool ref() Q_DECL_NOTHROW { return Ops::ref(_q_value); } - bool deref() Q_DECL_NOTHROW { return Ops::deref(_q_value); } + bool ref() noexcept { return Ops::ref(_q_value); } + bool deref() noexcept { return Ops::deref(_q_value); } - static Q_DECL_CONSTEXPR bool isTestAndSetNative() Q_DECL_NOTHROW { return Ops::isTestAndSetNative(); } - static Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return Ops::isTestAndSetWaitFree(); } + static Q_DECL_CONSTEXPR bool isTestAndSetNative() noexcept { return Ops::isTestAndSetNative(); } + static Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() noexcept { return Ops::isTestAndSetWaitFree(); } - bool testAndSetRelaxed(T expectedValue, T newValue) Q_DECL_NOTHROW + bool testAndSetRelaxed(T expectedValue, T newValue) noexcept { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue); } - bool testAndSetAcquire(T expectedValue, T newValue) Q_DECL_NOTHROW + bool testAndSetAcquire(T expectedValue, T newValue) noexcept { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue); } - bool testAndSetRelease(T expectedValue, T newValue) Q_DECL_NOTHROW + bool testAndSetRelease(T expectedValue, T newValue) noexcept { return Ops::testAndSetRelease(_q_value, expectedValue, newValue); } - bool testAndSetOrdered(T expectedValue, T newValue) Q_DECL_NOTHROW + bool testAndSetOrdered(T expectedValue, T newValue) noexcept { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue); } - bool testAndSetRelaxed(T expectedValue, T newValue, T ¤tValue) Q_DECL_NOTHROW + bool testAndSetRelaxed(T expectedValue, T newValue, T ¤tValue) noexcept { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue, ¤tValue); } - bool testAndSetAcquire(T expectedValue, T newValue, T ¤tValue) Q_DECL_NOTHROW + bool testAndSetAcquire(T expectedValue, T newValue, T ¤tValue) noexcept { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue, ¤tValue); } - bool testAndSetRelease(T expectedValue, T newValue, T ¤tValue) Q_DECL_NOTHROW + bool testAndSetRelease(T expectedValue, T newValue, T ¤tValue) noexcept { return Ops::testAndSetRelease(_q_value, expectedValue, newValue, ¤tValue); } - bool testAndSetOrdered(T expectedValue, T newValue, T ¤tValue) Q_DECL_NOTHROW + bool testAndSetOrdered(T expectedValue, T newValue, T ¤tValue) noexcept { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue, ¤tValue); } - static Q_DECL_CONSTEXPR bool isFetchAndStoreNative() Q_DECL_NOTHROW { return Ops::isFetchAndStoreNative(); } - static Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return Ops::isFetchAndStoreWaitFree(); } + static Q_DECL_CONSTEXPR bool isFetchAndStoreNative() noexcept { return Ops::isFetchAndStoreNative(); } + static Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() noexcept { return Ops::isFetchAndStoreWaitFree(); } - T fetchAndStoreRelaxed(T newValue) Q_DECL_NOTHROW + T fetchAndStoreRelaxed(T newValue) noexcept { return Ops::fetchAndStoreRelaxed(_q_value, newValue); } - T fetchAndStoreAcquire(T newValue) Q_DECL_NOTHROW + T fetchAndStoreAcquire(T newValue) noexcept { return Ops::fetchAndStoreAcquire(_q_value, newValue); } - T fetchAndStoreRelease(T newValue) Q_DECL_NOTHROW + T fetchAndStoreRelease(T newValue) noexcept { return Ops::fetchAndStoreRelease(_q_value, newValue); } - T fetchAndStoreOrdered(T newValue) Q_DECL_NOTHROW + T fetchAndStoreOrdered(T newValue) noexcept { return Ops::fetchAndStoreOrdered(_q_value, newValue); } - static Q_DECL_CONSTEXPR bool isFetchAndAddNative() Q_DECL_NOTHROW { return Ops::isFetchAndAddNative(); } - static Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return Ops::isFetchAndAddWaitFree(); } + static Q_DECL_CONSTEXPR bool isFetchAndAddNative() noexcept { return Ops::isFetchAndAddNative(); } + static Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() noexcept { return Ops::isFetchAndAddWaitFree(); } - T fetchAndAddRelaxed(T valueToAdd) Q_DECL_NOTHROW + T fetchAndAddRelaxed(T valueToAdd) noexcept { return Ops::fetchAndAddRelaxed(_q_value, valueToAdd); } - T fetchAndAddAcquire(T valueToAdd) Q_DECL_NOTHROW + T fetchAndAddAcquire(T valueToAdd) noexcept { return Ops::fetchAndAddAcquire(_q_value, valueToAdd); } - T fetchAndAddRelease(T valueToAdd) Q_DECL_NOTHROW + T fetchAndAddRelease(T valueToAdd) noexcept { return Ops::fetchAndAddRelease(_q_value, valueToAdd); } - T fetchAndAddOrdered(T valueToAdd) Q_DECL_NOTHROW + T fetchAndAddOrdered(T valueToAdd) noexcept { return Ops::fetchAndAddOrdered(_q_value, valueToAdd); } - T fetchAndSubRelaxed(T valueToAdd) Q_DECL_NOTHROW + T fetchAndSubRelaxed(T valueToAdd) noexcept { return Ops::fetchAndSubRelaxed(_q_value, valueToAdd); } - T fetchAndSubAcquire(T valueToAdd) Q_DECL_NOTHROW + T fetchAndSubAcquire(T valueToAdd) noexcept { return Ops::fetchAndSubAcquire(_q_value, valueToAdd); } - T fetchAndSubRelease(T valueToAdd) Q_DECL_NOTHROW + T fetchAndSubRelease(T valueToAdd) noexcept { return Ops::fetchAndSubRelease(_q_value, valueToAdd); } - T fetchAndSubOrdered(T valueToAdd) Q_DECL_NOTHROW + T fetchAndSubOrdered(T valueToAdd) noexcept { return Ops::fetchAndSubOrdered(_q_value, valueToAdd); } - T fetchAndAndRelaxed(T valueToAdd) Q_DECL_NOTHROW + T fetchAndAndRelaxed(T valueToAdd) noexcept { return Ops::fetchAndAndRelaxed(_q_value, valueToAdd); } - T fetchAndAndAcquire(T valueToAdd) Q_DECL_NOTHROW + T fetchAndAndAcquire(T valueToAdd) noexcept { return Ops::fetchAndAndAcquire(_q_value, valueToAdd); } - T fetchAndAndRelease(T valueToAdd) Q_DECL_NOTHROW + T fetchAndAndRelease(T valueToAdd) noexcept { return Ops::fetchAndAndRelease(_q_value, valueToAdd); } - T fetchAndAndOrdered(T valueToAdd) Q_DECL_NOTHROW + T fetchAndAndOrdered(T valueToAdd) noexcept { return Ops::fetchAndAndOrdered(_q_value, valueToAdd); } - T fetchAndOrRelaxed(T valueToAdd) Q_DECL_NOTHROW + T fetchAndOrRelaxed(T valueToAdd) noexcept { return Ops::fetchAndOrRelaxed(_q_value, valueToAdd); } - T fetchAndOrAcquire(T valueToAdd) Q_DECL_NOTHROW + T fetchAndOrAcquire(T valueToAdd) noexcept { return Ops::fetchAndOrAcquire(_q_value, valueToAdd); } - T fetchAndOrRelease(T valueToAdd) Q_DECL_NOTHROW + T fetchAndOrRelease(T valueToAdd) noexcept { return Ops::fetchAndOrRelease(_q_value, valueToAdd); } - T fetchAndOrOrdered(T valueToAdd) Q_DECL_NOTHROW + T fetchAndOrOrdered(T valueToAdd) noexcept { return Ops::fetchAndOrOrdered(_q_value, valueToAdd); } - T fetchAndXorRelaxed(T valueToAdd) Q_DECL_NOTHROW + T fetchAndXorRelaxed(T valueToAdd) noexcept { return Ops::fetchAndXorRelaxed(_q_value, valueToAdd); } - T fetchAndXorAcquire(T valueToAdd) Q_DECL_NOTHROW + T fetchAndXorAcquire(T valueToAdd) noexcept { return Ops::fetchAndXorAcquire(_q_value, valueToAdd); } - T fetchAndXorRelease(T valueToAdd) Q_DECL_NOTHROW + T fetchAndXorRelease(T valueToAdd) noexcept { return Ops::fetchAndXorRelease(_q_value, valueToAdd); } - T fetchAndXorOrdered(T valueToAdd) Q_DECL_NOTHROW + T fetchAndXorOrdered(T valueToAdd) noexcept { return Ops::fetchAndXorOrdered(_q_value, valueToAdd); } - T operator++() Q_DECL_NOTHROW + T operator++() noexcept { return fetchAndAddOrdered(1) + 1; } - T operator++(int) Q_DECL_NOTHROW + T operator++(int) noexcept { return fetchAndAddOrdered(1); } - T operator--() Q_DECL_NOTHROW + T operator--() noexcept { return fetchAndSubOrdered(1) - 1; } - T operator--(int) Q_DECL_NOTHROW + T operator--(int) noexcept { return fetchAndSubOrdered(1); } - T operator+=(T v) Q_DECL_NOTHROW + T operator+=(T v) noexcept { return fetchAndAddOrdered(v) + v; } - T operator-=(T v) Q_DECL_NOTHROW + T operator-=(T v) noexcept { return fetchAndSubOrdered(v) - v; } - T operator&=(T v) Q_DECL_NOTHROW + T operator&=(T v) noexcept { return fetchAndAndOrdered(v) & v; } - T operator|=(T v) Q_DECL_NOTHROW + T operator|=(T v) noexcept { return fetchAndOrOrdered(v) | v; } - T operator^=(T v) Q_DECL_NOTHROW + T operator^=(T v) noexcept { return fetchAndXorOrdered(v) ^ v; } #ifdef QT_BASIC_ATOMIC_HAS_CONSTRUCTORS QBasicAtomicInteger() = default; - constexpr QBasicAtomicInteger(T value) Q_DECL_NOTHROW : _q_value(value) {} + constexpr QBasicAtomicInteger(T value) noexcept : _q_value(value) {} QBasicAtomicInteger(const QBasicAtomicInteger &) = delete; QBasicAtomicInteger &operator=(const QBasicAtomicInteger &) = delete; QBasicAtomicInteger &operator=(const QBasicAtomicInteger &) volatile = delete; @@ -236,85 +236,85 @@ public: AtomicType _q_value; - Type load() const Q_DECL_NOTHROW { return Ops::load(_q_value); } - void store(Type newValue) Q_DECL_NOTHROW { Ops::store(_q_value, newValue); } - operator Type() const Q_DECL_NOTHROW { return loadAcquire(); } - Type operator=(Type newValue) Q_DECL_NOTHROW { storeRelease(newValue); return newValue; } + Type load() const noexcept { return Ops::load(_q_value); } + void store(Type newValue) noexcept { Ops::store(_q_value, newValue); } + operator Type() const noexcept { return loadAcquire(); } + Type operator=(Type newValue) noexcept { storeRelease(newValue); return newValue; } // Atomic API, implemented in qatomic_XXX.h - Type loadAcquire() const Q_DECL_NOTHROW { return Ops::loadAcquire(_q_value); } - void storeRelease(Type newValue) Q_DECL_NOTHROW { Ops::storeRelease(_q_value, newValue); } + Type loadAcquire() const noexcept { return Ops::loadAcquire(_q_value); } + void storeRelease(Type newValue) noexcept { Ops::storeRelease(_q_value, newValue); } - static Q_DECL_CONSTEXPR bool isTestAndSetNative() Q_DECL_NOTHROW { return Ops::isTestAndSetNative(); } - static Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() Q_DECL_NOTHROW { return Ops::isTestAndSetWaitFree(); } + static Q_DECL_CONSTEXPR bool isTestAndSetNative() noexcept { return Ops::isTestAndSetNative(); } + static Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() noexcept { return Ops::isTestAndSetWaitFree(); } - bool testAndSetRelaxed(Type expectedValue, Type newValue) Q_DECL_NOTHROW + bool testAndSetRelaxed(Type expectedValue, Type newValue) noexcept { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue); } - bool testAndSetAcquire(Type expectedValue, Type newValue) Q_DECL_NOTHROW + bool testAndSetAcquire(Type expectedValue, Type newValue) noexcept { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue); } - bool testAndSetRelease(Type expectedValue, Type newValue) Q_DECL_NOTHROW + bool testAndSetRelease(Type expectedValue, Type newValue) noexcept { return Ops::testAndSetRelease(_q_value, expectedValue, newValue); } - bool testAndSetOrdered(Type expectedValue, Type newValue) Q_DECL_NOTHROW + bool testAndSetOrdered(Type expectedValue, Type newValue) noexcept { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue); } - bool testAndSetRelaxed(Type expectedValue, Type newValue, Type ¤tValue) Q_DECL_NOTHROW + bool testAndSetRelaxed(Type expectedValue, Type newValue, Type ¤tValue) noexcept { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue, ¤tValue); } - bool testAndSetAcquire(Type expectedValue, Type newValue, Type ¤tValue) Q_DECL_NOTHROW + bool testAndSetAcquire(Type expectedValue, Type newValue, Type ¤tValue) noexcept { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue, ¤tValue); } - bool testAndSetRelease(Type expectedValue, Type newValue, Type ¤tValue) Q_DECL_NOTHROW + bool testAndSetRelease(Type expectedValue, Type newValue, Type ¤tValue) noexcept { return Ops::testAndSetRelease(_q_value, expectedValue, newValue, ¤tValue); } - bool testAndSetOrdered(Type expectedValue, Type newValue, Type ¤tValue) Q_DECL_NOTHROW + bool testAndSetOrdered(Type expectedValue, Type newValue, Type ¤tValue) noexcept { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue, ¤tValue); } - static Q_DECL_CONSTEXPR bool isFetchAndStoreNative() Q_DECL_NOTHROW { return Ops::isFetchAndStoreNative(); } - static Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return Ops::isFetchAndStoreWaitFree(); } + static Q_DECL_CONSTEXPR bool isFetchAndStoreNative() noexcept { return Ops::isFetchAndStoreNative(); } + static Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() noexcept { return Ops::isFetchAndStoreWaitFree(); } - Type fetchAndStoreRelaxed(Type newValue) Q_DECL_NOTHROW + Type fetchAndStoreRelaxed(Type newValue) noexcept { return Ops::fetchAndStoreRelaxed(_q_value, newValue); } - Type fetchAndStoreAcquire(Type newValue) Q_DECL_NOTHROW + Type fetchAndStoreAcquire(Type newValue) noexcept { return Ops::fetchAndStoreAcquire(_q_value, newValue); } - Type fetchAndStoreRelease(Type newValue) Q_DECL_NOTHROW + Type fetchAndStoreRelease(Type newValue) noexcept { return Ops::fetchAndStoreRelease(_q_value, newValue); } - Type fetchAndStoreOrdered(Type newValue) Q_DECL_NOTHROW + Type fetchAndStoreOrdered(Type newValue) noexcept { return Ops::fetchAndStoreOrdered(_q_value, newValue); } - static Q_DECL_CONSTEXPR bool isFetchAndAddNative() Q_DECL_NOTHROW { return Ops::isFetchAndAddNative(); } - static Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return Ops::isFetchAndAddWaitFree(); } + static Q_DECL_CONSTEXPR bool isFetchAndAddNative() noexcept { return Ops::isFetchAndAddNative(); } + static Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() noexcept { return Ops::isFetchAndAddWaitFree(); } - Type fetchAndAddRelaxed(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type fetchAndAddRelaxed(qptrdiff valueToAdd) noexcept { return Ops::fetchAndAddRelaxed(_q_value, valueToAdd); } - Type fetchAndAddAcquire(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type fetchAndAddAcquire(qptrdiff valueToAdd) noexcept { return Ops::fetchAndAddAcquire(_q_value, valueToAdd); } - Type fetchAndAddRelease(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type fetchAndAddRelease(qptrdiff valueToAdd) noexcept { return Ops::fetchAndAddRelease(_q_value, valueToAdd); } - Type fetchAndAddOrdered(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type fetchAndAddOrdered(qptrdiff valueToAdd) noexcept { return Ops::fetchAndAddOrdered(_q_value, valueToAdd); } - Type fetchAndSubRelaxed(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type fetchAndSubRelaxed(qptrdiff valueToAdd) noexcept { return Ops::fetchAndSubRelaxed(_q_value, valueToAdd); } - Type fetchAndSubAcquire(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type fetchAndSubAcquire(qptrdiff valueToAdd) noexcept { return Ops::fetchAndSubAcquire(_q_value, valueToAdd); } - Type fetchAndSubRelease(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type fetchAndSubRelease(qptrdiff valueToAdd) noexcept { return Ops::fetchAndSubRelease(_q_value, valueToAdd); } - Type fetchAndSubOrdered(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type fetchAndSubOrdered(qptrdiff valueToAdd) noexcept { return Ops::fetchAndSubOrdered(_q_value, valueToAdd); } - Type operator++() Q_DECL_NOTHROW + Type operator++() noexcept { return fetchAndAddOrdered(1) + 1; } - Type operator++(int) Q_DECL_NOTHROW + Type operator++(int) noexcept { return fetchAndAddOrdered(1); } - Type operator--() Q_DECL_NOTHROW + Type operator--() noexcept { return fetchAndSubOrdered(1) - 1; } - Type operator--(int) Q_DECL_NOTHROW + Type operator--(int) noexcept { return fetchAndSubOrdered(1); } - Type operator+=(qptrdiff valueToAdd) Q_DECL_NOTHROW + Type operator+=(qptrdiff valueToAdd) noexcept { return fetchAndAddOrdered(valueToAdd) + valueToAdd; } - Type operator-=(qptrdiff valueToSub) Q_DECL_NOTHROW + Type operator-=(qptrdiff valueToSub) noexcept { return fetchAndSubOrdered(valueToSub) - valueToSub; } #ifdef QT_BASIC_ATOMIC_HAS_CONSTRUCTORS QBasicAtomicPointer() = default; - constexpr QBasicAtomicPointer(Type value) Q_DECL_NOTHROW : _q_value(value) {} + constexpr QBasicAtomicPointer(Type value) noexcept : _q_value(value) {} QBasicAtomicPointer(const QBasicAtomicPointer &) = delete; QBasicAtomicPointer &operator=(const QBasicAtomicPointer &) = delete; QBasicAtomicPointer &operator=(const QBasicAtomicPointer &) volatile = delete; diff --git a/src/corelib/thread/qfutex_p.h b/src/corelib/thread/qfutex_p.h index 483664c783..136f6bca8c 100644 --- a/src/corelib/thread/qfutex_p.h +++ b/src/corelib/thread/qfutex_p.h @@ -85,7 +85,7 @@ QT_BEGIN_NAMESPACE namespace QtLinuxFutex { constexpr inline bool futexAvailable() { return true; } inline int _q_futex(int *addr, int op, int val, quintptr val2 = 0, - int *addr2 = nullptr, int val3 = 0) Q_DECL_NOTHROW + int *addr2 = nullptr, int val3 = 0) noexcept { // we use __NR_futex because some libcs (like Android's bionic) don't // provide SYS_futex etc. diff --git a/src/corelib/thread/qgenericatomic.h b/src/corelib/thread/qgenericatomic.h index 89c4fe9a11..f8333e7de6 100644 --- a/src/corelib/thread/qgenericatomic.h +++ b/src/corelib/thread/qgenericatomic.h @@ -72,32 +72,32 @@ template struct QGenericAtomicOps { template struct AtomicType { typedef T Type; typedef T *PointerType; }; - template static void acquireMemoryFence(const T &_q_value) Q_DECL_NOTHROW + template static void acquireMemoryFence(const T &_q_value) noexcept { BaseClass::orderedMemoryFence(_q_value); } - template static void releaseMemoryFence(const T &_q_value) Q_DECL_NOTHROW + template static void releaseMemoryFence(const T &_q_value) noexcept { BaseClass::orderedMemoryFence(_q_value); } - template static void orderedMemoryFence(const T &) Q_DECL_NOTHROW + template static void orderedMemoryFence(const T &) noexcept { } template static Q_ALWAYS_INLINE - T load(const T &_q_value) Q_DECL_NOTHROW + T load(const T &_q_value) noexcept { return _q_value; } template static Q_ALWAYS_INLINE - void store(T &_q_value, X newValue) Q_DECL_NOTHROW + void store(T &_q_value, X newValue) noexcept { _q_value = newValue; } template static Q_ALWAYS_INLINE - T loadAcquire(const T &_q_value) Q_DECL_NOTHROW + T loadAcquire(const T &_q_value) noexcept { T tmp = *static_cast(&_q_value); BaseClass::acquireMemoryFence(_q_value); @@ -105,24 +105,24 @@ template struct QGenericAtomicOps } template static Q_ALWAYS_INLINE - void storeRelease(T &_q_value, X newValue) Q_DECL_NOTHROW + void storeRelease(T &_q_value, X newValue) noexcept { BaseClass::releaseMemoryFence(_q_value); *static_cast(&_q_value) = newValue; } - static inline Q_DECL_CONSTEXPR bool isReferenceCountingNative() Q_DECL_NOTHROW + static inline Q_DECL_CONSTEXPR bool isReferenceCountingNative() noexcept { return BaseClass::isFetchAndAddNative(); } - static inline Q_DECL_CONSTEXPR bool isReferenceCountingWaitFree() Q_DECL_NOTHROW + static inline Q_DECL_CONSTEXPR bool isReferenceCountingWaitFree() noexcept { return BaseClass::isFetchAndAddWaitFree(); } template static Q_ALWAYS_INLINE - bool ref(T &_q_value) Q_DECL_NOTHROW + bool ref(T &_q_value) noexcept { return BaseClass::fetchAndAddRelaxed(_q_value, 1) != T(-1); } template static Q_ALWAYS_INLINE - bool deref(T &_q_value) Q_DECL_NOTHROW + bool deref(T &_q_value) noexcept { return BaseClass::fetchAndAddRelaxed(_q_value, -1) != 1; } @@ -130,16 +130,16 @@ template struct QGenericAtomicOps #if 0 // These functions have no default implementation // Archictectures must implement them - static inline Q_DECL_CONSTEXPR bool isTestAndSetNative() Q_DECL_NOTHROW; - static inline Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() Q_DECL_NOTHROW; + static inline Q_DECL_CONSTEXPR bool isTestAndSetNative() noexcept; + static inline Q_DECL_CONSTEXPR bool isTestAndSetWaitFree() noexcept; template static inline - bool testAndSetRelaxed(T &_q_value, X expectedValue, X newValue) Q_DECL_NOTHROW; + bool testAndSetRelaxed(T &_q_value, X expectedValue, X newValue) noexcept; template static inline - bool testAndSetRelaxed(T &_q_value, X expectedValue, X newValue, X *currentValue) Q_DECL_NOTHROW; + bool testAndSetRelaxed(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept; #endif template static Q_ALWAYS_INLINE - bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue) Q_DECL_NOTHROW + bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue) noexcept { bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue); BaseClass::acquireMemoryFence(_q_value); @@ -147,21 +147,21 @@ template struct QGenericAtomicOps } template static Q_ALWAYS_INLINE - bool testAndSetRelease(T &_q_value, X expectedValue, X newValue) Q_DECL_NOTHROW + bool testAndSetRelease(T &_q_value, X expectedValue, X newValue) noexcept { BaseClass::releaseMemoryFence(_q_value); return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue); } template static Q_ALWAYS_INLINE - bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue) Q_DECL_NOTHROW + bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue) noexcept { BaseClass::orderedMemoryFence(_q_value); return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue); } template static Q_ALWAYS_INLINE - bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue, X *currentValue) Q_DECL_NOTHROW + bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept { bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue); BaseClass::acquireMemoryFence(_q_value); @@ -169,24 +169,24 @@ template struct QGenericAtomicOps } template static Q_ALWAYS_INLINE - bool testAndSetRelease(T &_q_value, X expectedValue, X newValue, X *currentValue) Q_DECL_NOTHROW + bool testAndSetRelease(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept { BaseClass::releaseMemoryFence(_q_value); return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue); } template static Q_ALWAYS_INLINE - bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue, X *currentValue) Q_DECL_NOTHROW + bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept { BaseClass::orderedMemoryFence(_q_value); return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue); } - static inline Q_DECL_CONSTEXPR bool isFetchAndStoreNative() Q_DECL_NOTHROW { return false; } - static inline Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() Q_DECL_NOTHROW { return false; } + static inline Q_DECL_CONSTEXPR bool isFetchAndStoreNative() noexcept { return false; } + static inline Q_DECL_CONSTEXPR bool isFetchAndStoreWaitFree() noexcept { return false; } template static Q_ALWAYS_INLINE - T fetchAndStoreRelaxed(T &_q_value, X newValue) Q_DECL_NOTHROW + T fetchAndStoreRelaxed(T &_q_value, X newValue) noexcept { // implement fetchAndStore on top of testAndSet Q_FOREVER { @@ -197,7 +197,7 @@ template struct QGenericAtomicOps } template static Q_ALWAYS_INLINE - T fetchAndStoreAcquire(T &_q_value, X newValue) Q_DECL_NOTHROW + T fetchAndStoreAcquire(T &_q_value, X newValue) noexcept { T tmp = BaseClass::fetchAndStoreRelaxed(_q_value, newValue); BaseClass::acquireMemoryFence(_q_value); @@ -205,23 +205,23 @@ template struct QGenericAtomicOps } template static Q_ALWAYS_INLINE - T fetchAndStoreRelease(T &_q_value, X newValue) Q_DECL_NOTHROW + T fetchAndStoreRelease(T &_q_value, X newValue) noexcept { BaseClass::releaseMemoryFence(_q_value); return BaseClass::fetchAndStoreRelaxed(_q_value, newValue); } template static Q_ALWAYS_INLINE - T fetchAndStoreOrdered(T &_q_value, X newValue) Q_DECL_NOTHROW + T fetchAndStoreOrdered(T &_q_value, X newValue) noexcept { BaseClass::orderedMemoryFence(_q_value); return BaseClass::fetchAndStoreRelaxed(_q_value, newValue); } - static inline Q_DECL_CONSTEXPR bool isFetchAndAddNative() Q_DECL_NOTHROW { return false; } - static inline Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() Q_DECL_NOTHROW { return false; } + static inline Q_DECL_CONSTEXPR bool isFetchAndAddNative() noexcept { return false; } + static inline Q_DECL_CONSTEXPR bool isFetchAndAddWaitFree() noexcept { return false; } template static Q_ALWAYS_INLINE - T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { // implement fetchAndAdd on top of testAndSet Q_FOREVER { @@ -232,7 +232,7 @@ template struct QGenericAtomicOps } template static Q_ALWAYS_INLINE - T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { T tmp = BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd); BaseClass::acquireMemoryFence(_q_value); @@ -240,14 +240,14 @@ template struct QGenericAtomicOps } template static Q_ALWAYS_INLINE - T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { BaseClass::releaseMemoryFence(_q_value); return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd); } template static Q_ALWAYS_INLINE - T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) Q_DECL_NOTHROW + T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType::AdditiveT valueToAdd) noexcept { BaseClass::orderedMemoryFence(_q_value); return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd); @@ -256,7 +256,7 @@ template struct QGenericAtomicOps QT_WARNING_PUSH QT_WARNING_DISABLE_MSVC(4146) // unary minus operator applied to unsigned type, result still unsigned template static Q_ALWAYS_INLINE - T fetchAndSubRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT operand) Q_DECL_NOTHROW + T fetchAndSubRelaxed(T &_q_value, typename QAtomicAdditiveType::AdditiveT operand) noexcept { // implement fetchAndSub on top of fetchAndAdd return fetchAndAddRelaxed(_q_value, -operand); @@ -264,7 +264,7 @@ QT_WARNING_DISABLE_MSVC(4146) // unary minus operator applied to unsigned type QT_WARNING_POP template static Q_ALWAYS_INLINE - T fetchAndSubAcquire(T &_q_value, typename QAtomicAdditiveType::AdditiveT operand) Q_DECL_NOTHROW + T fetchAndSubAcquire(T &_q_value, typename QAtomicAdditiveType::AdditiveT operand) noexcept { T tmp = BaseClass::fetchAndSubRelaxed(_q_value, operand); BaseClass::acquireMemoryFence(_q_value); @@ -272,21 +272,21 @@ QT_WARNING_POP } template static Q_ALWAYS_INLINE - T fetchAndSubRelease(T &_q_value, typename QAtomicAdditiveType::AdditiveT operand) Q_DECL_NOTHROW + T fetchAndSubRelease(T &_q_value, typename QAtomicAdditiveType::AdditiveT operand) noexcept { BaseClass::releaseMemoryFence(_q_value); return BaseClass::fetchAndSubRelaxed(_q_value, operand); } template static Q_ALWAYS_INLINE - T fetchAndSubOrdered(T &_q_value, typename QAtomicAdditiveType::AdditiveT operand) Q_DECL_NOTHROW + T fetchAndSubOrdered(T &_q_value, typename QAtomicAdditiveType::AdditiveT operand) noexcept { BaseClass::orderedMemoryFence(_q_value); return BaseClass::fetchAndSubRelaxed(_q_value, operand); } template static Q_ALWAYS_INLINE - T fetchAndAndRelaxed(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndAndRelaxed(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { // implement fetchAndAnd on top of testAndSet T tmp = BaseClass::load(_q_value); @@ -297,7 +297,7 @@ QT_WARNING_POP } template static Q_ALWAYS_INLINE - T fetchAndAndAcquire(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndAndAcquire(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { T tmp = BaseClass::fetchAndAndRelaxed(_q_value, operand); BaseClass::acquireMemoryFence(_q_value); @@ -305,21 +305,21 @@ QT_WARNING_POP } template static Q_ALWAYS_INLINE - T fetchAndAndRelease(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndAndRelease(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { BaseClass::releaseMemoryFence(_q_value); return BaseClass::fetchAndAndRelaxed(_q_value, operand); } template static Q_ALWAYS_INLINE - T fetchAndAndOrdered(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndAndOrdered(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { BaseClass::orderedMemoryFence(_q_value); return BaseClass::fetchAndAndRelaxed(_q_value, operand); } template static Q_ALWAYS_INLINE - T fetchAndOrRelaxed(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndOrRelaxed(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { // implement fetchAndOr on top of testAndSet T tmp = BaseClass::load(_q_value); @@ -330,7 +330,7 @@ QT_WARNING_POP } template static Q_ALWAYS_INLINE - T fetchAndOrAcquire(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndOrAcquire(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { T tmp = BaseClass::fetchAndOrRelaxed(_q_value, operand); BaseClass::acquireMemoryFence(_q_value); @@ -338,21 +338,21 @@ QT_WARNING_POP } template static Q_ALWAYS_INLINE - T fetchAndOrRelease(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndOrRelease(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { BaseClass::releaseMemoryFence(_q_value); return BaseClass::fetchAndOrRelaxed(_q_value, operand); } template static Q_ALWAYS_INLINE - T fetchAndOrOrdered(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndOrOrdered(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { BaseClass::orderedMemoryFence(_q_value); return BaseClass::fetchAndOrRelaxed(_q_value, operand); } template static Q_ALWAYS_INLINE - T fetchAndXorRelaxed(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndXorRelaxed(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { // implement fetchAndXor on top of testAndSet T tmp = BaseClass::load(_q_value); @@ -363,7 +363,7 @@ QT_WARNING_POP } template static Q_ALWAYS_INLINE - T fetchAndXorAcquire(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndXorAcquire(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { T tmp = BaseClass::fetchAndXorRelaxed(_q_value, operand); BaseClass::acquireMemoryFence(_q_value); @@ -371,14 +371,14 @@ QT_WARNING_POP } template static Q_ALWAYS_INLINE - T fetchAndXorRelease(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndXorRelease(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { BaseClass::releaseMemoryFence(_q_value); return BaseClass::fetchAndXorRelaxed(_q_value, operand); } template static Q_ALWAYS_INLINE - T fetchAndXorOrdered(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) Q_DECL_NOTHROW + T fetchAndXorOrdered(T &_q_value, typename std::enable_if::isIntegral, T>::type operand) noexcept { BaseClass::orderedMemoryFence(_q_value); return BaseClass::fetchAndXorRelaxed(_q_value, operand); diff --git a/src/corelib/thread/qmutex.cpp b/src/corelib/thread/qmutex.cpp index 3881ac017e..4f55e50fe5 100644 --- a/src/corelib/thread/qmutex.cpp +++ b/src/corelib/thread/qmutex.cpp @@ -82,7 +82,7 @@ public: QMutex mutex; bool lock(int timeout) QT_MUTEX_LOCK_NOEXCEPT; - void unlock() Q_DECL_NOTHROW; + void unlock() noexcept; }; /* @@ -329,7 +329,7 @@ bool QMutex::tryLock(int timeout) QT_MUTEX_LOCK_NOEXCEPT \sa lock() */ -void QMutex::unlock() Q_DECL_NOTHROW +void QMutex::unlock() noexcept { QMutexData *current; if (fastTryUnlock(current)) @@ -348,7 +348,7 @@ void QMutex::unlock() Q_DECL_NOTHROW Returns \c true if the mutex is recursive. */ -bool QBasicMutex::isRecursive() Q_DECL_NOTHROW +bool QBasicMutex::isRecursive() noexcept { return QT_PREPEND_NAMESPACE(isRecursive)(d_ptr.loadAcquire()); } @@ -358,7 +358,7 @@ bool QBasicMutex::isRecursive() Q_DECL_NOTHROW Returns \c true if the mutex is recursive. */ -bool QBasicMutex::isRecursive() const Q_DECL_NOTHROW +bool QBasicMutex::isRecursive() const noexcept { return QT_PREPEND_NAMESPACE(isRecursive)(d_ptr.loadAcquire()); } @@ -600,7 +600,7 @@ bool QBasicMutex::lockInternal(int timeout) QT_MUTEX_LOCK_NOEXCEPT /*! \internal */ -void QBasicMutex::unlockInternal() Q_DECL_NOTHROW +void QBasicMutex::unlockInternal() noexcept { QMutexData *copy = d_ptr.loadAcquire(); Q_ASSERT(copy); //we must be locked @@ -675,7 +675,7 @@ void QMutexPrivate::release() } // atomically subtract "value" to the waiters, and remove the QMutexPrivate::BigNumber flag -void QMutexPrivate::derefWaiters(int value) Q_DECL_NOTHROW +void QMutexPrivate::derefWaiters(int value) noexcept { int old_waiters; int new_waiters; @@ -716,7 +716,7 @@ inline bool QRecursiveMutexPrivate::lock(int timeout) QT_MUTEX_LOCK_NOEXCEPT /*! \internal */ -inline void QRecursiveMutexPrivate::unlock() Q_DECL_NOTHROW +inline void QRecursiveMutexPrivate::unlock() noexcept { if (count > 0) { count--; diff --git a/src/corelib/thread/qmutex.h b/src/corelib/thread/qmutex.h index 837355a602..d7796092d1 100644 --- a/src/corelib/thread/qmutex.h +++ b/src/corelib/thread/qmutex.h @@ -57,7 +57,7 @@ QT_BEGIN_NAMESPACE #if QT_CONFIG(thread) || defined(Q_CLANG_QDOC) #ifdef Q_OS_LINUX -# define QT_MUTEX_LOCK_NOEXCEPT Q_DECL_NOTHROW +# define QT_MUTEX_LOCK_NOEXCEPT noexcept #else # define QT_MUTEX_LOCK_NOEXCEPT #endif @@ -80,39 +80,39 @@ public: } // BasicLockable concept - inline void unlock() Q_DECL_NOTHROW { + inline void unlock() noexcept { Q_ASSERT(d_ptr.load()); //mutex must be locked if (!fastTryUnlock()) unlockInternal(); } - bool tryLock() Q_DECL_NOTHROW { + bool tryLock() noexcept { return fastTryLock(); } // Lockable concept - bool try_lock() Q_DECL_NOTHROW { return tryLock(); } + bool try_lock() noexcept { return tryLock(); } - bool isRecursive() Q_DECL_NOTHROW; //### Qt6: remove me - bool isRecursive() const Q_DECL_NOTHROW; + bool isRecursive() noexcept; //### Qt6: remove me + bool isRecursive() const noexcept; private: - inline bool fastTryLock() Q_DECL_NOTHROW { + inline bool fastTryLock() noexcept { return d_ptr.testAndSetAcquire(nullptr, dummyLocked()); } - inline bool fastTryUnlock() Q_DECL_NOTHROW { + inline bool fastTryUnlock() noexcept { return d_ptr.testAndSetRelease(dummyLocked(), nullptr); } - inline bool fastTryLock(QMutexData *¤t) Q_DECL_NOTHROW { + inline bool fastTryLock(QMutexData *¤t) noexcept { return d_ptr.testAndSetAcquire(nullptr, dummyLocked(), current); } - inline bool fastTryUnlock(QMutexData *¤t) Q_DECL_NOTHROW { + inline bool fastTryUnlock(QMutexData *¤t) noexcept { return d_ptr.testAndSetRelease(dummyLocked(), nullptr, current); } void lockInternal() QT_MUTEX_LOCK_NOEXCEPT; bool lockInternal(int timeout) QT_MUTEX_LOCK_NOEXCEPT; - void unlockInternal() Q_DECL_NOTHROW; + void unlockInternal() noexcept; QBasicAtomicPointer d_ptr; static inline QMutexData *dummyLocked() { @@ -134,7 +134,7 @@ public: void lock() QT_MUTEX_LOCK_NOEXCEPT; bool tryLock(int timeout = 0) QT_MUTEX_LOCK_NOEXCEPT; // BasicLockable concept - void unlock() Q_DECL_NOTHROW; + void unlock() noexcept; // Lockable concept bool try_lock() QT_MUTEX_LOCK_NOEXCEPT { return tryLock(); } @@ -158,7 +158,7 @@ public: } #endif - bool isRecursive() const Q_DECL_NOTHROW + bool isRecursive() const noexcept { return QBasicMutex::isRecursive(); } private: @@ -212,7 +212,7 @@ public: #endif inline ~QMutexLocker() { unlock(); } - inline void unlock() Q_DECL_NOTHROW + inline void unlock() noexcept { if ((val & quintptr(1u)) == quintptr(1u)) { val &= ~quintptr(1u); @@ -257,24 +257,24 @@ class Q_CORE_EXPORT QMutex public: enum RecursionMode { NonRecursive, Recursive }; - inline Q_DECL_CONSTEXPR explicit QMutex(RecursionMode = NonRecursive) Q_DECL_NOTHROW { } + inline Q_DECL_CONSTEXPR explicit QMutex(RecursionMode = NonRecursive) noexcept { } - inline void lock() Q_DECL_NOTHROW {} - inline bool tryLock(int timeout = 0) Q_DECL_NOTHROW { Q_UNUSED(timeout); return true; } - inline bool try_lock() Q_DECL_NOTHROW { return true; } - inline void unlock() Q_DECL_NOTHROW {} - inline bool isRecursive() const Q_DECL_NOTHROW { return true; } + inline void lock() noexcept {} + inline bool tryLock(int timeout = 0) noexcept { Q_UNUSED(timeout); return true; } + inline bool try_lock() noexcept { return true; } + inline void unlock() noexcept {} + inline bool isRecursive() const noexcept { return true; } #if QT_HAS_INCLUDE() template - inline bool try_lock_for(std::chrono::duration duration) Q_DECL_NOTHROW + inline bool try_lock_for(std::chrono::duration duration) noexcept { Q_UNUSED(duration); return true; } template - inline bool try_lock_until(std::chrono::time_point timePoint) Q_DECL_NOTHROW + inline bool try_lock_until(std::chrono::time_point timePoint) noexcept { Q_UNUSED(timePoint); return true; @@ -288,12 +288,12 @@ private: class Q_CORE_EXPORT QMutexLocker { public: - inline explicit QMutexLocker(QMutex *) Q_DECL_NOTHROW {} - inline ~QMutexLocker() Q_DECL_NOTHROW {} + inline explicit QMutexLocker(QMutex *) noexcept {} + inline ~QMutexLocker() noexcept {} - inline void unlock() Q_DECL_NOTHROW {} - void relock() Q_DECL_NOTHROW {} - inline QMutex *mutex() const Q_DECL_NOTHROW { return nullptr; } + inline void unlock() noexcept {} + void relock() noexcept {} + inline QMutex *mutex() const noexcept { return nullptr; } private: Q_DISABLE_COPY(QMutexLocker) diff --git a/src/corelib/thread/qmutex_linux.cpp b/src/corelib/thread/qmutex_linux.cpp index 507e72cb76..b006ff1033 100644 --- a/src/corelib/thread/qmutex_linux.cpp +++ b/src/corelib/thread/qmutex_linux.cpp @@ -106,7 +106,7 @@ static inline QMutexData *dummyFutexValue() } template static inline -bool lockInternal_helper(QBasicAtomicPointer &d_ptr, int timeout = -1, QElapsedTimer *elapsedTimer = 0) Q_DECL_NOTHROW +bool lockInternal_helper(QBasicAtomicPointer &d_ptr, int timeout = -1, QElapsedTimer *elapsedTimer = 0) noexcept { if (!IsTimed) timeout = -1; @@ -153,13 +153,13 @@ bool lockInternal_helper(QBasicAtomicPointer &d_ptr, int timeout = - return true; } -void QBasicMutex::lockInternal() Q_DECL_NOTHROW +void QBasicMutex::lockInternal() noexcept { Q_ASSERT(!isRecursive()); lockInternal_helper(d_ptr); } -bool QBasicMutex::lockInternal(int timeout) Q_DECL_NOTHROW +bool QBasicMutex::lockInternal(int timeout) noexcept { Q_ASSERT(!isRecursive()); QElapsedTimer elapsedTimer; @@ -167,7 +167,7 @@ bool QBasicMutex::lockInternal(int timeout) Q_DECL_NOTHROW return lockInternal_helper(d_ptr, timeout, &elapsedTimer); } -void QBasicMutex::unlockInternal() Q_DECL_NOTHROW +void QBasicMutex::unlockInternal() noexcept { QMutexData *d = d_ptr.load(); Q_ASSERT(d); //we must be locked diff --git a/src/corelib/thread/qmutex_mac.cpp b/src/corelib/thread/qmutex_mac.cpp index 9a8d9bc750..923f89f697 100644 --- a/src/corelib/thread/qmutex_mac.cpp +++ b/src/corelib/thread/qmutex_mac.cpp @@ -79,7 +79,7 @@ bool QMutexPrivate::wait(int timeout) return (r == KERN_SUCCESS); } -void QMutexPrivate::wakeUp() Q_DECL_NOTHROW +void QMutexPrivate::wakeUp() noexcept { semaphore_signal(mach_semaphore); } diff --git a/src/corelib/thread/qmutex_p.h b/src/corelib/thread/qmutex_p.h index ec9bfc1152..5025f836b9 100644 --- a/src/corelib/thread/qmutex_p.h +++ b/src/corelib/thread/qmutex_p.h @@ -92,7 +92,7 @@ public: QMutexPrivate(); bool wait(int timeout = -1); - void wakeUp() Q_DECL_NOTHROW; + void wakeUp() noexcept; // Control the lifetime of the privates QAtomicInt refCount; @@ -125,7 +125,7 @@ public: when the mutex is unlocked. */ enum { BigNumber = 0x100000 }; //Must be bigger than the possible number of waiters (number of threads) - void derefWaiters(int value) Q_DECL_NOTHROW; + void derefWaiters(int value) noexcept; //platform specific stuff #if defined(Q_OS_MAC) diff --git a/src/corelib/thread/qmutex_unix.cpp b/src/corelib/thread/qmutex_unix.cpp index 3ee24a292c..a92ac4f943 100644 --- a/src/corelib/thread/qmutex_unix.cpp +++ b/src/corelib/thread/qmutex_unix.cpp @@ -99,7 +99,7 @@ bool QMutexPrivate::wait(int timeout) return true; } -void QMutexPrivate::wakeUp() Q_DECL_NOTHROW +void QMutexPrivate::wakeUp() noexcept { report_error(sem_post(&semaphore), "QMutex::unlock", "sem_post"); } @@ -146,7 +146,7 @@ bool QMutexPrivate::wait(int timeout) return ret; } -void QMutexPrivate::wakeUp() Q_DECL_NOTHROW +void QMutexPrivate::wakeUp() noexcept { report_error(pthread_mutex_lock(&mutex), "QMutex::unlock", "mutex lock"); wakeup = true; diff --git a/src/corelib/thread/qmutex_win.cpp b/src/corelib/thread/qmutex_win.cpp index 3c314a4c0c..e221bc89cb 100644 --- a/src/corelib/thread/qmutex_win.cpp +++ b/src/corelib/thread/qmutex_win.cpp @@ -64,7 +64,7 @@ bool QMutexPrivate::wait(int timeout) return (WaitForSingleObjectEx(event, timeout < 0 ? INFINITE : timeout, FALSE) == WAIT_OBJECT_0); } -void QMutexPrivate::wakeUp() Q_DECL_NOTHROW +void QMutexPrivate::wakeUp() noexcept { SetEvent(event); } QT_END_NAMESPACE diff --git a/src/corelib/thread/qorderedmutexlocker_p.h b/src/corelib/thread/qorderedmutexlocker_p.h index 5b2c7ab112..e0a67388d4 100644 --- a/src/corelib/thread/qorderedmutexlocker_p.h +++ b/src/corelib/thread/qorderedmutexlocker_p.h @@ -129,7 +129,7 @@ public: } inline ~QBasicMutexLocker() { if (isLocked) unlock(); } - inline void unlock() Q_DECL_NOTHROW + inline void unlock() noexcept { isLocked = false; m->unlock(); diff --git a/src/corelib/thread/qreadwritelock.h b/src/corelib/thread/qreadwritelock.h index 65fa76fd6d..139fde9214 100644 --- a/src/corelib/thread/qreadwritelock.h +++ b/src/corelib/thread/qreadwritelock.h @@ -180,18 +180,18 @@ class Q_CORE_EXPORT QReadWriteLock { public: enum RecursionMode { NonRecursive, Recursive }; - inline explicit QReadWriteLock(RecursionMode = NonRecursive) Q_DECL_NOTHROW { } + inline explicit QReadWriteLock(RecursionMode = NonRecursive) noexcept { } inline ~QReadWriteLock() { } - static inline void lockForRead() Q_DECL_NOTHROW { } - static inline bool tryLockForRead() Q_DECL_NOTHROW { return true; } - static inline bool tryLockForRead(int timeout) Q_DECL_NOTHROW { Q_UNUSED(timeout); return true; } + static inline void lockForRead() noexcept { } + static inline bool tryLockForRead() noexcept { return true; } + static inline bool tryLockForRead(int timeout) noexcept { Q_UNUSED(timeout); return true; } - static inline void lockForWrite() Q_DECL_NOTHROW { } - static inline bool tryLockForWrite() Q_DECL_NOTHROW { return true; } - static inline bool tryLockForWrite(int timeout) Q_DECL_NOTHROW { Q_UNUSED(timeout); return true; } + static inline void lockForWrite() noexcept { } + static inline bool tryLockForWrite() noexcept { return true; } + static inline bool tryLockForWrite(int timeout) noexcept { Q_UNUSED(timeout); return true; } - static inline void unlock() Q_DECL_NOTHROW { } + static inline void unlock() noexcept { } private: Q_DISABLE_COPY(QReadWriteLock) @@ -200,12 +200,12 @@ private: class Q_CORE_EXPORT QReadLocker { public: - inline QReadLocker(QReadWriteLock *) Q_DECL_NOTHROW { } - inline ~QReadLocker() Q_DECL_NOTHROW { } + inline QReadLocker(QReadWriteLock *) noexcept { } + inline ~QReadLocker() noexcept { } - static inline void unlock() Q_DECL_NOTHROW { } - static inline void relock() Q_DECL_NOTHROW { } - static inline QReadWriteLock *readWriteLock() Q_DECL_NOTHROW { return nullptr; } + static inline void unlock() noexcept { } + static inline void relock() noexcept { } + static inline QReadWriteLock *readWriteLock() noexcept { return nullptr; } private: Q_DISABLE_COPY(QReadLocker) @@ -214,12 +214,12 @@ private: class Q_CORE_EXPORT QWriteLocker { public: - inline explicit QWriteLocker(QReadWriteLock *) Q_DECL_NOTHROW { } - inline ~QWriteLocker() Q_DECL_NOTHROW { } + inline explicit QWriteLocker(QReadWriteLock *) noexcept { } + inline ~QWriteLocker() noexcept { } - static inline void unlock() Q_DECL_NOTHROW { } - static inline void relock() Q_DECL_NOTHROW { } - static inline QReadWriteLock *readWriteLock() Q_DECL_NOTHROW { return nullptr; } + static inline void unlock() noexcept { } + static inline void relock() noexcept { } + static inline QReadWriteLock *readWriteLock() noexcept { return nullptr; } private: Q_DISABLE_COPY(QWriteLocker) diff --git a/src/corelib/thread/qsemaphore.h b/src/corelib/thread/qsemaphore.h index b830ff1bfd..58c12997ad 100644 --- a/src/corelib/thread/qsemaphore.h +++ b/src/corelib/thread/qsemaphore.h @@ -75,14 +75,14 @@ class QSemaphoreReleaser { public: QSemaphoreReleaser() = default; - explicit QSemaphoreReleaser(QSemaphore &sem, int n = 1) Q_DECL_NOTHROW + explicit QSemaphoreReleaser(QSemaphore &sem, int n = 1) noexcept : m_sem(&sem), m_n(n) {} - explicit QSemaphoreReleaser(QSemaphore *sem, int n = 1) Q_DECL_NOTHROW + explicit QSemaphoreReleaser(QSemaphore *sem, int n = 1) noexcept : m_sem(sem), m_n(n) {} - QSemaphoreReleaser(QSemaphoreReleaser &&other) Q_DECL_NOTHROW + QSemaphoreReleaser(QSemaphoreReleaser &&other) noexcept : m_sem(other.m_sem), m_n(other.m_n) { other.m_sem = nullptr; } - QSemaphoreReleaser &operator=(QSemaphoreReleaser &&other) Q_DECL_NOTHROW + QSemaphoreReleaser &operator=(QSemaphoreReleaser &&other) noexcept { QSemaphoreReleaser moved(std::move(other)); swap(moved); return *this; } ~QSemaphoreReleaser() @@ -91,16 +91,16 @@ public: m_sem->release(m_n); } - void swap(QSemaphoreReleaser &other) Q_DECL_NOTHROW + void swap(QSemaphoreReleaser &other) noexcept { qSwap(m_sem, other.m_sem); qSwap(m_n, other.m_n); } - QSemaphore *semaphore() const Q_DECL_NOTHROW + QSemaphore *semaphore() const noexcept { return m_sem; } - QSemaphore *cancel() Q_DECL_NOTHROW + QSemaphore *cancel() noexcept { QSemaphore *old = m_sem; m_sem = nullptr; diff --git a/src/corelib/thread/qthread.cpp b/src/corelib/thread/qthread.cpp index b023ae9ed2..170cd0dec4 100644 --- a/src/corelib/thread/qthread.cpp +++ b/src/corelib/thread/qthread.cpp @@ -839,7 +839,7 @@ bool QThread::event(QEvent* event) return QObject::event(event); } -Qt::HANDLE QThread::currentThreadId() Q_DECL_NOTHROW +Qt::HANDLE QThread::currentThreadId() noexcept { return Qt::HANDLE(currentThread()); } @@ -849,7 +849,7 @@ QThread *QThread::currentThread() return QThreadData::current()->thread; } -int QThread::idealThreadCount() Q_DECL_NOTHROW +int QThread::idealThreadCount() noexcept { return 1; } diff --git a/src/corelib/thread/qthread.h b/src/corelib/thread/qthread.h index b6c5bf47d0..8e92d75401 100644 --- a/src/corelib/thread/qthread.h +++ b/src/corelib/thread/qthread.h @@ -70,9 +70,9 @@ class Q_CORE_EXPORT QThread : public QObject { Q_OBJECT public: - static Qt::HANDLE currentThreadId() Q_DECL_NOTHROW Q_DECL_PURE_FUNCTION; + static Qt::HANDLE currentThreadId() noexcept Q_DECL_PURE_FUNCTION; static QThread *currentThread(); - static int idealThreadCount() Q_DECL_NOTHROW; + static int idealThreadCount() noexcept; static void yieldCurrentThread(); explicit QThread(QObject *parent = nullptr); diff --git a/src/corelib/thread/qthread_p.h b/src/corelib/thread/qthread_p.h index e614ddd004..209225de98 100644 --- a/src/corelib/thread/qthread_p.h +++ b/src/corelib/thread/qthread_p.h @@ -187,8 +187,8 @@ public: #endif // Q_OS_UNIX #ifdef Q_OS_WIN - static unsigned int __stdcall start(void *) Q_DECL_NOEXCEPT; - static void finish(void *, bool lockAnyway=true) Q_DECL_NOEXCEPT; + static unsigned int __stdcall start(void *) noexcept; + static void finish(void *, bool lockAnyway=true) noexcept; Qt::HANDLE handle; unsigned int id; diff --git a/src/corelib/thread/qthread_unix.cpp b/src/corelib/thread/qthread_unix.cpp index a13f8ca215..8328e514a8 100644 --- a/src/corelib/thread/qthread_unix.cpp +++ b/src/corelib/thread/qthread_unix.cpp @@ -443,7 +443,7 @@ void QThreadPrivate::finish(void *arg) ** QThread *************************************************************************/ -Qt::HANDLE QThread::currentThreadId() Q_DECL_NOTHROW +Qt::HANDLE QThread::currentThreadId() noexcept { // requires a C cast here otherwise we run into trouble on AIX return to_HANDLE(pthread_self()); @@ -454,7 +454,7 @@ Qt::HANDLE QThread::currentThreadId() Q_DECL_NOTHROW # define _SC_NPROCESSORS_ONLN 84 #endif -int QThread::idealThreadCount() Q_DECL_NOTHROW +int QThread::idealThreadCount() noexcept { int cores = 1; diff --git a/src/corelib/thread/qthread_win.cpp b/src/corelib/thread/qthread_win.cpp index e56fe2c6ae..ee73280707 100644 --- a/src/corelib/thread/qthread_win.cpp +++ b/src/corelib/thread/qthread_win.cpp @@ -372,7 +372,7 @@ QAbstractEventDispatcher *QThreadPrivate::createEventDispatcher(QThreadData *dat #if QT_CONFIG(thread) -unsigned int __stdcall QT_ENSURE_STACK_ALIGNED_FOR_SSE QThreadPrivate::start(void *arg) Q_DECL_NOEXCEPT +unsigned int __stdcall QT_ENSURE_STACK_ALIGNED_FOR_SSE QThreadPrivate::start(void *arg) noexcept { QThread *thr = reinterpret_cast(arg); QThreadData *data = QThreadData::get2(thr); @@ -406,7 +406,7 @@ unsigned int __stdcall QT_ENSURE_STACK_ALIGNED_FOR_SSE QThreadPrivate::start(voi return 0; } -void QThreadPrivate::finish(void *arg, bool lockAnyway) Q_DECL_NOEXCEPT +void QThreadPrivate::finish(void *arg, bool lockAnyway) noexcept { QThread *thr = reinterpret_cast(arg); QThreadPrivate *d = thr->d_func(); @@ -447,12 +447,12 @@ void QThreadPrivate::finish(void *arg, bool lockAnyway) Q_DECL_NOEXCEPT ** QThread *************************************************************************/ -Qt::HANDLE QThread::currentThreadId() Q_DECL_NOTHROW +Qt::HANDLE QThread::currentThreadId() noexcept { return reinterpret_cast(quintptr(GetCurrentThreadId())); } -int QThread::idealThreadCount() Q_DECL_NOTHROW +int QThread::idealThreadCount() noexcept { SYSTEM_INFO sysinfo; #ifndef Q_OS_WINRT -- cgit v1.2.3