Use GNU-style attributes for several __throw_XXX() functions

[dim]

Summary

In rL279744, __throw_XXX() functions were introduced, partially for compatibility with software compiled against libstdc++. _LIBCPP_NORETURN is used on all of them, and when C++11 attributes are available, this gets defined as [[noreturn]], instead of the GNU-style __attribute__((noreturn)) style.

However, this can cause trouble with some software, for example Mozilla Firefox, which attempts to redefine several of these __throw_XXX() functions, and but uses the __attribute__((noreturn)) style exclusively. This then leads to errors like:

/usr/include/c++/v1/new:130:1: error: function declared '[[noreturn]]' after its first declaration
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
^
/usr/include/c++/v1/__config:283:30: note: expanded from macro '_LIBCPP_NORETURN'
#  define _LIBCPP_NORETURN [[noreturn]]
                             ^
../../dist/include/mozilla/throw_gcc.h:35:1: note: declaration missing '[[noreturn]]' attribute is here
__throw_bad_alloc(void)
^

See also https://bugs.freebsd.org/216186 and https://bugzilla.mozilla.org/1329520 . In Firefox's case, the following list of functions is affected:

__throw_bad_alloc(void)
__throw_bad_cast(void)
__throw_bad_exception(void)
__throw_bad_function_call(void)
__throw_bad_typeid(void)
__throw_domain_error(const char*)
__throw_invalid_argument(const char*)
__throw_ios_failure(const char*)
__throw_length_error(const char*)
__throw_logic_error(const char*)
__throw_out_of_range(const char*)
__throw_overflow_error(const char*)
__throw_range_error(const char*)
__throw_runtime_error(const char*)
__throw_system_error(int)
__throw_underflow_error(const char*)

To make it easier on third-party software, let's define a LIBCPP_NORETURN_GNU variant, which always uses the __attribute__((noreturn)) style, and apply it specifically to the above list of functions.

This should also be merged to the 4.0 branch, when it has been committed.

[mclow.lists]

In rL279744, __throw_XXX() functions were introduced, partially for compatibility with software compiled against libstdc++.

You're working from a false premise. These functions were not added for compatibility with libstdc++, but rather to encapsulate the mechanism for throwing an exception - to localize the changes needed to support -fno-exceptions

[dim]

In D28981#653908, @mclow.lists wrote:

In rL279744, __throw_XXX() functions were introduced, partially for compatibility with software compiled against libstdc++.

You're working from a false premise. These functions were not added for compatibility with libstdc++, but rather to encapsulate the mechanism for throwing an exception - to localize the changes needed to support -fno-exceptions

Ok, I was mistaken about the premise, but by accident (or by their self-evidentness) the names are still shared with the GNU names. It would be nice to have some way of making them semi-compatible. Alternatively, we could rename them, but that would be more churn, I guess.

[mclow.lists]

It would be nice to have some way of making them semi-compatible.

I'm afraid I disagree. If we make them something that people can "count on", then we have to support them.
The whole point of names that start with __ (or _[A-Z] are that they are internal, implementation details and are NOT part of the published API.

[jwakely]

The __throw_xxx functions are not part of the public libstdc++ API and whatever Firefox is trying to do with them is not supported by libstdc++ and is undefined behaviour. Make it stop.

[EricWF]

I think we've agreed that this change shouldn't proceed. Resigning as reviewer.

[dim]

Ok, back to Mozilla we go.

include/__config

 #endif
 
 #if !(__has_feature(cxx_decltype))
 #define _LIBCPP_HAS_NO_DECLTYPE
 #endif
 
 #if __has_feature(cxx_attributes)
 #  define _LIBCPP_NORETURN [[noreturn]]
+#  define _LIBCPP_NORETURN_GNU __attribute__ ((noreturn))
 #else
 #  define _LIBCPP_NORETURN __attribute__ ((noreturn))
+#  define _LIBCPP_NORETURN_GNU __attribute__ ((noreturn))
 #endif
 
 #if !(__has_feature(cxx_lambdas))
 #define _LIBCPP_HAS_NO_LAMBDAS
 #endif
 
 #if !(__has_feature(cxx_nullptr))
 # if (__has_extension(cxx_nullptr) || __has_keyword(__nullptr)) && defined(_LIBCPP_ABI_ALWAYS_USE_CXX11_NULLPTR)

 #endif
 
 #elif defined(_LIBCPP_COMPILER_GCC)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
 
 #define _LIBCPP_NORETURN __attribute__((noreturn))
+#define _LIBCPP_NORETURN_GNU __attribute__((noreturn))
 
 #if _GNUC_VER >= 407
 #define _LIBCPP_UNDERLYING_TYPE(T) __underlying_type(T)
 #define _LIBCPP_IS_LITERAL(T) __is_literal_type(T)
 #define _LIBCPP_HAS_IS_FINAL
 #endif
 
 #if defined(__GNUC__) && _GNUC_VER >= 403

 #define _LIBCPP_HAS_NO_CXX14_CONSTEXPR
 #define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
 #if _MSC_VER <= 1800
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #endif
 #define _LIBCPP_HAS_NO_NOEXCEPT
 #define __alignof__ __alignof
 #define _LIBCPP_NORETURN __declspec(noreturn)
+#define _LIBCPP_NORETURN_GNU __declspec(noreturn)
 #define _ALIGNAS(x) __declspec(align(x))
 #define _LIBCPP_HAS_NO_VARIADICS
 
 #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {
 #define _LIBCPP_END_NAMESPACE_STD  }
 #define _VSTD std
 
 #  define _LIBCPP_WEAK
 namespace std {
 }
 
 #define _LIBCPP_HAS_NO_ASAN
 
 #elif defined(_LIBCPP_COMPILER_IBM)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
 #define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
 #define _ATTRIBUTE(x) __attribute__((x))
 #define _LIBCPP_NORETURN __attribute__((noreturn))
+#define _LIBCPP_NORETURN_GNU __attribute__((noreturn))
 
 #define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 #define _LIBCPP_HAS_NO_NOEXCEPT
 #define _LIBCPP_HAS_NO_NULLPTR
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_IS_BASE_OF
 #define _LIBCPP_HAS_IS_FINAL
 #define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES

include/__locale

 {
 }
 
 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char, char, mbstate_t>)
 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>)
 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>)
 _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>)
 
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
+_LIBCPP_NORETURN_GNU _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
 
 template <size_t _Np>
 struct __narrow_to_utf8
 {
     template <class _OutputIterator, class _CharT>
     _OutputIterator
     operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const;
 };

include/functional

 
 // bad_function_call
 
 class _LIBCPP_EXCEPTION_ABI bad_function_call
     : public exception
 {
 };
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_bad_function_call()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_function_call();
 #else
   _VSTD::abort();
 #endif
 }

include/new

class _LIBCPP_EXCEPTION_ABI bad_array_new_length
     : public bad_alloc
 {
 public:
     bad_array_new_length() _NOEXCEPT;
     virtual ~bad_array_new_length() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
+_LIBCPP_NORETURN_GNU _LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
 
 #if defined(_LIBCPP_BUILDING_NEW) || (_LIBCPP_STD_VER > 11)
 
 class _LIBCPP_EXCEPTION_ABI bad_array_length
     : public bad_alloc
 {
 public:
     bad_array_length() _NOEXCEPT;

include/stdexcept

public:
     virtual ~underflow_error() _NOEXCEPT;
 };
 
 }  // std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // in the dylib
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
+_LIBCPP_NORETURN_GNU _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_logic_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw logic_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_domain_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw domain_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_invalid_argument(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw invalid_argument(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_length_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw length_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_out_of_range(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw out_of_range(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_range_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw range_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_overflow_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw overflow_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_underflow_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw underflow_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_STDEXCEPT

include/system_error

public:
 
     _LIBCPP_ALWAYS_INLINE
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
 private:
     static string __init(const error_code&, string);
 };
 
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
+_LIBCPP_NORETURN_GNU _LIBCPP_FUNC_VIS
 void __throw_system_error(int ev, const char* what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_SYSTEM_ERROR

include/typeinfo

public:
     bad_typeid() _NOEXCEPT;
     virtual ~bad_typeid() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
 }  // std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
+_LIBCPP_NORETURN_GNU inline _LIBCPP_ALWAYS_INLINE
 void __throw_bad_cast()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_cast();
 #else
   _VSTD::abort();
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // __LIBCPP_TYPEINFO