1 // Exception Handling support header (exception_ptr class) for -*- C++ -*-
3 // Copyright (C) 2008-2021 Free Software Foundation, Inc.
5 // This file is part of GCC.
7 // GCC is free software; you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by
9 // the Free Software Foundation; either version 3, or (at your option)
12 // GCC is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
17 // Under Section 7 of GPL version 3, you are granted additional
18 // permissions described in the GCC Runtime Library Exception, version
19 // 3.1, as published by the Free Software Foundation.
21 // You should have received a copy of the GNU General Public License and
22 // a copy of the GCC Runtime Library Exception along with this program;
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 // <http://www.gnu.org/licenses/>.
26 /** @file bits/exception_ptr.h
27 * This is an internal header file, included by other library headers.
28 * Do not attempt to use it directly. @headername{exception}
31 #ifndef _EXCEPTION_PTR_H
32 #define _EXCEPTION_PTR_H
34 #pragma GCC visibility push(default)
36 #include <bits/c++config.h>
37 #include <bits/exception_defines.h>
38 #include <bits/cxxabi_init_exception.h>
42 #if __cplusplus >= 201103L
43 # include <bits/move.h>
46 #ifdef _GLIBCXX_EH_PTR_RELOPS_COMPAT
47 # define _GLIBCXX_EH_PTR_USED __attribute__((__used__))
49 # define _GLIBCXX_EH_PTR_USED
59 * @addtogroup exceptions
63 namespace __exception_ptr
68 using __exception_ptr::exception_ptr
;
70 /** Obtain an exception_ptr to the currently handled exception. If there
71 * is none, or the currently handled exception is foreign, return the null
74 exception_ptr
current_exception() _GLIBCXX_USE_NOEXCEPT
;
76 template<typename _Ex
>
77 exception_ptr
make_exception_ptr(_Ex
) _GLIBCXX_USE_NOEXCEPT
;
79 /// Throw the object pointed to by the exception_ptr.
80 void rethrow_exception(exception_ptr
) __attribute__ ((__noreturn__
));
82 namespace __exception_ptr
84 using std::rethrow_exception
;
87 * @brief An opaque pointer to an arbitrary exception.
92 void* _M_exception_object
;
94 explicit exception_ptr(void* __e
) _GLIBCXX_USE_NOEXCEPT
;
96 void _M_addref() _GLIBCXX_USE_NOEXCEPT
;
97 void _M_release() _GLIBCXX_USE_NOEXCEPT
;
99 void *_M_get() const _GLIBCXX_NOEXCEPT
__attribute__ ((__pure__
));
101 friend exception_ptr
std::current_exception() _GLIBCXX_USE_NOEXCEPT
;
102 friend void std::rethrow_exception(exception_ptr
);
103 template<typename _Ex
>
104 friend exception_ptr
std::make_exception_ptr(_Ex
) _GLIBCXX_USE_NOEXCEPT
;
107 exception_ptr() _GLIBCXX_USE_NOEXCEPT
;
109 exception_ptr(const exception_ptr
&) _GLIBCXX_USE_NOEXCEPT
;
111 #if __cplusplus >= 201103L
112 exception_ptr(nullptr_t
) noexcept
113 : _M_exception_object(nullptr)
116 exception_ptr(exception_ptr
&& __o
) noexcept
117 : _M_exception_object(__o
._M_exception_object
)
118 { __o
._M_exception_object
= nullptr; }
121 #if (__cplusplus < 201103L) || defined (_GLIBCXX_EH_PTR_COMPAT)
122 typedef void (exception_ptr::*__safe_bool
)();
124 // For construction from nullptr or 0.
125 exception_ptr(__safe_bool
) _GLIBCXX_USE_NOEXCEPT
;
129 operator=(const exception_ptr
&) _GLIBCXX_USE_NOEXCEPT
;
131 #if __cplusplus >= 201103L
133 operator=(exception_ptr
&& __o
) noexcept
135 exception_ptr(static_cast<exception_ptr
&&>(__o
)).swap(*this);
140 ~exception_ptr() _GLIBCXX_USE_NOEXCEPT
;
143 swap(exception_ptr
&) _GLIBCXX_USE_NOEXCEPT
;
145 #ifdef _GLIBCXX_EH_PTR_COMPAT
146 // Retained for compatibility with CXXABI_1.3.
147 void _M_safe_bool_dummy() _GLIBCXX_USE_NOEXCEPT
148 __attribute__ ((__const__
));
149 bool operator!() const _GLIBCXX_USE_NOEXCEPT
150 __attribute__ ((__pure__
));
151 operator __safe_bool() const _GLIBCXX_USE_NOEXCEPT
;
154 #if __cplusplus >= 201103L
155 explicit operator bool() const noexcept
156 { return _M_exception_object
; }
159 #if __cpp_impl_three_way_comparison >= 201907L \
160 && ! defined _GLIBCXX_EH_PTR_RELOPS_COMPAT
162 operator==(const exception_ptr
&, const exception_ptr
&) noexcept
= default;
164 friend _GLIBCXX_EH_PTR_USED
bool
165 operator==(const exception_ptr
& __x
, const exception_ptr
& __y
)
166 _GLIBCXX_USE_NOEXCEPT
167 { return __x
._M_exception_object
== __y
._M_exception_object
; }
169 friend _GLIBCXX_EH_PTR_USED
bool
170 operator!=(const exception_ptr
& __x
, const exception_ptr
& __y
)
171 _GLIBCXX_USE_NOEXCEPT
172 { return __x
._M_exception_object
!= __y
._M_exception_object
; }
175 const class std::type_info
*
176 __cxa_exception_type() const _GLIBCXX_USE_NOEXCEPT
177 __attribute__ ((__pure__
));
182 exception_ptr::exception_ptr() _GLIBCXX_USE_NOEXCEPT
183 : _M_exception_object(0)
188 exception_ptr::exception_ptr(const exception_ptr
& __other
)
189 _GLIBCXX_USE_NOEXCEPT
190 : _M_exception_object(__other
._M_exception_object
)
192 if (_M_exception_object
)
198 exception_ptr::~exception_ptr() _GLIBCXX_USE_NOEXCEPT
200 if (_M_exception_object
)
205 inline exception_ptr
&
206 exception_ptr::operator=(const exception_ptr
& __other
) _GLIBCXX_USE_NOEXCEPT
208 exception_ptr(__other
).swap(*this);
214 exception_ptr::swap(exception_ptr
&__other
) _GLIBCXX_USE_NOEXCEPT
216 void *__tmp
= _M_exception_object
;
217 _M_exception_object
= __other
._M_exception_object
;
218 __other
._M_exception_object
= __tmp
;
221 /// @relates exception_ptr
223 swap(exception_ptr
& __lhs
, exception_ptr
& __rhs
)
224 { __lhs
.swap(__rhs
); }
226 /// @cond undocumented
227 template<typename _Ex
>
228 _GLIBCXX_CDTOR_CALLABI
230 __dest_thunk(void* __x
)
231 { static_cast<_Ex
*>(__x
)->~_Ex(); }
234 } // namespace __exception_ptr
236 /// Obtain an exception_ptr pointing to a copy of the supplied object.
237 #if (__cplusplus >= 201103L && __cpp_rtti) || __cpp_exceptions
238 template<typename _Ex
>
240 make_exception_ptr(_Ex __ex
) _GLIBCXX_USE_NOEXCEPT
242 #if __cplusplus >= 201103L && __cpp_rtti
243 using _Ex2
= typename decay
<_Ex
>::type
;
244 void* __e
= __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex
));
245 (void) __cxxabiv1::__cxa_init_primary_exception(
246 __e
, const_cast<std::type_info
*>(&typeid(_Ex
)),
247 __exception_ptr::__dest_thunk
<_Ex2
>);
250 ::new (__e
) _Ex2(__ex
);
251 return exception_ptr(__e
);
255 __cxxabiv1::__cxa_free_exception(__e
);
256 return current_exception();
265 return current_exception();
269 #else // no RTTI and no exceptions
270 // This is always_inline so the linker will never use this useless definition
271 // instead of a working one compiled with RTTI and/or exceptions enabled.
272 template<typename _Ex
>
273 __attribute__ ((__always_inline__
))
275 make_exception_ptr(_Ex
) _GLIBCXX_USE_NOEXCEPT
276 { return exception_ptr(); }
279 #undef _GLIBCXX_EH_PTR_USED
281 /// @} group exceptions
286 #pragma GCC visibility pop