[libcxxabi] Introduce an externally threaded libc++abi variant

[rmaprath]

Summary

This is more-or-less a mirror image of D21968, repeated for libcxxabi.

I will soon upload a dependent patch for libcxx which makes it possible to run the libcxx test suite with the externally-threaded libcxxabi variant.

[EricWF]

My main issue with this patch (and D27206) is that there are now two different CMake options for building two different external threading libraries. I would much prefer having libc++abi use libc++'s __threading_support header and cxx_external_threads library.

CMakeLists.txt

124

It's weird that libc++abi needs to define a libc++ option? Can you elaborate on the need for this?

src/CMakeLists.txt

132

Do you really need to glob a single file?

test/CMakeLists.txt

41

Target names shouldn't be in quotes.

45

For the in-tree libc++/libc++abi builds libc++abi gets configured before libc++, so I don't think libc++ target names are visible in this context.
Are you sure this works?

test/libcxxabi/test/config.py

43

libcxxabi_shared should default to True like it does within the libc++ config.

test/lit.cfg

21

I'm not sure I understand the reason for this change.

[rmaprath]

In D27204#613122, @EricWF wrote:

My main issue with this patch (and D27206) is that there are now two different CMake options for building two different external threading libraries. I would much prefer having libc++abi use libc++'s __threading_support header and cxx_external_threads library.

I would like to do that too!

But I always viewed libcxx and libcxxabi as two independent libraries that should be usable on their own. In this case, binding libcxxabi to __threading_support from libcxx sounded wrong, because __threading_support is something internal to libcxx (e.g. all the functions there are prefixed with __libcpp_ - there may be other libcpp-isms arising from __config in there too).

Is that not a concern? I could give it a shot and try to merge the two APIs into one if not.

[EricWF]

In D27204#613172, @rmaprath wrote:

In D27204#613122, @EricWF wrote:

My main issue with this patch (and D27206) is that there are now two different CMake options for building two different external threading libraries. I would much prefer having libc++abi use libc++'s __threading_support header and cxx_external_threads library.

I would like to do that too!

But I always viewed libcxx and libcxxabi as two independent libraries that should be usable on their own. In this case, binding libcxxabi to __threading_support from libcxx sounded wrong, because __threading_support is something internal to libcxx (e.g. all the functions there are prefixed with __libcpp_ - there may be other libcpp-isms arising from __config in there too).

Ironically I've always viewed libcxxabi as fully dependent on libcxx (and personally I would like to see the repos merged; Although using libc++ w/o libc++abi would still be supported).

Is that not a concern? I could give it a shot and try to merge the two APIs into one if not.

It's not a concern. Libc++abi already depends on libc++ internals to build (See the #include "__refstring" in stdlib_stdexcept.cpp`).

[rmaprath]

In D27204#613177, @EricWF wrote:

In D27204#613172, @rmaprath wrote:

In D27204#613122, @EricWF wrote:

My main issue with this patch (and D27206) is that there are now two different CMake options for building two different external threading libraries. I would much prefer having libc++abi use libc++'s __threading_support header and cxx_external_threads library.

I would like to do that too!

But I always viewed libcxx and libcxxabi as two independent libraries that should be usable on their own. In this case, binding libcxxabi to __threading_support from libcxx sounded wrong, because __threading_support is something internal to libcxx (e.g. all the functions there are prefixed with __libcpp_ - there may be other libcpp-isms arising from __config in there too).

Ironically I've always viewed libcxxabi as fully dependent on libcxx (and personally I would like to see the repos merged; Although using libc++ w/o libc++abi would still be supported).

Is that not a concern? I could give it a shot and try to merge the two APIs into one if not.

It's not a concern. Libc++abi already depends on libc++ internals to build (See the #include "__refstring" in stdlib_stdexcept.cpp`).

Thanks for the clarification. I'll re-spin the patch.

Responses to inline comments follow, but some of those would go away with the re-spin I imagine.

CMakeLists.txt

124

The libcxxabi test suite builds libcxx as part of running the test suite, I thought a separate option would be appropriate here to allow users to select which configuration they want to build libcxx for those tests.

Given the new knowledge I have, I think the right thing to do here is configure libcxx to also use external threads when libcxxabi is configured to use external threads, rather than providing a separate option here. Will fix.

src/CMakeLists.txt

132

Copy-paste, will fix.

test/CMakeLists.txt

41

Will fix.

45

This worked fine for me. All my builds are in-tree as well.

I also checked if the order in which tests are run (whether libcxx runs before libcxxabi and vice-versa) makes no difference.

I will double check still.

test/libcxxabi/test/config.py

43

Not sure if I follow, I'm trying to detect this particular combination of configs so that I can xfail a particular test.

test/lit.cfg

21

I should've put a comment. The test suite keeps trying to run test/support/external_threading.cpp as a test case without this. Perhaps there is a better way to handle that situation?

[rmaprath]

Abandoning as this has been replaced with D27575.

CMakeLists.txt

 option(LIBCXXABI_ENABLE_EXCEPTIONS "Use exceptions." ON)
 option(LIBCXXABI_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)
 option(LIBCXXABI_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LIBCXXABI_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 option(LIBCXXABI_USE_LLVM_UNWINDER "Build and use the LLVM unwinder." OFF)
 option(LIBCXXABI_USE_COMPILER_RT "Use compiler-rt instead of libgcc" OFF)
 option(LIBCXXABI_ENABLE_THREADS "Build with threads enabled" ON)
 option(LIBCXXABI_HAS_PTHREAD_API "Ignore auto-detection and force use of pthread API" OFF)
+option(LIBCXXABI_HAS_EXTERNAL_THREAD_API
+  "Build libc++abi with an externalized threading API.
+  This option may only be set to ON when LIBCXXABI_ENABLE_THREADS=ON." OFF)
+option(LIBCXX_HAS_EXTERNAL_THREAD_API
+  "Build libc++ with an externalized threading API.
+  This option may only be set to ON when LIBCXX_ENABLE_THREADS=ON." OFF)
 option(LIBCXXABI_BUILD_32_BITS "Build 32 bit libc++abi." ${LLVM_BUILD_32_BITS})
 set(LIBCXXABI_TARGET_TRIPLE "" CACHE STRING "Target triple for cross compiling.")
 set(LIBCXXABI_GCC_TOOLCHAIN "" CACHE PATH "GCC toolchain for cross compiling.")
 set(LIBCXXABI_SYSROOT "" CACHE PATH "Sysroot for cross compiling.")
 set(LIBCXXABI_LIBCXX_LIBRARY_PATH "" CACHE PATH "The path to libc++ library.")
 
 # Default to building a shared library so that the default options still test
 # the libc++abi that is being built. There are two problems with testing a

     list(APPEND LIBCXXABI_COMPILE_FLAGS -DNDEBUG)
   endif()
 endif()
 # Static library
 if (NOT LIBCXXABI_ENABLE_SHARED)
   list(APPEND LIBCXXABI_COMPILE_FLAGS -D_LIBCPP_BUILD_STATIC)
 endif()
 
+# Threading
 if (NOT LIBCXXABI_ENABLE_THREADS)
   if (LIBCXXABI_HAS_PTHREAD_API)
     message(FATAL_ERROR "LIBCXXABI_HAS_PTHREAD_API can only"
                         " be set to ON when LIBCXXABI_ENABLE_THREADS"
                         " is also set to ON.")
   endif()
+  if (LIBCXXABI_HAS_EXTERNAL_THREAD_API)
+    message(FATAL_ERROR "LIBCXXABI_HAS_EXTERNAL_THREAD_API can only"
+                        " be set to ON when LIBCXXABI_ENABLE_THREADS"
+                        " is also set to ON.")
+  endif()
   add_definitions(-D_LIBCXXABI_HAS_NO_THREADS)
 endif()
 
+if (LIBCXXABI_HAS_PTHREAD_API AND LIBCXXABI_HAS_EXTERNAL_THREAD_API)
+  message(FATAL_ERROR "The options LIBCXXABI_HAS_EXTERNAL_THREAD_API"
+                      "and LIBCXXABI_HAS_PTHREAD_API cannot be both"
+                      "set to ON at the same time.")
+endif()
+
+if (LIBCXXABI_HAS_EXTERNAL_THREAD_API AND LIBCXXABI_ENABLE_SHARED)
+  # Need to allow unresolved symbols if this is to work with shared library builds
+  if (APPLE)
+    add_link_flags("-undefined dynamic_lookup")
+  else()
+    # Relax this restriction from HandleLLVMOptions
+    string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
+  endif()
+endif()
+
 if (LIBCXXABI_HAS_PTHREAD_API)
   add_definitions(-D_LIBCPP_HAS_THREAD_API_PTHREAD)
   add_definitions(-D_LIBCXXABI_USE_THREAD_API_PTHREAD)
 endif()
 
+if (LIBCXXABI_HAS_EXTERNAL_THREAD_API)
+  add_definitions(-D_LIBCXXABI_HAS_THREAD_API_EXTERNAL)
+endif()
+
 if (MSVC)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 # Define LIBCXXABI_USE_LLVM_UNWINDER for conditional compilation.
 if (LIBCXXABI_USE_LLVM_UNWINDER)
   add_definitions(-DLIBCXXABI_USE_LLVM_UNWINDER=1)
 endif()

src/CMakeLists.txt

       LINK_FLAGS    "${LIBCXXABI_LINK_FLAGS} ${LIBCXXABI_SHARED_LINK_FLAGS}"
       OUTPUT_NAME   "c++abi"
       VERSION       "1.0"
       SOVERSION     "1"
     )
   list(APPEND LIBCXXABI_TARGETS "cxxabi_shared")
 endif()
 
+if (LIBCXXABI_HAS_EXTERNAL_THREAD_API)
+  file(GLOB LIBCXXABI_EXTERNAL_THREADING_SUPPORT_SOURCES ../test/support/external_threads.cpp)
+
+  if (LIBCXXABI_ENABLE_SHARED)
+    add_library(cxxabi_external_threads SHARED ${LIBCXXABI_EXTERNAL_THREADING_SUPPORT_SOURCES})
+  else()
+    add_library(cxxabi_external_threads STATIC ${LIBCXXABI_EXTERNAL_THREADING_SUPPORT_SOURCES})
+  endif()
+
+  set_target_properties(cxxabi_external_threads
+    PROPERTIES
+      LINK_FLAGS    "${LIBCXXABI_LINK_FLAGS}"
+      COMPILE_FLAGS "${LIBCXXABI_COMPILE_FLAGS}"
+      OUTPUT_NAME   "cxxabi_external_threads"
+  )
+endif()
+
 # Build the static library.
 if (LIBCXXABI_ENABLE_STATIC)
   add_library(cxxabi_static STATIC $<TARGET_OBJECTS:cxxabi_objects>)
   target_link_libraries(cxxabi_static ${libraries})
   set_target_properties(cxxabi_static
     PROPERTIES
       LINK_FLAGS    "${LIBCXXABI_LINK_FLAGS}"
       OUTPUT_NAME   "c++abi"

src/config.h

#if __has_attribute(__internal_linkage__)
   #define _LIBCXXABI_INLINE_VISIBILITY __attribute__ ((__internal_linkage__, __always_inline__))
  #else
   #define _LIBCXXABI_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
  #endif
 #endif
 
 // Try and deduce a threading api if one has not been explicitly set.
 #if !defined(_LIBCXXABI_HAS_NO_THREADS) && \
+    !defined(_LIBCXXABI_HAS_THREAD_API_EXTERNAL) && \
     !defined(_LIBCXXABI_USE_THREAD_API_PTHREAD)
   #if defined(_POSIX_THREADS) && _POSIX_THREADS >= 0
     #define _LIBCXXABI_USE_THREAD_API_PTHREAD
   #else
     #error "No thread API"
   #endif
 #endif
 
 // Set this in the CXXFLAGS when you need it, because otherwise we'd have to
 // #if !defined(__linux__) && !defined(__APPLE__) && ...
 // and so-on for *every* platform.
 #ifndef LIBCXXABI_BAREMETAL
 #  define LIBCXXABI_BAREMETAL 0
 #endif
 
 #endif // LIBCXXABI_CONFIG_H

src/threading_support.h

 #ifndef _LIBCXXABI_THREADING_SUPPORT_H
 #define _LIBCXXABI_THREADING_SUPPORT_H
 
 #include "__cxxabi_config.h"
 #include "config.h"
 
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 
-#if defined(_LIBCXXABI_USE_THREAD_API_PTHREAD)
+#ifndef __libcxxabi_has_include
+  #ifndef __has_include
+    #define __libcxxabi_has_include(x) 0
+  #else
+    #define __libcxxabi_has_include(x) __has_include(x)
+  #endif
+#endif
+
+#if defined(_LIBCXXABI_HAS_THREAD_API_EXTERNAL) && \
+    __libcxxabi_has_include(<external_threading.h>)
+#include <external_threading.h>
+#else
 #include <pthread.h>
 
+#if defined(_LIBCXXABI_HAS_THREAD_API_EXTERNAL)
+#define _LIBCXXABI_THREAD_ABI_VISIBILITY _LIBCXXABI_FUNC_VIS
+#else
 #define _LIBCXXABI_THREAD_ABI_VISIBILITY inline _LIBCXXABI_INLINE_VISIBILITY
+#endif
 
 // Mutex
 typedef pthread_mutex_t __libcxxabi_mutex_t;
 #define _LIBCXXABI_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
 
 _LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_mutex_lock(__libcxxabi_mutex_t *mutex);
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_mutex_unlock(__libcxxabi_mutex_t *mutex);
+
+// Condition variable
+typedef pthread_cond_t __libcxxabi_condvar_t;
+#define _LIBCXXABI_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_condvar_wait(__libcxxabi_condvar_t *cv,
+                             __libcxxabi_mutex_t *mutex);
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_condvar_broadcast(__libcxxabi_condvar_t *cv);
+
+// Execute once
+typedef pthread_once_t __libcxxabi_exec_once_flag;
+#define _LIBCXXABI_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_execute_once(__libcxxabi_exec_once_flag *flag,
+                             void (*init_routine)(void));
+
+// Thread id
+#if defined(__APPLE__) && !defined(__arm__)
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+mach_port_t __libcxxabi_thread_get_port();
+#endif
+
+// Thread
+typedef pthread_t __libcxxabi_thread_t;
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_thread_create(__libcxxabi_thread_t* __t,
+                           void* (*__func)(void*), void* __arg);
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_thread_join(__libcxxabi_thread_t* __t);
+
+// TLS
+typedef pthread_key_t __libcxxabi_tls_key;
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_tls_create(__libcxxabi_tls_key *key,
+                           void (*destructor)(void *));
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+void *__libcxxabi_tls_get(__libcxxabi_tls_key key);
+
+_LIBCXXABI_THREAD_ABI_VISIBILITY
+int __libcxxabi_tls_set(__libcxxabi_tls_key key, void *value);
+
+// Implementation of the above thread API. Used both by the pthread based
+// libc++abi build and the proof-of-concept externally threaded (i.e. no
+// external_threading.h header) libc++abi build (below implementation built
+// into a separate library for linking against the test suite).
+#if defined(_LIBCXXABI_USE_THREAD_API_PTHREAD) || \
+    defined(_LIBCXXABI_BUILDING_EXTERNAL_THREADS)
+// Mutex
 int __libcxxabi_mutex_lock(__libcxxabi_mutex_t *mutex) {
   return pthread_mutex_lock(mutex);
 }
 
-_LIBCXXABI_THREAD_ABI_VISIBILITY
 int __libcxxabi_mutex_unlock(__libcxxabi_mutex_t *mutex) {
   return pthread_mutex_unlock(mutex);
 }
 
 // Condition variable
-typedef pthread_cond_t __libcxxabi_condvar_t;
-#define _LIBCXXABI_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
-
-_LIBCXXABI_THREAD_ABI_VISIBILITY
 int __libcxxabi_condvar_wait(__libcxxabi_condvar_t *cv,
                              __libcxxabi_mutex_t *mutex) {
   return pthread_cond_wait(cv, mutex);
 }
 
-_LIBCXXABI_THREAD_ABI_VISIBILITY
 int __libcxxabi_condvar_broadcast(__libcxxabi_condvar_t *cv) {
   return pthread_cond_broadcast(cv);
 }
 
 // Execute once
-typedef pthread_once_t __libcxxabi_exec_once_flag;
-#define _LIBCXXABI_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT
-
-_LIBCXXABI_THREAD_ABI_VISIBILITY
 int __libcxxabi_execute_once(__libcxxabi_exec_once_flag *flag,
                              void (*init_routine)(void)) {
   return pthread_once(flag, init_routine);
 }
 
 // Thread id
 #if defined(__APPLE__) && !defined(__arm__)
-_LIBCXXABI_THREAD_ABI_VISIBILITY
-mach_port_t __libcxxabi_thread_get_port()
-{
+mach_port_t __libcxxabi_thread_get_port() {
     return pthread_mach_thread_np(pthread_self());
 }
 #endif
 
 // Thread
-typedef pthread_t __libcxxabi_thread_t;
-
-_LIBCXXABI_THREAD_ABI_VISIBILITY
 int __libcxxabi_thread_create(__libcxxabi_thread_t* __t,
-                           void* (*__func)(void*), void* __arg)
-{
+                           void* (*__func)(void*), void* __arg) {
     return pthread_create(__t, 0, __func, __arg);
 }
 
-_LIBCXXABI_THREAD_ABI_VISIBILITY
-int __libcxxabi_thread_join(__libcxxabi_thread_t* __t)
-{
+int __libcxxabi_thread_join(__libcxxabi_thread_t* __t) {
     return pthread_join(*__t, 0);
 }
 
 // TLS
-typedef pthread_key_t __libcxxabi_tls_key;
-
-_LIBCXXABI_THREAD_ABI_VISIBILITY
 int __libcxxabi_tls_create(__libcxxabi_tls_key *key,
                            void (*destructor)(void *)) {
   return pthread_key_create(key, destructor);
 }
 
-_LIBCXXABI_THREAD_ABI_VISIBILITY
 void *__libcxxabi_tls_get(__libcxxabi_tls_key key) {
   return pthread_getspecific(key);
 }
 
-_LIBCXXABI_THREAD_ABI_VISIBILITY
 int __libcxxabi_tls_set(__libcxxabi_tls_key key, void *value) {
   return pthread_setspecific(key, value);
 }
 #endif // _LIBCXXABI_USE_THREAD_API_PTHREAD
+
+#endif // !_LIBCXXABI_HAS_THREAD_API_EXTERNAL || !__libcxxabi_has_include(<external_threading.h>)
+
 #endif // !_LIBCXXABI_HAS_NO_THREADS
+
 #endif // _LIBCXXABI_THREADING_SUPPORT_H

test/CMakeLists.txt

 endif()
 
 pythonize_bool(LIBCXXABI_BUILD_32_BITS)
 pythonize_bool(LIBCXX_ENABLE_SHARED)
 pythonize_bool(LIBCXXABI_ENABLE_SHARED)
 pythonize_bool(LIBCXXABI_ENABLE_THREADS)
 pythonize_bool(LIBCXXABI_ENABLE_EXCEPTIONS)
 pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER)
+pythonize_bool(LIBCXXABI_HAS_CXA_THREAD_ATEXIT_IMPL)
+pythonize_bool(LIBCXX_HAS_EXTERNAL_THREAD_API)
+pythonize_bool(LIBCXXABI_HAS_EXTERNAL_THREAD_API)
 set(LIBCXXABI_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
     "TargetInfo to use when setting up test environment.")
 set(LIBCXXABI_EXECUTOR "None" CACHE STRING
     "Executor to use when running tests.")
 
 set(AUTO_GEN_COMMENT "## Autogenerated by libcxxabi configuration.\n# Do not edit!")
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
   @ONLY)
 
 if (LIBCXXABI_ENABLE_SHARED)
   set(LIBCXXABI_TEST_DEPS cxxabi_shared)
 else()
   set(LIBCXXABI_TEST_DEPS cxxabi_static)
 endif()
 
+if (LIBCXXABI_HAS_EXTERNAL_THREAD_API)
+  list(APPEND LIBCXXABI_TEST_DEPS "cxxabi_external_threads")
+endif()
+
+if (LIBCXX_HAS_EXTERNAL_THREAD_API)
+  list(APPEND LIBCXXABI_TEST_DEPS "cxx_external_threads")
+endif()
+
 if (NOT LIBCXXABI_STANDALONE_BUILD)
   list(APPEND LIBCXXABI_TEST_DEPS cxx)
   if (LIBCXXABI_USE_LLVM_UNWINDER)
     list(APPEND LIBCXXABI_TEST_DEPS unwind)
   endif()
 endif()
 
 add_lit_testsuite(check-cxxabi "Running libcxxabi tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   DEPENDS ${LIBCXXABI_TEST_DEPS}
   )
 
 # TODO: This is a legacy target name and should be removed at some point.
 add_custom_target(check-libcxxabi DEPENDS check-cxxabi)

test/libcxxabi/test/config.py

def configure_obj_root(self):
         super(Configuration, self).configure_obj_root()
 
     def configure_features(self):
         super(Configuration, self).configure_features()
         if not self.get_lit_bool('enable_exceptions', True):
             self.config.available_features.add('libcxxabi-no-exceptions')
         if not self.cxx.addCompileFlagIfSupported(['-Xclang', '-mqualified-function-type-info']):
             self.config.available_features.add("libcxxabi-no-qualified-function-types")
+        # test_exception_storage_nodynmem.pass.cpp fails under this specific configuration
+        if self.get_lit_bool('cxxabi_ext_threads', False) and self.get_lit_bool('libcxxabi_shared', False):
+            self.config.available_features.add('libcxxabi-shared-externally-threaded')
 
     def configure_compile_flags(self):
         self.cxx.compile_flags += ['-DLIBCXXABI_NO_TIMER']
         if self.get_lit_bool('enable_exceptions', True):
             self.cxx.compile_flags += ['-funwind-tables']
         else:
             self.cxx.compile_flags += ['-fno-exceptions', '-DLIBCXXABI_HAS_NO_EXCEPTIONS']
         if not self.get_lit_bool('enable_threads', True):

test/lit.cfg

 if 'PYLINT_IMPORT' in os.environ:
     config = object()
     lit_config = object()
 
 # name: The name of this test suite.
 config.name = 'libc++abi'
 
 # suffixes: A list of file extensions to treat as test files.
-config.suffixes = ['.cpp', '.s']
+config.suffixes = ['.pass.cpp', '.sh.s', '.sh.cpp']
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)
 
 # Infer the libcxx_test_source_root for configuration import.
 # If libcxx_source_root isn't specified in the config, assume that the libcxx
 # and libcxxabi source directories are sibling directories.
 libcxx_src_root = getattr(config, 'libcxx_src_root', None)

test/lit.site.cfg.in

 config.target_info              = "@LIBCXXABI_TARGET_INFO@"
 config.executor                 = "@LIBCXXABI_EXECUTOR@"
 config.libcxxabi_shared         = "@LIBCXXABI_ENABLE_SHARED@"
 config.enable_shared            = "@LIBCXX_ENABLE_SHARED@"
 config.enable_exceptions        = "@LIBCXXABI_ENABLE_EXCEPTIONS@"
 config.host_triple              = "@LLVM_HOST_TRIPLE@"
 config.target_triple            = "@TARGET_TRIPLE@"
 config.use_target               = len("@LIBCXXABI_TARGET_TRIPLE@") > 0
+config.cxx_ext_threads          = "@LIBCXX_HAS_EXTERNAL_THREAD_API@"
+config.cxxabi_ext_threads       = "@LIBCXXABI_HAS_EXTERNAL_THREAD_API@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBCXXABI_SOURCE_DIR@/test/lit.cfg")

test/support/external_threads.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 _LIBCXXABI_BUILDING_EXTERNAL_THREADS
+#include <threading_support.h>