[libcxx][libcxxabi] Decouple no-exceptions libcpp variant from cxa_exception.cpp and cxa_personality.cpp of libcxxabi

[rmaprath]

Summary

This is a pre-requisite to address a review comment on D20677; The no-exceptions variant of libcxxabi should not be allowed to be linked against code that requires exceptions.

In order to do this, we need to rip off some exceptions-related symbols from the no-exceptions libcxxabi build. We can get rid of both cxa_exception.cpp and cxa_personality.cpp to meet the said requirement, but this needs a small surgery to the no-exception libcpp variant; we must #ifdef out the dependency on these two libcxxabi sources from the exception.cpp of libcxx.

[EricWF]

I don't like the direction of this patch, and it seems like the wrong direction for what your trying to achieve as well.
If your trying to support a system with two variants of libc++abi, one that throws and the other that does not, then you'll want libc++ to remain unmodified so it can depend on the selected libc++abi to provide the correct exception handling behavior.

I think these particular symbols should always be defined within libc++abi (sorry if I said otherwise earlier, I didn't understand the implementation). The -fno-exceptions build of libc++abi can build these symbols with very simple definitions that is detached from the rest of the exception handling machinery.

My preference would be to create a new file cxa_no_exception_definitions.cpp (bike shedding welcome) which builds inplace of cxa_exception.cpp and contains definitions for these symbols. For example.

• __cxa_uncaugh_exception()/__cxa_uncaught_exceptions() always returns zero.
• __cxa_decrement_exception_refcount(ptr)/__cxa_increment_refcount(ptr) terminate if ptr != nullptr.
• __cxa_primary_exception() returns nullptr.
• __cxa_rethrow_primary_exception(ptr) returns as to hit the terminate call in libc++.

This way we are not conflating building libc++ without exceptions with building libc++ against an ABI library which doesn't provide the exception handling API.

[rmaprath]

In D20784#443708, @EricWF wrote:

I don't like the direction of this patch, and it seems like the wrong direction for what your trying to achieve as well.
If your trying to support a system with two variants of libc++abi, one that throws and the other that does not, then you'll want libc++ to remain unmodified so it can depend on the selected libc++abi to provide the correct exception handling behavior.

We do not allow linking a with-exceptions libc++ library with a no-exceptions libc++abi library, that is not a use-case for us. We have either with-exceptions libraries or no-exceptions libraries, there is no overlap. This is why I went with the current approach (modify the no-exceptions libc++ variant to match the no-exceptions libc++abi variant).

Note that our use-case is about code-size, we do not want exception handling routines (as well as exception tables) in our final image. We are not after a system where you can swap out the exceptions behaviour. Sorry if I wasn't clear about this.

I think these particular symbols should always be defined within libc++abi (sorry if I said otherwise earlier, I didn't understand the implementation). The -fno-exceptions build of libc++abi can build these symbols with very simple definitions that is detached from the rest of the exception handling machinery.

My preference would be to create a new file cxa_no_exception_definitions.cpp (bike shedding welcome) which builds inplace of cxa_exception.cpp and contains definitions for these symbols. For example.

• __cxa_uncaugh_exception()/__cxa_uncaught_exceptions() always returns zero.
• __cxa_decrement_exception_refcount(ptr)/__cxa_increment_refcount(ptr) terminate if ptr != nullptr.
• __cxa_primary_exception() returns nullptr.
• __cxa_rethrow_primary_exception(ptr) returns as to hit the terminate call in libc++.

This way we are not conflating building libc++ without exceptions with building libc++ against an ABI library which doesn't provide the exception handling API.

That too would work for us. I agree this is a bit more cleaner since it does not involve changes to libc++, so I will spin a patch for it on top of D20677.

/ Asiri

[rmaprath]

Updated D20677 with the necessary changes. This patch is no longer required.

src/exception.cpp

 #endif // !__EMSCRIPTEN__
 #endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION)
 
 #if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__)
 bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
 
 int uncaught_exceptions() _NOEXCEPT
 {
+#ifdef _LIBCPP_NO_EXCEPTIONS
+    return 0;
+#endif
 #if defined(__APPLE__) || defined(_LIBCPPABI_VERSION)
    // on Darwin, there is a helper function so __cxa_get_globals is private
 # if _LIBCPPABI_VERSION > 1101
     return __cxa_uncaught_exceptions();
 # else
     return __cxa_uncaught_exception() ? 1 : 0;
 # endif
 #else  // __APPLE__

 
 _LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
 
 #endif
 
 exception_ptr::~exception_ptr() _NOEXCEPT
 {
 #if HAVE_DEPENDENT_EH_ABI
+#   ifndef _LIBCPP_NO_EXCEPTIONS
     __cxa_decrement_exception_refcount(__ptr_);
+#   endif
 #elif defined(__GLIBCXX__)
     reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
 #else
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 
 exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
     : __ptr_(other.__ptr_)
 {
 #if HAVE_DEPENDENT_EH_ABI
+#   ifndef _LIBCPP_NO_EXCEPTIONS
     __cxa_increment_exception_refcount(__ptr_);
+#   endif
 #elif defined(__GLIBCXX__)
     new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
         reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
 #else
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 
 exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
 {
 #if HAVE_DEPENDENT_EH_ABI
     if (__ptr_ != other.__ptr_)
     {
+#       ifndef _LIBCPP_NO_EXCEPTIONS
         __cxa_increment_exception_refcount(other.__ptr_);
         __cxa_decrement_exception_refcount(__ptr_);
+#       endif
         __ptr_ = other.__ptr_;
     }
     return *this;
 #elif defined(__GLIBCXX__)
     *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
         reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
     return *this;
 #else

 
 exception_ptr current_exception() _NOEXCEPT
 {
 #if HAVE_DEPENDENT_EH_ABI
     // be nicer if there was a constructor that took a ptr, then
     // this whole function would be just:
     //    return exception_ptr(__cxa_current_primary_exception());
     exception_ptr ptr;
+#ifndef _LIBCPP_NO_EXCEPTIONS
     ptr.__ptr_ = __cxa_current_primary_exception();
+#endif
     return ptr;
 #else
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING( "exception_ptr not yet implemented" )
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 
 #endif  // !__GLIBCXX__
 
 _LIBCPP_NORETURN
 void rethrow_exception(exception_ptr p)
 {
 #if HAVE_DEPENDENT_EH_ABI
+#ifndef _LIBCPP_NO_EXCEPTIONS
     __cxa_rethrow_primary_exception(p.__ptr_);
+#endif
     // if p.__ptr_ is NULL, above returns so we terminate
     terminate();
 #elif defined(__GLIBCXX__)
     rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
 #else
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING("exception_ptr not yet implemented")
 #   else
 #       warning exception_ptr not yet implemented
 #   endif
     fprintf(stderr, "exception_ptr not yet implemented\n");
     ::abort();
 #endif
 }
 } // std