[PATCH] Fix thread_annotation negtest for thread safety.

[richard.barton.arm]

Summary

Although not testing the annotations feature, the test still needs guarding for thread-safety otherwise it will not compile at all.

[EricWF]

I think this diff is messed up a little. Could you upload a fixed diff?

[richard.barton.arm]

Sorry - not sure what happened there. That looks better for me.

[EricWF]

I don't actually understand this change. This test should compile with or without "-Wthread-safety" warning. This test doesn't actually turn the annotations on, that's the point. If annotations were actually enabled this test would fail to compile.

Could you explain the error your seeing here?

[richard.barton.arm]

Hi Eric

Sorry for the delay - I originally detected the failure while not running in a totally clean environment with clean sources, but I can reproduce on clean code.

I can reproduce by building with clean clang and libcxx sources:
cmake -DLLVM_PATH=/work/ricbar01/llvm_oss/ -DLIBCXX_CXX_ABI=libcxxabi -DLIBCXX_CXX_ABI_INCLUDE_PATHS=../../libcxxabi_oss/include -DCMAKE_C_COMPILER=/work/ricbar01/llvm_oss/build/bin/clang -DCMAKE_CXX_COMPILER=/work/ricbar01/llvm_oss/build/bin/clang++ -DLIBCXX_ENABLE_THREADS=OFF -DLIBCXX_ENABLE_SHARED=OFF -DLIBCXX_ENABLE_ABI_LINKER_SCRIPT=OFF ..

I get errors like:
/work/ricbar01/libcxx_oss/test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.pass.cpp:21:8: error: no type named 'mutex' in namespace 'std'

std::mutex m;

From eyeballing the include/mutex it looks like the mutex class is #ifdeffec out when _LIBCPP_HAS_NO_THREADS is unset.

[EricWF]

I think the correct fix is "// UNSUPPORTED: libcpp-has-no-threads"

[EricWF]

And looking at the current state of the single-threaded test suite this isn't the only test that needs this fix applied.

http://lab.llvm.org:8011/builders/libcxx-libcxxabi-singlethreaded-x86_64-linux-debian/builds/869

[richard.barton.arm]

Thanks for the help Eric. I'm just running a new patch now will put the new patch up when I get back in to office tomorrow.

[jamesr]

In D18347#380792, @EricWF wrote:

And looking at the current state of the single-threaded test suite this isn't the only test that needs this fix applied.

http://lab.llvm.org:8011/builders/libcxx-libcxxabi-singlethreaded-x86_64-linux-debian/builds/869

Indeed! I assumed by reading other nearby tests that there was some mechanism that disabled the thread/ tests when threads were disabled, but didn't verify this. Sorry about the breakage.

[richard.barton.arm]

My local run with no threads works with this updated patch.

[EricWF]

LGTM! Thanks for the complete patch! The "no-threads" bot should now be green so future breakage will be detected immediately!

[richard.barton.arm]

Hi Eric - no problem at all, you practically wrote it for me after all ;-)

[EricWF]

This was committed in r264191.

test/libcxx/thread/thread.mutex/thread_safety_annotations_not_enabled.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
+
 // <mutex>
 
 // This test does not define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS so it
 // should compile without any warnings or errors even though this pattern is not
 // understood by the thread safety annotations.
 
 #include <mutex>
 
 int main() {
   std::mutex m;
   m.lock();
   {
     std::unique_lock<std::mutex> g(m, std::adopt_lock);
   }
 }

test/libcxx/thread/thread.mutex/thread_safety_lock_guard.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
 // REQUIRES: thread-safety
 
 // <mutex>
 
 #define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
 
 #include <mutex>
 
 std::mutex m;
 int foo __attribute__((guarded_by(m)));
 
 int main() {
   std::lock_guard<std::mutex> lock(m);
   foo++;
 }

test/libcxx/thread/thread.mutex/thread_safety_lock_unlock.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
 // REQUIRES: thread-safety
 
 // <mutex>
 
 #define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
 
 #include <mutex>
 
 std::mutex m;
 int foo __attribute__((guarded_by(m)));
 
 int main() {
   m.lock();
   foo++;
   m.unlock();
 }

test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
 // REQUIRES: thread-safety
 
 // <mutex>
 
 #define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
 
 #include <mutex>
 
 std::mutex m;
 
 int main() {
   m.lock();
 } // expected-error {{mutex 'm' is still held at the end of function}}

test/libcxx/thread/thread.mutex/thread_safety_requires_capability.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.
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-threads
 // REQUIRES: thread-safety
 
 // <mutex>
 
 #define _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
 
 #include <mutex>
 

test/std/thread/futures/futures.promise/copy_assign.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.
 //
 //===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
 
 // <future>
 
 // class promise<R>
 
 // promise& operator=(const promise& rhs) = delete;
 
 #include <future>

test/std/thread/futures/futures.promise/copy_ctor.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.
 //
 //===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
 
 // <future>
 
 // class promise<R>
 
 // promise(const promise&) = delete;
 
 #include <future>

test/std/thread/futures/futures.tas/futures.task.members/assign_copy.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.
 //
 //===----------------------------------------------------------------------===//
-
+//
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class packaged_task<R(ArgTypes...)>
 
 // packaged_task& operator=(packaged_task&) = delete;
 

test/std/thread/futures/futures.tas/futures.task.members/ctor1.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.
 //
 //===----------------------------------------------------------------------===//
-
+//
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class packaged_task<R(ArgTypes...)>
 // template <class F>
 //   packaged_task(F&& f);
 // These constructors shall not participate in overload resolution if 

test/std/thread/futures/futures.tas/futures.task.members/ctor2.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.
 //
 //===----------------------------------------------------------------------===//
-
+//
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class packaged_task<R(ArgTypes...)>
 // template <class F, class Allocator>
 //   packaged_task(allocator_arg_t, const Allocator& a, F&& f);
 // These constructors shall not participate in overload resolution if 

test/std/thread/futures/futures.tas/futures.task.members/ctor_copy.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.
 //
 //===----------------------------------------------------------------------===//
-
+//
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class packaged_task<R(ArgTypes...)>
 
 // packaged_task(packaged_task&) = delete;
 

test/std/thread/futures/futures.unique_future/copy_assign.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.
 //
 //===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
 
 // <future>
 
 // class future<R>
 
 // future& operator=(const future&) = delete;
 
 #include <future>

test/std/thread/futures/futures.unique_future/copy_ctor.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.
 //
 //===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
 
 // <future>
 
 // class future<R>
 
 // future(const future&) = delete;
 
 #include <future>

test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/assign.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.
 //
 //===----------------------------------------------------------------------===//
 //
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <shared_mutex>
 
 // class shared_mutex;
 
 // shared_mutex& operator=(const shared_mutex&) = delete;
 
 #include <shared_mutex>
 
 int main()
 {
     std::shared_mutex m0;
     std::shared_mutex m1;
     m1 = m0; // expected-error {{overload resolution selected deleted operator '='}}
 }

test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/copy.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.
 //
 //===----------------------------------------------------------------------===//
 //
+// UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <shared_mutex>
 
 // class shared_mutex;
 
 // shared_mutex(const shared_mutex&) = delete;
 
 #include <shared_mutex>
 
 int main()
 {
     std::shared_mutex m0;
     std::shared_mutex m1(m0); // expected-error {{call to deleted constructor of 'std::shared_mutex'}}
 }