[libc++] Use _LIBCPP_VERBOSE_ABORT in a few remaining __throw_FOO functions

[ldionne]

Summary

This provides better error messages when the program terminates due to
an exception being thrown in -fno-exceptions mode. Those seem to have
been missed in https://reviews.llvm.org/D141222.

[ldionne]

Adjust error messages.

[ldionne]

Rebase and poke CI.

[philnik]

libcxx/src/system_error.cpp

288

Maybe we should add an overload for std::error_code and replace uses, so we can use error_code::message() for a nicer error message.

[Mordante]

LGTM modulo one nit.

libcxx/include/__format/format_error.h

15

I assume this header is no longer needed. At least for format and the dylib we can remove them unconditionally.

[ldionne]

libcxx/src/system_error.cpp

288

Would you put that into the dylib? So you'd do this from uses:

if (__m_ == nullptr)
    __throw_system_error(std::make_error_code(std::errc::operation_not_permitted), "unique_lock::lock: references null mutex");

// instead of

if (__m_ == nullptr)
    __throw_system_error(EPERM, "unique_lock::lock: references null mutex");

and then the overload would look like this?

_LIBCPP_NORETURN void __throw_system_error(error_code const& __code, char const* __what_arg) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
    throw system_error(__code, what_arg);
#else
    _LIBCPP_VERBOSE_ABORT("system_error was thrown in -fno-exceptions mode with error_code \"%s\" and message \"%s\"", __code.message(), what_arg);
#endif
}

[ldionne]

Address comment.

[philnik]

libcxx/src/system_error.cpp

288

Yeah, something like that. I wouldn't bother putting it in the dylib though. I don't even know why the have __throw_system_error in the dylib.

[ldionne]

Poke CI

[ldionne]

Adjust transitive includes

libcxx/include/__format/format_error.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___FORMAT_FORMAT_ERROR_H
 #define _LIBCPP___FORMAT_FORMAT_ERROR_H
 
 #include <__config>
+#include <__verbose_abort>
 #include <cstdlib>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 };
 _LIBCPP_DIAGNOSTIC_POP
 
 _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void
 __throw_format_error(const char* __s) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   throw format_error(__s);
 #else
-  (void)__s;
-  _VSTD::abort();
+  _LIBCPP_VERBOSE_ABORT("format_error was thrown in -fno-exceptions mode with message \"%s\"", __s);
 #endif
 }
 
 #endif //_LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_ERROR_H

libcxx/src/locale.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__utility/unreachable.h>
+#include <__verbose_abort>
 #include <algorithm>
 #include <clocale>
 #include <codecvt>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <locale>
 #include <string>
countof(const T * const begin, const T * const end)
     return static_cast<size_t>(end - begin);
 }
 
 _LIBCPP_NORETURN static void __throw_runtime_error(const string &msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw runtime_error(msg);
 #else
-    (void)msg;
-    _VSTD::abort();
+    _LIBCPP_VERBOSE_ABORT("runtime_error was thrown in -fno-exceptions mode with message \"%s\"", msg.c_str());
 #endif
 }
 
 }
 
 string
 build_name(const string& other, const string& one, locale::category c) {
     if (other == "*" || one == "*")

 
 void __do_nothing(void*) {}
 
 void __throw_runtime_error(const char* msg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw runtime_error(msg);
 #else
-    (void)msg;
-    _VSTD::abort();
+    _LIBCPP_VERBOSE_ABORT("runtime_error was thrown in -fno-exceptions mode with message \"%s\"", msg);
 #endif
 }
 
                            template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
 _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;)
 
                            template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
 _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;)

libcxx/src/string.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__assert>
 #include <cerrno>
 #include <charconv>
 #include <cstdlib>
 #include <limits>
 #include <stdexcept>
-#include <stdio.h>
 #include <string>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

 #endif
 #undef _LIBCPP_EXTERN_TEMPLATE_DEFINE
 
 template string operator+<char, char_traits<char>, allocator<char>>(char const*, string const&);
 
 namespace
 {
 
-template<typename T>
-inline void throw_helper(const string& msg) {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw T(msg);
-#else
-    fprintf(stderr, "%s\n", msg.c_str());
-    _VSTD::abort();
-#endif
-}
-
 inline void throw_from_string_out_of_range(const string& func) {
-    throw_helper<out_of_range>(func + ": out of range");
+    std::__throw_out_of_range((func + ": out of range").c_str());
 }
 
 inline void throw_from_string_invalid_arg(const string& func) {
-    throw_helper<invalid_argument>(func + ": no conversion");
+    std::__throw_invalid_argument((func + ": no conversion").c_str());
 }
 
 // as_integer
 
 template<typename V, typename S, typename F>
 inline V as_integer_helper(const string& func, const S& str, size_t* idx, int base, F f) {
     typename S::value_type* ptr = nullptr;
     const typename S::value_type* const p = str.c_str();

libcxx/src/system_error.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__config>
 #ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
 #   define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS
 #endif
 
 #include <__assert>
+#include <__verbose_abort>
 #include <cerrno>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <string.h>
 #include <system_error>
 

 {
 }
 
 system_error::~system_error() noexcept
 {
 }
 
 void
 __throw_system_error(int ev, const char* what_arg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw system_error(error_code(ev, system_category()), what_arg);
 #else
-    (void)ev;
-    (void)what_arg;
-    _VSTD::abort();
+    _LIBCPP_VERBOSE_ABORT("system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD