qatomic_avr32.h
上传用户:detong
上传日期:2022-06-22
资源大小:20675k
文件大小:11k
源码类别:

系统编程

开发平台:

Unix_Linux

  1. /****************************************************************************
  2. **
  3. ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
  4. ** Contact: Qt Software Information (qt-info@nokia.com)
  5. **
  6. ** This file is part of the QtCore module of the Qt Toolkit.
  7. **
  8. ** Commercial Usage
  9. ** Licensees holding valid Qt Commercial licenses may use this file in
  10. ** accordance with the Qt Commercial License Agreement provided with the
  11. ** Software or, alternatively, in accordance with the terms contained in
  12. ** a written agreement between you and Nokia.
  13. **
  14. **
  15. ** GNU General Public License Usage
  16. ** Alternatively, this file may be used under the terms of the GNU
  17. ** General Public License versions 2.0 or 3.0 as published by the Free
  18. ** Software Foundation and appearing in the file LICENSE.GPL included in
  19. ** the packaging of this file.  Please review the following information
  20. ** to ensure GNU General Public Licensing requirements will be met:
  21. ** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
  22. ** http://www.gnu.org/copyleft/gpl.html.  In addition, as a special
  23. ** exception, Nokia gives you certain additional rights. These rights
  24. ** are described in the Nokia Qt GPL Exception version 1.3, included in
  25. ** the file GPL_EXCEPTION.txt in this package.
  26. **
  27. ** Qt for Windows(R) Licensees
  28. ** As a special exception, Nokia, as the sole copyright holder for Qt
  29. ** Designer, grants users of the Qt/Eclipse Integration plug-in the
  30. ** right for the Qt/Eclipse Integration to link to functionality
  31. ** provided by Qt Designer and its related libraries.
  32. **
  33. ** If you are unsure which license is appropriate for your use, please
  34. ** contact the sales department at qt-sales@nokia.com.
  35. **
  36. ****************************************************************************/
  37. #ifndef QATOMIC_AVR32_H
  38. #define QATOMIC_AVR32_H
  39. QT_BEGIN_HEADER
  40. QT_BEGIN_NAMESPACE
  41. #define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE
  42. inline bool QBasicAtomicInt::isReferenceCountingNative()
  43. { return true; }
  44. inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
  45. { return false; }
  46. #define Q_ATOMIC_INT_TEST_AND_SET_IS_ALWAYS_NATIVE
  47. inline bool QBasicAtomicInt::isTestAndSetNative()
  48. { return true; }
  49. inline bool QBasicAtomicInt::isTestAndSetWaitFree()
  50. { return false; }
  51. #define Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE
  52. #define Q_ATOMIC_INT_FETCH_AND_STORE_IS_WAIT_FREE
  53. inline bool QBasicAtomicInt::isFetchAndStoreNative()
  54. { return true; }
  55. inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
  56. { return true; }
  57. #define Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE
  58. inline bool QBasicAtomicInt::isFetchAndAddNative()
  59. { return true; }
  60. inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
  61. { return false; }
  62. #define Q_ATOMIC_POINTER_TEST_AND_SET_IS_ALWAYS_NATIVE
  63. template <typename T>
  64. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetNative()
  65. { return true; }
  66. template <typename T>
  67. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
  68. { return false; }
  69. #define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_ALWAYS_NATIVE
  70. #define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_WAIT_FREE
  71. template <typename T>
  72. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
  73. { return true; }
  74. template <typename T>
  75. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
  76. { return true; }
  77. #define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_ALWAYS_NATIVE
  78. template <typename T>
  79. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddNative()
  80. { return true; }
  81. template <typename T>
  82. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
  83. { return false; }
  84. #if defined(QT_BUILD_QREGION_CPP)
  85. #warning "workaround!"
  86. __attribute__((noinline))
  87. #else
  88. inline
  89. #endif
  90. bool QBasicAtomicInt::ref()
  91. {
  92.     register int newValue;
  93.     asm volatile("0:n"
  94.                  "ssrf %[LOCK]n"
  95.                  "ld.w %[newValue], %[_q_value]n"
  96.                  "add %[newValue], %[ONE]n"
  97.                  "stcond %[_q_value], %[newValue]n"
  98.                  "brne 0bn"
  99.                  : [newValue] "=&r"(newValue),
  100.                    [_q_value] "+RKs16"(_q_value)
  101.                  : [LOCK] "i"(0x5),
  102.                    [ONE] "r"(1)
  103.                  : "cc", "memory");
  104.     return newValue;
  105. }
  106. inline bool QBasicAtomicInt::deref()
  107. {
  108.     register int newValue;
  109.     asm volatile("0:n"
  110.                  "ssrf %[LOCK]n"
  111.                  "ld.w %[newValue], %[_q_value]n"
  112.                  "sub %[newValue], %[ONE]n"
  113.                  "stcond %[_q_value], %[newValue]n"
  114.                  "brne 0bn"
  115.                  : [newValue] "=&r"(newValue),
  116.                    [_q_value] "+RKs16"(_q_value)
  117.                  : [LOCK] "i"(0x5),
  118.                    [ONE] "i"(1)
  119.                  : "cc", "memory");
  120.     return newValue;
  121. }
  122. inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
  123. {
  124.     register int originalValue;
  125.     asm volatile("0:n"
  126.                  "ssrf %[LOCK]n"
  127.                  "ld.w %[originalValue], %[_q_value]n"
  128.                  "cp.w %[originalValue], %[expectedValue]n"
  129.                  "brne 0fn"
  130.                  "stcond %[_q_value], %[newValue]n"
  131.                  "brne 0bn"
  132.                  "0:n"
  133.                  : [originalValue] "=&r"(originalValue),
  134.                    [_q_value] "+RKs16"(_q_value)
  135.                  : [LOCK] "i"(0x5),
  136.                    [expectedValue] "r"(expectedValue),
  137.                    [newValue] "r"(newValue)
  138.                  : "cc", "memory");
  139.     return originalValue == expectedValue;
  140. }
  141. inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
  142. {
  143.     return testAndSetOrdered(expectedValue, newValue);
  144. }
  145. inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
  146. {
  147.     return testAndSetOrdered(expectedValue, newValue);
  148. }
  149. inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
  150. {
  151.     return testAndSetOrdered(expectedValue, newValue);
  152. }
  153. inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
  154. {
  155.     register int originalValue;
  156.     asm volatile("xchg %[originalValue], %[_q_value], %[newValue]"
  157.                  : [originalValue] "=&r"(originalValue),
  158.                    "+m" (_q_value)
  159.                  : [_q_value] "r"(&_q_value),
  160.                    [newValue] "r"(newValue)
  161.                  : "cc", "memory");
  162.     return originalValue;
  163. }
  164. inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
  165. {
  166.     return fetchAndStoreOrdered(newValue);
  167. }
  168. inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
  169. {
  170.     return fetchAndStoreOrdered(newValue);
  171. }
  172. inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
  173. {
  174.     return fetchAndStoreOrdered(newValue);
  175. }
  176. inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
  177. {
  178.     register int originalValue, newValue;
  179.     asm volatile("0:n"
  180.                  "ssrf %[LOCK]n"
  181.                  "ld.w %[originalValue], %[_q_value]n"
  182.                  "add %[newValue], %[originalValue], %[valueToAdd]n"
  183.                  "stcond %[_q_value], %[newValue]n"
  184.                  "brne 0bn"
  185.                  : [originalValue] "=&r"(originalValue),
  186.                    [newValue] "=&r"(newValue),
  187.                    [_q_value] "+RKs16"(_q_value)
  188.                  : [LOCK] "i"(0x5),
  189.                    [valueToAdd] "r"(valueToAdd)
  190.                  : "cc", "memory");
  191.     return originalValue;
  192. }
  193. inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
  194. {
  195.     return fetchAndAddOrdered(valueToAdd);
  196. }
  197. inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
  198. {
  199.     return fetchAndAddOrdered(valueToAdd);
  200. }
  201. inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
  202. {
  203.     return fetchAndAddOrdered(valueToAdd);
  204. }
  205. template <typename T>
  206. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
  207. {
  208.     register T *originalValue;
  209.     asm volatile("0:n"
  210.                  "ssrf %[LOCK]n"
  211.                  "ld.w %[originalValue], %[_q_value]n"
  212.                  "cp.w %[originalValue], %[expectedValue]n"
  213.                  "brne 0fn"
  214.                  "stcond %[_q_value], %[newValue]n"
  215.                  "brne 0bn"
  216.                  "0:n"
  217.                  : [originalValue] "=&r"(originalValue),
  218.                    [_q_value] "+RKs16"(_q_value)
  219.                  : [LOCK] "i"(0x5),
  220.                    [expectedValue] "r"(expectedValue),
  221.                    [newValue] "r"(newValue)
  222.                  : "cc", "memory");
  223.     return originalValue == expectedValue;
  224. }
  225. template <typename T>
  226. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
  227. {
  228.     return testAndSetOrdered(expectedValue, newValue);
  229. }
  230. template <typename T>
  231. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
  232. {
  233.     return testAndSetOrdered(expectedValue, newValue);
  234. }
  235. template <typename T>
  236. Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
  237. {
  238.     return testAndSetOrdered(expectedValue, newValue);
  239. }
  240. template <typename T>
  241. Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
  242. {
  243.     register T *originalValue;
  244.     asm volatile("xchg %[originalValue], %[_q_value], %[newValue]"
  245.                  : [originalValue] "=&r"(originalValue),
  246.                    "+m" (_q_value)
  247.                  : [_q_value] "r"(&_q_value),
  248.                    [newValue] "r"(newValue)
  249.                  : "cc", "memory");
  250.     return originalValue;
  251. }
  252. template <typename T>
  253. Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
  254. {
  255.     return fetchAndStoreOrdered(newValue);
  256. }
  257. template <typename T>
  258. Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
  259. {
  260.     return fetchAndStoreOrdered(newValue);
  261. }
  262. template <typename T>
  263. Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
  264. {
  265.     return fetchAndStoreOrdered(newValue);
  266. }
  267. template <typename T>
  268. Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
  269. {
  270.     register T *originalValue, *newValue;
  271.     asm volatile("0:n"
  272.                  "ssrf %[LOCK]n"
  273.                  "ld.w %[originalValue], %[_q_value]n"
  274.                  "add %[newValue], %[originalValue], %[valueToAdd]n"
  275.                  "stcond %[_q_value], %[newValue]n"
  276.                  "brne 0bn"
  277.                  : [originalValue] "=&r"(originalValue),
  278.                    [newValue] "=&r"(newValue),
  279.                    [_q_value] "+RKs16"(_q_value)
  280.                  : [LOCK] "i"(0x5),
  281.                    [valueToAdd] "r"(valueToAdd * sizeof(T))
  282.                  : "cc", "memory");
  283.     return originalValue;
  284. }
  285. template <typename T>
  286. Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
  287. {
  288.     return fetchAndAddOrdered(valueToAdd);
  289. }
  290. template <typename T>
  291. Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
  292. {
  293.     return fetchAndAddOrdered(valueToAdd);
  294. }
  295. template <typename T>
  296. Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
  297. {
  298.     return fetchAndAddOrdered(valueToAdd);
  299. }
  300. QT_END_NAMESPACE
  301. QT_END_HEADER
  302. #endif // QATOMIC_AVR32_H