[libcxx] Add clang negative thread safety assertions to std::mutex

[lhchavez]

Summary

This adds clang negative thread safery assertion support to std::mutex,
as documented in:

https://clang.llvm.org/docs/ThreadSafetyAnalysis.html

Fixes #34951.

[mclow.lists]

include/__mutex_base

65

We don't get to add public member functions to classes defined in the standard - at least not ones with pronounceable names.

[lhchavez]

include/__mutex_base

65

So there's no way to support negative assertions as stated in the docs? That's unfortunate :(

include/__mutex_base

 private:
     mutex(const mutex&);// = delete;
     mutex& operator=(const mutex&);// = delete;
 
 public:
     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());
+#ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
+    const mutex& operator!() const { return *this; }
+#endif
 
     typedef __libcpp_mutex_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
 };
 
 static_assert(is_nothrow_default_constructible<mutex>::value,
               "the default constructor for std::mutex must be nothrow");
 

test/libcxx/thread/thread.mutex/thread_safety_annotations_negative.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: thread-safety, thread-safety-negative
+
+// <mutex>
+
+#define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+
+#include <mutex>
+
+std::mutex m;
+int foo __attribute__((guarded_by(m)));
+
+void increment() __attribute__((requires_capability(!m))) {
+  m.lock();
+  foo++;
+  m.unlock();
+}
+
+int main() {
+  m.lock();
+  increment();
+  m.unlock();
+}

test/libcxx/thread/thread.mutex/thread_safety_annotations_negative.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: thread-safety, thread-safety-negative
+
+// <mutex>
+
+#define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+
+#include <mutex>
+
+std::mutex m;
+int foo __attribute__((guarded_by(m)));
+
+void increment() __attribute__((requires_capability(!m))) {
+  m.lock();
+  foo++;
+  m.unlock();
+}
+
+int main() {
+  increment();
+}

utils/libcxx/test/config.py

def configure(self):
         self.configure_deployment()
         self.configure_availability()
         self.configure_src_root()
         self.configure_obj_root()
         self.configure_cxx_stdlib_under_test()
         self.configure_cxx_library_root()
         self.configure_use_clang_verify()
         self.configure_use_thread_safety()
+        self.configure_use_thread_safety_negative()
         self.configure_execute_external()
         self.configure_ccache()
         self.configure_compile_flags()
         self.configure_filesystem_compile_flags()
         self.configure_link_flags()
         self.configure_env()
         self.configure_color_diagnostics()
         self.configure_debug_mode()
class Configuration(object):
     def configure_use_thread_safety(self):
         '''If set, run clang with -verify on failing tests.'''
         has_thread_safety = self.cxx.hasCompileFlag('-Werror=thread-safety')
         if has_thread_safety:
             self.cxx.compile_flags += ['-Werror=thread-safety']
             self.config.available_features.add('thread-safety')
             self.lit_config.note("enabling thread-safety annotations")
 
+    def configure_use_thread_safety_negative(self):
+        '''If set, run clang with -verify on failing tests.'''
+        has_thread_safety_negative = self.cxx.hasCompileFlag(
+            '-Werror=thread-safety-negative')
+        if has_thread_safety_negative:
+            self.cxx.compile_flags += ['-Werror=thread-safety-negative']
+            self.config.available_features.add('thread-safety-negative')
+            self.lit_config.note("enabling thread-safety-negative annotations")
+
     def configure_execute_external(self):
         # Choose between lit's internal shell pipeline runner and a real shell.
         # If LIT_USE_INTERNAL_SHELL is in the environment, we use that as the
         # default value. Otherwise we ask the target_info.
         use_lit_shell_default = os.environ.get('LIT_USE_INTERNAL_SHELL')
         if use_lit_shell_default is not None:
             use_lit_shell_default = use_lit_shell_default != '0'
         else: