[libc++] Use __verbose_abort in additional contexts

[ldionne]

Summary

Instead of only using __verbose_abort to handle assertions, also use
it to handle exceptions thrown under -fno-exceptions and when
std::unreachable() is called. This will provide a strictly better
user experience in these cases, since we will provide additional
information in the logs over a simple std::abort().

[philnik]

libcxx/include/__filesystem/filesystem_error.h

94

Might as well remove _VSTD while you're at it.

libcxx/include/__verbose_abort

59

I don't think file and line are useful here. They will just be the file and line of the throw wrapper.

67

Why do you have this as an extra macro? It's used in just a single place.

[ldionne]

Abandoning since this was basically done in D141222.

libcxx/include/__assert

 #if _LIBCPP_ENABLE_ASSERTIONS != 0 && _LIBCPP_ENABLE_ASSERTIONS != 1
 # error "_LIBCPP_ENABLE_ASSERTIONS must be set to 0 or 1"
 #endif
 
 #if _LIBCPP_ENABLE_ASSERTIONS
 # define _LIBCPP_ASSERT(expression, message)                                        \
     (__builtin_expect(static_cast<bool>(expression), 1) ?                           \
       (void)0 :                                                                     \
-      ::std::__libcpp_verbose_abort("%s:%d: assertion %s failed: %s", __FILE__, __LINE__, #expression, message))
+      _LIBCPP_ASSERTION_ABORT(expression, message))
 #elif !defined(_LIBCPP_ASSERTIONS_DISABLE_ASSUME) && __has_builtin(__builtin_assume)
 # define _LIBCPP_ASSERT(expression, message)                                        \
     (_LIBCPP_DIAGNOSTIC_PUSH                                                        \
     _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wassume")                                    \
     __builtin_assume(static_cast<bool>(expression))                                 \
     _LIBCPP_DIAGNOSTIC_POP)
 #else
 # define _LIBCPP_ASSERT(expression, message) ((void)0)
 #endif
 
 #endif // _LIBCPP___ASSERT

libcxx/include/__filesystem/filesystem_error.h

 
 template <class... _Args>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 void __throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(_VSTD::forward<_Args>(__args)...);
 }
 #else
-void __throw_filesystem_error(_Args&&...) {
-  _VSTD::abort();
+void __throw_filesystem_error(_Args&&... __args) {
+  _LIBCPP_EXCEPTION_ABORT(filesystem_error(_VSTD::forward<_Args>(__args)...).what());
 }
 #endif
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H

libcxx/include/__functional/function.h

 _LIBCPP_DIAGNOSTIC_POP
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_function_call()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_function_call();
 #else
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT("bad_function_call");
 #endif
 }
 
 #if defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && __has_attribute(deprecated)
 #   define _LIBCPP_DEPRECATED_CXX03_FUNCTION \
         __attribute__((deprecated("Using std::function in C++03 is not supported anymore. Please upgrade to C++11 or later, or use a different type")))
 #else
 #   define _LIBCPP_DEPRECATED_CXX03_FUNCTION /* nothing */

libcxx/include/__memory/shared_ptr.h

 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_weak_ptr()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_weak_ptr();
 #else
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT("bad_weak_ptr");
 #endif
 }
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr;
 
 class _LIBCPP_TYPE_VIS __shared_count
 {
     __shared_count(const __shared_count&);

libcxx/include/__utility/unreachable.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___UTILITY_UNREACHABLE_H
 #define _LIBCPP___UTILITY_UNREACHABLE_H
 
 #include <__config>
-#include <cstdlib>
+#include <__verbose_abort>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __libcpp_unreachable()
 {
 #if __has_builtin(__builtin_unreachable)
   __builtin_unreachable();
 #else
-  std::abort();
+  std::__libcpp_verbose_abort("__libcpp_unreachable reached\n");
 #endif
 }
 
 #if _LIBCPP_STD_VER > 20
 
 [[noreturn]] _LIBCPP_HIDE_FROM_ABI inline void unreachable() { __libcpp_unreachable(); }
 
 #endif // _LIBCPP_STD_VER > 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif

libcxx/include/__verbose_abort

 
 _LIBCPP_NORETURN _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 2)
 void __libcpp_verbose_abort(const char *__format, ...);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif
 
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// Define utilities to abort with specific semantics.
+//
+// This is used to provide additional useful information in cases where we want to abort the program.
+
+// Handler for when an exception would be thrown but the code is compiled with -fno-exceptions
+#define _LIBCPP_EXCEPTION_ABORT(__msg)                                                                              \
+    ::std::__exception_abort(__FILE__, __LINE__, __msg)
+
+_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);
+}
+
+// Handler for when an assertion fails
+#define _LIBCPP_ASSERTION_ABORT(__expr, __msg)                                                                      \
+    ::std::__assertion_abort(__FILE__, __LINE__, #__expr, __msg)
+
+_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);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
 #endif // _LIBCPP___VERBOSE_ABORT

libcxx/include/any

 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
 void __throw_bad_any_cast()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_any_cast();
 #else
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT("bad_any_cast");
 #endif
 }
 
 // Forward declarations
 class _LIBCPP_TEMPLATE_VIS any;
 
 template <class _ValueType>
 _LIBCPP_INLINE_VISIBILITY

libcxx/include/future

 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 _LIBCPP_AVAILABILITY_FUTURE_ERROR
 #endif
 void __throw_future_error(future_errc __ev)
 {
+    std::error_code __ec = make_error_code(__ev);
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    throw future_error(make_error_code(__ev));
+    throw future_error(__ec);
 #else
-    ((void)__ev);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__ec.message().c_str());
 #endif
 }
 
 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
     : public __shared_count
 {
 protected:
     exception_ptr __exception_;

libcxx/include/ios

public:
     virtual ~failure() _NOEXCEPT;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_failure(char const* __msg) {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw ios_base::failure(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 class _LIBCPP_TYPE_VIS ios_base::Init
 {
 public:
     Init();
     ~Init();

libcxx/include/new

 _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_NO_EXCEPTIONS
     throw bad_array_new_length();
 #else
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT("bad_array_new_length");
 #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

 
 _LIBCPP_NORETURN
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
 void __throw_bad_optional_access() {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw bad_optional_access();
 #else
-        _VSTD::abort();
+        _LIBCPP_EXCEPTION_ABORT("bad_optional_access");
 #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

 
 template <regex_constants::error_type _Ev>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_regex_error()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw regex_error(_Ev);
 #else
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(regex_error(_Ev).what());
 #endif
 }
 
 template <class _CharT>
 struct _LIBCPP_TEMPLATE_VIS regex_traits
 {
 public:
     typedef _CharT                  char_type;

libcxx/include/stdexcept

 _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_NO_EXCEPTIONS
     throw logic_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_domain_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw domain_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_invalid_argument(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw invalid_argument(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_length_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw length_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_out_of_range(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw out_of_range(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_range_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw range_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_overflow_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw overflow_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_underflow_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw underflow_error(__msg);
 #else
-    ((void)__msg);
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(__msg);
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STDEXCEPT

libcxx/include/typeinfo

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_cast()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_cast();
 #else
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT("bad_cast");
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // __LIBCPP_TYPEINFO

libcxx/include/variant

 
 _LIBCPP_NORETURN
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 void __throw_bad_variant_access() {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw bad_variant_access();
 #else
-        _VSTD::abort();
+        _LIBCPP_EXCEPTION_ABORT("bad_variant_access");
 #endif
 }
 
 template <class... _Types>
 class _LIBCPP_TEMPLATE_VIS variant;
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS variant_size;

libcxx/src/locale.cpp

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_NO_EXCEPTIONS
     throw runtime_error(msg);
 #else
-    (void)msg;
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(msg.c_str());
 #endif
 }
 
 }
 
 const locale::category locale::none;
 const locale::category locale::collate;
 const locale::category locale::ctype;

 
 void __do_nothing(void*) {}
 
 void __throw_runtime_error(const char* msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw runtime_error(msg);
 #else
-    (void)msg;
-    _VSTD::abort();
+    _LIBCPP_EXCEPTION_ABORT(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>;)