external/bsd/libc++/dist/libcxx/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 #include <stdio.h>
  11
  12 #include "exception"
  13 #include "new"
  14
  15 #ifndef __has_include
  16 #define __has_include(inc) 0
  17 #endif
  18
  19 #if defined(__APPLE__) && !defined(LIBCXXRT)
  20   #include <cxxabi.h>
  21
  22   using namespace __cxxabiv1;
  23   #define HAVE_DEPENDENT_EH_ABI 1
  24   #ifndef _LIBCPPABI_VERSION
  25     using namespace __cxxabiapple;
  26     // On Darwin, there are two STL shared libraries and a lower level ABI
  27     // shared library.  The globals holding the current terminate handler and
  28     // current unexpected handler are in the ABI library.
  29     #define __terminate_handler  __cxxabiapple::__cxa_terminate_handler
  30     #define __unexpected_handler __cxxabiapple::__cxa_unexpected_handler
  31   #endif  // _LIBCPPABI_VERSION
  32 #elif defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI) || __has_include(<cxxabi.h>)
  33   #include <cxxabi.h>
  34   using namespace __cxxabiv1;
  35   #if defined(LIBCXXRT) || defined(_LIBCPPABI_VERSION)
  36     #define HAVE_DEPENDENT_EH_ABI 1
  37   #endif
  38 #elif !defined(__GLIBCXX__) // __has_include(<cxxabi.h>)
  39   static std::terminate_handler  __terminate_handler;
  40   static std::unexpected_handler __unexpected_handler;
  41 #endif // __has_include(<cxxabi.h>)
  42
  43 namespace std
  44 {
  45
  46 #if !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
  47
  48 // libcxxrt provides implementations of these functions itself.
  49 unexpected_handler
  50 set_unexpected(unexpected_handler func) _NOEXCEPT
  51 {
  52     return __sync_lock_test_and_set(&__unexpected_handler, func);
  53 }
  54
  55 unexpected_handler
  56 get_unexpected() _NOEXCEPT
  57 {
  58     return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0);
  59 }
  60
  61 _LIBCPP_NORETURN
  62 void
  63 unexpected()
  64 {
  65     (*get_unexpected())();
  66     // unexpected handler should not return
  67     terminate();
  68 }
  69
  70 terminate_handler
  71 set_terminate(terminate_handler func) _NOEXCEPT
  72 {
  73     return __sync_lock_test_and_set(&__terminate_handler, func);
  74 }
  75
  76 terminate_handler
  77 get_terminate() _NOEXCEPT
  78 {
  79     return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0);
  80 }
  81
  82 #ifndef __EMSCRIPTEN__ // We provide this in JS
  83 _LIBCPP_NORETURN
  84 void
  85 terminate() _NOEXCEPT
  86 {
  87 #ifndef _LIBCPP_NO_EXCEPTIONS
  88     try
  89     {
  90 #endif  // _LIBCPP_NO_EXCEPTIONS
  91         (*get_terminate())();
  92         // handler should not return
  93         fprintf(stderr, "terminate_handler unexpectedly returned\n");
  94         ::abort();
  95 #ifndef _LIBCPP_NO_EXCEPTIONS
  96     }
  97     catch (...)
  98     {
  99         // handler should not throw exception
 100         fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
 101         ::abort();
 102     }
 103 #endif  // _LIBCPP_NO_EXCEPTIONS
 104 }
 105 #endif // !__EMSCRIPTEN__
 106 #endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION)
 107
 108 #if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__)
 109 bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }
 110
 111 int uncaught_exceptions() _NOEXCEPT
 112 {
 113 #if defined(__APPLE__) || defined(_LIBCPPABI_VERSION)
 114    // on Darwin, there is a helper function so __cxa_get_globals is private
 115 # if _LIBCPPABI_VERSION > 1101
 116     return __cxa_uncaught_exceptions();
 117 # else
 118     return __cxa_uncaught_exception() ? 1 : 0;
 119 # endif
 120 #else  // __APPLE__
 121 #   if defined(_MSC_VER) && ! defined(__clang__)
 122         _LIBCPP_WARNING("uncaught_exceptions not yet implemented")
 123 #   else
 124 #       warning uncaught_exception not yet implemented
 125 #   endif
 126     fprintf(stderr, "uncaught_exceptions not yet implemented\n");
 127     ::abort();
 128 #endif  // __APPLE__
 129 }
 130
 131
 132 #ifndef _LIBCPPABI_VERSION
 133
 134 exception::~exception() _NOEXCEPT
 135 {
 136 }
 137
 138 const char* exception::what() const _NOEXCEPT
 139 {
 140   return "std::exception";
 141 }
 142
 143 #endif  // _LIBCPPABI_VERSION
 144 #endif //LIBCXXRT
 145 #if !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
 146
 147 bad_exception::~bad_exception() _NOEXCEPT
 148 {
 149 }
 150
 151 const char* bad_exception::what() const _NOEXCEPT
 152 {
 153   return "std::bad_exception";
 154 }
 155
 156 #endif
 157
 158 #if defined(__GLIBCXX__)
 159
 160 // libsupc++ does not implement the dependent EH ABI and the functionality
 161 // it uses to implement std::exception_ptr (which it declares as an alias of
 162 // std::__exception_ptr::exception_ptr) is not directly exported to clients. So
 163 // we have little choice but to hijack std::__exception_ptr::exception_ptr's
 164 // (which fortunately has the same layout as our std::exception_ptr) copy
 165 // constructor, assignment operator and destructor (which are part of its
 166 // stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)
 167 // function.
 168
 169 namespace __exception_ptr
 170 {
 171
 172 struct exception_ptr
 173 {
 174     void* __ptr_;
 175
 176     exception_ptr(const exception_ptr&) _NOEXCEPT;
 177     exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
 178     ~exception_ptr() _NOEXCEPT;
 179 };
 180
 181 }
 182
 183 _LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
 184
 185 #endif
 186
 187 exception_ptr::~exception_ptr() _NOEXCEPT
 188 {
 189 #if HAVE_DEPENDENT_EH_ABI
 190     __cxa_decrement_exception_refcount(__ptr_);
 191 #elif defined(__GLIBCXX__)
 192     reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
 193 #else
 194 #   if defined(_MSC_VER) && ! defined(__clang__)
 195         _LIBCPP_WARNING("exception_ptr not yet implemented")
 196 #   else
 197 #       warning exception_ptr not yet implemented
 198 #   endif
 199     fprintf(stderr, "exception_ptr not yet implemented\n");
 200     ::abort();
 201 #endif
 202 }
 203
 204 exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
 205     : __ptr_(other.__ptr_)
 206 {
 207 #if HAVE_DEPENDENT_EH_ABI
 208     __cxa_increment_exception_refcount(__ptr_);
 209 #elif defined(__GLIBCXX__)
 210     new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
 211         reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
 212 #else
 213 #   if defined(_MSC_VER) && ! defined(__clang__)
 214         _LIBCPP_WARNING("exception_ptr not yet implemented")
 215 #   else
 216 #       warning exception_ptr not yet implemented
 217 #   endif
 218     fprintf(stderr, "exception_ptr not yet implemented\n");
 219     ::abort();
 220 #endif
 221 }
 222
 223 exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
 224 {
 225 #if HAVE_DEPENDENT_EH_ABI
 226     if (__ptr_ != other.__ptr_)
 227     {
 228         __cxa_increment_exception_refcount(other.__ptr_);
 229         __cxa_decrement_exception_refcount(__ptr_);
 230         __ptr_ = other.__ptr_;
 231     }
 232     return *this;
 233 #elif defined(__GLIBCXX__)
 234     *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
 235         reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
 236     return *this;
 237 #else
 238 #   if defined(_MSC_VER) && ! defined(__clang__)
 239         _LIBCPP_WARNING("exception_ptr not yet implemented")
 240 #   else
 241 #       warning exception_ptr not yet implemented
 242 #   endif
 243     fprintf(stderr, "exception_ptr not yet implemented\n");
 244     ::abort();
 245 #endif
 246 }
 247
 248 nested_exception::nested_exception() _NOEXCEPT
 249     : __ptr_(current_exception())
 250 {
 251 }
 252
 253 #if !defined(__GLIBCXX__)
 254
 255 nested_exception::~nested_exception() _NOEXCEPT
 256 {
 257 }
 258
 259 #endif
 260
 261 _LIBCPP_NORETURN
 262 void
 263 nested_exception::rethrow_nested() const
 264 {
 265     if (__ptr_ == nullptr)
 266         terminate();
 267     rethrow_exception(__ptr_);
 268 }
 269
 270 #if !defined(__GLIBCXX__)
 271
 272 exception_ptr current_exception() _NOEXCEPT
 273 {
 274 #if HAVE_DEPENDENT_EH_ABI
 275     // be nicer if there was a constructor that took a ptr, then
 276     // this whole function would be just:
 277     //    return exception_ptr(__cxa_current_primary_exception());
 278     exception_ptr ptr;
 279     ptr.__ptr_ = __cxa_current_primary_exception();
 280     return ptr;
 281 #else
 282 #   if defined(_MSC_VER) && ! defined(__clang__)
 283         _LIBCPP_WARNING( "exception_ptr not yet implemented" )
 284 #   else
 285 #       warning exception_ptr not yet implemented
 286 #   endif
 287     fprintf(stderr, "exception_ptr not yet implemented\n");
 288     ::abort();
 289 #endif
 290 }
 291
 292 #endif  // !__GLIBCXX__
 293
 294 _LIBCPP_NORETURN
 295 void rethrow_exception(exception_ptr p)
 296 {
 297 #if HAVE_DEPENDENT_EH_ABI
 298     __cxa_rethrow_primary_exception(p.__ptr_);
 299     // if p.__ptr_ is NULL, above returns so we terminate
 300     terminate();
 301 #elif defined(__GLIBCXX__)
 302     rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
 303 #else
 304 #   if defined(_MSC_VER) && ! defined(__clang__)
 305         _LIBCPP_WARNING("exception_ptr not yet implemented")
 306 #   else
 307 #       warning exception_ptr not yet implemented
 308 #   endif
 309     fprintf(stderr, "exception_ptr not yet implemented\n");
 310     ::abort();
 311 #endif
 312 }
 313 } // std