1 //===----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H 10 #define _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H 11 12 #include <__config> 13 #include <__exception/exception_ptr.h> 14 #include <__memory/addressof.h> 15 #include <__type_traits/decay.h> 16 #include <__type_traits/enable_if.h> 17 #include <__type_traits/integral_constant.h> 18 #include <__type_traits/is_base_of.h> 19 #include <__type_traits/is_class.h> 20 #include <__type_traits/is_constructible.h> 21 #include <__type_traits/is_convertible.h> 22 #include <__type_traits/is_final.h> 23 #include <__type_traits/is_polymorphic.h> 24 #include <__utility/forward.h> 25 #include <cstddef> 26 27 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 28 # pragma GCC system_header 29 #endif 30 31 namespace std { // purposefully not using versioning namespace 32 33 class _LIBCPP_EXPORTED_FROM_ABI nested_exception { 34 exception_ptr __ptr_; 35 36 public: 37 nested_exception() _NOEXCEPT; 38 _LIBCPP_HIDE_FROM_ABI nested_exception(const nested_exception&) _NOEXCEPT = default; 39 _LIBCPP_HIDE_FROM_ABI nested_exception& operator=(const nested_exception&) _NOEXCEPT = default; 40 virtual ~nested_exception() _NOEXCEPT; 41 42 // access functions 43 _LIBCPP_NORETURN void rethrow_nested() const; 44 _LIBCPP_HIDE_FROM_ABI exception_ptr nested_ptr() const _NOEXCEPT { return __ptr_; } 45 }; 46 47 template <class _Tp> 48 struct __nested : public _Tp, public nested_exception { 49 _LIBCPP_HIDE_FROM_ABI explicit __nested(const _Tp& __t) : _Tp(__t) {} 50 }; 51 52 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 53 template <class _Tp, class _Up, bool> 54 struct __throw_with_nested; 55 56 template <class _Tp, class _Up> 57 struct __throw_with_nested<_Tp, _Up, true> { 58 _LIBCPP_NORETURN static inline _LIBCPP_HIDE_FROM_ABI void __do_throw(_Tp&& __t) { 59 throw __nested<_Up>(std::forward<_Tp>(__t)); 60 } 61 }; 62 63 template <class _Tp, class _Up> 64 struct __throw_with_nested<_Tp, _Up, false> { 65 _LIBCPP_NORETURN static inline _LIBCPP_HIDE_FROM_ABI void __do_throw(_Tp&& __t) { throw std::forward<_Tp>(__t); } 66 }; 67 #endif 68 69 template <class _Tp> 70 _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void throw_with_nested(_Tp&& __t) { 71 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 72 using _Up = __decay_t<_Tp>; 73 static_assert(is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible"); 74 __throw_with_nested<_Tp, 75 _Up, 76 is_class<_Up>::value && !is_base_of<nested_exception, _Up>::value && 77 !__libcpp_is_final<_Up>::value>::__do_throw(std::forward<_Tp>(__t)); 78 #else 79 ((void)__t); 80 // FIXME: Make this abort 81 #endif 82 } 83 84 template <class _From, class _To> 85 struct __can_dynamic_cast 86 : _BoolConstant< is_polymorphic<_From>::value && 87 (!is_base_of<_To, _From>::value || is_convertible<const _From*, const _To*>::value)> {}; 88 89 template <class _Ep, __enable_if_t< __can_dynamic_cast<_Ep, nested_exception>::value, int> = 0> 90 inline _LIBCPP_HIDE_FROM_ABI void rethrow_if_nested(const _Ep& __e) { 91 const nested_exception* __nep = dynamic_cast<const nested_exception*>(std::addressof(__e)); 92 if (__nep) 93 __nep->rethrow_nested(); 94 } 95 96 template <class _Ep, __enable_if_t<!__can_dynamic_cast<_Ep, nested_exception>::value, int> = 0> 97 inline _LIBCPP_HIDE_FROM_ABI void rethrow_if_nested(const _Ep&) {} 98 99 } // namespace std 100 101 #endif // _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H 102