2 * Copyright 2010-2011 PathScale, Inc. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
7 * 1. Redistributions of source code must retain the above copyright notice,
8 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
15 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
24 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 #define _MTHREADIFY_PTHREADS 1
37 #include <minix/mthread.h>
38 #define LIBCXXRT_WEAK_LOCKS 1
39 #endif /* !defined(__minix) */
46 #pragma weak pthread_key_create
47 #pragma weak pthread_setspecific
48 #pragma weak pthread_getspecific
49 #pragma weak pthread_once
50 #ifdef LIBCXXRT_WEAK_LOCKS
51 #pragma weak pthread_mutex_lock
52 #define pthread_mutex_lock(mtx) do {\
53 if (pthread_mutex_lock) pthread_mutex_lock(mtx);\
55 #pragma weak pthread_mutex_unlock
56 #define pthread_mutex_unlock(mtx) do {\
57 if (pthread_mutex_unlock) pthread_mutex_unlock(mtx);\
59 #pragma weak pthread_cond_signal
60 #define pthread_cond_signal(cv) do {\
61 if (pthread_cond_signal) pthread_cond_signal(cv);\
63 #pragma weak pthread_cond_wait
64 #define pthread_cond_wait(cv, mtx) do {\
65 if (pthread_cond_wait) pthread_cond_wait(cv, mtx);\
69 using namespace ABI_NAMESPACE
;
72 * Saves the result of the landing pad that we have found. For ARM, this is
73 * stored in the generic unwind structure, while on other platforms it is
74 * stored in the C++ exception.
76 static void saveLandingPad(struct _Unwind_Context
*context
,
77 struct _Unwind_Exception
*ucb
,
78 struct __cxa_exception
*ex
,
80 dw_eh_ptr_t landingPad
)
82 #if defined(__arm__) && !defined(__ARM_DWARF_EH__)
83 // On ARM, we store the saved exception in the generic part of the structure
84 ucb
->barrier_cache
.sp
= _Unwind_GetGR(context
, 13);
85 ucb
->barrier_cache
.bitpattern
[1] = static_cast<uint32_t>(selector
);
86 ucb
->barrier_cache
.bitpattern
[3] = reinterpret_cast<uint32_t>(landingPad
);
88 // Cache the results for the phase 2 unwind, if we found a handler
89 // and this is not a foreign exception.
92 ex
->handlerSwitchValue
= selector
;
93 ex
->catchTemp
= landingPad
;
98 * Loads the saved landing pad. Returns 1 on success, 0 on failure.
100 static int loadLandingPad(struct _Unwind_Context
*context
,
101 struct _Unwind_Exception
*ucb
,
102 struct __cxa_exception
*ex
,
103 unsigned long *selector
,
104 dw_eh_ptr_t
*landingPad
)
106 #if defined(__arm__) && !defined(__ARM_DWARF_EH__)
107 *selector
= ucb
->barrier_cache
.bitpattern
[1];
108 *landingPad
= reinterpret_cast<dw_eh_ptr_t
>(ucb
->barrier_cache
.bitpattern
[3]);
113 *selector
= ex
->handlerSwitchValue
;
114 *landingPad
= reinterpret_cast<dw_eh_ptr_t
>(ex
->catchTemp
);
121 static inline _Unwind_Reason_Code
continueUnwinding(struct _Unwind_Exception
*ex
,
122 struct _Unwind_Context
*context
)
124 #if defined(__arm__) && !defined(__ARM_DWARF_EH__)
125 if (__gnu_unwind_frame(ex
, context
) != _URC_OK
) { return _URC_FAILURE
; }
127 return _URC_CONTINUE_UNWIND
;
131 extern "C" void __cxa_free_exception(void *thrown_exception
);
132 extern "C" void __cxa_free_dependent_exception(void *thrown_exception
);
133 extern "C" void* __dynamic_cast(const void *sub
,
134 const __class_type_info
*src
,
135 const __class_type_info
*dst
,
136 ptrdiff_t src2dst_offset
);
139 * The type of a handler that has been found.
146 * A cleanup - the exception will propagate through this frame, but code
147 * must be run when this happens.
151 * A catch statement. The exception will not propagate past this frame
152 * (without an explicit rethrow).
158 * Per-thread info required by the runtime. We store a single structure
159 * pointer in thread-local storage, because this tends to be a scarce resource
160 * and it's impolite to steal all of it and not leave any for the rest of the
163 * Instances of this structure are allocated lazily - at most one per thread -
164 * and are destroyed on thread termination.
166 struct __cxa_thread_info
168 /** The termination handler for this thread. */
169 terminate_handler terminateHandler
;
170 /** The unexpected exception handler for this thread. */
171 unexpected_handler unexpectedHandler
;
173 * The number of emergency buffers held by this thread. This is 0 in
174 * normal operation - the emergency buffers are only used when malloc()
175 * fails to return memory for allocating an exception. Threads are not
176 * permitted to hold more than 4 emergency buffers (as per recommendation
177 * in ABI spec [3.3.1]).
179 int emergencyBuffersHeld
;
181 * The exception currently running in a cleanup.
183 _Unwind_Exception
*currentCleanup
;
185 * Our state with respect to foreign exceptions. Usually none, set to
186 * caught if we have just caught an exception and rethrown if we are
194 } foreign_exception_state
;
196 * The public part of this structure, accessible from outside of this
199 __cxa_eh_globals globals
;
202 * Dependent exception. This
204 struct __cxa_dependent_exception
207 void *primaryException
;
209 std::type_info
*exceptionType
;
210 void (*exceptionDestructor
) (void *);
211 unexpected_handler unexpectedHandler
;
212 terminate_handler terminateHandler
;
213 __cxa_exception
*nextException
;
215 #if defined(__arm__) && !defined(__ARM_DWARF_EH__)
216 _Unwind_Exception
*nextCleanup
;
219 int handlerSwitchValue
;
220 const char *actionRecord
;
221 const char *languageSpecificData
;
225 void *primaryException
;
227 _Unwind_Exception unwindHeader
;
237 virtual ~exception() throw();
238 virtual const char* what() const throw();
244 * Class of exceptions to distinguish between this and other exception types.
246 * The first four characters are the vendor ID. Currently, we use GNUC,
247 * because we aim for ABI-compatibility with the GNU implementation, and
248 * various checks may test for equality of the class, which is incorrect.
250 static const uint64_t exception_class
=
251 EXCEPTION_CLASS('G', 'N', 'U', 'C', 'C', '+', '+', '\0');
253 * Class used for dependent exceptions.
255 static const uint64_t dependent_exception_class
=
256 EXCEPTION_CLASS('G', 'N', 'U', 'C', 'C', '+', '+', '\x01');
258 * The low four bytes of the exception class, indicating that we conform to the
259 * Itanium C++ ABI. This is currently unused, but should be used in the future
260 * if we change our exception class, to allow this library and libsupc++ to be
261 * linked to the same executable and both to interoperate.
263 static const uint32_t abi_exception_class
=
264 GENERIC_EXCEPTION_CLASS('C', '+', '+', '\0');
266 static bool isCXXException(uint64_t cls
)
268 return (cls
== exception_class
) || (cls
== dependent_exception_class
);
271 static bool isDependentException(uint64_t cls
)
273 return cls
== dependent_exception_class
;
276 static __cxa_exception
*exceptionFromPointer(void *ex
)
278 return reinterpret_cast<__cxa_exception
*>(static_cast<char*>(ex
) -
279 offsetof(struct __cxa_exception
, unwindHeader
));
281 static __cxa_exception
*realExceptionFromException(__cxa_exception
*ex
)
283 if (!isDependentException(ex
->unwindHeader
.exception_class
)) { return ex
; }
284 return reinterpret_cast<__cxa_exception
*>((reinterpret_cast<__cxa_dependent_exception
*>(ex
))->primaryException
)-1;
290 // Forward declaration of standard library terminate() function used to
292 void terminate(void);
295 using namespace ABI_NAMESPACE
;
299 /** The global termination handler. */
300 static terminate_handler terminateHandler
= abort
;
301 /** The global unexpected exception handler. */
302 static unexpected_handler unexpectedHandler
= std::terminate
;
304 /** Key used for thread-local data. */
305 static pthread_key_t eh_key
;
309 * Cleanup function, allowing foreign exception handlers to correctly destroy
310 * this exception if they catch it.
312 static void exception_cleanup(_Unwind_Reason_Code reason
,
313 struct _Unwind_Exception
*ex
)
315 __cxa_free_exception(static_cast<void*>(ex
));
317 static void dependent_exception_cleanup(_Unwind_Reason_Code reason
,
318 struct _Unwind_Exception
*ex
)
321 __cxa_free_dependent_exception(static_cast<void*>(ex
));
325 * Recursively walk a list of exceptions and delete them all in post-order.
327 static void free_exception_list(__cxa_exception
*ex
)
329 if (0 != ex
->nextException
)
331 free_exception_list(ex
->nextException
);
333 // __cxa_free_exception() expects to be passed the thrown object, which
334 // immediately follows the exception, not the exception itself
335 __cxa_free_exception(ex
+1);
339 * Cleanup function called when a thread exists to make certain that all of the
340 * per-thread data is deleted.
342 static void thread_cleanup(void* thread_info
)
344 __cxa_thread_info
*info
= static_cast<__cxa_thread_info
*>(thread_info
);
345 if (info
->globals
.caughtExceptions
)
347 // If this is a foreign exception, ask it to clean itself up.
348 if (info
->foreign_exception_state
!= __cxa_thread_info::none
)
350 _Unwind_Exception
*e
= reinterpret_cast<_Unwind_Exception
*>(info
->globals
.caughtExceptions
);
351 e
->exception_cleanup(_URC_FOREIGN_EXCEPTION_CAUGHT
, e
);
355 free_exception_list(info
->globals
.caughtExceptions
);
363 * Once control used to protect the key creation.
365 static pthread_once_t once_control
= PTHREAD_ONCE_INIT
;
368 * We may not be linked against a full pthread implementation. If we're not,
369 * then we need to fake the thread-local storage by storing 'thread-local'
370 * things in a global.
374 * Thread-local storage for a single-threaded program.
376 static __cxa_thread_info singleThreadInfo
;
380 static void init_key(void)
382 if ((0 == pthread_key_create
) ||
383 (0 == pthread_setspecific
) ||
384 (0 == pthread_getspecific
))
389 pthread_key_create(&eh_key
, thread_cleanup
);
390 pthread_setspecific(eh_key
, reinterpret_cast<void *>(0x42));
391 fakeTLS
= (pthread_getspecific(eh_key
) != reinterpret_cast<void *>(0x42));
392 pthread_setspecific(eh_key
, 0);
396 * Returns the thread info structure, creating it if it is not already created.
398 static __cxa_thread_info
*thread_info()
400 if ((0 == pthread_once
) || pthread_once(&once_control
, init_key
))
404 if (fakeTLS
) { return &singleThreadInfo
; }
405 __cxa_thread_info
*info
= static_cast<__cxa_thread_info
*>(pthread_getspecific(eh_key
));
408 info
= static_cast<__cxa_thread_info
*>(calloc(1, sizeof(__cxa_thread_info
)));
409 pthread_setspecific(eh_key
, info
);
414 * Fast version of thread_info(). May fail if thread_info() is not called on
415 * this thread at least once already.
417 static __cxa_thread_info
*thread_info_fast()
419 if (fakeTLS
) { return &singleThreadInfo
; }
420 return static_cast<__cxa_thread_info
*>(pthread_getspecific(eh_key
));
423 * ABI function returning the __cxa_eh_globals structure.
425 extern "C" __cxa_eh_globals
*ABI_NAMESPACE::__cxa_get_globals(void)
427 return &(thread_info()->globals
);
430 * Version of __cxa_get_globals() assuming that __cxa_get_globals() has already
431 * been called at least once by this thread.
433 extern "C" __cxa_eh_globals
*ABI_NAMESPACE::__cxa_get_globals_fast(void)
435 return &(thread_info_fast()->globals
);
439 * An emergency allocation reserved for when malloc fails. This is treated as
440 * 16 buffers of 1KB each.
442 static char emergency_buffer
[16384];
444 * Flag indicating whether each buffer is allocated.
446 static bool buffer_allocated
[16];
448 * Lock used to protect emergency allocation.
450 static pthread_mutex_t emergency_malloc_lock
= PTHREAD_MUTEX_INITIALIZER
;
452 * Condition variable used to wait when two threads are both trying to use the
453 * emergency malloc() buffer at once.
455 static pthread_cond_t emergency_malloc_wait
= PTHREAD_COND_INITIALIZER
;
458 * Allocates size bytes from the emergency allocation mechanism, if possible.
459 * This function will fail if size is over 1KB or if this thread already has 4
460 * emergency buffers. If all emergency buffers are allocated, it will sleep
461 * until one becomes available.
463 static char *emergency_malloc(size_t size
)
465 if (size
> 1024) { return 0; }
467 __cxa_thread_info
*info
= thread_info();
468 // Only 4 emergency buffers allowed per thread!
469 if (info
->emergencyBuffersHeld
> 3) { return 0; }
471 pthread_mutex_lock(&emergency_malloc_lock
);
475 // While we were sleeping on the lock, another thread might have free'd
476 // enough memory for us to use, so try the allocation again - no point
477 // using the emergency buffer if there is some real memory that we can
479 void *m
= calloc(1, size
);
482 pthread_mutex_unlock(&emergency_malloc_lock
);
483 return static_cast<char*>(m
);
485 for (int i
=0 ; i
<16 ; i
++)
487 if (!buffer_allocated
[i
])
490 buffer_allocated
[i
] = true;
494 // If there still isn't a buffer available, then sleep on the condition
495 // variable. This will be signalled when another thread releases one
496 // of the emergency buffers.
499 pthread_cond_wait(&emergency_malloc_wait
, &emergency_malloc_lock
);
502 pthread_mutex_unlock(&emergency_malloc_lock
);
503 info
->emergencyBuffersHeld
++;
504 return emergency_buffer
+ (1024 * buffer
);
508 * Frees a buffer returned by emergency_malloc().
510 * Note: Neither this nor emergency_malloc() is particularly efficient. This
511 * should not matter, because neither will be called in normal operation - they
512 * are only used when the program runs out of memory, which should not happen
515 static void emergency_malloc_free(char *ptr
)
518 // Find the buffer corresponding to this pointer.
519 for (int i
=0 ; i
<16 ; i
++)
521 if (ptr
== static_cast<void*>(emergency_buffer
+ (1024 * i
)))
528 "Trying to free something that is not an emergency buffer!");
529 // emergency_malloc() is expected to return 0-initialized data. We don't
530 // zero the buffer when allocating it, because the static buffers will
531 // begin life containing 0 values.
532 memset(ptr
, 0, 1024);
533 // Signal the condition variable to wake up any threads that are blocking
534 // waiting for some space in the emergency buffer
535 pthread_mutex_lock(&emergency_malloc_lock
);
536 // In theory, we don't need to do this with the lock held. In practice,
537 // our array of bools will probably be updated using 32-bit or 64-bit
538 // memory operations, so this update may clobber adjacent values.
539 buffer_allocated
[buffer
] = false;
540 pthread_cond_signal(&emergency_malloc_wait
);
541 pthread_mutex_unlock(&emergency_malloc_lock
);
544 static char *alloc_or_die(size_t size
)
546 char *buffer
= static_cast<char*>(calloc(1, size
));
548 // If calloc() doesn't want to give us any memory, try using an emergency
552 buffer
= emergency_malloc(size
);
553 // This is only reached if the allocation is greater than 1KB, and
554 // anyone throwing objects that big really should know better.
557 fprintf(stderr
, "Out of memory attempting to allocate exception\n");
563 static void free_exception(char *e
)
565 // If this allocation is within the address range of the emergency buffer,
566 // don't call free() because it was not allocated with malloc()
567 if ((e
> emergency_buffer
) &&
568 (e
< (emergency_buffer
+ sizeof(emergency_buffer
))))
570 emergency_malloc_free(e
);
579 * Allocates an exception structure. Returns a pointer to the space that can
580 * be used to store an object of thrown_size bytes. This function will use an
581 * emergency buffer if malloc() fails, and may block if there are no such
584 extern "C" void *__cxa_allocate_exception(size_t thrown_size
)
586 size_t size
= thrown_size
+ sizeof(__cxa_exception
);
587 char *buffer
= alloc_or_die(size
);
588 return buffer
+sizeof(__cxa_exception
);
591 extern "C" void *__cxa_allocate_dependent_exception(void)
593 size_t size
= sizeof(__cxa_dependent_exception
);
594 char *buffer
= alloc_or_die(size
);
595 return buffer
+sizeof(__cxa_dependent_exception
);
599 * __cxa_free_exception() is called when an exception was thrown in between
600 * calling __cxa_allocate_exception() and actually throwing the exception.
601 * This happens when the object's copy constructor throws an exception.
603 * In this implementation, it is also called by __cxa_end_catch() and during
606 extern "C" void __cxa_free_exception(void *thrown_exception
)
608 __cxa_exception
*ex
= reinterpret_cast<__cxa_exception
*>(thrown_exception
) - 1;
609 // Free the object that was thrown, calling its destructor
610 if (0 != ex
->exceptionDestructor
)
614 ex
->exceptionDestructor(thrown_exception
);
618 // FIXME: Check that this is really what the spec says to do.
623 free_exception(reinterpret_cast<char*>(ex
));
626 static void releaseException(__cxa_exception
*exception
)
628 if (isDependentException(exception
->unwindHeader
.exception_class
))
630 __cxa_free_dependent_exception(exception
+1);
633 if (__sync_sub_and_fetch(&exception
->referenceCount
, 1) == 0)
635 // __cxa_free_exception() expects to be passed the thrown object,
636 // which immediately follows the exception, not the exception
638 __cxa_free_exception(exception
+1);
642 void __cxa_free_dependent_exception(void *thrown_exception
)
644 __cxa_dependent_exception
*ex
= reinterpret_cast<__cxa_dependent_exception
*>(thrown_exception
) - 1;
645 assert(isDependentException(ex
->unwindHeader
.exception_class
));
646 if (ex
->primaryException
)
648 releaseException(realExceptionFromException(reinterpret_cast<__cxa_exception
*>(ex
)));
650 free_exception(reinterpret_cast<char*>(ex
));
654 * Callback function used with _Unwind_Backtrace().
656 * Prints a stack trace. Used only for debugging help.
658 * Note: As of FreeBSD 8.1, dladd() still doesn't work properly, so this only
659 * correctly prints function names from public, relocatable, symbols.
661 static _Unwind_Reason_Code
trace(struct _Unwind_Context
*context
, void *c
)
665 dladdr(reinterpret_cast<void *>(__cxa_current_exception_type
), &myinfo
);
666 void *ip
= reinterpret_cast<void*>(_Unwind_GetIP(context
));
668 if (dladdr(ip
, &info
) != 0)
670 if (mylookup
== 0 || strcmp(info
.dli_fname
, myinfo
.dli_fname
) != 0)
672 printf("%p:%s() in %s\n", ip
, info
.dli_sname
, info
.dli_fname
);
675 return _URC_CONTINUE_UNWIND
;
679 * Report a failure that occurred when attempting to throw an exception.
681 * If the failure happened by falling off the end of the stack without finding
682 * a handler, prints a back trace before aborting.
684 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
685 extern "C" void *__cxa_begin_catch(void *e
) throw();
687 extern "C" void *__cxa_begin_catch(void *e
);
689 static void report_failure(_Unwind_Reason_Code err
, __cxa_exception
*thrown_exception
)
694 case _URC_FATAL_PHASE1_ERROR
:
695 fprintf(stderr
, "Fatal error during phase 1 unwinding\n");
697 #if !defined(__arm__) || defined(__ARM_DWARF_EH__)
698 case _URC_FATAL_PHASE2_ERROR
:
699 fprintf(stderr
, "Fatal error during phase 2 unwinding\n");
702 case _URC_END_OF_STACK
:
703 __cxa_begin_catch (&(thrown_exception
->unwindHeader
));
705 fprintf(stderr
, "Terminating due to uncaught exception %p",
706 static_cast<void*>(thrown_exception
));
707 thrown_exception
= realExceptionFromException(thrown_exception
);
708 static const __class_type_info
*e_ti
=
709 static_cast<const __class_type_info
*>(&typeid(std::exception
));
710 const __class_type_info
*throw_ti
=
711 dynamic_cast<const __class_type_info
*>(thrown_exception
->exceptionType
);
715 static_cast<std::exception
*>(e_ti
->cast_to(static_cast<void*>(thrown_exception
+1),
719 fprintf(stderr
, " '%s'", e
->what());
723 size_t bufferSize
= 128;
724 char *demangled
= static_cast<char*>(malloc(bufferSize
));
725 const char *mangled
= thrown_exception
->exceptionType
->name();
727 demangled
= __cxa_demangle(mangled
, demangled
, &bufferSize
, &status
);
728 fprintf(stderr
, " of type %s\n",
729 status
== 0 ? demangled
: mangled
);
730 if (status
== 0) { free(demangled
); }
731 // Print a back trace if no handler is found.
732 // TODO: Make this optional
733 _Unwind_Backtrace(trace
, 0);
735 // Just abort. No need to call std::terminate for the second time
742 static void throw_exception(__cxa_exception
*ex
)
744 __cxa_thread_info
*info
= thread_info();
745 ex
->unexpectedHandler
= info
->unexpectedHandler
;
746 if (0 == ex
->unexpectedHandler
)
748 ex
->unexpectedHandler
= unexpectedHandler
;
750 ex
->terminateHandler
= info
->terminateHandler
;
751 if (0 == ex
->terminateHandler
)
753 ex
->terminateHandler
= terminateHandler
;
755 info
->globals
.uncaughtExceptions
++;
757 _Unwind_Reason_Code err
= _Unwind_RaiseException(&ex
->unwindHeader
);
758 // The _Unwind_RaiseException() function should not return, it should
759 // unwind the stack past this function. If it does return, then something
761 report_failure(err
, ex
);
766 * ABI function for throwing an exception. Takes the object to be thrown (the
767 * pointer returned by __cxa_allocate_exception()), the type info for the
768 * pointee, and the destructor (if there is one) as arguments.
770 extern "C" void __cxa_throw(void *thrown_exception
,
771 std::type_info
*tinfo
,
774 __cxa_exception
*ex
= reinterpret_cast<__cxa_exception
*>(thrown_exception
) - 1;
776 ex
->referenceCount
= 1;
777 ex
->exceptionType
= tinfo
;
779 ex
->exceptionDestructor
= dest
;
781 ex
->unwindHeader
.exception_class
= exception_class
;
782 ex
->unwindHeader
.exception_cleanup
= exception_cleanup
;
787 extern "C" void __cxa_rethrow_primary_exception(void* thrown_exception
)
789 if (NULL
== thrown_exception
) { return; }
791 __cxa_exception
*original
= exceptionFromPointer(thrown_exception
);
792 __cxa_dependent_exception
*ex
= reinterpret_cast<__cxa_dependent_exception
*>(__cxa_allocate_dependent_exception())-1;
794 ex
->primaryException
= thrown_exception
;
795 __cxa_increment_exception_refcount(thrown_exception
);
797 ex
->exceptionType
= original
->exceptionType
;
798 ex
->unwindHeader
.exception_class
= dependent_exception_class
;
799 ex
->unwindHeader
.exception_cleanup
= dependent_exception_cleanup
;
801 throw_exception(reinterpret_cast<__cxa_exception
*>(ex
));
804 extern "C" void *__cxa_current_primary_exception(void)
806 __cxa_eh_globals
* globals
= __cxa_get_globals();
807 __cxa_exception
*ex
= globals
->caughtExceptions
;
809 if (0 == ex
) { return NULL
; }
810 ex
= realExceptionFromException(ex
);
811 __sync_fetch_and_add(&ex
->referenceCount
, 1);
815 extern "C" void __cxa_increment_exception_refcount(void* thrown_exception
)
817 if (NULL
== thrown_exception
) { return; }
818 __cxa_exception
*ex
= static_cast<__cxa_exception
*>(thrown_exception
) - 1;
819 if (isDependentException(ex
->unwindHeader
.exception_class
)) { return; }
820 __sync_fetch_and_add(&ex
->referenceCount
, 1);
822 extern "C" void __cxa_decrement_exception_refcount(void* thrown_exception
)
824 if (NULL
== thrown_exception
) { return; }
825 __cxa_exception
*ex
= static_cast<__cxa_exception
*>(thrown_exception
) - 1;
826 releaseException(ex
);
830 * ABI function. Rethrows the current exception. Does not remove the
831 * exception from the stack or decrement its handler count - the compiler is
832 * expected to set the landing pad for this function to the end of the catch
833 * block, and then call _Unwind_Resume() to continue unwinding once
834 * __cxa_end_catch() has been called and any cleanup code has been run.
836 extern "C" void __cxa_rethrow()
838 __cxa_thread_info
*ti
= thread_info();
839 __cxa_eh_globals
*globals
= &ti
->globals
;
840 // Note: We don't remove this from the caught list here, because
841 // __cxa_end_catch will be called when we unwind out of the try block. We
842 // could probably make this faster by providing an alternative rethrow
843 // function and ensuring that all cleanup code is run before calling it, so
844 // we can skip the top stack frame when unwinding.
845 __cxa_exception
*ex
= globals
->caughtExceptions
;
850 "Attempting to rethrow an exception that doesn't exist!\n");
854 if (ti
->foreign_exception_state
!= __cxa_thread_info::none
)
856 ti
->foreign_exception_state
= __cxa_thread_info::rethrown
;
857 _Unwind_Exception
*e
= reinterpret_cast<_Unwind_Exception
*>(ex
);
858 _Unwind_Reason_Code err
= _Unwind_Resume_or_Rethrow(e
);
859 report_failure(err
, ex
);
863 assert(ex
->handlerCount
> 0 && "Rethrowing uncaught exception!");
865 // ex->handlerCount will be decremented in __cxa_end_catch in enclosing
868 // Make handler count negative. This will tell __cxa_end_catch that
869 // exception was rethrown and exception object should not be destroyed
870 // when handler count become zero
871 ex
->handlerCount
= -ex
->handlerCount
;
873 // Continue unwinding the stack with this exception. This should unwind to
874 // the place in the caller where __cxa_end_catch() is called. The caller
875 // will then run cleanup code and bounce the exception back with
877 _Unwind_Reason_Code err
= _Unwind_Resume_or_Rethrow(&ex
->unwindHeader
);
878 report_failure(err
, ex
);
882 * Returns the type_info object corresponding to the filter.
884 static std::type_info
*get_type_info_entry(_Unwind_Context
*context
,
888 // Get the address of the record in the table.
889 dw_eh_ptr_t record
= lsda
->type_table
-
890 dwarf_size_of_fixed_size_field(lsda
->type_table_encoding
)*filter
;
892 dw_eh_ptr_t start
= record
;
893 // Read the value, but it's probably an indirect reference...
894 int64_t offset
= read_value(lsda
->type_table_encoding
, &record
);
896 // (If the entry is 0, don't try to dereference it. That would be bad.)
897 if (offset
== 0) { return 0; }
899 // ...so we need to resolve it
900 return reinterpret_cast<std::type_info
*>(resolve_indirect_value(context
,
901 lsda
->type_table_encoding
, offset
, start
));
907 * Checks the type signature found in a handler against the type of the thrown
908 * object. If ex is 0 then it is assumed to be a foreign exception and only
911 static bool check_type_signature(__cxa_exception
*ex
,
912 const std::type_info
*type
,
915 void *exception_ptr
= static_cast<void*>(ex
+1);
916 const std::type_info
*ex_type
= ex
? ex
->exceptionType
: 0;
918 bool is_ptr
= ex
? ex_type
->__is_pointer_p() : false;
921 exception_ptr
= *static_cast<void**>(exception_ptr
);
923 // Always match a catchall, even with a foreign exception
925 // Note: A 0 here is a catchall, not a cleanup, so we return true to
926 // indicate that we found a catch.
931 adjustedPtr
= exception_ptr
;
936 if (0 == ex
) { return false; }
938 // If the types are the same, no casting is needed.
939 if (*type
== *ex_type
)
941 adjustedPtr
= exception_ptr
;
946 if (type
->__do_catch(ex_type
, &exception_ptr
, 1))
948 adjustedPtr
= exception_ptr
;
955 * Checks whether the exception matches the type specifiers in this action
956 * record. If the exception only matches cleanups, then this returns false.
957 * If it matches a catch (including a catchall) then it returns true.
959 * The selector argument is used to return the selector that is passed in the
960 * second exception register when installing the context.
962 static handler_type
check_action_record(_Unwind_Context
*context
,
964 dw_eh_ptr_t action_record
,
966 unsigned long *selector
,
969 if (!action_record
) { return handler_cleanup
; }
970 handler_type found
= handler_none
;
971 while (action_record
)
973 int filter
= read_sleb128(&action_record
);
974 dw_eh_ptr_t action_record_offset_base
= action_record
;
975 int displacement
= read_sleb128(&action_record
);
976 action_record
= displacement
?
977 action_record_offset_base
+ displacement
: 0;
978 // We only check handler types for C++ exceptions - foreign exceptions
979 // are only allowed for cleanups and catchalls.
982 std::type_info
*handler_type
= get_type_info_entry(context
, lsda
, filter
);
983 if (check_type_signature(ex
, handler_type
, adjustedPtr
))
986 return handler_catch
;
989 else if (filter
< 0 && 0 != ex
)
991 bool matched
= false;
993 #if defined(__arm__) && !defined(__ARM_DWARF_EH__)
995 std::type_info
*handler_type
= get_type_info_entry(context
, lsda
, filter
--);
998 if (check_type_signature(ex
, handler_type
, adjustedPtr
))
1003 handler_type
= get_type_info_entry(context
, lsda
, filter
--);
1006 unsigned char *type_index
= reinterpret_cast<unsigned char*>(lsda
->type_table
) - filter
- 1;
1009 std::type_info
*handler_type
= get_type_info_entry(context
, lsda
, *(type_index
++));
1010 // If the exception spec matches a permitted throw type for
1011 // this function, don't report a handler - we are allowed to
1012 // propagate this exception out.
1013 if (check_type_signature(ex
, handler_type
, adjustedPtr
))
1020 if (matched
) { continue; }
1021 // If we don't find an allowed exception spec, we need to install
1022 // the context for this action. The landing pad will then call the
1023 // unexpected exception function. Treat this as a catch
1024 return handler_catch
;
1026 else if (filter
== 0)
1029 found
= handler_cleanup
;
1035 static void pushCleanupException(_Unwind_Exception
*exceptionObject
,
1036 __cxa_exception
*ex
)
1038 #if defined(__arm__) && !defined(__ARM_DWARF_EH__)
1039 __cxa_thread_info
*info
= thread_info_fast();
1043 if (ex
->cleanupCount
> 1)
1045 assert(exceptionObject
== info
->currentCleanup
);
1048 ex
->nextCleanup
= info
->currentCleanup
;
1050 info
->currentCleanup
= exceptionObject
;
1055 * The exception personality function. This is referenced in the unwinding
1056 * DWARF metadata and is called by the unwind library for each C++ stack frame
1057 * containing catch or cleanup code.
1060 BEGIN_PERSONALITY_FUNCTION(__gxx_personality_v0
)
1061 // This personality function is for version 1 of the ABI. If you use it
1062 // with a future version of the ABI, it won't know what to do, so it
1063 // reports a fatal error and give up before it breaks anything.
1066 return _URC_FATAL_PHASE1_ERROR
;
1068 __cxa_exception
*ex
= 0;
1069 __cxa_exception
*realEx
= 0;
1071 // If this exception is throw by something else then we can't make any
1072 // assumptions about its layout beyond the fields declared in
1073 // _Unwind_Exception.
1074 bool foreignException
= !isCXXException(exceptionClass
);
1076 // If this isn't a foreign exception, then we have a C++ exception structure
1077 if (!foreignException
)
1079 ex
= exceptionFromPointer(exceptionObject
);
1080 realEx
= realExceptionFromException(ex
);
1083 #if defined(__arm__) && !defined(__ARM_DWARF_EH__)
1084 unsigned char *lsda_addr
=
1085 static_cast<unsigned char*>(_Unwind_GetLanguageSpecificData(context
));
1087 unsigned char *lsda_addr
=
1088 reinterpret_cast<unsigned char*>(static_cast<uintptr_t>(_Unwind_GetLanguageSpecificData(context
)));
1091 // No LSDA implies no landing pads - try the next frame
1092 if (0 == lsda_addr
) { return continueUnwinding(exceptionObject
, context
); }
1094 // These two variables define how the exception will be handled.
1095 dwarf_eh_action action
= {0};
1096 unsigned long selector
= 0;
1098 // During the search phase, we do a complete lookup. If we return
1099 // _URC_HANDLER_FOUND, then the phase 2 unwind will call this function with
1100 // a _UA_HANDLER_FRAME action, telling us to install the handler frame. If
1101 // we return _URC_CONTINUE_UNWIND, we may be called again later with a
1102 // _UA_CLEANUP_PHASE action for this frame.
1104 // The point of the two-stage unwind allows us to entirely avoid any stack
1105 // unwinding if there is no handler. If there are just cleanups found,
1106 // then we can just panic call an abort function.
1108 // Matching a handler is much more expensive than matching a cleanup,
1109 // because we don't need to bother doing type comparisons (or looking at
1110 // the type table at all) for a cleanup. This means that there is no need
1111 // to cache the result of finding a cleanup, because it's (quite) quick to
1112 // look it up again from the action table.
1113 if (actions
& _UA_SEARCH_PHASE
)
1115 struct dwarf_eh_lsda lsda
= parse_lsda(context
, lsda_addr
);
1117 if (!dwarf_eh_find_callsite(context
, &lsda
, &action
))
1119 // EH range not found. This happens if exception is thrown and not
1120 // caught inside a cleanup (destructor). We should call
1121 // terminate() in this case. The catchTemp (landing pad) field of
1122 // exception object will contain null when personality function is
1123 // called with _UA_HANDLER_FRAME action for phase 2 unwinding.
1124 return _URC_HANDLER_FOUND
;
1127 handler_type found_handler
= check_action_record(context
, &lsda
,
1128 action
.action_record
, realEx
, &selector
, ex
->adjustedPtr
);
1129 // If there's no action record, we've only found a cleanup, so keep
1130 // searching for something real
1131 if (found_handler
== handler_catch
)
1133 // Cache the results for the phase 2 unwind, if we found a handler
1134 // and this is not a foreign exception.
1137 saveLandingPad(context
, exceptionObject
, ex
, selector
, action
.landing_pad
);
1138 ex
->languageSpecificData
= reinterpret_cast<const char*>(lsda_addr
);
1139 ex
->actionRecord
= reinterpret_cast<const char*>(action
.action_record
);
1140 // ex->adjustedPtr is set when finding the action record.
1142 return _URC_HANDLER_FOUND
;
1144 return continueUnwinding(exceptionObject
, context
);
1148 // If this is a foreign exception, we didn't have anywhere to cache the
1149 // lookup stuff, so we need to do it again. If this is either a forced
1150 // unwind, a foreign exception, or a cleanup, then we just install the
1151 // context for a cleanup.
1152 if (!(actions
& _UA_HANDLER_FRAME
))
1155 struct dwarf_eh_lsda lsda
= parse_lsda(context
, lsda_addr
);
1156 dwarf_eh_find_callsite(context
, &lsda
, &action
);
1157 if (0 == action
.landing_pad
) { return continueUnwinding(exceptionObject
, context
); }
1158 handler_type found_handler
= check_action_record(context
, &lsda
,
1159 action
.action_record
, realEx
, &selector
, ex
->adjustedPtr
);
1160 // Ignore handlers this time.
1161 if (found_handler
!= handler_cleanup
) { return continueUnwinding(exceptionObject
, context
); }
1162 pushCleanupException(exceptionObject
, ex
);
1164 else if (foreignException
)
1166 struct dwarf_eh_lsda lsda
= parse_lsda(context
, lsda_addr
);
1167 dwarf_eh_find_callsite(context
, &lsda
, &action
);
1168 check_action_record(context
, &lsda
, action
.action_record
, realEx
,
1169 &selector
, ex
->adjustedPtr
);
1171 else if (ex
->catchTemp
== 0)
1173 // Uncaught exception in cleanup, calling terminate
1178 // Restore the saved info if we saved some last time.
1179 loadLandingPad(context
, exceptionObject
, ex
, &selector
, &action
.landing_pad
);
1181 ex
->handlerSwitchValue
= 0;
1185 _Unwind_SetIP(context
, reinterpret_cast<unsigned long>(action
.landing_pad
));
1186 _Unwind_SetGR(context
, __builtin_eh_return_data_regno(0),
1187 reinterpret_cast<unsigned long>(exceptionObject
));
1188 _Unwind_SetGR(context
, __builtin_eh_return_data_regno(1), selector
);
1190 return _URC_INSTALL_CONTEXT
;
1194 * ABI function called when entering a catch statement. The argument is the
1195 * pointer passed out of the personality function. This is always the start of
1196 * the _Unwind_Exception object. The return value for this function is the
1197 * pointer to the caught exception, which is either the adjusted pointer (for
1198 * C++ exceptions) of the unadjusted pointer (for foreign exceptions).
1200 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
1201 extern "C" void *__cxa_begin_catch(void *e
) throw()
1203 extern "C" void *__cxa_begin_catch(void *e
)
1206 // We can't call the fast version here, because if the first exception that
1207 // we see is a foreign exception then we won't have called it yet.
1208 __cxa_thread_info
*ti
= thread_info();
1209 __cxa_eh_globals
*globals
= &ti
->globals
;
1210 globals
->uncaughtExceptions
--;
1211 _Unwind_Exception
*exceptionObject
= static_cast<_Unwind_Exception
*>(e
);
1213 if (isCXXException(exceptionObject
->exception_class
))
1215 __cxa_exception
*ex
= exceptionFromPointer(exceptionObject
);
1217 if (ex
->handlerCount
== 0)
1219 // Add this to the front of the list of exceptions being handled
1220 // and increment its handler count so that it won't be deleted
1222 ex
->nextException
= globals
->caughtExceptions
;
1223 globals
->caughtExceptions
= ex
;
1226 if (ex
->handlerCount
< 0)
1228 // Rethrown exception is catched before end of catch block.
1229 // Clear the rethrow flag (make value positive) - we are allowed
1230 // to delete this exception at the end of the catch block, as long
1231 // as it isn't thrown again later.
1243 // __cxa_begin_catch() <- we are here
1246 ex
->handlerCount
= -ex
->handlerCount
+ 1;
1252 ti
->foreign_exception_state
= __cxa_thread_info::none
;
1254 return ex
->adjustedPtr
;
1258 // If this is a foreign exception, then we need to be able to
1259 // store it. We can't chain foreign exceptions, so we give up
1260 // if there are already some outstanding ones.
1261 if (globals
->caughtExceptions
!= 0)
1265 globals
->caughtExceptions
= reinterpret_cast<__cxa_exception
*>(exceptionObject
);
1266 ti
->foreign_exception_state
= __cxa_thread_info::caught
;
1268 // exceptionObject is the pointer to the _Unwind_Exception within the
1269 // __cxa_exception. The throw object is after this
1270 return (reinterpret_cast<char*>(exceptionObject
) + sizeof(_Unwind_Exception
));
1276 * ABI function called when exiting a catch block. This will free the current
1277 * exception if it is no longer referenced in other catch blocks.
1279 extern "C" void __cxa_end_catch()
1281 // We can call the fast version here because the slow version is called in
1282 // __cxa_throw(), which must have been called before we end a catch block
1283 __cxa_thread_info
*ti
= thread_info_fast();
1284 __cxa_eh_globals
*globals
= &ti
->globals
;
1285 __cxa_exception
*ex
= globals
->caughtExceptions
;
1287 assert(0 != ex
&& "Ending catch when no exception is on the stack!");
1289 if (ti
->foreign_exception_state
!= __cxa_thread_info::none
)
1291 globals
->caughtExceptions
= 0;
1292 if (ti
->foreign_exception_state
!= __cxa_thread_info::rethrown
)
1294 _Unwind_Exception
*e
= reinterpret_cast<_Unwind_Exception
*>(ti
->globals
.caughtExceptions
);
1295 e
->exception_cleanup(_URC_FOREIGN_EXCEPTION_CAUGHT
, e
);
1297 ti
->foreign_exception_state
= __cxa_thread_info::none
;
1301 bool deleteException
= true;
1303 if (ex
->handlerCount
< 0)
1305 // exception was rethrown. Exception should not be deleted even if
1306 // handlerCount become zero.
1316 // __cxa_end_catch(); <- we are here
1322 deleteException
= false;
1329 if (ex
->handlerCount
== 0)
1331 globals
->caughtExceptions
= ex
->nextException
;
1332 if (deleteException
)
1334 releaseException(ex
);
1340 * ABI function. Returns the type of the current exception.
1342 extern "C" std::type_info
*__cxa_current_exception_type()
1344 __cxa_eh_globals
*globals
= __cxa_get_globals();
1345 __cxa_exception
*ex
= globals
->caughtExceptions
;
1346 return ex
? ex
->exceptionType
: 0;
1350 * ABI function, called when an exception specification is violated.
1352 * This function does not return.
1354 extern "C" void __cxa_call_unexpected(void*exception
)
1356 _Unwind_Exception
*exceptionObject
= static_cast<_Unwind_Exception
*>(exception
);
1357 if (exceptionObject
->exception_class
== exception_class
)
1359 __cxa_exception
*ex
= exceptionFromPointer(exceptionObject
);
1360 if (ex
->unexpectedHandler
)
1362 ex
->unexpectedHandler();
1363 // Should not be reached.
1368 // Should not be reached.
1373 * ABI function, returns the adjusted pointer to the exception object.
1375 extern "C" void *__cxa_get_exception_ptr(void *exceptionObject
)
1377 return exceptionFromPointer(exceptionObject
)->adjustedPtr
;
1381 * As an extension, we provide the ability for the unexpected and terminate
1382 * handlers to be thread-local. We default to the standards-compliant
1383 * behaviour where they are global.
1385 static bool thread_local_handlers
= false;
1391 * Sets whether unexpected and terminate handlers should be thread-local.
1393 void set_use_thread_local_handlers(bool flag
) throw()
1395 thread_local_handlers
= flag
;
1398 * Sets a thread-local unexpected handler.
1400 unexpected_handler
set_unexpected(unexpected_handler f
) throw()
1402 static __cxa_thread_info
*info
= thread_info();
1403 unexpected_handler old
= info
->unexpectedHandler
;
1404 info
->unexpectedHandler
= f
;
1408 * Sets a thread-local terminate handler.
1410 terminate_handler
set_terminate(terminate_handler f
) throw()
1412 static __cxa_thread_info
*info
= thread_info();
1413 terminate_handler old
= info
->terminateHandler
;
1414 info
->terminateHandler
= f
;
1422 * Sets the function that will be called when an exception specification is
1425 unexpected_handler
set_unexpected(unexpected_handler f
) throw()
1427 if (thread_local_handlers
) { return pathscale::set_unexpected(f
); }
1429 return ATOMIC_SWAP(&unexpectedHandler
, f
);
1432 * Sets the function that is called to terminate the program.
1434 terminate_handler
set_terminate(terminate_handler f
) throw()
1436 if (thread_local_handlers
) { return pathscale::set_terminate(f
); }
1438 return ATOMIC_SWAP(&terminateHandler
, f
);
1441 * Terminates the program, calling a custom terminate implementation if
1446 static __cxa_thread_info
*info
= thread_info();
1447 if (0 != info
&& 0 != info
->terminateHandler
)
1449 info
->terminateHandler();
1450 // Should not be reached - a terminate handler is not expected to
1457 * Called when an unexpected exception is encountered (i.e. an exception
1458 * violates an exception specification). This calls abort() unless a
1459 * custom handler has been set..
1463 static __cxa_thread_info
*info
= thread_info();
1464 if (0 != info
&& 0 != info
->unexpectedHandler
)
1466 info
->unexpectedHandler();
1467 // Should not be reached - a terminate handler is not expected to
1471 unexpectedHandler();
1474 * Returns whether there are any exceptions currently being thrown that
1475 * have not been caught. This can occur inside a nested catch statement.
1477 bool uncaught_exception() throw()
1479 __cxa_thread_info
*info
= thread_info();
1480 return info
->globals
.uncaughtExceptions
!= 0;
1483 * Returns the current unexpected handler.
1485 unexpected_handler
get_unexpected() throw()
1487 __cxa_thread_info
*info
= thread_info();
1488 if (info
->unexpectedHandler
)
1490 return info
->unexpectedHandler
;
1492 return ATOMIC_LOAD(&unexpectedHandler
);
1495 * Returns the current terminate handler.
1497 terminate_handler
get_terminate() throw()
1499 __cxa_thread_info
*info
= thread_info();
1500 if (info
->terminateHandler
)
1502 return info
->terminateHandler
;
1504 return ATOMIC_LOAD(&terminateHandler
);
1507 #if defined(__arm__) && !defined(__ARM_DWARF_EH__)
1508 extern "C" _Unwind_Exception
*__cxa_get_cleanup(void)
1510 __cxa_thread_info
*info
= thread_info_fast();
1511 _Unwind_Exception
*exceptionObject
= info
->currentCleanup
;
1512 if (isCXXException(exceptionObject
->exception_class
))
1514 __cxa_exception
*ex
= exceptionFromPointer(exceptionObject
);
1516 if (ex
->cleanupCount
== 0)
1518 info
->currentCleanup
= ex
->nextCleanup
;
1519 ex
->nextCleanup
= 0;
1524 info
->currentCleanup
= 0;
1526 return exceptionObject
;
1530 ".pushsection .text.__cxa_end_cleanup \n"
1531 ".global __cxa_end_cleanup \n"
1532 ".type __cxa_end_cleanup, \"function\" \n"
1533 "__cxa_end_cleanup: \n"
1534 " push {r1, r2, r3, r4} \n"
1535 " bl __cxa_get_cleanup \n"
1536 " push {r1, r2, r3, r4} \n"
1537 " b _Unwind_Resume \n"