1 //===------------------------- cxa_exception.cpp --------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
9 // This file implements the "Exception Handling APIs"
10 // http://mentorembedded.github.io/cxx-abi/abi-eh.html
12 //===----------------------------------------------------------------------===//
17 #include <exception> // for std::terminate
18 #include <cstdlib> // for malloc, free
19 #include <cstring> // for memset
20 #if !LIBCXXABI_SINGLE_THREADED
21 # include <pthread.h> // for fallback_malloc.ipp's mutexes
23 #include "cxa_exception.hpp"
24 #include "cxa_handlers.hpp"
26 // +---------------------------+-----------------------------+---------------+
27 // | __cxa_exception | _Unwind_Exception CLNGC++\0 | thrown object |
28 // +---------------------------+-----------------------------+---------------+
31 // +-------------------------------------------------------+
33 // +---------------------------+-----------------------------+
34 // | __cxa_dependent_exception | _Unwind_Exception CLNGC++\1 |
35 // +---------------------------+-----------------------------+
37 namespace __cxxabiv1 {
39 #pragma GCC visibility push(default)
45 cxa_exception_from_thrown_object(void* thrown_object)
47 return static_cast<__cxa_exception*>(thrown_object) - 1;
50 // Note: This is never called when exception_header is masquerading as a
51 // __cxa_dependent_exception.
55 thrown_object_from_cxa_exception(__cxa_exception* exception_header)
57 return static_cast<void*>(exception_header + 1);
60 // Get the exception object from the unwind pointer.
61 // Relies on the structure layout, where the unwind pointer is right in
62 // front of the user's exception object
66 cxa_exception_from_exception_unwind_exception(_Unwind_Exception* unwind_exception)
68 return cxa_exception_from_thrown_object(unwind_exception + 1 );
74 cxa_exception_size_from_exception_thrown_size(size_t size)
76 return size + sizeof (__cxa_exception);
79 static void setExceptionClass(_Unwind_Exception* unwind_exception) {
80 unwind_exception->exception_class = kOurExceptionClass;
83 static void setDependentExceptionClass(_Unwind_Exception* unwind_exception) {
84 unwind_exception->exception_class = kOurDependentExceptionClass;
88 static bool isOurExceptionClass(const _Unwind_Exception* unwind_exception) {
89 return (unwind_exception->exception_class & get_vendor_and_language) ==
90 (kOurExceptionClass & get_vendor_and_language);
93 static bool isDependentException(_Unwind_Exception* unwind_exception) {
94 return (unwind_exception->exception_class & 0xFF) == 0x01;
97 // This does not need to be atomic
98 static inline int incrementHandlerCount(__cxa_exception *exception) {
99 return ++exception->handlerCount;
102 // This does not need to be atomic
103 static inline int decrementHandlerCount(__cxa_exception *exception) {
104 return --exception->handlerCount;
107 #include "fallback_malloc.ipp"
109 // Allocate some memory from _somewhere_
110 static void *do_malloc(size_t size) {
111 void *ptr = std::malloc(size);
112 if (NULL == ptr) // if malloc fails, fall back to emergency stash
113 ptr = fallback_malloc(size);
117 static void do_free(void *ptr) {
118 is_fallback_ptr(ptr) ? fallback_free(ptr) : std::free(ptr);
122 If reason isn't _URC_FOREIGN_EXCEPTION_CAUGHT, then the terminateHandler
123 stored in exc is called. Otherwise the exceptionDestructor stored in
124 exc is called, and then the memory for the exception is deallocated.
126 This is never called for a __cxa_dependent_exception.
130 exception_cleanup_func(_Unwind_Reason_Code reason, _Unwind_Exception* unwind_exception)
132 __cxa_exception* exception_header = cxa_exception_from_exception_unwind_exception(unwind_exception);
133 if (_URC_FOREIGN_EXCEPTION_CAUGHT != reason)
134 std::__terminate(exception_header->terminateHandler);
135 // Just in case there exists a dependent exception that is pointing to this,
136 // check the reference count and only destroy this if that count goes to zero.
137 __cxa_decrement_exception_refcount(unwind_exception + 1);
140 static LIBCXXABI_NORETURN void failed_throw(__cxa_exception* exception_header) {
141 // Section 2.5.3 says:
142 // * For purposes of this ABI, several things are considered exception handlers:
143 // ** A terminate() call due to a throw.
145 // * Upon entry, Following initialization of the catch parameter,
146 // a handler must call:
147 // * void *__cxa_begin_catch(void *exceptionObject );
148 (void) __cxa_begin_catch(&exception_header->unwindHeader);
149 std::__terminate(exception_header->terminateHandler);
154 // Allocate a __cxa_exception object, and zero-fill it.
155 // Reserve "thrown_size" bytes on the end for the user's exception
156 // object. Zero-fill the object. If memory can't be allocated, call
157 // std::terminate. Return a pointer to the memory to be used for the
158 // user's exception object.
159 void * __cxa_allocate_exception (size_t thrown_size) throw() {
160 size_t actual_size = cxa_exception_size_from_exception_thrown_size(thrown_size);
161 __cxa_exception* exception_header = static_cast<__cxa_exception*>(do_malloc(actual_size));
162 if (NULL == exception_header)
164 std::memset(exception_header, 0, actual_size);
165 return thrown_object_from_cxa_exception(exception_header);
169 // Free a __cxa_exception object allocated with __cxa_allocate_exception.
170 void __cxa_free_exception (void * thrown_object) throw() {
171 do_free(cxa_exception_from_thrown_object(thrown_object));
175 // This function shall allocate a __cxa_dependent_exception and
176 // return a pointer to it. (Really to the object, not past its' end).
177 // Otherwise, it will work like __cxa_allocate_exception.
178 void * __cxa_allocate_dependent_exception () {
179 size_t actual_size = sizeof(__cxa_dependent_exception);
180 void *ptr = do_malloc(actual_size);
183 std::memset(ptr, 0, actual_size);
188 // This function shall free a dependent_exception.
189 // It does not affect the reference count of the primary exception.
190 void __cxa_free_dependent_exception (void * dependent_exception) {
191 do_free(dependent_exception);
195 // 2.4.3 Throwing the Exception Object
197 After constructing the exception object with the throw argument value,
198 the generated code calls the __cxa_throw runtime library routine. This
199 routine never returns.
201 The __cxa_throw routine will do the following:
203 * Obtain the __cxa_exception header from the thrown exception object address,
204 which can be computed as follows:
205 __cxa_exception *header = ((__cxa_exception *) thrown_exception - 1);
206 * Save the current unexpected_handler and terminate_handler in the __cxa_exception header.
207 * Save the tinfo and dest arguments in the __cxa_exception header.
208 * Set the exception_class field in the unwind header. This is a 64-bit value
209 representing the ASCII string "XXXXC++\0", where "XXXX" is a
210 vendor-dependent string. That is, for implementations conforming to this
211 ABI, the low-order 4 bytes of this 64-bit value will be "C++\0".
212 * Increment the uncaught_exception flag.
213 * Call _Unwind_RaiseException in the system unwind library, Its argument is the
214 pointer to the thrown exception, which __cxa_throw itself received as an argument.
215 __Unwind_RaiseException begins the process of stack unwinding, described
216 in Section 2.5. In special cases, such as an inability to find a
217 handler, _Unwind_RaiseException may return. In that case, __cxa_throw
218 will call terminate, assuming that there was no handler for the
223 __cxa_throw(void* thrown_object, std::type_info* tinfo, void (*dest)(void*))
225 __cxa_eh_globals *globals = __cxa_get_globals();
226 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
228 exception_header->unexpectedHandler = std::get_unexpected();
229 exception_header->terminateHandler = std::get_terminate();
230 exception_header->exceptionType = tinfo;
231 exception_header->exceptionDestructor = dest;
232 setExceptionClass(&exception_header->unwindHeader);
233 exception_header->referenceCount = 1; // This is a newly allocated exception, no need for thread safety.
234 globals->uncaughtExceptions += 1; // Not atomically, since globals are thread-local
236 exception_header->unwindHeader.exception_cleanup = exception_cleanup_func;
237 #if __USING_SJLJ_EXCEPTIONS__
238 _Unwind_SjLj_RaiseException(&exception_header->unwindHeader);
240 _Unwind_RaiseException(&exception_header->unwindHeader);
242 // This only happens when there is no handler, or some unexpected unwinding
244 failed_throw(exception_header);
248 // 2.5.3 Exception Handlers
250 The adjusted pointer is computed by the personality routine during phase 1
251 and saved in the exception header (either __cxa_exception or
252 __cxa_dependent_exception).
254 Requires: exception is native
257 __cxa_get_exception_ptr(void* unwind_exception) throw()
259 #if LIBCXXABI_ARM_EHABI
260 return reinterpret_cast<void*>(
261 static_cast<_Unwind_Control_Block*>(unwind_exception)->barrier_cache.bitpattern[0]);
263 return cxa_exception_from_exception_unwind_exception
265 static_cast<_Unwind_Exception*>(unwind_exception)
270 #if LIBCXXABI_ARM_EHABI
272 The routine to be called before the cleanup. This will save __cxa_exception in
273 __cxa_eh_globals, so that __cxa_end_cleanup() can recover later.
276 __cxa_begin_cleanup(void* unwind_arg) throw ()
278 _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(unwind_arg);
279 __cxa_eh_globals* globals = __cxa_get_globals();
280 __cxa_exception* exception_header =
281 cxa_exception_from_exception_unwind_exception(unwind_exception);
283 if (isOurExceptionClass(unwind_exception))
285 if (0 == exception_header->propagationCount)
287 exception_header->nextPropagatingException = globals->propagatingExceptions;
288 globals->propagatingExceptions = exception_header;
290 ++exception_header->propagationCount;
294 // If the propagatingExceptions stack is not empty, since we can't
295 // chain the foreign exception, terminate it.
296 if (NULL != globals->propagatingExceptions)
298 globals->propagatingExceptions = exception_header;
304 The routine to be called after the cleanup has been performed. It will get the
305 propagating __cxa_exception from __cxa_eh_globals, and continue the stack
306 unwinding with _Unwind_Resume.
308 According to ARM EHABI 8.4.1, __cxa_end_cleanup() should not clobber any
309 register, thus we have to write this function in assembly so that we can save
310 {r1, r2, r3}. We don't have to save r0 because it is the return value and the
311 first argument to _Unwind_Resume(). In addition, we are saving r4 in order to
312 align the stack to 16 bytes, even though it is a callee-save register.
314 __attribute__((used)) static _Unwind_Exception *
315 __cxa_end_cleanup_impl()
317 __cxa_eh_globals* globals = __cxa_get_globals();
318 __cxa_exception* exception_header = globals->propagatingExceptions;
319 if (NULL == exception_header)
321 // It seems that __cxa_begin_cleanup() is not called properly.
322 // We have no choice but terminate the program now.
326 if (isOurExceptionClass(&exception_header->unwindHeader))
328 --exception_header->propagationCount;
329 if (0 == exception_header->propagationCount)
331 globals->propagatingExceptions = exception_header->nextPropagatingException;
332 exception_header->nextPropagatingException = NULL;
337 globals->propagatingExceptions = NULL;
339 return &exception_header->unwindHeader;
343 " .pushsection .text.__cxa_end_cleanup\n"
344 " .globl __cxa_end_cleanup\n"
345 " .type __cxa_end_cleanup,%function\n"
346 "__cxa_end_cleanup:\n"
347 " push {r1, r2, r3, r4}\n"
348 " bl __cxa_end_cleanup_impl\n"
349 " pop {r1, r2, r3, r4}\n"
350 " bl _Unwind_Resume\n"
354 #endif // LIBCXXABI_ARM_EHABI
357 This routine can catch foreign or native exceptions. If native, the exception
358 can be a primary or dependent variety. This routine may remain blissfully
359 ignorant of whether the native exception is primary or dependent.
361 If the exception is native:
362 * Increment's the exception's handler count.
363 * Push the exception on the stack of currently-caught exceptions if it is not
364 already there (from a rethrow).
365 * Decrements the uncaught_exception count.
366 * Returns the adjusted pointer to the exception object, which is stored in
367 the __cxa_exception by the personality routine.
369 If the exception is foreign, this means it did not originate from one of throw
370 routines. The foreign exception does not necessarily have a __cxa_exception
371 header. However we can catch it here with a catch (...), or with a call
372 to terminate or unexpected during unwinding.
373 * Do not try to increment the exception's handler count, we don't know where
375 * Push the exception on the stack of currently-caught exceptions only if the
376 stack is empty. The foreign exception has no way to link to the current
377 top of stack. If the stack is not empty, call terminate. Even with an
378 empty stack, this is hacked in by pushing a pointer to an imaginary
379 __cxa_exception block in front of the foreign exception. It would be better
380 if the __cxa_eh_globals structure had a stack of _Unwind_Exception, but it
381 doesn't. It has a stack of __cxa_exception (which has a next* in it).
382 * Do not decrement the uncaught_exception count because we didn't increment it
383 in __cxa_throw (or one of our rethrow functions).
384 * If we haven't terminated, assume the exception object is just past the
385 _Unwind_Exception and return a pointer to that.
388 __cxa_begin_catch(void* unwind_arg) throw()
390 _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(unwind_arg);
391 bool native_exception = isOurExceptionClass(unwind_exception);
392 __cxa_eh_globals* globals = __cxa_get_globals();
393 // exception_header is a hackish offset from a foreign exception, but it
394 // works as long as we're careful not to try to access any __cxa_exception
396 __cxa_exception* exception_header =
397 cxa_exception_from_exception_unwind_exception
399 static_cast<_Unwind_Exception*>(unwind_exception)
401 if (native_exception)
403 // Increment the handler count, removing the flag about being rethrown
404 exception_header->handlerCount = exception_header->handlerCount < 0 ?
405 -exception_header->handlerCount + 1 : exception_header->handlerCount + 1;
406 // place the exception on the top of the stack if it's not already
407 // there by a previous rethrow
408 if (exception_header != globals->caughtExceptions)
410 exception_header->nextException = globals->caughtExceptions;
411 globals->caughtExceptions = exception_header;
413 globals->uncaughtExceptions -= 1; // Not atomically, since globals are thread-local
414 #if LIBCXXABI_ARM_EHABI
415 return reinterpret_cast<void*>(exception_header->unwindHeader.barrier_cache.bitpattern[0]);
417 return exception_header->adjustedPtr;
420 // Else this is a foreign exception
421 // If the caughtExceptions stack is not empty, terminate
422 if (globals->caughtExceptions != 0)
424 // Push the foreign exception on to the stack
425 globals->caughtExceptions = exception_header;
426 return unwind_exception + 1;
431 Upon exit for any reason, a handler must call:
432 void __cxa_end_catch ();
434 This routine can be called for either a native or foreign exception.
435 For a native exception:
436 * Locates the most recently caught exception and decrements its handler count.
437 * Removes the exception from the caught exception stack, if the handler count goes to zero.
438 * If the handler count goes down to zero, and the exception was not re-thrown
439 by throw, it locates the primary exception (which may be the same as the one
440 it's handling) and decrements its reference count. If that reference count
441 goes to zero, the function destroys the exception. In any case, if the current
442 exception is a dependent exception, it destroys that.
444 For a foreign exception:
445 * If it has been rethrown, there is nothing to do.
446 * Otherwise delete the exception and pop the catch stack to empty.
448 void __cxa_end_catch()
450 static_assert(sizeof(__cxa_exception) == sizeof(__cxa_dependent_exception),
451 "sizeof(__cxa_exception) must be equal to "
452 "sizeof(__cxa_dependent_exception)");
453 static_assert(offsetof(__cxa_exception, referenceCount) ==
454 offsetof(__cxa_dependent_exception, primaryException),
455 "the layout of __cxa_exception must match the layout of "
456 "__cxa_dependent_exception");
457 static_assert(offsetof(__cxa_exception, handlerCount) ==
458 offsetof(__cxa_dependent_exception, handlerCount),
459 "the layout of __cxa_exception must match the layout of "
460 "__cxa_dependent_exception");
461 __cxa_eh_globals* globals = __cxa_get_globals_fast(); // __cxa_get_globals called in __cxa_begin_catch
462 __cxa_exception* exception_header = globals->caughtExceptions;
463 // If we've rethrown a foreign exception, then globals->caughtExceptions
464 // will have been made an empty stack by __cxa_rethrow() and there is
465 // nothing more to be done. Do nothing!
466 if (NULL != exception_header)
468 bool native_exception = isOurExceptionClass(&exception_header->unwindHeader);
469 if (native_exception)
471 // This is a native exception
472 if (exception_header->handlerCount < 0)
474 // The exception has been rethrown by __cxa_rethrow, so don't delete it
475 if (0 == incrementHandlerCount(exception_header))
477 // Remove from the chain of uncaught exceptions
478 globals->caughtExceptions = exception_header->nextException;
481 // Keep handlerCount negative in case there are nested catch's
482 // that need to be told that this exception is rethrown. Don't
483 // erase this rethrow flag until the exception is recaught.
487 // The native exception has not been rethrown
488 if (0 == decrementHandlerCount(exception_header))
490 // Remove from the chain of uncaught exceptions
491 globals->caughtExceptions = exception_header->nextException;
492 // Destroy this exception, being careful to distinguish
493 // between dependent and primary exceptions
494 if (isDependentException(&exception_header->unwindHeader))
496 // Reset exception_header to primaryException and deallocate the dependent exception
497 __cxa_dependent_exception* dep_exception_header =
498 reinterpret_cast<__cxa_dependent_exception*>(exception_header);
500 cxa_exception_from_thrown_object(dep_exception_header->primaryException);
501 __cxa_free_dependent_exception(dep_exception_header);
503 // Destroy the primary exception only if its referenceCount goes to 0
504 // (this decrement must be atomic)
505 __cxa_decrement_exception_refcount(thrown_object_from_cxa_exception(exception_header));
511 // The foreign exception has not been rethrown. Pop the stack
512 // and delete it. If there are nested catch's and they try
513 // to touch a foreign exception in any way, that is undefined
514 // behavior. They likely can't since the only way to catch
515 // a foreign exception is with catch (...)!
516 _Unwind_DeleteException(&globals->caughtExceptions->unwindHeader);
517 globals->caughtExceptions = 0;
522 // Note: exception_header may be masquerading as a __cxa_dependent_exception
523 // and that's ok. exceptionType is there too.
524 // However watch out for foreign exceptions. Return null for them.
525 std::type_info * __cxa_current_exception_type() {
526 // get the current exception
527 __cxa_eh_globals *globals = __cxa_get_globals_fast();
529 return NULL; // If there have never been any exceptions, there are none now.
530 __cxa_exception *exception_header = globals->caughtExceptions;
531 if (NULL == exception_header)
532 return NULL; // No current exception
533 if (!isOurExceptionClass(&exception_header->unwindHeader))
535 return exception_header->exceptionType;
538 // 2.5.4 Rethrowing Exceptions
539 /* This routine can rethrow native or foreign exceptions.
540 If the exception is native:
541 * marks the exception object on top of the caughtExceptions stack
542 (in an implementation-defined way) as being rethrown.
543 * If the caughtExceptions stack is empty, it calls terminate()
544 (see [C++FDIS] [except.throw], 15.1.8).
545 * It then calls _Unwind_RaiseException which should not return
546 (terminate if it does).
547 Note: exception_header may be masquerading as a __cxa_dependent_exception
554 __cxa_eh_globals* globals = __cxa_get_globals();
555 __cxa_exception* exception_header = globals->caughtExceptions;
556 if (NULL == exception_header)
557 std::terminate(); // throw; called outside of a exception handler
558 bool native_exception = isOurExceptionClass(&exception_header->unwindHeader);
559 if (native_exception)
561 // Mark the exception as being rethrown (reverse the effects of __cxa_begin_catch)
562 exception_header->handlerCount = -exception_header->handlerCount;
563 globals->uncaughtExceptions += 1;
564 // __cxa_end_catch will remove this exception from the caughtExceptions stack if necessary
566 else // this is a foreign exception
568 // The only way to communicate to __cxa_end_catch that we've rethrown
569 // a foreign exception, so don't delete us, is to pop the stack here
570 // which must be empty afterwards. Then __cxa_end_catch will do
572 globals->caughtExceptions = 0;
574 #if __USING_SJLJ_EXCEPTIONS__
575 _Unwind_SjLj_RaiseException(&exception_header->unwindHeader);
577 _Unwind_RaiseException(&exception_header->unwindHeader);
580 // If we get here, some kind of unwinding error has occurred.
581 // There is some weird code generation bug happening with
582 // Apple clang version 4.0 (tags/Apple/clang-418.0.2) (based on LLVM 3.1svn)
583 // If we call failed_throw here. Turns up with -O2 or higher, and -Os.
584 __cxa_begin_catch(&exception_header->unwindHeader);
585 if (native_exception)
586 std::__terminate(exception_header->terminateHandler);
587 // Foreign exception: can't get exception_header->terminateHandler
592 If thrown_object is not null, atomically increment the referenceCount field
593 of the __cxa_exception header associated with the thrown object referred to
596 Requires: If thrown_object is not NULL, it is a native exception.
599 __cxa_increment_exception_refcount(void* thrown_object) throw()
601 if (thrown_object != NULL )
603 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
604 __sync_add_and_fetch(&exception_header->referenceCount, 1);
609 If thrown_object is not null, atomically decrement the referenceCount field
610 of the __cxa_exception header associated with the thrown object referred to
611 by thrown_object. If the referenceCount drops to zero, destroy and
612 deallocate the exception.
614 Requires: If thrown_object is not NULL, it is a native exception.
617 __cxa_decrement_exception_refcount(void* thrown_object) throw()
619 if (thrown_object != NULL )
621 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
622 if (__sync_sub_and_fetch(&exception_header->referenceCount, size_t(1)) == 0)
624 if (NULL != exception_header->exceptionDestructor)
625 exception_header->exceptionDestructor(thrown_object);
626 __cxa_free_exception(thrown_object);
632 Returns a pointer to the thrown object (if any) at the top of the
633 caughtExceptions stack. Atomically increment the exception's referenceCount.
634 If there is no such thrown object or if the thrown object is foreign,
637 We can use __cxa_get_globals_fast here to get the globals because if there have
638 been no exceptions thrown, ever, on this thread, we can return NULL without
639 the need to allocate the exception-handling globals.
642 __cxa_current_primary_exception() throw()
644 // get the current exception
645 __cxa_eh_globals* globals = __cxa_get_globals_fast();
647 return NULL; // If there are no globals, there is no exception
648 __cxa_exception* exception_header = globals->caughtExceptions;
649 if (NULL == exception_header)
650 return NULL; // No current exception
651 if (!isOurExceptionClass(&exception_header->unwindHeader))
652 return NULL; // Can't capture a foreign exception (no way to refcount it)
653 if (isDependentException(&exception_header->unwindHeader)) {
654 __cxa_dependent_exception* dep_exception_header =
655 reinterpret_cast<__cxa_dependent_exception*>(exception_header);
656 exception_header = cxa_exception_from_thrown_object(dep_exception_header->primaryException);
658 void* thrown_object = thrown_object_from_cxa_exception(exception_header);
659 __cxa_increment_exception_refcount(thrown_object);
660 return thrown_object;
664 If reason isn't _URC_FOREIGN_EXCEPTION_CAUGHT, then the terminateHandler
665 stored in exc is called. Otherwise the referenceCount stored in the
666 primary exception is decremented, destroying the primary if necessary.
667 Finally the dependent exception is destroyed.
671 dependent_exception_cleanup(_Unwind_Reason_Code reason, _Unwind_Exception* unwind_exception)
673 __cxa_dependent_exception* dep_exception_header =
674 reinterpret_cast<__cxa_dependent_exception*>(unwind_exception + 1) - 1;
675 if (_URC_FOREIGN_EXCEPTION_CAUGHT != reason)
676 std::__terminate(dep_exception_header->terminateHandler);
677 __cxa_decrement_exception_refcount(dep_exception_header->primaryException);
678 __cxa_free_dependent_exception(dep_exception_header);
682 If thrown_object is not null, allocate, initialize and throw a dependent
686 __cxa_rethrow_primary_exception(void* thrown_object)
688 if ( thrown_object != NULL )
690 // thrown_object guaranteed to be native because
691 // __cxa_current_primary_exception returns NULL for foreign exceptions
692 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
693 __cxa_dependent_exception* dep_exception_header =
694 static_cast<__cxa_dependent_exception*>(__cxa_allocate_dependent_exception());
695 dep_exception_header->primaryException = thrown_object;
696 __cxa_increment_exception_refcount(thrown_object);
697 dep_exception_header->exceptionType = exception_header->exceptionType;
698 dep_exception_header->unexpectedHandler = std::get_unexpected();
699 dep_exception_header->terminateHandler = std::get_terminate();
700 setDependentExceptionClass(&dep_exception_header->unwindHeader);
701 __cxa_get_globals()->uncaughtExceptions += 1;
702 dep_exception_header->unwindHeader.exception_cleanup = dependent_exception_cleanup;
703 #if __USING_SJLJ_EXCEPTIONS__
704 _Unwind_SjLj_RaiseException(&dep_exception_header->unwindHeader);
706 _Unwind_RaiseException(&dep_exception_header->unwindHeader);
708 // Some sort of unwinding error. Note that terminate is a handler.
709 __cxa_begin_catch(&dep_exception_header->unwindHeader);
711 // If we return client will call terminate()
715 __cxa_uncaught_exception() throw()
717 // This does not report foreign exceptions in flight
718 __cxa_eh_globals* globals = __cxa_get_globals_fast();
721 return globals->uncaughtExceptions != 0;
726 #pragma GCC visibility pop