Update on the bot failures: I've spoken to the owner of the bots and they are planning to upgrade their Clang versions. This will get the bots green again.
/Eric On Mon, Jun 13, 2016 at 11:49 PM, Eric Fiselier <e...@efcs.ca> wrote: > This is causing some of the libc++ bots to go red. > `variadic_copy.fail.cpp` is encountering an error, which seems to be a > clang bug which temporarily existed in 3.9. > The test passes against current ToT and older clang releases and GCC. > > Please do not revert this commit due to that specific failure. I am aware > of it and I am working to fix it. > > On Mon, Jun 13, 2016 at 9:48 PM, Eric Fiselier via cfe-commits < > cfe-commits@lists.llvm.org> wrote: > >> Author: ericwf >> Date: Mon Jun 13 22:48:09 2016 >> New Revision: 272634 >> >> URL: http://llvm.org/viewvc/llvm-project?rev=272634&view=rev >> Log: >> Implement variadic lock_guard. >> >> Summary: >> This patch implements the variadic `lock_guard` paper. >> >> Making `lock_guard` variadic is a ABI breaking change because the >> specialization `lock_guard<_Mutex>` mangles differently then when it was >> the primary template. This change only provides variadic `lock_guard` in >> ABI V2 or when `_LIBCPP_ABI_VARIADIC_LOCK_GUARD` is defined. >> >> Note that in ABI V2 `lock_guard` must always be declared as a variadic >> template, even in C++03, in order to keep the ABI consistent. For this >> reason `lock_guard` is forward declared as a variadic template in all >> standard dialects and therefore depends on variadic templates being >> provided as an extension in C++03. All supported versions of Clang and GCC >> provide this extension. >> >> >> >> >> Reviewers: mclow.lists >> >> Subscribers: K-ballo, mclow.lists, cfe-commits >> >> Differential Revision: http://reviews.llvm.org/D21260 >> >> Added: >> libcxx/trunk/test/libcxx/thread/thread.mutex/thread.lock/ >> >> libcxx/trunk/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/ >> >> libcxx/trunk/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_mangling.pass.cpp >> >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_adopt_lock.pass.cpp >> >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_assign.fail.cpp >> >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_copy.fail.cpp >> >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.fail.cpp >> >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.pass.cpp >> >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_cxx03.pass.cpp >> >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_types.pass.cpp >> Modified: >> libcxx/trunk/include/__config >> libcxx/trunk/include/__mutex_base >> libcxx/trunk/include/mutex >> >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp >> libcxx/trunk/www/cxx1z_status.html >> >> Modified: libcxx/trunk/include/__config >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__config?rev=272634&r1=272633&r2=272634&view=diff >> >> ============================================================================== >> --- libcxx/trunk/include/__config (original) >> +++ libcxx/trunk/include/__config Mon Jun 13 22:48:09 2016 >> @@ -43,6 +43,7 @@ >> #define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB >> #define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB >> #define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> #endif >> >> #define _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_X##_LIBCPP_Y >> >> Modified: libcxx/trunk/include/__mutex_base >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__mutex_base?rev=272634&r1=272633&r2=272634&view=diff >> >> ============================================================================== >> --- libcxx/trunk/include/__mutex_base (original) >> +++ libcxx/trunk/include/__mutex_base Mon Jun 13 22:48:09 2016 >> @@ -76,8 +76,21 @@ constexpr adopt_lock_t adopt_lock = ad >> >> #endif >> >> + >> +// Forward declare lock_guard as a variadic template even in C++03 to >> keep >> +// the mangling consistent between dialects. >> +#if defined(_LIBCPP_ABI_VARIADIC_LOCK_GUARD) >> +template <class ..._Mutexes> >> +class _LIBCPP_TYPE_VIS_ONLY lock_guard; >> +#endif >> + >> template <class _Mutex> >> -class _LIBCPP_TYPE_VIS_ONLY >> _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) lock_guard >> +class _LIBCPP_TYPE_VIS_ONLY >> _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) >> +#if !defined(_LIBCPP_ABI_VARIADIC_LOCK_GUARD) >> +lock_guard >> +#else >> +lock_guard<_Mutex> >> +#endif >> { >> public: >> typedef _Mutex mutex_type; >> @@ -96,8 +109,8 @@ public: >> ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) >> {__m_.unlock();} >> >> private: >> - lock_guard(lock_guard const&);// = delete; >> - lock_guard& operator=(lock_guard const&);// = delete; >> + lock_guard(lock_guard const&) _LIBCPP_EQUAL_DELETE; >> + lock_guard& operator=(lock_guard const&) _LIBCPP_EQUAL_DELETE; >> }; >> >> template <class _Mutex> >> >> Modified: libcxx/trunk/include/mutex >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/mutex?rev=272634&r1=272633&r2=272634&view=diff >> >> ============================================================================== >> --- libcxx/trunk/include/mutex (original) >> +++ libcxx/trunk/include/mutex Mon Jun 13 22:48:09 2016 >> @@ -109,6 +109,19 @@ public: >> lock_guard& operator=(lock_guard const&) = delete; >> }; >> >> +template <class... MutexTypes> // Variadic lock_guard only provided in >> ABI V2. >> +class lock_guard >> +{ >> +public: >> + explicit lock_guard(MutexTypes&... m); >> + lock_guard(MutexTypes&... m, adopt_lock_t); >> + ~lock_guard(); >> + lock_guard(lock_guard const&) = delete; >> + lock_guard& operator=(lock_guard const&) = delete; >> +private: >> + tuple<MutexTypes&...> pm; // exposition only >> +}; >> + >> template <class Mutex> >> class unique_lock >> { >> @@ -427,6 +440,27 @@ lock(_L0& __l0, _L1& __l1, _L2& __l2, _L >> __lock_first(0, __l0, __l1, __l2, __l3...); >> } >> >> +template <class _L0> >> +inline _LIBCPP_INLINE_VISIBILITY >> +void __unlock(_L0& __l0) { >> + __l0.unlock(); >> +} >> + >> +template <class _L0, class _L1> >> +inline _LIBCPP_INLINE_VISIBILITY >> +void __unlock(_L0& __l0, _L1& __l1) { >> + __l0.unlock(); >> + __l1.unlock(); >> +} >> + >> +template <class _L0, class _L1, class _L2, class ..._L3> >> +inline _LIBCPP_INLINE_VISIBILITY >> +void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) { >> + __l0.unlock(); >> + __l1.unlock(); >> + _VSTD::__unlock(__l2, __l3...); >> +} >> + >> #endif // _LIBCPP_HAS_NO_VARIADICS >> >> #endif // !_LIBCPP_HAS_NO_THREADS >> @@ -577,6 +611,63 @@ call_once(once_flag& __flag, const _Call >> >> #endif // _LIBCPP_HAS_NO_VARIADICS >> >> + >> +#if defined(_LIBCPP_ABI_VARIADIC_LOCK_GUARD) \ >> + && !defined(_LIBCPP_CXX03_LANG) >> +template <> >> +class _LIBCPP_TYPE_VIS_ONLY lock_guard<> { >> +public: >> + explicit lock_guard() = default; >> + ~lock_guard() = default; >> + >> + _LIBCPP_INLINE_VISIBILITY >> + explicit lock_guard(adopt_lock_t) {} >> + >> + lock_guard(lock_guard const&) = delete; >> + lock_guard& operator=(lock_guard const&) = delete; >> +}; >> + >> +template <class ..._MArgs> >> +class _LIBCPP_TYPE_VIS_ONLY lock_guard >> +{ >> + static_assert(sizeof...(_MArgs) >= 2, "At least 2 lock types >> required"); >> + typedef tuple<_MArgs&...> _MutexTuple; >> + >> +public: >> + _LIBCPP_INLINE_VISIBILITY >> + explicit lock_guard(_MArgs&... __margs) >> + : __t_(__margs...) >> + { >> + _VSTD::lock(__margs...); >> + } >> + >> + _LIBCPP_INLINE_VISIBILITY >> + lock_guard(_MArgs&... __margs, adopt_lock_t) >> + : __t_(__margs...) >> + { >> + } >> + >> + _LIBCPP_INLINE_VISIBILITY >> + ~lock_guard() { >> + typedef typename __make_tuple_indices<sizeof...(_MArgs)>::type >> _Indices; >> + __unlock_unpack(_Indices{}, __t_); >> + } >> + >> + lock_guard(lock_guard const&) = delete; >> + lock_guard& operator=(lock_guard const&) = delete; >> + >> +private: >> + template <size_t ..._Indx> >> + _LIBCPP_INLINE_VISIBILITY >> + static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& >> __mt) { >> + _VSTD::__unlock(_VSTD::get<_Indx>(__mt)...); >> + } >> + >> + _MutexTuple __t_; >> +}; >> + >> +#endif // _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> + >> _LIBCPP_END_NAMESPACE_STD >> >> #endif // _LIBCPP_MUTEX >> >> Added: >> libcxx/trunk/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_mangling.pass.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_mangling.pass.cpp?rev=272634&view=auto >> >> ============================================================================== >> --- >> libcxx/trunk/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_mangling.pass.cpp >> (added) >> +++ >> libcxx/trunk/test/libcxx/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_mangling.pass.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -0,0 +1,31 @@ >> >> +//===----------------------------------------------------------------------===// >> +// >> +// 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 >> + >> +// THIS TESTS C++03 EXTENSIONS. >> + >> +// <mutex> >> + >> +// template <class ...Mutex> class lock_guard; >> + >> +// Test that the the variadic lock guard implementation mangles the same >> in >> +// C++11 and C++03. This is important since the mangling of `lock_guard` >> depends >> +// on it being declared as a variadic template, even in C++03. >> + >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> +#include <mutex> >> +#include <typeinfo> >> +#include <cassert> >> +#include <iostream> >> + >> +int main() { >> + const std::string expect = "NSt3__110lock_guardIJNS_5mutexEEEE"; >> + assert(typeid(std::lock_guard<std::mutex>).name() == expect); >> +} >> >> Modified: >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp?rev=272634&r1=272633&r2=272634&view=diff >> >> ============================================================================== >> --- >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp >> (original) >> +++ >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.fail.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -7,6 +7,8 @@ >> // >> >> >> //===----------------------------------------------------------------------===// >> >> +// UNSUPPORTED: libcpp-has-no-threads >> + >> // <mutex> >> >> // template <class Mutex> class lock_guard; >> @@ -14,35 +16,9 @@ >> // explicit lock_guard(mutex_type& m); >> >> #include <mutex> >> -#include <thread> >> -#include <cstdlib> >> -#include <cassert> >> - >> -std::mutex m; >> - >> -typedef std::chrono::system_clock Clock; >> -typedef Clock::time_point time_point; >> -typedef Clock::duration duration; >> -typedef std::chrono::milliseconds ms; >> -typedef std::chrono::nanoseconds ns; >> - >> -void f() >> -{ >> - time_point t0 = Clock::now(); >> - time_point t1; >> - { >> - std::lock_guard<std::mutex> lg = m; >> - t1 = Clock::now(); >> - } >> - ns d = t1 - t0 - ms(250); >> - assert(d < ns(2500000)); // within 2.5ms >> -} >> >> int main() >> { >> - m.lock(); >> - std::thread t(f); >> - std::this_thread::sleep_for(ms(250)); >> - m.unlock(); >> - t.join(); >> + std::mutex m; >> + std::lock_guard<std::mutex> lg = m; // expected-error{{no viable >> conversion}} >> } >> >> Added: >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_adopt_lock.pass.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_adopt_lock.pass.cpp?rev=272634&view=auto >> >> ============================================================================== >> --- >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_adopt_lock.pass.cpp >> (added) >> +++ >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_adopt_lock.pass.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -0,0 +1,62 @@ >> >> +//===----------------------------------------------------------------------===// >> +// >> +// 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 >> + >> +// <mutex> >> + >> +// template <class ...Mutex> class lock_guard; >> + >> +// lock_guard(Mutex&..., adopt_lock_t); >> + >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> +#include <mutex> >> +#include <cassert> >> + >> +struct TestMutex { >> + bool locked = false; >> + TestMutex() = default; >> + >> + void lock() { assert(!locked); locked = true; } >> + bool try_lock() { if (locked) return false; return locked = true; } >> + void unlock() { assert(locked); locked = false; } >> + >> + TestMutex(TestMutex const&) = delete; >> + TestMutex& operator=(TestMutex const&) = delete; >> +}; >> + >> +int main() >> +{ >> + { >> + using LG = std::lock_guard<>; >> + LG lg(std::adopt_lock); >> + } >> + { >> + TestMutex m1, m2; >> + using LG = std::lock_guard<TestMutex, TestMutex>; >> + m1.lock(); m2.lock(); >> + { >> + LG lg(m1, m2, std::adopt_lock); >> + assert(m1.locked && m2.locked); >> + } >> + assert(!m1.locked && !m2.locked); >> + } >> + { >> + TestMutex m1, m2, m3; >> + using LG = std::lock_guard<TestMutex, TestMutex, TestMutex>; >> + m1.lock(); m2.lock(); m3.lock(); >> + { >> + LG lg(m1, m2, m3, std::adopt_lock); >> + assert(m1.locked && m2.locked && m3.locked); >> + } >> + assert(!m1.locked && !m2.locked && !m3.locked); >> + } >> + >> +} >> >> Added: >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_assign.fail.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_assign.fail.cpp?rev=272634&view=auto >> >> ============================================================================== >> --- >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_assign.fail.cpp >> (added) >> +++ >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_assign.fail.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -0,0 +1,44 @@ >> >> +//===----------------------------------------------------------------------===// >> +// >> +// 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 >> + >> +// <mutex> >> + >> +// template <class ...Mutex> class lock_guard; >> + >> +// lock_guard& operator=(lock_guard const&) = delete; >> + >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> +#include <mutex> >> + >> +int main() >> +{ >> + using M = std::mutex; >> + M m0, m1, m2; >> + M om0, om1, om2; >> + { >> + using LG = std::lock_guard<>; >> + LG lg1, lg2; >> + lg1 = lg2; // expected-error{{overload resolution selected >> deleted operator '='}} >> + } >> + { >> + using LG = std::lock_guard<M, M>; >> + LG lg1(m0, m1); >> + LG lg2(om0, om1); >> + lg1 = lg2; // expected-error{{overload resolution selected >> deleted operator '='}} >> + } >> + { >> + using LG = std::lock_guard<M, M, M>; >> + LG lg1(m0, m1, m2); >> + LG lg2(om0, om1, om2); >> + lg1 = lg2; // expected-error{{overload resolution selected >> deleted operator '='}} >> + } >> +} >> >> Added: >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_copy.fail.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_copy.fail.cpp?rev=272634&view=auto >> >> ============================================================================== >> --- >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_copy.fail.cpp >> (added) >> +++ >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_copy.fail.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -0,0 +1,41 @@ >> >> +//===----------------------------------------------------------------------===// >> +// >> +// 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 >> + >> +// <mutex> >> + >> +// template <class ...Mutex> class lock_guard; >> + >> +// lock_guard(lock_guard const&) = delete; >> + >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> +#include <mutex> >> + >> +int main() >> +{ >> + using M = std::mutex; >> + M m0, m1, m2; >> + { >> + using LG = std::lock_guard<>; >> + const LG Orig; >> + LG Copy(Orig); // expected-error{{call to deleted constructor of >> 'LG'}} >> + } >> + { >> + using LG = std::lock_guard<M, M>; >> + const LG Orig(m0, m1); >> + LG Copy(Orig); // expected-error{{call to deleted constructor of >> 'LG'}} >> + } >> + { >> + using LG = std::lock_guard<M, M, M>; >> + const LG Orig(m0, m1, m2); >> + LG Copy(Orig); // expected-error{{call to deleted constructor of >> 'LG'}} >> + } >> +} >> >> Added: >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.fail.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.fail.cpp?rev=272634&view=auto >> >> ============================================================================== >> --- >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.fail.cpp >> (added) >> +++ >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.fail.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -0,0 +1,47 @@ >> >> +//===----------------------------------------------------------------------===// >> +// >> +// 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 >> + >> +// <mutex> >> + >> +// template <class ...Mutex> class lock_guard; >> + >> +// explicit lock_guard(Mutex&...); >> + >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> +#include <mutex> >> + >> +template <class LG> >> +void test_conversion(LG) {} >> + >> +int main() >> +{ >> + using M = std::mutex; >> + M m0, m1, m2; >> + M n0, n1, n2; >> + { >> + using LG = std::lock_guard<>; >> + LG lg = {}; // expected-error{{chosen constructor is explicit in >> copy-initialization}} >> + test_conversion<LG>({}); // expected-error{{no matching function >> for call}} >> + ((void)lg); >> + } >> + { >> + using LG = std::lock_guard<M, M>; >> + LG lg = {m0, m1}; // expected-error{{chosen constructor is >> explicit in copy-initialization}} >> + test_conversion<LG>({n0, n1}); // expected-error{{no matching >> function for call}} >> + ((void)lg); >> + } >> + { >> + using LG = std::lock_guard<M, M, M>; >> + LG lg = {m0, m1, m2}; // expected-error{{chosen constructor is >> explicit in copy-initialization}} >> + test_conversion<LG>({n0, n1, n2}); // expected-error{{no >> matching function for call}} >> + } >> +} >> >> Added: >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.pass.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.pass.cpp?rev=272634&view=auto >> >> ============================================================================== >> --- >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.pass.cpp >> (added) >> +++ >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex.pass.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -0,0 +1,113 @@ >> >> +//===----------------------------------------------------------------------===// >> +// >> +// 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 >> + >> +// <mutex> >> + >> +// template <class ...Mutex> class lock_guard; >> + >> +// explicit lock_guard(mutex_type& m); >> + >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> +#include <mutex> >> +#include <cassert> >> + >> +struct TestMutex { >> + bool locked = false; >> + TestMutex() = default; >> + ~TestMutex() { assert(!locked); } >> + >> + void lock() { assert(!locked); locked = true; } >> + bool try_lock() { if (locked) return false; return locked = true; } >> + void unlock() { assert(locked); locked = false; } >> + >> + TestMutex(TestMutex const&) = delete; >> + TestMutex& operator=(TestMutex const&) = delete; >> +}; >> + >> +#if !defined(TEST_HAS_NO_EXCEPTIONS) >> +struct TestMutexThrows { >> + bool locked = false; >> + bool throws_on_lock = false; >> + >> + TestMutexThrows() = default; >> + ~TestMutexThrows() { assert(!locked); } >> + >> + void lock() { >> + assert(!locked); >> + if (throws_on_lock) { >> + throw 42; >> + } >> + locked = true; >> + } >> + >> + bool try_lock() { >> + if (locked) return false; >> + lock(); >> + return true; >> + } >> + >> + void unlock() { assert(locked); locked = false; } >> + >> + TestMutexThrows(TestMutexThrows const&) = delete; >> + TestMutexThrows& operator=(TestMutexThrows const&) = delete; >> +}; >> +#endif // !defined(TEST_HAS_NO_EXCEPTIONS) >> + >> +int main() >> +{ >> + { >> + using LG = std::lock_guard<>; >> + LG lg; >> + } >> + { >> + using LG = std::lock_guard<TestMutex, TestMutex>; >> + TestMutex m1, m2; >> + { >> + LG lg(m1, m2); >> + assert(m1.locked && m2.locked); >> + } >> + assert(!m1.locked && !m2.locked); >> + } >> + { >> + using LG = std::lock_guard<TestMutex, TestMutex, TestMutex>; >> + TestMutex m1, m2, m3; >> + { >> + LG lg(m1, m2, m3); >> + assert(m1.locked && m2.locked && m3.locked); >> + } >> + assert(!m1.locked && !m2.locked && !m3.locked); >> + } >> +#if !defined(TEST_HAS_NO_EXCEPTIONS) >> + { >> + using MT = TestMutexThrows; >> + using LG = std::lock_guard<MT, MT>; >> + MT m1, m2; >> + m1.throws_on_lock = true; >> + try { >> + LG lg(m1, m2); >> + assert(false); >> + } catch (int) {} >> + assert(!m1.locked && !m2.locked); >> + } >> + { >> + using MT = TestMutexThrows; >> + using LG = std::lock_guard<MT, MT, MT>; >> + MT m1, m2, m3; >> + m2.throws_on_lock = true; >> + try { >> + LG lg(m1, m2, m3); >> + assert(false); >> + } catch (int) {} >> + assert(!m1.locked && !m2.locked && !m3.locked); >> + } >> +#endif >> +} >> >> Added: >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_cxx03.pass.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_cxx03.pass.cpp?rev=272634&view=auto >> >> ============================================================================== >> --- >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_cxx03.pass.cpp >> (added) >> +++ >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_mutex_cxx03.pass.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -0,0 +1,21 @@ >> >> +//===----------------------------------------------------------------------===// >> +// >> +// 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> >> + >> +// template <class ...Mutex> class lock_guard; >> + >> +// Test that the variadic lock guard implementation compiles in all >> standard >> +// dialects, including C++03, even though it is forward declared using >> +// variadic templates. >> + >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> +#include "mutex.pass.cpp" // Use the existing non-variadic test >> >> Added: >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_types.pass.cpp >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_types.pass.cpp?rev=272634&view=auto >> >> ============================================================================== >> --- >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_types.pass.cpp >> (added) >> +++ >> libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/variadic_types.pass.cpp >> Mon Jun 13 22:48:09 2016 >> @@ -0,0 +1,78 @@ >> >> +//===----------------------------------------------------------------------===// >> +// >> +// 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 >> + >> +// <mutex> >> + >> +// template <class Mutex> >> +// class lock_guard >> +// { >> +// public: >> +// typedef Mutex mutex_type; >> +// ... >> +// }; >> + >> +#define _LIBCPP_ABI_VARIADIC_LOCK_GUARD >> +#include <mutex> >> +#include <type_traits> >> + >> +struct NAT {}; >> + >> +template <class LG> >> +auto test_typedef(int) -> typename LG::mutex_type; >> + >> +template <class LG> >> +auto test_typedef(...) -> NAT; >> + >> +template <class LG> >> +constexpr bool has_mutex_type() { >> + return !std::is_same<decltype(test_typedef<LG>(0)), NAT>::value; >> +} >> + >> +int main() >> +{ >> + { >> + using T = std::lock_guard<>; >> + static_assert(!has_mutex_type<T>(), ""); >> + } >> + { >> + using M1 = std::mutex; >> + using T = std::lock_guard<M1>; >> + static_assert(std::is_same<T::mutex_type, M1>::value, ""); >> + } >> + { >> + using M1 = std::recursive_mutex; >> + using T = std::lock_guard<M1>; >> + static_assert(std::is_same<T::mutex_type, M1>::value, ""); >> + } >> + { >> + using M1 = std::mutex; >> + using M2 = std::recursive_mutex; >> + using T = std::lock_guard<M1, M2>; >> + static_assert(!has_mutex_type<T>(), ""); >> + } >> + { >> + using M1 = std::mutex; >> + using M2 = std::recursive_mutex; >> + using T = std::lock_guard<M1, M1, M2>; >> + static_assert(!has_mutex_type<T>(), ""); >> + } >> + { >> + using M1 = std::mutex; >> + using T = std::lock_guard<M1, M1>; >> + static_assert(!has_mutex_type<T>(), ""); >> + } >> + { >> + using M1 = std::recursive_mutex; >> + using T = std::lock_guard<M1, M1, M1>; >> + static_assert(!has_mutex_type<T>(), ""); >> + } >> +} >> >> Modified: libcxx/trunk/www/cxx1z_status.html >> URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/www/cxx1z_status.html?rev=272634&r1=272633&r2=272634&view=diff >> >> ============================================================================== >> --- libcxx/trunk/www/cxx1z_status.html (original) >> +++ libcxx/trunk/www/cxx1z_status.html Mon Jun 13 22:48:09 2016 >> @@ -74,7 +74,7 @@ >> <tr><td><a href=" >> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0006R0.html">P0006R0</a></td><td>LWG</td><td>Adopt >> Type Traits Variable Templates for >> C++17.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr> >> <tr><td><a href=" >> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0092R1.html">P0092R1</a></td><td>LWG</td><td>Polishing >> <chrono></td><td>Kona</td><td>Complete</td><td>3.8</td></tr> >> <tr><td><a href=" >> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0007R1.html">P0007R1</a></td><td>LWG</td><td>Constant >> View: A proposal for a <tt>std::as_const</tt> helper function >> template.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr> >> - <tr><td><a href=" >> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0156R0.htm" >> >P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev >> 3).</td><td>Kona</td><td></td><td></td></tr> >> + <tr><td><a href=" >> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0156r0.html" >> >P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev >> 3).</td><td>Kona</td><td>Complete (ABI V2 Only)</td><td>3.9</td></tr> >> <tr><td><a href=" >> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0074R0.html">P0074R0</a></td><td>LWG</td><td>Making >> <tt>std::owner_less</tt> more >> flexible</td><td>Kona</td><td>Complete</td><td>3.8</td></tr> >> <tr><td><a href=" >> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/P0013R1.html">P0013R1</a></td><td>LWG</td><td>Logical >> type traits rev 2</td><td>Kona</td><td>Complete</td><td>3.8</td></tr> >> <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> >> >> >> _______________________________________________ >> cfe-commits mailing list >> cfe-commits@lists.llvm.org >> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits >> > >
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits