[libcxxabi] Add __cxa_thread_atexit for TLS support on Linux.

[danalbert]

Summary

Fixes PR21738.

The implementation for this is handled by __cxa_thread_atexit_impl,
which is supplied by libc.

More information:
https://sourceware.org/glibc/wiki/Destructor%20support%20for%20thread_local%20variables

[majnemer]

src/cxa_thread_atexit.cpp

19–21

The only libc which provides __cxa_thread_atexit_impl is glibc. Other libc implementations on linux do not and it doesn't seem available on the BSDs.

I think it makes sense to forward to __cxa_thread_atexit_impl if the symbol exists, otherwise we need to have a definition of __cxa_thread_atexit which can do the real heavy lifting.

[jroelofs]

test/cxa_thread_atexit_test.cpp

16

What about when the libc provides this symbol? Is it normally weak?

17

to have the same signature, this needs throw().

[danalbert]

src/cxa_thread_atexit.cpp

19–21

Oops. I added a guard to the header to make sure this was only there on Linux but forgot to do the same here and in the test.

BTW, glibc is the only one that supports it for now, but we're working on adding it to Bionic.

As for non-glibc libc implementations for non-Android Linux, are you thinking about newlib/musl? Those implementations would just need to add support for this if they want this kind of TLS; I don't think we need to add it here.

test/cxa_thread_atexit_test.cpp

16

The dynamic linker satisfies the symbol from the main executable first, even if there is a strong symbol in another shared object.

17

This is the _impl function, which doesn't have the throw() specifier (since it's C code). I suppose the throw() on the non-impl version of this is actually unnecessary since it's in extern "C". I had just match the Apple functions above my decl in cxxabi.h.

[danalbert]

Make the implementation only build on Linux, and make the test require linux.

[majnemer]

src/cxa_thread_atexit.cpp

19–21

musl does not which makes me feel like we shouldn't unconditionally try to provide it.

I think it would make more sense to make it conditional on _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL. Bionic can create its own way to signal that it has the function.

[danalbert]

Only build the implementation for cxa_thread_atexit if libc has
cxa_thread_atexit_impl.

test/cxa_thread_atexit_test.cpp

17

jroelofs: Hm. What about with statically linked libc?

I was under the impression that static linking on Linux wasn't really a thing any more: http://stackoverflow.com/questions/3430400/linux-static-linking-is-dead

At any rate, our tests will not build statically on Linux, so it's a non-issue. It's probably broken, but if we ever get to a state where we care about building this test statically, I'll fix it up then.

[jroelofs]

test/cxa_thread_atexit_test.cpp

17

sounds good.

[jroelofs]

LGTM

cmake/config-ix.cmake

 check_cxx_compiler_flag(/EHa-                 LIBCXXABI_HAS_NO_EHA_FLAG)
 check_cxx_compiler_flag(/GR-                  LIBCXXABI_HAS_NO_GR_FLAG)
 
 # Check libraries
 check_library_exists(c printf "" LIBCXXABI_HAS_C_LIB)
 check_library_exists(dl dladdr "" LIBCXXABI_HAS_DL_LIB)
 check_library_exists(pthread pthread_once "" LIBCXXABI_HAS_PTHREAD_LIB)
 check_library_exists(gcc_eh _Unwind_GetRegionStart "" LIBCXXABI_HAS_GCC_EH_LIB)
+check_library_exists(c __cxa_thread_atexit_impl ""
+  LIBCXXABI_HAS_CXA_THREAD_ATEXIT_IMPL)

include/cxxabi.h

 extern void * __cxa_current_primary_exception() throw();
 extern void __cxa_rethrow_primary_exception(void* primary_exception);
 extern void __cxa_increment_exception_refcount(void* primary_exception) throw();
 extern void __cxa_decrement_exception_refcount(void* primary_exception) throw();
 
 // Apple addition to support std::uncaught_exception()
 extern bool __cxa_uncaught_exception() throw();
 
+#ifdef __linux__
+// Linux TLS support. Not yet an official part of the Itanium ABI.
+// https://sourceware.org/glibc/wiki/Destructor%20support%20for%20thread_local%20variables
+extern int __cxa_thread_atexit(void (*)(void *), void *, void *) throw();
+#endif
+
   } // extern "C"
 } // namespace __cxxabiv1
 
 namespace abi = __cxxabiv1;
 
 #endif // __cplusplus
 
 #endif // __CXXABI_H 

src/CMakeLists.txt

set(LIBCXXABI_SOURCES
   cxa_vector.cpp
   cxa_virtual.cpp
   exception.cpp
   private_typeinfo.cpp
   stdexcept.cpp
   typeinfo.cpp
 )
 
+if (UNIX AND NOT (APPLE OR CYGWIN))
+  list(APPEND LIBCXXABI_SOURCES cxa_thread_atexit.cpp)
+endif()
+
 set(LIBCXXABI_HEADERS ../include/cxxabi.h)
 
 # Add all the headers to the project for IDEs.
 if (MSVC_IDE OR XCODE)
   # Force them all into the headers dir on MSVC, otherwise they end up at
   # project scope because they don't have extensions.
   if (MSVC_IDE)
     source_group("Header Files" FILES ${LIBCXXABI_HEADERS})
else()
   add_library(cxxabi STATIC
     ${LIBCXXABI_SOURCES}
     ${LIBCXXABI_HEADERS}
     )
 endif()
 
 include_directories("${LIBCXXABI_LIBCXX_INCLUDES}")
 
+if (LIBCXXABI_HAS_CXA_THREAD_ATEXIT_IMPL)
+  add_definitions(-DHAVE___CXA_THREAD_ATEXIT_IMPL)
+endif()
+
 # Generate library list.
 set(libraries ${LIBCXXABI_CXX_ABI_LIBRARIES})
 append_if(libraries LIBCXXABI_HAS_C_LIB c)
 if (LIBCXXABI_ENABLE_THREADS)
   append_if(libraries LIBCXXABI_HAS_PTHREAD_LIB pthread)
 endif()
 
 if (LIBCXXABI_USE_LLVM_UNWINDER)

src/cxa_thread_atexit.cpp

+//===----------------------- cxa_thread_atexit.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 "cxxabi.h"
+
+namespace __cxxabiv1 {
+
+extern "C" {
+
+#ifdef HAVE___CXA_THREAD_ATEXIT_IMPL
+
+int __cxa_thread_atexit(void (*dtor)(void *), void *obj,
+                        void *dso_symbol) throw() {
+  extern int __cxa_thread_atexit_impl(void (*)(void *), void *, void *);
+  return __cxa_thread_atexit_impl(dtor, obj, dso_symbol);
+}
+
+#endif // HAVE__CXA_THREAD_ATEXIT_IMPL
+
+} // extern "C"
+
+} // namespace __cxxabiv1

test/cxa_thread_atexit_test.cpp

+//===--------------------- cxa_thread_atexit_test.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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: linux2
+
+#include <assert.h>
+#include <cxxabi.h>
+
+static bool AtexitImplCalled = false;
+
+extern "C" int __cxa_thread_atexit_impl(void (*dtor)(void *), void *obj,
+                                        void *dso_symbol) {
+  assert(dtor == reinterpret_cast<void (*)(void *)>(1));
+  assert(obj == reinterpret_cast<void *>(2));
+  assert(dso_symbol == reinterpret_cast<void *>(3));
+  AtexitImplCalled = true;
+  return 4;
+}
+
+int main() {
+  int RV = __cxxabiv1::__cxa_thread_atexit(
+      reinterpret_cast<void (*)(void *)>(1), reinterpret_cast<void *>(2),
+      reinterpret_cast<void *>(3));
+  assert(RV = 4);
+  assert(AtexitImplCalled);
+  return 0;
+}

test/lit.cfg

 
 if sys.platform == 'darwin':
     exec_env['DYLD_LIBRARY_PATH'] = os.path.join(libcxxabi_obj_root, 'lib')
 elif sys.platform.startswith('linux'):
     link_flags += ['-Wl,-R', libcxxabi_obj_root + '/lib']
 else:
     lit_config.fatal("unrecognized system")
 
+config.available_features.add(sys.platform)
+
 config.test_format = LibcxxabiTestFormat(
     cxx_under_test,
     cpp_flags = ['-nostdinc++'] + compile_flags + include_paths,
     ld_flags = ['-nodefaultlibs'] + library_paths + ['-lc++'] + link_flags,
     exec_env = exec_env)
 
 # Get or infer the target triple.
 config.target_triple = lit_config.params.get('target_triple', None)
 # If no target triple was given, try to infer it from the compiler under test.
 if config.target_triple is None:
     config.target_triple = lit.util.capture(
         [cxx_under_test, '-dumpmachine']).strip()
     lit_config.note("inferred target_triple as: %r" % (config.target_triple,))