[libc] Add __cxa_atexit support to the atexit function.

[sivachandra]

I have incorporated some of the testing ideas suggested by @abrachet in https://reviews.llvm.org/D130966.

[sivachandra]

Rebase after splitting out ArrayStore in to a separate patch.

[sivachandra]

Depends on https://reviews.llvm.org/D131377.

[abrachet]

libc/loader/linux/x86_64/start.cpp

120–121

I think this was sent out for review before the D131133, so just a reminder to change the aarch64 code to behave this way too

libc/src/stdlib/atexit.cpp

80

Might be worth adding a TODO here that eventually this will need to address the dso_handle argument.

libc/test/integration/loader/linux/init_fini_array_test.cpp

26

We can remove this TODO now

[sivachandra]

Address comments.

[sivachandra]

Remove a TODO which is not relevant anymore.

[sivachandra]

Rebase

libc/cmake/modules/LLVMLibCTestRules.cmake

function(add_integration_test test_name)
   if(NOT INTEGRATION_TEST_SRCS)
     message(FATAL_ERROR "The SRCS list for add_integration_test is missing.")
   endif()
 
   get_fq_target_name(${test_name}.libc fq_libc_target_name)
 
   get_fq_deps_list(fq_deps_list ${INTEGRATION_TEST_DEPENDS})
   # All integration tests setup TLS area and the main thread's self object.
-  # So, we need to link in the threads implementation.
-  list(APPEND fq_deps_list libc.src.__support.threads.thread)
+  # So, we need to link in the threads implementation. Likewise, the startup
+  # code also has to run init_array callbacks which potentially register
+  # their own atexit callbacks. So, link in exit and atexit also with all
+  # integration tests.
+  list(
+      APPEND fq_deps_list
+      libc.src.__support.threads.thread
+      libc.src.stdlib.atexit
+      libc.src.stdlib.exit)
   list(REMOVE_DUPLICATES fq_deps_list)
   # TODO: Instead of gathering internal object files from entrypoints,
   # collect the object files with public names of entrypoints.
   get_object_files_for_test(
       link_object_files skipped_entrypoints_list ${fq_deps_list})
   if(skipped_entrypoints_list)
     message(STATUS "Skipping ${fq_target_name} as it has skipped deps.")
     return()

libc/loader/linux/x86_64/CMakeLists.txt

 add_loader_object(
   crt1
   SRC
     start.cpp
   DEPENDS
     libc.config.linux.app_h
     libc.include.sys_mman
     libc.include.sys_syscall
     libc.src.__support.threads.thread
     libc.src.__support.OSUtil.osutil
+    libc.src.stdlib.exit
+    libc.src.stdlib.atexit
     libc.src.string.memory_utils.memcpy_implementation
   COMPILE_OPTIONS
     -fno-omit-frame-pointer
     -ffreestanding # To avoid compiler warnings about calling the main function.
     -fno-builtin
 )

libc/loader/linux/x86_64/start.cpp

 //===-- Implementation of crt for x86_64 ----------------------------------===//
 //
 // 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 "config/linux/app.h"
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/threads/thread.h"
+#include "src/stdlib/atexit.h"
+#include "src/stdlib/exit.h"
 #include "src/string/memory_utils/memcpy_implementations.h"
 
 #include <asm/prctl.h>
 #include <linux/auxvec.h>
 #include <linux/elf.h>
 #include <stdint.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
for (size_t i = 0; i < preinit_array_size; ++i)
     reinterpret_cast<InitCallback *>(__preinit_array_start[i])(argc, argv, env);
   size_t init_array_size = __init_array_end - __init_array_start;
   for (size_t i = 0; i < init_array_size; ++i)
     reinterpret_cast<InitCallback *>(__init_array_start[i])(argc, argv, env);
 }
 
 static void call_fini_array_callbacks() {
   size_t fini_array_size = __fini_array_end - __fini_array_start;
-  for (size_t i = 0; i < fini_array_size; ++i)
-    reinterpret_cast<FiniCallback *>(__fini_array_start[i])();
+  for (size_t i = fini_array_size; i > 0; --i)
+    reinterpret_cast<FiniCallback *>(__fini_array_start[i - 1])();
 }
 
 } // namespace __llvm_libc
 
 using __llvm_libc::app;
 
 // TODO: Would be nice to use the aux entry structure from elf.h when available.
 struct AuxEntry {
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;
 
+  // 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(
       app.args->argc, reinterpret_cast<char **>(app.args->argv),
       reinterpret_cast<char **>(env_ptr));
 
   int retval = main(app.args->argc, reinterpret_cast<char **>(app.args->argv),
                     reinterpret_cast<char **>(env_ptr));
 
-  __llvm_libc::call_fini_array_callbacks();
-
+  // TODO: TLS cleanup should be done after all other atexit callbacks
+  // are run. So, register a cleanup callback for it with atexit before
+  // everything else.
   __llvm_libc::cleanup_tls(tls.addr, tls.size);
-  __llvm_libc::syscall(SYS_exit, retval);
+  __llvm_libc::exit(retval);
 }

libc/src/__support/CMakeLists.txt

 )
 
 add_header_library(
   arg_list
   HDRS
     arg_list.h
 )
 
+add_header_library(
+  arraystore
+  HDRS
+    arraystore.h
+  DEPENDS
+    libc.src.__support.CPP.array
+)
+
 add_subdirectory(FPUtil)
 add_subdirectory(OSUtil)
 
 # Thread support is used by other "File". So, we add the "threads"
 # before "File".
 add_subdirectory(threads)
 
 add_subdirectory(File)

libc/src/__support/arraystore.h

+//===-- A data structure for a fixed size data store ------------*- 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 "src/__support/CPP/array.h"
+
+namespace __llvm_libc {
+
+// A fixed size data store backed by an underlying cpp::array data structure. It
+// supports vector like API but is not resizable like a vector.
+template <typename T, size_t SIZE> class ArrayStore {
+  cpp::array<T, SIZE> store;
+  size_t item_count = 0;
+
+public:
+  constexpr ArrayStore() = default;
+
+  bool push_back(const T &obj) {
+    if (item_count == SIZE)
+      return false;
+    store[item_count] = obj;
+    ++item_count;
+    return true;
+  }
+
+  const T &back() const { return store[item_count - 1]; }
+
+  T &back() { return store[item_count - 1]; }
+
+  bool pop_back() {
+    if (item_count == 0)
+      return false;
+    --item_count;
+    return true;
+  }
+
+  bool empty() const { return item_count == 0; }
+
+  // Empties the store for all practical purposes.
+  void reset() { item_count = 0; }
+
+  static void destroy(ArrayStore<T, SIZE> *store) { store->reset(); }
+};
+
+} // namespace __llvm_libc

libc/src/stdlib/CMakeLists.txt

add_entrypoint_object(
   atexit
   SRCS
     atexit.cpp
   HDRS
     atexit.h
   CXX_STANDARD
     20 # For constinit of the atexit callback list.
   DEPENDS
+    libc.src.__support.arraystore
     libc.src.__support.CPP.blockstore
     libc.src.__support.threads.mutex
 )
 
 add_entrypoint_object(
   exit
   SRCS
     exit.cpp

libc/src/stdlib/atexit.h

 //===-- Implementation header for atexit ------------------------*- 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 LLVM_LIBC_SRC_STDLIB_ATEXIT_H
 #define LLVM_LIBC_SRC_STDLIB_ATEXIT_H
 
+#include <stddef.h> // For size_t
+
 namespace __llvm_libc {
 
+constexpr size_t CALLBACK_LIST_SIZE_FOR_TESTS = 1024;
+
 int atexit(void (*function)());
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDLIB_ATEXIT_H

libc/src/stdlib/atexit.cpp

 //===-- Implementation of atexit ------------------------------------------===//
 //
 // 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/stdlib/atexit.h"
 #include "src/__support/CPP/blockstore.h"
+#include "src/__support/arraystore.h"
 #include "src/__support/common.h"
 #include "src/__support/threads/mutex.h"
 
 namespace __llvm_libc {
 
 namespace {
 
 Mutex handler_list_mtx(false, false, false);
 
-using AtExitCallback = void(void);
-using ExitCallbackList = cpp::ReverseOrderBlockStore<AtExitCallback *, 32>;
+using AtExitCallback = void(void *);
+using StdCAtExitCallback = void(void);
+
+struct AtExitUnit {
+  AtExitCallback *callback = nullptr;
+  void *payload = nullptr;
+  constexpr AtExitUnit() = default;
+  constexpr AtExitUnit(AtExitCallback *c, void *p) : callback(c), payload(p) {}
+};
+
+#ifdef LLVM_LIBC_PUBLIC_PACKAGING
+using ExitCallbackList = cpp::ReverseOrderBlockStore<AtExitUnit, 32>;
+#else
+// BlockStore uses dynamic memory allocation. To avoid dynamic memory
+// allocation in tests, we use a fixed size callback list when built for
+// tests.
+// If we use BlockStore, then we will have to pull in malloc etc into
+// the tests. While this is not bad, the problem we have currently is
+// that LLVM libc' allocator is SCUDO. So, we will end up pulling SCUDO's
+// deps also (some of which are not yet available in LLVM libc) into the
+// integration tests.
+using ExitCallbackList = ArrayStore<AtExitUnit, CALLBACK_LIST_SIZE_FOR_TESTS>;
+#endif // LLVM_LIBC_PUBLIC_PACKAGING
+
 constinit ExitCallbackList exit_callbacks;
 
+void stdc_at_exit_func(void *payload) {
+  reinterpret_cast<StdCAtExitCallback *>(payload)();
+}
+
 } // namespace
 
 namespace internal {
 
 void call_exit_callbacks() {
   handler_list_mtx.lock();
   while (!exit_callbacks.empty()) {
-    auto *callback = exit_callbacks.back();
+    auto unit = exit_callbacks.back();
     exit_callbacks.pop_back();
     handler_list_mtx.unlock();
-    callback();
+    unit.callback(unit.payload);
     handler_list_mtx.lock();
   }
   ExitCallbackList::destroy(&exit_callbacks);
 }
 
 } // namespace internal
 
-LLVM_LIBC_FUNCTION(int, atexit, (AtExitCallback * callback)) {
+static int add_atexit_unit(const AtExitUnit &unit) {
+  // TODO: Use the return value of push_back and bubble it to the public
+  // function as error return value. Note that a BlockStore push_back can
+  // fail because of allocation failure. Likewise, an ArrayStore push_back
+  // can fail when it is full.
   handler_list_mtx.lock();
-  exit_callbacks.push_back(callback);
+  exit_callbacks.push_back(unit);
   handler_list_mtx.unlock();
   return 0;
 }
 
+extern "C" int __cxa_atexit(AtExitCallback *callback, void *payload, void *) {
+  return add_atexit_unit({callback, payload});
+}
+
+LLVM_LIBC_FUNCTION(int, atexit, (StdCAtExitCallback * callback)) {
+  return add_atexit_unit(
+      {&stdc_at_exit_func, reinterpret_cast<void *>(callback)});
+}
+
 } // namespace __llvm_libc

libc/test/integration/loader/linux/init_fini_array_test.cpp

 //===-- Loader test to test init and fini array iteration -----------------===//
 //
 // 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 "utils/IntegrationTest/test.h"
 
+#include <stddef.h>
+
+int global_destroyed = false;
+
 class A {
 private:
   int val[1024];
 
 public:
   A(int i, int a) {
     for (int k = 0; k < 1024; ++k)
       val[k] = 0;
     val[i] = a;
   }
 
   // TODO: When we have implementation for __cxa_atexit, an explicit definition
   // of the destructor should be provided to test that path of registering the
   // destructor callback for a global.
-  ~A() = default;
+  ~A() { global_destroyed = true; }
 
   int get(int i) const { return val[i]; }
 };
 
 int GLOBAL_INDEX = 512;
 int INITVAL_INITIALIZER = 0x600D;
 
 A global(GLOBAL_INDEX, INITVAL_INITIALIZER);
 
 int initval = 0;
+int preinitval = 0;
+
 __attribute__((constructor)) void set_initval() {
   initval = INITVAL_INITIALIZER;
 }
-__attribute__((destructor)) void reset_initval() { initval = 0; }
+__attribute__((destructor(1))) void reset_initval() {
+  ASSERT_TRUE(global_destroyed);
+  ASSERT_EQ(preinitval, 0);
+  initval = 0;
+}
 
-int preinitval = 0;
 void set_preinitval() { preinitval = INITVAL_INITIALIZER; }
-__attribute__((destructor)) void reset_preinitval() { preinitval = 0; }
+__attribute__((destructor(2))) void reset_preinitval() {
+  ASSERT_TRUE(global_destroyed);
+  ASSERT_EQ(initval, INITVAL_INITIALIZER);
+  preinitval = 0;
+}
 
 using PreInitFunc = void();
 __attribute__((section(".preinit_array"))) PreInitFunc *preinit_func_ptr =
     &set_preinitval;
 
 TEST_MAIN() {
   ASSERT_EQ(global.get(GLOBAL_INDEX), INITVAL_INITIALIZER);
   ASSERT_EQ(initval, INITVAL_INITIALIZER);
   ASSERT_EQ(preinitval, INITVAL_INITIALIZER);
   return 0;
 }