This is an archive of the discontinued LLVM Phabricator instance.

Differential D3969

[libc++] Allow libc++ to be built on systems without POSIX threads
ClosedPublic

Authored by jroelofs on May 30 2014, 2:28 PM.

Details

Reviewers
danalbert
joerg

Diff Detail

Event Timeline

jroelofs updated this revision to Diff 9964.May 30 2014, 2:28 PM
jroelofs retitled this revision from to [libc++] Allow libc++ to be built on systems without POSIX threads.
jroelofs updated this object.
jroelofs edited the test plan for this revision. (Show Details)
jroelofs added a reviewer: joerg.
jroelofs added a subscriber: Unknown Object (MLST).
joerg edited edge metadata.May 30 2014, 3:07 PM

I'm not sure I like the name _LIBCPP_SINGLE_THREADED, especially since it is pretty much exclusively used in the negative sense. Otherwise fine with me.

sources/cxx-stl/llvm-libc++/libcxx/include/__config
124 ↗(On Diff #9964)
#if _POSIX_THREADS - 0 > 0

might be simpler

jroelofs added a comment.May 30 2014, 3:15 PM

I picked the name to match the one I recently added to libc++abi. I'm open to suggestions though.

The other one I considered was _LIBCPP_HAS_POSIX_THREADS, but that seemed to be less fitting (one could have a system with pthreads, but still not want to build libc++ with threads enabled, for example).

sources/cxx-stl/llvm-libc++/libcxx/include/__config
124 ↗(On Diff #9964)

Is there much of a precedent either way? I haven't seen any laid out like that...

mclow.lists added a subscriber: mclow.lists.May 30 2014, 9:39 PM

In general, libc++ uses the negative for missing capabilities.
_LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_HAS_NO_ADVANCED_SFINAE
_LIBCPP_HAS_NO_VARIADICS
_LIBCPP_HAS_NO_TRAILING_RETURN

I would prefer to keep this convention.

mclow.lists added a comment.May 31 2014, 7:18 AM

I would also like to understand more about the motivation behind this patch.
Concurrency is a core part of C++11library, and just disabling it seems wrong to me.

I know there are systems w/o POSIX threads, but to support those systems, libc++ should use whatever primitives exist there, rather than just disabling all the threading support.

What are you trying to accomplish here?

jroelofs added a comment.EditedMay 31 2014, 7:43 AM

mclow, the motivation for this is for bare-metal systems where we don't have threads. I suppose my title for this left a little too much room to read into it.

The other alternative would be to write no-op shims around all of these primitives, but that seems like it would be a lot of mess for very little benefit.

sources/cxx-stl/llvm-libc++/libcxx/include/shared_mutex
419 ↗(On Diff #9964)

line should read:

#endif // !_LIBCPP_SINGLE_THREADED

sources/cxx-stl/llvm-libc++/libcxx/src/memory.cpp
175 ↗(On Diff #9964)

line should read:

#endif // __has_feature(cxx_atomic) && !_LIBCPP_SINGLE_THREADED

jroelofs added inline comments.May 31 2014, 7:48 AM
sources/cxx-stl/llvm-libc++/libcxx/include/__mutex_base
53 ↗(On Diff #9964)

awong pointed out that it makes sense to exclude defer_lock_t and friends also,

so delete this line....

269 ↗(On Diff #9964)

... and this one.

jroelofs added inline comments.May 31 2014, 8:51 AM
sources/cxx-stl/llvm-libc++/libcxx/include/__config
14 ↗(On Diff #9964)

awong also suggested that I wrap this in an #if !_WIN32.

compnerd added a subscriber: compnerd.Jul 26 2014, 6:09 PM
joerg added a comment.Jul 29 2014, 5:43 AM

What is the status of this patch?

jroelofs added inline comments.Aug 13 2014, 8:05 AM
sources/cxx-stl/llvm-libc++/libcxx/src/thread.cpp
129 ↗(On Diff #9964)

This ought to get moved to http://reviews.llvm.org/D4045 (i.e. place sleep_for inside a _LIBCPP_HAS_MONOTONIC_CLOCK)

jroelofs updated this revision to Diff 12452.Aug 13 2014, 8:08 AM
jroelofs edited edge metadata.

Hi Joerg,

I'm finally resurrecting this...

jroelofs updated this revision to Diff 12454.Aug 13 2014, 8:13 AM

Renamed according to mclow's suggestion: s/_LIBCPP_SINGLE_THREADED/_LIBCPP_HAS_NO_THREADS/

jroelofs updated this revision to Diff 12456.Aug 13 2014, 8:16 AM

Fix a couple of typos I just caught.

jroelofs added a comment.Aug 19 2014, 7:50 AM

Ping

mclow.lists added a comment.Aug 21 2014, 8:49 AM

See the inline comments; I think that _LIBCPP_HAS_NO_THREADS should be defined when building single-threaded, and not defined otherwise (that would match the rest of the libc++ config macros).

Also, aren't there a bunch of tests that are going to need to change?

include/__config
126 ↗(On Diff #12456)

This should be wrapped in an "#ifndef _LIBCPP_HAS_NO_THREADS" block, and should just define it, rather than give it a 0/1 value.

This will allow someone to build an "no threads" version of libcpp by -D _LIBCPP_HAS_NO_THREADS on the command line.

include/__mutex_base
25

this should just be #ifndef _LIBCPP_HAS_NO_THREADS

33

Whitespace change?

jroelofs added a comment.Aug 21 2014, 9:00 AM

I have another set of patches for the tests that this affects. Should I merge them all and include them here?

include/__config
126 ↗(On Diff #12456)

Wait, do you mean that this hunk should just go away? Or do you mean that it should be:

#if !defined(_LIBCPP_HAS_NO_THREADS) && defined(_POSIX_THREADS) && _POSIX_THREADS > 0
#define _LIBCPP_HAS_NO_THREADS
#endif

I'm not sure I understand what you're asking for here.

include/__mutex_base
25

Ok, I'll change all of them to that style.

33

Looks like... I'll get rid of it.

jroelofs updated this revision to Diff 12803.Aug 21 2014, 1:49 PM

Implement a few of mclow's comments.

jroelofs added a comment.Aug 21 2014, 1:58 PM

It'll take a bit more to fish out the changes to the tests (mostly adding 'XFAIL: libcxx-single-threaded')

include/__config
126 ↗(On Diff #12803)

@mclow earlier you suggested having just the build define this with -D_LIBCPP_HAS_NO_THREADS. I thought adding this as a error/warning might be nice.

Another thing I've just realized: if this is only set during the build, then how to I arrange for it to be set in an installed system? I don't want my users to have to -D_LIBCPP_HAS_NO_THREADS whenever they want to use libcxx.

include/thread
110

s/system/single threaded system/

src/thread.cpp
33

un-necessary whitespace change

jroelofs updated this revision to Diff 12804.Aug 21 2014, 2:02 PM

Fix a whiltespace issue, and re-word an error message.

jroelofs added a comment.Aug 21 2014, 3:05 PM

XFAILS for this are here: http://reviews.llvm.org/D5013

I didn't add any of the lists as a subscriber as this diff is rather large and mechanical.

In summary it adds "// XFAIL: libcxx-single-threaded" to all of the tests which this "breaks".

EricWF added a subscriber: EricWF.Aug 21 2014, 4:07 PM
EricWF added inline comments.
src/mutex.cpp
224–233

Wouldn't it be a lot cleaner to just separate the two implementation entirely instead of interweaving them like this?

jroelofs added inline comments.Aug 21 2014, 4:11 PM
src/mutex.cpp
224–233

Sigh. Yes. *hits head on desk*. Why did I do it like that?

jroelofs added inline comments.Aug 21 2014, 5:56 PM
include/memory
615

I missed a pair of changes in this file. The __has_feature(cxx_atomic) #ifdef block needs to be:

#if __has_feature(cxx_atomic) && !defined(_LIBCXX_HAS_NO_THREADS)
...
#endif  // __has_feature(cxx_atomic) && !defined(_LIBCXX_HAS_NO_THREADS)

I also missed a pair of these in include/ios near lines 216 and 367

jroelofs updated this revision to Diff 13079.Aug 29 2014, 7:13 AM

Separate out the two halves of __call_once as per EricWF's suggestion, and address my own review comment (about having forgotten a section).

danalbert added a subscriber: danalbert.Aug 29 2014, 9:59 AM

I'm a little bit worried about the no-threads build bit-rotting (if any of us forget to wrap something in #ifndef _LIBCPP_HAS_NO_THREADS). Should we have a buildbot set up to build this configuration? Would it be possible to define noop implementations of all the things you've ifdef'd out so that we don't have to worry about that? It's possible that would make things more or a mess, but I'm not sure.

src/condition_variable.cpp
19

nit

danalbert accepted this revision.Aug 29 2014, 10:39 AM
danalbert added a reviewer: danalbert.

From email thread:

Should we have a buildbot set up to build this configuration?

I would appreciate having one, but I can't host it at the moment.
At some point I would like to host a baremetal buildbot (targeting either QEMU, a raspberry pi, or some beagleboard), but I'm not quite ready for that... we need to work out the details of remote testing in lit before that is practical.

Keeping a buildbot going for this patch doesn't actually require baremetal (though that would be nice to have as well). @EricWF recently set up a buildbot. He might be willing to host it.

Would it be possible to define noop implementations of all the things you've ifdef'd out so that we don't have to worry about that? It's possible that would make things more or a mess, but I'm not sure.

I think that nop-shims have an even higher potential for bit-rot than these #ifdef's.
I originally attempted writing no-op shims for a few of them, but there were several where it didn't seem possible, and others where the shims were pretty hairy.

Okay, I thought that might be the case.

With those things accounted for, LGTM.

This revision is now accepted and ready to land.Aug 29 2014, 10:39 AM
jroelofs updated this revision to Diff 13336.Sep 5 2014, 11:54 AM
jroelofs edited edge metadata.

Fix a couple of nits, and add in the XFAILs as UNSUPPORTEDs.

jroelofs added a comment.Sep 5 2014, 11:56 AM

Oh, and I also removed the autodetect part of include/__config

jroelofs closed this revision.Sep 5 2014, 1:00 PM

r217271

• Quuxplusone mentioned this in D103769: [libcxx] Implement P0883R2 ("Fixing Atomic Initialization").Jun 9 2021, 9:21 AM

Revision Contents

PathSize
include/
6 lines
6 lines
4 lines
6 lines
6 lines
4 lines
6 lines
6 lines
src/
8 lines
6 lines
40 lines
6 lines
6 lines
27 lines
5 lines
5 lines
test/
atomics/
atomics.fences/
2 lines
atomics.flag/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
atomics.lockfree/
2 lines
atomics.order/
2 lines
2 lines
atomics.types.generic/
3 lines
2 lines
2 lines
2 lines
2 lines
atomics.types.operations/
atomics.types.operations.req/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
2 lines
2 lines
3 lines
2 lines
3 lines
3 lines
3 lines
3 lines
2 lines
2 lines
thread/
futures/
futures.async/
2 lines
futures.errors/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
futures.future_error/
2 lines
2 lines
2 lines
futures.overview/
2 lines
2 lines
2 lines
2 lines
futures.promise/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
futures.shared_future/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
futures.tas/
futures.task.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
futures.task.nonmembers/
2 lines
2 lines
2 lines
futures.unique_future/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.condition/
2 lines
2 lines
thread.condition.condvar/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.condition.condvarany/
2 lines
2 lines
2 lines
2 lines
11 lines
2 lines
11 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.mutex/
thread.lock.algorithm/
2 lines
2 lines
thread.lock/
thread.lock.guard/
2 lines
2 lines
2 lines
thread.lock.shared/
thread.lock.shared.cons/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.shared.locking/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.shared.mod/
2 lines
2 lines
2 lines
thread.lock.shared.obs/
2 lines
2 lines
2 lines
2 lines
thread.lock.unique/
thread.lock.unique.cons/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.unique.locking/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.lock.unique.mod/
2 lines
2 lines
2 lines
thread.lock.unique.obs/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.mutex.requirements/
thread.mutex.requirements.mutex/
thread.mutex.class/
2 lines
2 lines
2 lines
2 lines
thread.mutex.recursive/
2 lines
2 lines
2 lines
2 lines
thread.sharedtimedmutex.requirements/
thread.sharedtimedmutex.class/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.timedmutex.requirements/
thread.timedmutex.class/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.timedmutex.recursive/
2 lines
2 lines
2 lines
2 lines
2 lines
thread.once/
thread.once.callonce/
10 lines
thread.threads/
thread.thread.class/
thread.thread.algorithm/
2 lines
thread.thread.assign/
2 lines
thread.thread.constr/
2 lines
2 lines
2 lines
thread.thread.destr/
2 lines
thread.thread.id/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.thread.member/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
thread.thread.static/
2 lines
2 lines
thread.thread.this/
2 lines
2 lines
2 lines
2 lines
2 lines
utilities/
memory/
util.smartptr/
util.smartptr.shared.atomic/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines

Diff 13336

include/__mutex_base

Context not available.
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_THREADS
mclow.listsUnsubmitted
Not Done
ReplyInline Actions

this should just be #ifndef _LIBCPP_HAS_NO_THREADS

mclow.lists: this should just be #ifndef _LIBCPP_HAS_NO_THREADS
jroelofsAuthorUnsubmitted
Not Done
ReplyInline Actions

Ok, I'll change all of them to that style.

jroelofs: Ok, I'll change all of them to that style.
class _LIBCPP_TYPE_VIS mutex class _LIBCPP_TYPE_VIS mutex
{ {
pthread_mutex_t __m_; pthread_mutex_t __m_;
mclow.listsUnsubmitted
Not Done
ReplyInline Actions

Whitespace change?

mclow.lists: Whitespace change?
jroelofsAuthorUnsubmitted
Not Done
ReplyInline Actions

Looks like... I'll get rid of it.

jroelofs: Looks like... I'll get rid of it.
Context not available.
void __do_timed_wait(unique_lock<mutex>& __lk, void __do_timed_wait(unique_lock<mutex>& __lk,
chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT; chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
}; };
#endif // !_LIBCPP_HAS_NO_THREADS
template <class _To, class _Rep, class _Period> template <class _To, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
Context not available.
return __r; return __r;
} }
#ifndef _LIBCPP_HAS_NO_THREADS
template <class _Predicate> template <class _Predicate>
void void
condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred) condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
Context not available.
_VSTD::move(__pred)); _VSTD::move(__pred));
} }
#endif // !_LIBCPP_HAS_NO_THREADS
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MUTEX_BASE #endif // _LIBCPP___MUTEX_BASE
Context not available.

include/atomic

Context not available.
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#ifdef _LIBCPP_HAS_NO_THREADS
#error <atomic> is not supported on this single threaded system
#else // !_LIBCPP_HAS_NO_THREADS
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !__has_feature(cxx_atomic) && _GNUC_VER < 407 #if !__has_feature(cxx_atomic) && _GNUC_VER < 407
Context not available.
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
#endif // _LIBCPP_ATOMIC #endif // _LIBCPP_ATOMIC
Context not available.

include/condition_variable

Context not available.
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#ifndef _LIBCPP_HAS_NO_THREADS
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TYPE_VIS condition_variable_any class _LIBCPP_TYPE_VIS condition_variable_any
Context not available.
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
#endif // _LIBCPP_CONDITION_VARIABLE #endif // _LIBCPP_CONDITION_VARIABLE
Context not available.

include/future

Context not available.
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#ifndef _LIBCPP_HAS_NO_THREADS
#error <future> is not supported on this single threaded system
#else // !_LIBCPP_HAS_NO_THREADS
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
//enum class future_errc //enum class future_errc
Context not available.
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
#endif // _LIBCPP_FUTURE #endif // _LIBCPP_FUTURE
Context not available.

include/memory

Context not available.
#include <cassert> #include <cassert>
#endif #endif
#if __has_feature(cxx_atomic) #if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
# include <atomic> # include <atomic>
#endif #endif
jroelofsAuthorUnsubmitted
Not Done
ReplyInline Actions

I missed a pair of changes in this file. The __has_feature(cxx_atomic) #ifdef block needs to be:

#if __has_feature(cxx_atomic) && !defined(_LIBCXX_HAS_NO_THREADS)
...
#endif  // __has_feature(cxx_atomic) && !defined(_LIBCXX_HAS_NO_THREADS)

I also missed a pair of these in include/ios near lines 216 and 367

jroelofs: I missed a pair of changes in this file. The __has_feature(cxx_atomic) #ifdef block needs to be…
Context not available.
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p); operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
#if __has_feature(cxx_atomic) #if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
class _LIBCPP_TYPE_VIS __sp_mut class _LIBCPP_TYPE_VIS __sp_mut
{ {
Context not available.
return atomic_compare_exchange_weak(__p, __v, __w); return atomic_compare_exchange_weak(__p, __v, __w);
} }
#endif // __has_feature(cxx_atomic) #endif // __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
//enum class //enum class
struct _LIBCPP_TYPE_VIS pointer_safety struct _LIBCPP_TYPE_VIS pointer_safety
Context not available.

include/mutex

Context not available.
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_THREADS
class _LIBCPP_TYPE_VIS recursive_mutex class _LIBCPP_TYPE_VIS recursive_mutex
{ {
pthread_mutex_t __m_; pthread_mutex_t __m_;
Context not available.
#endif // _LIBCPP_HAS_NO_VARIADICS #endif // _LIBCPP_HAS_NO_VARIADICS
#endif // !_LIBCPP_HAS_NO_THREADS
struct _LIBCPP_TYPE_VIS_ONLY once_flag; struct _LIBCPP_TYPE_VIS_ONLY once_flag;
#ifndef _LIBCPP_HAS_NO_VARIADICS #ifndef _LIBCPP_HAS_NO_VARIADICS
Context not available.

include/shared_mutex

Context not available.
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#ifdef _LIBCPP_HAS_NO_THREADS
#error <shared_mutex> is not supported on this single threaded system
#else // !_LIBCPP_HAS_NO_THREADS
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TYPE_VIS shared_timed_mutex class _LIBCPP_TYPE_VIS shared_timed_mutex
Context not available.
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER > 11
#endif // _LIBCPP_SHARED_MUTEX #endif // _LIBCPP_SHARED_MUTEX
Context not available.

include/thread

Context not available.
#define __STDCPP_THREADS__ __cplusplus #define __STDCPP_THREADS__ __cplusplus
#ifdef _LIBCPP_HAS_NO_THREADS
#error <thread> is not supported on this single threaded system
jroelofsAuthorUnsubmitted
Not Done
ReplyInline Actions

s/system/single threaded system/

jroelofs: s/system/single threaded system/
#else // !_LIBCPP_HAS_NO_THREADS
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
Context not available.
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
#endif // _LIBCPP_THREAD #endif // _LIBCPP_THREAD
Context not available.

src/algorithm.cpp

Context not available.
template unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&); template unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&);
#ifndef _LIBCPP_HAS_NO_THREADS
static pthread_mutex_t __rs_mut = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t __rs_mut = PTHREAD_MUTEX_INITIALIZER;
#endif
unsigned __rs_default::__c_ = 0; unsigned __rs_default::__c_ = 0;
__rs_default::__rs_default() __rs_default::__rs_default()
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
pthread_mutex_lock(&__rs_mut); pthread_mutex_lock(&__rs_mut);
#endif
__c_ = 1; __c_ = 1;
} }
Context not available.
__rs_default::~__rs_default() __rs_default::~__rs_default()
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
if (--__c_ == 0) if (--__c_ == 0)
pthread_mutex_unlock(&__rs_mut); pthread_mutex_unlock(&__rs_mut);
#else
--__c_;
#endif
} }
__rs_default::result_type __rs_default::result_type
Context not available.

src/condition_variable.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "__config"
#ifndef _LIBCPP_HAS_NO_THREADS
#include "condition_variable" #include "condition_variable"
#include "thread" #include "thread"
#include "system_error" #include "system_error"
danalbertUnsubmitted
Not Done
ReplyInline Actions

nit

danalbert: nit
Context not available.
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
Context not available.

src/debug.cpp

Context not available.
namespace namespace
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
typedef mutex mutex_type; typedef mutex mutex_type;
typedef lock_guard<mutex_type> WLock; typedef lock_guard<mutex_type> WLock;
typedef lock_guard<mutex_type> RLock; typedef lock_guard<mutex_type> RLock;
Context not available.
static mutex_type m; static mutex_type m;
return m; return m;
} }
#endif // !_LIBCPP_HAS_NO_THREADS
} // unnamed namespace } // unnamed namespace
Context not available.
void* void*
__libcpp_db::__find_c_from_i(void* __i) const __libcpp_db::__find_c_from_i(void* __i) const
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut()); RLock _(mut());
#endif
__i_node* i = __find_iterator(__i); __i_node* i = __find_iterator(__i);
_LIBCPP_ASSERT(i != nullptr, "iterator not found in debug database."); _LIBCPP_ASSERT(i != nullptr, "iterator not found in debug database.");
return i->__c_ != nullptr ? i->__c_->__c_ : nullptr; return i->__c_ != nullptr ? i->__c_->__c_ : nullptr;
Context not available.
void void
__libcpp_db::__insert_ic(void* __i, const void* __c) __libcpp_db::__insert_ic(void* __i, const void* __c)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut()); WLock _(mut());
#endif
if (__cbeg_ == __cend_) if (__cbeg_ == __cend_)
return; return;
size_t hc = hash<const void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_); size_t hc = hash<const void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
Context not available.
__c_node* __c_node*
__libcpp_db::__insert_c(void* __c) __libcpp_db::__insert_c(void* __c)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut()); WLock _(mut());
#endif
if (__csz_ + 1 > static_cast<size_t>(__cend_ - __cbeg_)) if (__csz_ + 1 > static_cast<size_t>(__cend_ - __cbeg_))
{ {
size_t nc = __next_prime(2*static_cast<size_t>(__cend_ - __cbeg_) + 1); size_t nc = __next_prime(2*static_cast<size_t>(__cend_ - __cbeg_) + 1);
Context not available.
void void
__libcpp_db::__erase_i(void* __i) __libcpp_db::__erase_i(void* __i)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut()); WLock _(mut());
#endif
if (__ibeg_ != __iend_) if (__ibeg_ != __iend_)
{ {
size_t hi = hash<void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_); size_t hi = hash<void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_);
Context not available.
void void
__libcpp_db::__invalidate_all(void* __c) __libcpp_db::__invalidate_all(void* __c)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut()); WLock _(mut());
#endif
if (__cend_ != __cbeg_) if (__cend_ != __cbeg_)
{ {
size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_); size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
Context not available.
__c_node* __c_node*
__libcpp_db::__find_c_and_lock(void* __c) const __libcpp_db::__find_c_and_lock(void* __c) const
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
mut().lock(); mut().lock();
#endif
if (__cend_ == __cbeg_) if (__cend_ == __cbeg_)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
mut().unlock(); mut().unlock();
#endif
return nullptr; return nullptr;
} }
size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_); size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
Context not available.
__c_node* p = __cbeg_[hc]; __c_node* p = __cbeg_[hc];
if (p == nullptr) if (p == nullptr)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
mut().unlock(); mut().unlock();
#endif
return nullptr; return nullptr;
} }
while (p->__c_ != __c) while (p->__c_ != __c)
Context not available.
p = p->__next_; p = p->__next_;
if (p == nullptr) if (p == nullptr)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
mut().unlock(); mut().unlock();
#endif
return nullptr; return nullptr;
} }
} }
Context not available.
void void
__libcpp_db::unlock() const __libcpp_db::unlock() const
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
mut().unlock(); mut().unlock();
#endif
} }
void void
__libcpp_db::__erase_c(void* __c) __libcpp_db::__erase_c(void* __c)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut()); WLock _(mut());
#endif
if (__cend_ != __cbeg_) if (__cend_ != __cbeg_)
{ {
size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_); size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
Context not available.
void void
__libcpp_db::__iterator_copy(void* __i, const void* __i0) __libcpp_db::__iterator_copy(void* __i, const void* __i0)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut()); WLock _(mut());
#endif
__i_node* i = __find_iterator(__i); __i_node* i = __find_iterator(__i);
__i_node* i0 = __find_iterator(__i0); __i_node* i0 = __find_iterator(__i0);
__c_node* c0 = i0 != nullptr ? i0->__c_ : nullptr; __c_node* c0 = i0 != nullptr ? i0->__c_ : nullptr;
Context not available.
bool bool
__libcpp_db::__dereferenceable(const void* __i) const __libcpp_db::__dereferenceable(const void* __i) const
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut()); RLock _(mut());
#endif
__i_node* i = __find_iterator(__i); __i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__dereferenceable(__i); return i != nullptr && i->__c_ != nullptr && i->__c_->__dereferenceable(__i);
} }
Context not available.
bool bool
__libcpp_db::__decrementable(const void* __i) const __libcpp_db::__decrementable(const void* __i) const
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut()); RLock _(mut());
#endif
__i_node* i = __find_iterator(__i); __i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__decrementable(__i); return i != nullptr && i->__c_ != nullptr && i->__c_->__decrementable(__i);
} }
Context not available.
bool bool
__libcpp_db::__addable(const void* __i, ptrdiff_t __n) const __libcpp_db::__addable(const void* __i, ptrdiff_t __n) const
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut()); RLock _(mut());
#endif
__i_node* i = __find_iterator(__i); __i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__addable(__i, __n); return i != nullptr && i->__c_ != nullptr && i->__c_->__addable(__i, __n);
} }
Context not available.
bool bool
__libcpp_db::__subscriptable(const void* __i, ptrdiff_t __n) const __libcpp_db::__subscriptable(const void* __i, ptrdiff_t __n) const
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut()); RLock _(mut());
#endif
__i_node* i = __find_iterator(__i); __i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__subscriptable(__i, __n); return i != nullptr && i->__c_ != nullptr && i->__c_->__subscriptable(__i, __n);
} }
Context not available.
bool bool
__libcpp_db::__less_than_comparable(const void* __i, const void* __j) const __libcpp_db::__less_than_comparable(const void* __i, const void* __j) const
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
RLock _(mut()); RLock _(mut());
#endif
__i_node* i = __find_iterator(__i); __i_node* i = __find_iterator(__i);
__i_node* j = __find_iterator(__j); __i_node* j = __find_iterator(__j);
__c_node* ci = i != nullptr ? i->__c_ : nullptr; __c_node* ci = i != nullptr ? i->__c_ : nullptr;
Context not available.
void void
__libcpp_db::swap(void* c1, void* c2) __libcpp_db::swap(void* c1, void* c2)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut()); WLock _(mut());
#endif
size_t hc = hash<void*>()(c1) % static_cast<size_t>(__cend_ - __cbeg_); size_t hc = hash<void*>()(c1) % static_cast<size_t>(__cend_ - __cbeg_);
__c_node* p1 = __cbeg_[hc]; __c_node* p1 = __cbeg_[hc];
_LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap A"); _LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap A");
Context not available.
void void
__libcpp_db::__insert_i(void* __i) __libcpp_db::__insert_i(void* __i)
{ {
#ifndef _LIBCPP_HAS_NO_THREADS
WLock _(mut()); WLock _(mut());
#endif
__insert_iterator(__i); __insert_iterator(__i);
} }
Context not available.

src/future.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "__config"
#ifndef _LIBCPP_HAS_NO_THREADS
#include "future" #include "future"
#include "string" #include "string"
Context not available.
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
Context not available.

src/memory.cpp

Context not available.
#define _LIBCPP_BUILDING_MEMORY #define _LIBCPP_BUILDING_MEMORY
#include "memory" #include "memory"
#ifndef _LIBCPP_HAS_NO_THREADS
#include "mutex" #include "mutex"
#include "thread" #include "thread"
#endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
Context not available.
#endif // _LIBCPP_NO_RTTI #endif // _LIBCPP_NO_RTTI
#if __has_feature(cxx_atomic) #if __has_feature(cxx_atomic) && !_LIBCPP_HAS_NO_THREADS
static const std::size_t __sp_mut_count = 16; static const std::size_t __sp_mut_count = 16;
static pthread_mutex_t mut_back_imp[__sp_mut_count] = static pthread_mutex_t mut_back_imp[__sp_mut_count] =
Context not available.
return muts[hash<const void*>()(p) & (__sp_mut_count-1)]; return muts[hash<const void*>()(p) & (__sp_mut_count-1)];
} }
#endif // __has_feature(cxx_atomic) #endif // __has_feature(cxx_atomic) && !_LIBCPP_HAS_NO_THREADS
void void
declare_reachable(void*) declare_reachable(void*)
Context not available.

src/mutex.cpp

Context not available.
#include "cassert" #include "cassert"
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_THREADS
const defer_lock_t defer_lock = {}; const defer_lock_t defer_lock = {};
const try_to_lock_t try_to_lock = {}; const try_to_lock_t try_to_lock = {};
Context not available.
} }
} }
#endif // !_LIBCPP_HAS_NO_THREADS
// If dispatch_once_f ever handles C++ exceptions, and if one can get to it // If dispatch_once_f ever handles C++ exceptions, and if one can get to it
// without illegal macros (unexpected macros not beginning with _UpperCase or // without illegal macros (unexpected macros not beginning with _UpperCase or
// __lowercase), and if it stops spinning waiting threads, then call_once should // __lowercase), and if it stops spinning waiting threads, then call_once should
Context not available.
// call into dispatch_once_f instead of here. Relevant radar this code needs to // call into dispatch_once_f instead of here. Relevant radar this code needs to
// keep in sync with: 7741191. // keep in sync with: 7741191.
#ifndef _LIBCPP_HAS_NO_THREADS
static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cv = PTHREAD_COND_INITIALIZER; static pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
#endif
void void
__call_once(volatile unsigned long& flag, void* arg, void(*func)(void*)) __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
{ {
#if defined(_LIBCPP_HAS_NO_THREADS)
if (flag == 0)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
flag = 1;
EricWFUnsubmitted
Not Done
ReplyInline Actions

Wouldn't it be a lot cleaner to just separate the two implementation entirely instead of interweaving them like this?

EricWF: Wouldn't it be a lot cleaner to just separate the two implementation entirely instead of…
jroelofsAuthorUnsubmitted
Not Done
ReplyInline Actions

Sigh. Yes. *hits head on desk*. Why did I do it like that?

jroelofs: Sigh. Yes. *hits head on desk*. Why did I do it like that?
func(arg);
flag = ~0ul;
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
flag = 0ul;
throw;
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
#else // !_LIBCPP_HAS_NO_THREADS
pthread_mutex_lock(&mut); pthread_mutex_lock(&mut);
while (flag == 1) while (flag == 1)
pthread_cond_wait(&cv, &mut); pthread_cond_wait(&cv, &mut);
Context not available.
} }
else else
pthread_mutex_unlock(&mut); pthread_mutex_unlock(&mut);
#endif // !_LIBCPP_HAS_NO_THREADS
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
Context not available.

src/shared_mutex.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "__config"
#ifndef _LIBCPP_HAS_NO_THREADS
#define _LIBCPP_BUILDING_SHARED_MUTEX #define _LIBCPP_BUILDING_SHARED_MUTEX
#include "shared_mutex" #include "shared_mutex"
Context not available.
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
Context not available.

src/thread.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "__config"
#ifndef _LIBCPP_HAS_NO_THREADS
#include "thread" #include "thread"
#include "exception" #include "exception"
#include "vector" #include "vector"
jroelofsAuthorUnsubmitted
Not Done
ReplyInline Actions

un-necessary whitespace change

jroelofs: un-necessary whitespace change
Context not available.
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !_LIBCPP_HAS_NO_THREADS
Context not available.

test/atomics/atomics.fences/atomic_thread_fence.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.flag/atomic_flag_clear.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.flag/clear.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.flag/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.flag/init.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.flag/test_and_set.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.lockfree/lockfree.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.order/kill_dependency.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.order/memory_order.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.generic/address.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... test case crashes clang.
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.generic/bool.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.generic/integral.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.generic/integral_typedefs.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 34
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 38
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 34
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 38
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... fails assertion line 31
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 32
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... test crashes clang
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... test crashes clang
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... test crashes clang
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... test crashes clang
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 34
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 34
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 31
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 31
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// ... assertion fails line 31
// <atomic> // <atomic>
Context not available.

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/atomics/version.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <atomic> // <atomic>
Context not available.

test/thread/futures/futures.async/async.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.errors/default_error_condition.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.errors/equivalent_error_code_int.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.errors/equivalent_int_error_condition.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.errors/future_category.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.errors/make_error_code.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.errors/make_error_condition.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.future_error/code.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.future_error/types.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.future_error/what.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// LWG 2056 changed the values of future_errc, so if we're using new headers // LWG 2056 changed the values of future_errc, so if we're using new headers
// with an old library we'll get incorrect messages. // with an old library we'll get incorrect messages.
Context not available.

test/thread/futures/futures.overview/future_errc.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.overview/future_status.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.overview/is_error_code_enum_future_errc.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.overview/launch.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/alloc_ctor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/dtor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/get_future.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/move_assign.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/move_ctor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_exception.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_lvalue.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_lvalue_at_thread_exit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_rvalue.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_rvalue_at_thread_exit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_value_at_thread_exit_const.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_value_at_thread_exit_void.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_value_const.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/set_value_void.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.promise/uses_allocator.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/copy_assign.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/copy_ctor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/ctor_future.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/dtor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/get.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/move_assign.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/move_ctor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/wait.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/wait_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.shared_future/wait_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/assign_move.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/ctor_default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/ctor_func.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/ctor_func_alloc.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/ctor_move.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/dtor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/get_future.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/make_ready_at_thread_exit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/operator.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/reset.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.members/swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.nonmembers/swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/futures.task.nonmembers/uses_allocator.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.tas/types.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/dtor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/get.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/move_assign.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/move_ctor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/share.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/wait.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/wait_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/futures.unique_future/wait_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/futures/version.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
Context not available.

test/thread/macro.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.condition/cv_status.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/notify_all_at_thread_exit.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/destructor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/native_handle.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/notify_all.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/wait.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/destructor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/notify_all.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/notify_one.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/wait.exception.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
#include <thread> #include <thread>
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>

test/thread/thread.condition/thread.condition.condvarany/wait.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/wait_for.exception.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
#include <thread> #include <thread>
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>

test/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.condition/version.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <condition_variable> // <condition_variable>
Context not available.

test/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.guard/adopt_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.guard/mutex.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.guard/types.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_time_point.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_try_to_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/member_swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/nonmember_swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.mod/release.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/mutex.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/op_bool.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.obs/owns_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.shared/types.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_duration.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_time_point.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_try_to_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/unlock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/member_swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/nonmember_swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.mod/release.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/mutex.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/op_bool.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.obs/owns_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/thread.lock.unique/types.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.lock/types.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/native_handle.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/try_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/native_handle.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.recursive/try_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <shared_mutex> // <shared_mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.class/try_lock_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.mutex.requirements/thread.timedmutex.requirements/thread.timedmutex.recursive/try_lock_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.

test/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <mutex> // <mutex>
Context not available.
class MoveOnly class MoveOnly
{ {
#if !defined(__clang__)
// GCC 4.8 complains about the following being private
public:
MoveOnly(const MoveOnly&)
{
}
#else
MoveOnly(const MoveOnly&); MoveOnly(const MoveOnly&);
#endif
public: public:
MoveOnly() {} MoveOnly() {}
MoveOnly(MoveOnly&&) {} MoveOnly(MoveOnly&&) {}
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.algorithm/swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.assign/move.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.constr/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.constr/move.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.id/assign.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.id/copy.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.id/default.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.id/eq.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.id/lt.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.id/stream.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <functional> // <functional>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.member/get_id.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.member/join.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.member/joinable.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.member/native_handle.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.member/swap.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/thread.thread.static/hardware_concurrency.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.class/types.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.this/get_id.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.this/sleep_for.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/thread.thread.this/yield.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/thread/thread.threads/version.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <thread> // <thread>
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp

Context not available.
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//
// UNSUPPORTED: libcpp-has-no-threads
// <memory> // <memory>
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.

test/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp

Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// UNSUPPORTED: libcpp-has-no-threads
//
// This test uses new symbols that were not defined in the libc++ shipped on // This test uses new symbols that were not defined in the libc++ shipped on
// darwin11 and darwin12: // darwin11 and darwin12:
// XFAIL: with_system_lib=x86_64-apple-darwin11 // XFAIL: with_system_lib=x86_64-apple-darwin11
Context not available.