src/corelib/arch/qatomic_armv6.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtCore module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #ifndef QATOMIC_ARMV6_H
  43 #define QATOMIC_ARMV6_H
  44
  45 QT_BEGIN_HEADER
  46
  47 QT_BEGIN_NAMESPACE
  48 #define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE
  49
  50 inline bool QBasicAtomicInt::isReferenceCountingNative()
  51 { return true; }
  52 inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
  53 { return false; }
  54
  55 #define Q_ATOMIC_INT_TEST_AND_SET_IS_ALWAYS_NATIVE
  56
  57 inline bool QBasicAtomicInt::isTestAndSetNative()
  58 { return true; }
  59 inline bool QBasicAtomicInt::isTestAndSetWaitFree()
  60 { return false; }
  61
  62 #define Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE
  63
  64 inline bool QBasicAtomicInt::isFetchAndStoreNative()
  65 { return true; }
  66 inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
  67 { return false; }
  68
  69 #define Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE
  70
  71 inline bool QBasicAtomicInt::isFetchAndAddNative()
  72 { return true; }
  73 inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
  74 { return false; }
  75
  76 #define Q_ATOMIC_POINTER_TEST_AND_SET_IS_ALWAYS_NATIVE
  77
  78 template <typename T>
  79 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetNative()
  80 { return true; }
  81 template <typename T>
  82 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
  83 { return false; }
  84
  85 #define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_ALWAYS_NATIVE
  86
  87 template <typename T>
  88 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
  89 { return true; }
  90 template <typename T>
  91 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
  92 { return false; }
  93
  94 #define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_ALWAYS_NATIVE
  95
  96 template <typename T>
  97 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddNative()
  98 { return true; }
  99 template <typename T>
 100 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
 101 { return false; }
 102
 103 #ifndef Q_CC_RVCT
 104
 105 inline bool QBasicAtomicInt::ref()
 106 {
 107     register int newValue;
 108     register int result;
 109     asm volatile("0:\n"
 110                  "ldrex %[newValue], [%[_q_value]]\n"
 111                  "add %[newValue], %[newValue], #1\n"
 112                  "strex %[result], %[newValue], [%[_q_value]]\n"
 113                  "teq %[result], #0\n"
 114                  "bne 0b\n"
 115                  : [newValue] "=&r" (newValue),
 116                    [result] "=&r" (result),
 117                    "+m" (_q_value)
 118                  : [_q_value] "r" (&_q_value)
 119                  : "cc", "memory");
 120     return newValue != 0;
 121 }
 122
 123 inline bool QBasicAtomicInt::deref()
 124 {
 125     register int newValue;
 126     register int result;
 127     asm volatile("0:\n"
 128                  "ldrex %[newValue], [%[_q_value]]\n"
 129                  "sub %[newValue], %[newValue], #1\n"
 130                  "strex %[result], %[newValue], [%[_q_value]]\n"
 131                  "teq %[result], #0\n"
 132                  "bne 0b\n"
 133                  : [newValue] "=&r" (newValue),
 134                    [result] "=&r" (result),
 135                    "+m" (_q_value)
 136                  : [_q_value] "r" (&_q_value)
 137                  : "cc", "memory");
 138     return newValue != 0;
 139 }
 140
 141 inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
 142 {
 143     register int result;
 144     asm volatile("0:\n"
 145                  "ldrex %[result], [%[_q_value]]\n"
 146                  "eors %[result], %[result], %[expectedValue]\n"
 147                  "strexeq %[result], %[newValue], [%[_q_value]]\n"
 148                  "teqeq %[result], #1\n"
 149                  "beq 0b\n"
 150                  : [result] "=&r" (result),
 151                    "+m" (_q_value)
 152                  : [expectedValue] "r" (expectedValue),
 153                    [newValue] "r" (newValue),
 154                    [_q_value] "r" (&_q_value)
 155                  : "cc", "memory");
 156     return result == 0;
 157 }
 158
 159 inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
 160 {
 161     register int originalValue;
 162     register int result;
 163     asm volatile("0:\n"
 164                  "ldrex %[originalValue], [%[_q_value]]\n"
 165                  "strex %[result], %[newValue], [%[_q_value]]\n"
 166                  "teq %[result], #0\n"
 167                  "bne 0b\n"
 168                  : [originalValue] "=&r" (originalValue),
 169                    [result] "=&r" (result),
 170                    "+m" (_q_value)
 171                  : [newValue] "r" (newValue),
 172                    [_q_value] "r" (&_q_value)
 173                  : "cc", "memory");
 174     return originalValue;
 175 }
 176
 177 inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
 178 {
 179     register int originalValue;
 180     register int newValue;
 181     register int result;
 182     asm volatile("0:\n"
 183                  "ldrex %[originalValue], [%[_q_value]]\n"
 184                  "add %[newValue], %[originalValue], %[valueToAdd]\n"
 185                  "strex %[result], %[newValue], [%[_q_value]]\n"
 186                  "teq %[result], #0\n"
 187                  "bne 0b\n"
 188                  : [originalValue] "=&r" (originalValue),
 189                    [newValue] "=&r" (newValue),
 190                    [result] "=&r" (result),
 191                    "+m" (_q_value)
 192                  : [valueToAdd] "r" (valueToAdd),
 193                    [_q_value] "r" (&_q_value)
 194                  : "cc", "memory");
 195     return originalValue;
 196 }
 197
 198 template <typename T>
 199 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
 200 {
 201     register T *result;
 202     asm volatile("0:\n"
 203                  "ldrex %[result], [%[_q_value]]\n"
 204                  "eors %[result], %[result], %[expectedValue]\n"
 205                  "strexeq %[result], %[newValue], [%[_q_value]]\n"
 206                  "teqeq %[result], #1\n"
 207                  "beq 0b\n"
 208                  : [result] "=&r" (result),
 209                    "+m" (_q_value)
 210                  : [expectedValue] "r" (expectedValue),
 211                    [newValue] "r" (newValue),
 212                    [_q_value] "r" (&_q_value)
 213                  : "cc", "memory");
 214     return result == 0;
 215 }
 216
 217 template <typename T>
 218 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
 219 {
 220     register T *originalValue;
 221     register int result;
 222     asm volatile("0:\n"
 223                  "ldrex %[originalValue], [%[_q_value]]\n"
 224                  "strex %[result], %[newValue], [%[_q_value]]\n"
 225                  "teq %[result], #0\n"
 226                  "bne 0b\n"
 227                  : [originalValue] "=&r" (originalValue),
 228                    [result] "=&r" (result),
 229                    "+m" (_q_value)
 230                  : [newValue] "r" (newValue),
 231                    [_q_value] "r" (&_q_value)
 232                  : "cc", "memory");
 233     return originalValue;
 234 }
 235
 236 template <typename T>
 237 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
 238 {
 239     register T *originalValue;
 240     register T *newValue;
 241     register int result;
 242     asm volatile("0:\n"
 243                  "ldrex %[originalValue], [%[_q_value]]\n"
 244                  "add %[newValue], %[originalValue], %[valueToAdd]\n"
 245                  "strex %[result], %[newValue], [%[_q_value]]\n"
 246                  "teq %[result], #0\n"
 247                  "bne 0b\n"
 248                  : [originalValue] "=&r" (originalValue),
 249                    [newValue] "=&r" (newValue),
 250                    [result] "=&r" (result),
 251                    "+m" (_q_value)
 252                  : [valueToAdd] "r" (valueToAdd * sizeof(T)),
 253                    [_q_value] "r" (&_q_value)
 254                  : "cc", "memory");
 255     return originalValue;
 256 }
 257
 258 #else
 259 // This is Q_CC_RVCT
 260
 261 // RVCT inline assembly documentation:
 262 // http://www.keil.com/support/man/docs/armcc/armcc_chdcffdb.htm
 263 // RVCT embedded assembly documentation:
 264 // http://www.keil.com/support/man/docs/armcc/armcc_chddbeib.htm
 265
 266 // save our pragma state and switch to ARM mode
 267 #pragma push
 268 #pragma arm
 269
 270 inline bool QBasicAtomicInt::ref()
 271 {
 272     register int newValue;
 273     register int result;
 274     retry:
 275     __asm {
 276         ldrex   newValue, [&_q_value]
 277         add     newValue, newValue, #1
 278         strex   result, newValue, [&_q_value]
 279         teq     result, #0
 280         bne     retry
 281     }
 282     return newValue != 0;
 283 }
 284
 285 inline bool QBasicAtomicInt::deref()
 286 {
 287     register int newValue;
 288     register int result;
 289     retry:
 290     __asm {
 291         ldrex   newValue, [&_q_value]
 292         sub     newValue, newValue, #1
 293         strex   result, newValue, [&_q_value]
 294         teq     result, #0
 295         bne     retry
 296     }
 297     return newValue != 0;
 298 }
 299
 300 inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
 301 {
 302     register int result;
 303     retry:
 304     __asm {
 305         ldrex   result, [&_q_value]
 306         eors    result, result, expectedValue
 307         strexeq result, newValue, [&_q_value]
 308         teqeq   result, #1
 309         beq     retry
 310     }
 311     return result == 0;
 312 }
 313
 314 inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
 315 {
 316     register int originalValue;
 317     register int result;
 318     retry:
 319     __asm {
 320         ldrex   originalValue, [&_q_value]
 321         strex   result, newValue, [&_q_value]
 322         teq     result, #0
 323         bne     retry
 324     }
 325     return originalValue;
 326 }
 327
 328 inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
 329 {
 330     register int originalValue;
 331     register int newValue;
 332     register int result;
 333     retry:
 334     __asm {
 335         ldrex   originalValue, [&_q_value]
 336         add     newValue, originalValue, valueToAdd
 337         strex   result, newValue, [&_q_value]
 338         teq     result, #0
 339         bne     retry
 340     }
 341     return originalValue;
 342 }
 343
 344 template <typename T>
 345 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
 346 {
 347     register T *result;
 348     retry:
 349     __asm {
 350         ldrex   result, [&_q_value]
 351         eors    result, result, expectedValue
 352         strexeq result, newValue, [&_q_value]
 353         teqeq   result, #1
 354         beq     retry
 355     }
 356     return result == 0;
 357 }
 358
 359 template <typename T>
 360 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
 361 {
 362     register T *originalValue;
 363     register int result;
 364     retry:
 365     __asm {
 366         ldrex   originalValue, [&_q_value]
 367         strex   result, newValue, [&_q_value]
 368         teq     result, #0
 369         bne     retry
 370     }
 371     return originalValue;
 372 }
 373
 374 template <typename T>
 375 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
 376 {
 377     register T *originalValue;
 378     register T *newValue;
 379     register int result;
 380     retry:
 381     __asm {
 382         ldrex   originalValue, [&_q_value]
 383         add     newValue, originalValue, valueToAdd * sizeof(T)
 384         strex   result, newValue, [&_q_value]
 385         teq     result, #0
 386         bne     retry
 387     }
 388     return originalValue;
 389 }
 390
 391 // go back to the previous pragma state (probably Thumb mode)
 392 #pragma pop
 393 #endif
 394
 395 // common code
 396
 397 inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
 398 {
 399     return testAndSetOrdered(expectedValue, newValue);
 400 }
 401
 402 inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
 403 {
 404     return testAndSetOrdered(expectedValue, newValue);
 405 }
 406
 407 inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
 408 {
 409     return testAndSetOrdered(expectedValue, newValue);
 410 }
 411
 412 inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
 413 {
 414     return fetchAndStoreOrdered(newValue);
 415 }
 416
 417 inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
 418 {
 419     return fetchAndStoreOrdered(newValue);
 420 }
 421
 422 inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
 423 {
 424     return fetchAndStoreOrdered(newValue);
 425 }
 426
 427 inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
 428 {
 429     return fetchAndAddOrdered(valueToAdd);
 430 }
 431
 432 inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
 433 {
 434     return fetchAndAddOrdered(valueToAdd);
 435 }
 436
 437 inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
 438 {
 439     return fetchAndAddOrdered(valueToAdd);
 440 }
 441
 442 template <typename T>
 443 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
 444 {
 445     return testAndSetOrdered(expectedValue, newValue);
 446 }
 447
 448 template <typename T>
 449 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
 450 {
 451     return testAndSetOrdered(expectedValue, newValue);
 452 }
 453
 454 template <typename T>
 455 Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
 456 {
 457     return testAndSetOrdered(expectedValue, newValue);
 458 }
 459
 460 template <typename T>
 461 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
 462 {
 463     return fetchAndStoreOrdered(newValue);
 464 }
 465
 466 template <typename T>
 467 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
 468 {
 469     return fetchAndStoreOrdered(newValue);
 470 }
 471
 472 template <typename T>
 473 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
 474 {
 475     return fetchAndStoreOrdered(newValue);
 476 }
 477
 478 template <typename T>
 479 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
 480 {
 481     return fetchAndAddOrdered(valueToAdd);
 482 }
 483
 484 template <typename T>
 485 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
 486 {
 487     return fetchAndAddOrdered(valueToAdd);
 488 }
 489
 490 template <typename T>
 491 Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
 492 {
 493     return fetchAndAddOrdered(valueToAdd);
 494 }
 495
 496 QT_END_NAMESPACE
 497
 498 QT_END_HEADER
 499
 500 #endif // QATOMIC_ARMV6_H