[libcxx][SystemZ][ POSIX(OFF) support on z/OS

[zibi]

Summary

This is the 3rd version for POSIX(OFF) on z/OS. It replaces previous proposals in D110349 and D117375. This patch will help out other platforms where threading support can be determined and/or switched at run-time like AIX.

The full support on z/OS for POSIX(OFF) depends on the following, additional patches from version 2 (D117375). Eventually they need to be landed as well. I'm listing them just for reference:

D117373
D117372
D117366

Please be aware that this revision doesn't include the necessary work for:

1. the shared_ptr overloads of std::atomic_foo()
2. Debug Mode
3. std::random_shuffle(first, last)
4. fallback_malloc

[• Quuxplusone]

Does this mean that D110349 and/or D117375 could be closed/abandoned at this point?

libcxxabi/src/cxa_guard_impl.h

296

Do you know a concrete reason that _VSTD is needed here, i.e. why wouldn't std::internal_thread::__libcpp_condvar_broadcast work here?

[zibi]

In D120348#3338820, @Quuxplusone wrote:

Does this mean that D110349 and/or D117375 could be closed/abandoned at this point?

Yes, they will be closed once this is approved.

libcxxabi/src/cxa_guard_impl.h

296

No reason, I will change it to std::internal_thread::

[zibi]

Change _VSTD to std and formatting changes to fix CI.

[zibi]

Formatting and fixing MAC/WIN/AIX builds.

[zibi]

Rebase to fix CI documentation error

[DanielMcIntosh-IBM]

libcxx/src/include/internal_threading_support.h

55–59

This is redundant because it's part of the forward declaration.

71

Unlike _VSTD::__libcpp_foo, these are never provided by an external library, nor are the definitions ever used to build an external library, so they should probably always be inline and hidden from the ABI.

198

199

[DanielMcIntosh-IBM]

libcxx/src/include/internal_threading_support.h

71

This will also probably fix the Windows CI failures.

[zibi]

Attempt to fix CI with _LIBCXXABI_HAS_NO_THREADS guard.

[zibi]

another attempt to fix CI

[zibi]

Trying to fix CI with static inline and addressing Daniel's comments.

[zibi]

rebase to fix CI

[DanielMcIntosh-IBM]

LGTM

[zibi]

NFC to pick up the fix for std_format_spec_string_unicode.pass.cp and make CI clean.

[zibi]

Switched to new header <threading_support.h> introduced in https://reviews.llvm.org/D106124?id=411574.

[zibi]

Move threading_support.h to libcxx/include to be together with __threading_support.

[zibi]

formatting

[zibi]

Attempt to fix Generated output in CI

[zibi]

waiting for the review...

[zibi]

Rebase and undo changes for reverted commit 5aaefa51.

[EricWF]

libcxx/src/include/internal_threading_support.h

28

I think we're very trying to avoid including <cassert> anywhere within libc++ headers.

31

Why static inline?

36

These declarations are different every time they appear..

63

This would need to be a reserved identifier.

77

Why not just use weak functions to allow different definitions, which can live outside of mainline libc++, to be shimmed in at link/load time?

179

No assert. Use one of the abort methods.

libcxxabi/src/cxa_exception_storage.cpp

96

This seems like performance sensitive code. Are we cool with a branch here?

Also, are we even allowed to use function local statics in this function?

libcxxabi/test/test_exception_storage.pass.cpp

19–20

This diff is hard to read because of all the whitespace changes.
What has actually changed here?

[EricWF]

The entire point of the <__threading_support> interface is that it allows vendors/system maintainers to provide their own implementation without needing to change libc++.
I don't see why this patch couldn't use that same mechanism?

The libc++abi changes might need to live upstream, but the rest wouldn't.

[zibi]

libcxxabi/test/test_exception_storage.pass.cpp

19–20

I decided to do clang-format on the entire file since CI was failing and suggesting indentation which was not inline with the rest of the file. The file is relatively small. The relevant changes are inside the main():

#ifdef _LIBCXXABI_HAS_NO_THREADS
  size_t thread_globals;
  thread_code(&thread_globals);
  // Check that __cxa_get_globals() is not NULL.
  return (thread_globals == 0) ? 1 : 0;
#else  // !_LIBCXXABI_HAS_NO_THREADS
  // If threads are disabled at runtime, revert to single-threaded test.
  if (!__libcpp_is_threading_api_enabled()) {
    thread_code((void*)thread_globals);
    // Check that __cxa_get_globals() is not NULL.
    return (thread_globals[0] == 0) ? 1 : 0;
  }

[DanielMcIntosh-IBM]

libcxx/src/include/internal_threading_support.h

28

Even for internal headers? (Note that this file is under libcxx/src/include rather than libcxx/include)

31

To prevent this symbol from getting exported as part of the library (it shouldn't ever get invoked by user code and is purely for internal use within libcxx/libcxxabi source), and also to prevent duplicate definitions as a result of using this header in both libcxx and libcxxabi.

36

I'm not sure what you mean?

Since there's no standard way of checking whether the base threading library (e.g. pthreads) is available, each platform which needs to support runtime-dependent threading will have to write their own implementation of these functions (line 40-54). For example, AIX would change the #if on line 29 to #if defined(__MVS__) || defined(_AIX), and add it's own implementation before line 49 (guarded by an # elif defined(_AIX)).

Since each platform will need to provide their own implementation, we've provided a separate forward declaration to ensure the signature is always the same across all platforms (line 29-38). However, on platforms which don't have runtime-dependent threading (i.e. they know at the time we compile libcxx/libcxxabi whether a thread library like pthreads is available) the default, trivial implementation we provide should ideally declare these functions as constexpr. To do this we need to provide two separate versions of the forward declaration.

63

Probably a good idea to use a reserved identifier anyways, but this is internal to libcxx/libcxxabi, so it's impossible for this to produce any negative interaction with user code. Note that every symbol in this file is static inline.

[EricWF]

I made a few mistakes in my first set of comments. I better understand now. But I'm even more concerned.
I'll spend some time reading the design doc to see if that answers my quenstions.

libcxx/src/include/internal_threading_support.h

28

Sorry, I see now that this isn't strictly a libc++ header.

44

s/should not/does not Because that's necessary for correctness.
When exactly at runtime does this property become fixed?

63

Disregard that comment. I see I was mistakne.

68

This non-recursive call that looks super recursive makes me super uncomfortable.
Can't we just choose a different name?

What does the call to _VSTD::__libcpp_recursive_mutex_init do if threading is fully disabled?

73

Can __libcpp_might_have_multiple_threads() change during program execution? Or is its value fixed after program load?

85

When are any of these functions called?

For example, there's nothing in the src/ directory that calls __libcpp_thread_yield() but there's a definition for internal_thread::__libcpp_thread_yield.

92

If __libcpp_might_have_multiple_threads is a property set during program load. Couldn't these simply be

static auto  __libcpp_foo = __libcpp_might_have_multiple_threads() ? +[](auto args...) { return std::__libcpp_foo(args...); } : +[](auto args...) { return 0; }

171

I thought the value of __libcpp_is_threading_api_enabled cannot change during program execution.

I don't see how any of this code is correct if that property can change. What if it changes right after our call to __libcpp_is_threading_api_enabled() ? Then whatever we do next is racey because we're skipping the now required synchronization,

libcxx/src/locale.cpp

730

I would prefer we just use call_once in all cases. Why can't we do that?
Presumably call_once needs to work when you have runtime enable/disabled threads?

[DanielMcIntosh-IBM]

libcxx/src/locale.cpp

730

call_once doesn't need to work when you threads have been disabled at runtime. As I discuss in D117372 it's actually kind of foolish to use call_once when threads have been disabled.

We could still support it, but we'd have to make changes to std::__call_once. That is an option, and it's what I went with in V1 and V2, but as I discuss in D117372, I think the better option is to eventually stop using call_once or any other parts of the C++11 Thread Support Library in the rest of libc++.

libcxxabi/src/cxa_exception_storage.cpp

96

On platforms without runtime-dependent threading, __libcpp_is_threading_api_enabled() is constexpr, so this should almost always be optimized out (and every compiler I can find will do it even on -O0).

I don't see why we couldn't use function local statics here? We use them when HAS_THREAD_LOCAL is defined (though they are thread_local there).

[zibi]

The __libcpp_is_threading_api_enabled() checks if threading is enabled (POSIX ON) or not (POSIX OFF) as its name clearly indicates. It cannot be changed throughout the
live of the application but it can be set at the start of the application via env. var. _CEE_RUNOPTS=POSIX(OFF).

However, the __libcpp_might_have_multiple_threads() can be changed in the life of the application. It is needed so the single threading execution can be made optimum.

libcxx/src/include/internal_threading_support.h

31

The static inline was chosen so they are optimized out on the platforms which do not have dynamic threading support.

68

Are you suggesting to change names for all __libcpp_recursive_foo() functions in this file and __threading_support? We use static mechanism and
@DanielMcIntosh-IBM can provide more details if needed.

73

It can change during the execution of the program.

77

We will have to experiment to see if that is even fisible.

92

The __libcpp_might_have_multiple_threads can change during the execution.

171

The value of __libcpp_is_threading_api_enabled() can only change at the load time.

179

Can you provide an example for it?

libcxx/src/locale.cpp

730

Will have a look at that. @DanielMcIntosh-IBM are then any plans to make changes to call_once() in future patches?

libcxxabi/src/cxa_exception_storage.cpp

96

I think so, this is done in single threaded case.

[zibi]

Fix a typo.

[DanielMcIntosh-IBM]

In D120348#3375321, @zibi wrote:

The __libcpp_is_threading_api_enabled() checks if threading is enabled (POSIX ON) or not (POSIX OFF) as its name clearly indicates. It cannot be changed throughout the
live of the application but it can be set at the start of the application via env. var. _CEE_RUNOPTS=POSIX(OFF).

However, the __libcpp_might_have_multiple_threads() can be changed in the life of the application. It is needed so the single threading execution can be made optimum.

Just to clarify this point a little bit: There are many places where we could use either might_have_multiple_threads() or is_threading_api_enabled(). However, some places are a little more sensitive to which one we choose to use.

First, __cxa_get_globals_fast() needs to be as consistent as possible about which __cxa_eh_globals object it associates with a given thread. This makes might_have_multiple_threads() a bad choice here, and using it would effectively forbid users from spawning threads while exception handling is ongoing. Spawning a thread inside a catch block seems like uncommon, but not unreasonable behaviour, so we'd like to support it if possible. To a lesser extent, this is also true for spawning a thread in a deconstructor during stack unwinding. Banning users from loading the thread library under the same circumstances is much more palatable, not to mention that loading the thread library mid-program is not possible on platforms like z/OS anyways.

Second, cxa_guard cannot invoke any functions which use static local variables. So, the functions it uses when locking/unlocking a mutex don't really have any decent way of preserving information across invocations. In other words, even though is_threading_api_enabled() doesn't change during the application lifetime, if cxa_guard was to use it, we'd have to get rid of any static locals from it, and re-load the value from __libcpp_ceeedb_posix() every time. We could create a separate is_threading_api_enabled_no_statics(), internal_thread::__libcpp_mutex_lock_no_static(), internal_thread::__libcpp_condvar_broadcast_no_static(), etc. but at that point why not just use might_have_multiple_threads()?
Admittedly, we could remove any static locals from is_threading_api_enabled() and just tank the performance hit that comes with making something like 5 sequential load operations every time we call it (2 in __libcpp_ceeedb_flags and 3 when that calls __gtca()), but as you pointed out, some of these areas appear to be performance critical (e.g. __cxa_get_globals_fast()).

libcxx/src/include/internal_threading_support.h

44

When exactly at runtime does this property become fixed?

On z/OS, it's set by the OS prior to launching an application (that is, prior to ANYTHING that the user/library has any control over)

68

The names were chosen to match the names from __threading_support since these are mostly just thin wrappers around those functions and intended as drop-in replacements. I don't see any reason we couldn't use different names, but it should be clear which function from __threading_support each one is a wrapper for. Since they're supposed to be drop-in replacements the most logical thing seemed to be to use the same names, but we could add a _wrapped suffix or something I suppose.

73

As zibi said, it can change during the execution of the program, but it can't spontaneously go from false to true. That would require e.g. spawning a thread.

77

z/OS has very limited and weak support (no pun intended) for weak linking. It really only works if both definitions are visible at link time, and neither is coming from a shared library.

During the link stage, z/OS will prioritize symbols from object/source files and such over shared libraries, regardless of whether they've been declared as weak definitions. Furthermore, when searching for a symbol in shared libraries, z/OS uses "Side decks" to determine which shared libraries provide which symbols. Side decks do not record information about whether a symbol is weak, so it's impossible to weakly export a symbol from a shared library.

85

Many of these are not called as far as I'm aware. They're just provided for increased parity with __threading_support (though I'm noticing now that we have already dropped some functions). We might be able to remove many of them if you'd prefer a more limited set of definitions here.

171

This comment is a little misleading now that this bit of code is z/OS-specific. Initially we'd hoped to write this in a more generic way, but on some platforms __libcpp_exec_once_flag is a struct, which made everything too complicated. We should probably update the comment to make the intent more clear. It was simply intended as a warning for other platforms like AIX where __libcpp_is_threading_api_enabled() might change mid-program that they might not be able to re-use this because of the *flag = 2; part.

Side note: @zibi It won't make any difference to program correctness, but now that this code is z/OS specific it might be a good idea to make sure that we're writing the same value _VSTD::__libcpp_execute_once would write.

[DanielMcIntosh-IBM]

libcxx/src/locale.cpp

730

Will have a look at that. @DanielMcIntosh-IBM are then any plans to make changes to call_once() in future patches?

Not at the moment. The plan is to apply D117372 and D117373, then leave all of the C++11 Thread Support library unsupported/UB when threads are disabled.
This gives a very clear and sensible division between what is and isn't supported, rather than some vague, best-effort system, or listing every unsupported function one at a time.
As I discuss here, IMO this is what we should have done for _LIBCPP_HAS_NO_THREADS, but it might be too late for that now.

Update: it appears that [atomic] in the standard has been moved under [thread] and what was previously known as the "Thread Support Library" is now the "Concurrency support library" (see https://github.com/cplusplus/draft/commit/d74c2170a9f4c928519461d7742293af2d141852). This changes how we have to word things in documentation and comments, but that's about it. E.g. now the plan would be "When threads are disabled, support of the C++11 Concurrency Support Library will be limited to atomic operations."

[zibi]

This revision updates __libcpp_execute_once() according to the comments.

[ldionne]

libcxx/src/include/internal_threading_support.h

77

Does this mean that users can't override operator new/operator delete by providing a strong definition in their program, i.e. that it's impossible to have a conforming C++ implementation on z/OS?

[DanielMcIntosh-IBM]

libcxx/src/include/internal_threading_support.h

77

At the moment, yes. Any invocation of new and delete within the standard library DLL will not use any user-defined operator new\operator delete. This is something that would need to be fixed in the OS, and I'm not aware of any timeline or plans for fixing it right now.

Win32 DLL has the same problem, and had to disable portions of tests for that reason. D107755 made their solution more generic so it could be used for z/OS.

[zibi]

This revision reduced wrapper functions in internal_threading_support.h to just
__libcpp_mutex_lock_wrapper() and __libcpp_mutex_unlock_wrapper() with the new suffix.
This is a bare minimum needed for POSIX(OFF) on z/OS.

It also added the guard for z/OS was added in locale::id::__get() for POSIX(OFF) path.

Lastly, the formatting in test_exception_storage.pass.cpp was removed to help the review.

[DanielMcIntosh-IBM]

libcxxabi/test/test_exception_storage.pass.cpp

54–56

This indentation should match the rest of the if

[zibi]

libcxxabi/test/test_exception_storage.pass.cpp

54–56

Yes, I will wait if there are any other requests and do them together otherwise, I'm planning to clang-format the entire file as I had before in a separate subsequent commit.

[zibi]

@ldionne Louis, this is one of the reviews I DM you about.

libcxx/src/CMakeLists.txt

set(LIBCXX_SOURCES
   condition_variable_destructor.cpp
   exception.cpp
   functional.cpp
   future.cpp
   hash.cpp
   include/apple_availability.h
   include/atomic_support.h
   include/config_elast.h
+  include/internal_threading_support.h
   include/refstring.h
   include/ryu/common.h
   include/ryu/d2fixed.h
   include/ryu/d2fixed_full_table.h
   include/ryu/d2s.h
   include/ryu/d2s_full_table.h
   include/ryu/d2s_intrinsics.h
   include/ryu/digit_table.h

 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
   list(APPEND LIBCXX_SOURCES
     support/solaris/mbsnrtowcs.inc
     support/solaris/wcsnrtombs.inc
     support/solaris/xlocale.cpp
     )
 elseif(ZOS)
   list(APPEND LIBCXX_SOURCES
+    include/ceeedb.h
     support/ibm/mbsnrtowcs.cpp
     support/ibm/wcsnrtombs.cpp
     support/ibm/xlocale_zos.cpp
     )
 endif()
 
 if (LIBCXX_ENABLE_FILESYSTEM)
   list(APPEND LIBCXX_SOURCES

libcxx/src/include/ceeedb.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_IBM_CEEEDB_H
+#define _LIBCPP_SUPPORT_IBM_CEEEDB_H
+
+#ifndef __MVS__
+#  error This header should only be included on z/OS
+#endif
+
+#include <__config>
+#include <__gfunc.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+static inline unsigned char __libcpp_ceeedb_flags() {
+  // Offsets can be found in the z/OS Language Environment Vendor Interfaces book
+  // https://www-01.ibm.com/servers/resourcelink/svc00100.nsf/pages/zOSV2R4sa380688?OpenDocument
+#ifndef __64BIT__
+  enum { OFFSET_CEECAAEDB = 0x2f0 };
+  enum { OFFSET_CEEEDBFLAG1 = 0x08 };
+#else
+  enum { OFFSET_CEECAAEDB = 0x388 };
+  enum { OFFSET_CEEEDBFLAG1 = 0x100 };
+#endif
+
+  // See the zOS Language Environment Vendor Interfaces book for a description
+  // of the Common Anchor Area (CEECAA), the Enclave Data Block (CEECAAEDB),
+  // and the EDB flags (CEEEDBFLAG1).
+  const unsigned char* CEECAA = static_cast<const unsigned char*>(__gtca());
+  const unsigned char* CEECAAEDB =
+      *static_cast<const unsigned char**>(const_cast<void*>(static_cast<const void*>(CEECAA + OFFSET_CEECAAEDB)));
+  const unsigned char* CEEEDBFLAG1 = (CEECAAEDB + OFFSET_CEEEDBFLAG1);
+  return *CEEEDBFLAG1;
+}
+
+static inline bool __libcpp_ceeedb_multithread() {
+  const unsigned char CEEEDBMULTITHREAD = 0x02;
+  return __libcpp_ceeedb_flags() & CEEEDBMULTITHREAD;
+}
+
+static inline bool __libcpp_ceeedb_posix() {
+  const unsigned char CEEEDB_POSIX = 0x04;
+  return __libcpp_ceeedb_flags() & CEEEDB_POSIX;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SUPPORT_IBM_CEEEDB_H

libcxx/src/include/internal_threading_support.h

+//===----------------------------------------------------------------------===////
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===////
+
+#ifndef _LIBCPP_INTERNAL_THREADING_SUPPORT_H
+#define _LIBCPP_INTERNAL_THREADING_SUPPORT_H
+
+/** internal_threading_support.h - Equivalent to __threading_support, but for internal uses that are
+ * not related to the C++11 Threading Library. These should all be within code that is compiled into
+ * the libcxx library rather than potentially #included by user code.
+ *
+ * See libcxx/docs/DesignDocs/InternalThreadSynchronization.rst for details.
+ *
+ * Any platforms which cannot determine during compilation of libc++ the availability of a thread
+ * library such as pthreads should use wrappers definitions provided here and define 
+ * `__libcpp_is_threading_api_enabled()` and `__libcpp_might_have_multiple_threads()`
+ * following implementation on z/OS.
+ */
+
+#include <__threading_support>
+#include <cassert>
+
+#if defined(__MVS__)
+_LIBCPP_THREAD_ABI_VISIBILITY
+bool __libcpp_is_threading_api_enabled();
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+bool __libcpp_might_have_multiple_threads();
+
+#else
+_LIBCPP_THREAD_ABI_VISIBILITY
+_LIBCPP_CONSTEXPR bool __libcpp_is_threading_api_enabled();
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+_LIBCPP_CONSTEXPR bool __libcpp_might_have_multiple_threads();
+#endif // __MVS__
+
+#if defined(__MVS__)
+#  include "ceeedb.h"
+/// On z/OS some posix functions can be enabled/disabled at runtime.
+/// However, the enabled/disabled status should not change over the life of the process.
+bool __libcpp_is_threading_api_enabled() {
+  static bool __posix_on = std::__libcpp_ceeedb_posix();
+  return __posix_on;
+}
+bool __libcpp_might_have_multiple_threads() { return std::__libcpp_ceeedb_multithread(); }
+#else
+_LIBCPP_THREAD_ABI_VISIBILITY
+_LIBCPP_CONSTEXPR bool __libcpp_is_threading_api_enabled() { return true; }
+
+// Without any way of checking, we are forced to assume other threads have been spawned.
+_LIBCPP_THREAD_ABI_VISIBILITY
+_LIBCPP_CONSTEXPR bool __libcpp_might_have_multiple_threads() { return __libcpp_is_threading_api_enabled(); }
+#endif // __MVS__
+
+//===----------------------------------------------------------------------===//
+//    Definitions which would normally be provided by <__threading_support>
+//    are defined here as wrappers to enable POSIX(OFF) on z/OS.
+//===----------------------------------------------------------------------===//
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace internal_thread {
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t* __m) {
+  if (!__libcpp_is_threading_api_enabled())
+    return 0;
+  return _VSTD::__libcpp_recursive_mutex_init(__m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t* __m) {
+  // See __libcpp_mutex_lock for an explaination of why this is safe
+  if (!__libcpp_might_have_multiple_threads())
+    return 0;
+  return _VSTD::__libcpp_recursive_mutex_lock(__m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t* __m) {
+  // See __libcpp_mutex_lock for an explaination of why this is safe
+  if (!__libcpp_might_have_multiple_threads())
+    return true;
+  return _VSTD::__libcpp_recursive_mutex_trylock(__m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t* __m) {
+  // See __libcpp_mutex_lock for an explaination of why this is safe
+  if (!__libcpp_might_have_multiple_threads())
+    return 0;
+  return _VSTD::__libcpp_recursive_mutex_unlock(__m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t* __m) {
+  if (!__libcpp_is_threading_api_enabled())
+    return 0;
+  return _VSTD::__libcpp_recursive_mutex_destroy(__m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_mutex_lock(__libcpp_mutex_t* __m) {
+  // All libcxx-internal locks are released before we run any code which could
+  // spawn a thread, so we can safely skip mutex acquisition when there's only
+  // one thread (even if the threading API is enabled).
+  if (!__libcpp_might_have_multiple_threads())
+    return 0;
+  return _VSTD::__libcpp_mutex_lock(__m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+bool __libcpp_mutex_trylock(__libcpp_mutex_t* __m) {
+  // See __libcpp_mutex_lock for an explaination of why this is safe
+  if (!__libcpp_might_have_multiple_threads())
+    return true;
+  return _VSTD::__libcpp_mutex_trylock(__m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_mutex_unlock(__libcpp_mutex_t* __m) {
+  // See __libcpp_mutex_lock for an explaination of why this is safe
+  if (!__libcpp_might_have_multiple_threads())
+    return 0;
+  return _VSTD::__libcpp_mutex_unlock(__m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_mutex_destroy(__libcpp_mutex_t* __m) {
+  if (!__libcpp_is_threading_api_enabled())
+    return 0;
+  return _VSTD::__libcpp_mutex_destroy(__m);
+}
+
+// Condition Variable
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_signal(__libcpp_condvar_t* __cv) {
+  // If we're the only thread, there's no one to signal to, skip it
+  if (!__libcpp_might_have_multiple_threads())
+    return 0;
+  return _VSTD::__libcpp_condvar_signal(__cv);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv) {
+  // If we're the only thread, there's no one to broadcast to, skip it
+  if (!__libcpp_might_have_multiple_threads())
+    return 0;
+  return _VSTD::__libcpp_condvar_broadcast(__cv);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m) {
+  // If we're the only thread, there's no one to wake us up, so this is a deadlock
+  assert(__libcpp_might_have_multiple_threads());
+  return _VSTD::__libcpp_condvar_wait(__cv, __m);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m,
+                                                                    __libcpp_timespec_t* __ts) {
+  if (!__libcpp_is_threading_api_enabled()) {
+    // With nobody to wake us up, this is equivalent to a sleep
+    // TODO: actually wait until __ts, and replace this with
+    // `if(!__libcpp_might_have_multiple_threads())`
+    return ETIMEDOUT;
+  }
+  return _VSTD::__libcpp_condvar_timedwait(__cv, __m, __ts);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv) {
+  if (!__libcpp_is_threading_api_enabled())
+    return 0;
+  return _VSTD::__libcpp_condvar_destroy(__cv);
+}
+
+// Execute once
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_execute_once(__libcpp_exec_once_flag* flag, void (*init_routine)()) {
+  if (!__libcpp_is_threading_api_enabled()) {
+    if (*flag == _LIBCPP_EXEC_ONCE_INITIALIZER) {
+      init_routine();
+      // TODO: In order for this to work when __libcpp_is_threading_api_enabled() can change during
+      // program execution, we have to write the same value pthread_once would.
+      // For glibc this seems to be 2, but it could vary.
+      *flag = 2;
+    }
+    return 0;
+  }
+
+  return _VSTD::__libcpp_execute_once(flag, init_routine);
+}
+
+// Thread id
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_thread_create(__libcpp_thread_t* __t, void* (*__func)(void*),
+                                                                void* __arg) {
+  assert(__libcpp_is_threading_api_enabled());
+  return _VSTD::__libcpp_thread_create(__t, __func, __arg);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+__libcpp_thread_id __libcpp_thread_get_current_id() {
+  assert(__libcpp_is_threading_api_enabled());
+  return _VSTD::__libcpp_thread_get_current_id();
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_thread_join(__libcpp_thread_t* __t) {
+  assert(__libcpp_is_threading_api_enabled());
+  return _VSTD::__libcpp_thread_join(__t);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_thread_detach(__libcpp_thread_t* __t) {
+  assert(__libcpp_is_threading_api_enabled());
+  return _VSTD::__libcpp_thread_detach(__t);
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+void __libcpp_thread_yield() {
+  if (!__libcpp_might_have_multiple_threads())
+    return;
+  _VSTD::__libcpp_thread_yield();
+}
+
+_LIBCPP_THREAD_ABI_VISIBILITY
+void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns) {
+  assert(__libcpp_is_threading_api_enabled());
+  _VSTD::__libcpp_thread_sleep_for(__ns);
+}
+
+} // end namespace internal_thread
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_INTERNAL_THREADING_SUPPORT_H

libcxx/src/locale.cpp

 #include <cstdlib>
 #include <cstring>
 #include <locale>
 #include <string>
 #include <type_traits>
 #include <typeinfo>
 #include <vector>
 
+#include "include/internal_threading_support.h"
+
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #   include <cwctype>
 #endif
 
 #if defined(_AIX)
 #   include <sys/localedef.h> // for __lc_ctype_ptr
 #endif
 
public:
     }
 };
 
 }
 
 long
 locale::id::__get()
 {
+    if (!__libcpp_is_threading_api_enabled()) {
+        __id_ = ++__next_id;
+        return __id_-1;
+    }
     call_once(__flag_, __fake_bind(&locale::id::__init, this));
     return __id_ - 1;
 }
 
 void
 locale::id::__init()
 {
     __id_ = __libcpp_atomic_add(&__next_id, 1);

libcxxabi/src/cxa_exception_storage.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //
 //  This file implements the storage for the "Caught Exception Stack"
 //  https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html#cxx-exc-stack
 //
 //===----------------------------------------------------------------------===//
 
 #include "cxa_exception.h"
 
-#include <__threading_support>
+#include "include/internal_threading_support.h" // from libc++
 
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
 
 namespace __cxxabiv1 {
 extern "C" {
     static __cxa_eh_globals eh_globals;
     __cxa_eh_globals *__cxa_get_globals() { return &eh_globals; }
     __cxa_eh_globals *__cxa_get_globals_fast() { return &eh_globals; }
__cxa_eh_globals *__cxa_get_globals() {
         return retVal;
     }
 
     // Note that this implementation will reliably return NULL if not
     // preceded by a call to __cxa_get_globals().  This is an extension
     // to the Itanium ABI and is taken advantage of in several places in
     // libc++abi.
     __cxa_eh_globals *__cxa_get_globals_fast() {
+        // If threads are disabled at runtime, revert to single-threaded implementation.
+        if (!__libcpp_is_threading_api_enabled()) {
+            static __cxa_eh_globals eh_globals;
+            return &eh_globals;
+        }
         // First time through, create the key.
         if (0 != std::__libcpp_execute_once(&flag_, construct_))
             abort_message("execute once failure in __cxa_get_globals_fast()");
         return static_cast<__cxa_eh_globals*>(std::__libcpp_tls_get(key_));
     }
 } // extern "C"
 } // namespace __cxxabiv1
 
 #endif

libcxxabi/src/cxa_guard_impl.h

 #  endif
 #  if __has_include(<unistd.h>)
 #    include <unistd.h>
 #  endif
 #endif
 
 #include <limits.h>
 #include <stdlib.h>
-#include <__threading_support>
+#include "include/internal_threading_support.h" // from libc++
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 #  if defined(__ELF__) && defined(_LIBCXXABI_LINK_PTHREAD_LIB)
 #    pragma comment(lib, "pthread")
 #  endif
 #endif
 
 #if defined(__clang__)
 #  pragma clang diagnostic push

 
 //===----------------------------------------------------------------------===//
 //                       PlatformGetThreadID
 //===----------------------------------------------------------------------===//
 
 #if defined(__APPLE__) && defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 uint32_t PlatformThreadID() {
   static_assert(sizeof(mach_port_t) == sizeof(uint32_t), "");
-  return static_cast<uint32_t>(pthread_mach_thread_np(std::__libcpp_thread_get_current_id()));
+  return static_cast<uint32_t>(pthread_mach_thread_np(_VSTD::internal_thread::__libcpp_thread_get_current_id()));
 }
 #elif defined(SYS_gettid) && defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 uint32_t PlatformThreadID() {
   static_assert(sizeof(pid_t) == sizeof(uint32_t), "");
   return static_cast<uint32_t>(syscall(SYS_gettid));
 }
 #else
 constexpr uint32_t (*PlatformThreadID)() = nullptr;

 struct LibcppCondVar;
 
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 struct LibcppMutex {
   LibcppMutex() = default;
   LibcppMutex(LibcppMutex const&) = delete;
   LibcppMutex& operator=(LibcppMutex const&) = delete;
 
-  bool lock() { return std::__libcpp_mutex_lock(&mutex); }
-  bool unlock() { return std::__libcpp_mutex_unlock(&mutex); }
+  bool lock() { return _VSTD::internal_thread::__libcpp_mutex_lock(&mutex); }
+  bool unlock() { return _VSTD::internal_thread::__libcpp_mutex_unlock(&mutex); }
 
 private:
   friend struct LibcppCondVar;
   std::__libcpp_mutex_t mutex = _LIBCPP_MUTEX_INITIALIZER;
 };
 
 struct LibcppCondVar {
   LibcppCondVar() = default;
   LibcppCondVar(LibcppCondVar const&) = delete;
   LibcppCondVar& operator=(LibcppCondVar const&) = delete;
 
-  bool wait(LibcppMutex& mut) { return std::__libcpp_condvar_wait(&cond, &mut.mutex); }
-  bool broadcast() { return std::__libcpp_condvar_broadcast(&cond); }
+  bool wait(LibcppMutex& mut) { return _VSTD::internal_thread::__libcpp_condvar_wait(&cond, &mut.mutex); }
+  bool broadcast() { return _VSTD::internal_thread::__libcpp_condvar_broadcast(&cond); }
 
 private:
   std::__libcpp_condvar_t cond = _LIBCPP_CONDVAR_INITIALIZER;
 };
 #else
 struct LibcppMutex {};
 struct LibcppCondVar {};
 #endif // !defined(_LIBCXXABI_HAS_NO_THREADS)

libcxxabi/test/test_exception_storage.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <cstdio>
 #include <cstdlib>
-#include <__threading_support>
+#include "include/internal_threading_support.h" // from libc++
 #include <unistd.h>
 
 #include "../src/cxa_exception.h"
 
 typedef __cxxabiv1::__cxa_eh_globals globals_t ;
 
 void *thread_code (void *parm) {
     size_t *result = (size_t *) parm;
     globals_t *glob1, *glob2;
 
     glob1 = __cxxabiv1::__cxa_get_globals ();
     if ( NULL == glob1 )
         std::printf("Got null result from __cxa_get_globals\n");
 
     glob2 = __cxxabiv1::__cxa_get_globals_fast ();
     if ( glob1 != glob2 )
         std::printf("Got different globals!\n");
 
     *result = (size_t) glob1;
 #ifndef _LIBCXXABI_HAS_NO_THREADS
     sleep ( 1 );
 #endif
     return parm;
 }
 
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 #define NUMTHREADS  10
 size_t                 thread_globals [ NUMTHREADS ] = { 0 };
 std::__libcpp_thread_t   threads        [ NUMTHREADS ];
 #endif
 
 int main() {
-#ifndef _LIBCXXABI_HAS_NO_THREADS
+#ifdef _LIBCXXABI_HAS_NO_THREADS
+    size_t thread_globals;
+    thread_code(&thread_globals);
+    // Check that __cxa_get_globals() is not NULL.
+    return (thread_globals == 0) ? 1 : 0;
+#else  // !_LIBCXXABI_HAS_NO_THREADS
+    // If threads are disabled at runtime, revert to single-threaded test.
+    if (!__libcpp_is_threading_api_enabled()) {
+        thread_code((void*)thread_globals);
+        // Check that __cxa_get_globals() is not NULL.
+        return (thread_globals[0] == 0) ? 1 : 0;
+    }
+
 //  Make the threads, let them run, and wait for them to finish
     for ( int i = 0; i < NUMTHREADS; ++i )
         std::__libcpp_thread_create ( threads + i, thread_code, (void *) (thread_globals + i));
     for ( int i = 0; i < NUMTHREADS; ++i )
         std::__libcpp_thread_join ( &threads [ i ] );
 
     int retVal = 0;
     for ( int i = 0; i < NUMTHREADS; ++i ) {
         if ( 0 == thread_globals [ i ] ) {
             std::printf("Thread #%d had a zero global\n", i);
             retVal = 1;
         }
     }
 
     std::sort ( thread_globals, thread_globals + NUMTHREADS );
     for ( int i = 1; i < NUMTHREADS; ++i ) {
         if ( thread_globals [ i - 1 ] == thread_globals [ i ] ) {
             std::printf("Duplicate thread globals (%d and %d)\n", i-1, i);
             retVal = 2;
         }
     }
     return retVal;
-#else // _LIBCXXABI_HAS_NO_THREADS
-    size_t thread_globals;
-    thread_code(&thread_globals);
-    // Check that __cxa_get_globals() is not NULL.
-    return (thread_globals == 0) ? 1 : 0;
 #endif // !_LIBCXXABI_HAS_NO_THREADS
 }