diff options
| -rw-r--r-- | libcxx/include/atomic | 78 | ||||
| -rw-r--r-- | libcxx/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp | 125 |
2 files changed, 203 insertions, 0 deletions
diff --git a/libcxx/include/atomic b/libcxx/include/atomic index a25b5bf8d77..4353c178b5e 100644 --- a/libcxx/include/atomic +++ b/libcxx/include/atomic @@ -560,6 +560,29 @@ void atomic_signal_fence(memory_order m) noexcept; # define __cpp_lib_atomic_is_always_lock_free 201603L #endif + +#if __has_attribute(__enable_if__) && __has_attribute(__unavailable__) +# define _LIBCPP_CHECK_ATOMIC_MEMORY_ORDER +# define _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) \ + __attribute__ ((__enable_if__(__m == memory_order_release \ + || __m == memory_order_acq_rel, ""))) \ + __attribute__ ((__unavailable__("memory order argument to atomic operation is invalid"))) + +# define _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) \ + __attribute__ ((__enable_if__(__m == memory_order_consume \ + || __m == memory_order_acquire \ + || __m == memory_order_acq_rel, ""))) \ + __attribute__ ((__unavailable__("memory order argument to atomic operation is invalid"))) + +// Note that this is not checking the 'stronger' requirement. +// See wg21.link/p0418 +# define _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) \ + __attribute__ ((__enable_if__(__f == memory_order_release \ + || __f == memory_order_acq_rel, ""))) \ + __attribute__ ((__unavailable__("memory order argument to atomic operation is invalid"))) +#endif + + _LIBCPP_BEGIN_NAMESPACE_STD typedef enum memory_order @@ -933,6 +956,21 @@ struct __atomic_base // false bool compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);} +#if defined(_LIBCPP_CHECK_ATOMIC_MEMORY_ORDER) + void store(_Tp __d, memory_order __m) volatile _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m); + void store(_Tp __d, memory_order __m) _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m); + + _Tp load(memory_order __m) const volatile _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m); + _Tp load(memory_order __m) const _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m); + bool compare_exchange_weak(_Tp&, _Tp, memory_order __s, memory_order __f) volatile + _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f); + bool compare_exchange_weak(_Tp&, _Tp, memory_order __s, memory_order __f) + _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f); + bool compare_exchange_strong(_Tp&, _Tp, memory_order __s, memory_order __f) volatile + _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f); + bool compare_exchange_strong(_Tp&, _Tp, memory_order __s, memory_order __f) + _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f); +#endif _LIBCPP_INLINE_VISIBILITY #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -1344,6 +1382,46 @@ atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e, return __o->compare_exchange_strong(*__e, __d, __s, __f); } + +#ifdef _LIBCPP_CHECK_ATOMIC_MEMORY_ORDER +template <class _Tp> +void atomic_store_explicit(volatile atomic<_Tp>*, _Tp, memory_order __m) +_LIBCPP_CHECK_STORE_MEMORY_ORDER(__m); + +template <class _Tp> +void atomic_store_explicit(atomic<_Tp>*, _Tp, memory_order __m) +_LIBCPP_CHECK_STORE_MEMORY_ORDER(__m); + +template <class _Tp> +_Tp atomic_load_explicit(const volatile atomic<_Tp>*, memory_order __m) +_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m); + +template <class _Tp> +_Tp atomic_load_explicit(const atomic<_Tp>*, memory_order __m) +_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m); + +template <class _Tp> +bool atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>*, _Tp*, _Tp, + memory_order __s, memory_order __f) +_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f); + +template <class _Tp> +bool atomic_compare_exchange_weak_explicit(atomic<_Tp>*, _Tp*, _Tp, + memory_order __s, memory_order __f) +_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f); + +template <class _Tp> +bool atomic_compare_exchange_strong_explicit(volatile atomic<_Tp>*, _Tp*, _Tp, + memory_order __s, memory_order __f) +_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f); + +template <class _Tp> +bool atomic_compare_exchange_strong_explicit(atomic<_Tp>*, _Tp*, _Tp, + memory_order __s, memory_order __f) +_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f); + +#endif + // atomic_fetch_add template <class _Tp> diff --git a/libcxx/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp b/libcxx/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp new file mode 100644 index 00000000000..58fc684e049 --- /dev/null +++ b/libcxx/test/libcxx/atomics/diagnose_invalid_memory_order.fail.cpp @@ -0,0 +1,125 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// The attributes used to diagnose incorrect memory order inputs is clang +// specific. +// UNSUPPORTED: gcc + +// <atomic> + +// Test that invalid memory order arguments are diagnosed where possible. + +#include <atomic> + +int main() { + std::atomic<int> x(42); + volatile std::atomic<int>& vx = x; + int val1 = 1; + int val2 = 2; + // load operations + { + x.load(std::memory_order_release); // expected-error {{operation is invalid}} + x.load(std::memory_order_acq_rel); // expected-error {{operation is invalid}} + vx.load(std::memory_order_release); // expected-error {{operation is invalid}} + vx.load(std::memory_order_acq_rel); // expected-error {{operation is invalid}} + // valid memory orders + x.load(std::memory_order_relaxed); + x.load(std::memory_order_consume); + x.load(std::memory_order_acquire); + x.load(std::memory_order_seq_cst); + } + { + std::atomic_load_explicit(&x, std::memory_order_release); // expected-error {{operation is invalid}} + std::atomic_load_explicit(&x, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + std::atomic_load_explicit(&vx, std::memory_order_release); // expected-error {{operation is invalid}} + std::atomic_load_explicit(&vx, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + // valid memory orders + std::atomic_load_explicit(&x, std::memory_order_relaxed); + std::atomic_load_explicit(&x, std::memory_order_consume); + std::atomic_load_explicit(&x, std::memory_order_acquire); + std::atomic_load_explicit(&x, std::memory_order_seq_cst); + } + // store operations + { + x.store(42, std::memory_order_consume); // expected-error {{operation is invalid}} + x.store(42, std::memory_order_acquire); // expected-error {{operation is invalid}} + x.store(42, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + vx.store(42, std::memory_order_consume); // expected-error {{operation is invalid}} + vx.store(42, std::memory_order_acquire); // expected-error {{operation is invalid}} + vx.store(42, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + // valid memory orders + x.store(42, std::memory_order_relaxed); + x.store(42, std::memory_order_release); + x.store(42, std::memory_order_seq_cst); + } + { + std::atomic_store_explicit(&x, 42, std::memory_order_consume); // expected-error {{operation is invalid}} + std::atomic_store_explicit(&x, 42, std::memory_order_acquire); // expected-error {{operation is invalid}} + std::atomic_store_explicit(&x, 42, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + std::atomic_store_explicit(&vx, 42, std::memory_order_consume); // expected-error {{operation is invalid}} + std::atomic_store_explicit(&vx, 42, std::memory_order_acquire); // expected-error {{operation is invalid}} + std::atomic_store_explicit(&vx, 42, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + // valid memory orders + std::atomic_store_explicit(&x, 42, std::memory_order_relaxed); + std::atomic_store_explicit(&x, 42, std::memory_order_release); + std::atomic_store_explicit(&x, 42, std::memory_order_seq_cst); + } + // compare exchange weak + { + x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}} + x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + vx.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}} + vx.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + // valid memory orders + x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed); + x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_consume); + x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_acquire); + x.compare_exchange_weak(val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst); + // Test that the cmpxchg overload with only one memory order argument + // does not generate any diagnostics. + x.compare_exchange_weak(val1, val2, std::memory_order_release); + } + { + std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}} + std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + std::atomic_compare_exchange_weak_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}} + std::atomic_compare_exchange_weak_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + // valid memory orders + std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed); + std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_consume); + std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acquire); + std::atomic_compare_exchange_weak_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst); + } + // compare exchange strong + { + x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}} + x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + vx.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}} + vx.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + // valid memory orders + x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed); + x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_consume); + x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_acquire); + x.compare_exchange_strong(val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst); + // Test that the cmpxchg overload with only one memory order argument + // does not generate any diagnostics. + x.compare_exchange_strong(val1, val2, std::memory_order_release); + } + { + std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}} + std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + std::atomic_compare_exchange_strong_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_release); // expected-error {{operation is invalid}} + std::atomic_compare_exchange_strong_explicit(&vx, &val1, val2, std::memory_order_seq_cst, std::memory_order_acq_rel); // expected-error {{operation is invalid}} + // valid memory orders + std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_relaxed); + std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_consume); + std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_acquire); + std::atomic_compare_exchange_strong_explicit(&x, &val1, val2, std::memory_order_seq_cst, std::memory_order_seq_cst); + } +} |
