1 files changed, 13 insertions, 12 deletions

diff --git a/src/corelib/thread/qreadwritelock.cpp b/src/corelib/thread/qreadwritelock.cpp
index d7cf7a7284..14654986a0 100644
--- a/src/corelib/thread/qreadwritelock.cpp
+++ b/src/corelib/thread/qreadwritelock.cpp
@@ -48,6 +48,7 @@
 #include "qreadwritelock_p.h"
 #include "qelapsedtimer.h"
 #include "private/qfreelist_p.h"
+#include "private/qlocking_p.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -143,7 +144,7 @@ inline bool isUncontendedLocked(const QReadWriteLockPrivate *d)
 QReadWriteLock::QReadWriteLock(RecursionMode recursionMode)
     : d_ptr(recursionMode == Recursive ? new QReadWriteLockPrivate(true) : nullptr)
 {
-    Q_ASSERT_X(!(quintptr(d_ptr.load()) & StateMask), "QReadWriteLock::QReadWriteLock", "bad d_ptr alignment");
+    Q_ASSERT_X(!(quintptr(d_ptr.loadRelaxed()) & StateMask), "QReadWriteLock::QReadWriteLock", "bad d_ptr alignment");
 }
 
 /*!
@@ -154,7 +155,7 @@ QReadWriteLock::QReadWriteLock(RecursionMode recursionMode)
 */
 QReadWriteLock::~QReadWriteLock()
 {
-    auto d = d_ptr.load();
+    auto d = d_ptr.loadRelaxed();
     if (isUncontendedLocked(d)) {
         qWarning("QReadWriteLock: destroying locked QReadWriteLock");
         return;
@@ -262,8 +263,8 @@ bool QReadWriteLock::tryLockForRead(int timeout)
         if (d->recursive)
             return d->recursiveLockForRead(timeout);
 
-        QMutexLocker lock(&d->mutex);
-        if (d != d_ptr.load()) {
+        auto lock = qt_unique_lock(d->mutex);
+        if (d != d_ptr.loadRelaxed()) {
             // d_ptr has changed: this QReadWriteLock was unlocked before we had
             // time to lock d->mutex.
             // We are holding a lock to a mutex within a QReadWriteLockPrivate
@@ -369,8 +370,8 @@ bool QReadWriteLock::tryLockForWrite(int timeout)
         if (d->recursive)
             return d->recursiveLockForWrite(timeout);
 
-        QMutexLocker lock(&d->mutex);
-        if (d != d_ptr.load()) {
+        auto lock = qt_unique_lock(d->mutex);
+        if (d != d_ptr.loadRelaxed()) {
             // The mutex was unlocked before we had time to lock the mutex.
             // We are holding to a mutex within a QReadWriteLockPrivate that is already released
             // (or even is already re-used) but that's ok because the QFreeList never frees them.
@@ -418,7 +419,7 @@ void QReadWriteLock::unlock()
             return;
         }
 
-        QMutexLocker locker(&d->mutex);
+        const auto lock = qt_scoped_lock(d->mutex);
         if (d->writerCount) {
             Q_ASSERT(d->writerCount == 1);
             Q_ASSERT(d->readerCount == 0);
@@ -433,7 +434,7 @@ void QReadWriteLock::unlock()
         if (d->waitingReaders || d->waitingWriters) {
             d->unlock();
         } else {
-            Q_ASSERT(d_ptr.load() == d); // should not change when we still hold the mutex
+            Q_ASSERT(d_ptr.loadRelaxed() == d); // should not change when we still hold the mutex
             d_ptr.storeRelease(nullptr);
             d->release();
         }
@@ -444,7 +445,7 @@ void QReadWriteLock::unlock()
 /*! \internal  Helper for QWaitCondition::wait */
 QReadWriteLock::StateForWaitCondition QReadWriteLock::stateForWaitCondition() const
 {
-    QReadWriteLockPrivate *d = d_ptr.load();
+    QReadWriteLockPrivate *d = d_ptr.loadRelaxed();
     switch (quintptr(d) & StateMask) {
     case StateLockedForRead: return LockedForRead;
     case StateLockedForWrite: return LockedForWrite;
@@ -536,7 +537,7 @@ void QReadWriteLockPrivate::unlock()
 bool QReadWriteLockPrivate::recursiveLockForRead(int timeout)
 {
     Q_ASSERT(recursive);
-    QMutexLocker lock(&mutex);
+    auto lock = qt_unique_lock(mutex);
 
     Qt::HANDLE self = QThread::currentThreadId();
 
@@ -556,7 +557,7 @@ bool QReadWriteLockPrivate::recursiveLockForRead(int timeout)
 bool QReadWriteLockPrivate::recursiveLockForWrite(int timeout)
 {
     Q_ASSERT(recursive);
-    QMutexLocker lock(&mutex);
+    auto lock = qt_unique_lock(mutex);
 
     Qt::HANDLE self = QThread::currentThreadId();
     if (currentWriter == self) {
@@ -574,7 +575,7 @@ bool QReadWriteLockPrivate::recursiveLockForWrite(int timeout)
 void QReadWriteLockPrivate::recursiveUnlock()
 {
     Q_ASSERT(recursive);
-    QMutexLocker lock(&mutex);
+    auto lock = qt_unique_lock(mutex);
 
     Qt::HANDLE self = QThread::currentThreadId();
     if (self == currentWriter) {