[libcxx-commits] [libcxx] [libc++] Add the thread safety annotations unconditionally (PR #117497)
Nikolas Klauser via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Jun 11 11:37:29 PDT 2025
https://github.com/philnik777 updated https://github.com/llvm/llvm-project/pull/117497
>From 208f56ba01945bcd46d328df87efc9c9d65436c1 Mon Sep 17 00:00:00 2001
From: Nikolas Klauser <nikolasklauser at berlin.de>
Date: Sun, 24 Nov 2024 16:44:16 +0100
Subject: [PATCH] [libc++] Add the thread safety annotations unconditionally
---
libcxx/.clang-format | 9 ++-
libcxx/docs/UserDocumentation.rst | 5 --
libcxx/include/__config | 71 ++++++++++++++-----
libcxx/include/__mutex/lock_guard.h | 10 ++-
libcxx/include/__mutex/mutex.h | 8 +--
libcxx/include/mutex | 11 ++-
libcxx/include/shared_mutex | 54 ++++++--------
.../thread_safety_lock_guard.pass.cpp | 5 +-
.../thread_safety_lock_unlock.pass.cpp | 5 +-
.../thread_safety_missing_unlock.verify.cpp | 7 +-
...thread_safety_requires_capability.pass.cpp | 5 +-
.../thread_safety.verify.cpp | 8 +--
.../thread_safety.verify.cpp | 12 ++--
libcxx/utils/libcxx/test/features.py | 5 --
14 files changed, 120 insertions(+), 95 deletions(-)
diff --git a/libcxx/.clang-format b/libcxx/.clang-format
index fe2f2ef0119fa..f372ac9619997 100644
--- a/libcxx/.clang-format
+++ b/libcxx/.clang-format
@@ -16,8 +16,11 @@ AllowShortLambdasOnASingleLine: All
AttributeMacros: [
'_ALIGNAS_TYPE',
'_ALIGNAS',
+ '_LIBCPP_ACQUIRE_CAPABILITY',
+ '_LIBCPP_ACQUIRE_SHARED_CAPABILITY',
'_LIBCPP_ALIGNOF',
'_LIBCPP_ALWAYS_INLINE',
+ '_LIBCPP_CAPABILITY',
'_LIBCPP_CONSTEXPR_SINCE_CXX14',
'_LIBCPP_CONSTEXPR_SINCE_CXX17',
'_LIBCPP_CONSTEXPR_SINCE_CXX20',
@@ -41,9 +44,13 @@ AttributeMacros: [
'_LIBCPP_NO_UNIQUE_ADDRESS',
'_LIBCPP_NOALIAS',
'_LIBCPP_OVERRIDABLE_FUNC_VIS',
+ '_LIBCPP_RELEASE_CAPABILITY',
+ '_LIBCPP_REQUIRES_CAPABILITY',
+ '_LIBCPP_SCOPED_LOCKABLE',
'_LIBCPP_STANDALONE_DEBUG',
'_LIBCPP_TEMPLATE_DATA_VIS',
- '_LIBCPP_THREAD_SAFETY_ANNOTATION',
+ '_LIBCPP_TRY_ACQUIRE_CAPABILITY',
+ '_LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY',
'_LIBCPP_USING_IF_EXISTS',
'_LIBCPP_WEAK',
]
diff --git a/libcxx/docs/UserDocumentation.rst b/libcxx/docs/UserDocumentation.rst
index f82554a4869fa..79f5908bdc6b6 100644
--- a/libcxx/docs/UserDocumentation.rst
+++ b/libcxx/docs/UserDocumentation.rst
@@ -114,11 +114,6 @@ enable or disable extended libc++ behavior.
ensure that the appropriate experimental library (usually ``libc++experimental.a``)
is linked into their program.
-**_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS**:
- This macro is used to enable -Wthread-safety annotations on libc++'s
- ``std::mutex`` and ``std::lock_guard``. By default, these annotations are
- disabled and must be manually enabled by the user.
-
**_LIBCPP_HARDENING_MODE**:
This macro is used to choose the :ref:`hardening mode <using-hardening-modes>`.
diff --git a/libcxx/include/__config b/libcxx/include/__config
index 38c47e8d45c81..cb4f44e075d7d 100644
--- a/libcxx/include/__config
+++ b/libcxx/include/__config
@@ -910,23 +910,6 @@ typedef __char32_t char32_t;
# define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
# endif
-// Work around the attribute handling in clang. When both __declspec and
-// __attribute__ are present, the processing goes awry preventing the definition
-// of the types. In MinGW mode, __declspec evaluates to __attribute__, and thus
-// combining the two does work.
-# if defined(_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS) && defined(__clang__) && \
- __has_attribute(acquire_capability) && !defined(_MSC_VER)
-# define _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS 1
-# else
-# define _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS 0
-# endif
-
-# if _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
-# define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
-# else
-# define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
-# endif
-
# if _LIBCPP_STD_VER >= 20
# define _LIBCPP_CONSTINIT constinit
# elif __has_attribute(__require_constant_initialization__)
@@ -1154,6 +1137,60 @@ typedef __char32_t char32_t;
# define _LIBCPP_PREFERRED_NAME(x)
# endif
+# if __has_cpp_attribute(_Clang::__scoped_lockable__)
+# define _LIBCPP_SCOPED_LOCKABLE [[_Clang::__scoped_lockable__]]
+# else
+# define _LIBCPP_SCOPED_LOCKABLE
+# endif
+
+# if __has_cpp_attribute(_Clang::__capability__)
+# define _LIBCPP_CAPABILITY(...) [[_Clang::__capability__(__VA_ARGS__)]]
+# else
+# define _LIBCPP_CAPABILITY(...)
+# endif
+
+# if __has_attribute(__acquire_capability__)
+# define _LIBCPP_ACQUIRE_CAPABILITY(...) __attribute__((__acquire_capability__(__VA_ARGS__)))
+# else
+# define _LIBCPP_ACQUIRE_CAPABILITY(...)
+# endif
+
+# if __has_cpp_attribute(_Clang::__try_acquire_capability__)
+# define _LIBCPP_TRY_ACQUIRE_CAPABILITY(...) [[_Clang::__try_acquire_capability__(__VA_ARGS__)]]
+# else
+# define _LIBCPP_TRY_ACQUIRE_CAPABILITY(...)
+# endif
+
+# if __has_cpp_attribute(_Clang::__acquire_shared_capability__)
+# define _LIBCPP_ACQUIRE_SHARED_CAPABILITY [[_Clang::__acquire_shared_capability__]]
+# else
+# define _LIBCPP_ACQUIRE_SHARED_CAPABILITY
+# endif
+
+# if __has_cpp_attribute(_Clang::__try_acquire_shared_capability__)
+# define _LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY(...) [[_Clang::__try_acquire_shared_capability__(__VA_ARGS__)]]
+# else
+# define _LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY(...)
+# endif
+
+# if __has_cpp_attribute(_Clang::__release_capability__)
+# define _LIBCPP_RELEASE_CAPABILITY [[_Clang::__release_capability__]]
+# else
+# define _LIBCPP_RELEASE_CAPABILITY
+# endif
+
+# if __has_cpp_attribute(_Clang::__release_shared_capability__)
+# define _LIBCPP_RELEASE_SHARED_CAPABILITY [[_Clang::__release_shared_capability__]]
+# else
+# define _LIBCPP_RELEASE_SHARED_CAPABILITY
+# endif
+
+# if __has_attribute(__requires_capability__)
+# define _LIBCPP_REQUIRES_CAPABILITY(...) __attribute__((__requires_capability__(__VA_ARGS__)))
+# else
+# define _LIBCPP_REQUIRES_CAPABILITY(...)
+# endif
+
# if defined(_LIBCPP_ABI_MICROSOFT) && __has_declspec_attribute(empty_bases)
# define _LIBCPP_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
# else
diff --git a/libcxx/include/__mutex/lock_guard.h b/libcxx/include/__mutex/lock_guard.h
index a529c552a1df0..67a25ed2f8a89 100644
--- a/libcxx/include/__mutex/lock_guard.h
+++ b/libcxx/include/__mutex/lock_guard.h
@@ -19,7 +19,7 @@
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Mutex>
-class _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) lock_guard {
+class _LIBCPP_SCOPED_LOCKABLE lock_guard {
public:
typedef _Mutex mutex_type;
@@ -27,16 +27,14 @@ class _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) lock_guard {
mutex_type& __m_;
public:
- [[__nodiscard__]]
- _LIBCPP_HIDE_FROM_ABI explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
+ [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI explicit lock_guard(mutex_type& __m) _LIBCPP_ACQUIRE_CAPABILITY(__m)
: __m_(__m) {
__m_.lock();
}
- [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI lock_guard(mutex_type& __m, adopt_lock_t)
- _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
+ [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_REQUIRES_CAPABILITY(__m)
: __m_(__m) {}
- _LIBCPP_HIDE_FROM_ABI ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) { __m_.unlock(); }
+ _LIBCPP_RELEASE_CAPABILITY _LIBCPP_HIDE_FROM_ABI ~lock_guard() { __m_.unlock(); }
lock_guard(lock_guard const&) = delete;
lock_guard& operator=(lock_guard const&) = delete;
diff --git a/libcxx/include/__mutex/mutex.h b/libcxx/include/__mutex/mutex.h
index 317320287902f..68c8842b35eda 100644
--- a/libcxx/include/__mutex/mutex.h
+++ b/libcxx/include/__mutex/mutex.h
@@ -21,7 +21,7 @@
_LIBCPP_BEGIN_NAMESPACE_STD
-class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex {
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_CAPABILITY("mutex") mutex {
__libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
public:
@@ -36,9 +36,9 @@ class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mut
~mutex() _NOEXCEPT;
# endif
- void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability());
- bool try_lock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
- void unlock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
+ _LIBCPP_ACQUIRE_CAPABILITY() void lock();
+ _LIBCPP_TRY_ACQUIRE_CAPABILITY(true) bool try_lock() _NOEXCEPT;
+ _LIBCPP_RELEASE_CAPABILITY void unlock() _NOEXCEPT;
typedef __libcpp_mutex_t* native_handle_type;
_LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }
diff --git a/libcxx/include/mutex b/libcxx/include/mutex
index e058b3113073e..6cbffc155dd3a 100644
--- a/libcxx/include/mutex
+++ b/libcxx/include/mutex
@@ -434,7 +434,7 @@ public:
};
template <class _Mutex>
-class _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) scoped_lock<_Mutex> {
+class _LIBCPP_SCOPED_LOCKABLE scoped_lock<_Mutex> {
public:
typedef _Mutex mutex_type;
@@ -442,16 +442,15 @@ private:
mutex_type& __m_;
public:
- [[nodiscard]]
- _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(mutex_type& __m) _LIBCPP_ACQUIRE_CAPABILITY(__m)
: __m_(__m) {
__m_.lock();
}
- ~scoped_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) { __m_.unlock(); }
+ _LIBCPP_RELEASE_CAPABILITY _LIBCPP_HIDE_FROM_ABI ~scoped_lock() { __m_.unlock(); }
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t, mutex_type& __m)
- _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
+ [[nodiscard]]
+ _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t, mutex_type& __m) _LIBCPP_REQUIRES_CAPABILITY(__m)
: __m_(__m) {}
scoped_lock(scoped_lock const&) = delete;
diff --git a/libcxx/include/shared_mutex b/libcxx/include/shared_mutex
index e6759e413dfef..2108b83c20e6c 100644
--- a/libcxx/include/shared_mutex
+++ b/libcxx/include/shared_mutex
@@ -183,7 +183,7 @@ struct _LIBCPP_EXPORTED_FROM_ABI __shared_mutex_base {
};
# if _LIBCPP_STD_VER >= 17
-class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_THREAD_SAFETY_ANNOTATION(__capability__("shared_mutex")) shared_mutex {
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_CAPABILITY("shared_mutex") shared_mutex {
__shared_mutex_base __base_;
public:
@@ -194,25 +194,16 @@ public:
shared_mutex& operator=(const shared_mutex&) = delete;
// Exclusive ownership
- _LIBCPP_HIDE_FROM_ABI void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__acquire_capability__()) {
- return __base_.lock();
- }
- _LIBCPP_HIDE_FROM_ABI bool try_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_capability__(true)) {
- return __base_.try_lock();
- }
- _LIBCPP_HIDE_FROM_ABI void unlock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__release_capability__()) {
- return __base_.unlock();
- }
+ _LIBCPP_ACQUIRE_CAPABILITY() _LIBCPP_HIDE_FROM_ABI void lock() { return __base_.lock(); }
+ _LIBCPP_TRY_ACQUIRE_CAPABILITY(true) _LIBCPP_HIDE_FROM_ABI bool try_lock() { return __base_.try_lock(); }
+ _LIBCPP_RELEASE_CAPABILITY _LIBCPP_HIDE_FROM_ABI void unlock() { return __base_.unlock(); }
// Shared ownership
- _LIBCPP_HIDE_FROM_ABI void lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__acquire_shared_capability__()) {
- return __base_.lock_shared();
- }
- _LIBCPP_HIDE_FROM_ABI bool try_lock_shared()
- _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_shared_capability__(true)) {
+ _LIBCPP_ACQUIRE_SHARED_CAPABILITY _LIBCPP_HIDE_FROM_ABI void lock_shared() { return __base_.lock_shared(); }
+ _LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY(true) _LIBCPP_HIDE_FROM_ABI bool try_lock_shared() {
return __base_.try_lock_shared();
}
- _LIBCPP_HIDE_FROM_ABI void unlock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__release_shared_capability__()) {
+ _LIBCPP_RELEASE_SHARED_CAPABILITY _LIBCPP_HIDE_FROM_ABI void unlock_shared() {
return __base_.unlock_shared();
}
@@ -221,8 +212,7 @@ public:
};
# endif
-class _LIBCPP_EXPORTED_FROM_ABI
-_LIBCPP_THREAD_SAFETY_ANNOTATION(__capability__("shared_timed_mutex")) shared_timed_mutex {
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_CAPABILITY("shared_timed_mutex") shared_timed_mutex {
__shared_mutex_base __base_;
public:
@@ -233,17 +223,17 @@ public:
shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
// Exclusive ownership
- void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__acquire_capability__());
- bool try_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_capability__(true));
+ void lock() _LIBCPP_ACQUIRE_CAPABILITY();
+ _LIBCPP_TRY_ACQUIRE_CAPABILITY(true) bool try_lock();
template <class _Rep, class _Period>
- _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
- _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_capability__(true)) {
+ _LIBCPP_TRY_ACQUIRE_CAPABILITY(true) _LIBCPP_HIDE_FROM_ABI bool
+ try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time) {
return try_lock_until(chrono::steady_clock::now() + __rel_time);
}
template <class _Clock, class _Duration>
- _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
- _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_capability__(true)) {
+ _LIBCPP_TRY_ACQUIRE_CAPABILITY(true) _LIBCPP_HIDE_FROM_ABI bool
+ try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time) {
unique_lock<mutex> __lk(__base_.__mut_);
if (__base_.__state_ & __base_.__write_entered_) {
while (true) {
@@ -270,20 +260,20 @@ public:
return true;
}
- void unlock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__release_capability__());
+ _LIBCPP_RELEASE_CAPABILITY void unlock();
// Shared ownership
- void lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__acquire_shared_capability__());
- bool try_lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_shared_capability__(true));
+ _LIBCPP_ACQUIRE_SHARED_CAPABILITY void lock_shared();
+ _LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY(true) bool try_lock_shared();
template <class _Rep, class _Period>
- _LIBCPP_HIDE_FROM_ABI bool try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
- _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_shared_capability__(true)) {
+ _LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY(true) _LIBCPP_HIDE_FROM_ABI bool
+ try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time) {
return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
}
template <class _Clock, class _Duration>
- _LIBCPP_HIDE_FROM_ABI bool try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
- _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_shared_capability__(true)) {
+ _LIBCPP_TRY_ACQUIRE_SHARED_CAPABILITY(true) _LIBCPP_HIDE_FROM_ABI bool
+ try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time) {
unique_lock<mutex> __lk(__base_.__mut_);
if ((__base_.__state_ & __base_.__write_entered_) ||
(__base_.__state_ & __base_.__n_readers_) == __base_.__n_readers_) {
@@ -302,7 +292,7 @@ public:
return true;
}
- void unlock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__release_shared_capability__());
+ _LIBCPP_RELEASE_SHARED_CAPABILITY void unlock_shared();
};
template <class _Mutex>
diff --git a/libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp b/libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
index 1c1f36459c837..7db5baaa744c1 100644
--- a/libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
+++ b/libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_guard.pass.cpp
@@ -11,11 +11,12 @@
// XFAIL: msvc
// UNSUPPORTED: no-threads
-// REQUIRES: thread-safety
// <mutex>
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+// ADDITIONAL_COMPILE_FLAGS: -Wthread-safety
+
+// XFAIL: FROZEN-CXX03-HEADERS-FIXME
#include <mutex>
diff --git a/libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp b/libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
index ddfe3269fdfa7..98bad19884d2e 100644
--- a/libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
+++ b/libcxx/test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.pass.cpp
@@ -11,11 +11,12 @@
// XFAIL: msvc
// UNSUPPORTED: no-threads
-// REQUIRES: thread-safety
+
+// XFAIL: FROZEN-CXX03-HEADERS-FIXME
// <mutex>
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+// ADDITIONAL_COMPILE_FLAGS: -Wthread-safety
#include <mutex>
diff --git a/libcxx/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.verify.cpp b/libcxx/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.verify.cpp
index bab686e7b4ca2..db81885bdd847 100644
--- a/libcxx/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.verify.cpp
+++ b/libcxx/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.verify.cpp
@@ -11,11 +11,12 @@
// XFAIL: msvc
// UNSUPPORTED: no-threads
-// REQUIRES: thread-safety
// <mutex>
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+// ADDITIONAL_COMPILE_FLAGS: -Wthread-safety
+
+// XFAIL: FROZEN-CXX03-HEADERS-FIXME
#include <mutex>
@@ -23,4 +24,4 @@ std::mutex m;
void f() {
m.lock();
-} // expected-error {{mutex 'm' is still held at the end of function}}
+} // expected-warning {{mutex 'm' is still held at the end of function}}
diff --git a/libcxx/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp b/libcxx/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
index 81ce3b25a8394..943cefe556bff 100644
--- a/libcxx/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
+++ b/libcxx/test/libcxx/thread/thread.mutex/thread_safety_requires_capability.pass.cpp
@@ -11,11 +11,12 @@
// XFAIL: msvc
// UNSUPPORTED: no-threads
-// REQUIRES: thread-safety
// <mutex>
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+// ADDITIONAL_COMPILE_FLAGS: -Wthread-safety
+
+// XFAIL: FROZEN-CXX03-HEADERS-FIXME
#include <mutex>
diff --git a/libcxx/test/libcxx/thread/thread.shared_mutex/thread_safety.verify.cpp b/libcxx/test/libcxx/thread/thread.shared_mutex/thread_safety.verify.cpp
index fee940fff847b..64b2c20241115 100644
--- a/libcxx/test/libcxx/thread/thread.shared_mutex/thread_safety.verify.cpp
+++ b/libcxx/test/libcxx/thread/thread.shared_mutex/thread_safety.verify.cpp
@@ -8,8 +8,8 @@
// UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: no-threads
-// REQUIRES: thread-safety
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+
+// ADDITIONAL_COMPILE_FLAGS: -Wthread-safety
// On Windows Clang bugs out when both __declspec and __attribute__ are present,
// the processing goes awry preventing the definition of the types.
@@ -51,13 +51,13 @@ void f() {
{
m.lock_shared();
read(data); // ok
- ++data; // expected-error {{writing variable 'data' requires holding shared_mutex 'm' exclusively}}
+ ++data; // expected-warning {{writing variable 'data' requires holding shared_mutex 'm' exclusively}}
m.unlock_shared();
}
{
if (m.try_lock_shared()) {
read(data); // ok
- ++data; // expected-error {{writing variable 'data' requires holding shared_mutex 'm' exclusively}}
+ ++data; // expected-warning {{writing variable 'data' requires holding shared_mutex 'm' exclusively}}
m.unlock_shared();
}
}
diff --git a/libcxx/test/libcxx/thread/thread.shared_timed_mutex/thread_safety.verify.cpp b/libcxx/test/libcxx/thread/thread.shared_timed_mutex/thread_safety.verify.cpp
index baa8bc614f149..e1c81a65de666 100644
--- a/libcxx/test/libcxx/thread/thread.shared_timed_mutex/thread_safety.verify.cpp
+++ b/libcxx/test/libcxx/thread/thread.shared_timed_mutex/thread_safety.verify.cpp
@@ -8,8 +8,8 @@
// UNSUPPORTED: c++03, c++11
// UNSUPPORTED: no-threads
-// REQUIRES: thread-safety
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+
+// ADDITIONAL_COMPILE_FLAGS: -Wthread-safety
// On Windows Clang bugs out when both __declspec and __attribute__ are present,
// the processing goes awry preventing the definition of the types.
@@ -68,27 +68,27 @@ void f(std::chrono::time_point<std::chrono::steady_clock> tp, std::chrono::milli
{
m.lock_shared();
read(data); // ok
- ++data; // expected-error {{writing variable 'data' requires holding shared_timed_mutex 'm' exclusively}}
+ ++data; // expected-warning {{writing variable 'data' requires holding shared_timed_mutex 'm' exclusively}}
m.unlock_shared();
}
{
if (m.try_lock_shared()) {
read(data); // ok
- ++data; // expected-error {{writing variable 'data' requires holding shared_timed_mutex 'm' exclusively}}
+ ++data; // expected-warning {{writing variable 'data' requires holding shared_timed_mutex 'm' exclusively}}
m.unlock_shared();
}
}
{
if (m.try_lock_shared_for(d)) {
read(data); // ok
- ++data; // expected-error {{writing variable 'data' requires holding shared_timed_mutex 'm' exclusively}}
+ ++data; // expected-warning {{writing variable 'data' requires holding shared_timed_mutex 'm' exclusively}}
m.unlock_shared();
}
}
{
if (m.try_lock_shared_until(tp)) {
read(data); // ok
- ++data; // expected-error {{writing variable 'data' requires holding shared_timed_mutex 'm' exclusively}}
+ ++data; // expected-warning {{writing variable 'data' requires holding shared_timed_mutex 'm' exclusively}}
m.unlock_shared();
}
}
diff --git a/libcxx/utils/libcxx/test/features.py b/libcxx/utils/libcxx/test/features.py
index 74746e37d3bc4..99e374352408c 100644
--- a/libcxx/utils/libcxx/test/features.py
+++ b/libcxx/utils/libcxx/test/features.py
@@ -134,11 +134,6 @@ def _mingwSupportsModules(cfg):
Feature(name=lambda cfg: "msvc-{}".format(*_msvcVersion(cfg)), when=_isMSVC),
Feature(name=lambda cfg: "msvc-{}.{}".format(*_msvcVersion(cfg)), when=_isMSVC),
- Feature(
- name="thread-safety",
- when=lambda cfg: hasCompileFlag(cfg, "-Werror=thread-safety"),
- actions=[AddCompileFlag("-Werror=thread-safety")],
- ),
Feature(
name="diagnose-if-support",
when=lambda cfg: hasCompileFlag(cfg, "-Wuser-defined-warnings"),
More information about the libcxx-commits
mailing list