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