Add -Watomic-memory-ordering diagnostic tests for atomic_ref

Author: dalg24

libcxx/test/libcxx/atomics/atomics.ref/compare_exchange_strong.verify.cpp

@@ -0,0 +1,38 @@
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: diagnose-if-support
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <atomic>
+
+// bool compare_exchange_strong(T& expected, T desired, memory_order success,
+// memory_order failure) const noexcept;
+//
+// Preconditions: failure is memory_order::relaxed, memory_order::consume,
+// memory_order::acquire, or memory_order::seq_cst.
+
+#include <atomic>
+
+void test() {
+  using T = int;
+
+  T x(T(1));
+  std::atomic_ref const a(x);
+
+  T expected(T(2));
+  T const desired(T(3));
+  std::memory_order const success = std::memory_order_relaxed;
+  // clang-format off
+  a.compare_exchange_strong(expected, desired, success, std::memory_order_relaxed);
+  a.compare_exchange_strong(expected, desired, success, std::memory_order_consume);
+  a.compare_exchange_strong(expected, desired, success, std::memory_order_acquire);
+  a.compare_exchange_strong(expected, desired, success, std::memory_order_seq_cst);
+  a.compare_exchange_strong(expected, desired, success, std::memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
+  a.compare_exchange_strong(expected, desired, success, std::memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
+  // clang-format on
+}

libcxx/test/libcxx/atomics/atomics.ref/compare_exchange_weak.verify.cpp

@@ -0,0 +1,38 @@
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: diagnose-if-support
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <atomic>
+
+// bool compare_exchange_weak(T& expected, T desired, memory_order success,
+// memory_order failure) const noexcept;
+//
+// Preconditions: failure is memory_order::relaxed, memory_order::consume,
+// memory_order::acquire, or memory_order::seq_cst.
+
+#include <atomic>
+
+void test() {
+  using T = int;
+
+  T x(T(42));
+  std::atomic_ref const a(x);
+
+  T expected(T(2));
+  T const desired(T(3));
+  std::memory_order const success = std::memory_order_relaxed;
+  // clang-format off
+  a.compare_exchange_weak(expected, desired, success, std::memory_order_relaxed);
+  a.compare_exchange_weak(expected, desired, success, std::memory_order_consume);
+  a.compare_exchange_weak(expected, desired, success, std::memory_order_acquire);
+  a.compare_exchange_weak(expected, desired, success, std::memory_order_seq_cst);
+  a.compare_exchange_weak(expected, desired, success, std::memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
+  a.compare_exchange_weak(expected, desired, success, std::memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
+  // clang-format on
+}

libcxx/test/libcxx/atomics/atomics.ref/load.verify.cpp

@@ -0,0 +1,33 @@
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: diagnose-if-support
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <atomic>
+
+// T load(memory_order order = memory_order::seq_cst) const noexcept;
+//
+// Preconditions: order is memory_order::relaxed, memory_order::consume, memory_order::acquire, or memory_order::seq_cst.
+
+#include <atomic>
+
+void test() {
+  using T = int;
+
+  T x(T(1));
+  std::atomic_ref const a(x);
+
+  // clang-format off
+  (void)a.load(std::memory_order_relaxed);
+  (void)a.load(std::memory_order_consume);
+  (void)a.load(std::memory_order_acquire);
+  (void)a.load(std::memory_order_seq_cst);
+  (void)a.load(std::memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
+  (void)a.load(std::memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
+  // clang-format on
+}

libcxx/test/libcxx/atomics/atomics.ref/store.verify.cpp

@@ -0,0 +1,35 @@
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: diagnose-if-support
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <atomic>
+
+// void store(T desired, memory_order order = memory_order::seq_cst) const noexcept;
+//
+// Preconditions: order is memory_order::relaxed, memory_order::release, or memory_order::seq_cst.
+
+#include <atomic>
+
+void test() {
+  using T = int;
+
+  T x(T(1));
+  std::atomic_ref const a(x);
+
+  T const desired(T(2));
+
+  // clang-format off
+  a.store(desired, std::memory_order_relaxed);
+  a.store(desired, std::memory_order_release);
+  a.store(desired, std::memory_order_seq_cst);
+  a.store(desired, std::memory_order_consume); // expected-warning {{memory order argument to atomic operation is invalid}}
+  a.store(desired, std::memory_order_acquire); // expected-warning {{memory order argument to atomic operation is invalid}}
+  a.store(desired, std::memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
+  // clang-format on
+}

libcxx/test/libcxx/atomics/atomics.ref/wait.verify.cpp

@@ -0,0 +1,35 @@
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: diagnose-if-support
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <atomic>
+
+// void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
+//
+// Preconditions: order is memory_order::relaxed, memory_order::consume, memory_order::acquire, or memory_order::seq_cst.
+
+#include <atomic>
+
+void test() {
+  using T = int;
+
+  T x(T(1));
+  std::atomic_ref const a(x);
+
+  T const old(T(2));
+
+  // clang-format off
+  a.wait(old, std::memory_order_relaxed);
+  a.wait(old, std::memory_order_consume);
+  a.wait(old, std::memory_order_acquire);
+  a.wait(old, std::memory_order_seq_cst);
+  a.wait(old, std::memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
+  a.wait(old, std::memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
+  // clang-format on
+}