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/is_base_of.h> 17 #include <__type_traits/is_class.h> 18 #include <__type_traits/is_convertible.h> 19 #include <__type_traits/is_copy_constructible.h> 20 #include <__type_traits/is_final.h> 21 #include <__type_traits/is_polymorphic.h> 22 #include <__utility/forward.h> 23 #include <cstddef> 24 25 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 26 # pragma GCC system_header 27 #endif 28 29 namespace std { // purposefully not using versioning namespace 30 31 class _LIBCPP_EXPORTED_FROM_ABI nested_exception { 32 exception_ptr __ptr_; 33 34 public: 35 nested_exception() _NOEXCEPT; 36 // nested_exception(const nested_exception&) noexcept = default; 37 // nested_exception& operator=(const nested_exception&) noexcept = default; 38 virtual ~nested_exception() _NOEXCEPT; 39 40 // access functions 41 _LIBCPP_NORETURN void rethrow_nested() const; 42 _LIBCPP_HIDE_FROM_ABI exception_ptr nested_ptr() const _NOEXCEPT { return __ptr_; } 43 }; 44 45 template <class _Tp> 46 struct __nested : public _Tp, public nested_exception { 47 _LIBCPP_HIDE_FROM_ABI explicit __nested(const _Tp& __t) : _Tp(__t) {} 48 }; 49 50 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 51 template <class _Tp, class _Up, bool> 52 struct __throw_with_nested; 53 54 template <class _Tp, class _Up> 55 struct __throw_with_nested<_Tp, _Up, true> { 56 _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void __do_throw(_Tp&& __t) { 57 throw __nested<_Up>(std::forward<_Tp>(__t)); 58 } 59 }; 60 61 template <class _Tp, class _Up> 62 struct __throw_with_nested<_Tp, _Up, false> { 63 _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void __do_throw(_Tp&& __t) { throw std::forward<_Tp>(__t); } 64 }; 65 #endif 66 67 template <class _Tp> 68 _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void throw_with_nested(_Tp&& __t) { 69 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 70 using _Up = __decay_t<_Tp>; 71 static_assert(is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible"); 72 __throw_with_nested<_Tp, 73 _Up, 74 is_class<_Up>::value && !is_base_of<nested_exception, _Up>::value && 75 !__libcpp_is_final<_Up>::value>::__do_throw(std::forward<_Tp>(__t)); 76 #else 77 ((void)__t); 78 // FIXME: Make this abort 79 #endif 80 } 81 82 template <class _From, class _To> 83 struct __can_dynamic_cast 84 : _BoolConstant< is_polymorphic<_From>::value && 85 (!is_base_of<_To, _From>::value || is_convertible<const _From*, const _To*>::value)> {}; 86 87 template <class _Ep> 88 inline _LIBCPP_HIDE_FROM_ABI void 89 rethrow_if_nested(const _Ep& __e, __enable_if_t< __can_dynamic_cast<_Ep, nested_exception>::value>* = 0) { 90 const nested_exception* __nep = dynamic_cast<const nested_exception*>(std::addressof(__e)); 91 if (__nep) 92 __nep->rethrow_nested(); 93 } 94 95 template <class _Ep> 96 inline _LIBCPP_HIDE_FROM_ABI void 97 rethrow_if_nested(const _Ep&, __enable_if_t<!__can_dynamic_cast<_Ep, nested_exception>::value>* = 0) {} 98 99 } // namespace std 100 101 #endif // _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H 102