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