[libcxx] refactor for throw

[weimingz]

Summary

Replacing macro guarded throw with __libcpp_throw

[weimingz]

Before replacing all throw/assert to macros, let's first check if we're on the right path.

[EricWF]

We actually have a non-macro that does this. It's called __libcpp_throw and it lives in <exception>. Please use that instead.

[EricWF]

Please make the changes in the above comment.

[weimingz]

In D21706#471091, @EricWF wrote:

Please make the changes in the above comment.

Sure. I'm working on it. Just got interrupted/distracted by other tasks time to time. :(

[grandinj]

include/array

209

the error message of the assert was perhaps better?

219

the error message of the assert was perhaps better?

include/experimental/dynarray

279

the error message of the assert was perhaps better?

291

ditto

include/map

1446

looks like extra spaces in this message (which was there in the original, I know)

1457

extra spaces here too

[rmaprath]

Generally looks OK to me.

There are similar uses in test sources as well, but those can be taken care of separately (I'm hoping to get back to the -fno-exceptions XFAILs soon).

[weimingz]

fix issues per Noel's suggestion

[mclow.lists]

This is getting close. A nit, and a couple of non-trivial comments.

include/exception

262

I thought that we were going to add a macro for the "no return if no exceptions"

src/future.cpp

96

Is the indentation right here? (or is phab lying to me?)

src/locale.cpp

527

Did you miss one here?

[weimingz]

include/exception

262

something like this?

#ifndef __LIBCPP_NO_EXCEPTIONS

#define NORETURN_EXP __attribute__((noreturn))

#else

#define NORETURN_EXP

#endif

inline NORETURN_EXP void libcpp_throw(_Exception const& e) {

...

}

src/future.cpp

96

It looks ok here. The first underscore is on the same column as "__has_value" (the line above). 4 space indention

src/locale.cpp

527

The reason I skipeed this and two or three other similar cases is the constructor expects the function __libcpp_throw() to return a pointer.

[weimingz]

Hi Marshall, do you have any comments?

[mclow.lists]

I just realized that this will break the following code:

try {  __cxxabiv1:: __cxa_bad_cast(); }
catch ( std::bad_cast &ex ) {}

because what gets thrown is a const std::bad_cast &

Yes, people should catch by value or const reference.
But that doesn't mean that they always do.

include/exception

262

There's another patch out for review that adds noreturn attributes for some functions when exceptions are disabled. I suggested a macro name like _LIBCPP_NO_RETURN_WHEN_EXCEPTIONS_DISABLED for this instead of using the [[noreturn]] or __attribute__((noreturn)) .

I can't find the review at the moment, but I'll turn it up.

[mclow.lists]

I think we've got most of this now. Do we still need this patch?

include/__functional_03

 _Rp
 function<_Rp()>::operator()() const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__f_ == 0)
-        throw bad_function_call();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(bad_function_call());
     return (*__f_)();
 }
 

 _Rp
 function<_Rp(_A0)>::operator()(_A0 __a0) const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__f_ == 0)
-        throw bad_function_call();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(bad_function_call());
     return (*__f_)(__a0);
 }
 

 _Rp
 function<_Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__f_ == 0)
-        throw bad_function_call();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(bad_function_call());
     return (*__f_)(__a0, __a1);
 }
 

 _Rp
 function<_Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2) const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__f_ == 0)
-        throw bad_function_call();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(bad_function_call());
     return (*__f_)(__a0, __a1, __a2);
 }
 

include/__locale

 locale
 locale::combine(const locale& __other) const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (!_VSTD::has_facet<_Facet>(__other))
-        throw runtime_error("locale::combine: locale missing facet");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+         __libcpp_throw(runtime_error("locale::combine: locale missing facet"));
     return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other)));
 }
 

include/array

 #include <iterator>
 #include <algorithm>
 #include <stdexcept>
-#if defined(_LIBCPP_NO_EXCEPTIONS)
-    #include <cassert>
-#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

 array<_Tp, _Size>::at(size_type __n)
 {
     if (__n >= _Size)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("array::at");
-#else
-        assert(!"array::at out_of_range");
-#endif
+        __libcpp_throw(out_of_range("array::at out of range"));
     return __elems_[__n];
 }
 

 array<_Tp, _Size>::at(size_type __n) const
 {
     if (__n >= _Size)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("array::at");
-#else
-        assert(!"array::at out_of_range");
-#endif
+        __libcpp_throw(out_of_range("array::at out of range"));
     return __elems_[__n];
 }
 

include/bitset

 #include <stdexcept>
 #include <iosfwd>
 #include <__functional_base>
-#if defined(_LIBCPP_NO_EXCEPTIONS)
-    #include <cassert>
-#endif
 
 #include <__undef_min_max>
 

     const_iterator __e = __make_iter(_Size);
     const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
     if (__i != __e)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw overflow_error("bitset to_ulong overflow error");
-#else
-        assert(!"bitset to_ulong overflow error");
-#endif
+        __libcpp_throw(overflow_error("bitset to_ulong overflow error"));
     return __first_[0];
 }
 

     const_iterator __e = __make_iter(_Size);
     const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
     if (__i != __e)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw overflow_error("bitset to_ullong overflow error");
-#else
-        assert(!"bitset to_ullong overflow error");
-#endif
+        __libcpp_throw(overflow_error("bitset to_ullong overflow error"));
     return to_ullong(true_type());
 }
 

     size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str));
     for (size_t __i = 0; __i < __rlen; ++__i)
         if (__str[__i] != __zero && __str[__i] != __one)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw invalid_argument("bitset string ctor has invalid argument");
-#else
-            assert(!"bitset string ctor has invalid argument");
-#endif
+            __libcpp_throw(invalid_argument("bitset string ctor has invalid argument"));
     size_t _Mp = _VSTD::min(__rlen, _Size);
     size_t __i = 0;
     for (; __i < _Mp; ++__i)

        _CharT __zero, _CharT __one)
 {
     if (__pos > __str.size())
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("bitset string pos out of range");
-#else
-        assert(!"bitset string pos out of range");
-#endif
+        __libcpp_throw(out_of_range("bitset string pos out of range"));
     size_t __rlen = _VSTD::min(__n, __str.size() - __pos);
     for (size_t __i = __pos; __i < __pos + __rlen; ++__i)
         if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one))
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw invalid_argument("bitset string ctor has invalid argument");
-#else
-            assert(!"bitset string ctor has invalid argument");
-#endif
+            __libcpp_throw(invalid_argument("bitset string ctor has invalid argument"));
     size_t _Mp = _VSTD::min(__rlen, _Size);
     size_t __i = 0;
     for (; __i < _Mp; ++__i)

 bitset<_Size>::set(size_t __pos, bool __val)
 {
     if (__pos >= _Size)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("bitset set argument out of range");
-#else
-        assert(!"bitset set argument out of range");
-#endif
+        __libcpp_throw(out_of_range("bitset set argument out of range"));
     (*this)[__pos] = __val;
     return *this;
 }

 bitset<_Size>::reset(size_t __pos)
 {
     if (__pos >= _Size)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("bitset reset argument out of range");
-#else
-        assert(!"bitset reset argument out of range");
-#endif
+        __libcpp_throw(out_of_range("bitset reset argument out of range"));
     (*this)[__pos] = false;
     return *this;
 }

 bitset<_Size>::flip(size_t __pos)
 {
     if (__pos >= _Size)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("bitset flip argument out of range");
-#else
-        assert(!"bitset flip argument out of range");
-#endif
+        __libcpp_throw(out_of_range("bitset flip argument out of range"));
     reference r = base::__make_ref(__pos);
     r = ~r;
     return *this;

 bitset<_Size>::test(size_t __pos) const
 {
     if (__pos >= _Size)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("bitset test argument out of range");
-#else
-        assert(!"bitset test argument out of range");
-#endif
+        __libcpp_throw(out_of_range("bitset test argument out of range"));
     return (*this)[__pos];
 }
 

include/complex

 #include <stdexcept>
 #include <cmath>
 #include <sstream>
-#if defined(_LIBCPP_NO_EXCEPTIONS)
-    #include <cassert>
-#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

include/deque

 void
 __deque_base_common<__b>::__throw_length_error() const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw length_error("deque");
-#endif
+    __libcpp_throw(length_error("deque"));
 }
 
 template <bool __b>
 void
 __deque_base_common<__b>::__throw_out_of_range() const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw out_of_range("deque");
-#endif
+    __libcpp_throw(out_of_range("deque"));
 }
 
 template <class _Tp, class _Allocator>

include/exception

 
 template <class _Exception>
 _LIBCPP_INLINE_VISIBILITY
-inline void __libcpp_throw(_Exception const& __e) {
+inline __attribute__((noreturn)) void __libcpp_throw(_Exception const& __e) {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw __e;
 #else

include/experimental/dynarray

 
 #include <__undef___deallocate>
 
-#if defined(_LIBCPP_NO_EXCEPTIONS)
-    #include <cassert>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

     {
         if ( numeric_limits<size_t>::max() / sizeof (value_type) <= count )
         {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw bad_array_length();
-#else
-            assert(!"dynarray::allocation");
-#endif
+            __libcpp_throw(bad_array_length());
         }
         return static_cast<value_type *> (_VSTD::__allocate (sizeof(value_type) * count));
     }

 {
     if (__n >= __size_)
     {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("dynarray::at");
-#else
-        assert(!"dynarray::at out_of_range");
-#endif
+        __libcpp_throw(out_of_range("dynarray::at out of range"));
     }
     return data()[__n];
 }

 {
     if (__n >= __size_)
     {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw out_of_range("dynarray::at");
-#else
-        assert(!"dynarray::at out_of_range");
-#endif
+        __libcpp_throw(out_of_range("dynarray::at out of range"));
     }
     return data()[__n];
 }

include/experimental/optional

     constexpr value_type const& value() const
     {
         if (!this->__engaged_)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw bad_optional_access();
-#else
-            assert(!"bad optional access");
-#endif
+            __libcpp_throw(bad_optional_access());
         return this->__val_;
     }
 

     value_type& value()
     {
         if (!this->__engaged_)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw bad_optional_access();
-#else
-            assert(!"bad optional access");
-#endif
+            __libcpp_throw(bad_optional_access());
         return this->__val_;
     }
 

include/fstream

             size_t __nr = fread((void*)__extbufnext_, 1, __nmemb, __file_);
             if (__nr != 0)
             {
-#ifndef _LIBCPP_NO_EXCEPTIONS
                 if (!__cv_)
-                    throw bad_cast();
-#endif
+                    __libcpp_throw(bad_cast());
                 __extbufend_ = __extbufnext_ + __nr;
                 char_type*  __inext;
                 __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,

             codecvt_base::result __r;
             do
             {
-#ifndef _LIBCPP_NO_EXCEPTIONS
                 if (!__cv_)
-                    throw bad_cast();
-#endif
+                    __libcpp_throw(bad_cast());
                 const char_type* __e;
                 __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
                                         __extbuf_, __extbuf_ + __ebs_, __extbe);

 basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
                                         ios_base::openmode)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (!__cv_)
-        throw bad_cast();
-#endif
+        __libcpp_throw(bad_cast());
     int __width = __cv_->encoding();
     if (__file_ == 0 || (__width <= 0 && __off != 0) || sync())
         return pos_type(off_type(-1));

 {
     if (__file_ == 0)
         return 0;
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (!__cv_)
-        throw bad_cast();
-#endif
+        __libcpp_throw(bad_cast());
     if (__cm_ & ios_base::out)
     {
         if (this->pptr() != this->pbase())

include/functional

 _Rp
 function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__f_ == 0)
-        throw bad_function_call();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(bad_function_call());
     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
 }
 

include/future

 inline _LIBCPP_ALWAYS_INLINE
 void __throw_future_error(future_errc _Ev)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw future_error(make_error_code(_Ev));
-#else
-    assert(!"future_error");
-#endif
+    __libcpp_throw(future_error(make_error_code(_Ev)));
 }
 
 class _LIBCPP_TYPE_VIS __assoc_sub_state

include/locale

         if (__r == codecvt_base::ok)
             return __ws;
     }
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__wide_err_string_.empty())
-        throw range_error("wstring_convert: from_bytes error");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(range_error("wstring_convert: from_bytes error"));
     return __wide_err_string_;
 }
 

                 return __bs;
         }
     }
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__byte_err_string_.empty())
-        throw range_error("wstring_convert: to_bytes error");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(range_error("wstring_convert: to_bytes error"));
     return __byte_err_string_;
 }
 

include/map

 {
     __node_base_pointer __parent;
     __node_base_pointer& __child = __find_equal_key(__parent, __k);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__child == nullptr)
-        throw out_of_range("map::at:  key not found");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(out_of_range("map::at: key not found"));
     return static_cast<__node_pointer>(__child)->__value_.__cc.second;
 }
 

 {
     __node_base_pointer __parent;
     __node_base_pointer __child = __find_equal_key(__parent, __k);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__child == nullptr)
-        throw out_of_range("map::at:  key not found");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(out_of_range("map::at: key not found"));
     return static_cast<__node_pointer>(__child)->__value_.__cc.second;
 }
 

include/memory

 #include <tuple>
 #include <stdexcept>
 #include <cstring>
-#if defined(_LIBCPP_NO_EXCEPTIONS)
-    #include <cassert>
-#endif
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>

       __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_)
 {
     if (__cntrl_ == 0)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw bad_weak_ptr();
-#else
-        assert(!"bad_weak_ptr");
-#endif
+        __libcpp_throw(bad_weak_ptr());
 }
 
 template<class _Tp>

include/regex

 _LIBCPP_ALWAYS_INLINE
 void __throw_regex_error()
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw regex_error(_Ev);
-#else
-    assert(!"regex_error");
-#endif
+    __libcpp_throw(regex_error(_Ev));
 }
 
 template <class _CharT>

include/string

 void
 __basic_string_common<__b>::__throw_length_error() const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw length_error("basic_string");
-#else
-    assert(!"basic_string length_error");
-#endif
+    __libcpp_throw(length_error("basic_string"));
 }
 
 template <bool __b>
 void
 __basic_string_common<__b>::__throw_out_of_range() const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw out_of_range("basic_string");
-#else
-    assert(!"basic_string out_of_range");
-#endif
+    __libcpp_throw(out_of_range("basic_string"));
 }
 
 #ifdef _LIBCPP_MSVC

include/unordered_map

 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k)
 {
     iterator __i = find(__k);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__i == end())
-        throw out_of_range("unordered_map::at: key not found");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(out_of_range("unordered_map::at: key not found"));
     return __i->second;
 }
 

 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const
 {
     const_iterator __i = find(__k);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__i == end())
-        throw out_of_range("unordered_map::at: key not found");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(out_of_range("unordered_map::at: key not found")));
     return __i->second;
 }
 

include/vector

 void
 __vector_base_common<__b>::__throw_length_error() const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw length_error("vector");
-#else
-    assert(!"vector length_error");
-#endif
+    __libcpp_throw(length_error("vector"));
 }
 
 template <bool __b>
 void
 __vector_base_common<__b>::__throw_out_of_range() const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw out_of_range("vector");
-#else
-    assert(!"vector out_of_range");
-#endif
+    __libcpp_throw(out_of_range("vector"));
 }
 
 #ifdef _LIBCPP_MSVC

src/debug.cpp

         size_t nc = __next_prime(2*static_cast<size_t>(__cend_ - __cbeg_) + 1);
         __c_node** cbeg = static_cast<__c_node**>(calloc(nc, sizeof(void*)));
         if (cbeg == nullptr)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw bad_alloc();
-#else
-            abort();
-#endif
+            __libcpp_throw(bad_alloc());
         for (__c_node** p = __cbeg_; p != __cend_; ++p)
         {
             __c_node* q = *p;

     __c_node* r = __cbeg_[hc] =
       static_cast<__c_node*>(malloc(sizeof(__c_node)));
     if (__cbeg_[hc] == nullptr)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw bad_alloc();
-#else
-        abort();
-#endif
+        __libcpp_throw(bad_alloc());
     r->__c_ = __c;
     r->__next_ = p;
     ++__csz_;

         __i_node** beg =
            static_cast<__i_node**>(malloc(nc * sizeof(__i_node*)));
         if (beg == nullptr)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw bad_alloc();
-#else
-            abort();
-#endif
+            __libcpp_throw(bad_alloc());
         if (nc > 1)
             memcpy(beg, beg_, nc/2*sizeof(__i_node*));
         free(beg_);

         size_t nc = __next_prime(2*static_cast<size_t>(__iend_ - __ibeg_) + 1);
         __i_node** ibeg = static_cast<__i_node**>(calloc(nc, sizeof(void*)));
         if (ibeg == nullptr)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw bad_alloc();
-#else
-            abort();
-#endif
+            __libcpp_throw(bad_alloc());
         for (__i_node** p = __ibeg_; p != __iend_; ++p)
         {
             __i_node* q = *p;

     __i_node* r = __ibeg_[hi] =
       static_cast<__i_node*>(malloc(sizeof(__i_node)));
     if (r == nullptr)
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw bad_alloc();
-#else
-        abort();
-#endif
+        __libcpp_throw(bad_alloc());
     ::new(r) __i_node(__i, p, nullptr);
     ++__isz_;
     return r;

src/experimental/memory_resource.cpp

 
 protected:
     virtual void* do_allocate(size_t, size_t) {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw std::bad_alloc();
-#else
-        abort();
-#endif
+        __libcpp_throw(std::bad_alloc());
     }
     virtual void do_deallocate(void *, size_t, size_t) {}
     virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT

     return __default_memory_resource(true, __new_res);
 }
 
-_LIBCPP_END_NAMESPACE_LFTS_PMR
+_LIBCPP_END_NAMESPACE_LFTS_PMR
 

src/future.cpp

 __assoc_sub_state::set_value()
 {
     unique_lock<mutex> __lk(__mut_);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__has_value())
-        throw future_error(make_error_code(future_errc::promise_already_satisfied));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::promise_already_satisfied)));
     __state_ |= __constructed | ready;
     __cv_.notify_all();
 }

 __assoc_sub_state::set_value_at_thread_exit()
 {
     unique_lock<mutex> __lk(__mut_);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__has_value())
-        throw future_error(make_error_code(future_errc::promise_already_satisfied));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::promise_already_satisfied)));
     __state_ |= __constructed;
     __thread_local_data()->__make_ready_at_thread_exit(this);
 }

 __assoc_sub_state::set_exception(exception_ptr __p)
 {
     unique_lock<mutex> __lk(__mut_);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__has_value())
-        throw future_error(make_error_code(future_errc::promise_already_satisfied));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::promise_already_satisfied)));
     __exception_ = __p;
     __state_ |= ready;
     __cv_.notify_all();

 __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
 {
     unique_lock<mutex> __lk(__mut_);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__has_value())
-        throw future_error(make_error_code(future_errc::promise_already_satisfied));
-#endif
+        __libcxx_throw(future_error(make_error_code(future_errc::promise_already_satisfied)));
     __exception_ = __p;
     __thread_local_data()->__make_ready_at_thread_exit(this);
 }

 void
 __assoc_sub_state::__execute()
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw future_error(make_error_code(future_errc::no_state));
-#endif
+    __libcpp_throw(future_error(make_error_code(future_errc::no_state)));
 }
 
 future<void>::future(__assoc_sub_state* __state)
     : __state_(__state)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_->__has_future_attached())
-        throw future_error(make_error_code(future_errc::future_already_retrieved));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::future_already_retrieved)));
     __state_->__add_shared();
     __state_->__set_future_attached();
 }

 future<void>
 promise<void>::get_future()
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
-        throw future_error(make_error_code(future_errc::no_state));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::no_state)));
     return future<void>(__state_);
 }
 
 void
 promise<void>::set_value()
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
-        throw future_error(make_error_code(future_errc::no_state));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::no_state)));
     __state_->set_value();
 }
 
 void
 promise<void>::set_exception(exception_ptr __p)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
-        throw future_error(make_error_code(future_errc::no_state));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::no_state)));
     __state_->set_exception(__p);
 }
 
 void
 promise<void>::set_value_at_thread_exit()
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
-        throw future_error(make_error_code(future_errc::no_state));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::no_state)));
     __state_->set_value_at_thread_exit();
 }
 
 void
 promise<void>::set_exception_at_thread_exit(exception_ptr __p)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
-        throw future_error(make_error_code(future_errc::no_state));
-#endif
+        __libcpp_throw(future_error(make_error_code(future_errc::no_state)));
     __state_->set_exception_at_thread_exit(__p);
 }
 

src/hash.cpp

 typename enable_if<_Sz == 4, void>::type
 __check_for_overflow(size_t N)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (N > 0xFFFFFFFB)
-        throw overflow_error("__next_prime overflow");
-#else
-    (void)N;
-#endif
+        __libcpp_throw(overflow_error("__next_prime overflow"));
 }
 
 template <size_t _Sz = sizeof(size_t)>

 typename enable_if<_Sz == 8, void>::type
 __check_for_overflow(size_t N)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (N > 0xFFFFFFFFFFFFFFC5ull)
-        throw overflow_error("__next_prime overflow");
-#else
-    (void)N;
-#endif
+        __libcpp_throw(overflow_error("__next_prime overflow"));
 }
 
 size_t

src/ios.cpp

         __rdstate_ = state;
     else
         __rdstate_ = state | badbit;
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
-        throw failure("ios_base::clear");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(failure("ios_base::clear"));
 }
 
 // init

     {
         size_t newesize = sizeof(event_callback) * rhs.__event_size_;
         new_callbacks.reset(static_cast<event_callback*>(malloc(newesize)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!new_callbacks)
-            throw bad_alloc();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __libcpp_throw(bad_alloc());
 
         size_t newisize = sizeof(int) * rhs.__event_size_;
         new_ints.reset(static_cast<int *>(malloc(newisize)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!new_ints)
-            throw bad_alloc();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __libcpp_throw(bad_alloc());
     }
     if (__iarray_cap_ < rhs.__iarray_size_)
     {
         size_t newsize = sizeof(long) * rhs.__iarray_size_;
         new_longs.reset(static_cast<long*>(malloc(newsize)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!new_longs)
-            throw bad_alloc();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __libcpp_throw(bad_alloc());
     }
     if (__parray_cap_ < rhs.__parray_size_)
     {
         size_t newsize = sizeof(void*) * rhs.__parray_size_;
         new_pointers.reset(static_cast<void**>(malloc(newsize)));
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (!new_pointers)
-            throw bad_alloc();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __libcpp_throw(bad_alloc());
     }
     // Got everything we need.  Copy everything but __rdstate_, __rdbuf_ and __exceptions_
     __fmtflags_ = rhs.__fmtflags_;

src/locale.cpp

 const locale::facet*
 locale::__imp::use_facet(long id) const
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (!has_facet(id))
-        throw bad_cast();
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(bad_cast());
     return facets_[static_cast<size_t>(id)];
 }
 

 #else  // _LIBCPP_NO_EXCEPTIONS
     : __locale_(new __imp(*other.__locale_, name, c))
 #endif
+
 {
     __locale_->__add_shared();
 }

     : collate<char>(refs),
       __l(newlocale(LC_ALL_MASK, n, 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("collate_byname<char>::collate_byname"
-                            " failed to construct for " + string(n));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("collate_byname<char>::collate_byname"
+                            " failed to construct for " + string(n)));
 }
 
 collate_byname<char>::collate_byname(const string& name, size_t refs)
     : collate<char>(refs),
       __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("collate_byname<char>::collate_byname"
-                            " failed to construct for " + name);
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("collate_byname<char>::collate_byname"
+                            " failed to construct for " + name));
 }
 
 collate_byname<char>::~collate_byname()

     : collate<wchar_t>(refs),
       __l(newlocale(LC_ALL_MASK, n, 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
-                            " failed to construct for " + string(n));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("collate_byname<wchar_t>::collate_byname("
+                          "size_t refs) failed to construct for " + string(n)));
 }
 
 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))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
-                            " failed to construct for " + name);
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("collate_byname<wchar_t>::collate_byname"
+                          "(size_t refs) failed to construct for " + name));
 }
 
 collate_byname<wchar_t>::~collate_byname()

     : ctype<char>(0, false, refs),
       __l(newlocale(LC_ALL_MASK, name, 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("ctype_byname<char>::ctype_byname"
-                            " failed to construct for " + string(name));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("ctype_byname<char>::ctype_byname"
+                            " failed to construct for " + string(name)));
 }
 
 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))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("ctype_byname<char>::ctype_byname"
-                            " failed to construct for " + name);
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("ctype_byname<char>::ctype_byname"
+                            " failed to construct for " + name));
 }
 
 ctype_byname<char>::~ctype_byname()

     : ctype<wchar_t>(refs),
       __l(newlocale(LC_ALL_MASK, name, 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("ctype_byname<wchar_t>::ctype_byname"
-                            " failed to construct for " + string(name));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("ctype_byname<wchar_t>::ctype_byname"
+                            " failed to construct for " + string(name)));
 }
 
 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))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("ctype_byname<wchar_t>::ctype_byname"
-                            " failed to construct for " + name);
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("ctype_byname<wchar_t>::ctype_byname"
+                            " failed to construct for " + name));
 }
 
 ctype_byname<wchar_t>::~ctype_byname()

     : locale::facet(refs),
       __l(newlocale(LC_ALL_MASK, nm, 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__l == 0)
-        throw runtime_error("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
-                            " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("codecvt_byname<wchar_t, char, mbstate_t>"
+                                     "::codecvt_byname failed to construct "
+                                     "for " + string(nm)));
 }
 
 codecvt<wchar_t, char, mbstate_t>::~codecvt()

     if (strcmp(nm, "C") != 0)
     {
         __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (loc == nullptr)
-            throw runtime_error("numpunct_byname<char>::numpunct_byname"
-                                " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __libcpp_throw(runtime_error("numpunct_byname<char>::"
+                                         "numpunct_byname  failed to construct "
+                                         "for " + string(nm)));
         lconv* lc = __libcpp_localeconv_l(loc.get());
         if (*lc->decimal_point)
             __decimal_point_ = *lc->decimal_point;

     if (strcmp(nm, "C") != 0)
     {
         __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
-#ifndef _LIBCPP_NO_EXCEPTIONS
         if (loc == nullptr)
-            throw runtime_error("numpunct_byname<char>::numpunct_byname"
-                                " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+            __libcpp_throw(runtime_error("numpunct_byname<char>::numpunct_"
+                                         "byname failed to construct for " +
+                                         string(nm)));
         lconv* lc = __libcpp_localeconv_l(loc.get());
         if (*lc->decimal_point)
             __decimal_point_ = *lc->decimal_point;

 __time_get::__time_get(const char* nm)
     : __loc_(newlocale(LC_ALL_MASK, nm, 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__loc_ == 0)
-        throw runtime_error("time_get_byname"
-                            " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("time_get_byname"
+                            " failed to construct for " + string(nm)));
 }
 
 __time_get::__time_get(const string& nm)
     : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__loc_ == 0)
-        throw runtime_error("time_get_byname"
-                            " failed to construct for " + nm);
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("time_get_byname"
+                            " failed to construct for " + nm));
 }
 
 __time_get::~__time_get()

 __time_put::__time_put(const char* nm)
     : __loc_(newlocale(LC_ALL_MASK, nm, 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__loc_ == 0)
-        throw runtime_error("time_put_byname"
-                            " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("time_put_byname"
+                            " failed to construct for " + string(nm)));
 }
 
 __time_put::__time_put(const string& nm)
     : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__loc_ == 0)
-        throw runtime_error("time_put_byname"
-                            " failed to construct for " + nm);
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("time_put_byname"
+                            " failed to construct for " + nm));
 }
 
 __time_put::~__time_put()

 {
     typedef moneypunct<char, false> base;
     __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == nullptr)
-        throw runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("moneypunct_byname"
+                            " failed to construct for " + string(nm)));
     lconv* lc = __libcpp_localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = *lc->mon_decimal_point;

 {
     typedef moneypunct<char, true> base;
     __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == nullptr)
-        throw runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("moneypunct_byname"
+                            " failed to construct for " + string(nm)));
     lconv* lc = __libcpp_localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = *lc->mon_decimal_point;

 {
     typedef moneypunct<wchar_t, false> base;
     __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == nullptr)
-        throw runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("moneypunct_byname"
+                            " failed to construct for " + string(nm)));
     lconv* lc = __libcpp_localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = static_cast<wchar_t>(*lc->mon_decimal_point);

 {
     typedef moneypunct<wchar_t, true> base;
     __locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == nullptr)
-        throw runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(runtime_error("moneypunct_byname"
+                            " failed to construct for " + string(nm)));
     lconv* lc = __libcpp_localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = static_cast<wchar_t>(*lc->mon_decimal_point);

 
 void __throw_runtime_error(const char* msg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw runtime_error(msg);
-#else
+    __libcpp_throw(runtime_error(msg));
     (void)msg;
-#endif
 }
 
 template class collate<char>;

src/new.cpp

             nh();
         else
 #ifndef _LIBCPP_NO_EXCEPTIONS
-            throw std::bad_alloc();
+            __libcpp_throw(std::bad_alloc());
 #else
             break;
 #endif

src/string.cpp

 namespace
 {
 
-template<typename T>
-inline
-void throw_helper( const string& msg )
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw T( msg );
-#else
-    fprintf(stderr, "%s\n", msg.c_str());
-    abort();
-#endif
-}
-
 inline
 void throw_from_string_out_of_range( const string& func )
 {
-    throw_helper<out_of_range>(func + ": out of range");
+    __libcpp_throw(out_of_range(func + ": out of range"));
 }
 
 inline
 void throw_from_string_invalid_arg( const string& func )
 {
-    throw_helper<invalid_argument>(func + ": no conversion");
+    __libcpp_throw(invalid_argument(func + ": no conversion"));
 }
 
 // as_integer

src/system_error.cpp

 void
 __throw_system_error(int ev, const char* what_arg)
 {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw system_error(error_code(ev, system_category()), what_arg);
-#else
-    (void)ev;
-    (void)what_arg;
-#endif
+    __libcpp_throw(system_error(error_code(ev, system_category()), what_arg));
 }
 
 _LIBCPP_END_NAMESPACE_STD

src/thread.cpp

         if (ec == 0)
             __t_ = 0;
     }
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (ec)
-        throw system_error(error_code(ec, system_category()), "thread::join failed");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(system_error(error_code(ec, system_category()),
+                                               "thread::join failed"));
 }
 
 void

         if (ec == 0)
             __t_ = 0;
     }
-#ifndef _LIBCPP_NO_EXCEPTIONS
     if (ec)
-        throw system_error(error_code(ec, system_category()), "thread::detach failed");
-#endif  // _LIBCPP_NO_EXCEPTIONS
+        __libcpp_throw(system_error(error_code(ec, system_category()),
+                                               "thread::detach failed"));
 }
 
 unsigned

src/typeinfo.cpp

   // because bad_cast and bad_typeid are defined in his higher level library
   void __cxxabiv1::__cxa_bad_typeid()
   {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-     throw std::bad_typeid();
-#endif
+     __libcpp_throw(std::bad_typeid());
   }
   void __cxxabiv1::__cxa_bad_cast()
   {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-      throw std::bad_cast();
-#endif
+      __libcpp_throw(std::bad_cast());
   }
 #endif