[libc] Add implementation of pthread_exit and thrd_exit.

[sivachandra]

Rebase

[michaelrj]

LGTM

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.pthread.pthread_attr_setdetachstate
     libc.src.pthread.pthread_attr_setguardsize
     libc.src.pthread.pthread_attr_setstack
     libc.src.pthread.pthread_attr_setstacksize
     libc.src.pthread.pthread_attr_init
     libc.src.pthread.pthread_create
     libc.src.pthread.pthread_detach
     libc.src.pthread.pthread_equal
+    libc.src.pthread.pthread_exit
     libc.src.pthread.pthread_getname_np
     libc.src.pthread.pthread_join
     libc.src.pthread.pthread_self
     libc.src.pthread.pthread_setname_np
     libc.src.pthread.pthread_mutex_destroy
     libc.src.pthread.pthread_mutex_init
     libc.src.pthread.pthread_mutex_lock
     libc.src.pthread.pthread_mutex_unlock
list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.threads.mtx_destroy
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_current
     libc.src.threads.thrd_detach
     libc.src.threads.thrd_equal
+    libc.src.threads.thrd_exit
     libc.src.threads.thrd_join
 
     # time.h entrypoints
     libc.src.time.asctime
     libc.src.time.asctime_r
     libc.src.time.gmtime
     libc.src.time.gmtime_r
     libc.src.time.mktime
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/loader/linux/x86_64/start.cpp

extern "C" void _start() {
   }
 
   __llvm_libc::TLSDescriptor tls;
   __llvm_libc::init_tls(tls);
   if (tls.size != 0 && !__llvm_libc::set_thread_ptr(tls.tp))
     __llvm_libc::syscall(SYS_exit, 1);
 
   __llvm_libc::self.attrib = &__llvm_libc::main_thread_attrib;
+  __llvm_libc::main_thread_attrib.atexit_callback_mgr =
+      __llvm_libc::internal::get_thread_atexit_callback_mgr();
 
   // We want the fini array callbacks to be run after other atexit
   // callbacks are run. So, we register them before running the init
   // array callbacks as they can potentially register their own atexit
   // callbacks.
   __llvm_libc::atexit(&__llvm_libc::call_fini_array_callbacks);
 
   __llvm_libc::call_init_array_callbacks(

libc/spec/posix.td

[
           [ArgSpec<PThreadTType>, ArgSpec<VoidPtrPtr>]
       >,
       FunctionSpec<
           "pthread_detach",
           RetValSpec<IntType>,
           [ArgSpec<PThreadTType>]
       >,
       FunctionSpec<
+          "pthread_exit",
+          RetValSpec<VoidType>,
+          [ArgSpec<VoidPtr>]
+      >,
+      FunctionSpec<
           "pthread_self",
           RetValSpec<PThreadTType>,
           [ArgSpec<VoidType>]
       >,
       FunctionSpec<
           "pthread_equal",
           RetValSpec<IntType>,
           [ArgSpec<PThreadTType>, ArgSpec<PThreadTType>]

libc/spec/stdc.td

HeaderSpec Threads = HeaderSpec<
               "thrd_current",
               RetValSpec<ThrdTType>,
               [ArgSpec<VoidType>]
           >,
           FunctionSpec<
               "thrd_equal",
               RetValSpec<IntType>,
               [ArgSpec<ThrdTType>, ArgSpec<ThrdTType>]
-          >
+          >,
+          FunctionSpec<
+              "thrd_exit",
+              RetValSpec<VoidType>,
+              [ArgSpec<IntType>]
+          >,
       ]
   >;
 
   HeaderSpec Time = HeaderSpec<
       "time.h",
       [], // Macros
       [ // Types
        StructTmType,

libc/src/__support/threads/CMakeLists.txt

 )
 
 if(TARGET libc.src.__support.threads.${LIBC_TARGET_OS}.thread)
   add_object_library(
     thread
     SRCS
       thread.cpp
     DEPENDS
+      .mutex
       .${LIBC_TARGET_OS}.thread
+      libc.src.__support.fixedvector
   )
 endif()

libc/src/__support/threads/linux/thread.cpp

 #endif
 }
 
 __attribute__((noinline))
 static void start_thread() {
   auto *start_args = reinterpret_cast<StartArgs *>(get_start_args_addr());
   auto *attrib = start_args->thread_attrib;
   self.attrib = attrib;
+  self.attrib->atexit_callback_mgr = internal::get_thread_atexit_callback_mgr();
 
-  long retval;
   if (attrib->style == ThreadStyle::POSIX) {
     attrib->retval.posix_retval =
         start_args->runner.posix_runner(start_args->arg);
-    retval = long(attrib->retval.posix_retval);
+    thread_exit(ThreadReturnValue(attrib->retval.posix_retval),
+                ThreadStyle::POSIX);
   } else {
     attrib->retval.stdc_retval =
         start_args->runner.stdc_runner(start_args->arg);
-    retval = long(attrib->retval.stdc_retval);
+    thread_exit(ThreadReturnValue(attrib->retval.stdc_retval),
+                ThreadStyle::STDC);
   }
-
-  uint32_t joinable_state = uint32_t(DetachState::JOINABLE);
-  if (!attrib->detach_state.compare_exchange_strong(
-          joinable_state, uint32_t(DetachState::EXITING))) {
-    // Thread is detached so cleanup the resources.
-    cleanup_thread_resources(attrib);
-
-    // Set the CLEAR_TID address to nullptr to prevent the kernel
-    // from signalling at a non-existent futex location.
-    __llvm_libc::syscall(SYS_set_tid_address, 0);
-  }
-
-  __llvm_libc::syscall(SYS_exit, retval);
 }
 
 int Thread::run(ThreadStyle style, ThreadRunner runner, void *arg, void *stack,
                 size_t size, bool detached) {
   bool owned_stack = false;
   if (stack == nullptr) {
     if (size == 0)
       size = DEFAULT_STACK_SIZE;
#endif
   if (name_buffer[retval - 1] == '\n')
     name_buffer[retval - 1] = '\0';
   else
     name_buffer[retval] = '\0';
   name << name_buffer;
   return 0;
 }
 
+void thread_exit(ThreadReturnValue retval, ThreadStyle style) {
+  auto attrib = self.attrib;
+
+  // The very first thing we do is to call the thread's atexit callbacks.
+  // These callbacks could be the ones registered by the language runtimes,
+  // for example, the destructors of thread local objects. They can also
+  // be destructors of the TSS objects set using API like pthread_setspecific.
+  // NOTE: We cannot call the atexit callbacks as part of the 
+  // cleanup_thread_resources function as that function can be called from a
+  // different thread. The destructors of thread local and TSS objects should
+  // be called by the thread which owns them.
+  internal::call_atexit_callbacks(attrib);
+
+  uint32_t joinable_state = uint32_t(DetachState::JOINABLE);
+  if (!attrib->detach_state.compare_exchange_strong(
+          joinable_state, uint32_t(DetachState::EXITING))) {
+    // Thread is detached so cleanup the resources.
+    cleanup_thread_resources(attrib);
+
+    // Set the CLEAR_TID address to nullptr to prevent the kernel
+    // from signalling at a non-existent futex location.
+    __llvm_libc::syscall(SYS_set_tid_address, 0);
+  }
+
+  if (style == ThreadStyle::POSIX)
+    __llvm_libc::syscall(SYS_exit, retval.posix_retval);
+  else
+    __llvm_libc::syscall(SYS_exit, retval.stdc_retval);
+}
+
 } // namespace __llvm_libc

libc/src/__support/threads/thread.h

union ThreadRunner {
   ThreadRunnerPosix *posix_runner;
   ThreadRunnerStdc *stdc_runner;
 };
 
 union ThreadReturnValue {
   void *posix_retval;
   int stdc_retval;
   constexpr ThreadReturnValue() : posix_retval(nullptr) {}
+  constexpr ThreadReturnValue(int r) : stdc_retval(r) {}
+  constexpr ThreadReturnValue(void *r) : posix_retval(r) {}
 };
 
 #if (defined(LLVM_LIBC_ARCH_AARCH64) || defined(LLVM_LIBC_ARCH_X86_64))
 constexpr unsigned int STACK_ALIGNMENT = 16;
 #endif
 // TODO: Provide stack alignment requirements for other architectures.
 
 enum class DetachState : uint32_t {
enum class DetachType : int {
   // Indicates that the detach operation just set the detach state to DETACHED
   // and returned.
   SIMPLE = 1,
 
   // Indicates that the detach operation performed thread cleanup.
   CLEANUP = 2
 };
 
+class ThreadAtExitCallbackMgr;
+
 // A data type to hold common thread attributes which have to be stored as
 // thread state. Note that this is different from public attribute types like
 // pthread_attr_t which might contain information which need not be saved as
 // part of a thread's state. For example, the stack guard size.
 //
 // Thread attributes are typically stored on the stack. So, we align as required
 // for the target architecture.
 struct alignas(STACK_ALIGNMENT) ThreadAttributes {
struct alignas(STACK_ALIGNMENT) ThreadAttributes {
   void *stack;                   // Pointer to the thread stack
   unsigned long long stack_size; // Size of the stack
   uintptr_t tls;                 // Address to the thread TLS memory
   uintptr_t tls_size;            // The size of area pointed to by |tls|.
   unsigned char owned_stack; // Indicates if the thread owns this stack memory
   int tid;
   ThreadStyle style;
   ThreadReturnValue retval;
+  ThreadAtExitCallbackMgr *atexit_callback_mgr;
   void *platform_data;
 
   constexpr ThreadAttributes()
       : detach_state(uint32_t(DetachState::DETACHED)), stack(nullptr),
         stack_size(0), tls(0), tls_size(0), owned_stack(false), tid(-1),
-        style(ThreadStyle::POSIX), retval(), platform_data(nullptr) {}
+        style(ThreadStyle::POSIX), retval(), atexit_callback_mgr(nullptr),
+        platform_data(nullptr) {}
 };
 
 struct Thread {
   ThreadAttributes *attrib;
 
   constexpr Thread() : attrib(nullptr) {}
   constexpr Thread(ThreadAttributes *attr) : attrib(attr) {}
 
struct Thread {
   int set_name(const cpp::StringView &name);
 
   // Return the name of the thread in |name|. Return the error number of error.
   int get_name(cpp::StringStream &name) const;
 };
 
 extern thread_local Thread self;
 
+// Platforms should implement this function.
+void thread_exit(ThreadReturnValue retval, ThreadStyle style);
+
+namespace internal {
+// Internal namespace containing utilities which are to be used by platform
+// implementations of threads.
+
+// Return the current thread's atexit callback manager. After thread startup
+// but before running the thread function, platform implementations should
+// set the "atexit_callback_mgr" field of the thread's attributes to the value
+// returned by this function.
+ThreadAtExitCallbackMgr *get_thread_atexit_callback_mgr();
+
+// Call the currently registered thread specific atexit callbacks. Useful for
+// implementing the thread_exit function.
+void call_atexit_callbacks(ThreadAttributes *attrib);
+
+} // namespace internal
+
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_THREADS_THREAD_H

libc/src/__support/threads/thread.cpp

 //===--- Definitions of common thread items ---------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "thread.h"
+#include "mutex.h"
+
+#include "src/__support/fixedvector.h"
 
 namespace __llvm_libc {
 
 thread_local Thread self;
 
+namespace {
+
+using AtExitCallback = void(void *);
+
+struct AtExitUnit {
+  AtExitCallback *callback = nullptr;
+  void *obj = nullptr;
+  constexpr AtExitUnit() = default;
+  constexpr AtExitUnit(AtExitCallback *cb, void *o) : callback(cb), obj(o) {}
+};
+
+} // anonymous namespace
+
+class ThreadAtExitCallbackMgr {
+  Mutex mtx;
+  // TODO: Use a BlockStore when compiled for production.
+  FixedVector<AtExitUnit, 1024> callback_list;
+
+public:
+  constexpr ThreadAtExitCallbackMgr() : mtx(false, false, false) {}
+
+  int add_callback(AtExitCallback *callback, void *obj) {
+    MutexLock lock(&mtx);
+    return callback_list.push_back({callback, obj});
+  }
+
+  void call() {
+    mtx.lock();
+    while (!callback_list.empty()) {
+      auto atexit_unit = callback_list.back();
+      callback_list.pop_back();
+      mtx.unlock();
+      atexit_unit.callback(atexit_unit.obj);
+      mtx.lock();
+    }
+  }
+};
+
+static thread_local ThreadAtExitCallbackMgr atexit_callback_mgr;
+
+// The function __cxa_thread_atexit is provided by C++ runtimes like libcxxabi.
+// It is used by thread local object runtime to register destructor calls. To
+// actually register destructor call with the threading library, it calls
+// __cxa_thread_atexit_impl, which is to be provided by the threading library.
+// The semantics are very similar to the __cxa_atexit function except for the
+// fact that the registered callback is thread specific.
+extern "C" int __cxa_thread_atexit_impl(AtExitCallback *callback, void *obj,
+                                        void *) {
+  return atexit_callback_mgr.add_callback(callback, obj);
+}
+
+namespace internal {
+
+ThreadAtExitCallbackMgr *get_thread_atexit_callback_mgr() {
+  return &atexit_callback_mgr;
+}
+
+void call_atexit_callbacks(ThreadAttributes *attrib) {
+  attrib->atexit_callback_mgr->call();
+}
+
+} // namespace internal
+
 } // namespace __llvm_libc

libc/src/pthread/CMakeLists.txt

add_entrypoint_object(
   HDRS
     pthread_equal.h
   DEPENDS
     libc.include.pthread
     libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(
+  pthread_exit
+  SRCS
+    pthread_exit.cpp
+  HDRS
+    pthread_exit.h
+  DEPENDS
+    libc.include.threads
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
   pthread_self
   SRCS
     pthread_self.cpp
   HDRS
     pthread_self.h
   DEPENDS
     libc.include.pthread
     libc.src.__support.threads.thread

libc/src/pthread/pthread_exit.h

-//===--- Definitions of common thread items ---------------------*- C++ -*-===//
+//===-- Implementation header for pthread_exit function ---------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "thread.h"
+#ifndef LLVM_LIBC_SRC_THREADS_PTHREAD_EXIT_H
+#define LLVM_LIBC_SRC_THREADS_PTHREAD_EXIT_H
+
+#include <pthread.h>
 
 namespace __llvm_libc {
 
-thread_local Thread self;
+void pthread_exit(void *retval);
 
 } // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_PTHREAD_EXIT_H

libc/src/pthread/pthread_exit.cpp

+//===-- Implementation of the pthread_exit function -----------------------===//
+//
+// 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 "pthread_exit.h"
+
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <pthread.h> // For pthread_* type definitions.
+
+namespace __llvm_libc {
+
+static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
+              "Mismatch between pthread_t and internal Thread.");
+
+LLVM_LIBC_FUNCTION(void, pthread_exit, (void *retval)) {
+  thread_exit(ThreadReturnValue(retval), ThreadStyle::POSIX);
+}
+
+} // namespace __llvm_libc

libc/src/threads/CMakeLists.txt

add_entrypoint_object(
   HDRS
     thrd_equal.h
   DEPENDS
     libc.include.threads
     libc.src.__support.threads.thread
 )
 
 add_entrypoint_object(
+  thrd_exit
+  SRCS
+    thrd_exit.cpp
+  HDRS
+    thrd_exit.h
+  DEPENDS
+    libc.include.threads
+    libc.src.__support.threads.thread
+)
+
+add_entrypoint_object(
   mtx_init
   SRCS
     mtx_init.cpp
   HDRS
     mtx_init.h
   DEPENDS
     libc.include.threads
     libc.src.__support.threads.mutex

libc/src/threads/thrd_exit.h

-//===--- Definitions of common thread items ---------------------*- C++ -*-===//
+//===-- Implementation header for thrd_exit function ------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "thread.h"
+#ifndef LLVM_LIBC_SRC_THREADS_THRD_EXIT_H
+#define LLVM_LIBC_SRC_THREADS_THRD_EXIT_H
+
+#include "include/threads.h"
 
 namespace __llvm_libc {
 
-thread_local Thread self;
+void thrd_exit(int retval);
 
 } // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_THREADS_THRD_EXIT_H

libc/src/threads/thrd_exit.cpp

+//===-- Linux implementation of the thrd_exit function --------------------===//
+//
+// 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 "src/threads/thrd_exit.h"
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h"
+
+#include <threads.h> // For thrd_* type definitions.
+
+namespace __llvm_libc {
+
+static_assert(sizeof(thrd_t) == sizeof(__llvm_libc::Thread),
+              "Mismatch between thrd_t and internal Thread.");
+
+LLVM_LIBC_FUNCTION(void, thrd_exit, (int retval)) {
+  thread_exit(ThreadReturnValue(retval), ThreadStyle::STDC);
+}
+
+} // namespace __llvm_libc

libc/test/integration/src/pthread/CMakeLists.txt

DEPENDS
     libc.src.pthread.pthread_join
     libc.src.pthread.pthread_mutex_destroy
     libc.src.pthread.pthread_mutex_init
     libc.src.pthread.pthread_mutex_lock
     libc.src.pthread.pthread_mutex_unlock
     libc.src.pthread.pthread_self
     libc.src.pthread.pthread_setname_np
 )
+
+add_integration_test(
+  pthread_exit_test
+  SUITE
+    libc-pthread-integration-tests
+  SRCS
+    pthread_exit_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.include.pthread
+    libc.src.pthread.pthread_create
+    libc.src.pthread.pthread_exit
+    libc.src.pthread.pthread_join
+)

libc/test/integration/src/pthread/pthread_exit_test.cpp

+//===-- Tests for pthread_exit --------------------------------------------===//
+//
+// 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 "src/pthread/pthread_create.h"
+#include "src/pthread/pthread_exit.h"
+#include "src/pthread/pthread_join.h"
+#include "utils/IntegrationTest/test.h"
+
+#include <pthread.h>
+
+bool dtor_called = false;
+
+class A {
+  int val;
+
+public:
+  A(int i) { val = i; }
+
+  void set(int i) { val = i; }
+
+  ~A() {
+    val = 0;
+    dtor_called = true;
+  }
+};
+
+thread_local A thread_local_a(123);
+
+void *func(void *) {
+  // Touch the thread local variable so that it gets initialized and a callback
+  // for its destructor gets registered with __cxa_thread_atexit.
+  thread_local_a.set(321);
+  __llvm_libc::pthread_exit(nullptr);
+  return nullptr;
+}
+
+TEST_MAIN() {
+  pthread_t th;
+  void *retval;
+
+  ASSERT_EQ(__llvm_libc::pthread_create(&th, nullptr, func, nullptr), 0);
+  ASSERT_EQ(__llvm_libc::pthread_join(th, &retval), 0);
+
+  ASSERT_TRUE(dtor_called);
+  __llvm_libc::pthread_exit(nullptr);
+  return 0;
+}
+
+extern "C" {
+
+using Destructor = void(void *);
+
+int __cxa_thread_atexit_impl(Destructor *, void *, void *);
+
+// We do not link integration tests to C++ runtime pieces like the libcxxabi.
+// So, we provide our own simple __cxa_thread_atexit implementation.
+int __cxa_thread_atexit(Destructor *dtor, void *obj, void *) {
+  return __cxa_thread_atexit_impl(dtor, obj, nullptr);
+}
+}

libc/test/integration/src/threads/CMakeLists.txt

add_integration_test(
   DEPENDS
     libc.include.threads
     libc.src.errno.errno
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
 )
 
 add_integration_test(
+  thrd_exit_test
+  SUITE
+    libc-threads-integration-tests
+  SRCS
+    thrd_exit_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.include.threads
+    libc.src.threads.thrd_create
+    libc.src.threads.thrd_exit
+    libc.src.threads.thrd_join
+)
+
+add_integration_test(
   call_once_test
   SUITE
     libc-threads-integration-tests
   SRCS
     call_once_test.cpp
   LOADER
     libc.loader.linux.crt1
   DEPENDS

libc/test/integration/src/threads/thrd_exit_test.cpp

+//===-- Tests for thrd_exit -----------------------------------------------===//
+//
+// 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 "src/threads/thrd_create.h"
+#include "src/threads/thrd_exit.h"
+#include "src/threads/thrd_join.h"
+#include "utils/IntegrationTest/test.h"
+
+#include <threads.h>
+
+bool dtor_called = false;
+
+class A {
+  int val;
+
+public:
+  A(int i) { val = i; }
+
+  void set(int i) { val = i; }
+
+  ~A() {
+    val = 0;
+    dtor_called = true;
+  }
+};
+
+thread_local A thread_local_a(123);
+
+int func(void *) {
+  thread_local_a.set(321);
+  __llvm_libc::thrd_exit(0);
+  return 0;
+}
+
+TEST_MAIN() {
+  thrd_t th;
+  int retval;
+
+  ASSERT_EQ(__llvm_libc::thrd_create(&th, func, nullptr), thrd_success);
+  ASSERT_EQ(__llvm_libc::thrd_join(&th, &retval), thrd_success);
+
+  ASSERT_TRUE(dtor_called);
+  __llvm_libc::thrd_exit(0);
+  return 0;
+}
+
+extern "C" {
+
+using Destructor = void(void *);
+
+int __cxa_thread_atexit_impl(Destructor *, void *, void *);
+
+// We do not link integration tests to C++ runtime pieces like the libcxxabi.
+// So, we provide our own simple __cxa_thread_atexit implementation.
+int __cxa_thread_atexit(Destructor *dtor, void *obj, void *) {
+  return __cxa_thread_atexit_impl(dtor, obj, nullptr);
+}
+}