intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-21 12:19:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

[libc++] Add -Watomic-memory-ordering diagnostic tests for atomic_ref (#130206)

Browse Source 
Fix #130053
This commit is contained in:
Damien L-G
2025-03-10 16:32:13 -04:00
committed by GitHub
parent f84f4e1e05
commit e235432867
11 changed files with 190 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libcxx/test/libcxx/atomics/atomics.ref/assert.compare_exchange_strong.pass.cpp
View File

@@ -1,3 +1,4 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.

1
libcxx/test/libcxx/atomics/atomics.ref/assert.compare_exchange_weak.pass.cpp
View File

@@ -1,3 +1,4 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.

1
libcxx/test/libcxx/atomics/atomics.ref/assert.ctor.pass.cpp
View File

@@ -1,3 +1,4 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.

1
libcxx/test/libcxx/atomics/atomics.ref/assert.load.pass.cpp
View File

@@ -1,3 +1,4 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.

1
libcxx/test/libcxx/atomics/atomics.ref/assert.store.pass.cpp
View File

@@ -1,3 +1,4 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.

1
libcxx/test/libcxx/atomics/atomics.ref/assert.wait.pass.cpp
View File

@@ -1,3 +1,4 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.

39
libcxx/test/libcxx/atomics/atomics.ref/compare_exchange_strong.verify.cpp Normal file
View File

@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// 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
}

39
libcxx/test/libcxx/atomics/atomics.ref/compare_exchange_weak.verify.cpp Normal file
View File

@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// 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
}

34
libcxx/test/libcxx/atomics/atomics.ref/load.verify.cpp Normal file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// 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
}

36
libcxx/test/libcxx/atomics/atomics.ref/store.verify.cpp Normal file
View File

@@ -0,0 +1,36 @@
//===----------------------------------------------------------------------===//
//
// 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
}

36
libcxx/test/libcxx/atomics/atomics.ref/wait.verify.cpp Normal file
View File

@@ -0,0 +1,36 @@
//===----------------------------------------------------------------------===//
//
// 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
}