[libc++] Use __verbose_abort instead of std::abort in __throw_ functions

[philnik]

Summary

This results in proper error messages instead of just an abort.

[philnik]

Try to fix CI

[Mordante]

I really like this change! I think it would be good to let @ldionne to have a look too.

[huixie90]

libcxx/include/__expected/expected.h

53

I wonder if we can remove this now. (Maybe we need to remove the public dependency too)

[philnik]

libcxx/include/__expected/expected.h

53

I've already got a patch for that locally.

[ldionne]

This is great. I actually thought I had a local patch doing this, but I can't find it. At least it's been on my mind for a while, and in fact it was the main reason why I generalized from __libcpp_assertion_handler to __libcpp_verbose_abort.

One thing to keep in mind is that calling __libcpp_verbose_abort may generate larger code than calling abort() did, which could be annoying for folks compiling with -fno-exceptions. I think we may want to e.g. mark __libcpp_verbose_abort as cold to help the compiler optimize it better when possible, but at the end of the day, the calling convention for variadic functions on some architectures like arm64 isn't super size-friendly. I don't think this should prevent us from making this change, but size regressions should be on our radar.

Pinging vendors just for awareness, in particular I think Google doesn't use exceptions so they may be able to give us some early feedback on this change.

libcxx/include/future

536–537

You're using the %s format specifier but you're passing a std::error_code, which seems wrong.

537

libcxx/include/ios

455

[ldionne]

Oh actually I had created D131619, that's what I was looking for.

[ldionne]

In D141222#4037293, @ldionne wrote:

Oh actually I had created D131619, that's what I was looking for.

Looking at that patch again, I feel like the additional

_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline
void __exception_abort(char const* __file, int __line, char const* __msg) {
  std::__libcpp_verbose_abort("%s:%d: Exception thrown with exceptions disabled: %s\n", __file, __line, __msg);
}

and

_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline
void __assertion_abort(char const* __file, int __line, char const* __expr, char const* __msg) {
  std::__libcpp_verbose_abort("%s:%d: Assertion %s failed: %s\n", __file, __line, __expr, __msg);
}

did make sense, no?

[philnik]

Address comments

[philnik]

In D141222#4037026, @ldionne wrote:

This is great. I actually thought I had a local patch doing this, but I can't find it. At least it's been on my mind for a while, and in fact it was the main reason why I generalized from __libcpp_assertion_handler to __libcpp_verbose_abort.

One thing to keep in mind is that calling __libcpp_verbose_abort may generate larger code than calling abort() did, which could be annoying for folks compiling with -fno-exceptions. I think we may want to e.g. mark __libcpp_verbose_abort as cold to help the compiler optimize it better when possible, but at the end of the day, the calling convention for variadic functions on some architectures like arm64 isn't super size-friendly. I don't think this should prevent us from making this change, but size regressions should be on our radar.

The compiler already considers [[noreturn]] functions to be extremely unlikely: https://godbolt.org/z/9xoYWfK4T. So I don't think we have to give the compiler extra hints.

In D141222#4037300, @ldionne wrote:

In D141222#4037293, @ldionne wrote:

Oh actually I had created D131619, that's what I was looking for.

Looking at that patch again, I feel like the additional

_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline
void __exception_abort(char const* __file, int __line, char const* __msg) {
  std::__libcpp_verbose_abort("%s:%d: Exception thrown with exceptions disabled: %s\n", __file, __line, __msg);
}

and

_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline
void __assertion_abort(char const* __file, int __line, char const* __expr, char const* __msg) {
  std::__libcpp_verbose_abort("%s:%d: Assertion %s failed: %s\n", __file, __line, __expr, __msg);
}

did make sense, no?

I don't think so. This would only give people the __throw_whatever functions, which seems not exactly useful.

[ldionne]

LGTM w/ passing CI. Please ping me again if you have to change the patch non-trivially to make CI pass.

[philnik]

Try to fix CI

[philnik]

Next try

[philnik]

Try to fix CI

[bulbazord]

I believe this change broke the LLDB tests. Can you please fix or revert?

Details: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/52383/

======================================================================
FAIL: test_dsym (TestDbgInfoContentVectorFromStdModule.TestDbgInfoContentVector)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 1707, in test_method
    return attrvalue(self)
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 159, in wrapper
    return func(*args, **kwargs)
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 159, in wrapper
    return func(*args, **kwargs)
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/commands/expression/import-std-module/vector-dbg-info-content/TestDbgInfoContentVectorFromStdModule.py", line 64, in test
    self.expect_expr("a.at(0).a", result_type="int", result_value="2")
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 2463, in expect_expr
    value_check.check_value(self, eval_result, str(eval_result))
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 287, in check_value
    test_base.assertSuccess(val.GetError())
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 2499, in assertSuccess
    self.fail(self._formatMessage(msg,
AssertionError: 'expression failed to parse:
error: Couldn't lookup symbols:
  __ZNSt3__122__libcpp_verbose_abortEPKcz
' is not success
Config=x86_64-/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/clang
======================================================================
FAIL: test_dwarf (TestDbgInfoContentVectorFromStdModule.TestDbgInfoContentVector)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 1707, in test_method
    return attrvalue(self)
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 159, in wrapper
    return func(*args, **kwargs)
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 159, in wrapper
    return func(*args, **kwargs)
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/test/API/commands/expression/import-std-module/vector-dbg-info-content/TestDbgInfoContentVectorFromStdModule.py", line 64, in test
    self.expect_expr("a.at(0).a", result_type="int", result_value="2")
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 2463, in expect_expr
    value_check.check_value(self, eval_result, str(eval_result))
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 287, in check_value
    test_base.assertSuccess(val.GetError())
  File "/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 2499, in assertSuccess
    self.fail(self._formatMessage(msg,
AssertionError: 'expression failed to parse:
error: Couldn't lookup symbols:
  __ZNSt3__122__libcpp_verbose_abortEPKcz
' is not success
Config=x86_64-/Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/clang
----------------------------------------------------------------------

[jgorbe]

There's a comment next to the __libcpp_verbose_abort definition that says

// This function should never be called directly from the code -- it should only be called through
// the _LIBCPP_VERBOSE_ABORT macro.

Does this apply here? For context, we have a libc-free project that uses variant and optional and this change pulls in vfprintf. We'd like to just provide our own _LIBCPP_VERBOSE_ABORT, or build with -D_LIBCPP_HAS_NO_VERBOSE_ABORT_IN_LIBRARY but it doesn't look like we can do that if the code calls __libcpp_verbose_abort directly.

[abrachet]

In D141222#4197878, @jgorbe wrote:

There's a comment next to the __libcpp_verbose_abort definition that says

// This function should never be called directly from the code -- it should only be called through
// the _LIBCPP_VERBOSE_ABORT macro.

Does this apply here? For context, we have a libc-free project that uses variant and optional and this change pulls in vfprintf. We'd like to just provide our own _LIBCPP_VERBOSE_ABORT, or build with -D_LIBCPP_HAS_NO_VERBOSE_ABORT_IN_LIBRARY but it doesn't look like we can do that if the code calls __libcpp_verbose_abort directly.

+1 we are running into this too

[fdeazeve]

Should we revert this?

[smeenai]

D146227 is a fix diff that's up and waiting for CI.

libcxx/include/__expected/expected.h

 #include <__type_traits/negation.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/exception_guard.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
+#include <__verbose_abort>
 #include <cstdlib> // for std::abort
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __expected {
 
 template <class _Err, class _Arg>
 _LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) {
 #  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   throw bad_expected_access<_Err>(std::forward<_Arg>(__arg));
 #  else
   (void)__arg;
-  std::abort();
+  std::__libcpp_verbose_abort("bad_expected_access was thrown in -fno-exceptions mode");
 #  endif
 }
 
 } // namespace __expected
 
 template <class _Tp, class _Err>
 class expected {
   static_assert(

libcxx/include/__filesystem/filesystem_error.h

 #ifndef _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
 #define _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
 
 #include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <__memory/shared_ptr.h>
 #include <__utility/forward.h>
+#include <__verbose_abort>
 #include <iosfwd>
 #include <new>
 #include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

 template <class... _Args>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 void __throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(_VSTD::forward<_Args>(__args)...);
 }
 #else
 void __throw_filesystem_error(_Args&&...) {
-  _VSTD::abort();
+    std::__libcpp_verbose_abort("filesystem_error was thrown in -fno-exceptions mode");
 }
 #endif
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H

libcxx/include/__functional/function.h

 #include <__type_traits/aligned_storage.h>
 #include <__type_traits/is_trivially_copy_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
 #include <__type_traits/strip_signature.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
+#include <__verbose_abort>
 #include <exception>
 #include <new>
 #include <tuple>
 #include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

 _LIBCPP_DIAGNOSTIC_POP
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_function_call()
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_function_call();
 #else
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("bad_function_call was thrown in -fno-exceptions mode");
 #endif
 }
 
 template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined
 
 namespace __function
 {
 

libcxx/include/__memory/shared_ptr.h

 #include <__type_traits/nat.h>
 #include <__type_traits/negation.h>
 #include <__type_traits/remove_extent.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
+#include <__verbose_abort>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
 #include <new>
 #include <stdexcept>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <__atomic/memory_order.h>

 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_weak_ptr()
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_weak_ptr();
 #else
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("bad_weak_ptr was thrown in -fno-exceptions mode");
 #endif
 }
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr;
 
 class _LIBCPP_TYPE_VIS __shared_count
 {
     __shared_count(const __shared_count&);

libcxx/include/any

 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
+#include <__verbose_abort>
 #include <cstdlib>
 #include <initializer_list>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
 void __throw_bad_any_cast()
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_any_cast();
 #else
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("bad_any_cast was thrown in -fno-exceptions mode");
 #endif
 }
 
 // Forward declarations
 class _LIBCPP_TEMPLATE_VIS any;
 
 template <class _ValueType>
 _LIBCPP_INLINE_VISIBILITY

libcxx/include/future

 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
 #include <__type_traits/aligned_storage.h>
 #include <__type_traits/alignment_of.h>
 #include <__type_traits/strip_signature.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__verbose_abort>
 #include <exception>
 #include <mutex>
 #include <new>
 #include <system_error>
 #include <thread>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 _LIBCPP_AVAILABILITY_FUTURE_ERROR
 #endif
 void __throw_future_error(future_errc __ev)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw future_error(make_error_code(__ev));
 #else
-    ((void)__ev);
-    _VSTD::abort();
+    (void)__ev;
+    std::__libcpp_verbose_abort("future_error was thrown in -fno-exceptions mode");
 #endif
 }
 
 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
     : public __shared_count
 {
 protected:
     exception_ptr __exception_;

libcxx/include/ios

 #if defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   error "The iostreams library is not supported since libc++ has been configured without support for localization."
 #endif
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__ios/fpos.h>
 #include <__locale>
 #include <__utility/swap.h>
+#include <__verbose_abort>
 #include <system_error>
 #include <version>
 
 // standard-mandated includes
 
 // [ios.syn]
 #include <iosfwd>
 
public:
     ~failure() _NOEXCEPT override;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_failure(char const* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw ios_base::failure(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("ios_base::failure was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 class _LIBCPP_TYPE_VIS ios_base::Init
 {
 public:
     Init();
     ~Init();

libcxx/include/new

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cv.h>
+#include <__verbose_abort>
 #include <cstddef>
 #include <cstdlib>
 #include <exception>
 #include <version>
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <new.h>
 #endif

 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_array_new_length()
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_array_new_length();
 #else
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("bad_array_new_length was thrown in -fno-exceptions mode");
 #endif
 }
 
 #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && \
     !defined(_LIBCPP_ABI_VCRUNTIME)
 #ifndef _LIBCPP_CXX03_LANG
 enum class _LIBCPP_ENUM_VIS align_val_t : size_t { };
 #else

libcxx/include/optional

 #include <__type_traits/is_trivially_move_assignable.h>
 #include <__type_traits/is_trivially_move_constructible.h>
 #include <__type_traits/negation.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
+#include <__verbose_abort>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <version>
 
 // standard-mandated includes
 
 // [optional.syn]

 
 _LIBCPP_NORETURN
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
 void __throw_bad_optional_access() {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         throw bad_optional_access();
 #else
-        _VSTD::abort();
+    std::__libcpp_verbose_abort("bad_optional_access was thrown in -fno-exceptions mode");
 #endif
 }
 
 struct nullopt_t
 {
     struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; };
     _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
 };

libcxx/include/regex

 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__type_traits/is_swappable.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
+#include <__verbose_abort>
 #include <deque>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include <version>
 
 // standard-mandated includes
 

 
 template <regex_constants::error_type _Ev>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_regex_error()
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw regex_error(_Ev);
 #else
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("regex_error was thrown in -fno-exceptions mode");
 #endif
 }
 
 template <class _CharT>
 struct _LIBCPP_TEMPLATE_VIS regex_traits
 {
 public:
     typedef _CharT                  char_type;

libcxx/include/stdexcept

 };
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__verbose_abort>
 #include <cstdlib>
 #include <exception>
 #include <iosfwd>  // for string forward decl
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_logic_error(const char*__msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw logic_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("logic_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_domain_error(const char*__msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw domain_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("domain_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_invalid_argument(const char*__msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw invalid_argument(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("invalid_argument was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_length_error(const char*__msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw length_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("length_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_out_of_range(const char*__msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw out_of_range(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("out_of_range was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_range_error(const char*__msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw range_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("range_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_overflow_error(const char*__msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw overflow_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("overflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_underflow_error(const char*__msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw underflow_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("underflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STDEXCEPT

libcxx/include/typeinfo

 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__type_traits/is_constant_evaluated.h>
+#include <__verbose_abort>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <exception>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_cast()
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_cast();
 #else
-    _VSTD::abort();
+    std::__libcpp_verbose_abort("bad_cast was thrown in -fno-exceptions mode");
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <type_traits>
 #endif
 
 #endif // __LIBCPP_TYPEINFO

libcxx/include/variant

 #include <__type_traits/type_identity.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__variant/monostate.h>
+#include <__verbose_abort>
 #include <exception>
 #include <initializer_list>
 #include <limits>
 #include <new>
 #include <tuple>
 #include <version>
 
 // standard-mandated includes

 
 _LIBCPP_NORETURN
 inline _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 void __throw_bad_variant_access() {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
         throw bad_variant_access();
 #else
-        _VSTD::abort();
+    std::__libcpp_verbose_abort("bad_variant_access was thrown in -fno-exceptions mode");
 #endif
 }
 
 template <class... _Types>
 class _LIBCPP_TEMPLATE_VIS variant;
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS variant_size;