[libc++] Clean up mess around __throw_runtime_error

[ldionne]

Summary

We were defining the function in locale.cpp, and we actually had two
overloads for it. This is pretty confusing given that one was static
and not exported from the dylib, and the other one was. Instead, use
the vanilla __throw_runtime_error function everywhere even though that
adds a tiny bit of code duplication.

[ldionne]

Rebase.

[Mordante]

LGTM!

[ldionne]

CI failure is AIX -- it reports a failure even though it's marked as soft fail. I'll have to fix that.

Merging.

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>

 inline
 _LIBCPP_CONSTEXPR
 size_t
 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
-    _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 == "*")
         return "*";
     if (c == locale::none || other == one)
         return other;

 
 // template <> class collate_byname<char>
 
 collate_byname<char>::collate_byname(const char* n, size_t refs)
     : collate<char>(refs),
       __l_(newlocale(LC_ALL_MASK, n, 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("collate_byname<char>::collate_byname"
-                            " failed to construct for " + string(n));
+        __throw_runtime_error(("collate_byname<char>::collate_byname"
+                               " failed to construct for " + string(n)).c_str());
 }
 
 collate_byname<char>::collate_byname(const string& name, size_t refs)
     : collate<char>(refs),
       __l_(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("collate_byname<char>::collate_byname"
-                            " failed to construct for " + name);
+        __throw_runtime_error(("collate_byname<char>::collate_byname"
+                               " failed to construct for " + name).c_str());
 }
 
 collate_byname<char>::~collate_byname()
 {
     freelocale(__l_);
 }
 
 int

 // template <> class collate_byname<wchar_t>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
     : collate<wchar_t>(refs),
       __l_(newlocale(LC_ALL_MASK, n, 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
-                            " failed to construct for " + string(n));
+        __throw_runtime_error(("collate_byname<wchar_t>::collate_byname(size_t refs)"
+                               " failed to construct for " + string(n)).c_str());
 }
 
 collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
     : collate<wchar_t>(refs),
       __l_(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
-                            " failed to construct for " + name);
+        __throw_runtime_error(("collate_byname<wchar_t>::collate_byname(size_t refs)"
+                               " failed to construct for " + name).c_str());
 }
 
 collate_byname<wchar_t>::~collate_byname()
 {
     freelocale(__l_);
 }
 
 int

 
 // template <> class ctype_byname<char>
 
 ctype_byname<char>::ctype_byname(const char* name, size_t refs)
     : ctype<char>(0, false, refs),
       __l_(newlocale(LC_ALL_MASK, name, 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("ctype_byname<char>::ctype_byname"
-                            " failed to construct for " + string(name));
+        __throw_runtime_error(("ctype_byname<char>::ctype_byname"
+                               " failed to construct for " + string(name)).c_str());
 }
 
 ctype_byname<char>::ctype_byname(const string& name, size_t refs)
     : ctype<char>(0, false, refs),
       __l_(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("ctype_byname<char>::ctype_byname"
-                            " failed to construct for " + name);
+        __throw_runtime_error(("ctype_byname<char>::ctype_byname"
+                               " failed to construct for " + name).c_str());
 }
 
 ctype_byname<char>::~ctype_byname()
 {
     freelocale(__l_);
 }
 
 char

 // template <> class ctype_byname<wchar_t>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
     : ctype<wchar_t>(refs),
       __l_(newlocale(LC_ALL_MASK, name, 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
-                            " failed to construct for " + string(name));
+        __throw_runtime_error(("ctype_byname<wchar_t>::ctype_byname"
+                               " failed to construct for " + string(name)).c_str());
 }
 
 ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
     : ctype<wchar_t>(refs),
       __l_(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
-                            " failed to construct for " + name);
+        __throw_runtime_error(("ctype_byname<wchar_t>::ctype_byname"
+                               " failed to construct for " + name).c_str());
 }
 
 ctype_byname<wchar_t>::~ctype_byname()
 {
     freelocale(__l_);
 }
 
 bool

 {
 }
 
 codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
     : locale::facet(refs),
       __l_(newlocale(LC_ALL_MASK, nm, 0))
 {
     if (__l_ == 0)
-        __throw_runtime_error("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
-                            " failed to construct for " + string(nm));
+        __throw_runtime_error(("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
+                               " failed to construct for " + string(nm)).c_str());
 }
 
 codecvt<wchar_t, char, mbstate_t>::~codecvt()
 {
     if (__l_ != _LIBCPP_GET_C_LOCALE)
         freelocale(__l_);
 }
 

 void
 numpunct_byname<char>::__init(const char* nm)
 {
     typedef numpunct<char> base;
     if (strcmp(nm, "C") != 0)
     {
         __libcpp_unique_locale loc(nm);
         if (!loc)
-            __throw_runtime_error("numpunct_byname<char>::numpunct_byname"
-                                " failed to construct for " + string(nm));
+            __throw_runtime_error(("numpunct_byname<char>::numpunct_byname"
+                                   " failed to construct for " + string(nm)).c_str());
 
         lconv* lc = __libcpp_localeconv_l(loc.get());
         if (!checked_string_to_char_convert(__decimal_point_, lc->decimal_point,
                                             loc.get()))
             __decimal_point_ = base::do_decimal_point();
         if (!checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep,
                                             loc.get()))
             __thousands_sep_ = base::do_thousands_sep();

 
 void
 numpunct_byname<wchar_t>::__init(const char* nm)
 {
     if (strcmp(nm, "C") != 0)
     {
         __libcpp_unique_locale loc(nm);
         if (!loc)
-            __throw_runtime_error("numpunct_byname<wchar_t>::numpunct_byname"
-                                " failed to construct for " + string(nm));
+            __throw_runtime_error(("numpunct_byname<wchar_t>::numpunct_byname"
+                                   " failed to construct for " + string(nm)).c_str());
 
         lconv* lc = __libcpp_localeconv_l(loc.get());
         checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point,
                                         loc.get());
         checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep,
                                         loc.get());
         __grouping_ = lc->grouping;
         // localization for truename and falsename is not available

 #endif
 
 // time_get_byname
 
 __time_get::__time_get(const char* nm)
     : __loc_(newlocale(LC_ALL_MASK, nm, 0))
 {
     if (__loc_ == 0)
-        __throw_runtime_error("time_get_byname"
-                            " failed to construct for " + string(nm));
+        __throw_runtime_error(("time_get_byname failed to construct for " + string(nm)).c_str());
 }
 
 __time_get::__time_get(const string& nm)
     : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
 {
     if (__loc_ == 0)
-        __throw_runtime_error("time_get_byname"
-                            " failed to construct for " + nm);
+        __throw_runtime_error(("time_get_byname failed to construct for " + nm).c_str());
 }
 
 __time_get::~__time_get()
 {
     freelocale(__loc_);
 }
 
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-field-initializers")

 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 // time_put
 
 __time_put::__time_put(const char* nm)
     : __loc_(newlocale(LC_ALL_MASK, nm, 0))
 {
     if (__loc_ == 0)
-        __throw_runtime_error("time_put_byname"
-                            " failed to construct for " + string(nm));
+        __throw_runtime_error(("time_put_byname failed to construct for " + string(nm)).c_str());
 }
 
 __time_put::__time_put(const string& nm)
     : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
 {
     if (__loc_ == 0)
-        __throw_runtime_error("time_put_byname"
-                            " failed to construct for " + nm);
+        __throw_runtime_error(("time_put_byname failed to construct for " + nm).c_str());
 }
 
 __time_put::~__time_put()
 {
     if (__loc_ != _LIBCPP_GET_C_LOCALE)
         freelocale(__loc_);
 }
 

 
 template<>
 void
 moneypunct_byname<char, false>::init(const char* nm)
 {
     typedef moneypunct<char, false> base;
     __libcpp_unique_locale loc(nm);
     if (!loc)
-        __throw_runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
+        __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
 
     lconv* lc = __libcpp_localeconv_l(loc.get());
     if (!checked_string_to_char_convert(__decimal_point_,
                                         lc->mon_decimal_point,
                                         loc.get()))
       __decimal_point_ = base::do_decimal_point();
     if (!checked_string_to_char_convert(__thousands_sep_,
                                         lc->mon_thousands_sep,

 
 template<>
 void
 moneypunct_byname<char, true>::init(const char* nm)
 {
     typedef moneypunct<char, true> base;
     __libcpp_unique_locale loc(nm);
     if (!loc)
-        __throw_runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
+        __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
 
     lconv* lc = __libcpp_localeconv_l(loc.get());
     if (!checked_string_to_char_convert(__decimal_point_,
                                         lc->mon_decimal_point,
                                         loc.get()))
       __decimal_point_ = base::do_decimal_point();
     if (!checked_string_to_char_convert(__thousands_sep_,
                                         lc->mon_thousands_sep,

 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template<>
 void
 moneypunct_byname<wchar_t, false>::init(const char* nm)
 {
     typedef moneypunct<wchar_t, false> base;
     __libcpp_unique_locale loc(nm);
     if (!loc)
-        __throw_runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
+        __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
     lconv* lc = __libcpp_localeconv_l(loc.get());
     if (!checked_string_to_wchar_convert(__decimal_point_,
                                          lc->mon_decimal_point,
                                          loc.get()))
       __decimal_point_ = base::do_decimal_point();
     if (!checked_string_to_wchar_convert(__thousands_sep_,
                                          lc->mon_thousands_sep,
                                          loc.get()))

 
 template<>
 void
 moneypunct_byname<wchar_t, true>::init(const char* nm)
 {
     typedef moneypunct<wchar_t, true> base;
     __libcpp_unique_locale loc(nm);
     if (!loc)
-        __throw_runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
+        __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
 
     lconv* lc = __libcpp_localeconv_l(loc.get());
     if (!checked_string_to_wchar_convert(__decimal_point_,
                                          lc->mon_decimal_point,
                                          loc.get()))
       __decimal_point_ = base::do_decimal_point();
     if (!checked_string_to_wchar_convert(__thousands_sep_,
                                          lc->mon_thousands_sep,
__init_pat(__neg_format_, __curr_symbol_, true,
                lc->int_n_cs_precedes, lc->int_n_sep_by_space,
                lc->int_n_sign_posn, L' ');
 #endif // !_LIBCPP_MSVCRT
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 void __do_nothing(void*) {}
 
-void __throw_runtime_error(const char* msg)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw runtime_error(msg);
-#else
-    _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>;)
 
                            template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
 _LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;)

libcxx/src/stdexcept.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 <__verbose_abort>
 #include <new>
 #include <stdexcept>
 #include <string>
 
 #ifdef _LIBCPP_ABI_VCRUNTIME
-#include "support/runtime/stdexcept_vcruntime.ipp"
+#  include "support/runtime/stdexcept_vcruntime.ipp"
 #else
-#include "support/runtime/stdexcept_default.ipp"
+#  include "support/runtime/stdexcept_default.ipp"
 #endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_NORETURN void __throw_runtime_error(const char* msg) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw runtime_error(msg);
+#else
+  _LIBCPP_VERBOSE_ABORT("runtime_error was thrown in -fno-exceptions mode with message \"%s\"", msg);
+#endif
+}
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/utils/data/ignore_format.txt

 libcxx/src/mutex.cpp
 libcxx/src/mutex_destructor.cpp
 libcxx/src/new.cpp
 libcxx/src/optional.cpp
 libcxx/src/pstl/libdispatch.cpp
 libcxx/src/random.cpp
 libcxx/src/random_shuffle.cpp
 libcxx/src/regex.cpp
-libcxx/src/stdexcept.cpp
 libcxx/src/std_stream.h
 libcxx/src/string.cpp
 libcxx/src/strstream.cpp
 libcxx/src/support/ibm/mbsnrtowcs.cpp
 libcxx/src/support/ibm/wcsnrtombs.cpp
 libcxx/src/support/ibm/xlocale_zos.cpp
 libcxx/src/support/runtime/exception_fallback.ipp
 libcxx/src/support/runtime/exception_glibcxx.ipp