* [PATCH] PR libitm/61164: use always_inline consistently @ 2014-09-27 12:07 Gleb Fotengauer-Malinovskiy 2014-09-27 17:00 ` [PATCH v2] " Gleb Fotengauer-Malinovskiy 0 siblings, 1 reply; 9+ messages in thread From: Gleb Fotengauer-Malinovskiy @ 2014-09-27 12:07 UTC (permalink / raw) To: gcc-patches 2014-09-27 Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org> libitm/ PR libitm/61164 * local_atomic (__always_inline): Add inline. (__calculate_memory_order): Remove inline. (atomic_thread_fence): Likewise. (atomic_signal_fence): Likewise. (atomic_flag_test_and_set_explicit): Likewise. (atomic_flag_clear_explicit): Likewise. (atomic_flag_test_and_set): Likewise. (atomic_flag_clear): Likewise. --- libitm/local_atomic | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/libitm/local_atomic b/libitm/local_atomic index c3e079f..ae35ada 100644 --- a/libitm/local_atomic +++ b/libitm/local_atomic - inline __always_inline void + __always_inline void atomic_signal_fence(memory_order __m) noexcept { __atomic_thread_fence (__m); @@ -1544,38 +1544,38 @@ namespace std // _GLIBCXX_VISIBILITY(default) // Function definitions, atomic_flag operations. - inline __always_inline bool + __always_inline bool atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline __always_inline bool + __always_inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline __always_inline void + __always_inline void atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline __always_inline void + __always_inline void atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline __always_inline bool + __always_inline bool atomic_flag_test_and_set(atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline __always_inline bool + __always_inline bool atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline __always_inline void + __always_inline void atomic_flag_clear(atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } - inline __always_inline void + __always_inline void atomic_flag_clear(volatile atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } -- glebfm ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v2] PR libitm/61164: use always_inline consistently 2014-09-27 12:07 [PATCH] PR libitm/61164: use always_inline consistently Gleb Fotengauer-Malinovskiy @ 2014-09-27 17:00 ` Gleb Fotengauer-Malinovskiy 2014-09-29 8:54 ` Jakub Jelinek 0 siblings, 1 reply; 9+ messages in thread From: Gleb Fotengauer-Malinovskiy @ 2014-09-27 17:00 UTC (permalink / raw) To: gcc-patches [-- Attachment #1: Type: text/plain, Size: 2488 bytes --] 2014-09-27 Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org> libitm/ PR libitm/61164 * local_atomic (__always_inline): Add inline. (__calculate_memory_order): Remove inline. (atomic_thread_fence): Likewise. (atomic_signal_fence): Likewise. (atomic_flag_test_and_set_explicit): Likewise. (atomic_flag_clear_explicit): Likewise. (atomic_flag_test_and_set): Likewise. (atomic_flag_clear): Likewise. --- Sorry, previous patch is incomplete. libitm/local_atomic | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/libitm/local_atomic b/libitm/local_atomic index c3e079f..ae35ada 100644 --- a/libitm/local_atomic +++ b/libitm/local_atomic - inline __always_inline void + __always_inline void atomic_signal_fence(memory_order __m) noexcept { __atomic_thread_fence (__m); @@ -1544,38 +1544,38 @@ namespace std // _GLIBCXX_VISIBILITY(default) // Function definitions, atomic_flag operations. - inline __always_inline bool + __always_inline bool atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline __always_inline bool + __always_inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline __always_inline void + __always_inline void atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline __always_inline void + __always_inline void atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline __always_inline bool + __always_inline bool atomic_flag_test_and_set(atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline __always_inline bool + __always_inline bool atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline __always_inline void + __always_inline void atomic_flag_clear(atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } - inline __always_inline void + __always_inline void atomic_flag_clear(volatile atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } -- glebfm [-- Attachment #2: Type: application/pgp-signature, Size: 181 bytes --] ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v2] PR libitm/61164: use always_inline consistently 2014-09-27 17:00 ` [PATCH v2] " Gleb Fotengauer-Malinovskiy @ 2014-09-29 8:54 ` Jakub Jelinek 2014-09-29 12:53 ` [PATCH v3] " Gleb Fotengauer-Malinovskiy 0 siblings, 1 reply; 9+ messages in thread From: Jakub Jelinek @ 2014-09-29 8:54 UTC (permalink / raw) To: Gleb Fotengauer-Malinovskiy, Torvald Riegel, Richard Henderson Cc: gcc-patches On Sat, Sep 27, 2014 at 09:00:00PM +0400, Gleb Fotengauer-Malinovskiy wrote: > 2014-09-27 Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org> > > libitm/ > > PR libitm/61164 > * local_atomic (__always_inline): Add inline. > (__calculate_memory_order): Remove inline. > (atomic_thread_fence): Likewise. > (atomic_signal_fence): Likewise. > (atomic_flag_test_and_set_explicit): Likewise. > (atomic_flag_clear_explicit): Likewise. > (atomic_flag_test_and_set): Likewise. > (atomic_flag_clear): Likewise. > > --- > Sorry, previous patch is incomplete. This patch doesn't seem to match the ChangeLog, there is no change in the #define, etc. Furthermore, I think it is just wrong to redefine a glibc macro. I'd suggest to just sed -i -e 's/__always_inline/__libitm_always_inline/g' libitm/local_atomic Jakub ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v3] PR libitm/61164: use always_inline consistently 2014-09-29 8:54 ` Jakub Jelinek @ 2014-09-29 12:53 ` Gleb Fotengauer-Malinovskiy 2014-09-29 13:38 ` Jakub Jelinek 2014-09-29 15:35 ` [PATCH v3] PR libitm/61164: use always_inline consistently Torvald Riegel 0 siblings, 2 replies; 9+ messages in thread From: Gleb Fotengauer-Malinovskiy @ 2014-09-29 12:53 UTC (permalink / raw) To: Jakub Jelinek, Torvald Riegel, Richard Henderson; +Cc: gcc-patches 2014-09-27 Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org> libitm/ PR libitm/61164 * local_atomic: Rename __always_inline to __libitm_always_inline to eliminate glibc macro redefinition. (__libitm_always_inline): Add inline. (__calculate_memory_order): Remove inline. (atomic_thread_fence): Likewise. (atomic_signal_fence): Likewise. (atomic_flag_test_and_set_explicit): Likewise. (atomic_flag_clear_explicit): Likewise. (atomic_flag_test_and_set): Likewise. (atomic_flag_clear): Likewise. --- local_atomic | 299 +++++++++++++++++++++++++++++------------------------------ 1 file changed, 149 insertions(+), 150 deletions(-) diff --git a/local_atomic b/local_atomic index c3e079f..84dd8c2 100644 --- a/local_atomic +++ b/local_atomic @@ -41,8 +41,7 @@ #ifndef _GLIBCXX_ATOMIC #define _GLIBCXX_ATOMIC 1 -#undef __always_inline -#define __always_inline __attribute__((always_inline)) +#define __libitm_always_inline inline __attribute__((always_inline)) // #pragma GCC system_header @@ -74,7 +73,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) memory_order_seq_cst } memory_order; - inline __always_inline memory_order + __libitm_always_inline memory_order __calculate_memory_order(memory_order __m) noexcept { const bool __cond1 = __m == memory_order_release; @@ -84,13 +83,13 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __mo2; } - inline __always_inline void + __libitm_always_inline void atomic_thread_fence(memory_order __m) noexcept { __atomic_thread_fence (__m); } - inline __always_inline void + __libitm_always_inline void atomic_signal_fence(memory_order __m) noexcept { __atomic_thread_fence (__m); @@ -280,19 +279,19 @@ namespace std // _GLIBCXX_VISIBILITY(default) // Conversion to ATOMIC_FLAG_INIT. atomic_flag(bool __i) noexcept : __atomic_flag_base({ __i }) { } - __always_inline bool + __libitm_always_inline bool test_and_set(memory_order __m = memory_order_seq_cst) noexcept { return __atomic_test_and_set (&_M_i, __m); } - __always_inline bool + __libitm_always_inline bool test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_test_and_set (&_M_i, __m); } - __always_inline void + __libitm_always_inline void clear(memory_order __m = memory_order_seq_cst) noexcept { // __glibcxx_assert(__m != memory_order_consume); @@ -302,7 +301,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_clear (&_M_i, __m); } - __always_inline void + __libitm_always_inline void clear(memory_order __m = memory_order_seq_cst) volatile noexcept { // __glibcxx_assert(__m != memory_order_consume); @@ -455,7 +454,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); } - __always_inline void + __libitm_always_inline void store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { // __glibcxx_assert(__m != memory_order_acquire); @@ -465,7 +464,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_i, __i, __m); } - __always_inline void + __libitm_always_inline void store(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -476,7 +475,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type load(memory_order __m = memory_order_seq_cst) const noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -485,7 +484,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -494,21 +493,21 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_i, __i, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { @@ -519,7 +518,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept @@ -531,7 +530,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { @@ -539,7 +538,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -547,7 +546,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { @@ -558,7 +557,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept @@ -570,7 +569,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { @@ -578,7 +577,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -586,52 +585,52 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_and(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_and(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_or(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_or(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_xor(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_xor(&_M_i, __i, __m); } @@ -733,7 +732,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return __atomic_is_lock_free (sizeof (_M_p), &_M_p); } - __always_inline void + __libitm_always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { @@ -744,7 +743,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_p, __p, __m); } - __always_inline void + __libitm_always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -755,7 +754,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_p, __p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -764,7 +763,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -773,21 +772,21 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_p, __p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_p, __p, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept @@ -799,7 +798,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept @@ -811,22 +810,22 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_p, __d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_p, __d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_p, __d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_p, __d, __m); } @@ -870,67 +869,67 @@ namespace std // _GLIBCXX_VISIBILITY(default) bool is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } - __always_inline void + __libitm_always_inline void store(bool __i, memory_order __m = memory_order_seq_cst) noexcept { _M_base.store(__i, __m); } - __always_inline void + __libitm_always_inline void store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { _M_base.store(__i, __m); } - __always_inline bool + __libitm_always_inline bool load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_base.load(__m); } - __always_inline bool + __libitm_always_inline bool load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_base.load(__m); } - __always_inline bool + __libitm_always_inline bool exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.exchange(__i, __m); } - __always_inline bool + __libitm_always_inline bool exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.exchange(__i, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } @@ -980,11 +979,11 @@ namespace std // _GLIBCXX_VISIBILITY(default) store(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept { __atomic_store(&_M_i, &__i, _m); } - __always_inline void + __libitm_always_inline void store(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept { __atomic_store(&_M_i, &__i, _m); } - __always_inline _Tp + __libitm_always_inline _Tp load(memory_order _m = memory_order_seq_cst) const noexcept { _Tp tmp; @@ -992,7 +991,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - __always_inline _Tp + __libitm_always_inline _Tp load(memory_order _m = memory_order_seq_cst) const volatile noexcept { _Tp tmp; @@ -1000,7 +999,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - __always_inline _Tp + __libitm_always_inline _Tp exchange(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept { _Tp tmp; @@ -1008,7 +1007,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - __always_inline _Tp + __libitm_always_inline _Tp exchange(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept { @@ -1017,50 +1016,50 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__e, __i, __m, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__e, __i, __m, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__e, __i, __m, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__e, __i, __m, __m); } @@ -1153,46 +1152,46 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return _M_b.is_lock_free(); } - __always_inline void + __libitm_always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.store(__p, __m); } - __always_inline void + __libitm_always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.store(__p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_b.load(__m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_b.load(__m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.exchange(__p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.exchange(__p, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { @@ -1200,7 +1199,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -1208,18 +1207,18 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { @@ -1227,7 +1226,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -1235,22 +1234,22 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.fetch_add(__d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.fetch_add(__d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.fetch_sub(__d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.fetch_sub(__d, __m); } @@ -1544,98 +1543,98 @@ namespace std // _GLIBCXX_VISIBILITY(default) // Function definitions, atomic_flag operations. - inline __always_inline bool + __libitm_always_inline bool atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline __always_inline bool + __libitm_always_inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline __always_inline void + __libitm_always_inline void atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline __always_inline void + __libitm_always_inline void atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline __always_inline bool + __libitm_always_inline bool atomic_flag_test_and_set(atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline __always_inline bool + __libitm_always_inline bool atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline __always_inline void + __libitm_always_inline void atomic_flag_clear(atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } - inline __always_inline void + __libitm_always_inline void atomic_flag_clear(volatile atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } // Function templates generally applicable to atomic types. template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_is_lock_free(const atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept; template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept; template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_store_explicit(atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { __a->store(__i, __m); } template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { __a->store(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_load_explicit(const volatile atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1643,7 +1642,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1651,7 +1650,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1659,7 +1658,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1668,37 +1667,37 @@ namespace std // _GLIBCXX_VISIBILITY(default) template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_load(const atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_load(const volatile atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_weak(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1708,7 +1707,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1718,7 +1717,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_strong(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1728,7 +1727,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1742,158 +1741,158 @@ namespace std // _GLIBCXX_VISIBILITY(default) // intergral types as specified in the standard, excluding address // types. template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } // Partial specializations for pointers. template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_add(__d, __m); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_add(__d, __m); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_add(__d); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_add(__d); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_sub(__d, __m); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_sub(__d, __m); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_sub(__d); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_sub(__d); } // @} group atomics -- glebfm ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v3] PR libitm/61164: use always_inline consistently 2014-09-29 12:53 ` [PATCH v3] " Gleb Fotengauer-Malinovskiy @ 2014-09-29 13:38 ` Jakub Jelinek 2014-09-29 16:24 ` [PATCH] PR libitm/61164: redefinition of __always_inline Gleb Fotengauer-Malinovskiy 2014-09-29 15:35 ` [PATCH v3] PR libitm/61164: use always_inline consistently Torvald Riegel 1 sibling, 1 reply; 9+ messages in thread From: Jakub Jelinek @ 2014-09-29 13:38 UTC (permalink / raw) To: Gleb Fotengauer-Malinovskiy Cc: Torvald Riegel, Richard Henderson, gcc-patches On Mon, Sep 29, 2014 at 04:53:26PM +0400, Gleb Fotengauer-Malinovskiy wrote: > 2014-09-27 Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org> Two spaces around name on each side. > > libitm/ > > PR libitm/61164 > * local_atomic: Rename __always_inline to __libitm_always_inline > to eliminate glibc macro redefinition. That would be * local_atomic (__always_inline): Rename to... (__libitm_always_inline): ... this. > --- a/local_atomic > +++ b/local_atomic > @@ -41,8 +41,7 @@ > #ifndef _GLIBCXX_ATOMIC > #define _GLIBCXX_ATOMIC 1 > > -#undef __always_inline > -#define __always_inline __attribute__((always_inline)) > +#define __libitm_always_inline inline __attribute__((always_inline)) Why do you want to add inline keyword to that? Some inline keywords are implicit (methods defined inline), so there is no point adding it there. Jakub ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] PR libitm/61164: redefinition of __always_inline 2014-09-29 13:38 ` Jakub Jelinek @ 2014-09-29 16:24 ` Gleb Fotengauer-Malinovskiy 0 siblings, 0 replies; 9+ messages in thread From: Gleb Fotengauer-Malinovskiy @ 2014-09-29 16:24 UTC (permalink / raw) To: Jakub Jelinek; +Cc: Torvald Riegel, Richard Henderson, gcc-patches 2014-09-27 Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org> libitm/ PR libitm/61164 * local_atomic (__always_inline): Rename to... (__libitm_always_inline): ... this. --- On Mon, Sep 29, 2014 at 03:38:25PM +0200, Jakub Jelinek wrote: > Why do you want to add inline keyword to that? Some inline keywords > are implicit (methods defined inline), so there is no point adding it there. I just didn't get that redefinition of __always_inline was the source of the problem. local_atomic | 299 +++++++++++++++++++++++++++++------------------------------ 1 file changed, 149 insertions(+), 150 deletions(-) diff --git a/local_atomic b/local_atomic index c3e079f..552b919 100644 --- a/local_atomic +++ b/local_atomic @@ -41,8 +41,7 @@ #ifndef _GLIBCXX_ATOMIC #define _GLIBCXX_ATOMIC 1 -#undef __always_inline -#define __always_inline __attribute__((always_inline)) +#define __libitm_always_inline __attribute__((always_inline)) // #pragma GCC system_header @@ -74,7 +74,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) memory_order_seq_cst } memory_order; - inline __always_inline memory_order + inline __libitm_always_inline memory_order __calculate_memory_order(memory_order __m) noexcept { const bool __cond1 = __m == memory_order_release; @@ -84,13 +84,13 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __mo2; } - inline __always_inline void + inline __libitm_always_inline void atomic_thread_fence(memory_order __m) noexcept { __atomic_thread_fence (__m); } - inline __always_inline void + inline __libitm_always_inline void atomic_signal_fence(memory_order __m) noexcept { __atomic_thread_fence (__m); @@ -280,19 +280,19 @@ namespace std // _GLIBCXX_VISIBILITY(default) // Conversion to ATOMIC_FLAG_INIT. atomic_flag(bool __i) noexcept : __atomic_flag_base({ __i }) { } - __always_inline bool + __libitm_always_inline bool test_and_set(memory_order __m = memory_order_seq_cst) noexcept { return __atomic_test_and_set (&_M_i, __m); } - __always_inline bool + __libitm_always_inline bool test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_test_and_set (&_M_i, __m); } - __always_inline void + __libitm_always_inline void clear(memory_order __m = memory_order_seq_cst) noexcept { // __glibcxx_assert(__m != memory_order_consume); @@ -302,7 +302,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_clear (&_M_i, __m); } - __always_inline void + __libitm_always_inline void clear(memory_order __m = memory_order_seq_cst) volatile noexcept { // __glibcxx_assert(__m != memory_order_consume); @@ -455,7 +455,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); } - __always_inline void + __libitm_always_inline void store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { // __glibcxx_assert(__m != memory_order_acquire); @@ -465,7 +465,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_i, __i, __m); } - __always_inline void + __libitm_always_inline void store(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -476,7 +476,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type load(memory_order __m = memory_order_seq_cst) const noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -485,7 +485,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -494,21 +494,21 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_i, __i, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { @@ -519,7 +519,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept @@ -531,7 +531,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { @@ -539,7 +539,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -547,7 +547,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { @@ -558,7 +558,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept @@ -570,7 +570,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { @@ -578,7 +578,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -586,52 +586,52 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_and(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_and(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_or(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_or(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_xor(&_M_i, __i, __m); } - __always_inline __int_type + __libitm_always_inline __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_xor(&_M_i, __i, __m); } @@ -733,7 +733,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return __atomic_is_lock_free (sizeof (_M_p), &_M_p); } - __always_inline void + __libitm_always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { @@ -744,7 +744,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_p, __p, __m); } - __always_inline void + __libitm_always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -755,7 +755,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_p, __p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -764,7 +764,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -773,21 +773,21 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_p, __p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_p, __p, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept @@ -799,7 +799,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept @@ -811,22 +811,22 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_p, __d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_p, __d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_p, __d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_p, __d, __m); } @@ -870,67 +870,67 @@ namespace std // _GLIBCXX_VISIBILITY(default) bool is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } - __always_inline void + __libitm_always_inline void store(bool __i, memory_order __m = memory_order_seq_cst) noexcept { _M_base.store(__i, __m); } - __always_inline void + __libitm_always_inline void store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { _M_base.store(__i, __m); } - __always_inline bool + __libitm_always_inline bool load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_base.load(__m); } - __always_inline bool + __libitm_always_inline bool load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_base.load(__m); } - __always_inline bool + __libitm_always_inline bool exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.exchange(__i, __m); } - __always_inline bool + __libitm_always_inline bool exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.exchange(__i, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } @@ -980,11 +980,11 @@ namespace std // _GLIBCXX_VISIBILITY(default) store(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept { __atomic_store(&_M_i, &__i, _m); } - __always_inline void + __libitm_always_inline void store(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept { __atomic_store(&_M_i, &__i, _m); } - __always_inline _Tp + __libitm_always_inline _Tp load(memory_order _m = memory_order_seq_cst) const noexcept { _Tp tmp; @@ -992,7 +992,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - __always_inline _Tp + __libitm_always_inline _Tp load(memory_order _m = memory_order_seq_cst) const volatile noexcept { _Tp tmp; @@ -1000,7 +1000,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - __always_inline _Tp + __libitm_always_inline _Tp exchange(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept { _Tp tmp; @@ -1008,7 +1008,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - __always_inline _Tp + __libitm_always_inline _Tp exchange(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept { @@ -1017,50 +1017,50 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__e, __i, __m, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__e, __i, __m, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__e, __i, __m, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__e, __i, __m, __m); } @@ -1153,46 +1153,46 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return _M_b.is_lock_free(); } - __always_inline void + __libitm_always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.store(__p, __m); } - __always_inline void + __libitm_always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.store(__p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_b.load(__m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_b.load(__m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.exchange(__p, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.exchange(__p, __m); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { @@ -1200,7 +1200,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -1208,18 +1208,18 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { @@ -1227,7 +1227,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline bool + __libitm_always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -1235,22 +1235,22 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.fetch_add(__d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.fetch_add(__d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.fetch_sub(__d, __m); } - __always_inline __pointer_type + __libitm_always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.fetch_sub(__d, __m); } @@ -1544,98 +1544,98 @@ namespace std // _GLIBCXX_VISIBILITY(default) // Function definitions, atomic_flag operations. - inline __always_inline bool + inline __libitm_always_inline bool atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline __always_inline bool + inline __libitm_always_inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline __always_inline void + inline __libitm_always_inline void atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline __always_inline void + inline __libitm_always_inline void atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline __always_inline bool + inline __libitm_always_inline bool atomic_flag_test_and_set(atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline __always_inline bool + inline __libitm_always_inline bool atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline __always_inline void + inline __libitm_always_inline void atomic_flag_clear(atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } - inline __always_inline void + inline __libitm_always_inline void atomic_flag_clear(volatile atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } // Function templates generally applicable to atomic types. template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_is_lock_free(const atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept; template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept; template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_store_explicit(atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { __a->store(__i, __m); } template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { __a->store(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_load_explicit(const volatile atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1643,7 +1643,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1651,7 +1651,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1659,7 +1659,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1668,37 +1668,37 @@ namespace std // _GLIBCXX_VISIBILITY(default) template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline void + __libitm_always_inline void atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_load(const atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_load(const volatile atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_weak(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1708,7 +1708,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1718,7 +1718,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_strong(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1728,7 +1728,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - __always_inline bool + __libitm_always_inline bool atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1742,158 +1742,158 @@ namespace std // _GLIBCXX_VISIBILITY(default) // intergral types as specified in the standard, excluding address // types. template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - __always_inline _ITp + __libitm_always_inline _ITp atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } // Partial specializations for pointers. template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_add(__d, __m); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_add(__d, __m); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_add(__d); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_add(__d); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_sub(__d, __m); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_sub(__d, __m); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_sub(__d); } template<typename _ITp> - __always_inline _ITp* + __libitm_always_inline _ITp* atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_sub(__d); } // @} group atomics -- glebfm ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v3] PR libitm/61164: use always_inline consistently 2014-09-29 12:53 ` [PATCH v3] " Gleb Fotengauer-Malinovskiy 2014-09-29 13:38 ` Jakub Jelinek @ 2014-09-29 15:35 ` Torvald Riegel 2014-09-29 15:39 ` Jakub Jelinek 1 sibling, 1 reply; 9+ messages in thread From: Torvald Riegel @ 2014-09-29 15:35 UTC (permalink / raw) To: Gleb Fotengauer-Malinovskiy; +Cc: Jakub Jelinek, Richard Henderson, gcc-patches On Mon, 2014-09-29 at 16:53 +0400, Gleb Fotengauer-Malinovskiy wrote: > -#undef __always_inline > -#define __always_inline __attribute__((always_inline)) > +#define __libitm_always_inline inline __attribute__((always_inline)) The previous code seems to work in libstdc++. I believe that eventually, we'll want to use libstdc++-v3/include/bits/atomic_base.h (see the comment at the top of the file). Can we keep the diff between the two files small? ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v3] PR libitm/61164: use always_inline consistently 2014-09-29 15:35 ` [PATCH v3] PR libitm/61164: use always_inline consistently Torvald Riegel @ 2014-09-29 15:39 ` Jakub Jelinek 2014-09-29 16:45 ` Torvald Riegel 0 siblings, 1 reply; 9+ messages in thread From: Jakub Jelinek @ 2014-09-29 15:39 UTC (permalink / raw) To: Torvald Riegel Cc: Gleb Fotengauer-Malinovskiy, Richard Henderson, gcc-patches On Mon, Sep 29, 2014 at 05:35:24PM +0200, Torvald Riegel wrote: > On Mon, 2014-09-29 at 16:53 +0400, Gleb Fotengauer-Malinovskiy wrote: > > -#undef __always_inline > > -#define __always_inline __attribute__((always_inline)) > > +#define __libitm_always_inline inline __attribute__((always_inline)) > > The previous code seems to work in libstdc++. I believe that > eventually, we'll want to use libstdc++-v3/include/bits/atomic_base.h > (see the comment at the top of the file). Can we keep the diff between > the two files small? libstdc++-v3/include/bits/atomic_base.h uses _GLIBCXX_ALWAYS_INLINE macro: #ifndef _GLIBCXX_ALWAYS_INLINE #define _GLIBCXX_ALWAYS_INLINE inline __attribute__((always_inline)) #endif but using a libstdc++ specific macro in libitm sounds weird to me (any change to that macro would mean you need to change it accordingly also in libitm or vice versa). Jakub ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v3] PR libitm/61164: use always_inline consistently 2014-09-29 15:39 ` Jakub Jelinek @ 2014-09-29 16:45 ` Torvald Riegel 0 siblings, 0 replies; 9+ messages in thread From: Torvald Riegel @ 2014-09-29 16:45 UTC (permalink / raw) To: Jakub Jelinek; +Cc: Gleb Fotengauer-Malinovskiy, Richard Henderson, gcc-patches On Mon, 2014-09-29 at 17:38 +0200, Jakub Jelinek wrote: > On Mon, Sep 29, 2014 at 05:35:24PM +0200, Torvald Riegel wrote: > > On Mon, 2014-09-29 at 16:53 +0400, Gleb Fotengauer-Malinovskiy wrote: > > > -#undef __always_inline > > > -#define __always_inline __attribute__((always_inline)) > > > +#define __libitm_always_inline inline __attribute__((always_inline)) > > > > The previous code seems to work in libstdc++. I believe that > > eventually, we'll want to use libstdc++-v3/include/bits/atomic_base.h > > (see the comment at the top of the file). Can we keep the diff between > > the two files small? > > libstdc++-v3/include/bits/atomic_base.h uses > _GLIBCXX_ALWAYS_INLINE macro: > > #ifndef _GLIBCXX_ALWAYS_INLINE > #define _GLIBCXX_ALWAYS_INLINE inline __attribute__((always_inline)) > #endif Ahh.. I missed that "inline" in there when I had a quick look. Sorry for the noise :) ^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2014-09-29 16:45 UTC | newest] Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2014-09-27 12:07 [PATCH] PR libitm/61164: use always_inline consistently Gleb Fotengauer-Malinovskiy 2014-09-27 17:00 ` [PATCH v2] " Gleb Fotengauer-Malinovskiy 2014-09-29 8:54 ` Jakub Jelinek 2014-09-29 12:53 ` [PATCH v3] " Gleb Fotengauer-Malinovskiy 2014-09-29 13:38 ` Jakub Jelinek 2014-09-29 16:24 ` [PATCH] PR libitm/61164: redefinition of __always_inline Gleb Fotengauer-Malinovskiy 2014-09-29 15:35 ` [PATCH v3] PR libitm/61164: use always_inline consistently Torvald Riegel 2014-09-29 15:39 ` Jakub Jelinek 2014-09-29 16:45 ` Torvald Riegel
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).