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

[joerg]

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]

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]

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]

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]

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]

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]

sources/cxx-stl/llvm-libc++/libcxx/include/__config

14 ↗

(On Diff #9964)

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

[joerg]

What is the status of this patch?

[jroelofs]

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]

Hi Joerg,

I'm finally resurrecting this...

[jroelofs]

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

[jroelofs]

Fix a couple of typos I just caught.

[jroelofs]

Ping

[mclow.lists]

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

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]

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

include/__config

126

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]

Implement a few of mclow's comments.

[jroelofs]

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

include/__config

126

@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]

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

[jroelofs]

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]

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]

src/mutex.cpp

224–233

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

[jroelofs]

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]

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]

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]

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.

[jroelofs]

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

[jroelofs]

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

[jroelofs]

r217271

include/__config

 // -*- C++ -*-
 //===--------------------------- __config ---------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_CONFIG
 #define _LIBCPP_CONFIG
 
+#if !_WIN32
+#include <unistd.h>
+#endif
+
 #if !defined(_MSC_VER) || defined(__clang__)
 #pragma GCC system_header
 #endif
 
 #ifdef __GNUC__
 #define _GNUC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
 #endif
 

 # elif __BYTE_ORDER == __BIG_ENDIAN
 #  define _LIBCPP_LITTLE_ENDIAN 0
 #  define _LIBCPP_BIG_ENDIAN    1
 # else  // __BYTE_ORDER == __BIG_ENDIAN
 #  error unable to determine endian
 # endif
 #endif  // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
 
+#if !defined(_LIBCPP_HAS_NO_THREADS) && (!defined(_POSIX_THREADS) || _POSIX_THREADS <= 0)
+#  error <unistd.h> suggests that your system doesn't have PTHREADS... \
+         If you'd like to build libcxx for a single threaded system,   \
+         please use -D_LIBCPP_SINGLE_THREADED
+#endif
+
 #ifdef _WIN32
 
 // only really useful for a DLL
 #ifdef _LIBCPP_DLL // this should be a compiler builtin define ideally...
 # ifdef cxx_EXPORTS
 #  define _LIBCPP_HIDDEN
 #  define _LIBCPP_FUNC_VIS __declspec(dllexport)
 #  define _LIBCPP_TYPE_VIS __declspec(dllexport)

include/__mutex_base

 #include <pthread.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_HAS_NO_THREADS
+
 class _LIBCPP_TYPE_VIS mutex
 {
     pthread_mutex_t __m_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
      constexpr mutex() _NOEXCEPT : __m_(PTHREAD_MUTEX_INITIALIZER) {}
 #else
      mutex() _NOEXCEPT {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
 #endif
      ~mutex();
 
 private:
     mutex(const mutex&);// = delete;
public:
 
     typedef pthread_cond_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
 
 private:
     void __do_timed_wait(unique_lock<mutex>& __lk,
        chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
 };
+#endif // !_LIBCPP_HAS_NO_THREADS
 
 template <class _To, class _Rep, class _Period>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     chrono::__is_duration<_To>::value,
     _To
 >::type
 __ceil(chrono::duration<_Rep, _Period> __d)
 {
     using namespace chrono;
     _To __r = duration_cast<_To>(__d);
     if (__r < __d)
         ++__r;
     return __r;
 }
 
+#ifndef _LIBCPP_HAS_NO_THREADS
 template <class _Predicate>
 void
 condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
 {
     while (!__pred())
         wait(__lk);
 }
 

 condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d,
                              _Predicate __pred)
 {
     return wait_until(__lk, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
+#endif // !_LIBCPP_HAS_NO_THREADS
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP___MUTEX_BASE

include/atomic

 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #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
 
 #if !__has_feature(cxx_atomic) && _GNUC_VER < 407
 #error <atomic> is not implemented
 #else
 
 typedef enum memory_order
 {

 #define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE
 #define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
 #define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE
 
 #endif  //  !__has_feature(cxx_atomic)
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif  // !_LIBCPP_HAS_NO_THREADS
+
 #endif  // _LIBCPP_ATOMIC

include/condition_variable

 #include <__config>
 #include <__mutex_base>
 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#ifndef _LIBCPP_HAS_NO_THREADS
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS condition_variable_any
 {
     condition_variable __cv_;
     shared_ptr<mutex>  __mut_;
 public:
     condition_variable_any();
return wait_until(__lock, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
 _LIBCPP_FUNC_VIS
 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // !_LIBCPP_HAS_NO_THREADS
+
 #endif  // _LIBCPP_CONDITION_VARIABLE

include/future

 #include <exception>
 #include <mutex>
 #include <thread>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #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
 
 //enum class future_errc
 _LIBCPP_DECLARE_STRONG_ENUM(future_errc)
 {
     future_already_retrieved = 1,
     promise_already_satisfied,
     no_state,

 {
     return shared_future<void>(_VSTD::move(*this));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // !_LIBCPP_HAS_NO_THREADS
+
 #endif  // _LIBCPP_FUTURE

include/memory

 #include <__functional_base>
 #include <iosfwd>
 #include <tuple>
 #include <cstring>
 #if defined(_LIBCPP_NO_EXCEPTIONS)
     #include <cassert>
 #endif
 
-#if __has_feature(cxx_atomic)
+#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
 #  include <atomic>
 #endif
 
 #include <__undef_min_max>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

     }
 };
 
 template<class _CharT, class _Traits, class _Yp>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 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
 {
     void* __lx;
 public:
     void lock() _NOEXCEPT;
     void unlock() _NOEXCEPT;
 

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
                                       shared_ptr<_Tp> __w, memory_order, memory_order)
 {
     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
 struct _LIBCPP_TYPE_VIS pointer_safety
 {
     enum __lx
     {
         relaxed,
         preferred,

include/mutex

 #include <__undef_min_max>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_HAS_NO_THREADS
+
 class _LIBCPP_TYPE_VIS recursive_mutex
 {
     pthread_mutex_t __m_;
 
 public:
      recursive_mutex();
      ~recursive_mutex();
 

 void
 lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 {
     __lock_first(0, __l0, __l1, __l2, __l3...);
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
+#endif // !_LIBCPP_HAS_NO_THREADS
+
 struct _LIBCPP_TYPE_VIS_ONLY once_flag;
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template<class _Callable, class... _Args>
 _LIBCPP_INLINE_VISIBILITY
 void call_once(once_flag&, _Callable&&, _Args&&...);
 

include/shared_mutex

 #include <__mutex_base>
 
 #include <__undef_min_max>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #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
 
 class _LIBCPP_TYPE_VIS shared_timed_mutex
 {
     mutex               __mut_;
     condition_variable  __gate1_;
     condition_variable  __gate2_;
     unsigned            __state_;

 template <class _Mutex>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept
     {__x.swap(__y);}
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif  // !_LIBCPP_HAS_NO_THREADS
+
 #endif  // _LIBCPP_STD_VER > 11
 
 #endif  // _LIBCPP_SHARED_MUTEX

include/thread

 #include <pthread.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #define __STDCPP_THREADS__ __cplusplus
 
+#ifdef _LIBCPP_HAS_NO_THREADS
+#error <thread> is not supported on this single threaded system
+#else // !_LIBCPP_HAS_NO_THREADS
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 class __thread_specific_ptr
 {
     pthread_key_t __key_;
 
     __thread_specific_ptr(const __thread_specific_ptr&);

 
 inline _LIBCPP_INLINE_VISIBILITY
 void yield() _NOEXCEPT {sched_yield();}
 
 }  // this_thread
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // !_LIBCPP_HAS_NO_THREADS
+
 #endif  // _LIBCPP_THREAD

src/algorithm.cpp

 template bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&);
 template bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&);
 template bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&);
 template bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&);
 template bool __insertion_sort_incomplete<__less<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;
+#endif
 unsigned __rs_default::__c_ = 0;
 
 __rs_default::__rs_default()
 {
+#ifndef _LIBCPP_HAS_NO_THREADS
     pthread_mutex_lock(&__rs_mut);
+#endif
     __c_ = 1;
 }
 
 __rs_default::__rs_default(const __rs_default&)
 {
     ++__c_;
 }
 
 __rs_default::~__rs_default()
 {
+#ifndef _LIBCPP_HAS_NO_THREADS
     if (--__c_ == 0)
         pthread_mutex_unlock(&__rs_mut);
+#else
+    --__c_;
+#endif
 }
 
 __rs_default::result_type
 __rs_default::operator()()
 {
     static mt19937 __rs_g;
     return __rs_g();
 }
 
 __rs_default
 __rs_get()
 {
     return __rs_default();
 }
 
 _LIBCPP_END_NAMESPACE_STD

src/condition_variable.cpp

 //===-------------------- condition_variable.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.
 //
 //===----------------------------------------------------------------------===//
 
+#include "__config"
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
 #include "condition_variable"
 #include "thread"
 #include "system_error"
 #include "cassert"
 
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 condition_variable::~condition_variable()
 {
     pthread_cond_destroy(&__cv_);
 }
 
 void

 
 void
 notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
 {
     __thread_local_data()->notify_all_at_thread_exit(&cond, lk.release());
 }
 
 _LIBCPP_END_NAMESPACE_STD
+
+#endif // !_LIBCPP_HAS_NO_THREADS
+

src/debug.cpp

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

src/future.cpp

 //===------------------------- future.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.
 //
 //===----------------------------------------------------------------------===//
 
+#include "__config"
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
 #include "future"
 #include "string"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __future_error_category
     : public __do_message
 {
if (__rhs.__state_)
         __rhs.__state_->__add_shared();
     if (__state_)
         __state_->__release_shared();
     __state_ = __rhs.__state_;
     return *this;
 }
 
 _LIBCPP_END_NAMESPACE_STD
+
+#endif // !_LIBCPP_HAS_NO_THREADS
+
+

src/memory.cpp

 //===------------------------ memory.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.
 //
 //===----------------------------------------------------------------------===//
 
 #define _LIBCPP_BUILDING_MEMORY
 #include "memory"
+#ifndef _LIBCPP_HAS_NO_THREADS
 #include "mutex"
 #include "thread"
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace
 {
 
 template <class T>
 inline T

 const void*
 __shared_weak_count::__get_deleter(const type_info&) const _NOEXCEPT
 {
     return 0;
 }
 
 #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 pthread_mutex_t mut_back_imp[__sp_mut_count] =
 {
     PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
     PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
     PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
     PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER
static __sp_mut muts[__sp_mut_count]
         &mut_back[ 0], &mut_back[ 1], &mut_back[ 2], &mut_back[ 3],
         &mut_back[ 4], &mut_back[ 5], &mut_back[ 6], &mut_back[ 7],
         &mut_back[ 8], &mut_back[ 9], &mut_back[10], &mut_back[11],
         &mut_back[12], &mut_back[13], &mut_back[14], &mut_back[15]
     };
     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
 declare_reachable(void*)
 {
 }
 
 void
 declare_no_pointers(char*, size_t)

src/mutex.cpp

 //===------------------------- mutex.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.
 //
 //===----------------------------------------------------------------------===//
 
 #define _LIBCPP_BUILDING_MUTEX
 #include "mutex"
 #include "limits"
 #include "system_error"
 #include "cassert"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+#ifndef _LIBCPP_HAS_NO_THREADS
 
 const defer_lock_t  defer_lock = {};
 const try_to_lock_t try_to_lock = {};
 const adopt_lock_t  adopt_lock = {};
 
 mutex::~mutex()
 {
     pthread_mutex_destroy(&__m_);
recursive_timed_mutex::unlock() _NOEXCEPT
     if (--__count_ == 0)
     {
         __id_ = 0;
         lk.unlock();
         __cv_.notify_one();
     }
 }
 
+#endif // !_LIBCPP_HAS_NO_THREADS
+
 // 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
 // __lowercase), and if it stops spinning waiting threads, then call_once should
 // call into dispatch_once_f instead of here. Relevant radar this code needs to
 // keep in sync with:  7741191.
 
+#ifndef _LIBCPP_HAS_NO_THREADS
 static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t  cv  = PTHREAD_COND_INITIALIZER;
+#endif
 
 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;
+            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);
     while (flag == 1)
         pthread_cond_wait(&cv, &mut);
     if (flag == 0)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
#ifndef _LIBCPP_NO_EXCEPTIONS
             pthread_mutex_unlock(&mut);
             pthread_cond_broadcast(&cv);
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
     else
         pthread_mutex_unlock(&mut);
+#endif // !_LIBCPP_HAS_NO_THREADS
+
 }
 
 _LIBCPP_END_NAMESPACE_STD

src/shared_mutex.cpp

 //===---------------------- shared_mutex.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.
 //
 //===----------------------------------------------------------------------===//
 
+#include "__config"
+#ifndef _LIBCPP_HAS_NO_THREADS
+
 #define _LIBCPP_BUILDING_SHARED_MUTEX
 #include "shared_mutex"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 shared_timed_mutex::shared_timed_mutex()
     : __state_(0)
 {
shared_timed_mutex::unlock_shared()
     {
         if (num_readers == __n_readers_ - 1)
             __gate1_.notify_one();
     }
 }
 
 
 _LIBCPP_END_NAMESPACE_STD
+
+#endif // !_LIBCPP_HAS_NO_THREADS
+
+

src/thread.cpp

 //===------------------------- thread.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.
 //
 //===----------------------------------------------------------------------===//
 
+#include "__config"
+#ifndef _LIBCPP_HAS_NO_THREADS
+
 #include "thread"
 #include "exception"
 #include "vector"
 #include "future"
 #include "limits"
 #include <sys/types.h>
 #if !defined(_WIN32)
 #if !defined(__sun__) && !defined(__linux__) && !defined(_AIX)
 #include <sys/sysctl.h>
 #endif // !__sun__ && !__linux__ && !_AIX
 #include <unistd.h>
 #endif // !_WIN32
 
 #if defined(__NetBSD__)
 #pragma weak pthread_create // Do not create libpthread dependency
 #endif
 #if defined(_WIN32)
 #include <windows.h>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 thread::~thread()
 {
     if (__t_ != 0)
         terminate();
 }
 
 void

 
 void
 __thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s)
 {
     __p_->__make_ready_at_thread_exit(__s);
 }
 
 _LIBCPP_END_NAMESPACE_STD
+
+#endif // !_LIBCPP_HAS_NO_THREADS