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_handlers.cc

@@ -0,0 +1,101 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 functionality associated with the terminate_handler,
+// unexpected_handler, and new_handler.
+//===----------------------------------------------------------------------===//
+
+#include "third_party/libcxx/stdexcept"
+#include "third_party/libcxx/new"
+#include "third_party/libcxx/exception"
+#include "third_party/libcxxabi/abort_message.h"
+#include "third_party/libcxxabi/include/cxxabi.h"
+#include "third_party/libcxxabi/cxa_handlers.h"
+#include "third_party/libcxxabi/cxa_exception.h"
+#include "third_party/libcxxabi/private_typeinfo.h"
+#include "third_party/libcxx/include/atomic_support.hh" // from libc++
+
+namespace std
+{
+
+unexpected_handler
+get_unexpected() noexcept
+{
+    return __libcpp_atomic_load(&__cxa_unexpected_handler, _AO_Acquire);
+}
+
+void
+__unexpected(unexpected_handler func)
+{
+    func();
+    // unexpected handler should not return
+    abort_message("unexpected_handler unexpectedly returned");
+}
+
+__attribute__((noreturn))
+void
+unexpected()
+{
+    __unexpected(get_unexpected());
+}
+
+terminate_handler
+get_terminate() noexcept
+{
+    return __libcpp_atomic_load(&__cxa_terminate_handler, _AO_Acquire);
+}
+
+void
+__terminate(terminate_handler func) noexcept
+{
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
+    try
+    {
+#endif // _LIBCXXABI_NO_EXCEPTIONS
+        func();
+        // handler should not return
+        abort_message("terminate_handler unexpectedly returned");
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
+    }
+    catch (...)
+    {
+        // handler should not throw exception
+        abort_message("terminate_handler unexpectedly threw an exception");
+    }
+#endif // _LIBCXXABI_NO_EXCEPTIONS
+}
+
+__attribute__((noreturn))
+void
+terminate() noexcept
+{
+#ifndef _LIBCXXABI_NO_EXCEPTIONS
+    // If there might be an uncaught exception
+    using namespace __cxxabiv1;
+    __cxa_eh_globals* globals = __cxa_get_globals_fast();
+    if (globals)
+    {
+        __cxa_exception* exception_header = globals->caughtExceptions;
+        if (exception_header)
+        {
+            _Unwind_Exception* unwind_exception =
+                reinterpret_cast<_Unwind_Exception*>(exception_header + 1) - 1;
+            if (__isOurExceptionClass(unwind_exception))
+                __terminate(exception_header->terminateHandler);
+        }
+    }
+#endif
+    __terminate(get_terminate());
+}
+
+new_handler
+get_new_handler() noexcept
+{
+    return __libcpp_atomic_load(&__cxa_new_handler, _AO_Acquire);
+}
+
+}  // std