Port from QAtomic::load() to loadRelaxed()

Semi-automated, just needed ~20 manual fixes:

$ find \( -iname \*.cpp -or -iname \*.h \) -exec perl -pe 's/(\.|->)load\(\)/$1loadRelaxed\(\)/g' -i \{\} +
$ find \( -iname \*.cpp -or -iname \*.h \) -exec perl -pe 's/(\.|->)store\(/$1storeRelaxed\(/g' -i \{\} +

It can be easily improved (e.g. for store check that there are no commas
after the opening parens). The most common offender is QLibrary::load,
and some code using std::atomic directly.

Change-Id: I07c38a3c8ed32c924ef4999e85c7e45cf48f0f6c
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
 
 

10 files changed, 295 insertions, 295 deletions

diff --git a/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp b/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp
index 9b5a273131..bef491d5f0 100644
--- a/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp
+++ b/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp
@@ -105,12 +105,12 @@ static void warningFreeHelperTemplate()
     assemblyMarker<1>(&i);
 
     // the loads sometimes generate no assembly output
-    i.load();
+    i.loadRelaxed();
     assemblyMarker<11>(&i);
     i.loadAcquire();
     assemblyMarker<12>(&i);
 
-    i.store(newValue);
+    i.storeRelaxed(newValue);
     assemblyMarker<21>(&i);
     i.storeRelease(newValue);
     assemblyMarker<22>(&i);
@@ -282,9 +282,9 @@ void tst_QAtomicInt::constructor()
 {
     QFETCH(int, value);
     QAtomicInt atomic1(value);
-    QCOMPARE(atomic1.load(), value);
+    QCOMPARE(atomic1.loadRelaxed(), value);
     QAtomicInt atomic2 = value;
-    QCOMPARE(atomic2.load(), value);
+    QCOMPARE(atomic2.loadRelaxed(), value);
 }
 
 void tst_QAtomicInt::copy_constructor_data()
@@ -294,16 +294,16 @@ void tst_QAtomicInt::copy_constructor()
 {
     QFETCH(int, value);
     QAtomicInt atomic1(value);
-    QCOMPARE(atomic1.load(), value);
+    QCOMPARE(atomic1.loadRelaxed(), value);
 
     QAtomicInt atomic2(atomic1);
-    QCOMPARE(atomic2.load(), value);
+    QCOMPARE(atomic2.loadRelaxed(), value);
     QAtomicInt atomic3 = atomic1;
-    QCOMPARE(atomic3.load(), value);
+    QCOMPARE(atomic3.loadRelaxed(), value);
     QAtomicInt atomic4(atomic2);
-    QCOMPARE(atomic4.load(), value);
+    QCOMPARE(atomic4.loadRelaxed(), value);
     QAtomicInt atomic5 = atomic2;
-    QCOMPARE(atomic5.load(), value);
+    QCOMPARE(atomic5.loadRelaxed(), value);
 }
 
 void tst_QAtomicInt::assignment_operator_data()
@@ -327,13 +327,13 @@ void tst_QAtomicInt::assignment_operator()
     {
         QAtomicInt atomic1 = value;
         atomic1 = newval;
-        QCOMPARE(atomic1.load(), newval);
+        QCOMPARE(atomic1.loadRelaxed(), newval);
         atomic1 = value;
-        QCOMPARE(atomic1.load(), value);
+        QCOMPARE(atomic1.loadRelaxed(), value);
 
         QAtomicInt atomic2 = newval;
         atomic1 = atomic2;
-        QCOMPARE(atomic1.load(), atomic2.load());
+        QCOMPARE(atomic1.loadRelaxed(), atomic2.loadRelaxed());
     }
 }
 
@@ -401,7 +401,7 @@ void tst_QAtomicInt::ref()
     QFETCH(int, value);
     QAtomicInt x = value;
     QTEST(x.ref() ? 1 : 0, "result");
-    QTEST(x.load(), "expected");
+    QTEST(x.loadRelaxed(), "expected");
 }
 
 void tst_QAtomicInt::deref_data()
@@ -420,7 +420,7 @@ void tst_QAtomicInt::deref()
     QFETCH(int, value);
     QAtomicInt x = value;
     QTEST(x.deref() ? 1 : 0, "result");
-    QTEST(x.load(), "expected");
+    QTEST(x.loadRelaxed(), "expected");
 }
 
 void tst_QAtomicInt::isTestAndSetNative()
@@ -636,25 +636,25 @@ void tst_QAtomicInt::fetchAndStore()
     {
         QAtomicInt atomic = value;
         QCOMPARE(atomic.fetchAndStoreRelaxed(newval), value);
-        QCOMPARE(atomic.load(), newval);
+        QCOMPARE(atomic.loadRelaxed(), newval);
     }
 
     {
         QAtomicInt atomic = value;
         QCOMPARE(atomic.fetchAndStoreAcquire(newval), value);
-        QCOMPARE(atomic.load(), newval);
+        QCOMPARE(atomic.loadRelaxed(), newval);
     }
 
     {
         QAtomicInt atomic = value;
         QCOMPARE(atomic.fetchAndStoreRelease(newval), value);
-        QCOMPARE(atomic.load(), newval);
+        QCOMPARE(atomic.loadRelaxed(), newval);
     }
 
     {
         QAtomicInt atomic = value;
         QCOMPARE(atomic.fetchAndStoreOrdered(newval), value);
-        QCOMPARE(atomic.load(), newval);
+        QCOMPARE(atomic.loadRelaxed(), newval);
     }
 }
 
@@ -773,28 +773,28 @@ void tst_QAtomicInt::fetchAndAdd()
         QAtomicInt atomic = value1;
         result = atomic.fetchAndAddRelaxed(value2);
         QCOMPARE(result, value1);
-        QCOMPARE(atomic.load(), value1 + value2);
+        QCOMPARE(atomic.loadRelaxed(), value1 + value2);
     }
 
     {
         QAtomicInt atomic = value1;
         result = atomic.fetchAndAddAcquire(value2);
         QCOMPARE(result, value1);
-        QCOMPARE(atomic.load(), value1 + value2);
+        QCOMPARE(atomic.loadRelaxed(), value1 + value2);
     }
 
     {
         QAtomicInt atomic = value1;
         result = atomic.fetchAndAddRelease(value2);
         QCOMPARE(result, value1);
-        QCOMPARE(atomic.load(), value1 + value2);
+        QCOMPARE(atomic.loadRelaxed(), value1 + value2);
     }
 
     {
         QAtomicInt atomic = value1;
         result = atomic.fetchAndAddOrdered(value2);
         QCOMPARE(result, value1);
-        QCOMPARE(atomic.load(), value1 + value2);
+        QCOMPARE(atomic.loadRelaxed(), value1 + value2);
     }
 }
 
@@ -859,7 +859,7 @@ void tst_QAtomicInt::testAndSet_loop()
 
     QAtomicInt val=0;
     for (int i = 0; i < iterations; ++i) {
-        int v = val.load();
+        int v = val.loadRelaxed();
         QVERIFY(val.testAndSetRelaxed(v, v+1));
         if ((i % 1000) == 999) {
             if (stopWatch.elapsed() > 60 * 1000) {
@@ -882,7 +882,7 @@ void tst_QAtomicInt::fetchAndAdd_loop()
     QAtomicInt val=0;
     for (int i = 0; i < iterations; ++i) {
         const int prev = val.fetchAndAddRelaxed(1);
-        QCOMPARE(prev, val.load() -1);
+        QCOMPARE(prev, val.loadRelaxed() -1);
     }
 }
 
@@ -920,7 +920,7 @@ void tst_QAtomicInt::fetchAndAdd_threadedLoop()
     t1.wait();
     t2.wait();
 
-    QCOMPARE(val.load(), 0);
+    QCOMPARE(val.loadRelaxed(), 0);
 }
 
 QTEST_MAIN(tst_QAtomicInt)
diff --git a/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp b/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
index 3a98732f9d..bfe2a60088 100644
--- a/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
+++ b/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
@@ -270,13 +270,13 @@ void tst_QAtomicIntegerXX::constructor()
     QFETCH(LargeInt, value);
 
     QAtomicInteger<T> atomic(value);
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QAtomicInteger<T> atomic2 = value;
-    QCOMPARE(atomic2.load(), T(value));
+    QCOMPARE(atomic2.loadRelaxed(), T(value));
 
-    QVERIFY(atomic.load() >= std::numeric_limits<T>::min());
-    QVERIFY(atomic.load() <= std::numeric_limits<T>::max());
+    QVERIFY(atomic.loadRelaxed() >= std::numeric_limits<T>::min());
+    QVERIFY(atomic.loadRelaxed() <= std::numeric_limits<T>::max());
 }
 
 void tst_QAtomicIntegerXX::copy()
@@ -285,17 +285,17 @@ void tst_QAtomicIntegerXX::copy()
 
     QAtomicInteger<T> atomic(value);
     QAtomicInteger<T> copy(atomic);
-    QCOMPARE(copy.load(), atomic.load());
+    QCOMPARE(copy.loadRelaxed(), atomic.loadRelaxed());
 
     QAtomicInteger<T> copy2 = atomic;
-    QCOMPARE(copy2.load(), atomic.load());
+    QCOMPARE(copy2.loadRelaxed(), atomic.loadRelaxed());
 
     // move
     QAtomicInteger<T> copy3(std::move(copy));
-    QCOMPARE(copy3.load(), atomic.load());
+    QCOMPARE(copy3.loadRelaxed(), atomic.loadRelaxed());
 
     QAtomicInteger<T> copy4 = std::move(copy2);
-    QCOMPARE(copy4.load(), atomic.load());
+    QCOMPARE(copy4.loadRelaxed(), atomic.loadRelaxed());
 }
 
 void tst_QAtomicIntegerXX::assign()
@@ -305,24 +305,24 @@ void tst_QAtomicIntegerXX::assign()
     QAtomicInteger<T> atomic(value);
     QAtomicInteger<T> copy;
     copy = atomic;
-    QCOMPARE(copy.load(), atomic.load());
+    QCOMPARE(copy.loadRelaxed(), atomic.loadRelaxed());
 
     QAtomicInteger<T> copy2;
     copy2 = atomic;  // operator=(const QAtomicInteger &)
-    QCOMPARE(copy2.load(), atomic.load());
+    QCOMPARE(copy2.loadRelaxed(), atomic.loadRelaxed());
 
     QAtomicInteger<T> copy2bis;
-    copy2bis = atomic.load(); // operator=(T)
-    QCOMPARE(copy2bis.load(), atomic.load());
+    copy2bis = atomic.loadRelaxed(); // operator=(T)
+    QCOMPARE(copy2bis.loadRelaxed(), atomic.loadRelaxed());
 
     // move
     QAtomicInteger<T> copy3;
     copy3 = std::move(copy);
-    QCOMPARE(copy3.load(), atomic.load());
+    QCOMPARE(copy3.loadRelaxed(), atomic.loadRelaxed());
 
     QAtomicInteger<T> copy4;
     copy4 = std::move(copy2);
-    QCOMPARE(copy4.load(), atomic.load());
+    QCOMPARE(copy4.loadRelaxed(), atomic.loadRelaxed());
 }
 
 void tst_QAtomicIntegerXX::operatorInteger()
@@ -331,7 +331,7 @@ void tst_QAtomicIntegerXX::operatorInteger()
 
     QAtomicInteger<T> atomic(value);
     T val2 = atomic;
-    QCOMPARE(val2, atomic.load());
+    QCOMPARE(val2, atomic.loadRelaxed());
     QCOMPARE(val2, T(value));
 }
 
@@ -346,7 +346,7 @@ void tst_QAtomicIntegerXX::loadAcquireStoreRelease()
     QCOMPARE(atomic.loadAcquire(), T(~value));
 
     atomic.storeRelease(value);
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 }
 
 void tst_QAtomicIntegerXX::refDeref()
@@ -364,16 +364,16 @@ void tst_QAtomicIntegerXX::refDeref()
     QAtomicInteger<T> atomic(value);
     if (!needToPreventOverflow) {
     QCOMPARE(atomic.ref(), (nextValue != 0));
-    QCOMPARE(atomic.load(), nextValue);
+    QCOMPARE(atomic.loadRelaxed(), nextValue);
     QCOMPARE(atomic.deref(), (value != 0));
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     if (!needToPreventUnderflow) {
     QCOMPARE(atomic.deref(), (prevValue != 0));
-    QCOMPARE(atomic.load(), prevValue);
+    QCOMPARE(atomic.loadRelaxed(), prevValue);
     QCOMPARE(atomic.ref(), (value != 0));
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     if (!needToPreventOverflow) {
     QCOMPARE(++atomic, nextValue);
@@ -392,7 +392,7 @@ void tst_QAtomicIntegerXX::refDeref()
     QCOMPARE(atomic--, T(value));
     QCOMPARE(atomic++, prevValue);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 }
 
 void tst_QAtomicIntegerXX::testAndSet()
@@ -402,16 +402,16 @@ void tst_QAtomicIntegerXX::testAndSet()
     QAtomicInteger<T> atomic(value);
 
     QVERIFY(atomic.testAndSetRelaxed(value, newValue));
-    QCOMPARE(atomic.load(), newValue);
+    QCOMPARE(atomic.loadRelaxed(), newValue);
     QVERIFY(!atomic.testAndSetRelaxed(value, newValue));
     QVERIFY(atomic.testAndSetRelaxed(newValue, value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QVERIFY(atomic.testAndSetAcquire(value, newValue));
-    QCOMPARE(atomic.load(), newValue);
+    QCOMPARE(atomic.loadRelaxed(), newValue);
     QVERIFY(!atomic.testAndSetAcquire(value, newValue));
     QVERIFY(atomic.testAndSetAcquire(newValue, value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QVERIFY(atomic.testAndSetRelease(value, newValue));
     QCOMPARE(atomic.loadAcquire(), newValue);
@@ -434,18 +434,18 @@ void tst_QAtomicIntegerXX::testAndSet3()
     QAtomicInteger<T> atomic(value);
 
     QVERIFY(atomic.testAndSetRelaxed(value, newValue, oldValue));
-    QCOMPARE(atomic.load(), newValue);
+    QCOMPARE(atomic.loadRelaxed(), newValue);
     QVERIFY(!atomic.testAndSetRelaxed(value, newValue, oldValue));
     QCOMPARE(oldValue, newValue);
     QVERIFY(atomic.testAndSetRelaxed(newValue, value, oldValue));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QVERIFY(atomic.testAndSetAcquire(value, newValue, oldValue));
-    QCOMPARE(atomic.load(), newValue);
+    QCOMPARE(atomic.loadRelaxed(), newValue);
     QVERIFY(!atomic.testAndSetAcquire(value, newValue, oldValue));
     QCOMPARE(oldValue, newValue);
     QVERIFY(atomic.testAndSetAcquire(newValue, value, oldValue));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QVERIFY(atomic.testAndSetRelease(value, newValue, oldValue));
     QCOMPARE(atomic.loadAcquire(), newValue);
@@ -469,14 +469,14 @@ void tst_QAtomicIntegerXX::fetchAndStore()
     QAtomicInteger<T> atomic(value);
 
     QCOMPARE(atomic.fetchAndStoreRelaxed(newValue), T(value));
-    QCOMPARE(atomic.load(), newValue);
+    QCOMPARE(atomic.loadRelaxed(), newValue);
     QCOMPARE(atomic.fetchAndStoreRelaxed(value), newValue);
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QCOMPARE(atomic.fetchAndStoreAcquire(newValue), T(value));
-    QCOMPARE(atomic.load(), newValue);
+    QCOMPARE(atomic.loadRelaxed(), newValue);
     QCOMPARE(atomic.fetchAndStoreAcquire(value), newValue);
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QCOMPARE(atomic.fetchAndStoreRelease(newValue), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue);
@@ -509,29 +509,29 @@ void tst_QAtomicIntegerXX::fetchAndAdd()
 
     if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel1), T(value));
-    QCOMPARE(atomic.load(), newValue1);
+    QCOMPARE(atomic.loadRelaxed(), newValue1);
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel2), newValue1);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel2), T(value));
-    QCOMPARE(atomic.load(), newValue2);
+    QCOMPARE(atomic.loadRelaxed(), newValue2);
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel1), newValue2);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddAcquire(parcel1), T(value));
-    QCOMPARE(atomic.load(), newValue1);
+    QCOMPARE(atomic.loadRelaxed(), newValue1);
     QCOMPARE(atomic.fetchAndAddAcquire(parcel2), newValue1);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddAcquire(parcel2), T(value));
-    QCOMPARE(atomic.load(), newValue2);
+    QCOMPARE(atomic.loadRelaxed(), newValue2);
     QCOMPARE(atomic.fetchAndAddAcquire(parcel1), newValue2);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddRelease(parcel1), T(value));
@@ -590,29 +590,29 @@ void tst_QAtomicIntegerXX::fetchAndSub()
 
     if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel1), T(value));
-    QCOMPARE(atomic.load(), newValue1);
+    QCOMPARE(atomic.loadRelaxed(), newValue1);
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel2), newValue1);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel2), T(value));
-    QCOMPARE(atomic.load(), newValue2);
+    QCOMPARE(atomic.loadRelaxed(), newValue2);
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel1), newValue2);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubAcquire(parcel1), T(value));
-    QCOMPARE(atomic.load(), newValue1);
+    QCOMPARE(atomic.loadRelaxed(), newValue1);
     QCOMPARE(atomic.fetchAndSubAcquire(parcel2), newValue1);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubAcquire(parcel2), T(value));
-    QCOMPARE(atomic.load(), newValue2);
+    QCOMPARE(atomic.loadRelaxed(), newValue2);
     QCOMPARE(atomic.fetchAndSubAcquire(parcel1), newValue2);
     }
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubRelease(parcel1), T(value));
@@ -662,32 +662,32 @@ void tst_QAtomicIntegerXX::fetchAndOr()
 
     QCOMPARE(atomic.fetchAndOrRelaxed(zero), T(value));
     QCOMPARE(atomic.fetchAndOrRelaxed(one), T(value));
-    QCOMPARE(atomic.load(), T(value | 1));
+    QCOMPARE(atomic.loadRelaxed(), T(value | 1));
     QCOMPARE(atomic.fetchAndOrRelaxed(minusOne), T(value | 1));
-    QCOMPARE(atomic.load(), minusOne);
+    QCOMPARE(atomic.loadRelaxed(), minusOne);
 
-    atomic.store(value);
+    atomic.storeRelaxed(value);
     QCOMPARE(atomic.fetchAndOrAcquire(zero), T(value));
     QCOMPARE(atomic.fetchAndOrAcquire(one), T(value));
-    QCOMPARE(atomic.load(), T(value | 1));
+    QCOMPARE(atomic.loadRelaxed(), T(value | 1));
     QCOMPARE(atomic.fetchAndOrAcquire(minusOne), T(value | 1));
-    QCOMPARE(atomic.load(), minusOne);
+    QCOMPARE(atomic.loadRelaxed(), minusOne);
 
-    atomic.store(value);
+    atomic.storeRelaxed(value);
     QCOMPARE(atomic.fetchAndOrRelease(zero), T(value));
     QCOMPARE(atomic.fetchAndOrRelease(one), T(value));
-    QCOMPARE(atomic.load(), T(value | 1));
+    QCOMPARE(atomic.loadRelaxed(), T(value | 1));
     QCOMPARE(atomic.fetchAndOrRelease(minusOne), T(value | 1));
-    QCOMPARE(atomic.load(), minusOne);
+    QCOMPARE(atomic.loadRelaxed(), minusOne);
 
-    atomic.store(value);
+    atomic.storeRelaxed(value);
     QCOMPARE(atomic.fetchAndOrOrdered(zero), T(value));
     QCOMPARE(atomic.fetchAndOrOrdered(one), T(value));
-    QCOMPARE(atomic.load(), T(value | 1));
+    QCOMPARE(atomic.loadRelaxed(), T(value | 1));
     QCOMPARE(atomic.fetchAndOrOrdered(minusOne), T(value | 1));
-    QCOMPARE(atomic.load(), minusOne);
+    QCOMPARE(atomic.loadRelaxed(), minusOne);
 
-    atomic.store(value);
+    atomic.storeRelaxed(value);
     QCOMPARE(atomic |= zero, T(value));
     QCOMPARE(atomic |= one, T(value | 1));
     QCOMPARE(atomic |= minusOne, minusOne);
@@ -703,37 +703,37 @@ void tst_QAtomicIntegerXX::fetchAndAnd()
     T minusOne = T(~0);
 
     QCOMPARE(atomic.fetchAndAndRelaxed(minusOne), T(value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndAndRelaxed(f), T(value));
-    QCOMPARE(atomic.load(), T(value & 0xf));
+    QCOMPARE(atomic.loadRelaxed(), T(value & 0xf));
     QCOMPARE(atomic.fetchAndAndRelaxed(zero), T(value & 0xf));
-    QCOMPARE(atomic.load(), zero);
+    QCOMPARE(atomic.loadRelaxed(), zero);
 
-    atomic.store(value);
+    atomic.storeRelaxed(value);
     QCOMPARE(atomic.fetchAndAndAcquire(minusOne), T(value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndAndAcquire(f), T(value));
-    QCOMPARE(atomic.load(), T(value & 0xf));
+    QCOMPARE(atomic.loadRelaxed(), T(value & 0xf));
     QCOMPARE(atomic.fetchAndAndAcquire(zero), T(value & 0xf));
-    QCOMPARE(atomic.load(), zero);
+    QCOMPARE(atomic.loadRelaxed(), zero);
 
-    atomic.store(value);
+    atomic.storeRelaxed(value);
     QCOMPARE(atomic.fetchAndAndRelease(minusOne), T(value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndAndRelease(f), T(value));
-    QCOMPARE(atomic.load(), T(value & 0xf));
+    QCOMPARE(atomic.loadRelaxed(), T(value & 0xf));
     QCOMPARE(atomic.fetchAndAndRelease(zero), T(value & 0xf));
-    QCOMPARE(atomic.load(), zero);
+    QCOMPARE(atomic.loadRelaxed(), zero);
 
-    atomic.store(value);
+    atomic.storeRelaxed(value);
     QCOMPARE(atomic.fetchAndAndOrdered(minusOne), T(value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndAndOrdered(f), T(value));
-    QCOMPARE(atomic.load(), T(value & 0xf));
+    QCOMPARE(atomic.loadRelaxed(), T(value & 0xf));
     QCOMPARE(atomic.fetchAndAndOrdered(zero), T(value & 0xf));
-    QCOMPARE(atomic.load(), zero);
+    QCOMPARE(atomic.loadRelaxed(), zero);
 
-    atomic.store(value);
+    atomic.storeRelaxed(value);
     QCOMPARE(atomic &= minusOne, T(value));
     QCOMPARE(atomic &= f, T(value & 0xf));
     QCOMPARE(atomic &= zero, zero);
@@ -749,48 +749,48 @@ void tst_QAtomicIntegerXX::fetchAndXor()
     T minusOne = T(~0);
 
     QCOMPARE(atomic.fetchAndXorRelaxed(zero), T(value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndXorRelaxed(pattern), T(value));
-    QCOMPARE(atomic.load(), T(value ^ pattern));
+    QCOMPARE(atomic.loadRelaxed(), T(value ^ pattern));
     QCOMPARE(atomic.fetchAndXorRelaxed(pattern), T(value ^ pattern));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndXorRelaxed(minusOne), T(value));
-    QCOMPARE(atomic.load(), T(~value));
+    QCOMPARE(atomic.loadRelaxed(), T(~value));
     QCOMPARE(atomic.fetchAndXorRelaxed(minusOne), T(~value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QCOMPARE(atomic.fetchAndXorAcquire(zero), T(value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndXorAcquire(pattern), T(value));
-    QCOMPARE(atomic.load(), T(value ^ pattern));
+    QCOMPARE(atomic.loadRelaxed(), T(value ^ pattern));
     QCOMPARE(atomic.fetchAndXorAcquire(pattern), T(value ^ pattern));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndXorAcquire(minusOne), T(value));
-    QCOMPARE(atomic.load(), T(~value));
+    QCOMPARE(atomic.loadRelaxed(), T(~value));
     QCOMPARE(atomic.fetchAndXorAcquire(minusOne), T(~value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QCOMPARE(atomic.fetchAndXorRelease(zero), T(value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndXorRelease(pattern), T(value));
-    QCOMPARE(atomic.load(), T(value ^ pattern));
+    QCOMPARE(atomic.loadRelaxed(), T(value ^ pattern));
     QCOMPARE(atomic.fetchAndXorRelease(pattern), T(value ^ pattern));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndXorRelease(minusOne), T(value));
-    QCOMPARE(atomic.load(), T(~value));
+    QCOMPARE(atomic.loadRelaxed(), T(~value));
     QCOMPARE(atomic.fetchAndXorRelease(minusOne), T(~value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QCOMPARE(atomic.fetchAndXorOrdered(zero), T(value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndXorOrdered(pattern), T(value));
-    QCOMPARE(atomic.load(), T(value ^ pattern));
+    QCOMPARE(atomic.loadRelaxed(), T(value ^ pattern));
     QCOMPARE(atomic.fetchAndXorOrdered(pattern), T(value ^ pattern));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
     QCOMPARE(atomic.fetchAndXorOrdered(minusOne), T(value));
-    QCOMPARE(atomic.load(), T(~value));
+    QCOMPARE(atomic.loadRelaxed(), T(~value));
     QCOMPARE(atomic.fetchAndXorOrdered(minusOne), T(~value));
-    QCOMPARE(atomic.load(), T(value));
+    QCOMPARE(atomic.loadRelaxed(), T(value));
 
     QCOMPARE(atomic ^= zero, T(value));
     QCOMPARE(atomic ^= pattern, T(value ^ pattern));
diff --git a/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp b/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp
index 0200473cae..a699cf6202 100644
--- a/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp
+++ b/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp
@@ -75,7 +75,7 @@ void tst_QAtomicPointer::warningFreeHelper()
 
     QBasicAtomicPointer<WFHC> p = Q_BASIC_ATOMIC_INITIALIZER(0);
 
-    p.load()->bar();
+    p.loadRelaxed()->bar();
 
     WFHC *expectedValue = 0;
     WFHC *newValue = 0;
@@ -119,15 +119,15 @@ void tst_QAtomicPointer::constructor()
 {
     void *one = this;
     QAtomicPointer<void> atomic1 = one;
-    QCOMPARE(atomic1.load(), one);
+    QCOMPARE(atomic1.loadRelaxed(), one);
 
     void *two = &one;
     QAtomicPointer<void> atomic2 = two;
-    QCOMPARE(atomic2.load(), two);
+    QCOMPARE(atomic2.loadRelaxed(), two);
 
     void *three = &two;
     QAtomicPointer<void> atomic3 = three;
-    QCOMPARE(atomic3.load(), three);
+    QCOMPARE(atomic3.loadRelaxed(), three);
 }
 
 void tst_QAtomicPointer::copy_constructor()
@@ -135,20 +135,20 @@ void tst_QAtomicPointer::copy_constructor()
     void *one = this;
     QAtomicPointer<void> atomic1 = one;
     QAtomicPointer<void> atomic1_copy = atomic1;
-    QCOMPARE(atomic1_copy.load(), one);
-    QCOMPARE(atomic1_copy.load(), atomic1.load());
+    QCOMPARE(atomic1_copy.loadRelaxed(), one);
+    QCOMPARE(atomic1_copy.loadRelaxed(), atomic1.loadRelaxed());
 
     void *two = &one;
     QAtomicPointer<void> atomic2 = two;
     QAtomicPointer<void> atomic2_copy = atomic2;
-    QCOMPARE(atomic2_copy.load(), two);
-    QCOMPARE(atomic2_copy.load(), atomic2.load());
+    QCOMPARE(atomic2_copy.loadRelaxed(), two);
+    QCOMPARE(atomic2_copy.loadRelaxed(), atomic2.loadRelaxed());
 
     void *three = &two;
     QAtomicPointer<void> atomic3 = three;
     QAtomicPointer<void> atomic3_copy = atomic3;
-    QCOMPARE(atomic3_copy.load(), three);
-    QCOMPARE(atomic3_copy.load(), atomic3.load());
+    QCOMPARE(atomic3_copy.loadRelaxed(), three);
+    QCOMPARE(atomic3_copy.loadRelaxed(), atomic3.loadRelaxed());
 }
 
 void tst_QAtomicPointer::assignment_operator()
@@ -161,17 +161,17 @@ void tst_QAtomicPointer::assignment_operator()
     QAtomicPointer<void> atomic2 = two;
     QAtomicPointer<void> atomic3 = three;
 
-    QCOMPARE(atomic1.load(), one);
-    QCOMPARE(atomic2.load(), two);
-    QCOMPARE(atomic3.load(), three);
+    QCOMPARE(atomic1.loadRelaxed(), one);
+    QCOMPARE(atomic2.loadRelaxed(), two);
+    QCOMPARE(atomic3.loadRelaxed(), three);
 
     atomic1 = two;
     atomic2 = three;
     atomic3 = one;
 
-    QCOMPARE(atomic1.load(), two);
-    QCOMPARE(atomic2.load(), three);
-    QCOMPARE(atomic3.load(), one);
+    QCOMPARE(atomic1.loadRelaxed(), two);
+    QCOMPARE(atomic2.loadRelaxed(), three);
+    QCOMPARE(atomic3.loadRelaxed(), one);
 }
 
 void tst_QAtomicPointer::isTestAndSetNative()
@@ -234,17 +234,17 @@ void tst_QAtomicPointer::testAndSet()
         QAtomicPointer<void> atomic2 = two;
         QAtomicPointer<void> atomic3 = three;
 
-        QCOMPARE(atomic1.load(), one);
-        QCOMPARE(atomic2.load(), two);
-        QCOMPARE(atomic3.load(), three);
+        QCOMPARE(atomic1.loadRelaxed(), one);
+        QCOMPARE(atomic2.loadRelaxed(), two);
+        QCOMPARE(atomic3.loadRelaxed(), three);
 
         QVERIFY(atomic1.testAndSetRelaxed(one, two));
         QVERIFY(atomic2.testAndSetRelaxed(two, three));
         QVERIFY(atomic3.testAndSetRelaxed(three, one));
 
-        QCOMPARE(atomic1.load(), two);
-        QCOMPARE(atomic2.load(), three);
-        QCOMPARE(atomic3.load(), one);
+        QCOMPARE(atomic1.loadRelaxed(), two);
+        QCOMPARE(atomic2.loadRelaxed(), three);
+        QCOMPARE(atomic3.loadRelaxed(), one);
     }
 
     {
@@ -252,17 +252,17 @@ void tst_QAtomicPointer::testAndSet()
         QAtomicPointer<void> atomic2 = two;
         QAtomicPointer<void> atomic3 = three;
 
-        QCOMPARE(atomic1.load(), one);
-        QCOMPARE(atomic2.load(), two);
-        QCOMPARE(atomic3.load(), three);
+        QCOMPARE(atomic1.loadRelaxed(), one);
+        QCOMPARE(atomic2.loadRelaxed(), two);
+        QCOMPARE(atomic3.loadRelaxed(), three);
 
         QVERIFY(atomic1.testAndSetAcquire(one, two));
         QVERIFY(atomic2.testAndSetAcquire(two, three));
         QVERIFY(atomic3.testAndSetAcquire(three, one));
 
-        QCOMPARE(atomic1.load(), two);
-        QCOMPARE(atomic2.load(), three);
-        QCOMPARE(atomic3.load(), one);
+        QCOMPARE(atomic1.loadRelaxed(), two);
+        QCOMPARE(atomic2.loadRelaxed(), three);
+        QCOMPARE(atomic3.loadRelaxed(), one);
     }
 
     {
@@ -270,17 +270,17 @@ void tst_QAtomicPointer::testAndSet()
         QAtomicPointer<void> atomic2 = two;
         QAtomicPointer<void> atomic3 = three;
 
-        QCOMPARE(atomic1.load(), one);
-        QCOMPARE(atomic2.load(), two);
-        QCOMPARE(atomic3.load(), three);
+        QCOMPARE(atomic1.loadRelaxed(), one);
+        QCOMPARE(atomic2.loadRelaxed(), two);
+        QCOMPARE(atomic3.loadRelaxed(), three);
 
         QVERIFY(atomic1.testAndSetRelease(one, two));
         QVERIFY(atomic2.testAndSetRelease(two, three));
         QVERIFY(atomic3.testAndSetRelease(three, one));
 
-        QCOMPARE(atomic1.load(), two);
-        QCOMPARE(atomic2.load(), three);
-        QCOMPARE(atomic3.load(), one);
+        QCOMPARE(atomic1.loadRelaxed(), two);
+        QCOMPARE(atomic2.loadRelaxed(), three);
+        QCOMPARE(atomic3.loadRelaxed(), one);
     }
 
     {
@@ -288,17 +288,17 @@ void tst_QAtomicPointer::testAndSet()
         QAtomicPointer<void> atomic2 = two;
         QAtomicPointer<void> atomic3 = three;
 
-        QCOMPARE(atomic1.load(), one);
-        QCOMPARE(atomic2.load(), two);
-        QCOMPARE(atomic3.load(), three);
+        QCOMPARE(atomic1.loadRelaxed(), one);
+        QCOMPARE(atomic2.loadRelaxed(), two);
+        QCOMPARE(atomic3.loadRelaxed(), three);
 
         QVERIFY(atomic1.testAndSetOrdered(one, two));
         QVERIFY(atomic2.testAndSetOrdered(two, three));
         QVERIFY(atomic3.testAndSetOrdered(three, one));
 
-        QCOMPARE(atomic1.load(), two);
-        QCOMPARE(atomic2.load(), three);
-        QCOMPARE(atomic3.load(), one);
+        QCOMPARE(atomic1.loadRelaxed(), two);
+        QCOMPARE(atomic2.loadRelaxed(), three);
+        QCOMPARE(atomic3.loadRelaxed(), one);
     }
 }
 
@@ -362,17 +362,17 @@ void tst_QAtomicPointer::fetchAndStore()
         QAtomicPointer<void> atomic2 = two;
         QAtomicPointer<void> atomic3 = three;
 
-        QCOMPARE(atomic1.load(), one);
-        QCOMPARE(atomic2.load(), two);
-        QCOMPARE(atomic3.load(), three);
+        QCOMPARE(atomic1.loadRelaxed(), one);
+        QCOMPARE(atomic2.loadRelaxed(), two);
+        QCOMPARE(atomic3.loadRelaxed(), three);
 
         QCOMPARE(atomic1.fetchAndStoreRelaxed(two), one);
         QCOMPARE(atomic2.fetchAndStoreRelaxed(three), two);
         QCOMPARE(atomic3.fetchAndStoreRelaxed(one), three);
 
-        QCOMPARE(atomic1.load(), two);
-        QCOMPARE(atomic2.load(), three);
-        QCOMPARE(atomic3.load(), one);
+        QCOMPARE(atomic1.loadRelaxed(), two);
+        QCOMPARE(atomic2.loadRelaxed(), three);
+        QCOMPARE(atomic3.loadRelaxed(), one);
     }
 
     {
@@ -380,17 +380,17 @@ void tst_QAtomicPointer::fetchAndStore()
         QAtomicPointer<void> atomic2 = two;
         QAtomicPointer<void> atomic3 = three;
 
-        QCOMPARE(atomic1.load(), one);
-        QCOMPARE(atomic2.load(), two);
-        QCOMPARE(atomic3.load(), three);
+        QCOMPARE(atomic1.loadRelaxed(), one);
+        QCOMPARE(atomic2.loadRelaxed(), two);
+        QCOMPARE(atomic3.loadRelaxed(), three);
 
         QCOMPARE(atomic1.fetchAndStoreAcquire(two), one);
         QCOMPARE(atomic2.fetchAndStoreAcquire(three), two);
         QCOMPARE(atomic3.fetchAndStoreAcquire(one), three);
 
-        QCOMPARE(atomic1.load(), two);
-        QCOMPARE(atomic2.load(), three);
-        QCOMPARE(atomic3.load(), one);
+        QCOMPARE(atomic1.loadRelaxed(), two);
+        QCOMPARE(atomic2.loadRelaxed(), three);
+        QCOMPARE(atomic3.loadRelaxed(), one);
     }
 
     {
@@ -398,17 +398,17 @@ void tst_QAtomicPointer::fetchAndStore()
         QAtomicPointer<void> atomic2 = two;
         QAtomicPointer<void> atomic3 = three;
 
-        QCOMPARE(atomic1.load(), one);
-        QCOMPARE(atomic2.load(), two);
-        QCOMPARE(atomic3.load(), three);
+        QCOMPARE(atomic1.loadRelaxed(), one);
+        QCOMPARE(atomic2.loadRelaxed(), two);
+        QCOMPARE(atomic3.loadRelaxed(), three);
 
         QCOMPARE(atomic1.fetchAndStoreRelease(two), one);
         QCOMPARE(atomic2.fetchAndStoreRelease(three), two);
         QCOMPARE(atomic3.fetchAndStoreRelease(one), three);
 
-        QCOMPARE(atomic1.load(), two);
-        QCOMPARE(atomic2.load(), three);
-        QCOMPARE(atomic3.load(), one);
+        QCOMPARE(atomic1.loadRelaxed(), two);
+        QCOMPARE(atomic2.loadRelaxed(), three);
+        QCOMPARE(atomic3.loadRelaxed(), one);
     }
 
     {
@@ -416,17 +416,17 @@ void tst_QAtomicPointer::fetchAndStore()
         QAtomicPointer<void> atomic2 = two;
         QAtomicPointer<void> atomic3 = three;
 
-        QCOMPARE(atomic1.load(), one);
-        QCOMPARE(atomic2.load(), two);
-        QCOMPARE(atomic3.load(), three);
+        QCOMPARE(atomic1.loadRelaxed(), one);
+        QCOMPARE(atomic2.loadRelaxed(), two);
+        QCOMPARE(atomic3.loadRelaxed(), three);
 
         QCOMPARE(atomic1.fetchAndStoreOrdered(two), one);
         QCOMPARE(atomic2.fetchAndStoreOrdered(three), two);
         QCOMPARE(atomic3.fetchAndStoreOrdered(one), three);
 
-        QCOMPARE(atomic1.load(), two);
-        QCOMPARE(atomic2.load(), three);
-        QCOMPARE(atomic3.load(), one);
+        QCOMPARE(atomic1.loadRelaxed(), two);
+        QCOMPARE(atomic2.loadRelaxed(), three);
+        QCOMPARE(atomic3.loadRelaxed(), one);
     }
 }
 
@@ -530,60 +530,60 @@ void tst_QAtomicPointer::fetchAndAdd()
         // cast to void* in order to avoid QCOMPARE to compare string content of the char*
         QCOMPARE(static_cast<void*>(pointer1.fetchAndAddRelaxed(valueToAdd)), static_cast<void*>(pc));
         QCOMPARE(static_cast<void*>(pointer1.fetchAndAddRelaxed(-valueToAdd)), static_cast<void*>(pc + valueToAdd));
-        QCOMPARE(static_cast<void*>(pointer1.load()), static_cast<void*>(pc));
+        QCOMPARE(static_cast<void*>(pointer1.loadRelaxed()), static_cast<void*>(pc));
         QAtomicPointer<short> pointer2 = ps;
         QCOMPARE(pointer2.fetchAndAddRelaxed(valueToAdd), ps);
         QCOMPARE(pointer2.fetchAndAddRelaxed(-valueToAdd), ps + valueToAdd);
-        QCOMPARE(pointer2.load(), ps);
+        QCOMPARE(pointer2.loadRelaxed(), ps);
         QAtomicPointer<int> pointer3 = pi;
         QCOMPARE(pointer3.fetchAndAddRelaxed(valueToAdd), pi);
         QCOMPARE(pointer3.fetchAndAddRelaxed(-valueToAdd), pi + valueToAdd);
-        QCOMPARE(pointer3.load(), pi);
+        QCOMPARE(pointer3.loadRelaxed(), pi);
     }
 
     {
         QAtomicPointer<char> pointer1 = pc;
         QCOMPARE(static_cast<void*>(pointer1.fetchAndAddAcquire(valueToAdd)), static_cast<void*>(pc));
         QCOMPARE(static_cast<void*>(pointer1.fetchAndAddAcquire(-valueToAdd)), static_cast<void*>(pc + valueToAdd));
-        QCOMPARE(static_cast<void*>(pointer1.load()), static_cast<void*>(pc));
+        QCOMPARE(static_cast<void*>(pointer1.loadRelaxed()), static_cast<void*>(pc));
         QAtomicPointer<short> pointer2 = ps;
         QCOMPARE(pointer2.fetchAndAddAcquire(valueToAdd), ps);
         QCOMPARE(pointer2.fetchAndAddAcquire(-valueToAdd), ps + valueToAdd);
-        QCOMPARE(pointer2.load(), ps);
+        QCOMPARE(pointer2.loadRelaxed(), ps);
         QAtomicPointer<int> pointer3 = pi;
         QCOMPARE(pointer3.fetchAndAddAcquire(valueToAdd), pi);
         QCOMPARE(pointer3.fetchAndAddAcquire(-valueToAdd), pi + valueToAdd);
-        QCOMPARE(pointer3.load(), pi);
+        QCOMPARE(pointer3.loadRelaxed(), pi);
     }
 
     {
         QAtomicPointer<char> pointer1 = pc;
         QCOMPARE(static_cast<void*>(pointer1.fetchAndAddRelease(valueToAdd)), static_cast<void*>(pc));
         QCOMPARE(static_cast<void*>(pointer1.fetchAndAddRelease(-valueToAdd)), static_cast<void*>(pc + valueToAdd));
-        QCOMPARE(static_cast<void*>(pointer1.load()), static_cast<void*>(pc));
+        QCOMPARE(static_cast<void*>(pointer1.loadRelaxed()), static_cast<void*>(pc));
         QAtomicPointer<short> pointer2 = ps;
         QCOMPARE(pointer2.fetchAndAddRelease(valueToAdd), ps);
         QCOMPARE(pointer2.fetchAndAddRelease(-valueToAdd), ps + valueToAdd);
-        QCOMPARE(pointer2.load(), ps);
+        QCOMPARE(pointer2.loadRelaxed(), ps);
         QAtomicPointer<int> pointer3 = pi;
         QCOMPARE(pointer3.fetchAndAddRelease(valueToAdd), pi);
         QCOMPARE(pointer3.fetchAndAddRelease(-valueToAdd), pi + valueToAdd);
-        QCOMPARE(pointer3.load(), pi);
+        QCOMPARE(pointer3.loadRelaxed(), pi);
     }
 
     {
         QAtomicPointer<char> pointer1 = pc;
         QCOMPARE(static_cast<void*>(pointer1.fetchAndAddOrdered(valueToAdd)), static_cast<void*>(pc));
         QCOMPARE(static_cast<void*>(pointer1.fetchAndAddOrdered(-valueToAdd)), static_cast<void*>(pc + valueToAdd));
-        QCOMPARE(static_cast<void*>(pointer1.load()), static_cast<void*>(pc));
+        QCOMPARE(static_cast<void*>(pointer1.loadRelaxed()), static_cast<void*>(pc));
         QAtomicPointer<short> pointer2 = ps;
         QCOMPARE(pointer2.fetchAndAddOrdered(valueToAdd), ps);
         QCOMPARE(pointer2.fetchAndAddOrdered(-valueToAdd), ps + valueToAdd);
-        QCOMPARE(pointer2.load(), ps);
+        QCOMPARE(pointer2.loadRelaxed(), ps);
         QAtomicPointer<int> pointer3 = pi;
         QCOMPARE(pointer3.fetchAndAddOrdered(valueToAdd), pi);
         QCOMPARE(pointer3.fetchAndAddOrdered(-valueToAdd), pi + valueToAdd);
-        QCOMPARE(pointer3.load(), pi);
+        QCOMPARE(pointer3.loadRelaxed(), pi);
     }
 }
 
@@ -598,34 +598,34 @@ template <typename T> void constAndVolatile_helper()
         QAtomicPointer<T> atomic2 = two;
         QAtomicPointer<T> atomic3 = three;
 
-        QVERIFY(atomic1.load() == one);
-        QVERIFY(atomic2.load() == two);
-        QVERIFY(atomic3.load() == three);
+        QVERIFY(atomic1.loadRelaxed() == one);
+        QVERIFY(atomic2.loadRelaxed() == two);
+        QVERIFY(atomic3.loadRelaxed() == three);
 
         QVERIFY(atomic1.fetchAndStoreRelaxed(two) == one);
         QVERIFY(atomic2.fetchAndStoreRelaxed(three) == two);
         QVERIFY(atomic3.fetchAndStoreRelaxed(one) == three);
 
-        QVERIFY(atomic1.load() == two);
-        QVERIFY(atomic2.load() == three);
-        QVERIFY(atomic3.load() == one);
+        QVERIFY(atomic1.loadRelaxed() == two);
+        QVERIFY(atomic2.loadRelaxed() == three);
+        QVERIFY(atomic3.loadRelaxed() == one);
     }
     {
         QAtomicPointer<T> atomic1 = one;
         QAtomicPointer<T> atomic2 = two;
         QAtomicPointer<T> atomic3 = three;
 
-        QVERIFY(atomic1.load() == one);
-        QVERIFY(atomic2.load() == two);
-        QVERIFY(atomic3.load() == three);
+        QVERIFY(atomic1.loadRelaxed() == one);
+        QVERIFY(atomic2.loadRelaxed() == two);
+        QVERIFY(atomic3.loadRelaxed() == three);
 
         QVERIFY(atomic1.testAndSetRelaxed(one, two));
         QVERIFY(atomic2.testAndSetRelaxed(two, three));
         QVERIFY(atomic3.testAndSetRelaxed(three, one));
 
-        QVERIFY(atomic1.load() == two);
-        QVERIFY(atomic2.load() == three);
-        QVERIFY(atomic3.load() == one);
+        QVERIFY(atomic1.loadRelaxed() == two);
+        QVERIFY(atomic2.loadRelaxed() == three);
+        QVERIFY(atomic3.loadRelaxed() == one);
     }
 
 }
diff --git a/tests/auto/corelib/thread/qmutex/tst_qmutex.cpp b/tests/auto/corelib/thread/qmutex/tst_qmutex.cpp
index 7fb9a861d7..37c5874c02 100644
--- a/tests/auto/corelib/thread/qmutex/tst_qmutex.cpp
+++ b/tests/auto/corelib/thread/qmutex/tst_qmutex.cpp
@@ -1132,7 +1132,7 @@ void tst_QMutex::stressTest()
     for (int i = 1; i < threadCount; ++i)
         QVERIFY(threads[i].wait(10000));
     QCOMPARE(StressTestThread::errorCount, 0);
-    qDebug("locked %d times", int(StressTestThread::lockCount.load()));
+    qDebug("locked %d times", int(StressTestThread::lockCount.loadRelaxed()));
 }
 
 class TryLockRaceThread : public QThread
@@ -1286,28 +1286,28 @@ public:
         quint64 i = 0;
         while (t.elapsed() < one_minute) {
             i++;
-            uint nb = (i * 9 + lockCount.load() * 13) % threadCount;
+            uint nb = (i * 9 + lockCount.loadRelaxed() * 13) % threadCount;
             QMutexLocker locker(&mutex[nb]);
-            if (sentinel[nb].load()) errorCount.ref();
+            if (sentinel[nb].loadRelaxed()) errorCount.ref();
             if (sentinel[nb].fetchAndAddRelaxed(5)) errorCount.ref();
             if (!sentinel[nb].testAndSetRelaxed(5, 0)) errorCount.ref();
-            if (sentinel[nb].load()) errorCount.ref();
+            if (sentinel[nb].loadRelaxed()) errorCount.ref();
             lockCount.ref();
-            nb = (nb * 17 + i * 5 + lockCount.load() * 3) % threadCount;
+            nb = (nb * 17 + i * 5 + lockCount.loadRelaxed() * 3) % threadCount;
             if (mutex[nb].tryLock()) {
-                if (sentinel[nb].load()) errorCount.ref();
+                if (sentinel[nb].loadRelaxed()) errorCount.ref();
                 if (sentinel[nb].fetchAndAddRelaxed(16)) errorCount.ref();
                 if (!sentinel[nb].testAndSetRelaxed(16, 0)) errorCount.ref();
-                if (sentinel[nb].load()) errorCount.ref();
+                if (sentinel[nb].loadRelaxed()) errorCount.ref();
                 lockCount.ref();
                 mutex[nb].unlock();
             }
-            nb = (nb * 15 + i * 47 + lockCount.load() * 31) % threadCount;
+            nb = (nb * 15 + i * 47 + lockCount.loadRelaxed() * 31) % threadCount;
             if (mutex[nb].tryLock(2)) {
-                if (sentinel[nb].load()) errorCount.ref();
+                if (sentinel[nb].loadRelaxed()) errorCount.ref();
                 if (sentinel[nb].fetchAndAddRelaxed(53)) errorCount.ref();
                 if (!sentinel[nb].testAndSetRelaxed(53, 0)) errorCount.ref();
-                if (sentinel[nb].load()) errorCount.ref();
+                if (sentinel[nb].loadRelaxed()) errorCount.ref();
                 lockCount.ref();
                 mutex[nb].unlock();
             }
@@ -1327,8 +1327,8 @@ void tst_QMutex::moreStress()
     QVERIFY(threads[0].wait(one_minute + 10000));
     for (int i = 1; i < threadCount; ++i)
         QVERIFY(threads[i].wait(10000));
-    qDebug("locked %d times", MoreStressTestThread::lockCount.load());
-    QCOMPARE(MoreStressTestThread::errorCount.load(), 0);
+    qDebug("locked %d times", MoreStressTestThread::lockCount.loadRelaxed());
+    QCOMPARE(MoreStressTestThread::errorCount.loadRelaxed(), 0);
 }
 
 
diff --git a/tests/auto/corelib/thread/qreadwritelock/tst_qreadwritelock.cpp b/tests/auto/corelib/thread/qreadwritelock/tst_qreadwritelock.cpp
index 45fcf9657d..47bae585a1 100644
--- a/tests/auto/corelib/thread/qreadwritelock/tst_qreadwritelock.cpp
+++ b/tests/auto/corelib/thread/qreadwritelock/tst_qreadwritelock.cpp
@@ -458,7 +458,7 @@ public:
     void run()
     {
         testRwlock.lockForWrite();
-        while(release.load()==false) {
+        while (release.loadRelaxed() == false) {
             RWTESTSLEEP
         }
         testRwlock.unlock();
@@ -478,7 +478,7 @@ public:
     void run()
     {
         testRwlock.lockForRead();
-        while(release.load()==false) {
+        while (release.loadRelaxed() == false) {
             RWTESTSLEEP
         }
         testRwlock.unlock();
@@ -677,7 +677,7 @@ void tst_QReadWriteLock::multipleReadersBlockRelease()
 {
 
     QReadWriteLock testLock;
-    release.store(false);
+    release.storeRelaxed(false);
     threadDone=false;
     ReadLockReleasableThread rlt1(testLock);
     ReadLockReleasableThread rlt2(testLock);
@@ -687,7 +687,7 @@ void tst_QReadWriteLock::multipleReadersBlockRelease()
     WriteLockThread wlt(testLock);
     wlt.start();
     sleep(1);
-    release.store(true);
+    release.storeRelaxed(true);
     wlt.wait();
     rlt1.wait();
     rlt2.wait();
diff --git a/tests/auto/corelib/thread/qthread/tst_qthread.cpp b/tests/auto/corelib/thread/qthread/tst_qthread.cpp
index 19922b1ea5..baec4a22a5 100644
--- a/tests/auto/corelib/thread/qthread/tst_qthread.cpp
+++ b/tests/auto/corelib/thread/qthread/tst_qthread.cpp
@@ -121,7 +121,7 @@ public:
     { }
 
     bool wasActivated()
-    { return activationCount.load() > 0; }
+    { return activationCount.loadRelaxed() > 0; }
 
 public slots:
     void slot();
@@ -900,7 +900,7 @@ void tst_QThread::adoptMultipleThreads()
 
     QTestEventLoop::instance().enterLoop(5);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(recorder.activationCount.load(), numThreads);
+    QCOMPARE(recorder.activationCount.loadRelaxed(), numThreads);
 }
 
 void tst_QThread::adoptMultipleThreadsOverlap()
@@ -937,7 +937,7 @@ void tst_QThread::adoptMultipleThreadsOverlap()
 
     QTestEventLoop::instance().enterLoop(5);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(recorder.activationCount.load(), numThreads);
+    QCOMPARE(recorder.activationCount.loadRelaxed(), numThreads);
 }
 
 // Disconnects on WinCE
@@ -1208,7 +1208,7 @@ class DummyEventDispatcher : public QAbstractEventDispatcher {
 public:
     DummyEventDispatcher() : QAbstractEventDispatcher() {}
     bool processEvents(QEventLoop::ProcessEventsFlags) {
-        visited.store(true);
+        visited.storeRelaxed(true);
         emit awake();
         QCoreApplication::sendPostedEvents();
         return false;
@@ -1270,7 +1270,7 @@ void tst_QThread::customEventDispatcher()
     QMetaObject::invokeMethod(&obj, "visit", Qt::QueuedConnection);
     loop.exec();
     // test that the ED has really been used
-    QVERIFY(ed->visited.load());
+    QVERIFY(ed->visited.loadRelaxed());
 
     QPointer<DummyEventDispatcher> weak_ed(ed);
     QVERIFY(!weak_ed.isNull());
diff --git a/tests/auto/corelib/thread/qthreadonce/tst_qthreadonce.cpp b/tests/auto/corelib/thread/qthreadonce/tst_qthreadonce.cpp
index a9af182ed8..710288af9e 100644
--- a/tests/auto/corelib/thread/qthreadonce/tst_qthreadonce.cpp
+++ b/tests/auto/corelib/thread/qthreadonce/tst_qthreadonce.cpp
@@ -56,7 +56,7 @@ class SingletonObject: public QObject
     Q_OBJECT
 public:
     static int runCount;
-    SingletonObject() { val.store(42); ++runCount; }
+    SingletonObject() { val.storeRelaxed(42); ++runCount; }
     ~SingletonObject() { }
 
     QBasicAtomicInt val;
@@ -112,7 +112,7 @@ void tst_QThreadOnce::sameThread()
     QCOMPARE(controlVariable, 1);
 
     static QSingleton<SingletonObject> s;
-    QTEST((int)s->val.load(), "expectedValue");
+    QTEST((int)s->val.loadRelaxed(), "expectedValue");
     s->val.ref();
 
     QCOMPARE(SingletonObject::runCount, 1);
@@ -134,7 +134,7 @@ void tst_QThreadOnce::multipleThreads()
 
     QCOMPARE(controlVariable, 0); // nothing must have set them yet
     SingletonObject::runCount = 0;
-    IncrementThread::runCount.store(0);
+    IncrementThread::runCount.storeRelaxed(0);
 
     // wait for all of them to be ready
     sem2.acquire(NumberOfThreads);
@@ -145,7 +145,7 @@ void tst_QThreadOnce::multipleThreads()
     delete parent;
 
     QCOMPARE(controlVariable, 1);
-    QCOMPARE((int)IncrementThread::runCount.load(), NumberOfThreads);
+    QCOMPARE((int)IncrementThread::runCount.loadRelaxed(), NumberOfThreads);
     QCOMPARE(SingletonObject::runCount, 1);
 }
 
diff --git a/tests/auto/corelib/thread/qthreadpool/tst_qthreadpool.cpp b/tests/auto/corelib/thread/qthreadpool/tst_qthreadpool.cpp
index f41cbe2601..112c36952c 100644
--- a/tests/auto/corelib/thread/qthreadpool/tst_qthreadpool.cpp
+++ b/tests/auto/corelib/thread/qthreadpool/tst_qthreadpool.cpp
@@ -220,16 +220,16 @@ class TestTask : public QRunnable
 public:
     void run()
     {
-        ran.store(true);
+        ran.storeRelaxed(true);
     }
 };
 
 void tst_QThreadPool::runTask()
 {
     QThreadPool manager;
-    ran.store(false);
+    ran.storeRelaxed(false);
     manager.start(new TestTask());
-    QTRY_VERIFY(ran.load());
+    QTRY_VERIFY(ran.loadRelaxed());
 }
 
 /*
@@ -237,9 +237,9 @@ void tst_QThreadPool::runTask()
 */
 void tst_QThreadPool::singleton()
 {
-    ran.store(false);
+    ran.storeRelaxed(false);
     QThreadPool::globalInstance()->start(new TestTask());
-    QTRY_VERIFY(ran.load());
+    QTRY_VERIFY(ran.loadRelaxed());
 }
 
 QAtomicInt *value = 0;
@@ -344,7 +344,7 @@ void tst_QThreadPool::expiryTimeout()
     // run the task
     threadPool.start(&task);
     QVERIFY(task.semaphore.tryAcquire(1, 10000));
-    QCOMPARE(task.runCount.load(), 1);
+    QCOMPARE(task.runCount.loadRelaxed(), 1);
     QVERIFY(!task.thread->wait(100));
     // thread should expire
     QThread *firstThread = task.thread;
@@ -353,7 +353,7 @@ void tst_QThreadPool::expiryTimeout()
     // run task again, thread should be restarted
     threadPool.start(&task);
     QVERIFY(task.semaphore.tryAcquire(1, 10000));
-    QCOMPARE(task.runCount.load(), 2);
+    QCOMPARE(task.runCount.loadRelaxed(), 2);
     QVERIFY(!task.thread->wait(100));
     // thread should expire again
     QVERIFY(task.thread->wait(10000));
@@ -382,7 +382,7 @@ void tst_QThreadPool::expiryTimeoutRace() // QTBUG-3786
         QThread::msleep(50); // exactly the same as the expiry timeout
     }
     QVERIFY(task.semaphore.tryAcquire(numTasks, 10000));
-    QCOMPARE(task.runCount.load(), numTasks);
+    QCOMPARE(task.runCount.loadRelaxed(), numTasks);
     QVERIFY(threadPool.waitForDone(2000));
 }
 
@@ -685,7 +685,7 @@ void tst_QThreadPool::reserveAndStart() // QTBUG-21051
     QCOMPARE(threadpool->activeThreadCount(), 2);
     task->waitForStarted.acquire();
     task->waitBeforeDone.release();
-    QTRY_COMPARE(task->count.load(), 1);
+    QTRY_COMPARE(task->count.loadRelaxed(), 1);
     QTRY_COMPARE(threadpool->activeThreadCount(), 1);
 
     // now the thread is waiting, but tryStart() will fail since activeThreadCount() >= maxThreadCount()
@@ -698,7 +698,7 @@ void tst_QThreadPool::reserveAndStart() // QTBUG-21051
     QTRY_COMPARE(threadpool->activeThreadCount(), 2);
     task->waitForStarted.acquire();
     task->waitBeforeDone.release();
-    QTRY_COMPARE(task->count.load(), 2);
+    QTRY_COMPARE(task->count.loadRelaxed(), 2);
     QTRY_COMPARE(threadpool->activeThreadCount(), 1);
 
     threadpool->releaseThread();
@@ -721,14 +721,14 @@ class CountingRunnable : public QRunnable
 void tst_QThreadPool::start()
 {
     const int runs = 1000;
-    count.store(0);
+    count.storeRelaxed(0);
     {
         QThreadPool threadPool;
         for (int i = 0; i< runs; ++i) {
             threadPool.start(new CountingRunnable());
         }
     }
-    QCOMPARE(count.load(), runs);
+    QCOMPARE(count.loadRelaxed(), runs);
 }
 
 void tst_QThreadPool::tryStart()
@@ -747,7 +747,7 @@ void tst_QThreadPool::tryStart()
         }
     };
 
-    count.store(0);
+    count.storeRelaxed(0);
 
     WaitingTask task;
     QThreadPool threadPool;
@@ -757,7 +757,7 @@ void tst_QThreadPool::tryStart()
     QVERIFY(!threadPool.tryStart(&task));
     task.semaphore.release(threadPool.maxThreadCount());
     threadPool.waitForDone();
-    QCOMPARE(count.load(), threadPool.maxThreadCount());
+    QCOMPARE(count.loadRelaxed(), threadPool.maxThreadCount());
 }
 
 QMutex mutex;
@@ -775,7 +775,7 @@ void tst_QThreadPool::tryStartPeakThreadCount()
             {
                 QMutexLocker lock(&mutex);
                 activeThreads.ref();
-                peakActiveThreads.store(qMax(peakActiveThreads.load(), activeThreads.load()));
+                peakActiveThreads.storeRelaxed(qMax(peakActiveThreads.loadRelaxed(), activeThreads.loadRelaxed()));
             }
 
             QTest::qWait(100);
@@ -793,13 +793,13 @@ void tst_QThreadPool::tryStartPeakThreadCount()
         if (threadPool.tryStart(&task) == false)
             QTest::qWait(10);
     }
-    QCOMPARE(peakActiveThreads.load(), QThread::idealThreadCount());
+    QCOMPARE(peakActiveThreads.loadRelaxed(), QThread::idealThreadCount());
 
     for (int i = 0; i < 20; ++i) {
         if (threadPool.tryStart(&task) == false)
             QTest::qWait(10);
     }
-    QCOMPARE(peakActiveThreads.load(), QThread::idealThreadCount());
+    QCOMPARE(peakActiveThreads.loadRelaxed(), QThread::idealThreadCount());
 }
 
 void tst_QThreadPool::tryStartCount()
@@ -877,7 +877,7 @@ void tst_QThreadPool::priorityStart()
 
     sem.release();
     QVERIFY(threadPool.waitForDone());
-    QCOMPARE(firstStarted.load(), expected);
+    QCOMPARE(firstStarted.loadRelaxed(), expected);
 }
 
 void tst_QThreadPool::waitForDone()
@@ -888,16 +888,16 @@ void tst_QThreadPool::waitForDone()
     QThreadPool threadPool;
     while (total.elapsed() < 10000) {
         int runs;
-        count.store(runs = 0);
+        count.storeRelaxed(runs = 0);
         pass.restart();
         while (pass.elapsed() < 100) {
             threadPool.start(new CountingRunnable());
             ++runs;
         }
         threadPool.waitForDone();
-        QCOMPARE(count.load(), runs);
+        QCOMPARE(count.loadRelaxed(), runs);
 
-        count.store(runs = 0);
+        count.storeRelaxed(runs = 0);
         pass.restart();
         while (pass.elapsed() < 100) {
             threadPool.start(new CountingRunnable());
@@ -905,7 +905,7 @@ void tst_QThreadPool::waitForDone()
             runs += 2;
         }
         threadPool.waitForDone();
-        QCOMPARE(count.load(), runs);
+        QCOMPARE(count.loadRelaxed(), runs);
     }
 }
 
@@ -953,14 +953,14 @@ void tst_QThreadPool::clear()
     QThreadPool threadPool;
     threadPool.setMaxThreadCount(10);
     int runs = 2 * threadPool.maxThreadCount();
-    count.store(0);
+    count.storeRelaxed(0);
     for (int i = 0; i <= runs; i++) {
         threadPool.start(new BlockingRunnable(sem));
     }
     threadPool.clear();
     sem.release(threadPool.maxThreadCount());
     threadPool.waitForDone();
-    QCOMPARE(count.load(), threadPool.maxThreadCount());
+    QCOMPARE(count.loadRelaxed(), threadPool.maxThreadCount());
 }
 
 void tst_QThreadPool::cancel()
@@ -1008,7 +1008,7 @@ void tst_QThreadPool::cancel()
     // and cause an early return:
     const QSemaphoreReleaser semReleaser(sem, runs);
 
-    count.store(0);
+    count.storeRelaxed(0);
     QAtomicInt dtorCounter = 0;
     QAtomicInt runCounter = 0;
     for (int i = 0; i < runs; i++) {
@@ -1025,12 +1025,12 @@ void tst_QThreadPool::cancel()
     }
     runnables[0]->dummy = 0; //valgrind will catch this if cancel() is crazy enough to delete currently running jobs
     runnables[runs-1]->dummy = 0;
-    QCOMPARE(dtorCounter.load(), runs - threadPool.maxThreadCount() - 1);
+    QCOMPARE(dtorCounter.loadRelaxed(), runs - threadPool.maxThreadCount() - 1);
     sem.release(threadPool.maxThreadCount());
     threadPool.waitForDone();
-    QCOMPARE(runCounter.load(), threadPool.maxThreadCount());
-    QCOMPARE(count.load(), threadPool.maxThreadCount());
-    QCOMPARE(dtorCounter.load(), runs - 2);
+    QCOMPARE(runCounter.loadRelaxed(), threadPool.maxThreadCount());
+    QCOMPARE(count.loadRelaxed(), threadPool.maxThreadCount());
+    QCOMPARE(dtorCounter.loadRelaxed(), runs - 2);
     delete runnables[0]; //if the pool deletes them then we'll get double-free crash
     delete runnables[runs-1];
 }
@@ -1080,7 +1080,7 @@ void tst_QThreadPool::tryTake()
     // and cause an early return:
     const QSemaphoreReleaser semReleaser(sem, Runs);
 
-    count.store(0);
+    count.storeRelaxed(0);
     QAtomicInt dtorCounter = 0;
     QAtomicInt runCounter = 0;
     for (int i = 0; i < Runs; i++) {
@@ -1102,12 +1102,12 @@ void tst_QThreadPool::tryTake()
     }
 
     runnables[0]->dummy = 0; // valgrind will catch this if tryTake() is crazy enough to delete currently running jobs
-    QCOMPARE(dtorCounter.load(), int(Runs - MaxThreadCount));
+    QCOMPARE(dtorCounter.loadRelaxed(), int(Runs - MaxThreadCount));
     sem.release(MaxThreadCount);
     threadPool.waitForDone();
-    QCOMPARE(runCounter.load(), int(MaxThreadCount));
-    QCOMPARE(count.load(), int(MaxThreadCount));
-    QCOMPARE(dtorCounter.load(), int(Runs - 1));
+    QCOMPARE(runCounter.loadRelaxed(), int(MaxThreadCount));
+    QCOMPARE(count.loadRelaxed(), int(MaxThreadCount));
+    QCOMPARE(dtorCounter.loadRelaxed(), int(Runs - 1));
     delete runnables[0]; // if the pool deletes them then we'll get double-free crash
 }
 
@@ -1118,7 +1118,7 @@ void tst_QThreadPool::destroyingWaitsForTasksToFinish()
 
     while (total.elapsed() < 10000) {
         int runs;
-        count.store(runs = 0);
+        count.storeRelaxed(runs = 0);
         {
             QThreadPool threadPool;
             pass.restart();
@@ -1127,9 +1127,9 @@ void tst_QThreadPool::destroyingWaitsForTasksToFinish()
                 ++runs;
             }
         }
-        QCOMPARE(count.load(), runs);
+        QCOMPARE(count.loadRelaxed(), runs);
 
-        count.store(runs = 0);
+        count.storeRelaxed(runs = 0);
         {
             QThreadPool threadPool;
             pass.restart();
@@ -1139,7 +1139,7 @@ void tst_QThreadPool::destroyingWaitsForTasksToFinish()
                 runs += 2;
             }
         }
-        QCOMPARE(count.load(), runs);
+        QCOMPARE(count.loadRelaxed(), runs);
     }
 }
 
diff --git a/tests/auto/corelib/thread/qthreadstorage/tst_qthreadstorage.cpp b/tests/auto/corelib/thread/qthreadstorage/tst_qthreadstorage.cpp
index ef5d3452d5..3538d90803 100644
--- a/tests/auto/corelib/thread/qthreadstorage/tst_qthreadstorage.cpp
+++ b/tests/auto/corelib/thread/qthreadstorage/tst_qthreadstorage.cpp
@@ -359,7 +359,7 @@ void tst_QThreadStorage::leakInDestructor()
             QVERIFY(tls.hasLocalData());
         }
     };
-    int c = SPointer::count.load();
+    int c = SPointer::count.loadRelaxed();
 
     QThreadStorage<ThreadStorageLocalDataTester *> tls;
 
@@ -383,7 +383,7 @@ void tst_QThreadStorage::leakInDestructor()
     QVERIFY(t3.wait());
 
     //check all the constructed things have been destructed
-    QCOMPARE(int(SPointer::count.load()), c);
+    QCOMPARE(int(SPointer::count.loadRelaxed()), c);
 }
 
 class ThreadStorageResetLocalDataTester {
@@ -411,7 +411,7 @@ void tst_QThreadStorage::resetInDestructor()
             QVERIFY(ThreadStorageResetLocalDataTesterTls()->hasLocalData());
         }
     };
-    int c = SPointer::count.load();
+    int c = SPointer::count.loadRelaxed();
 
     Thread t1;
     Thread t2;
@@ -424,7 +424,7 @@ void tst_QThreadStorage::resetInDestructor()
     QVERIFY(t3.wait());
 
     //check all the constructed things have been destructed
-    QCOMPARE(int(SPointer::count.load()), c);
+    QCOMPARE(int(SPointer::count.loadRelaxed()), c);
 }
 
 
@@ -475,7 +475,7 @@ void tst_QThreadStorage::valueBased()
     QThreadStorage<QString> tlsString;
     QThreadStorage<int> tlsInt;
 
-    int c = SPointer::count.load();
+    int c = SPointer::count.loadRelaxed();
 
     Thread t1(tlsSPointer, tlsString, tlsInt);
     Thread t2(tlsSPointer, tlsString, tlsInt);
@@ -495,7 +495,7 @@ void tst_QThreadStorage::valueBased()
     QVERIFY(t2.wait());
     QVERIFY(t3.wait());
 
-    QCOMPARE(c, int(SPointer::count.load()));
+    QCOMPARE(c, int(SPointer::count.loadRelaxed()));
 
 }
 
diff --git a/tests/auto/corelib/thread/qwaitcondition/tst_qwaitcondition.cpp b/tests/auto/corelib/thread/qwaitcondition/tst_qwaitcondition.cpp
index 126cb6b180..5363231895 100644
--- a/tests/auto/corelib/thread/qwaitcondition/tst_qwaitcondition.cpp
+++ b/tests/auto/corelib/thread/qwaitcondition/tst_qwaitcondition.cpp
@@ -481,7 +481,7 @@ void tst_QWaitCondition::wakeOne()
         }
         mutex.unlock();
 
-        QCOMPARE(count.load(), ThreadCount);
+        QCOMPARE(count.loadRelaxed(), ThreadCount);
 
         // wake up threads one at a time
         for (x = 0; x < ThreadCount; ++x) {
@@ -502,10 +502,10 @@ void tst_QWaitCondition::wakeOne()
             }
 
             QCOMPARE(exited, 1);
-            QCOMPARE(count.load(), ThreadCount - (x + 1));
+            QCOMPARE(count.loadRelaxed(), ThreadCount - (x + 1));
         }
 
-        QCOMPARE(count.load(), 0);
+        QCOMPARE(count.loadRelaxed(), 0);
 
         // QReadWriteLock
         QReadWriteLock readWriteLock;
@@ -530,7 +530,7 @@ void tst_QWaitCondition::wakeOne()
         }
         readWriteLock.unlock();
 
-        QCOMPARE(count.load(), ThreadCount);
+        QCOMPARE(count.loadRelaxed(), ThreadCount);
 
         // wake up threads one at a time
         for (x = 0; x < ThreadCount; ++x) {
@@ -551,10 +551,10 @@ void tst_QWaitCondition::wakeOne()
             }
 
             QCOMPARE(exited, 1);
-            QCOMPARE(count.load(), ThreadCount - (x + 1));
+            QCOMPARE(count.loadRelaxed(), ThreadCount - (x + 1));
         }
 
-        QCOMPARE(count.load(), 0);
+        QCOMPARE(count.loadRelaxed(), 0);
     }
 
     // wake up threads, two at a time
@@ -585,7 +585,7 @@ void tst_QWaitCondition::wakeOne()
         }
         mutex.unlock();
 
-        QCOMPARE(count.load(), ThreadCount);
+        QCOMPARE(count.loadRelaxed(), ThreadCount);
 
         // wake up threads one at a time
         for (x = 0; x < ThreadCount; x += 2) {
@@ -608,10 +608,10 @@ void tst_QWaitCondition::wakeOne()
             }
 
             QCOMPARE(exited, 2);
-            QCOMPARE(count.load(), ThreadCount - (x + 2));
+            QCOMPARE(count.loadRelaxed(), ThreadCount - (x + 2));
         }
 
-        QCOMPARE(count.load(), 0);
+        QCOMPARE(count.loadRelaxed(), 0);
 
         // QReadWriteLock
         QReadWriteLock readWriteLock;
@@ -636,7 +636,7 @@ void tst_QWaitCondition::wakeOne()
         }
         readWriteLock.unlock();
 
-        QCOMPARE(count.load(), ThreadCount);
+        QCOMPARE(count.loadRelaxed(), ThreadCount);
 
         // wake up threads one at a time
         for (x = 0; x < ThreadCount; x += 2) {
@@ -659,10 +659,10 @@ void tst_QWaitCondition::wakeOne()
             }
 
             QCOMPARE(exited, 2);
-            QCOMPARE(count.load(), ThreadCount - (x + 2));
+            QCOMPARE(count.loadRelaxed(), ThreadCount - (x + 2));
         }
 
-        QCOMPARE(count.load(), 0);
+        QCOMPARE(count.loadRelaxed(), 0);
     }
 }
 
@@ -692,7 +692,7 @@ void tst_QWaitCondition::wakeAll()
         }
         mutex.unlock();
 
-        QCOMPARE(count.load(), ThreadCount);
+        QCOMPARE(count.loadRelaxed(), ThreadCount);
 
         // wake up all threads at once
         mutex.lock();
@@ -707,7 +707,7 @@ void tst_QWaitCondition::wakeAll()
         }
 
         QCOMPARE(exited, ThreadCount);
-        QCOMPARE(count.load(), 0);
+        QCOMPARE(count.loadRelaxed(), 0);
 
         // QReadWriteLock
         QReadWriteLock readWriteLock;
@@ -728,7 +728,7 @@ void tst_QWaitCondition::wakeAll()
         }
         readWriteLock.unlock();
 
-        QCOMPARE(count.load(), ThreadCount);
+        QCOMPARE(count.loadRelaxed(), ThreadCount);
 
         // wake up all threads at once
         readWriteLock.lockForWrite();
@@ -743,7 +743,7 @@ void tst_QWaitCondition::wakeAll()
         }
 
         QCOMPARE(exited, ThreadCount);
-        QCOMPARE(count.load(), 0);
+        QCOMPARE(count.loadRelaxed(), 0);
     }
 }