From 872bad5ab72ec9e5b5bab1bff98285b1c36bbe58 Mon Sep 17 00:00:00 2001 From: Dan Albert Date: Tue, 6 Jan 2015 18:39:37 +0000 Subject: [PATCH] Obey [atomics.types.operations.req]/21 for GCC. Summary: Excerpt from [atomics.types.operations.req]/21: > When only one memory_order argument is supplied, the value of > success is order, and the value of failure is order except that a > value of memory_order_acq_rel shall be replaced by the value > memory_order_acquire and a value of memory_order_release shall be > replaced by the value memory_order_relaxed. Clean up some copy pasta while I'm here (someone added a return statement to a void function). Reviewers: EricWF, jroelofs, mclow.lists Reviewed By: mclow.lists Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D6632 llvm-svn: 225280 --- libcxx/include/atomic | 22 ++++++++---- .../atomics.general/replace_failure_order.pass.cpp | 41 ++++++++++++++++++++++ 2 files changed, 57 insertions(+), 6 deletions(-) create mode 100644 libcxx/test/atomics/atomics.general/replace_failure_order.pass.cpp diff --git a/libcxx/include/atomic b/libcxx/include/atomic index b01a59f..7a6dd24f 100644 --- a/libcxx/include/atomic +++ b/libcxx/include/atomic @@ -583,6 +583,16 @@ static inline constexpr int __to_gcc_order(memory_order __order) { __ATOMIC_CONSUME)))); } +static inline constexpr int __to_gcc_failure_order(memory_order __order) { + // Avoid switch statement to make this a constexpr. + return __order == memory_order_relaxed ? __ATOMIC_RELAXED: + (__order == memory_order_acquire ? __ATOMIC_ACQUIRE: + (__order == memory_order_release ? __ATOMIC_RELAXED: + (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST: + (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE: + __ATOMIC_CONSUME)))); +} + } // namespace __gcc_atomic template @@ -637,8 +647,8 @@ static inline void __c11_atomic_store(volatile _Atomic(_Tp)* __a, _Tp __val, template static inline void __c11_atomic_store(_Atomic(_Tp)* __a, _Tp __val, memory_order __order) { - return __atomic_store(&__a->__a_value, &__val, - __gcc_atomic::__to_gcc_order(__order)); + __atomic_store(&__a->__a_value, &__val, + __gcc_atomic::__to_gcc_order(__order)); } template @@ -683,7 +693,7 @@ static inline bool __c11_atomic_compare_exchange_strong( return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, false, __gcc_atomic::__to_gcc_order(__success), - __gcc_atomic::__to_gcc_order(__failure)); + __gcc_atomic::__to_gcc_failure_order(__failure)); } template @@ -693,7 +703,7 @@ static inline bool __c11_atomic_compare_exchange_strong( return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, false, __gcc_atomic::__to_gcc_order(__success), - __gcc_atomic::__to_gcc_order(__failure)); + __gcc_atomic::__to_gcc_failure_order(__failure)); } template @@ -703,7 +713,7 @@ static inline bool __c11_atomic_compare_exchange_weak( return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, true, __gcc_atomic::__to_gcc_order(__success), - __gcc_atomic::__to_gcc_order(__failure)); + __gcc_atomic::__to_gcc_failure_order(__failure)); } template @@ -713,7 +723,7 @@ static inline bool __c11_atomic_compare_exchange_weak( return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, true, __gcc_atomic::__to_gcc_order(__success), - __gcc_atomic::__to_gcc_order(__failure)); + __gcc_atomic::__to_gcc_failure_order(__failure)); } template diff --git a/libcxx/test/atomics/atomics.general/replace_failure_order.pass.cpp b/libcxx/test/atomics/atomics.general/replace_failure_order.pass.cpp new file mode 100644 index 0000000..0b37c9d --- /dev/null +++ b/libcxx/test/atomics/atomics.general/replace_failure_order.pass.cpp @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// This test verifies behavior specified by [atomics.types.operations.req]/21: +// +// When only one memory_order argument is supplied, the value of success is +// order, and the value of failure is order except that a value of +// memory_order_acq_rel shall be replaced by the value memory_order_acquire +// and a value of memory_order_release shall be replaced by the value +// memory_order_relaxed. +// +// Clang's atomic intrinsics do this for us, but GCC's do not. We don't actually +// have visibility to see what these memory orders are lowered to, but we can at +// least check that they are lowered at all (otherwise there is a compile +// failure with GCC). + +#include + +int main() { + std::atomic i; + volatile std::atomic v; + int exp; + + i.compare_exchange_weak(exp, 0, std::memory_order_acq_rel); + i.compare_exchange_weak(exp, 0, std::memory_order_release); + i.compare_exchange_strong(exp, 0, std::memory_order_acq_rel); + i.compare_exchange_strong(exp, 0, std::memory_order_release); + + v.compare_exchange_weak(exp, 0, std::memory_order_acq_rel); + v.compare_exchange_weak(exp, 0, std::memory_order_release); + v.compare_exchange_strong(exp, 0, std::memory_order_acq_rel); + v.compare_exchange_strong(exp, 0, std::memory_order_release); + + return 0; +} -- 2.7.4