Obey [atomics.types.operations.req]/21 for GCC.

[danalbert]

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).

[mclow.lists]

LGTM.

include/atomic

650–651

it's perfectly fine to return the result of a void function (from a function returning void)

[danalbert]

Change standard references to use the section names rather than numbers.

include/atomic

static inline constexpr int __to_gcc_order(memory_order __order) {
   return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
          (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
           (__order == memory_order_release ? __ATOMIC_RELEASE:
            (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
             (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL:
               __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>
 static inline
 typename enable_if<
     __gcc_atomic::__can_assign<volatile _Atomic(_Tp)*, _Tp>::value>::type
 __c11_atomic_init(volatile _Atomic(_Tp)* __a,  _Tp __val) {
   __a->__a_value = __val;
static inline void __c11_atomic_store(volatile _Atomic(_Tp)* __a,  _Tp __val,
                                       memory_order __order) {
   return __atomic_store(&__a->__a_value, &__val,
                         __gcc_atomic::__to_gcc_order(__order));
 }
 
 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,
 }
 
 template <typename _Tp>
 static inline _Tp __c11_atomic_load(volatile _Atomic(_Tp)* __a,
                                     memory_order __order) {
   _Tp __ret;
   __atomic_load(&__a->__a_value, &__ret,
                 __gcc_atomic::__to_gcc_order(__order));

 
 template <typename _Tp>
 static inline bool __c11_atomic_compare_exchange_strong(
     volatile _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value,
     memory_order __success, memory_order __failure) {
   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>
 static inline bool __c11_atomic_compare_exchange_strong(
     _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value, memory_order __success,
     memory_order __failure) {
   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>
 static inline bool __c11_atomic_compare_exchange_weak(
     volatile _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value,
     memory_order __success, memory_order __failure) {
   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>
 static inline bool __c11_atomic_compare_exchange_weak(
     _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value, memory_order __success,
     memory_order __failure) {
   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>
 struct __skip_amt { enum {value = 1}; };
 
 template <typename _Tp>
 struct __skip_amt<_Tp*> { enum {value = sizeof(_Tp)}; };
 

test/atomics/atomics.general/replace_failure_order.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     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;
+}