[libcxx] [libcxxabi] don't throw+catch in std::make_exception_ptr when building with libcxxabi

[itrofimow]

Summary

Instead of throwing an exception allocate its memory and initialize it
explicitly. Makes std::make_exception_ptr more efficient since no stack
unwinding is needed.

[itrofimow]

• + clang-format

[itrofimow]

• cleanup

[itrofimow]

• + clang-format, fix libcxx.imp

[itrofimow]

Hi!

Inspired by what libstdc++ does: we don't have to throw + catch (thus unwinding) an exception when creating exception_ptr,
because libcxxabi knows exactly how to create an exception_ptr from the given object.

Could you please validate this idea and if this seems reasonable guide me on what and where should be adjusted to make
generated_files/modules/etc. tests pass?

[itrofimow]

• wip on making the build green

[itrofimow]

• wip on making the build green

[itrofimow]

• regenerate ignore_format.txt

[itrofimow]

• + clang-format
• cleanup
• + clang-format, fix libcxx.imp
• wip on making the build green
• wip on making the build green
• regenerate ignore_format.txt
• bits of formatting
• wip on making the build green

[itrofimow]

• wip on making the build green

[itrofimow]

• rebase to trigger build

[philnik]

Since we are moving to GitHub PRs and there hasn't been any activity here yet, could you move this patch over?

[itrofimow]

Closing this in favor of github PR: https://github.com/llvm/llvm-project/pull/65534

libcxx/include/__exception/exception_ptr.h

 //===----------------------------------------------------------------------===//
 //
 // 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 _LIBCPP___EXCEPTION_EXCEPTION_PTR_H
 #define _LIBCPP___EXCEPTION_EXCEPTION_PTR_H
 
 #include <__config>
 #include <__exception/operations.h>
 #include <__memory/addressof.h>
 #include <cstddef>
 #include <cstdlib>
+#include <type_traits>
+#include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 namespace std { // purposefully not using versioning namespace
 
 #ifndef _LIBCPP_ABI_MICROSOFT
 
 class _LIBCPP_EXPORTED_FROM_ABI exception_ptr {
   void* __ptr_;
 
+  template <class _Ep>
+  static inline void __dest_thunk(void* __x) {
+    static_cast<_Ep*>(__x)->~_Ep();
+  }
+
+  static void* init_ex(size_t, std::type_info*, void (*)(void*)) _NOEXCEPT;
+  static void free_ex(void*) _NOEXCEPT;
+  static exception_ptr from_ex_ptr(void* __e) _NOEXCEPT;
+
+  template <class _Ep>
+  friend _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep) _NOEXCEPT;
+
 public:
   _LIBCPP_HIDE_FROM_ABI exception_ptr() _NOEXCEPT : __ptr_() {}
   _LIBCPP_HIDE_FROM_ABI exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
 
   exception_ptr(const exception_ptr&) _NOEXCEPT;
   exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
   ~exception_ptr() _NOEXCEPT;
 
public:
 
   friend _LIBCPP_EXPORTED_FROM_ABI exception_ptr current_exception() _NOEXCEPT;
   friend _LIBCPP_EXPORTED_FROM_ABI void rethrow_exception(exception_ptr);
 };
 
 template <class _Ep>
 _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep __e) _NOEXCEPT {
 #  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+#    if defined(LIBCXX_BUILDING_LIBCXXABI)
+  using _Ep2 = typename decay<_Ep>::type;
+  void* __ex =
+      exception_ptr::init_ex(sizeof(_Ep), const_cast<std::type_info*>(&typeid(_Ep)), exception_ptr::__dest_thunk<_Ep2>);
+  try {
+    ::new (__ex) _Ep2(__e);
+    return exception_ptr::from_ex_ptr(__ex);
+  } catch (...) {
+    exception_ptr::free_ex(__ex);
+    return current_exception();
+  }
+#    else
   try {
     throw __e;
   } catch (...) {
     return current_exception();
   }
+#    endif
 #  else
   ((void)__e);
   std::abort();
 #  endif
 }
 
 #else // _LIBCPP_ABI_MICROSOFT
 

libcxx/src/support/runtime/exception_pointer_cxxabi.ipp

exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
     {
         __cxa_increment_exception_refcount(other.__ptr_);
         __cxa_decrement_exception_refcount(__ptr_);
         __ptr_ = other.__ptr_;
     }
     return *this;
 }
 
+void *exception_ptr::init_ex(size_t size, type_info *tinfo, void (*dest)(void *)) noexcept {
+  void *__ex = __cxa_allocate_exception(size);
+  (void)__cxa_init_primary_exception(__ex, tinfo, dest);
+  return __ex;
+}
+
+void exception_ptr::free_ex(void *thrown_object) noexcept {
+  __cxa_free_exception(thrown_object);
+}
+
+exception_ptr exception_ptr::from_ex_ptr(void *__e) noexcept {
+    exception_ptr ptr;
+    ptr.__ptr_ = __e;
+    __cxa_increment_exception_refcount(ptr.__ptr_);
+
+    return ptr;
+}
+
 nested_exception::nested_exception() noexcept
     : __ptr_(current_exception())
 {
 }
 
 nested_exception::~nested_exception() noexcept
 {
 }

libcxxabi/include/cxxabi.h

 #else
 class type_info; // forward declaration
 #endif
 }
 
 
 // runtime routines use C calling conventions, but are in __cxxabiv1 namespace
 namespace __cxxabiv1 {
+
+struct __cxa_exception;
+
 extern "C"  {
 
 // 2.4.2 Allocating the Exception Object
 extern _LIBCXXABI_FUNC_VIS void *
 __cxa_allocate_exception(size_t thrown_size) throw();
 extern _LIBCXXABI_FUNC_VIS void
 __cxa_free_exception(void *thrown_exception) throw();
+// This function is an llvm extension
+extern _LIBCXXABI_FUNC_VIS __cxa_exception*
+__cxa_init_primary_exception(void* object, std::type_info* tinfo, void(_LIBCXXABI_DTOR_FUNC* dest)(void*)) throw();
 
 // 2.4.3 Throwing the Exception Object
 extern _LIBCXXABI_FUNC_VIS _LIBCXXABI_NORETURN void
 __cxa_throw(void *thrown_exception, std::type_info *tinfo,
             void (_LIBCXXABI_DTOR_FUNC *dest)(void *));
 
 // 2.5.3 Exception Handlers
 extern _LIBCXXABI_FUNC_VIS void *

libcxxabi/src/cxa_exception.cpp

 void __cxa_free_exception(void *thrown_object) throw() {
     // Compute the size of the padding before the header.
     size_t header_offset = get_cxa_exception_offset();
     char *raw_buffer =
         ((char *)cxa_exception_from_thrown_object(thrown_object)) - header_offset;
     __aligned_free_with_fallback((void *)raw_buffer);
 }
 
+__cxa_exception* __cxa_init_primary_exception(void* object, std::type_info* tinfo,
+                                              void(_LIBCXXABI_DTOR_FUNC* dest)(void*)) throw() {
+    __cxa_exception* exception_header = cxa_exception_from_thrown_object(object);
+    exception_header->referenceCount = 0;
+    exception_header->unexpectedHandler = std::get_unexpected();
+    exception_header->terminateHandler = std::get_terminate();
+    exception_header->exceptionType = tinfo;
+    exception_header->exceptionDestructor = dest;
+    setOurExceptionClass(&exception_header->unwindHeader);
+    exception_header->unwindHeader.exception_cleanup = exception_cleanup_func;
+
+    return exception_header;
+}
 
 //  This function shall allocate a __cxa_dependent_exception and
 //  return a pointer to it. (Really to the object, not past its' end).
 //  Otherwise, it will work like __cxa_allocate_exception.
 void * __cxa_allocate_dependent_exception () {
     size_t actual_size = sizeof(__cxa_dependent_exception);
     void *ptr = __aligned_malloc_with_fallback(actual_size);
     if (NULL == ptr)

 __Unwind_RaiseException begins the process of stack unwinding, described
 in Section 2.5. In special cases, such as an inability to find a
 handler, _Unwind_RaiseException may return. In that case, __cxa_throw
 will call terminate, assuming that there was no handler for the
 exception.
 */
 void
 __cxa_throw(void *thrown_object, std::type_info *tinfo, void (_LIBCXXABI_DTOR_FUNC *dest)(void *)) {
-    __cxa_eh_globals *globals = __cxa_get_globals();
-    __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
-
-    exception_header->unexpectedHandler = std::get_unexpected();
-    exception_header->terminateHandler  = std::get_terminate();
-    exception_header->exceptionType = tinfo;
-    exception_header->exceptionDestructor = dest;
-    setOurExceptionClass(&exception_header->unwindHeader);
-    exception_header->referenceCount = 1;  // This is a newly allocated exception, no need for thread safety.
+    __cxa_eh_globals* globals = __cxa_get_globals();
     globals->uncaughtExceptions += 1;   // Not atomically, since globals are thread-local
 
-    exception_header->unwindHeader.exception_cleanup = exception_cleanup_func;
+    __cxa_exception* exception_header = __cxa_init_primary_exception(thrown_object, tinfo, dest);
+    exception_header->referenceCount = 1; // This is a newly allocated exception, no need for thread safety.
 
 #if __has_feature(address_sanitizer)
     // Inform the ASan runtime that now might be a good time to clean stuff up.
     __asan_handle_no_return();
 #endif
 
 #ifdef __USING_SJLJ_EXCEPTIONS__
     _Unwind_SjLj_RaiseException(&exception_header->unwindHeader);