[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

18–20

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

15

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

16

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

[danalbert]

src/cxa_thread_atexit.cpp

18–20

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

15

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

16

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

18–20

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

16

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

16

sounds good.

[jroelofs]

LGTM

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

 # Get sources
 set(LIBCXXABI_SOURCES
   abort_message.cpp
   cxa_aux_runtime.cpp
   cxa_default_handlers.cpp
   cxa_demangle.cpp
   cxa_exception.cpp
   cxa_exception_storage.cpp
   cxa_guard.cpp
   cxa_handlers.cpp
   cxa_new_delete.cpp
+  cxa_thread_atexit.cpp
   cxa_personality.cpp
   cxa_unexpected.cpp
   cxa_vector.cpp
   cxa_virtual.cpp
   exception.cpp
   private_typeinfo.cpp
   stdexcept.cpp
   typeinfo.cpp

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" {
+
+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);
+}
+
+} // 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.
+//
+//===----------------------------------------------------------------------===//
+
+#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;
+}