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