blob: 09e52ae7bb1098b3b7fc86555e81dec77ea8c7b5 [file] [log] [blame]
Marshall Clowe2dcb752011-07-20 15:04:39 +00001//===------------------------- cxa_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// This file implements the "Exception Handling APIs"
Jonathan Roelofsc5f7e6f2014-02-12 04:49:09 +000010// http://mentorembedded.github.io/cxx-abi/abi-eh.html
Marshall Clowe2dcb752011-07-20 15:04:39 +000011//
12//===----------------------------------------------------------------------===//
13
Jonathan Roelofs40e98422014-05-06 21:30:56 +000014#include "config.h"
Marshall Clowe2dcb752011-07-20 15:04:39 +000015#include "cxxabi.h"
16
17#include <exception> // for std::terminate
Howard Hinnant862c4a02013-06-17 18:10:34 +000018#include <cstring> // for memset
Marshall Clowe2dcb752011-07-20 15:04:39 +000019#include "cxa_exception.hpp"
Howard Hinnant5ec91832011-12-07 21:16:40 +000020#include "cxa_handlers.hpp"
Igor Kudrind9edde42016-10-07 08:48:28 +000021#include "fallback_malloc.h"
Marshall Clowe2dcb752011-07-20 15:04:39 +000022
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000023// +---------------------------+-----------------------------+---------------+
24// | __cxa_exception | _Unwind_Exception CLNGC++\0 | thrown object |
25// +---------------------------+-----------------------------+---------------+
26// ^
27// |
28// +-------------------------------------------------------+
29// |
30// +---------------------------+-----------------------------+
31// | __cxa_dependent_exception | _Unwind_Exception CLNGC++\1 |
32// +---------------------------+-----------------------------+
33
Marshall Clowe2dcb752011-07-20 15:04:39 +000034namespace __cxxabiv1 {
Howard Hinnant6830b2a2012-01-24 18:15:20 +000035
Marshall Clowe2dcb752011-07-20 15:04:39 +000036// Utility routines
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000037static
38inline
39__cxa_exception*
Howard Hinnant47cb85482012-01-30 16:07:00 +000040cxa_exception_from_thrown_object(void* thrown_object)
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000041{
42 return static_cast<__cxa_exception*>(thrown_object) - 1;
Marshall Clow9b454bc2011-08-15 18:06:47 +000043}
Marshall Clowe2dcb752011-07-20 15:04:39 +000044
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000045// Note: This is never called when exception_header is masquerading as a
46// __cxa_dependent_exception.
47static
48inline
49void*
Howard Hinnant47cb85482012-01-30 16:07:00 +000050thrown_object_from_cxa_exception(__cxa_exception* exception_header)
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000051{
52 return static_cast<void*>(exception_header + 1);
Marshall Clow9b454bc2011-08-15 18:06:47 +000053}
Marshall Clowe2dcb752011-07-20 15:04:39 +000054
Marshall Clow87694492011-08-09 15:09:41 +000055// Get the exception object from the unwind pointer.
56// Relies on the structure layout, where the unwind pointer is right in
57// front of the user's exception object
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000058static
59inline
60__cxa_exception*
Howard Hinnant47cb85482012-01-30 16:07:00 +000061cxa_exception_from_exception_unwind_exception(_Unwind_Exception* unwind_exception)
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000062{
63 return cxa_exception_from_thrown_object(unwind_exception + 1 );
Marshall Clow9b454bc2011-08-15 18:06:47 +000064}
Marshall Clow87694492011-08-09 15:09:41 +000065
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000066static
67inline
68size_t
Howard Hinnant47cb85482012-01-30 16:07:00 +000069cxa_exception_size_from_exception_thrown_size(size_t size)
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000070{
71 return size + sizeof (__cxa_exception);
Marshall Clow9b454bc2011-08-15 18:06:47 +000072}
Marshall Clow87694492011-08-09 15:09:41 +000073
Howard Hinnant47cb85482012-01-30 16:07:00 +000074static void setExceptionClass(_Unwind_Exception* unwind_exception) {
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000075 unwind_exception->exception_class = kOurExceptionClass;
76}
77
Howard Hinnant47cb85482012-01-30 16:07:00 +000078static void setDependentExceptionClass(_Unwind_Exception* unwind_exception) {
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000079 unwind_exception->exception_class = kOurDependentExceptionClass;
Marshall Clow9b454bc2011-08-15 18:06:47 +000080}
Marshall Clow87694492011-08-09 15:09:41 +000081
82// Is it one of ours?
Howard Hinnant47cb85482012-01-30 16:07:00 +000083static bool isOurExceptionClass(const _Unwind_Exception* unwind_exception) {
Howard Hinnant8aa78512012-02-01 18:15:15 +000084 return (unwind_exception->exception_class & get_vendor_and_language) ==
85 (kOurExceptionClass & get_vendor_and_language);
Marshall Clow9b454bc2011-08-15 18:06:47 +000086}
Marshall Clow87694492011-08-09 15:09:41 +000087
Howard Hinnant47cb85482012-01-30 16:07:00 +000088static bool isDependentException(_Unwind_Exception* unwind_exception) {
Howard Hinnantafcf7ac2012-01-22 19:14:27 +000089 return (unwind_exception->exception_class & 0xFF) == 0x01;
Marshall Clow9b454bc2011-08-15 18:06:47 +000090}
91
Howard Hinnant6ccae152011-12-08 19:35:18 +000092// This does not need to be atomic
Howard Hinnant47cb85482012-01-30 16:07:00 +000093static inline int incrementHandlerCount(__cxa_exception *exception) {
Howard Hinnant6ccae152011-12-08 19:35:18 +000094 return ++exception->handlerCount;
Marshall Clow9b454bc2011-08-15 18:06:47 +000095}
96
Howard Hinnant6ccae152011-12-08 19:35:18 +000097// This does not need to be atomic
Howard Hinnant47cb85482012-01-30 16:07:00 +000098static inline int decrementHandlerCount(__cxa_exception *exception) {
Howard Hinnant6ccae152011-12-08 19:35:18 +000099 return --exception->handlerCount;
Marshall Clow9b454bc2011-08-15 18:06:47 +0000100}
Marshall Clow87694492011-08-09 15:09:41 +0000101
Howard Hinnant5ec91832011-12-07 21:16:40 +0000102/*
Marshall Clow87694492011-08-09 15:09:41 +0000103 If reason isn't _URC_FOREIGN_EXCEPTION_CAUGHT, then the terminateHandler
104 stored in exc is called. Otherwise the exceptionDestructor stored in
105 exc is called, and then the memory for the exception is deallocated.
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000106
107 This is never called for a __cxa_dependent_exception.
Marshall Clow87694492011-08-09 15:09:41 +0000108*/
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000109static
110void
111exception_cleanup_func(_Unwind_Reason_Code reason, _Unwind_Exception* unwind_exception)
112{
113 __cxa_exception* exception_header = cxa_exception_from_exception_unwind_exception(unwind_exception);
Marshall Clow9b454bc2011-08-15 18:06:47 +0000114 if (_URC_FOREIGN_EXCEPTION_CAUGHT != reason)
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000115 std::__terminate(exception_header->terminateHandler);
Howard Hinnantd0bfbb32012-02-01 18:44:21 +0000116 // Just in case there exists a dependent exception that is pointing to this,
117 // check the reference count and only destroy this if that count goes to zero.
118 __cxa_decrement_exception_refcount(unwind_exception + 1);
Marshall Clow9b454bc2011-08-15 18:06:47 +0000119}
Marshall Clow87694492011-08-09 15:09:41 +0000120
Eric Fiselier71e32922017-03-01 02:23:54 +0000121static _LIBCXXABI_NORETURN void failed_throw(__cxa_exception* exception_header) {
Marshall Clow87694492011-08-09 15:09:41 +0000122// Section 2.5.3 says:
123// * For purposes of this ABI, several things are considered exception handlers:
124// ** A terminate() call due to a throw.
125// and
126// * Upon entry, Following initialization of the catch parameter,
127// a handler must call:
Marshall Clow9b454bc2011-08-15 18:06:47 +0000128// * void *__cxa_begin_catch(void *exceptionObject );
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000129 (void) __cxa_begin_catch(&exception_header->unwindHeader);
130 std::__terminate(exception_header->terminateHandler);
Marshall Clow9b454bc2011-08-15 18:06:47 +0000131}
Marshall Clowe2dcb752011-07-20 15:04:39 +0000132
133extern "C" {
134
135// Allocate a __cxa_exception object, and zero-fill it.
136// Reserve "thrown_size" bytes on the end for the user's exception
137// object. Zero-fill the object. If memory can't be allocated, call
138// std::terminate. Return a pointer to the memory to be used for the
139// user's exception object.
Shoaib Meenaife989a92017-03-01 03:55:57 +0000140void *__cxa_allocate_exception(size_t thrown_size) throw() {
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000141 size_t actual_size = cxa_exception_size_from_exception_thrown_size(thrown_size);
Igor Kudrind9edde42016-10-07 08:48:28 +0000142 __cxa_exception *exception_header =
143 static_cast<__cxa_exception *>(__malloc_with_fallback(actual_size));
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000144 if (NULL == exception_header)
Marshall Clow9b454bc2011-08-15 18:06:47 +0000145 std::terminate();
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000146 std::memset(exception_header, 0, actual_size);
147 return thrown_object_from_cxa_exception(exception_header);
Marshall Clow9b454bc2011-08-15 18:06:47 +0000148}
Marshall Clowe2dcb752011-07-20 15:04:39 +0000149
150
151// Free a __cxa_exception object allocated with __cxa_allocate_exception.
Shoaib Meenaife989a92017-03-01 03:55:57 +0000152void __cxa_free_exception(void *thrown_object) throw() {
Igor Kudrind9edde42016-10-07 08:48:28 +0000153 __free_with_fallback(cxa_exception_from_thrown_object(thrown_object));
Marshall Clow9b454bc2011-08-15 18:06:47 +0000154}
Marshall Clowe2dcb752011-07-20 15:04:39 +0000155
156
157// This function shall allocate a __cxa_dependent_exception and
158// return a pointer to it. (Really to the object, not past its' end).
159// Otherwise, it will work like __cxa_allocate_exception.
Howard Hinnant47cb85482012-01-30 16:07:00 +0000160void * __cxa_allocate_dependent_exception () {
Marshall Clow9b454bc2011-08-15 18:06:47 +0000161 size_t actual_size = sizeof(__cxa_dependent_exception);
Igor Kudrind9edde42016-10-07 08:48:28 +0000162 void *ptr = __malloc_with_fallback(actual_size);
Marshall Clow9b454bc2011-08-15 18:06:47 +0000163 if (NULL == ptr)
164 std::terminate();
165 std::memset(ptr, 0, actual_size);
Marshall Clowe2dcb752011-07-20 15:04:39 +0000166 return ptr;
Marshall Clow9b454bc2011-08-15 18:06:47 +0000167}
Marshall Clowe2dcb752011-07-20 15:04:39 +0000168
169
170// This function shall free a dependent_exception.
171// It does not affect the reference count of the primary exception.
Howard Hinnant47cb85482012-01-30 16:07:00 +0000172void __cxa_free_dependent_exception (void * dependent_exception) {
Igor Kudrind9edde42016-10-07 08:48:28 +0000173 __free_with_fallback(dependent_exception);
Marshall Clow9b454bc2011-08-15 18:06:47 +0000174}
Marshall Clowe2dcb752011-07-20 15:04:39 +0000175
Marshall Clow87694492011-08-09 15:09:41 +0000176
177// 2.4.3 Throwing the Exception Object
178/*
179After constructing the exception object with the throw argument value,
180the generated code calls the __cxa_throw runtime library routine. This
181routine never returns.
182
183The __cxa_throw routine will do the following:
184
185* Obtain the __cxa_exception header from the thrown exception object address,
186which can be computed as follows:
187 __cxa_exception *header = ((__cxa_exception *) thrown_exception - 1);
188* Save the current unexpected_handler and terminate_handler in the __cxa_exception header.
189* Save the tinfo and dest arguments in the __cxa_exception header.
190* Set the exception_class field in the unwind header. This is a 64-bit value
191representing the ASCII string "XXXXC++\0", where "XXXX" is a
192vendor-dependent string. That is, for implementations conforming to this
193ABI, the low-order 4 bytes of this 64-bit value will be "C++\0".
194* Increment the uncaught_exception flag.
195* Call _Unwind_RaiseException in the system unwind library, Its argument is the
196pointer to the thrown exception, which __cxa_throw itself received as an argument.
197__Unwind_RaiseException begins the process of stack unwinding, described
198in Section 2.5. In special cases, such as an inability to find a
199handler, _Unwind_RaiseException may return. In that case, __cxa_throw
200will call terminate, assuming that there was no handler for the
201exception.
202*/
Shoaib Meenaife989a92017-03-01 03:55:57 +0000203void
Saleem Abdulrasool12315ed2015-12-04 02:14:58 +0000204__cxa_throw(void *thrown_object, std::type_info *tinfo, void (*dest)(void *)) {
Marshall Clow9b454bc2011-08-15 18:06:47 +0000205 __cxa_eh_globals *globals = __cxa_get_globals();
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000206 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
Howard Hinnant6ccae152011-12-08 19:35:18 +0000207
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000208 exception_header->unexpectedHandler = std::get_unexpected();
209 exception_header->terminateHandler = std::get_terminate();
210 exception_header->exceptionType = tinfo;
211 exception_header->exceptionDestructor = dest;
212 setExceptionClass(&exception_header->unwindHeader);
213 exception_header->referenceCount = 1; // This is a newly allocated exception, no need for thread safety.
Marshall Clow87694492011-08-09 15:09:41 +0000214 globals->uncaughtExceptions += 1; // Not atomically, since globals are thread-local
215
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000216 exception_header->unwindHeader.exception_cleanup = exception_cleanup_func;
Dan Albert3bd13ca2015-02-05 01:33:15 +0000217#ifdef __USING_SJLJ_EXCEPTIONS__
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000218 _Unwind_SjLj_RaiseException(&exception_header->unwindHeader);
Howard Hinnant6ccae152011-12-08 19:35:18 +0000219#else
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000220 _Unwind_RaiseException(&exception_header->unwindHeader);
Howard Hinnant6ccae152011-12-08 19:35:18 +0000221#endif
Howard Hinnant9aa46842012-01-28 00:34:46 +0000222 // This only happens when there is no handler, or some unexpected unwinding
223 // error happens.
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000224 failed_throw(exception_header);
Marshall Clow9b454bc2011-08-15 18:06:47 +0000225}
Marshall Clow87694492011-08-09 15:09:41 +0000226
227
228// 2.5.3 Exception Handlers
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000229/*
230The adjusted pointer is computed by the personality routine during phase 1
231 and saved in the exception header (either __cxa_exception or
232 __cxa_dependent_exception).
Howard Hinnant47cb85482012-01-30 16:07:00 +0000233
234 Requires: exception is native
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000235*/
Saleem Abdulrasool242d67b2015-12-04 02:14:41 +0000236void *__cxa_get_exception_ptr(void *unwind_exception) throw() {
Ranjeet Singhef6e6722017-03-01 11:42:01 +0000237#if defined(_LIBCXXABI_ARM_EHABI)
Logan Chiendc65ab42014-05-10 00:42:10 +0000238 return reinterpret_cast<void*>(
Dan Albertb98c20c2015-02-05 23:48:06 +0000239 static_cast<_Unwind_Control_Block*>(unwind_exception)->barrier_cache.bitpattern[0]);
Logan Chiendc65ab42014-05-10 00:42:10 +0000240#else
Dan Albertb98c20c2015-02-05 23:48:06 +0000241 return cxa_exception_from_exception_unwind_exception(
242 static_cast<_Unwind_Exception*>(unwind_exception))->adjustedPtr;
Logan Chiendc65ab42014-05-10 00:42:10 +0000243#endif
Marshall Clow9b454bc2011-08-15 18:06:47 +0000244}
Logan Chiendc65ab42014-05-10 00:42:10 +0000245
Ranjeet Singhef6e6722017-03-01 11:42:01 +0000246#if defined(_LIBCXXABI_ARM_EHABI)
Logan Chiendc65ab42014-05-10 00:42:10 +0000247/*
248The routine to be called before the cleanup. This will save __cxa_exception in
249__cxa_eh_globals, so that __cxa_end_cleanup() can recover later.
250*/
Saleem Abdulrasool242d67b2015-12-04 02:14:41 +0000251bool __cxa_begin_cleanup(void *unwind_arg) throw() {
Logan Chiendc65ab42014-05-10 00:42:10 +0000252 _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(unwind_arg);
253 __cxa_eh_globals* globals = __cxa_get_globals();
254 __cxa_exception* exception_header =
255 cxa_exception_from_exception_unwind_exception(unwind_exception);
256
257 if (isOurExceptionClass(unwind_exception))
258 {
259 if (0 == exception_header->propagationCount)
260 {
261 exception_header->nextPropagatingException = globals->propagatingExceptions;
262 globals->propagatingExceptions = exception_header;
263 }
264 ++exception_header->propagationCount;
265 }
266 else
267 {
268 // If the propagatingExceptions stack is not empty, since we can't
269 // chain the foreign exception, terminate it.
270 if (NULL != globals->propagatingExceptions)
271 std::terminate();
272 globals->propagatingExceptions = exception_header;
273 }
274 return true;
275}
276
277/*
278The routine to be called after the cleanup has been performed. It will get the
279propagating __cxa_exception from __cxa_eh_globals, and continue the stack
280unwinding with _Unwind_Resume.
281
282According to ARM EHABI 8.4.1, __cxa_end_cleanup() should not clobber any
283register, thus we have to write this function in assembly so that we can save
284{r1, r2, r3}. We don't have to save r0 because it is the return value and the
285first argument to _Unwind_Resume(). In addition, we are saving r4 in order to
286align the stack to 16 bytes, even though it is a callee-save register.
287*/
288__attribute__((used)) static _Unwind_Exception *
289__cxa_end_cleanup_impl()
290{
291 __cxa_eh_globals* globals = __cxa_get_globals();
292 __cxa_exception* exception_header = globals->propagatingExceptions;
293 if (NULL == exception_header)
294 {
295 // It seems that __cxa_begin_cleanup() is not called properly.
296 // We have no choice but terminate the program now.
297 std::terminate();
298 }
299
300 if (isOurExceptionClass(&exception_header->unwindHeader))
301 {
302 --exception_header->propagationCount;
303 if (0 == exception_header->propagationCount)
304 {
305 globals->propagatingExceptions = exception_header->nextPropagatingException;
306 exception_header->nextPropagatingException = NULL;
307 }
308 }
309 else
310 {
311 globals->propagatingExceptions = NULL;
312 }
313 return &exception_header->unwindHeader;
314}
315
316asm (
Logan Chien338d6de2015-12-22 14:38:30 +0000317 " .pushsection .text.__cxa_end_cleanup,\"ax\",%progbits\n"
Logan Chiendc65ab42014-05-10 00:42:10 +0000318 " .globl __cxa_end_cleanup\n"
319 " .type __cxa_end_cleanup,%function\n"
320 "__cxa_end_cleanup:\n"
321 " push {r1, r2, r3, r4}\n"
322 " bl __cxa_end_cleanup_impl\n"
323 " pop {r1, r2, r3, r4}\n"
324 " bl _Unwind_Resume\n"
325 " bl abort\n"
326 " .popsection"
327);
Ranjeet Singhef6e6722017-03-01 11:42:01 +0000328#endif // defined(_LIBCXXABI_ARM_EHABI)
Marshall Clow87694492011-08-09 15:09:41 +0000329
Marshall Clow87694492011-08-09 15:09:41 +0000330/*
Howard Hinnant47cb85482012-01-30 16:07:00 +0000331This routine can catch foreign or native exceptions. If native, the exception
332can be a primary or dependent variety. This routine may remain blissfully
333ignorant of whether the native exception is primary or dependent.
334
335If the exception is native:
Marshall Clow87694492011-08-09 15:09:41 +0000336* Increment's the exception's handler count.
Howard Hinnant47cb85482012-01-30 16:07:00 +0000337* Push the exception on the stack of currently-caught exceptions if it is not
338 already there (from a rethrow).
Marshall Clow87694492011-08-09 15:09:41 +0000339* Decrements the uncaught_exception count.
Howard Hinnant47cb85482012-01-30 16:07:00 +0000340* Returns the adjusted pointer to the exception object, which is stored in
341 the __cxa_exception by the personality routine.
342
343If the exception is foreign, this means it did not originate from one of throw
344routines. The foreign exception does not necessarily have a __cxa_exception
345header. However we can catch it here with a catch (...), or with a call
346to terminate or unexpected during unwinding.
347* Do not try to increment the exception's handler count, we don't know where
348 it is.
349* Push the exception on the stack of currently-caught exceptions only if the
350 stack is empty. The foreign exception has no way to link to the current
351 top of stack. If the stack is not empty, call terminate. Even with an
352 empty stack, this is hacked in by pushing a pointer to an imaginary
353 __cxa_exception block in front of the foreign exception. It would be better
354 if the __cxa_eh_globals structure had a stack of _Unwind_Exception, but it
355 doesn't. It has a stack of __cxa_exception (which has a next* in it).
356* Do not decrement the uncaught_exception count because we didn't increment it
357 in __cxa_throw (or one of our rethrow functions).
358* If we haven't terminated, assume the exception object is just past the
359 _Unwind_Exception and return a pointer to that.
Marshall Clow87694492011-08-09 15:09:41 +0000360*/
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000361void*
Howard Hinnant47cb85482012-01-30 16:07:00 +0000362__cxa_begin_catch(void* unwind_arg) throw()
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000363{
Howard Hinnant47cb85482012-01-30 16:07:00 +0000364 _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(unwind_arg);
365 bool native_exception = isOurExceptionClass(unwind_exception);
366 __cxa_eh_globals* globals = __cxa_get_globals();
367 // exception_header is a hackish offset from a foreign exception, but it
368 // works as long as we're careful not to try to access any __cxa_exception
369 // parts.
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000370 __cxa_exception* exception_header =
371 cxa_exception_from_exception_unwind_exception
372 (
373 static_cast<_Unwind_Exception*>(unwind_exception)
374 );
Howard Hinnant47cb85482012-01-30 16:07:00 +0000375 if (native_exception)
376 {
377 // Increment the handler count, removing the flag about being rethrown
378 exception_header->handlerCount = exception_header->handlerCount < 0 ?
379 -exception_header->handlerCount + 1 : exception_header->handlerCount + 1;
380 // place the exception on the top of the stack if it's not already
381 // there by a previous rethrow
382 if (exception_header != globals->caughtExceptions)
383 {
384 exception_header->nextException = globals->caughtExceptions;
385 globals->caughtExceptions = exception_header;
386 }
387 globals->uncaughtExceptions -= 1; // Not atomically, since globals are thread-local
Ranjeet Singhef6e6722017-03-01 11:42:01 +0000388#if defined(_LIBCXXABI_ARM_EHABI)
Logan Chiendc65ab42014-05-10 00:42:10 +0000389 return reinterpret_cast<void*>(exception_header->unwindHeader.barrier_cache.bitpattern[0]);
390#else
Howard Hinnant47cb85482012-01-30 16:07:00 +0000391 return exception_header->adjustedPtr;
Logan Chiendc65ab42014-05-10 00:42:10 +0000392#endif
Marshall Clow9b454bc2011-08-15 18:06:47 +0000393 }
Howard Hinnant47cb85482012-01-30 16:07:00 +0000394 // Else this is a foreign exception
395 // If the caughtExceptions stack is not empty, terminate
396 if (globals->caughtExceptions != 0)
397 std::terminate();
398 // Push the foreign exception on to the stack
399 globals->caughtExceptions = exception_header;
400 return unwind_exception + 1;
Marshall Clow9b454bc2011-08-15 18:06:47 +0000401}
Marshall Clow87694492011-08-09 15:09:41 +0000402
403
404/*
405Upon exit for any reason, a handler must call:
406 void __cxa_end_catch ();
407
Howard Hinnant47cb85482012-01-30 16:07:00 +0000408This routine can be called for either a native or foreign exception.
409For a native exception:
Marshall Clow87694492011-08-09 15:09:41 +0000410* Locates the most recently caught exception and decrements its handler count.
411* Removes the exception from the caught exception stack, if the handler count goes to zero.
Howard Hinnant6ccae152011-12-08 19:35:18 +0000412* If the handler count goes down to zero, and the exception was not re-thrown
413 by throw, it locates the primary exception (which may be the same as the one
414 it's handling) and decrements its reference count. If that reference count
415 goes to zero, the function destroys the exception. In any case, if the current
416 exception is a dependent exception, it destroys that.
Howard Hinnant47cb85482012-01-30 16:07:00 +0000417
418For a foreign exception:
419* If it has been rethrown, there is nothing to do.
420* Otherwise delete the exception and pop the catch stack to empty.
Marshall Clow87694492011-08-09 15:09:41 +0000421*/
Shoaib Meenaife989a92017-03-01 03:55:57 +0000422void __cxa_end_catch() {
Nico Weberae543872014-06-25 23:52:07 +0000423 static_assert(sizeof(__cxa_exception) == sizeof(__cxa_dependent_exception),
424 "sizeof(__cxa_exception) must be equal to "
425 "sizeof(__cxa_dependent_exception)");
Saleem Abdulrasoole113b5e2015-11-18 05:33:38 +0000426 static_assert(__builtin_offsetof(__cxa_exception, referenceCount) ==
427 __builtin_offsetof(__cxa_dependent_exception,
428 primaryException),
429 "the layout of __cxa_exception must match the layout of "
430 "__cxa_dependent_exception");
431 static_assert(__builtin_offsetof(__cxa_exception, handlerCount) ==
432 __builtin_offsetof(__cxa_dependent_exception, handlerCount),
433 "the layout of __cxa_exception must match the layout of "
434 "__cxa_dependent_exception");
Howard Hinnant47cb85482012-01-30 16:07:00 +0000435 __cxa_eh_globals* globals = __cxa_get_globals_fast(); // __cxa_get_globals called in __cxa_begin_catch
436 __cxa_exception* exception_header = globals->caughtExceptions;
437 // If we've rethrown a foreign exception, then globals->caughtExceptions
438 // will have been made an empty stack by __cxa_rethrow() and there is
439 // nothing more to be done. Do nothing!
440 if (NULL != exception_header)
441 {
442 bool native_exception = isOurExceptionClass(&exception_header->unwindHeader);
443 if (native_exception)
444 {
445 // This is a native exception
446 if (exception_header->handlerCount < 0)
447 {
448 // The exception has been rethrown by __cxa_rethrow, so don't delete it
449 if (0 == incrementHandlerCount(exception_header))
450 {
451 // Remove from the chain of uncaught exceptions
452 globals->caughtExceptions = exception_header->nextException;
453 // but don't destroy
Howard Hinnant6ccae152011-12-08 19:35:18 +0000454 }
Howard Hinnant47cb85482012-01-30 16:07:00 +0000455 // Keep handlerCount negative in case there are nested catch's
456 // that need to be told that this exception is rethrown. Don't
457 // erase this rethrow flag until the exception is recaught.
458 }
459 else
460 {
461 // The native exception has not been rethrown
462 if (0 == decrementHandlerCount(exception_header))
463 {
464 // Remove from the chain of uncaught exceptions
465 globals->caughtExceptions = exception_header->nextException;
466 // Destroy this exception, being careful to distinguish
467 // between dependent and primary exceptions
468 if (isDependentException(&exception_header->unwindHeader))
469 {
470 // Reset exception_header to primaryException and deallocate the dependent exception
471 __cxa_dependent_exception* dep_exception_header =
472 reinterpret_cast<__cxa_dependent_exception*>(exception_header);
473 exception_header =
474 cxa_exception_from_thrown_object(dep_exception_header->primaryException);
475 __cxa_free_dependent_exception(dep_exception_header);
476 }
477 // Destroy the primary exception only if its referenceCount goes to 0
478 // (this decrement must be atomic)
479 __cxa_decrement_exception_refcount(thrown_object_from_cxa_exception(exception_header));
480 }
Marshall Clow9b454bc2011-08-15 18:06:47 +0000481 }
482 }
Howard Hinnant47cb85482012-01-30 16:07:00 +0000483 else
484 {
485 // The foreign exception has not been rethrown. Pop the stack
486 // and delete it. If there are nested catch's and they try
487 // to touch a foreign exception in any way, that is undefined
488 // behavior. They likely can't since the only way to catch
489 // a foreign exception is with catch (...)!
490 _Unwind_DeleteException(&globals->caughtExceptions->unwindHeader);
491 globals->caughtExceptions = 0;
492 }
Marshall Clow87694492011-08-09 15:09:41 +0000493 }
Marshall Clow9b454bc2011-08-15 18:06:47 +0000494}
Marshall Clow87694492011-08-09 15:09:41 +0000495
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000496// Note: exception_header may be masquerading as a __cxa_dependent_exception
497// and that's ok. exceptionType is there too.
Howard Hinnant47cb85482012-01-30 16:07:00 +0000498// However watch out for foreign exceptions. Return null for them.
Shoaib Meenaife989a92017-03-01 03:55:57 +0000499std::type_info *__cxa_current_exception_type() {
Marshall Clow87694492011-08-09 15:09:41 +0000500// get the current exception
Marshall Clow1de4fc02011-12-22 15:45:05 +0000501 __cxa_eh_globals *globals = __cxa_get_globals_fast();
502 if (NULL == globals)
503 return NULL; // If there have never been any exceptions, there are none now.
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000504 __cxa_exception *exception_header = globals->caughtExceptions;
505 if (NULL == exception_header)
Marshall Clow87694492011-08-09 15:09:41 +0000506 return NULL; // No current exception
Howard Hinnant47cb85482012-01-30 16:07:00 +0000507 if (!isOurExceptionClass(&exception_header->unwindHeader))
508 return NULL;
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000509 return exception_header->exceptionType;
Marshall Clow9b454bc2011-08-15 18:06:47 +0000510}
Marshall Clow87694492011-08-09 15:09:41 +0000511
512// 2.5.4 Rethrowing Exceptions
Howard Hinnant47cb85482012-01-30 16:07:00 +0000513/* This routine can rethrow native or foreign exceptions.
514If the exception is native:
Marshall Clow87694492011-08-09 15:09:41 +0000515* marks the exception object on top of the caughtExceptions stack
516 (in an implementation-defined way) as being rethrown.
517* If the caughtExceptions stack is empty, it calls terminate()
518 (see [C++FDIS] [except.throw], 15.1.8).
Howard Hinnant47cb85482012-01-30 16:07:00 +0000519* It then calls _Unwind_RaiseException which should not return
Howard Hinnant58926c92011-12-12 19:11:42 +0000520 (terminate if it does).
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000521 Note: exception_header may be masquerading as a __cxa_dependent_exception
522 and that's ok.
Marshall Clow87694492011-08-09 15:09:41 +0000523*/
Shoaib Meenaife989a92017-03-01 03:55:57 +0000524void __cxa_rethrow() {
Howard Hinnant47cb85482012-01-30 16:07:00 +0000525 __cxa_eh_globals* globals = __cxa_get_globals();
Howard Hinnant47cb85482012-01-30 16:07:00 +0000526 __cxa_exception* exception_header = globals->caughtExceptions;
527 if (NULL == exception_header)
528 std::terminate(); // throw; called outside of a exception handler
529 bool native_exception = isOurExceptionClass(&exception_header->unwindHeader);
530 if (native_exception)
531 {
Howard Hinnant47cb85482012-01-30 16:07:00 +0000532 // Mark the exception as being rethrown (reverse the effects of __cxa_begin_catch)
533 exception_header->handlerCount = -exception_header->handlerCount;
534 globals->uncaughtExceptions += 1;
535 // __cxa_end_catch will remove this exception from the caughtExceptions stack if necessary
536 }
537 else // this is a foreign exception
538 {
539 // The only way to communicate to __cxa_end_catch that we've rethrown
540 // a foreign exception, so don't delete us, is to pop the stack here
541 // which must be empty afterwards. Then __cxa_end_catch will do
542 // nothing
543 globals->caughtExceptions = 0;
544 }
Dan Albert3bd13ca2015-02-05 01:33:15 +0000545#ifdef __USING_SJLJ_EXCEPTIONS__
Howard Hinnant20d6c142012-02-29 22:14:19 +0000546 _Unwind_SjLj_RaiseException(&exception_header->unwindHeader);
Marshall Clow87694492011-08-09 15:09:41 +0000547#else
Howard Hinnant20d6c142012-02-29 22:14:19 +0000548 _Unwind_RaiseException(&exception_header->unwindHeader);
Marshall Clow87694492011-08-09 15:09:41 +0000549#endif
550
Howard Hinnant47cb85482012-01-30 16:07:00 +0000551 // If we get here, some kind of unwinding error has occurred.
552 // There is some weird code generation bug happening with
553 // Apple clang version 4.0 (tags/Apple/clang-418.0.2) (based on LLVM 3.1svn)
554 // If we call failed_throw here. Turns up with -O2 or higher, and -Os.
555 __cxa_begin_catch(&exception_header->unwindHeader);
556 if (native_exception)
557 std::__terminate(exception_header->terminateHandler);
558 // Foreign exception: can't get exception_header->terminateHandler
559 std::terminate();
Marshall Clow9b454bc2011-08-15 18:06:47 +0000560}
Marshall Clow87694492011-08-09 15:09:41 +0000561
Howard Hinnante04f5162011-12-21 23:32:11 +0000562/*
Howard Hinnant47cb85482012-01-30 16:07:00 +0000563 If thrown_object is not null, atomically increment the referenceCount field
564 of the __cxa_exception header associated with the thrown object referred to
565 by thrown_object.
566
567 Requires: If thrown_object is not NULL, it is a native exception.
Howard Hinnante04f5162011-12-21 23:32:11 +0000568*/
Shoaib Meenaife989a92017-03-01 03:55:57 +0000569void
Saleem Abdulrasool12315ed2015-12-04 02:14:58 +0000570__cxa_increment_exception_refcount(void *thrown_object) throw() {
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000571 if (thrown_object != NULL )
Howard Hinnante04f5162011-12-21 23:32:11 +0000572 {
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000573 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
574 __sync_add_and_fetch(&exception_header->referenceCount, 1);
Howard Hinnante04f5162011-12-21 23:32:11 +0000575 }
576}
577
578/*
Howard Hinnant47cb85482012-01-30 16:07:00 +0000579 If thrown_object is not null, atomically decrement the referenceCount field
580 of the __cxa_exception header associated with the thrown object referred to
581 by thrown_object. If the referenceCount drops to zero, destroy and
582 deallocate the exception.
583
584 Requires: If thrown_object is not NULL, it is a native exception.
Howard Hinnante04f5162011-12-21 23:32:11 +0000585*/
Shoaib Meenaife989a92017-03-01 03:55:57 +0000586void
Saleem Abdulrasool12315ed2015-12-04 02:14:58 +0000587__cxa_decrement_exception_refcount(void *thrown_object) throw() {
Howard Hinnante04f5162011-12-21 23:32:11 +0000588 if (thrown_object != NULL )
589 {
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000590 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
591 if (__sync_sub_and_fetch(&exception_header->referenceCount, size_t(1)) == 0)
Howard Hinnante04f5162011-12-21 23:32:11 +0000592 {
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000593 if (NULL != exception_header->exceptionDestructor)
594 exception_header->exceptionDestructor(thrown_object);
Howard Hinnante04f5162011-12-21 23:32:11 +0000595 __cxa_free_exception(thrown_object);
596 }
597 }
598}
599
600/*
601 Returns a pointer to the thrown object (if any) at the top of the
Howard Hinnantbe2eced2013-02-15 15:48:49 +0000602 caughtExceptions stack. Atomically increment the exception's referenceCount.
Howard Hinnant47cb85482012-01-30 16:07:00 +0000603 If there is no such thrown object or if the thrown object is foreign,
604 returns null.
Marshall Clowd2bab352012-01-04 22:18:10 +0000605
606 We can use __cxa_get_globals_fast here to get the globals because if there have
607 been no exceptions thrown, ever, on this thread, we can return NULL without
608 the need to allocate the exception-handling globals.
Howard Hinnante04f5162011-12-21 23:32:11 +0000609*/
Shoaib Meenaife989a92017-03-01 03:55:57 +0000610void *__cxa_current_primary_exception() throw() {
Howard Hinnante04f5162011-12-21 23:32:11 +0000611// get the current exception
Marshall Clowf83663a2012-01-03 23:26:09 +0000612 __cxa_eh_globals* globals = __cxa_get_globals_fast();
Marshall Clow3e417e72012-01-03 23:10:20 +0000613 if (NULL == globals)
Marshall Clowf3684862012-01-04 14:56:09 +0000614 return NULL; // If there are no globals, there is no exception
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000615 __cxa_exception* exception_header = globals->caughtExceptions;
616 if (NULL == exception_header)
Howard Hinnante04f5162011-12-21 23:32:11 +0000617 return NULL; // No current exception
Howard Hinnant47cb85482012-01-30 16:07:00 +0000618 if (!isOurExceptionClass(&exception_header->unwindHeader))
619 return NULL; // Can't capture a foreign exception (no way to refcount it)
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000620 if (isDependentException(&exception_header->unwindHeader)) {
621 __cxa_dependent_exception* dep_exception_header =
622 reinterpret_cast<__cxa_dependent_exception*>(exception_header);
623 exception_header = cxa_exception_from_thrown_object(dep_exception_header->primaryException);
Howard Hinnante04f5162011-12-21 23:32:11 +0000624 }
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000625 void* thrown_object = thrown_object_from_cxa_exception(exception_header);
Howard Hinnante04f5162011-12-21 23:32:11 +0000626 __cxa_increment_exception_refcount(thrown_object);
627 return thrown_object;
628}
629
630/*
631 If reason isn't _URC_FOREIGN_EXCEPTION_CAUGHT, then the terminateHandler
632 stored in exc is called. Otherwise the referenceCount stored in the
633 primary exception is decremented, destroying the primary if necessary.
634 Finally the dependent exception is destroyed.
635*/
636static
637void
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000638dependent_exception_cleanup(_Unwind_Reason_Code reason, _Unwind_Exception* unwind_exception)
Howard Hinnante04f5162011-12-21 23:32:11 +0000639{
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000640 __cxa_dependent_exception* dep_exception_header =
641 reinterpret_cast<__cxa_dependent_exception*>(unwind_exception + 1) - 1;
Howard Hinnante04f5162011-12-21 23:32:11 +0000642 if (_URC_FOREIGN_EXCEPTION_CAUGHT != reason)
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000643 std::__terminate(dep_exception_header->terminateHandler);
644 __cxa_decrement_exception_refcount(dep_exception_header->primaryException);
645 __cxa_free_dependent_exception(dep_exception_header);
Howard Hinnante04f5162011-12-21 23:32:11 +0000646}
647
648/*
Howard Hinnantbe2eced2013-02-15 15:48:49 +0000649 If thrown_object is not null, allocate, initialize and throw a dependent
Howard Hinnante04f5162011-12-21 23:32:11 +0000650 exception.
651*/
652void
653__cxa_rethrow_primary_exception(void* thrown_object)
654{
655 if ( thrown_object != NULL )
656 {
Howard Hinnant47cb85482012-01-30 16:07:00 +0000657 // thrown_object guaranteed to be native because
658 // __cxa_current_primary_exception returns NULL for foreign exceptions
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000659 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
660 __cxa_dependent_exception* dep_exception_header =
661 static_cast<__cxa_dependent_exception*>(__cxa_allocate_dependent_exception());
662 dep_exception_header->primaryException = thrown_object;
Howard Hinnante04f5162011-12-21 23:32:11 +0000663 __cxa_increment_exception_refcount(thrown_object);
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000664 dep_exception_header->exceptionType = exception_header->exceptionType;
665 dep_exception_header->unexpectedHandler = std::get_unexpected();
666 dep_exception_header->terminateHandler = std::get_terminate();
667 setDependentExceptionClass(&dep_exception_header->unwindHeader);
Howard Hinnant22f28b22011-12-21 23:48:05 +0000668 __cxa_get_globals()->uncaughtExceptions += 1;
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000669 dep_exception_header->unwindHeader.exception_cleanup = dependent_exception_cleanup;
Dan Albert3bd13ca2015-02-05 01:33:15 +0000670#ifdef __USING_SJLJ_EXCEPTIONS__
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000671 _Unwind_SjLj_RaiseException(&dep_exception_header->unwindHeader);
Howard Hinnante04f5162011-12-21 23:32:11 +0000672#else
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000673 _Unwind_RaiseException(&dep_exception_header->unwindHeader);
Howard Hinnante04f5162011-12-21 23:32:11 +0000674#endif
675 // Some sort of unwinding error. Note that terminate is a handler.
Howard Hinnantafcf7ac2012-01-22 19:14:27 +0000676 __cxa_begin_catch(&dep_exception_header->unwindHeader);
Howard Hinnante04f5162011-12-21 23:32:11 +0000677 }
678 // If we return client will call terminate()
679}
680
Howard Hinnante33b2f52012-01-24 00:01:31 +0000681bool
Marshall Clow604de5c2015-06-02 13:03:17 +0000682__cxa_uncaught_exception() throw() { return __cxa_uncaught_exceptions() != 0; }
683
684unsigned int
685__cxa_uncaught_exceptions() throw()
Howard Hinnante33b2f52012-01-24 00:01:31 +0000686{
Howard Hinnant47cb85482012-01-30 16:07:00 +0000687 // This does not report foreign exceptions in flight
Howard Hinnante33b2f52012-01-24 00:01:31 +0000688 __cxa_eh_globals* globals = __cxa_get_globals_fast();
689 if (globals == 0)
Marshall Clow604de5c2015-06-02 13:03:17 +0000690 return 0;
691 return globals->uncaughtExceptions;
Howard Hinnante33b2f52012-01-24 00:01:31 +0000692}
693
Marshall Clowe2dcb752011-07-20 15:04:39 +0000694} // extern "C"
695
Marshall Clowe2dcb752011-07-20 15:04:39 +0000696} // abi