[libc++] Rename *SAFE_STATIC to *CONSTINIT, and normalize its uses.

[• Quuxplusone]

Summary

As I suggested in D118874.
This is not NFC; if we're worried about the functional changes, I'm willing to split this into an NFC and a cleanup.

In particular I'm not clear on whether we can safely assume, inside src/*.cpp:

• that C++11 is available? Several places use 0 for nullptr, and _LIBCPP_CONSTEXPR for constexpr. Can I fix those?
• that C++20 is available? Could we just use constinit directly instead of _LIBCPP_CONSTINIT, in src/*.cpp?

In the .h files we're at the mercy of the user-programmer and must generally assume C++03, but in src/*.cpp we (that is, our vendors) control the compiler switches.

[• Quuxplusone]

libcxx/src/experimental/memory_resource_init_helper.h

2

Here I wonder if adding static would be helpful. (This is included from within an anonymous namespace already, so it'd be redundant to the computer, but possibly helpful to the human reader.)

libcxx/src/memory.cpp

135–136

Here I'm changing constinit const to constexpr. I suspect the original code was just static const (i.e., C++03-friendly constexpr), and then _LIBCPP_SAFE_STATIC got added basically in a cut-and-paste error.

174

Here I'm adding constinit to this array that seems like it was always intended to be constinit. (The compiler optimizer was probably already doing the obvious thing anyway.)

libcxxabi/src/cxa_default_handlers.cpp

108

Here's a place it would be nice to use nullptr, if it's allowed.

[• Quuxplusone]

Remove some more redundant constexpr-friendliness declarations in the coroutines tests.
Boldly use nullptr in the place I said it'd be nice to use it; let's see if CI is happy with it.

[ldionne]

LGTM in essence, however some tests are failing. Also, we are free to assume C++20 the we build the library (in src/), because we require it here: https://github.com/llvm/llvm-project/blob/main/libcxx/CMakeLists.txt#L538-L541.

Ship it when this passes, and I suggest you use constinit directly in src/.

[Mordante]

Thanks for the cleanup! LGTM!

libcxx/src/debug.cpp

37–38

As @ldionne already pointed out we require C++20 to build the dylib so I would suggest to use constinit here.

[• Quuxplusone]

Fix the failing tests (forgot to remove a use of the removed constinit variable), and use constinit directly in libcxx/src/.
Should I use constinit directly in libcxxabi/src/ too? So far I have not.

[ldionne]

In D119264#3309220, @Quuxplusone wrote:

Fix the failing tests (forgot to remove a use of the removed constinit variable), and use constinit directly in libcxx/src/.
Should I use constinit directly in libcxxabi/src/ too? So far I have not.

I think you can, since we require CXX20 from the libc++abi CMake too. I think I checked yesterday and that was the case. If you try and it fails while building libc++abi, you'll have your answer.

This is why keeping compiler requirements fairly up-to-date is nice -- we don't have to jump through too many hoops in the sources at least.

[• Quuxplusone]

Use constinit in libcxxabi/src/*.cpp, too.

[• Quuxplusone]

CI failures: https://buildkite.com/llvm-project/libcxx-ci/builds/8602
Roll back some of the libcxxabi/src/ modernizations.

In src/, most files can use `constinit` directly because they're always
compiled with C++20. But some files, like "libcxxabi/src/fallback_malloc.cpp",
can't, because they're `#include`d directly from test cases in libcxxabi/test/
and therefore must (currently) compile as C++03. We might consider refactoring
those offending tests, or at least marking them `UNSUPPORTED: c++03`.

[ldionne]

Let's ship this!

[thakis]

Hi, this is causing us some trouble: We build with a very new libc++abi (our project autoupdates to the latest version of libc++abi every time a change lands), but an old-ish (1 year maybe) libc++ (our libc++ doesn't autoupdate yet – we're working on that part).

So our libc++ header files don't have _LIBCPP_CONSTINIT yet (it's added in this change here), but libc++abi requires it now.

Even if our libc++ would autoupdate, we probably wouldn't be able to auto-import this change automatically since libc++ and libc++abi would still autoupdate separately from each other.

If this is something you want to address at all is up to you – our setup is admittedly weird, but libc++ and libc++abi _are_ separate projects, and our setup has been working fine for the last few years.

If you do want to address it, the easiest fix is probably to just use constinit instead of _LIBCPP_CONSTINIT in libc++abi (and disable the tests that include the internal header, or make them build with -std=c++20 too, or something).

Thanks for your consideration.

[thakis]

@hans had the good idea that we can build libc++abi with -D_LIBCPP_CONSTINIT=constinit for now, which unblocks us for now. It'd still be nice if we didn't have to do that though :)

[• Quuxplusone]

In D119264#3329344, @thakis wrote:

If you do want to address it, the easiest fix is probably to just use constinit instead of _LIBCPP_CONSTINIT in libc++abi (and disable the tests that include the internal header, or make them build with -std=c++20 too, or something).

If we want to address it, I'd suggest we could add

#ifndef _LIBCPP_CONSTINIT
#define _LIBCPP_CONSTINIT constinit
#endif

somewhere near the top of the offending files.

But I'll defer to @ldionne as to whether we want to address this at all; I have no opinion myself, and it sounds like you found an okay workaround. @ldionne?

libcxx/include/__config

 #endif
 
 #ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
 #   define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
 #else
 #   define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
 #endif
 
-#if __has_attribute(require_constant_initialization)
-#  define _LIBCPP_SAFE_STATIC __attribute__((__require_constant_initialization__))
+#if _LIBCPP_STD_VER > 17
+#  define _LIBCPP_CONSTINIT constinit
+#elif __has_attribute(require_constant_initialization)
+#  define _LIBCPP_CONSTINIT __attribute__((__require_constant_initialization__))
 #else
-#  define _LIBCPP_SAFE_STATIC
+#  define _LIBCPP_CONSTINIT
 #endif
 
 #if __has_attribute(diagnose_if) && !defined(_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS)
 #  define _LIBCPP_DIAGNOSE_WARNING(...) \
      __attribute__((diagnose_if(__VA_ARGS__, "warning")))
 #  define _LIBCPP_DIAGNOSE_ERROR(...) \
      __attribute__((diagnose_if(__VA_ARGS__, "error")))
 #else

libcxx/src/debug.cpp

std::string __libcpp_debug_info::what() const {
   msg += "' failed. ";
   msg += __msg_;
   return msg;
 }
 _LIBCPP_NORETURN void __libcpp_abort_debug_function(__libcpp_debug_info const& info) {
     std::fprintf(stderr, "%s\n", info.what().c_str());
     std::abort();
 }
 
-_LIBCPP_SAFE_STATIC __libcpp_debug_function_type
-    __libcpp_debug_function = __libcpp_abort_debug_function;
+constinit __libcpp_debug_function_type __libcpp_debug_function = __libcpp_abort_debug_function;
 
 bool __libcpp_set_debug_function(__libcpp_debug_function_type __func) {
   __libcpp_debug_function = __func;
   return true;
 }
 
 _LIBCPP_FUNC_VIS
 __libcpp_db*

libcxx/src/experimental/memory_resource.cpp

 }
 
 // default_memory_resource()
 
 static memory_resource *
 __default_memory_resource(bool set = false, memory_resource * new_res = nullptr) noexcept
 {
 #ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-    _LIBCPP_SAFE_STATIC static atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
+    static constinit atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
     if (set) {
         new_res = new_res ? new_res : new_delete_resource();
         // TODO: Can a weaker ordering be used?
         return _VSTD::atomic_exchange_explicit(
             &__res, new_res, memory_order_acq_rel);
     }
     else {
         return _VSTD::atomic_load_explicit(
             &__res, memory_order_acquire);
     }
 #elif !defined(_LIBCPP_HAS_NO_THREADS)
-    _LIBCPP_SAFE_STATIC static memory_resource * res = &res_init.resources.new_delete_res;
+    static constinit memory_resource *res = &res_init.resources.new_delete_res;
     static mutex res_lock;
     if (set) {
         new_res = new_res ? new_res : new_delete_resource();
         lock_guard<mutex> guard(res_lock);
         memory_resource * old_res = res;
         res = new_res;
         return old_res;
     } else {
         lock_guard<mutex> guard(res_lock);
         return res;
     }
 #else
-    _LIBCPP_SAFE_STATIC static memory_resource* res = &res_init.resources.new_delete_res;
+    static constinit memory_resource *res = &res_init.resources.new_delete_res;
     if (set) {
         new_res = new_res ? new_res : new_delete_resource();
         memory_resource * old_res = res;
         res = new_res;
         return old_res;
     } else {
         return res;
     }

libcxx/src/experimental/memory_resource_init_helper.h

 #pragma GCC system_header
-_LIBCPP_SAFE_STATIC ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;
+static constinit ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;

libcxx/src/memory.cpp

 const void*
 __shared_weak_count::__get_deleter(const type_info&) const noexcept
 {
     return nullptr;
 }
 
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 
-_LIBCPP_SAFE_STATIC static const std::size_t __sp_mut_count = 16;
-_LIBCPP_SAFE_STATIC static __libcpp_mutex_t mut_back[__sp_mut_count] =
+static constexpr std::size_t __sp_mut_count = 16;
+static constinit __libcpp_mutex_t mut_back[__sp_mut_count] =
 {
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER
 };
 
 _LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) noexcept

 __sp_mut::unlock() noexcept
 {
     __libcpp_mutex_unlock(static_cast<__libcpp_mutex_t*>(__lx));
 }
 
 __sp_mut&
 __get_sp_mut(const void* p)
 {
-    static __sp_mut muts[__sp_mut_count]
-    {
+    static constinit __sp_mut muts[__sp_mut_count] = {
         &mut_back[ 0], &mut_back[ 1], &mut_back[ 2], &mut_back[ 3],
         &mut_back[ 4], &mut_back[ 5], &mut_back[ 6], &mut_back[ 7],
         &mut_back[ 8], &mut_back[ 9], &mut_back[10], &mut_back[11],
         &mut_back[12], &mut_back[13], &mut_back[14], &mut_back[15]
     };
     return muts[hash<const void*>()(p) & (__sp_mut_count-1)];
 }
 

libcxx/src/mutex.cpp

 
 // If dispatch_once_f ever handles C++ exceptions, and if one can get to it
 // without illegal macros (unexpected macros not beginning with _UpperCase or
 // __lowercase), and if it stops spinning waiting threads, then call_once should
 // call into dispatch_once_f instead of here. Relevant radar this code needs to
 // keep in sync with:  7741191.
 
 #ifndef _LIBCPP_HAS_NO_THREADS
-_LIBCPP_SAFE_STATIC static __libcpp_mutex_t mut = _LIBCPP_MUTEX_INITIALIZER;
-_LIBCPP_SAFE_STATIC static __libcpp_condvar_t cv = _LIBCPP_CONDVAR_INITIALIZER;
+static constinit __libcpp_mutex_t mut = _LIBCPP_MUTEX_INITIALIZER;
+static constinit __libcpp_condvar_t cv = _LIBCPP_CONDVAR_INITIALIZER;
 #endif
 
 void __call_once(volatile once_flag::_State_type& flag, void* arg,
                  void (*func)(void*))
 {
 #if defined(_LIBCPP_HAS_NO_THREADS)
     if (flag == 0)
     {

libcxx/src/random_shuffle.cpp

 #   if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #       pragma comment(lib, "pthread")
 #   endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_THREADS
-_LIBCPP_SAFE_STATIC static __libcpp_mutex_t __rs_mut = _LIBCPP_MUTEX_INITIALIZER;
+static constinit __libcpp_mutex_t __rs_mut = _LIBCPP_MUTEX_INITIALIZER;
 #endif
 unsigned __rs_default::__c_ = 0;
 
 __rs_default::__rs_default()
 {
 #ifndef _LIBCPP_HAS_NO_THREADS
     __libcpp_mutex_lock(&__rs_mut);
 #endif

libcxx/src/support/runtime/exception_fallback.ipp

 // -*- 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 <cstdio>
 
 namespace std {
 
-_LIBCPP_SAFE_STATIC static std::terminate_handler  __terminate_handler;
-_LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler;
-
+static constinit std::terminate_handler  __terminate_handler = nullptr;
+static constinit std::unexpected_handler __unexpected_handler = nullptr;
 
 // libcxxrt provides implementations of these functions itself.
 unexpected_handler
 set_unexpected(unexpected_handler func) noexcept
 {
   return __libcpp_atomic_exchange(&__unexpected_handler, func);
 }
 
 unexpected_handler
 get_unexpected() noexcept
 {
   return __libcpp_atomic_load(&__unexpected_handler);
-
 }
 
 _LIBCPP_NORETURN
 void unexpected()
 {
     (*get_unexpected())();
     // unexpected handler should not return
     terminate();

libcxx/src/support/runtime/new_handler_fallback.ipp

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 namespace std {
 
-_LIBCPP_SAFE_STATIC static std::new_handler __new_handler;
+static constinit std::new_handler __new_handler = nullptr;
 
 new_handler
 set_new_handler(new_handler handler) noexcept
 {
     return __libcpp_atomic_exchange(&__new_handler, handler);
 }
 
 new_handler
 get_new_handler() noexcept
 {
     return __libcpp_atomic_load(&__new_handler);
 }
 
 } // namespace std

libcxx/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 namespace coro = std::experimental;
 
 using SuspendT = std::experimental::coroutines_v1::suspend_always;
 
-TEST_SAFE_STATIC SuspendT safe_sa;
-constexpr SuspendT constexpr_sa;
-
 constexpr bool check_suspend_constexpr() {
-  SuspendT s{};
-  const SuspendT scopy(s); ((void)scopy);
-  SuspendT smove(std::move(s)); ((void)smove);
+  SuspendT s;
+  const SuspendT scopy(s); (void)scopy;
+  SuspendT smove(std::move(s)); (void)smove;
   s = scopy;
   s = std::move(smove);
   return true;
 }
 
 int main(int, char**)
 {
   using H = coro::coroutine_handle<>;
S const& cs = s;
     static_assert(std::is_nothrow_default_constructible<S>::value, "");
     static_assert(std::is_nothrow_copy_constructible<S>::value, "");
     static_assert(std::is_nothrow_move_constructible<S>::value, "");
     static_assert(std::is_nothrow_copy_assignable<S>::value, "");
     static_assert(std::is_nothrow_move_assignable<S>::value, "");
     static_assert(std::is_trivially_copyable<S>::value, "");
     static_assert(check_suspend_constexpr(), "");
   }
-  {
-    // suppress unused warnings for the global constexpr test variable
-    ((void)constexpr_sa);
-  }
 
   return 0;
 }

libcxx/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp

 #include <experimental/coroutine>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace coro = std::experimental;
 
-// Test that the type is in the correct namespace
 using SuspendT = std::experimental::coroutines_v1::suspend_never;
 
-TEST_SAFE_STATIC SuspendT safe_sn;
-constexpr SuspendT constexpr_sn;
-
 constexpr bool check_suspend_constexpr() {
-  SuspendT s{};
-  const SuspendT scopy(s); ((void)scopy);
-  SuspendT smove(std::move(s)); ((void)smove);
+  SuspendT s;
+  const SuspendT scopy(s); (void)scopy;
+  SuspendT smove(std::move(s)); (void)smove;
   s = scopy;
   s = std::move(smove);
   return true;
 }
 
 
 int main(int, char**)
 {
S const& cs = s;
     static_assert(std::is_nothrow_default_constructible<S>::value, "");
     static_assert(std::is_nothrow_copy_constructible<S>::value, "");
     static_assert(std::is_nothrow_move_constructible<S>::value, "");
     static_assert(std::is_nothrow_copy_assignable<S>::value, "");
     static_assert(std::is_nothrow_move_assignable<S>::value, "");
     static_assert(std::is_trivially_copyable<S>::value, "");
     static_assert(check_suspend_constexpr(), "");
   }
-  {
-    // suppress unused warnings for the global constexpr test variable
-    ((void)constexpr_sn);
-  }
 
   return 0;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp

 
 #include <coroutine>
 #include <type_traits>
 #include <cassert>
 #include <utility>
 
 #include "test_macros.h"
 
-TEST_SAFE_STATIC std::suspend_always safe_sa;
-
 constexpr bool check_suspend_constexpr() {
   std::suspend_always s{};
   const std::suspend_always scopy(s);
   std::suspend_always smove(std::move(s));
   s = scopy;
   s = std::move(smove);
   return true;
 }

libcxx/test/std/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp

 
 #include <coroutine>
 #include <type_traits>
 #include <cassert>
 #include <utility>
 
 #include "test_macros.h"
 
-// Test that the type 'std::suspend_never' is in the correct namespace
-
-TEST_SAFE_STATIC std::suspend_never safe_sn;
-constexpr std::suspend_never constexpr_sn;
-
 constexpr bool check_suspend_constexpr() {
   std::suspend_never s{};
   const std::suspend_never scopy(s); ((void)scopy);
   std::suspend_never smove(std::move(s)); ((void)smove);
   s = scopy;
   s = std::move(smove);
   return true;
 }
S const& cs = s;
     static_assert(std::is_nothrow_copy_assignable<std::suspend_never>::value, "");
     static_assert(std::is_nothrow_move_assignable<std::suspend_never>::value, "");
     static_assert(std::is_trivially_copyable<std::suspend_never>::value, "");
     static_assert(check_suspend_constexpr(), "");
   }
   {
     static_assert(test_trivial_awaitable_constexpr<std::suspend_never>(true));
   }
-  {
-    // suppress unused warnings for the global constexpr test variable
-    ((void)constexpr_sn);
-  }
 
   return 0;
 }

libcxx/test/std/utilities/any/any.class/any.cons/default.pass.cpp

using std::any;
             std::is_nothrow_default_constructible<any>::value
           , "Must be default constructible"
           );
     }
     {
         struct TestConstexpr : public std::any {
           constexpr TestConstexpr() : std::any() {}
         };
-        TEST_SAFE_STATIC static std::any a;
-        ((void)a);
+        static TEST_CONSTINIT std::any a;
+        (void)a;
     }
     {
         DisableAllocationGuard g; ((void)g);
         any const a;
         assertEmpty(a);
     }
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/default.pass.cpp

 #include <cassert>
 #include "test_macros.h"
 
 #include "test_macros.h"
 #include "deleter_types.h"
 #include "unique_ptr_test_helper.h"
 
 #if TEST_STD_VER >= 11
-TEST_SAFE_STATIC std::unique_ptr<int> global_static_unique_ptr_single;
-TEST_SAFE_STATIC std::unique_ptr<int[]> global_static_unique_ptr_runtime;
+TEST_CONSTINIT std::unique_ptr<int> global_static_unique_ptr_single;
+TEST_CONSTINIT std::unique_ptr<int[]> global_static_unique_ptr_runtime;
 
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;
   void operator()(void*) const {}
 };
 #endif
 
 template <class ElemType>

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/nullptr.pass.cpp

 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "unique_ptr_test_helper.h"
 
 
 #if TEST_STD_VER >= 11
-TEST_SAFE_STATIC std::unique_ptr<int> global_static_unique_ptr_single(nullptr);
-TEST_SAFE_STATIC std::unique_ptr<int[]> global_static_unique_ptr_runtime(nullptr);
+TEST_CONSTINIT std::unique_ptr<int> global_static_unique_ptr_single(nullptr);
+TEST_CONSTINIT std::unique_ptr<int[]> global_static_unique_ptr_runtime(nullptr);
 
 struct NonDefaultDeleter {
   NonDefaultDeleter() = delete;
   void operator()(void*) const {}
 };
 #endif
 
 template <class VT>

libcxx/test/support/test_macros.h

 #endif
 
 #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) || \
   (!(TEST_STD_VER > 14 || \
     (defined(__cpp_aligned_new) && __cpp_aligned_new >= 201606L)))
 #define TEST_HAS_NO_ALIGNED_ALLOCATION
 #endif
 
-#if defined(_LIBCPP_SAFE_STATIC)
-#define TEST_SAFE_STATIC _LIBCPP_SAFE_STATIC
+#if TEST_STD_VER > 17
+#define TEST_CONSTINIT constinit
+#elif defined(_LIBCPP_CONSTINIT)
+#define TEST_CONSTINIT _LIBCPP_CONSTINIT
 #else
-#define TEST_SAFE_STATIC
+#define TEST_CONSTINIT
 #endif
 
 #if !defined(__cpp_impl_three_way_comparison) \
     && (!defined(_MSC_VER) || defined(__clang__) || _MSC_VER < 1920 || _MSVC_LANG <= 201703L)
 #define TEST_HAS_NO_SPACESHIP_OPERATOR
 #endif
 
 #if TEST_STD_VER < 11

libcxxabi/src/cxa_default_handlers.cpp

 #include "cxxabi.h"
 #include "cxa_handlers.h"
 #include "cxa_exception.h"
 #include "private_typeinfo.h"
 #include "include/atomic_support.h" // from libc++
 
 #if !defined(LIBCXXABI_SILENT_TERMINATE)
 
-_LIBCPP_SAFE_STATIC
-static const char* cause = "uncaught";
+static constinit const char* cause = "uncaught";
 
 __attribute__((noreturn))
 static void demangling_terminate_handler()
 {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     // If there might be an uncaught exception
     using namespace __cxxabiv1;
     __cxa_eh_globals* globals = __cxa_get_globals_fast();

 static constexpr std::terminate_handler default_terminate_handler = ::abort;
 static constexpr std::terminate_handler default_unexpected_handler = std::terminate;
 #endif
 
 //
 // Global variables that hold the pointers to the current handler
 //
 _LIBCXXABI_DATA_VIS
-_LIBCPP_SAFE_STATIC std::terminate_handler __cxa_terminate_handler = default_terminate_handler;
+constinit std::terminate_handler __cxa_terminate_handler = default_terminate_handler;
 
 _LIBCXXABI_DATA_VIS
-_LIBCPP_SAFE_STATIC std::unexpected_handler __cxa_unexpected_handler = default_unexpected_handler;
+constinit std::unexpected_handler __cxa_unexpected_handler = default_unexpected_handler;
 
 _LIBCXXABI_DATA_VIS
-_LIBCPP_SAFE_STATIC std::new_handler __cxa_new_handler = 0;
+constinit std::new_handler __cxa_new_handler = nullptr;
 
 namespace std
 {
 
 unexpected_handler
 set_unexpected(unexpected_handler func) noexcept
 {
     if (func == 0)

libcxxabi/src/cxa_guard_impl.h

 //
 //===----------------------------------------------------------------------===//
 
 template <class T>
 struct GlobalStatic {
   static T instance;
 };
 template <class T>
-_LIBCPP_SAFE_STATIC T GlobalStatic<T>::instance = {};
+_LIBCPP_CONSTINIT T GlobalStatic<T>::instance = {};
 
 enum class Implementation { NoThreads, GlobalMutex, Futex };
 
 template <Implementation Impl>
 struct SelectImplementation;
 
 template <>
 struct SelectImplementation<Implementation::NoThreads> {

libcxxabi/src/fallback_malloc.cpp

 //  Allocates chunks in multiples of four bytes, with a four byte header
 //  for each chunk. The overhead of each chunk is kept low by keeping pointers
 //  as two byte offsets within the heap, rather than (4 or 8 byte) pointers.
 
 namespace {
 
 // When POSIX threads are not available, make the mutex operations a nop
 #ifndef _LIBCXXABI_HAS_NO_THREADS
-_LIBCPP_SAFE_STATIC
-static std::__libcpp_mutex_t heap_mutex = _LIBCPP_MUTEX_INITIALIZER;
+static _LIBCPP_CONSTINIT std::__libcpp_mutex_t heap_mutex = _LIBCPP_MUTEX_INITIALIZER;
 #else
-static void* heap_mutex = 0;
+static _LIBCPP_CONSTINIT void* heap_mutex = 0;
 #endif
 
 class mutexor {
 public:
 #ifndef _LIBCXXABI_HAS_NO_THREADS
   mutexor(std::__libcpp_mutex_t* m) : mtx_(m) {
     std::__libcpp_mutex_lock(mtx_);
   }