contrib/libc++/src/exception.cpp

   1 //===------------------------ exception.cpp -------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 #include <stdlib.h>
  10
  11 #include "exception"
  12
  13 #if __APPLE__
  14   #include <cxxabi.h>
  15   using namespace __cxxabiv1;
  16   using namespace __cxxabiapple;
  17   // On Darwin, there are two STL shared libraries and a lower level ABI
  18   // shared libray.  The globals holding the current terminate handler and
  19   // current unexpected handler are in the ABI library.
  20   #define __terminate_handler  __cxxabiapple::__cxa_terminate_handler
  21   #define __unexpected_handler __cxxabiapple::__cxa_unexpected_handler
  22   #define HAVE_DEPENDENT_EH_ABI 1
  23 #elif defined(LIBCXXRT)
  24   #include <cxxabi.h>
  25   using namespace __cxxabiv1;
  26   #define HAVE_DEPENDENT_EH_ABI 1
  27 #else  // __APPLE__
  28   static std::terminate_handler  __terminate_handler;
  29   static std::unexpected_handler __unexpected_handler;
  30 #endif  // __APPLE__
  31
  32 #ifndef LIBCXXRT
  33 // libcxxrt provides implementations of these functions itself.
  34 std::unexpected_handler
  35 std::set_unexpected(std::unexpected_handler func) _NOEXCEPT
  36 {
  37     return __sync_lock_test_and_set(&__unexpected_handler, func);
  38 }
  39
  40 std::unexpected_handler
  41 std::get_unexpected() _NOEXCEPT
  42 {
  43     return __sync_fetch_and_add(&__unexpected_handler, (std::unexpected_handler)0);
  44 }
  45
  46 _ATTRIBUTE(noreturn)
  47 void
  48 std::unexpected()
  49 {
  50     (*std::get_unexpected())();
  51     // unexpected handler should not return
  52     std::terminate();
  53 }
  54
  55 std::terminate_handler
  56 std::set_terminate(std::terminate_handler func) _NOEXCEPT
  57 {
  58     return __sync_lock_test_and_set(&__terminate_handler, func);
  59 }
  60
  61 std::terminate_handler
  62 std::get_terminate() _NOEXCEPT
  63 {
  64     return __sync_fetch_and_add(&__terminate_handler, (std::terminate_handler)0);
  65 }
  66
  67 _ATTRIBUTE(noreturn)
  68 void
  69 std::terminate() _NOEXCEPT
  70 {
  71 #ifndef _LIBCPP_NO_EXCEPTIONS
  72     try
  73     {
  74 #endif  // _LIBCPP_NO_EXCEPTIONS
  75         (*std::get_terminate())();
  76         // handler should not return
  77         ::abort ();
  78 #ifndef _LIBCPP_NO_EXCEPTIONS
  79     }
  80     catch (...)
  81     {
  82         // handler should not throw exception
  83         ::abort ();
  84     }
  85 #endif  // _LIBCPP_NO_EXCEPTIONS
  86 }
  87 #endif // LIBCXXRT
  88
  89 bool std::uncaught_exception() _NOEXCEPT
  90 {
  91 #if __APPLE__
  92     // on Darwin, there is a helper function so __cxa_get_globals is private
  93     return __cxxabiapple::__cxa_uncaught_exception();
  94 #elif LIBCXXRT
  95     __cxa_eh_globals * globals = __cxa_get_globals();
  96     return (globals->uncaughtExceptions != 0);
  97 #else  // __APPLE__
  98     #warning uncaught_exception not yet implemented
  99     ::abort();
 100 #endif  // __APPLE__
 101 }
 102
 103 namespace std
 104 {
 105
 106 exception::~exception() _NOEXCEPT
 107 {
 108 }
 109
 110 bad_exception::~bad_exception() _NOEXCEPT
 111 {
 112 }
 113
 114 const char* exception::what() const _NOEXCEPT
 115 {
 116   return "std::exception";
 117 }
 118
 119 const char* bad_exception::what() const _NOEXCEPT
 120 {
 121   return "std::bad_exception";
 122 }
 123
 124 exception_ptr::~exception_ptr() _NOEXCEPT
 125 {
 126 #if HAVE_DEPENDENT_EH_ABI
 127     __cxa_decrement_exception_refcount(__ptr_);
 128 #else
 129     #warning exception_ptr not yet implemented
 130     ::abort();
 131 #endif  // __APPLE__
 132 }
 133
 134 exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
 135     : __ptr_(other.__ptr_)
 136 {
 137 #if HAVE_DEPENDENT_EH_ABI
 138     __cxa_increment_exception_refcount(__ptr_);
 139 #else
 140     #warning exception_ptr not yet implemented
 141     ::abort();
 142 #endif  // __APPLE__
 143 }
 144
 145 exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
 146 {
 147 #if HAVE_DEPENDENT_EH_ABI
 148     if (__ptr_ != other.__ptr_)
 149     {
 150         __cxa_increment_exception_refcount(other.__ptr_);
 151         __cxa_decrement_exception_refcount(__ptr_);
 152         __ptr_ = other.__ptr_;
 153     }
 154     return *this;
 155 #else  // __APPLE__
 156     #warning exception_ptr not yet implemented
 157     ::abort();
 158 #endif  // __APPLE__
 159 }
 160
 161 nested_exception::nested_exception() _NOEXCEPT
 162     : __ptr_(current_exception())
 163 {
 164 }
 165
 166 nested_exception::~nested_exception() _NOEXCEPT
 167 {
 168 }
 169
 170 _ATTRIBUTE(noreturn)
 171 void
 172 nested_exception::rethrow_nested() const
 173 {
 174     if (__ptr_ == nullptr)
 175         terminate();
 176     rethrow_exception(__ptr_);
 177 }
 178
 179 } // std
 180
 181 std::exception_ptr std::current_exception() _NOEXCEPT
 182 {
 183 #if HAVE_DEPENDENT_EH_ABI
 184     // be nicer if there was a constructor that took a ptr, then
 185     // this whole function would be just:
 186     //    return exception_ptr(__cxa_current_primary_exception());
 187     std::exception_ptr ptr;
 188     ptr.__ptr_ = __cxa_current_primary_exception();
 189     return ptr;
 190 #else  // __APPLE__
 191     #warning exception_ptr not yet implemented
 192     ::abort();
 193 #endif  // __APPLE__
 194 }
 195
 196 void std::rethrow_exception(exception_ptr p)
 197 {
 198 #if HAVE_DEPENDENT_EH_ABI
 199     __cxa_rethrow_primary_exception(p.__ptr_);
 200     // if p.__ptr_ is NULL, above returns so we terminate
 201     terminate();
 202 #else  // __APPLE__
 203     #warning exception_ptr not yet implemented
 204     ::abort();
 205 #endif  // __APPLE__
 206 }