Changeset 769 for trunk/src/corelib/arch

Timestamp:

Aug 2, 2010, 9:27:30 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.3 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/corelib/arch/armv6/qatomic_generic_armv6.cpp (modified) (14 diffs)
• src/corelib/arch/qatomic_alpha.h (modified) (6 diffs)
• src/corelib/arch/qatomic_s390.h (modified) (3 diffs)
• src/corelib/arch/qatomic_symbian.h (modified) (17 diffs)
• src/corelib/arch/sparc/arch.pri (modified) (1 diff)
• src/corelib/arch/symbian/qatomic_symbian.cpp (modified) (9 diffs)

trunk/src/corelib/arch/armv6/qatomic_generic_armv6.cpp

@@ -47 +47 @@
 
 #ifdef QT_HAVE_ARMV6
+
 
 QT_BEGIN_NAMESPACE
@@ -55 +56 @@
 #pragma push
 #pragma arm
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Q_CORE_EXPORT asm
 bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
@@ -74 +93 @@
 
 Q_CORE_EXPORT asm
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
 {
@@ -88 +125 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Q_CORE_EXPORT asm
 int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
@@ -105 +160 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Q_CORE_EXPORT asm
 bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
@@ -126 +205 @@
 
 Q_CORE_EXPORT asm
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
 {
@@ -140 +237 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Q_CORE_EXPORT asm
 void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
@@ -159 +274 @@
 #pragma pop
 #elif defined (Q_CC_GCCE)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Q_CORE_EXPORT __declspec( naked )
 bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
@@ -177 +307 @@
 
 Q_CORE_EXPORT __declspec( naked )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
 {
@@ -190 +335 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Q_CORE_EXPORT __declspec( naked )
 int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
@@ -206 +366 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Q_CORE_EXPORT __declspec( naked )
 bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
@@ -226 +407 @@
 
 Q_CORE_EXPORT __declspec( naked )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
 {
@@ -239 +435 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Q_CORE_EXPORT __declspec( naked )
 void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
@@ -259 +470 @@
 QT_END_NAMESPACE
 #endif
+

trunk/src/corelib/arch/qatomic_alpha.h

@@ -368 +368 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
 {
-    register void *old, *tmp;
+    register  *old, *tmp;
     asm volatile("1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
@@ -386 +386 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
 {
-    register void *old, *tmp;
+    register  *old, *tmp;
     asm volatile("1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
@@ -405 +405 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
 {
-    register void *old, *tmp;
+    register  *old, *tmp;
     asm volatile("mb\n"
                  "1:\n"
@@ -424 +424 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
 {
-    register void *old, *tmp;
+    register  *old, *tmp;
     asm volatile("1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
@@ -442 +442 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
 {
-    register void *old, *tmp;
+    register  *old, *tmp;
     asm volatile("1:\n"
                  "ldq_l %0,%2\n"   /* old=*ptr;                               */
@@ -461 +461 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
 {
-    register void *old, *tmp;
+    register  *old, *tmp;
     asm volatile("mb\n"
                  "1:\n"

trunk/src/corelib/arch/qatomic_s390.h

@@ -367 +367 @@
 {
 #ifndef __s390x__
-    return (T*)__CS_OLD_LOOP(reinterpret_cast<volatile long*>(_q_value), (int)newValue, "lr",
-                             "", "bcr 15,0\n");
-#else
-    return (T*)__CSG_OLD_LOOP(reinterpret_cast<volatile long*>(_q_value), (long)newValue, "lgr",
-                              "", "bcr 15,0\n");
+    return (T*)__CS_OLD_LOOP(&_q_value, (int)newValue, "lr", "", "");
+#else
+    return (T*)__CSG_OLD_LOOP(&_q_value, (long)newValue, "lgr", "", "");
 #endif
 }
@@ -379 +377 @@
 {
 #ifndef __s390x__
-    return (T*)__CS_OLD_LOOP(reinterpret_cast<volatile long*>(_q_value), (int)newValue, "lr", "", "");
-#else
-    return (T*)__CSG_OLD_LOOP(reinterpret_cast<volatile long*>(_q_value), (long)newValue, "lgr", "", "");
+    return (T*)__CS_OLD_LOOP(");
+#else
+    return (T*)__CSG_OLD_LOOP(");
 #endif
 }
@@ -389 +387 @@
 {
 #ifndef __s390x__
-    return (T*)__CS_OLD_LOOP(reinterpret_cast<volatile long*>(_q_value), (int)newValue, "lr",
-                             "bcr 15,0 \n", "");
-#else
-    return (T*)__CSG_OLD_LOOP(reinterpret_cast<volatile long*>(_q_value), (long)newValue, "lgr",
-                              "bcr 15,0\n", "");
+    return (T*)__CS_OLD_LOOP(&_q_value, (int)newValue, "lr", "bcr 15,0 \n", "");
+#else
+    return (T*)__CSG_OLD_LOOP(&_q_value, (long)newValue, "lgr", "bcr 15,0\n", "");
 #endif
 }

trunk/src/corelib/arch/qatomic_symbian.h

@@ -43 +43 @@
 #define QATOMIC_SYMBIAN_H
 
-#include <qglobal.h>
+#include <qglobal.h>
 #include <e32std.h>
 
@@ -105 +105 @@
 Q_CORE_EXPORT int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *, int);
 Q_CORE_EXPORT int QBasicAtomicInt_fetchAndAddOrdered(volatile int *, int);
+
+
+
+
+
+
+
+
+
 
 Q_CORE_EXPORT bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *, void *, void *);
 Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *, void *);
 Q_CORE_EXPORT void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *, qptrdiff);
+
+
+
+
+
+
+
+
+
 
 // Reference counting
@@ -134 +152 @@
 inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
 {
-    return testAndSetOrdered(expectedValue, newValue);
+    return expectedValue, newValue);
 }
 
 inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
 {
-    return testAndSetOrdered(expectedValue, newValue);
+    return expectedValue, newValue);
 }
 
 inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
 {
-    return testAndSetOrdered(expectedValue, newValue);
+    return expectedValue, newValue);
 }
 
@@ -156 +174 @@
 inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
 {
-    return fetchAndStoreOrdered(newValue);
+    return newValue);
 }
 
 inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
 {
-    return fetchAndStoreOrdered(newValue);
+    return newValue);
 }
 
 inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
 {
-    return fetchAndStoreOrdered(newValue);
+    return newValue);
 }
 
@@ -178 +196 @@
 inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
 {
-    return fetchAndAddOrdered(valueToAdd);
+    return valueToAdd);
 }
 
 inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
 {
-    return fetchAndAddOrdered(valueToAdd);
+    return valueToAdd);
 }
 
 inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
 {
-    return fetchAndAddOrdered(valueToAdd);
+    return valueToAdd);
 }
 
@@ -196 +214 @@
 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
 {
-    union { T * volatile * typed; void * volatile * voidp; } pointer;
-    pointer.typed = &_q_value;
-    return QBasicAtomicPointer_testAndSetOrdered(pointer.voidp, expectedValue, newValue);
+    return QBasicAtomicPointer_testAndSetOrdered(reinterpret_cast<void * volatile *>(&_q_value),
+        expectedValue, newValue);
 }
 
@@ -204 +221 @@
 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
 {
-    return testAndSetOrdered(expectedValue, newValue);
+    return QBasicAtomicPointer_testAndSetRelaxed(reinterpret_cast<void * volatile *>(&_q_value),
+        expectedValue, newValue);
 }
 
@@ -210 +228 @@
 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
 {
-    return testAndSetOrdered(expectedValue, newValue);
+    return QBasicAtomicPointer_testAndSetAcquire(reinterpret_cast<void * volatile *>(&_q_value),
+        expectedValue, newValue);
 }
 
@@ -216 +235 @@
 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
 {
-    return testAndSetOrdered(expectedValue, newValue);
+    return QBasicAtomicPointer_testAndSetRelease(reinterpret_cast<void * volatile *>(&_q_value),
+        expectedValue, newValue);
 }
 
@@ -224 +244 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
 {
-    union { T * volatile * typed; void * volatile * voidp; } pointer;
-    union { T *typed; void *voidp; } returnValue;
-    pointer.typed = &_q_value;
-    returnValue.voidp = QBasicAtomicPointer_fetchAndStoreOrdered(pointer.voidp, newValue);
-    return returnValue.typed;
+    return static_cast<T*>(QBasicAtomicPointer_fetchAndStoreOrdered(
+        reinterpret_cast<void * volatile *>(&_q_value)
+        , newValue));
 }
 
@@ -234 +252 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
 {
-    return fetchAndStoreOrdered(newValue);
+    return static_cast<T*>(QBasicAtomicPointer_fetchAndStoreRelaxed(
+        reinterpret_cast<void * volatile *>(&_q_value)
+        , newValue));
 }
 
@@ -240 +260 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
 {
-    return fetchAndStoreOrdered(newValue);
+    return static_cast<T*>(QBasicAtomicPointer_fetchAndStoreAcquire(
+        reinterpret_cast<void * volatile *>(&_q_value)
+        , newValue));
 }
 
@@ -246 +268 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
 {
-    return fetchAndStoreOrdered(newValue);
+    return static_cast<T*>(QBasicAtomicPointer_fetchAndStoreRelease(
+        reinterpret_cast<void * volatile *>(&_q_value)
+        , newValue));
 }
 
@@ -254 +278 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
 {
-    union { T * volatile *typed; void * volatile *voidp; } pointer;
-    union { T *typed; void *voidp; } returnValue;
-    pointer.typed = &_q_value;
-    returnValue.voidp = QBasicAtomicPointer_fetchAndAddOrdered(pointer.voidp, valueToAdd * sizeof(T));
-    return returnValue.typed;
+    return static_cast<T*>(QBasicAtomicPointer_fetchAndAddOrdered(
+        reinterpret_cast<void * volatile *>(&_q_value),
+        valueToAdd * sizeof(T)));
 }
 
@@ -264 +286 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
 {
-    return fetchAndAddOrdered(valueToAdd);
+    return static_cast<T*>(QBasicAtomicPointer_fetchAndAddRelaxed(
+        reinterpret_cast<void * volatile *>(&_q_value),
+        valueToAdd * sizeof(T)));
 }
 
@@ -270 +294 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
 {
-    return fetchAndAddOrdered(valueToAdd);
+    return static_cast<T*>(QBasicAtomicPointer_fetchAndAddAcquire(
+        reinterpret_cast<void * volatile *>(&_q_value),
+        valueToAdd * sizeof(T)));
 }
 
@@ -276 +302 @@
 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
 {
-    return fetchAndAddOrdered(valueToAdd);
+    return static_cast<T*>(QBasicAtomicPointer_fetchAndAddRelease(
+        reinterpret_cast<void * volatile *>(&_q_value),
+        valueToAdd * sizeof(T)));
 }
 

trunk/src/corelib/arch/sparc/arch.pri

@@ -2 +2 @@
 # SPARC architecture
 #
-*-64 {
+*-64 {
     SOURCES += $$QT_ARCH_CPP/qatomic64.s
 } 

trunk/src/corelib/arch/symbian/qatomic_symbian.cpp

@@ -42 +42 @@
 #include <QtCore/qglobal.h>
 #include <QtCore/qatomic.h>
+
+
+
+
 
 #include <e32debug.h>
@@ -80 +84 @@
 Q_CORE_EXPORT bool QBasicAtomicInt::isReferenceCountingNative()
 {
-#ifdef QT_HAVE_ARMV6
+#if
     return true;
 #else
@@ -89 +93 @@
 Q_CORE_EXPORT bool QBasicAtomicInt::isTestAndSetNative()
 {
-#ifdef QT_HAVE_ARMV6
+#if
     return true;
 #else
@@ -98 +102 @@
 Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndStoreNative()
 {
-#ifdef QT_HAVE_ARMV6
+#if
     return true;
 #else
@@ -107 +111 @@
 Q_CORE_EXPORT bool QBasicAtomicInt::isFetchAndAddNative()
 {
-#ifdef QT_HAVE_ARMV6
+#if
     return true;
 #else
@@ -116 +120 @@
 Q_CORE_EXPORT bool QBasicAtomicPointer_isTestAndSetNative()
 {
-#ifdef QT_HAVE_ARMV6
+#if
     return true;
 #else
@@ -125 +129 @@
 Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndStoreNative()
 {
-#ifdef QT_HAVE_ARMV6
+#if
     return true;
 #else
@@ -134 +138 @@
 Q_CORE_EXPORT bool QBasicAtomicPointer_isFetchAndAddNative()
 {
-#ifdef QT_HAVE_ARMV6
-    return true;
-#else
-    return false;
-#endif
-}
+#if !defined(SYMBIAN_E32_ATOMIC_API) && defined(QT_HAVE_ARMV6)
+    return true;
+#else
+    return false;
+#endif
+}
+
+#ifdef SYMBIAN_E32_ATOMIC_API
+//Symbian's API is SMP-safe when using SMP kernel, and cheap when using uniprocessor kernel
+
+//generate compiler error if casting assumptions are wrong (symbian64?)
+__ASSERT_COMPILE(sizeof(int) == sizeof(TUint32));
+__ASSERT_COMPILE(sizeof(void *) == sizeof(TUint32));
+
+Q_CORE_EXPORT
+bool QBasicAtomicInt_testAndSetOrdered(volatile int *_q_value, int expectedValue, int newValue)
+{
+    return static_cast<bool>(__e32_atomic_cas_ord32(_q_value,
+        reinterpret_cast<TUint32*>(&expectedValue), newValue));
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicInt_testAndSetRelaxed(volatile int *_q_value, int expectedValue, int newValue)
+{
+    return static_cast<bool>(__e32_atomic_cas_rlx32(_q_value,
+        reinterpret_cast<TUint32*>(&expectedValue), newValue));
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicInt_testAndSetAcquire(volatile int *_q_value, int expectedValue, int newValue)
+{
+    return static_cast<bool>(__e32_atomic_cas_acq32(_q_value,
+        reinterpret_cast<TUint32*>(&expectedValue), newValue));
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicInt_testAndSetRelease(volatile int *_q_value, int expectedValue, int newValue)
+{
+    return static_cast<bool>(__e32_atomic_cas_rel32(_q_value,
+        reinterpret_cast<TUint32*>(&expectedValue), newValue));
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *_q_value, int newValue)
+{
+    return static_cast<int>(__e32_atomic_swp_ord32(_q_value, newValue));
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndStoreRelaxed(volatile int *_q_value, int newValue)
+{
+    return static_cast<int>(__e32_atomic_swp_rlx32(_q_value, newValue));
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndStoreAcquire(volatile int *_q_value, int newValue)
+{
+    return static_cast<int>(__e32_atomic_swp_acq32(_q_value, newValue));
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndStoreRelease(volatile int *_q_value, int newValue)
+{
+    return static_cast<int>(__e32_atomic_swp_rel32(_q_value, newValue));
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndAddOrdered(volatile int *_q_value, int valueToAdd)
+{
+    return static_cast<int>(__e32_atomic_add_ord32(_q_value, valueToAdd));
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndAddRelaxed(volatile int *_q_value, int valueToAdd)
+{
+    return static_cast<int>(__e32_atomic_add_rlx32(_q_value, valueToAdd));
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndAddAcquire(volatile int *_q_value, int valueToAdd)
+{
+    return static_cast<int>(__e32_atomic_add_acq32(_q_value, valueToAdd));
+}
+
+Q_CORE_EXPORT
+int QBasicAtomicInt_fetchAndAddRelease(volatile int *_q_value, int valueToAdd)
+{
+    return static_cast<int>(__e32_atomic_add_rel32(_q_value, valueToAdd));
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    return static_cast<bool>(__e32_atomic_cas_ord_ptr(_q_value,
+        &expectedValue,
+        newValue));
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicPointer_testAndSetRelaxed(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    return static_cast<bool>(__e32_atomic_cas_rlx_ptr(_q_value,
+        &expectedValue,
+        newValue));
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicPointer_testAndSetAcquire(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    return static_cast<bool>(__e32_atomic_cas_acq_ptr(_q_value,
+        &expectedValue,
+        newValue));
+}
+
+Q_CORE_EXPORT
+bool QBasicAtomicPointer_testAndSetRelease(void * volatile *_q_value,
+                                           void *expectedValue,
+                                           void *newValue)
+{
+    return static_cast<bool>(__e32_atomic_cas_rel_ptr(_q_value,
+        &expectedValue,
+        newValue));
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *_q_value, void *newValue)
+{
+    return __e32_atomic_swp_ord_ptr(_q_value, newValue);
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndStoreRelaxed(void * volatile *_q_value, void *newValue)
+{
+    return __e32_atomic_swp_rlx_ptr(_q_value, newValue);
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndStoreAcquire(void * volatile *_q_value, void *newValue)
+{
+    return __e32_atomic_swp_acq_ptr(_q_value, newValue);
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndStoreRelease(void * volatile *_q_value, void *newValue)
+{
+    return __e32_atomic_swp_rel_ptr(_q_value, newValue);
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    return __e32_atomic_add_ord_ptr(_q_value, valueToAdd);
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndAddRelaxed(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    return __e32_atomic_add_rlx_ptr(_q_value, valueToAdd);
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndAddAcquire(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    return __e32_atomic_add_acq_ptr(_q_value, valueToAdd);
+}
+
+Q_CORE_EXPORT
+void *QBasicAtomicPointer_fetchAndAddRelease(void * volatile *_q_value, qptrdiff valueToAdd)
+{
+    return __e32_atomic_add_rel_ptr(_q_value, valueToAdd);
+}
+
+#else
+//Symbian kernels 9.4 and earlier don't expose a suitable API
 
 //For ARMv6, the generic atomics are machine coded
@@ -230 +408 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 #endif // QT_HAVE_ARMV6
+
 
 QT_END_NAMESPACE