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