__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 <typename _Tp>
template <typename _Tp>
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 <typename _Tp>
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 <typename _Tp>
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 <typename _Tp>
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 <typename _Tp>
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 <typename _Tp>
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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 <atomic>
+
+int main() {
+ std::atomic<int> i;
+ volatile std::atomic<int> 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;
+}