1// -*- C++ -*- 2//===-------------------------- exception ---------------------------------===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_EXCEPTION 11#define _LIBCPP_EXCEPTION 12 13/* 14 exception synopsis 15 16namespace std 17{ 18 19class exception 20{ 21public: 22 exception() noexcept; 23 exception(const exception&) noexcept; 24 exception& operator=(const exception&) noexcept; 25 virtual ~exception() noexcept; 26 virtual const char* what() const noexcept; 27}; 28 29class bad_exception 30 : public exception 31{ 32public: 33 bad_exception() noexcept; 34 bad_exception(const bad_exception&) noexcept; 35 bad_exception& operator=(const bad_exception&) noexcept; 36 virtual ~bad_exception() noexcept; 37 virtual const char* what() const noexcept; 38}; 39 40typedef void (*unexpected_handler)(); 41unexpected_handler set_unexpected(unexpected_handler f ) noexcept; 42unexpected_handler get_unexpected() noexcept; 43[[noreturn]] void unexpected(); 44 45typedef void (*terminate_handler)(); 46terminate_handler set_terminate(terminate_handler f ) noexcept; 47terminate_handler get_terminate() noexcept; 48[[noreturn]] void terminate() noexcept; 49 50bool uncaught_exception() noexcept; 51int uncaught_exceptions() noexcept; // C++17 52 53typedef unspecified exception_ptr; 54 55exception_ptr current_exception() noexcept; 56void rethrow_exception [[noreturn]] (exception_ptr p); 57template<class E> exception_ptr make_exception_ptr(E e) noexcept; 58 59class nested_exception 60{ 61public: 62 nested_exception() noexcept; 63 nested_exception(const nested_exception&) noexcept = default; 64 nested_exception& operator=(const nested_exception&) noexcept = default; 65 virtual ~nested_exception() = default; 66 67 // access functions 68 [[noreturn]] void rethrow_nested() const; 69 exception_ptr nested_ptr() const noexcept; 70}; 71 72template <class T> [[noreturn]] void throw_with_nested(T&& t); 73template <class E> void rethrow_if_nested(const E& e); 74 75} // std 76 77*/ 78 79#include <__config> 80#include <cstddef> 81#include <cstdlib> 82#include <type_traits> 83#include <version> 84 85#if defined(_LIBCPP_ABI_VCRUNTIME) 86#include <vcruntime_exception.h> 87#endif 88 89#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 90#pragma GCC system_header 91#endif 92 93namespace std // purposefully not using versioning namespace 94{ 95 96#if !defined(_LIBCPP_ABI_VCRUNTIME) 97class _LIBCPP_EXCEPTION_ABI exception 98{ 99public: 100 _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {} 101 _LIBCPP_INLINE_VISIBILITY exception(const exception&) _NOEXCEPT = default; 102 103 virtual ~exception() _NOEXCEPT; 104 virtual const char* what() const _NOEXCEPT; 105}; 106 107class _LIBCPP_EXCEPTION_ABI bad_exception 108 : public exception 109{ 110public: 111 _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {} 112 virtual ~bad_exception() _NOEXCEPT; 113 virtual const char* what() const _NOEXCEPT; 114}; 115#endif // !_LIBCPP_ABI_VCRUNTIME 116 117#if _LIBCPP_STD_VER <= 14 \ 118 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \ 119 || defined(_LIBCPP_BUILDING_LIBRARY) 120typedef void (*unexpected_handler)(); 121_LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT; 122_LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT; 123_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected(); 124#endif 125 126typedef void (*terminate_handler)(); 127_LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT; 128_LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT; 129_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT; 130 131_LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT; 132_LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS int uncaught_exceptions() _NOEXCEPT; 133 134class _LIBCPP_TYPE_VIS exception_ptr; 135 136_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT; 137_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr); 138 139#ifndef _LIBCPP_ABI_MICROSOFT 140 141class _LIBCPP_TYPE_VIS exception_ptr 142{ 143 void* __ptr_; 144public: 145 _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {} 146 _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {} 147 148 exception_ptr(const exception_ptr&) _NOEXCEPT; 149 exception_ptr& operator=(const exception_ptr&) _NOEXCEPT; 150 ~exception_ptr() _NOEXCEPT; 151 152 _LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT 153 {return __ptr_ != nullptr;} 154 155 friend _LIBCPP_INLINE_VISIBILITY 156 bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT 157 {return __x.__ptr_ == __y.__ptr_;} 158 159 friend _LIBCPP_INLINE_VISIBILITY 160 bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT 161 {return !(__x == __y);} 162 163 friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT; 164 friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr); 165}; 166 167template<class _Ep> 168_LIBCPP_INLINE_VISIBILITY exception_ptr 169make_exception_ptr(_Ep __e) _NOEXCEPT 170{ 171#ifndef _LIBCPP_NO_EXCEPTIONS 172 try 173 { 174 throw __e; 175 } 176 catch (...) 177 { 178 return current_exception(); 179 } 180#else 181 ((void)__e); 182 _VSTD::abort(); 183#endif 184} 185 186#else // _LIBCPP_ABI_MICROSOFT 187 188class _LIBCPP_TYPE_VIS exception_ptr 189{ 190#if defined(__clang__) 191#pragma clang diagnostic push 192#pragma clang diagnostic ignored "-Wunused-private-field" 193#endif 194 void* __ptr1_; 195 void* __ptr2_; 196#if defined(__clang__) 197#pragma clang diagnostic pop 198#endif 199public: 200 exception_ptr() _NOEXCEPT; 201 exception_ptr(nullptr_t) _NOEXCEPT; 202 exception_ptr(const exception_ptr& __other) _NOEXCEPT; 203 exception_ptr& operator=(const exception_ptr& __other) _NOEXCEPT; 204 exception_ptr& operator=(nullptr_t) _NOEXCEPT; 205 ~exception_ptr() _NOEXCEPT; 206 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT; 207}; 208 209_LIBCPP_FUNC_VIS 210bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT; 211 212inline _LIBCPP_INLINE_VISIBILITY 213bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT 214 {return !(__x == __y);} 215 216_LIBCPP_FUNC_VIS void swap(exception_ptr&, exception_ptr&) _NOEXCEPT; 217 218_LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void *__except, const void* __ptr); 219_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT; 220_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr p); 221 222// This is a built-in template function which automagically extracts the required 223// information. 224template <class _E> void *__GetExceptionInfo(_E); 225 226template<class _Ep> 227_LIBCPP_INLINE_VISIBILITY exception_ptr 228make_exception_ptr(_Ep __e) _NOEXCEPT 229{ 230 return __copy_exception_ptr(_VSTD::addressof(__e), __GetExceptionInfo(__e)); 231} 232 233#endif // _LIBCPP_ABI_MICROSOFT 234// nested_exception 235 236class _LIBCPP_EXCEPTION_ABI nested_exception 237{ 238 exception_ptr __ptr_; 239public: 240 nested_exception() _NOEXCEPT; 241// nested_exception(const nested_exception&) noexcept = default; 242// nested_exception& operator=(const nested_exception&) noexcept = default; 243 virtual ~nested_exception() _NOEXCEPT; 244 245 // access functions 246 _LIBCPP_NORETURN void rethrow_nested() const; 247 _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;} 248}; 249 250template <class _Tp> 251struct __nested 252 : public _Tp, 253 public nested_exception 254{ 255 _LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {} 256}; 257 258#ifndef _LIBCPP_NO_EXCEPTIONS 259template <class _Tp, class _Up, bool> 260struct __throw_with_nested; 261 262template <class _Tp, class _Up> 263struct __throw_with_nested<_Tp, _Up, true> { 264 _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void 265 __do_throw(_Tp&& __t) 266 { 267 throw __nested<_Up>(_VSTD::forward<_Tp>(__t)); 268 } 269}; 270 271template <class _Tp, class _Up> 272struct __throw_with_nested<_Tp, _Up, false> { 273 _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void 274#ifndef _LIBCPP_CXX03_LANG 275 __do_throw(_Tp&& __t) 276#else 277 __do_throw (_Tp& __t) 278#endif // _LIBCPP_CXX03_LANG 279 { 280 throw _VSTD::forward<_Tp>(__t); 281 } 282}; 283#endif 284 285template <class _Tp> 286_LIBCPP_NORETURN 287void 288throw_with_nested(_Tp&& __t) 289{ 290#ifndef _LIBCPP_NO_EXCEPTIONS 291 typedef typename decay<_Tp>::type _Up; 292 static_assert( is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible"); 293 __throw_with_nested<_Tp, _Up, 294 is_class<_Up>::value && 295 !is_base_of<nested_exception, _Up>::value && 296 !__libcpp_is_final<_Up>::value>:: 297 __do_throw(_VSTD::forward<_Tp>(__t)); 298#else 299 ((void)__t); 300 // FIXME: Make this abort 301#endif 302} 303 304template <class _From, class _To> 305struct __can_dynamic_cast : public _LIBCPP_BOOL_CONSTANT( 306 is_polymorphic<_From>::value && 307 (!is_base_of<_To, _From>::value || 308 is_convertible<const _From*, const _To*>::value)) {}; 309 310template <class _Ep> 311inline _LIBCPP_INLINE_VISIBILITY 312void 313rethrow_if_nested(const _Ep& __e, 314 typename enable_if< __can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0) 315{ 316 const nested_exception* __nep = dynamic_cast<const nested_exception*>(_VSTD::addressof(__e)); 317 if (__nep) 318 __nep->rethrow_nested(); 319} 320 321template <class _Ep> 322inline _LIBCPP_INLINE_VISIBILITY 323void 324rethrow_if_nested(const _Ep&, 325 typename enable_if<!__can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0) 326{ 327} 328 329} // std 330 331#endif // _LIBCPP_EXCEPTION 332