Add LLVM libcxxabi (#1063)

* third_party: Add libcxxabi

Added libcxxabi from LLVM 17.0.6
The library implements the Itanium C++ exception handling ABI.

* third_party/libcxxabi: Enable __cxa_thread_atexit

Enable `__cxa_thread_atexit` from libcxxabi.
`__cxa_thread_atexit_impl` is still implemented by the cosmo libc.
The original `__cxa_thread_atexit` has been removed.

* third_party/libcxx: Build with exceptions

Build libcxx with exceptions enabled.

- Removed `_LIBCPP_NO_EXCEPTIONS` from `__config`.
- Switched the exception implementation to `libcxxabi`. These two files
are taken from the same `libcxx` version as mentioned in `README.cosmo`.
- Removed `new_handler_fallback` in favor of `libcxxabi` implementation.
- Enable `-fexceptions` and `-frtti` for `libcxx`.
- Removed `THIRD_PARTY_LIBCXX` dependency from `libcxxabi` and
`libunwind`. These libraries do not use any runtime `libcxx` functions,
just headers.

* libc: Remove remaining redundant cxa functions

- `__cxa_pure_virtual` in `libcxxabi` is also a stub similar to the
existing one.
- `__cxa_guard_*` from `libcxxabi` is used instead of the ones from
Android.

Now there should be no more duplicate implementations.
`__cxa_thread_atexit_impl`, `__cxa_atexit`, and related supporting
functions, are still left to other libraries as in `libcxxabi`.

`libcxxabi` is also now added to `cosmopolitan.a` to make up for the
removed functions.

Affected in-tree libraries (`third_party/double-conversion`) have been
updated.

third_party/libcxxabi/cxa_exception_storage.cc

@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//
+//  This file implements the storage for the "Caught Exception Stack"
+//  https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html#cxx-exc-stack
+//
+//===----------------------------------------------------------------------===//
+
+#include "third_party/libcxxabi/cxa_exception.h"
+
+#include "third_party/libcxx/__threading_support"
+
+#if defined(_LIBCXXABI_HAS_NO_THREADS)
+
+namespace __cxxabiv1 {
+extern "C" {
+    static __cxa_eh_globals eh_globals;
+    __cxa_eh_globals *__cxa_get_globals() { return &eh_globals; }
+    __cxa_eh_globals *__cxa_get_globals_fast() { return &eh_globals; }
+} // extern "C"
+} // namespace __cxxabiv1
+
+#elif defined(HAS_THREAD_LOCAL)
+
+namespace __cxxabiv1 {
+namespace {
+    __cxa_eh_globals *__globals() {
+        static thread_local __cxa_eh_globals eh_globals;
+        return &eh_globals;
+    }
+} // namespace
+
+extern "C" {
+    __cxa_eh_globals *__cxa_get_globals() { return __globals(); }
+    __cxa_eh_globals *__cxa_get_globals_fast() { return __globals(); }
+} // extern "C"
+} // namespace __cxxabiv1
+
+#else
+
+#include "third_party/libcxxabi/abort_message.h"
+#include "third_party/libcxxabi/fallback_malloc.h"
+
+#if defined(__ELF__) && defined(_LIBCXXABI_LINK_PTHREAD_LIB)
+#pragma comment(lib, "pthread")
+#endif
+
+//  In general, we treat all threading errors as fatal.
+//  We cannot call std::terminate() because that will in turn
+//  call __cxa_get_globals() and cause infinite recursion.
+
+namespace __cxxabiv1 {
+namespace {
+    std::__libcpp_tls_key key_;
+    std::__libcpp_exec_once_flag flag_ = _LIBCPP_EXEC_ONCE_INITIALIZER;
+
+    void _LIBCPP_TLS_DESTRUCTOR_CC destruct_(void *p) {
+        __free_with_fallback(p);
+        if (0 != std::__libcpp_tls_set(key_, NULL))
+            abort_message("cannot zero out thread value for __cxa_get_globals()");
+    }
+
+    void construct_() {
+        if (0 != std::__libcpp_tls_create(&key_, destruct_))
+            abort_message("cannot create thread specific key for __cxa_get_globals()");
+    }
+} // namespace
+
+extern "C" {
+    __cxa_eh_globals *__cxa_get_globals() {
+        // Try to get the globals for this thread
+        __cxa_eh_globals *retVal = __cxa_get_globals_fast();
+
+        // If this is the first time we've been asked for these globals, create them
+        if (NULL == retVal) {
+            retVal = static_cast<__cxa_eh_globals*>(
+                __calloc_with_fallback(1, sizeof(__cxa_eh_globals)));
+            if (NULL == retVal)
+                abort_message("cannot allocate __cxa_eh_globals");
+            if (0 != std::__libcpp_tls_set(key_, retVal))
+               abort_message("std::__libcpp_tls_set failure in __cxa_get_globals()");
+        }
+        return retVal;
+    }
+
+    // Note that this implementation will reliably return NULL if not
+    // preceded by a call to __cxa_get_globals().  This is an extension
+    // to the Itanium ABI and is taken advantage of in several places in
+    // libc++abi.
+    __cxa_eh_globals *__cxa_get_globals_fast() {
+        // First time through, create the key.
+        if (0 != std::__libcpp_execute_once(&flag_, construct_))
+            abort_message("execute once failure in __cxa_get_globals_fast()");
+        return static_cast<__cxa_eh_globals*>(std::__libcpp_tls_get(key_));
+    }
+} // extern "C"
+} // namespace __cxxabiv1
+
+#endif