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// This file implements the "Exception Handling APIs"
9// https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
10//
11//===----------------------------------------------------------------------===//
12
13#include "cxxabi.h"
14
15#include <exception> // for std::terminate
16#include <string.h> // for memset
17#include "cxa_exception.h"
18#include "cxa_handlers.h"
19#include "fallback_malloc.h"
20#include "include/atomic_support.h" // from libc++
21
22#if __has_feature(address_sanitizer)
23#include <sanitizer/asan_interface.h>
24#endif
25
26// +---------------------------+-----------------------------+---------------+
27// | __cxa_exception | _Unwind_Exception CLNGC++\0 | thrown object |
28// +---------------------------+-----------------------------+---------------+
29// ^
30// |
31// +-------------------------------------------------------+
32// |
33// +---------------------------+-----------------------------+
34// | __cxa_dependent_exception | _Unwind_Exception CLNGC++\1 |
35// +---------------------------+-----------------------------+
36
37namespace __cxxabiv1 {
38
39// Utility routines
40static
41inline
42__cxa_exception*
43cxa_exception_from_thrown_object(void* thrown_object)
44{
45 return static_cast<__cxa_exception*>(thrown_object) - 1;
46}
47
48// Note: This is never called when exception_header is masquerading as a
49// __cxa_dependent_exception.
50static
51inline
52void*
53thrown_object_from_cxa_exception(__cxa_exception* exception_header)
54{
55 return static_cast<void*>(exception_header + 1);
56}
57
58// Get the exception object from the unwind pointer.
59// Relies on the structure layout, where the unwind pointer is right in
60// front of the user's exception object
61static
62inline
63__cxa_exception*
64cxa_exception_from_exception_unwind_exception(_Unwind_Exception* unwind_exception)
65{
66 return cxa_exception_from_thrown_object(thrown_object: unwind_exception + 1 );
67}
68
69// Round s up to next multiple of a.
70static inline
71size_t aligned_allocation_size(size_t s, size_t a) {
72 return (s + a - 1) & ~(a - 1);
73}
74
75static inline
76size_t cxa_exception_size_from_exception_thrown_size(size_t size) {
77 return aligned_allocation_size(s: size + sizeof (__cxa_exception),
78 a: alignof(__cxa_exception));
79}
80
81void __setExceptionClass(_Unwind_Exception* unwind_exception, uint64_t newValue) {
82 ::memcpy(dest: &unwind_exception->exception_class, src: &newValue, n: sizeof(newValue));
83}
84
85
86static void setOurExceptionClass(_Unwind_Exception* unwind_exception) {
87 __setExceptionClass(unwind_exception, newValue: kOurExceptionClass);
88}
89
90static void setDependentExceptionClass(_Unwind_Exception* unwind_exception) {
91 __setExceptionClass(unwind_exception, newValue: kOurDependentExceptionClass);
92}
93
94// Is it one of ours?
95uint64_t __getExceptionClass(const _Unwind_Exception* unwind_exception) {
96 // On x86 and some ARM unwinders, unwind_exception->exception_class is
97 // a uint64_t. On other ARM unwinders, it is a char[8].
98 // See: http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf
99 // So we just copy it into a uint64_t to be sure.
100 uint64_t exClass;
101 ::memcpy(dest: &exClass, src: &unwind_exception->exception_class, n: sizeof(exClass));
102 return exClass;
103}
104
105bool __isOurExceptionClass(const _Unwind_Exception* unwind_exception) {
106 return (__getExceptionClass(unwind_exception) & get_vendor_and_language) ==
107 (kOurExceptionClass & get_vendor_and_language);
108}
109
110static bool isDependentException(_Unwind_Exception* unwind_exception) {
111 return (__getExceptionClass(unwind_exception) & 0xFF) == 0x01;
112}
113
114// This does not need to be atomic
115static inline int incrementHandlerCount(__cxa_exception *exception) {
116 return ++exception->handlerCount;
117}
118
119// This does not need to be atomic
120static inline int decrementHandlerCount(__cxa_exception *exception) {
121 return --exception->handlerCount;
122}
123
124/*
125 If reason isn't _URC_FOREIGN_EXCEPTION_CAUGHT, then the terminateHandler
126 stored in exc is called. Otherwise the exceptionDestructor stored in
127 exc is called, and then the memory for the exception is deallocated.
128
129 This is never called for a __cxa_dependent_exception.
130*/
131static
132void
133exception_cleanup_func(_Unwind_Reason_Code reason, _Unwind_Exception* unwind_exception)
134{
135 __cxa_exception* exception_header = cxa_exception_from_exception_unwind_exception(unwind_exception);
136 if (_URC_FOREIGN_EXCEPTION_CAUGHT != reason)
137 std::__terminate(func: exception_header->terminateHandler);
138 // Just in case there exists a dependent exception that is pointing to this,
139 // check the reference count and only destroy this if that count goes to zero.
140 __cxa_decrement_exception_refcount(primary_exception: unwind_exception + 1);
141}
142
143static _LIBCXXABI_NORETURN void failed_throw(__cxa_exception* exception_header) {
144// Section 2.5.3 says:
145// * For purposes of this ABI, several things are considered exception handlers:
146// ** A terminate() call due to a throw.
147// and
148// * Upon entry, Following initialization of the catch parameter,
149// a handler must call:
150// * void *__cxa_begin_catch(void *exceptionObject );
151 (void) __cxa_begin_catch(exceptionObject: &exception_header->unwindHeader);
152 std::__terminate(func: exception_header->terminateHandler);
153}
154
155// Return the offset of the __cxa_exception header from the start of the
156// allocated buffer. If __cxa_exception's alignment is smaller than the maximum
157// useful alignment for the target machine, padding has to be inserted before
158// the header to ensure the thrown object that follows the header is
159// sufficiently aligned. This happens if _Unwind_exception isn't double-word
160// aligned (on Darwin, for example).
161static size_t get_cxa_exception_offset() {
162 struct S {
163 } __attribute__((aligned));
164
165 // Compute the maximum alignment for the target machine.
166 constexpr size_t alignment = alignof(S);
167 constexpr size_t excp_size = sizeof(__cxa_exception);
168 constexpr size_t aligned_size =
169 (excp_size + alignment - 1) / alignment * alignment;
170 constexpr size_t offset = aligned_size - excp_size;
171 static_assert((offset == 0 || alignof(_Unwind_Exception) < alignment),
172 "offset is non-zero only if _Unwind_Exception isn't aligned");
173 return offset;
174}
175
176extern "C" {
177
178// Allocate a __cxa_exception object, and zero-fill it.
179// Reserve "thrown_size" bytes on the end for the user's exception
180// object. Zero-fill the object. If memory can't be allocated, call
181// std::terminate. Return a pointer to the memory to be used for the
182// user's exception object.
183void *__cxa_allocate_exception(size_t thrown_size) throw() {
184 size_t actual_size = cxa_exception_size_from_exception_thrown_size(size: thrown_size);
185
186 // Allocate extra space before the __cxa_exception header to ensure the
187 // start of the thrown object is sufficiently aligned.
188 size_t header_offset = get_cxa_exception_offset();
189 char *raw_buffer =
190 (char *)__aligned_malloc_with_fallback(size: header_offset + actual_size);
191 if (NULL == raw_buffer)
192 std::terminate();
193 __cxa_exception *exception_header =
194 static_cast<__cxa_exception *>((void *)(raw_buffer + header_offset));
195 ::memset(s: exception_header, c: 0, n: actual_size);
196 return thrown_object_from_cxa_exception(exception_header);
197}
198
199
200// Free a __cxa_exception object allocated with __cxa_allocate_exception.
201void __cxa_free_exception(void *thrown_object) throw() {
202 // Compute the size of the padding before the header.
203 size_t header_offset = get_cxa_exception_offset();
204 char *raw_buffer =
205 ((char *)cxa_exception_from_thrown_object(thrown_object)) - header_offset;
206 __aligned_free_with_fallback(ptr: (void *)raw_buffer);
207}
208
209__cxa_exception* __cxa_init_primary_exception(void* object, std::type_info* tinfo,
210#ifdef __wasm__
211// In Wasm, a destructor returns its argument
212 void *(_LIBCXXABI_DTOR_FUNC* dest)(void*)) throw() {
213#else
214 void(_LIBCXXABI_DTOR_FUNC* dest)(void*)) throw() {
215#endif
216 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object: object);
217 exception_header->referenceCount = 0;
218 exception_header->unexpectedHandler = std::get_unexpected();
219 exception_header->terminateHandler = std::get_terminate();
220 exception_header->exceptionType = tinfo;
221 exception_header->exceptionDestructor = dest;
222 setOurExceptionClass(&exception_header->unwindHeader);
223 exception_header->unwindHeader.exception_cleanup = exception_cleanup_func;
224
225 return exception_header;
226}
227
228// This function shall allocate a __cxa_dependent_exception and
229// return a pointer to it. (Really to the object, not past its' end).
230// Otherwise, it will work like __cxa_allocate_exception.
231void * __cxa_allocate_dependent_exception () {
232 size_t actual_size = sizeof(__cxa_dependent_exception);
233 void *ptr = __aligned_malloc_with_fallback(size: actual_size);
234 if (NULL == ptr)
235 std::terminate();
236 ::memset(s: ptr, c: 0, n: actual_size);
237 return ptr;
238}
239
240
241// This function shall free a dependent_exception.
242// It does not affect the reference count of the primary exception.
243void __cxa_free_dependent_exception (void * dependent_exception) {
244 __aligned_free_with_fallback(ptr: dependent_exception);
245}
246
247
248// 2.4.3 Throwing the Exception Object
249/*
250After constructing the exception object with the throw argument value,
251the generated code calls the __cxa_throw runtime library routine. This
252routine never returns.
253
254The __cxa_throw routine will do the following:
255
256* Obtain the __cxa_exception header from the thrown exception object address,
257which can be computed as follows:
258 __cxa_exception *header = ((__cxa_exception *) thrown_exception - 1);
259* Save the current unexpected_handler and terminate_handler in the __cxa_exception header.
260* Save the tinfo and dest arguments in the __cxa_exception header.
261* Set the exception_class field in the unwind header. This is a 64-bit value
262representing the ASCII string "XXXXC++\0", where "XXXX" is a
263vendor-dependent string. That is, for implementations conforming to this
264ABI, the low-order 4 bytes of this 64-bit value will be "C++\0".
265* Increment the uncaught_exception flag.
266* Call _Unwind_RaiseException in the system unwind library, Its argument is the
267pointer to the thrown exception, which __cxa_throw itself received as an argument.
268__Unwind_RaiseException begins the process of stack unwinding, described
269in Section 2.5. In special cases, such as an inability to find a
270handler, _Unwind_RaiseException may return. In that case, __cxa_throw
271will call terminate, assuming that there was no handler for the
272exception.
273*/
274void
275#ifdef __wasm__
276// In Wasm, a destructor returns its argument
277__cxa_throw(void *thrown_object, std::type_info *tinfo, void *(_LIBCXXABI_DTOR_FUNC *dest)(void *)) {
278#else
279__cxa_throw(void *thrown_object, std::type_info *tinfo, void (_LIBCXXABI_DTOR_FUNC *dest)(void *)) {
280#endif
281 __cxa_eh_globals* globals = __cxa_get_globals();
282 globals->uncaughtExceptions += 1; // Not atomically, since globals are thread-local
283
284 __cxa_exception* exception_header = __cxa_init_primary_exception(object: thrown_object, tinfo, dest);
285 exception_header->referenceCount = 1; // This is a newly allocated exception, no need for thread safety.
286
287#if __has_feature(address_sanitizer)
288 // Inform the ASan runtime that now might be a good time to clean stuff up.
289 __asan_handle_no_return();
290#endif
291
292#ifdef __USING_SJLJ_EXCEPTIONS__
293 _Unwind_SjLj_RaiseException(&exception_header->unwindHeader);
294#else
295 _Unwind_RaiseException(exception_object: &exception_header->unwindHeader);
296#endif
297 // This only happens when there is no handler, or some unexpected unwinding
298 // error happens.
299 failed_throw(exception_header);
300}
301
302
303// 2.5.3 Exception Handlers
304/*
305The adjusted pointer is computed by the personality routine during phase 1
306 and saved in the exception header (either __cxa_exception or
307 __cxa_dependent_exception).
308
309 Requires: exception is native
310*/
311void *__cxa_get_exception_ptr(void *unwind_exception) throw() {
312#if defined(_LIBCXXABI_ARM_EHABI)
313 return reinterpret_cast<void*>(
314 static_cast<_Unwind_Control_Block*>(unwind_exception)->barrier_cache.bitpattern[0]);
315#else
316 return cxa_exception_from_exception_unwind_exception(
317 unwind_exception: static_cast<_Unwind_Exception*>(unwind_exception))->adjustedPtr;
318#endif
319}
320
321#if defined(_LIBCXXABI_ARM_EHABI)
322/*
323The routine to be called before the cleanup. This will save __cxa_exception in
324__cxa_eh_globals, so that __cxa_end_cleanup() can recover later.
325*/
326bool __cxa_begin_cleanup(void *unwind_arg) throw() {
327 _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(unwind_arg);
328 __cxa_eh_globals* globals = __cxa_get_globals();
329 __cxa_exception* exception_header =
330 cxa_exception_from_exception_unwind_exception(unwind_exception);
331
332 if (__isOurExceptionClass(unwind_exception))
333 {
334 if (0 == exception_header->propagationCount)
335 {
336 exception_header->nextPropagatingException = globals->propagatingExceptions;
337 globals->propagatingExceptions = exception_header;
338 }
339 ++exception_header->propagationCount;
340 }
341 else
342 {
343 // If the propagatingExceptions stack is not empty, since we can't
344 // chain the foreign exception, terminate it.
345 if (NULL != globals->propagatingExceptions)
346 std::terminate();
347 globals->propagatingExceptions = exception_header;
348 }
349 return true;
350}
351
352/*
353The routine to be called after the cleanup has been performed. It will get the
354propagating __cxa_exception from __cxa_eh_globals, and continue the stack
355unwinding with _Unwind_Resume.
356
357According to ARM EHABI 8.4.1, __cxa_end_cleanup() should not clobber any
358register, thus we have to write this function in assembly so that we can save
359{r1, r2, r3}. We don't have to save r0 because it is the return value and the
360first argument to _Unwind_Resume(). The function also saves/restores r4 to
361keep the stack aligned and to provide a temp register. _Unwind_Resume never
362returns and we need to keep the original lr so just branch to it. When
363targeting bare metal, the function also clobbers ip/r12 to hold the address of
364_Unwind_Resume, which may be too far away for an ordinary branch.
365*/
366__attribute__((used)) static _Unwind_Exception *
367__cxa_end_cleanup_impl()
368{
369 __cxa_eh_globals* globals = __cxa_get_globals();
370 __cxa_exception* exception_header = globals->propagatingExceptions;
371 if (NULL == exception_header)
372 {
373 // It seems that __cxa_begin_cleanup() is not called properly.
374 // We have no choice but terminate the program now.
375 std::terminate();
376 }
377
378 if (__isOurExceptionClass(&exception_header->unwindHeader))
379 {
380 --exception_header->propagationCount;
381 if (0 == exception_header->propagationCount)
382 {
383 globals->propagatingExceptions = exception_header->nextPropagatingException;
384 exception_header->nextPropagatingException = NULL;
385 }
386 }
387 else
388 {
389 globals->propagatingExceptions = NULL;
390 }
391 return &exception_header->unwindHeader;
392}
393
394asm(" .pushsection .text.__cxa_end_cleanup,\"ax\",%progbits\n"
395 " .globl __cxa_end_cleanup\n"
396 " .type __cxa_end_cleanup,%function\n"
397 "__cxa_end_cleanup:\n"
398#if defined(__ARM_FEATURE_BTI_DEFAULT)
399 " bti\n"
400#endif
401 " push {r1, r2, r3, r4}\n"
402 " mov r4, lr\n"
403 " bl __cxa_end_cleanup_impl\n"
404 " mov lr, r4\n"
405#if defined(LIBCXXABI_BAREMETAL)
406 " ldr r4, =_Unwind_Resume\n"
407 " mov ip, r4\n"
408#endif
409 " pop {r1, r2, r3, r4}\n"
410#if defined(LIBCXXABI_BAREMETAL)
411 " bx ip\n"
412#else
413 " b _Unwind_Resume\n"
414#endif
415 " .popsection");
416#endif // defined(_LIBCXXABI_ARM_EHABI)
417
418/*
419This routine can catch foreign or native exceptions. If native, the exception
420can be a primary or dependent variety. This routine may remain blissfully
421ignorant of whether the native exception is primary or dependent.
422
423If the exception is native:
424* Increment's the exception's handler count.
425* Push the exception on the stack of currently-caught exceptions if it is not
426 already there (from a rethrow).
427* Decrements the uncaught_exception count.
428* Returns the adjusted pointer to the exception object, which is stored in
429 the __cxa_exception by the personality routine.
430
431If the exception is foreign, this means it did not originate from one of throw
432routines. The foreign exception does not necessarily have a __cxa_exception
433header. However we can catch it here with a catch (...), or with a call
434to terminate or unexpected during unwinding.
435* Do not try to increment the exception's handler count, we don't know where
436 it is.
437* Push the exception on the stack of currently-caught exceptions only if the
438 stack is empty. The foreign exception has no way to link to the current
439 top of stack. If the stack is not empty, call terminate. Even with an
440 empty stack, this is hacked in by pushing a pointer to an imaginary
441 __cxa_exception block in front of the foreign exception. It would be better
442 if the __cxa_eh_globals structure had a stack of _Unwind_Exception, but it
443 doesn't. It has a stack of __cxa_exception (which has a next* in it).
444* Do not decrement the uncaught_exception count because we didn't increment it
445 in __cxa_throw (or one of our rethrow functions).
446* If we haven't terminated, assume the exception object is just past the
447 _Unwind_Exception and return a pointer to that.
448*/
449void*
450__cxa_begin_catch(void* unwind_arg) throw()
451{
452 _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(unwind_arg);
453 bool native_exception = __isOurExceptionClass(unwind_exception);
454 __cxa_eh_globals* globals = __cxa_get_globals();
455 // exception_header is a hackish offset from a foreign exception, but it
456 // works as long as we're careful not to try to access any __cxa_exception
457 // parts.
458 __cxa_exception* exception_header =
459 cxa_exception_from_exception_unwind_exception
460 (
461 unwind_exception: static_cast<_Unwind_Exception*>(unwind_exception)
462 );
463
464#if defined(__MVS__)
465 // Remove the exception object from the linked list of exceptions that the z/OS unwinder
466 // maintains before adding it to the libc++abi list of caught exceptions.
467 // The libc++abi will manage the lifetime of the exception from this point forward.
468 _UnwindZOS_PopException();
469#endif
470
471 if (native_exception)
472 {
473 // Increment the handler count, removing the flag about being rethrown
474 exception_header->handlerCount = exception_header->handlerCount < 0 ?
475 -exception_header->handlerCount + 1 : exception_header->handlerCount + 1;
476 // place the exception on the top of the stack if it's not already
477 // there by a previous rethrow
478 if (exception_header != globals->caughtExceptions)
479 {
480 exception_header->nextException = globals->caughtExceptions;
481 globals->caughtExceptions = exception_header;
482 }
483 globals->uncaughtExceptions -= 1; // Not atomically, since globals are thread-local
484#if defined(_LIBCXXABI_ARM_EHABI)
485 return reinterpret_cast<void*>(exception_header->unwindHeader.barrier_cache.bitpattern[0]);
486#else
487 return exception_header->adjustedPtr;
488#endif
489 }
490 // Else this is a foreign exception
491 // If the caughtExceptions stack is not empty, terminate
492 if (globals->caughtExceptions != 0)
493 std::terminate();
494 // Push the foreign exception on to the stack
495 globals->caughtExceptions = exception_header;
496 return unwind_exception + 1;
497}
498
499
500/*
501Upon exit for any reason, a handler must call:
502 void __cxa_end_catch ();
503
504This routine can be called for either a native or foreign exception.
505For a native exception:
506* Locates the most recently caught exception and decrements its handler count.
507* Removes the exception from the caught exception stack, if the handler count goes to zero.
508* If the handler count goes down to zero, and the exception was not re-thrown
509 by throw, it locates the primary exception (which may be the same as the one
510 it's handling) and decrements its reference count. If that reference count
511 goes to zero, the function destroys the exception. In any case, if the current
512 exception is a dependent exception, it destroys that.
513
514For a foreign exception:
515* If it has been rethrown, there is nothing to do.
516* Otherwise delete the exception and pop the catch stack to empty.
517*/
518void __cxa_end_catch() {
519 static_assert(sizeof(__cxa_exception) == sizeof(__cxa_dependent_exception),
520 "sizeof(__cxa_exception) must be equal to "
521 "sizeof(__cxa_dependent_exception)");
522 static_assert(__builtin_offsetof(__cxa_exception, referenceCount) ==
523 __builtin_offsetof(__cxa_dependent_exception,
524 primaryException),
525 "the layout of __cxa_exception must match the layout of "
526 "__cxa_dependent_exception");
527 static_assert(__builtin_offsetof(__cxa_exception, handlerCount) ==
528 __builtin_offsetof(__cxa_dependent_exception, handlerCount),
529 "the layout of __cxa_exception must match the layout of "
530 "__cxa_dependent_exception");
531 __cxa_eh_globals* globals = __cxa_get_globals_fast(); // __cxa_get_globals called in __cxa_begin_catch
532 __cxa_exception* exception_header = globals->caughtExceptions;
533 // If we've rethrown a foreign exception, then globals->caughtExceptions
534 // will have been made an empty stack by __cxa_rethrow() and there is
535 // nothing more to be done. Do nothing!
536 if (NULL != exception_header)
537 {
538 bool native_exception = __isOurExceptionClass(unwind_exception: &exception_header->unwindHeader);
539 if (native_exception)
540 {
541 // This is a native exception
542 if (exception_header->handlerCount < 0)
543 {
544 // The exception has been rethrown by __cxa_rethrow, so don't delete it
545 if (0 == incrementHandlerCount(exception: exception_header))
546 {
547 // Remove from the chain of uncaught exceptions
548 globals->caughtExceptions = exception_header->nextException;
549 // but don't destroy
550 }
551 // Keep handlerCount negative in case there are nested catch's
552 // that need to be told that this exception is rethrown. Don't
553 // erase this rethrow flag until the exception is recaught.
554 }
555 else
556 {
557 // The native exception has not been rethrown
558 if (0 == decrementHandlerCount(exception: exception_header))
559 {
560 // Remove from the chain of uncaught exceptions
561 globals->caughtExceptions = exception_header->nextException;
562 // Destroy this exception, being careful to distinguish
563 // between dependent and primary exceptions
564 if (isDependentException(unwind_exception: &exception_header->unwindHeader))
565 {
566 // Reset exception_header to primaryException and deallocate the dependent exception
567 __cxa_dependent_exception* dep_exception_header =
568 reinterpret_cast<__cxa_dependent_exception*>(exception_header);
569 exception_header =
570 cxa_exception_from_thrown_object(thrown_object: dep_exception_header->primaryException);
571 __cxa_free_dependent_exception(dependent_exception: dep_exception_header);
572 }
573 // Destroy the primary exception only if its referenceCount goes to 0
574 // (this decrement must be atomic)
575 __cxa_decrement_exception_refcount(primary_exception: thrown_object_from_cxa_exception(exception_header));
576 }
577 }
578 }
579 else
580 {
581 // The foreign exception has not been rethrown. Pop the stack
582 // and delete it. If there are nested catch's and they try
583 // to touch a foreign exception in any way, that is undefined
584 // behavior. They likely can't since the only way to catch
585 // a foreign exception is with catch (...)!
586 _Unwind_DeleteException(exception_object: &globals->caughtExceptions->unwindHeader);
587 globals->caughtExceptions = 0;
588 }
589 }
590}
591
592void __cxa_call_terminate(void* unwind_arg) throw() {
593 __cxa_begin_catch(unwind_arg);
594 std::terminate();
595}
596
597// Note: exception_header may be masquerading as a __cxa_dependent_exception
598// and that's ok. exceptionType is there too.
599// However watch out for foreign exceptions. Return null for them.
600std::type_info *__cxa_current_exception_type() {
601// get the current exception
602 __cxa_eh_globals *globals = __cxa_get_globals_fast();
603 if (NULL == globals)
604 return NULL; // If there have never been any exceptions, there are none now.
605 __cxa_exception *exception_header = globals->caughtExceptions;
606 if (NULL == exception_header)
607 return NULL; // No current exception
608 if (!__isOurExceptionClass(unwind_exception: &exception_header->unwindHeader))
609 return NULL;
610 return exception_header->exceptionType;
611}
612
613// 2.5.4 Rethrowing Exceptions
614/* This routine can rethrow native or foreign exceptions.
615If the exception is native:
616* marks the exception object on top of the caughtExceptions stack
617 (in an implementation-defined way) as being rethrown.
618* If the caughtExceptions stack is empty, it calls terminate()
619 (see [C++FDIS] [except.throw], 15.1.8).
620* It then calls _Unwind_RaiseException which should not return
621 (terminate if it does).
622 Note: exception_header may be masquerading as a __cxa_dependent_exception
623 and that's ok.
624*/
625void __cxa_rethrow() {
626 __cxa_eh_globals* globals = __cxa_get_globals();
627 __cxa_exception* exception_header = globals->caughtExceptions;
628 if (NULL == exception_header)
629 std::terminate(); // throw; called outside of a exception handler
630 bool native_exception = __isOurExceptionClass(unwind_exception: &exception_header->unwindHeader);
631 if (native_exception)
632 {
633 // Mark the exception as being rethrown (reverse the effects of __cxa_begin_catch)
634 exception_header->handlerCount = -exception_header->handlerCount;
635 globals->uncaughtExceptions += 1;
636 // __cxa_end_catch will remove this exception from the caughtExceptions stack if necessary
637 }
638 else // this is a foreign exception
639 {
640 // The only way to communicate to __cxa_end_catch that we've rethrown
641 // a foreign exception, so don't delete us, is to pop the stack here
642 // which must be empty afterwards. Then __cxa_end_catch will do
643 // nothing
644 globals->caughtExceptions = 0;
645 }
646#ifdef __USING_SJLJ_EXCEPTIONS__
647 _Unwind_SjLj_RaiseException(&exception_header->unwindHeader);
648#else
649 _Unwind_RaiseException(exception_object: &exception_header->unwindHeader);
650#endif
651
652 // If we get here, some kind of unwinding error has occurred.
653 // There is some weird code generation bug happening with
654 // Apple clang version 4.0 (tags/Apple/clang-418.0.2) (based on LLVM 3.1svn)
655 // If we call failed_throw here. Turns up with -O2 or higher, and -Os.
656 __cxa_begin_catch(unwind_arg: &exception_header->unwindHeader);
657 if (native_exception)
658 std::__terminate(func: exception_header->terminateHandler);
659 // Foreign exception: can't get exception_header->terminateHandler
660 std::terminate();
661}
662
663/*
664 If thrown_object is not null, atomically increment the referenceCount field
665 of the __cxa_exception header associated with the thrown object referred to
666 by thrown_object.
667
668 Requires: If thrown_object is not NULL, it is a native exception.
669*/
670void
671__cxa_increment_exception_refcount(void *thrown_object) throw() {
672 if (thrown_object != NULL )
673 {
674 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
675 std::__libcpp_atomic_add(val: &exception_header->referenceCount, a: size_t(1));
676 }
677}
678
679/*
680 If thrown_object is not null, atomically decrement the referenceCount field
681 of the __cxa_exception header associated with the thrown object referred to
682 by thrown_object. If the referenceCount drops to zero, destroy and
683 deallocate the exception.
684
685 Requires: If thrown_object is not NULL, it is a native exception.
686*/
687_LIBCXXABI_NO_CFI
688void __cxa_decrement_exception_refcount(void *thrown_object) throw() {
689 if (thrown_object != NULL )
690 {
691 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
692 if (std::__libcpp_atomic_add(val: &exception_header->referenceCount, a: size_t(-1)) == 0)
693 {
694 if (NULL != exception_header->exceptionDestructor)
695 exception_header->exceptionDestructor(thrown_object);
696 __cxa_free_exception(thrown_object);
697 }
698 }
699}
700
701/*
702 Returns a pointer to the thrown object (if any) at the top of the
703 caughtExceptions stack. Atomically increment the exception's referenceCount.
704 If there is no such thrown object or if the thrown object is foreign,
705 returns null.
706
707 We can use __cxa_get_globals_fast here to get the globals because if there have
708 been no exceptions thrown, ever, on this thread, we can return NULL without
709 the need to allocate the exception-handling globals.
710*/
711void *__cxa_current_primary_exception() throw() {
712// get the current exception
713 __cxa_eh_globals* globals = __cxa_get_globals_fast();
714 if (NULL == globals)
715 return NULL; // If there are no globals, there is no exception
716 __cxa_exception* exception_header = globals->caughtExceptions;
717 if (NULL == exception_header)
718 return NULL; // No current exception
719 if (!__isOurExceptionClass(unwind_exception: &exception_header->unwindHeader))
720 return NULL; // Can't capture a foreign exception (no way to refcount it)
721 if (isDependentException(unwind_exception: &exception_header->unwindHeader)) {
722 __cxa_dependent_exception* dep_exception_header =
723 reinterpret_cast<__cxa_dependent_exception*>(exception_header);
724 exception_header = cxa_exception_from_thrown_object(thrown_object: dep_exception_header->primaryException);
725 }
726 void* thrown_object = thrown_object_from_cxa_exception(exception_header);
727 __cxa_increment_exception_refcount(thrown_object);
728 return thrown_object;
729}
730
731/*
732 If reason isn't _URC_FOREIGN_EXCEPTION_CAUGHT, then the terminateHandler
733 stored in exc is called. Otherwise the referenceCount stored in the
734 primary exception is decremented, destroying the primary if necessary.
735 Finally the dependent exception is destroyed.
736*/
737static
738void
739dependent_exception_cleanup(_Unwind_Reason_Code reason, _Unwind_Exception* unwind_exception)
740{
741 __cxa_dependent_exception* dep_exception_header =
742 reinterpret_cast<__cxa_dependent_exception*>(unwind_exception + 1) - 1;
743 if (_URC_FOREIGN_EXCEPTION_CAUGHT != reason)
744 std::__terminate(func: dep_exception_header->terminateHandler);
745 __cxa_decrement_exception_refcount(thrown_object: dep_exception_header->primaryException);
746 __cxa_free_dependent_exception(dependent_exception: dep_exception_header);
747}
748
749/*
750 If thrown_object is not null, allocate, initialize and throw a dependent
751 exception.
752*/
753void
754__cxa_rethrow_primary_exception(void* thrown_object)
755{
756 if ( thrown_object != NULL )
757 {
758 // thrown_object guaranteed to be native because
759 // __cxa_current_primary_exception returns NULL for foreign exceptions
760 __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
761 __cxa_dependent_exception* dep_exception_header =
762 static_cast<__cxa_dependent_exception*>(__cxa_allocate_dependent_exception());
763 dep_exception_header->primaryException = thrown_object;
764 __cxa_increment_exception_refcount(thrown_object);
765 dep_exception_header->exceptionType = exception_header->exceptionType;
766 dep_exception_header->unexpectedHandler = std::get_unexpected();
767 dep_exception_header->terminateHandler = std::get_terminate();
768 setDependentExceptionClass(&dep_exception_header->unwindHeader);
769 __cxa_get_globals()->uncaughtExceptions += 1;
770 dep_exception_header->unwindHeader.exception_cleanup = dependent_exception_cleanup;
771#ifdef __USING_SJLJ_EXCEPTIONS__
772 _Unwind_SjLj_RaiseException(&dep_exception_header->unwindHeader);
773#else
774 _Unwind_RaiseException(exception_object: &dep_exception_header->unwindHeader);
775#endif
776 // Some sort of unwinding error. Note that terminate is a handler.
777 __cxa_begin_catch(unwind_arg: &dep_exception_header->unwindHeader);
778 }
779 // If we return client will call terminate()
780}
781
782bool
783__cxa_uncaught_exception() throw() { return __cxa_uncaught_exceptions() != 0; }
784
785unsigned int
786__cxa_uncaught_exceptions() throw()
787{
788 // This does not report foreign exceptions in flight
789 __cxa_eh_globals* globals = __cxa_get_globals_fast();
790 if (globals == 0)
791 return 0;
792 return globals->uncaughtExceptions;
793}
794
795} // extern "C"
796
797} // abi
798