diff --git a/contrib/libcxxrt/cxxabi.h b/contrib/libcxxrt/cxxabi.h index e843599c66da..e021f85c905a 100644 --- a/contrib/libcxxrt/cxxabi.h +++ b/contrib/libcxxrt/cxxabi.h @@ -1,251 +1,259 @@ /* * Copyright 2012 David Chisnall. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __CXXABI_H_ #define __CXXABI_H_ #include #include #include "unwind.h" namespace std { class type_info; } /* * The cxxabi.h header provides a set of public definitions for types and * functions defined by the Itanium C++ ABI specification. For reference, see * the ABI specification here: * * http://sourcery.mentor.com/public/cxx-abi/abi.html * * All deviations from this specification, unless otherwise noted, are * accidental. */ #ifdef __cplusplus namespace __cxxabiv1 { extern "C" { #endif /** * Function type to call when an unexpected exception is encountered. */ typedef void (*unexpected_handler)(); /** * Function type to call when an unrecoverable condition is encountered. */ typedef void (*terminate_handler)(); /** * Structure used as a header on thrown exceptions. This is the same layout as * defined by the Itanium ABI spec, so should be interoperable with any other * implementation of this spec, such as GNU libsupc++. * * This structure is allocated when an exception is thrown. Unwinding happens * in two phases, the first looks for a handler and the second installs the * context. This structure stores a cache of the handler location between * phase 1 and phase 2. Unfortunately, cleanup information is not cached, so * must be looked up in both phases. This happens for two reasons. The first * is that we don't know how many frames containing cleanups there will be, and * we should avoid dynamic allocation during unwinding (the exception may be * reporting that we've run out of memory). The second is that finding * cleanups is much cheaper than finding handlers, because we don't have to * look at the type table at all. * * Note: Several fields of this structure have not-very-informative names. * These are taken from the ABI spec and have not been changed to make it * easier for people referring to to the spec while reading this code. */ struct __cxa_exception { #if __LP64__ /** * Now _Unwind_Exception is marked with __attribute__((aligned)), which * implies __cxa_exception is also aligned. Insert padding in the * beginning of the struct, rather than before unwindHeader. */ void *reserve; /** * Reference count. Used to support the C++11 exception_ptr class. This * is prepended to the structure in 64-bit mode and squeezed in to the * padding left before the 64-bit aligned _Unwind_Exception at the end in * 32-bit mode. * * Note that it is safe to extend this structure at the beginning, rather * than the end, because the public API for creating it returns the address * of the end (where the exception object can be stored). */ uintptr_t referenceCount; #endif /** Type info for the thrown object. */ std::type_info *exceptionType; /** Destructor for the object, if one exists. */ void (*exceptionDestructor) (void *); /** Handler called when an exception specification is violated. */ unexpected_handler unexpectedHandler; /** Hander called to terminate. */ terminate_handler terminateHandler; /** * Next exception in the list. If an exception is thrown inside a catch * block and caught in a nested catch, this points to the exception that * will be handled after the inner catch block completes. */ __cxa_exception *nextException; /** * The number of handlers that currently have references to this * exception. The top (non-sign) bit of this is used as a flag to indicate * that the exception is being rethrown, so should not be deleted when its * handler count reaches 0 (which it doesn't with the top bit set). */ int handlerCount; #if defined(__arm__) && !defined(__ARM_DWARF_EH__) /** * The ARM EH ABI requires the unwind library to keep track of exceptions * during cleanups. These support nesting, so we need to keep a list of * them. */ _Unwind_Exception *nextCleanup; /** * The number of cleanups that are currently being run on this exception. */ int cleanupCount; #endif /** * The selector value to be returned when installing the catch handler. * Used at the call site to determine which catch() block should execute. * This is found in phase 1 of unwinding then installed in phase 2. */ int handlerSwitchValue; /** * The action record for the catch. This is cached during phase 1 * unwinding. */ const char *actionRecord; /** * Pointer to the language-specific data area (LSDA) for the handler * frame. This is unused in this implementation, but set for ABI * compatibility in case we want to mix code in very weird ways. */ const char *languageSpecificData; /** The cached landing pad for the catch handler.*/ void *catchTemp; /** * The pointer that will be returned as the pointer to the object. When * throwing a class and catching a virtual superclass (for example), we * need to adjust the thrown pointer to make it all work correctly. */ void *adjustedPtr; #if !__LP64__ /** * Reference count. Used to support the C++11 exception_ptr class. This * is prepended to the structure in 64-bit mode and squeezed in to the * padding left before the 64-bit aligned _Unwind_Exception at the end in * 32-bit mode. * * Note that it is safe to extend this structure at the beginning, rather * than the end, because the public API for creating it returns the address * of the end (where the exception object can be stored) */ uintptr_t referenceCount; #endif /** The language-agnostic part of the exception header. */ _Unwind_Exception unwindHeader; }; /** * ABI-specified globals structure. Returned by the __cxa_get_globals() * function and its fast variant. This is a per-thread structure - every * thread will have one lazily allocated. * * This structure is defined by the ABI, so may be used outside of this * library. */ struct __cxa_eh_globals { /** * A linked list of exceptions that are currently caught. There may be * several of these in nested catch() blocks. */ __cxa_exception *caughtExceptions; /** * The number of uncaught exceptions. */ unsigned int uncaughtExceptions; }; /** * ABI function returning the __cxa_eh_globals structure. */ __cxa_eh_globals *__cxa_get_globals(void); /** * Version of __cxa_get_globals() assuming that __cxa_get_globals() has already * been called at least once by this thread. */ __cxa_eh_globals *__cxa_get_globals_fast(void); std::type_info * __cxa_current_exception_type(); + +void *__cxa_allocate_exception(size_t thrown_size); + +void __cxa_free_exception(void* thrown_exception); + +__cxa_exception *__cxa_init_primary_exception( + void *object, std::type_info* tinfo, void (*dest)(void *)); + /** * Throws an exception returned by __cxa_current_primary_exception(). This * exception may have been caught in another thread. */ void __cxa_rethrow_primary_exception(void* thrown_exception); /** * Returns the current exception in a form that can be stored in an * exception_ptr object and then rethrown by a call to * __cxa_rethrow_primary_exception(). */ void *__cxa_current_primary_exception(void); /** * Increments the reference count of an exception. Called when an * exception_ptr is copied. */ void __cxa_increment_exception_refcount(void* thrown_exception); /** * Decrements the reference count of an exception. Called when an * exception_ptr is deleted. */ void __cxa_decrement_exception_refcount(void* thrown_exception); /** * Demangles a C++ symbol or type name. The buffer, if non-NULL, must be * allocated with malloc() and must be *n bytes or more long. This function * may call realloc() on the value pointed to by buf, and will return the * length of the string via *n. * * The value pointed to by status is set to one of the following: * * 0: success * -1: memory allocation failure * -2: invalid mangled name * -3: invalid arguments */ char* __cxa_demangle(const char* mangled_name, char* buf, size_t* n, int* status); #ifdef __cplusplus } // extern "C" } // namespace namespace abi = __cxxabiv1; #endif /* __cplusplus */ #endif /* __CXXABI_H_ */ diff --git a/contrib/libcxxrt/exception.cc b/contrib/libcxxrt/exception.cc index 6c5196876b10..b1659c902f56 100644 --- a/contrib/libcxxrt/exception.cc +++ b/contrib/libcxxrt/exception.cc @@ -1,1588 +1,1616 @@ /* * Copyright 2010-2011 PathScale, Inc. All rights reserved. * Copyright 2021 David Chisnall. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include "typeinfo.h" #include "dwarf_eh.h" #include "atomic.h" #include "cxxabi.h" #pragma weak pthread_key_create #pragma weak pthread_setspecific #pragma weak pthread_getspecific #pragma weak pthread_once #ifdef LIBCXXRT_WEAK_LOCKS #pragma weak pthread_mutex_lock #define pthread_mutex_lock(mtx) do {\ if (pthread_mutex_lock) pthread_mutex_lock(mtx);\ } while(0) #pragma weak pthread_mutex_unlock #define pthread_mutex_unlock(mtx) do {\ if (pthread_mutex_unlock) pthread_mutex_unlock(mtx);\ } while(0) #pragma weak pthread_cond_signal #define pthread_cond_signal(cv) do {\ if (pthread_cond_signal) pthread_cond_signal(cv);\ } while(0) #pragma weak pthread_cond_wait #define pthread_cond_wait(cv, mtx) do {\ if (pthread_cond_wait) pthread_cond_wait(cv, mtx);\ } while(0) #endif using namespace ABI_NAMESPACE; /** * Saves the result of the landing pad that we have found. For ARM, this is * stored in the generic unwind structure, while on other platforms it is * stored in the C++ exception. */ static void saveLandingPad(struct _Unwind_Context *context, struct _Unwind_Exception *ucb, struct __cxa_exception *ex, int selector, dw_eh_ptr_t landingPad) { #if defined(__arm__) && !defined(__ARM_DWARF_EH__) // On ARM, we store the saved exception in the generic part of the structure ucb->barrier_cache.sp = _Unwind_GetGR(context, 13); ucb->barrier_cache.bitpattern[1] = static_cast(selector); ucb->barrier_cache.bitpattern[3] = reinterpret_cast(landingPad); #endif // Cache the results for the phase 2 unwind, if we found a handler // and this is not a foreign exception. if (ex) { ex->handlerSwitchValue = selector; ex->catchTemp = landingPad; } } /** * Loads the saved landing pad. Returns 1 on success, 0 on failure. */ static int loadLandingPad(struct _Unwind_Context *context, struct _Unwind_Exception *ucb, struct __cxa_exception *ex, unsigned long *selector, dw_eh_ptr_t *landingPad) { #if defined(__arm__) && !defined(__ARM_DWARF_EH__) *selector = ucb->barrier_cache.bitpattern[1]; *landingPad = reinterpret_cast(ucb->barrier_cache.bitpattern[3]); return 1; #else if (ex) { *selector = ex->handlerSwitchValue; *landingPad = reinterpret_cast(ex->catchTemp); return 0; } return 0; #endif } static inline _Unwind_Reason_Code continueUnwinding(struct _Unwind_Exception *ex, struct _Unwind_Context *context) { #if defined(__arm__) && !defined(__ARM_DWARF_EH__) if (__gnu_unwind_frame(ex, context) != _URC_OK) { return _URC_FAILURE; } #endif return _URC_CONTINUE_UNWIND; } extern "C" void __cxa_free_exception(void *thrown_exception); extern "C" void __cxa_free_dependent_exception(void *thrown_exception); extern "C" void* __dynamic_cast(const void *sub, const __class_type_info *src, const __class_type_info *dst, ptrdiff_t src2dst_offset); /** * The type of a handler that has been found. */ typedef enum { /** No handler. */ handler_none, /** * A cleanup - the exception will propagate through this frame, but code * must be run when this happens. */ handler_cleanup, /** * A catch statement. The exception will not propagate past this frame * (without an explicit rethrow). */ handler_catch } handler_type; /** * Per-thread info required by the runtime. We store a single structure * pointer in thread-local storage, because this tends to be a scarce resource * and it's impolite to steal all of it and not leave any for the rest of the * program. * * Instances of this structure are allocated lazily - at most one per thread - * and are destroyed on thread termination. */ struct __cxa_thread_info { /** The termination handler for this thread. */ terminate_handler terminateHandler; /** The unexpected exception handler for this thread. */ unexpected_handler unexpectedHandler; +#ifndef LIBCXXRT_NO_EMERGENCY_MALLOC /** * The number of emergency buffers held by this thread. This is 0 in * normal operation - the emergency buffers are only used when malloc() * fails to return memory for allocating an exception. Threads are not * permitted to hold more than 4 emergency buffers (as per recommendation * in ABI spec [3.3.1]). */ int emergencyBuffersHeld; +#endif /** * The exception currently running in a cleanup. */ _Unwind_Exception *currentCleanup; /** * Our state with respect to foreign exceptions. Usually none, set to * caught if we have just caught an exception and rethrown if we are * rethrowing it. */ enum { none, caught, rethrown } foreign_exception_state; /** * The public part of this structure, accessible from outside of this * module. */ __cxa_eh_globals globals; }; /** * Dependent exception. This */ struct __cxa_dependent_exception { #if __LP64__ void *reserve; void *primaryException; #endif std::type_info *exceptionType; void (*exceptionDestructor) (void *); unexpected_handler unexpectedHandler; terminate_handler terminateHandler; __cxa_exception *nextException; int handlerCount; #if defined(__arm__) && !defined(__ARM_DWARF_EH__) _Unwind_Exception *nextCleanup; int cleanupCount; #endif int handlerSwitchValue; const char *actionRecord; const char *languageSpecificData; void *catchTemp; void *adjustedPtr; #if !__LP64__ void *primaryException; #endif _Unwind_Exception unwindHeader; }; static_assert(sizeof(__cxa_exception) == sizeof(__cxa_dependent_exception), "__cxa_exception and __cxa_dependent_exception should have the same size"); static_assert(offsetof(__cxa_exception, referenceCount) == offsetof(__cxa_dependent_exception, primaryException), "referenceCount and primaryException should have the same offset"); static_assert(offsetof(__cxa_exception, unwindHeader) == offsetof(__cxa_dependent_exception, unwindHeader), "unwindHeader fields should have the same offset"); static_assert(offsetof(__cxa_dependent_exception, unwindHeader) == offsetof(__cxa_dependent_exception, adjustedPtr) + 8, "there should be no padding before unwindHeader"); namespace std { void unexpected(); class exception { public: virtual ~exception() throw(); virtual const char* what() const throw(); }; } /** * Class of exceptions to distinguish between this and other exception types. * * The first four characters are the vendor ID. Currently, we use GNUC, * because we aim for ABI-compatibility with the GNU implementation, and * various checks may test for equality of the class, which is incorrect. */ static const uint64_t exception_class = EXCEPTION_CLASS('G', 'N', 'U', 'C', 'C', '+', '+', '\0'); /** * Class used for dependent exceptions. */ static const uint64_t dependent_exception_class = EXCEPTION_CLASS('G', 'N', 'U', 'C', 'C', '+', '+', '\x01'); /** * The low four bytes of the exception class, indicating that we conform to the * Itanium C++ ABI. This is currently unused, but should be used in the future * if we change our exception class, to allow this library and libsupc++ to be * linked to the same executable and both to interoperate. */ static const uint32_t abi_exception_class = GENERIC_EXCEPTION_CLASS('C', '+', '+', '\0'); static bool isCXXException(uint64_t cls) { return (cls == exception_class) || (cls == dependent_exception_class); } static bool isDependentException(uint64_t cls) { return cls == dependent_exception_class; } static __cxa_exception *exceptionFromPointer(void *ex) { return reinterpret_cast<__cxa_exception*>(static_cast(ex) - offsetof(struct __cxa_exception, unwindHeader)); } static __cxa_exception *realExceptionFromException(__cxa_exception *ex) { if (!isDependentException(ex->unwindHeader.exception_class)) { return ex; } return reinterpret_cast<__cxa_exception*>((reinterpret_cast<__cxa_dependent_exception*>(ex))->primaryException)-1; } namespace std { // Forward declaration of standard library terminate() function used to // abort execution. void terminate(void); } using namespace ABI_NAMESPACE; /** The global termination handler. */ static atomic terminateHandler = abort; /** The global unexpected exception handler. */ static atomic unexpectedHandler = std::terminate; /** Key used for thread-local data. */ static pthread_key_t eh_key; /** * Cleanup function, allowing foreign exception handlers to correctly destroy * this exception if they catch it. */ static void exception_cleanup(_Unwind_Reason_Code reason, struct _Unwind_Exception *ex) { // Exception layout: // [__cxa_exception [_Unwind_Exception]] [exception object] // // __cxa_free_exception expects a pointer to the exception object __cxa_free_exception(static_cast(ex + 1)); } static void dependent_exception_cleanup(_Unwind_Reason_Code reason, struct _Unwind_Exception *ex) { __cxa_free_dependent_exception(static_cast(ex + 1)); } /** * Recursively walk a list of exceptions and delete them all in post-order. */ static void free_exception_list(__cxa_exception *ex) { if (0 != ex->nextException) { free_exception_list(ex->nextException); } // __cxa_free_exception() expects to be passed the thrown object, which // immediately follows the exception, not the exception itself __cxa_free_exception(ex+1); } /** * Cleanup function called when a thread exists to make certain that all of the * per-thread data is deleted. */ static void thread_cleanup(void* thread_info) { __cxa_thread_info *info = static_cast<__cxa_thread_info*>(thread_info); if (info->globals.caughtExceptions) { // If this is a foreign exception, ask it to clean itself up. if (info->foreign_exception_state != __cxa_thread_info::none) { _Unwind_Exception *e = reinterpret_cast<_Unwind_Exception*>(info->globals.caughtExceptions); if (e->exception_cleanup) e->exception_cleanup(_URC_FOREIGN_EXCEPTION_CAUGHT, e); } else { free_exception_list(info->globals.caughtExceptions); } } free(thread_info); } /** * Once control used to protect the key creation. */ static pthread_once_t once_control = PTHREAD_ONCE_INIT; /** * We may not be linked against a full pthread implementation. If we're not, * then we need to fake the thread-local storage by storing 'thread-local' * things in a global. */ static bool fakeTLS; /** * Thread-local storage for a single-threaded program. */ static __cxa_thread_info singleThreadInfo; /** * Initialise eh_key. */ static void init_key(void) { if ((0 == pthread_key_create) || (0 == pthread_setspecific) || (0 == pthread_getspecific)) { fakeTLS = true; return; } pthread_key_create(&eh_key, thread_cleanup); pthread_setspecific(eh_key, reinterpret_cast(0x42)); fakeTLS = (pthread_getspecific(eh_key) != reinterpret_cast(0x42)); pthread_setspecific(eh_key, 0); } /** * Returns the thread info structure, creating it if it is not already created. */ static __cxa_thread_info *thread_info() { if ((0 == pthread_once) || pthread_once(&once_control, init_key)) { fakeTLS = true; } if (fakeTLS) { return &singleThreadInfo; } __cxa_thread_info *info = static_cast<__cxa_thread_info*>(pthread_getspecific(eh_key)); if (0 == info) { info = static_cast<__cxa_thread_info*>(calloc(1, sizeof(__cxa_thread_info))); pthread_setspecific(eh_key, info); } return info; } /** * Fast version of thread_info(). May fail if thread_info() is not called on * this thread at least once already. */ static __cxa_thread_info *thread_info_fast() { if (fakeTLS) { return &singleThreadInfo; } return static_cast<__cxa_thread_info*>(pthread_getspecific(eh_key)); } /** * ABI function returning the __cxa_eh_globals structure. */ extern "C" __cxa_eh_globals *ABI_NAMESPACE::__cxa_get_globals(void) { return &(thread_info()->globals); } /** * Version of __cxa_get_globals() assuming that __cxa_get_globals() has already * been called at least once by this thread. */ extern "C" __cxa_eh_globals *ABI_NAMESPACE::__cxa_get_globals_fast(void) { return &(thread_info_fast()->globals); } +#ifdef LIBCXXRT_NO_EMERGENCY_MALLOC +static char *alloc_or_die(size_t size) +{ + char *buffer = static_cast(calloc(1, size)); + + if (buffer == nullptr) + { + fputs("Out of memory attempting to allocate exception\n", stderr); + std::terminate(); + } + return buffer; +} +static void free_exception(char *e) +{ + free(e); +} +#else /** * An emergency allocation reserved for when malloc fails. This is treated as * 16 buffers of 1KB each. */ static char emergency_buffer[16384]; /** * Flag indicating whether each buffer is allocated. */ static bool buffer_allocated[16]; /** * Lock used to protect emergency allocation. */ static pthread_mutex_t emergency_malloc_lock = PTHREAD_MUTEX_INITIALIZER; /** * Condition variable used to wait when two threads are both trying to use the * emergency malloc() buffer at once. */ static pthread_cond_t emergency_malloc_wait = PTHREAD_COND_INITIALIZER; /** * Allocates size bytes from the emergency allocation mechanism, if possible. * This function will fail if size is over 1KB or if this thread already has 4 * emergency buffers. If all emergency buffers are allocated, it will sleep * until one becomes available. */ static char *emergency_malloc(size_t size) { if (size > 1024) { return 0; } __cxa_thread_info *info = thread_info(); // Only 4 emergency buffers allowed per thread! if (info->emergencyBuffersHeld > 3) { return 0; } pthread_mutex_lock(&emergency_malloc_lock); int buffer = -1; while (buffer < 0) { // While we were sleeping on the lock, another thread might have free'd // enough memory for us to use, so try the allocation again - no point // using the emergency buffer if there is some real memory that we can // use... void *m = calloc(1, size); if (0 != m) { pthread_mutex_unlock(&emergency_malloc_lock); return static_cast(m); } for (int i=0 ; i<16 ; i++) { if (!buffer_allocated[i]) { buffer = i; buffer_allocated[i] = true; break; } } // If there still isn't a buffer available, then sleep on the condition // variable. This will be signalled when another thread releases one // of the emergency buffers. if (buffer < 0) { pthread_cond_wait(&emergency_malloc_wait, &emergency_malloc_lock); } } pthread_mutex_unlock(&emergency_malloc_lock); info->emergencyBuffersHeld++; return emergency_buffer + (1024 * buffer); } /** * Frees a buffer returned by emergency_malloc(). * * Note: Neither this nor emergency_malloc() is particularly efficient. This * should not matter, because neither will be called in normal operation - they * are only used when the program runs out of memory, which should not happen * often. */ static void emergency_malloc_free(char *ptr) { int buffer = -1; // Find the buffer corresponding to this pointer. for (int i=0 ; i<16 ; i++) { if (ptr == static_cast(emergency_buffer + (1024 * i))) { buffer = i; break; } } assert(buffer >= 0 && "Trying to free something that is not an emergency buffer!"); // emergency_malloc() is expected to return 0-initialized data. We don't // zero the buffer when allocating it, because the static buffers will // begin life containing 0 values. memset(ptr, 0, 1024); // Signal the condition variable to wake up any threads that are blocking // waiting for some space in the emergency buffer pthread_mutex_lock(&emergency_malloc_lock); // In theory, we don't need to do this with the lock held. In practice, // our array of bools will probably be updated using 32-bit or 64-bit // memory operations, so this update may clobber adjacent values. buffer_allocated[buffer] = false; pthread_cond_signal(&emergency_malloc_wait); pthread_mutex_unlock(&emergency_malloc_lock); } static char *alloc_or_die(size_t size) { char *buffer = static_cast(calloc(1, size)); // If calloc() doesn't want to give us any memory, try using an emergency // buffer. if (0 == buffer) { buffer = emergency_malloc(size); // This is only reached if the allocation is greater than 1KB, and // anyone throwing objects that big really should know better. if (0 == buffer) { fprintf(stderr, "Out of memory attempting to allocate exception\n"); std::terminate(); } } return buffer; } static void free_exception(char *e) { // If this allocation is within the address range of the emergency buffer, // don't call free() because it was not allocated with malloc() if ((e >= emergency_buffer) && (e < (emergency_buffer + sizeof(emergency_buffer)))) { emergency_malloc_free(e); } else { free(e); } } +#endif /** * Allocates an exception structure. Returns a pointer to the space that can * be used to store an object of thrown_size bytes. This function will use an * emergency buffer if malloc() fails, and may block if there are no such * buffers available. */ extern "C" void *__cxa_allocate_exception(size_t thrown_size) { size_t size = thrown_size + sizeof(__cxa_exception); char *buffer = alloc_or_die(size); return buffer+sizeof(__cxa_exception); } extern "C" void *__cxa_allocate_dependent_exception(void) { size_t size = sizeof(__cxa_dependent_exception); char *buffer = alloc_or_die(size); return buffer+sizeof(__cxa_dependent_exception); } /** * __cxa_free_exception() is called when an exception was thrown in between * calling __cxa_allocate_exception() and actually throwing the exception. * This happens when the object's copy constructor throws an exception. * * In this implementation, it is also called by __cxa_end_catch() and during * thread cleanup. */ extern "C" void __cxa_free_exception(void *thrown_exception) { __cxa_exception *ex = reinterpret_cast<__cxa_exception*>(thrown_exception) - 1; // Free the object that was thrown, calling its destructor if (0 != ex->exceptionDestructor) { try { ex->exceptionDestructor(thrown_exception); } catch(...) { // FIXME: Check that this is really what the spec says to do. std::terminate(); } } free_exception(reinterpret_cast(ex)); } static void releaseException(__cxa_exception *exception) { if (isDependentException(exception->unwindHeader.exception_class)) { __cxa_free_dependent_exception(exception+1); return; } if (__sync_sub_and_fetch(&exception->referenceCount, 1) == 0) { // __cxa_free_exception() expects to be passed the thrown object, // which immediately follows the exception, not the exception // itself __cxa_free_exception(exception+1); } } void __cxa_free_dependent_exception(void *thrown_exception) { __cxa_dependent_exception *ex = reinterpret_cast<__cxa_dependent_exception*>(thrown_exception) - 1; assert(isDependentException(ex->unwindHeader.exception_class)); if (ex->primaryException) { releaseException(realExceptionFromException(reinterpret_cast<__cxa_exception*>(ex))); } free_exception(reinterpret_cast(ex)); } /** * Callback function used with _Unwind_Backtrace(). * * Prints a stack trace. Used only for debugging help. * * Note: As of FreeBSD 8.1, dladd() still doesn't work properly, so this only * correctly prints function names from public, relocatable, symbols. */ static _Unwind_Reason_Code trace(struct _Unwind_Context *context, void *c) { Dl_info myinfo; int mylookup = dladdr(reinterpret_cast(__cxa_current_exception_type), &myinfo); void *ip = reinterpret_cast(_Unwind_GetIP(context)); Dl_info info; if (dladdr(ip, &info) != 0) { if (mylookup == 0 || strcmp(info.dli_fname, myinfo.dli_fname) != 0) { printf("%p:%s() in %s\n", ip, info.dli_sname, info.dli_fname); } } return _URC_CONTINUE_UNWIND; } /** * Report a failure that occurred when attempting to throw an exception. * * If the failure happened by falling off the end of the stack without finding * a handler, prints a back trace before aborting. */ #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) extern "C" void *__cxa_begin_catch(void *e) throw(); #else extern "C" void *__cxa_begin_catch(void *e); #endif static void report_failure(_Unwind_Reason_Code err, __cxa_exception *thrown_exception) { switch (err) { default: break; case _URC_FATAL_PHASE1_ERROR: fprintf(stderr, "Fatal error during phase 1 unwinding\n"); break; #if !defined(__arm__) || defined(__ARM_DWARF_EH__) case _URC_FATAL_PHASE2_ERROR: fprintf(stderr, "Fatal error during phase 2 unwinding\n"); break; #endif case _URC_END_OF_STACK: __cxa_begin_catch (&(thrown_exception->unwindHeader)); std::terminate(); fprintf(stderr, "Terminating due to uncaught exception %p", static_cast(thrown_exception)); thrown_exception = realExceptionFromException(thrown_exception); static const __class_type_info *e_ti = static_cast(&typeid(std::exception)); const __class_type_info *throw_ti = dynamic_cast(thrown_exception->exceptionType); if (throw_ti) { std::exception *e = static_cast(e_ti->cast_to(static_cast(thrown_exception+1), throw_ti)); if (e) { fprintf(stderr, " '%s'", e->what()); } } size_t bufferSize = 128; char *demangled = static_cast(malloc(bufferSize)); const char *mangled = thrown_exception->exceptionType->name(); int status; demangled = __cxa_demangle(mangled, demangled, &bufferSize, &status); fprintf(stderr, " of type %s\n", status == 0 ? demangled : mangled); if (status == 0) { free(demangled); } // Print a back trace if no handler is found. // TODO: Make this optional #ifndef __arm__ _Unwind_Backtrace(trace, 0); #endif // Just abort. No need to call std::terminate for the second time abort(); break; } std::terminate(); } static void throw_exception(__cxa_exception *ex) { __cxa_thread_info *info = thread_info(); ex->unexpectedHandler = info->unexpectedHandler; if (0 == ex->unexpectedHandler) { ex->unexpectedHandler = unexpectedHandler.load(); } ex->terminateHandler = info->terminateHandler; if (0 == ex->terminateHandler) { ex->terminateHandler = terminateHandler.load(); } info->globals.uncaughtExceptions++; _Unwind_Reason_Code err = _Unwind_RaiseException(&ex->unwindHeader); // The _Unwind_RaiseException() function should not return, it should // unwind the stack past this function. If it does return, then something // has gone wrong. report_failure(err, ex); } +extern "C" __cxa_exception *__cxa_init_primary_exception( + void *object, std::type_info* tinfo, void (*dest)(void *)) { + __cxa_exception *ex = reinterpret_cast<__cxa_exception*>(object) - 1; + + ex->referenceCount = 0; + ex->exceptionType = tinfo; + + ex->exceptionDestructor = dest; + + ex->unwindHeader.exception_class = exception_class; + ex->unwindHeader.exception_cleanup = exception_cleanup; + + return ex; +} + /** * ABI function for throwing an exception. Takes the object to be thrown (the * pointer returned by __cxa_allocate_exception()), the type info for the * pointee, and the destructor (if there is one) as arguments. */ extern "C" void __cxa_throw(void *thrown_exception, std::type_info *tinfo, void(*dest)(void*)) { - __cxa_exception *ex = reinterpret_cast<__cxa_exception*>(thrown_exception) - 1; - + __cxa_exception *ex = __cxa_init_primary_exception(thrown_exception, tinfo, dest); ex->referenceCount = 1; - ex->exceptionType = tinfo; - - ex->exceptionDestructor = dest; - - ex->unwindHeader.exception_class = exception_class; - ex->unwindHeader.exception_cleanup = exception_cleanup; throw_exception(ex); } extern "C" void __cxa_rethrow_primary_exception(void* thrown_exception) { if (NULL == thrown_exception) { return; } __cxa_exception *original = exceptionFromPointer(thrown_exception); __cxa_dependent_exception *ex = reinterpret_cast<__cxa_dependent_exception*>(__cxa_allocate_dependent_exception())-1; ex->primaryException = thrown_exception; __cxa_increment_exception_refcount(thrown_exception); ex->exceptionType = original->exceptionType; ex->unwindHeader.exception_class = dependent_exception_class; ex->unwindHeader.exception_cleanup = dependent_exception_cleanup; throw_exception(reinterpret_cast<__cxa_exception*>(ex)); } extern "C" void *__cxa_current_primary_exception(void) { __cxa_eh_globals* globals = __cxa_get_globals(); __cxa_exception *ex = globals->caughtExceptions; if (0 == ex) { return NULL; } ex = realExceptionFromException(ex); __sync_fetch_and_add(&ex->referenceCount, 1); return ex + 1; } extern "C" void __cxa_increment_exception_refcount(void* thrown_exception) { if (NULL == thrown_exception) { return; } __cxa_exception *ex = static_cast<__cxa_exception*>(thrown_exception) - 1; if (isDependentException(ex->unwindHeader.exception_class)) { return; } __sync_fetch_and_add(&ex->referenceCount, 1); } extern "C" void __cxa_decrement_exception_refcount(void* thrown_exception) { if (NULL == thrown_exception) { return; } __cxa_exception *ex = static_cast<__cxa_exception*>(thrown_exception) - 1; releaseException(ex); } /** * ABI function. Rethrows the current exception. Does not remove the * exception from the stack or decrement its handler count - the compiler is * expected to set the landing pad for this function to the end of the catch * block, and then call _Unwind_Resume() to continue unwinding once * __cxa_end_catch() has been called and any cleanup code has been run. */ extern "C" void __cxa_rethrow() { __cxa_thread_info *ti = thread_info(); __cxa_eh_globals *globals = &ti->globals; // Note: We don't remove this from the caught list here, because // __cxa_end_catch will be called when we unwind out of the try block. We // could probably make this faster by providing an alternative rethrow // function and ensuring that all cleanup code is run before calling it, so // we can skip the top stack frame when unwinding. __cxa_exception *ex = globals->caughtExceptions; if (0 == ex) { fprintf(stderr, "Attempting to rethrow an exception that doesn't exist!\n"); std::terminate(); } if (ti->foreign_exception_state != __cxa_thread_info::none) { ti->foreign_exception_state = __cxa_thread_info::rethrown; _Unwind_Exception *e = reinterpret_cast<_Unwind_Exception*>(ex); _Unwind_Reason_Code err = _Unwind_Resume_or_Rethrow(e); report_failure(err, ex); return; } assert(ex->handlerCount > 0 && "Rethrowing uncaught exception!"); // `globals->uncaughtExceptions` was decremented by `__cxa_begin_catch`. // It's normally incremented by `throw_exception`, but this path invokes // `_Unwind_Resume_or_Rethrow` directly to rethrow the exception. // This path is only reachable if we're rethrowing a C++ exception - // foreign exceptions don't adjust any of this state. globals->uncaughtExceptions++; // ex->handlerCount will be decremented in __cxa_end_catch in enclosing // catch block // Make handler count negative. This will tell __cxa_end_catch that // exception was rethrown and exception object should not be destroyed // when handler count become zero ex->handlerCount = -ex->handlerCount; // Continue unwinding the stack with this exception. This should unwind to // the place in the caller where __cxa_end_catch() is called. The caller // will then run cleanup code and bounce the exception back with // _Unwind_Resume(). _Unwind_Reason_Code err = _Unwind_Resume_or_Rethrow(&ex->unwindHeader); report_failure(err, ex); } /** * Returns the type_info object corresponding to the filter. */ static std::type_info *get_type_info_entry(_Unwind_Context *context, dwarf_eh_lsda *lsda, int filter) { // Get the address of the record in the table. dw_eh_ptr_t record = lsda->type_table - dwarf_size_of_fixed_size_field(lsda->type_table_encoding)*filter; //record -= 4; dw_eh_ptr_t start = record; // Read the value, but it's probably an indirect reference... int64_t offset = read_value(lsda->type_table_encoding, &record); // (If the entry is 0, don't try to dereference it. That would be bad.) if (offset == 0) { return 0; } // ...so we need to resolve it return reinterpret_cast(resolve_indirect_value(context, lsda->type_table_encoding, offset, start)); } /** * Checks the type signature found in a handler against the type of the thrown * object. If ex is 0 then it is assumed to be a foreign exception and only * matches cleanups. */ static bool check_type_signature(__cxa_exception *ex, const std::type_info *type, void *&adjustedPtr) { void *exception_ptr = static_cast(ex+1); const std::type_info *ex_type = ex ? ex->exceptionType : 0; bool is_ptr = ex ? ex_type->__is_pointer_p() : false; if (is_ptr) { exception_ptr = *static_cast(exception_ptr); } // Always match a catchall, even with a foreign exception // // Note: A 0 here is a catchall, not a cleanup, so we return true to // indicate that we found a catch. if (0 == type) { if (ex) { adjustedPtr = exception_ptr; } return true; } if (0 == ex) { return false; } // If the types are the same, no casting is needed. if (*type == *ex_type) { adjustedPtr = exception_ptr; return true; } if (type->__do_catch(ex_type, &exception_ptr, 1)) { adjustedPtr = exception_ptr; return true; } return false; } /** * Checks whether the exception matches the type specifiers in this action * record. If the exception only matches cleanups, then this returns false. * If it matches a catch (including a catchall) then it returns true. * * The selector argument is used to return the selector that is passed in the * second exception register when installing the context. */ static handler_type check_action_record(_Unwind_Context *context, dwarf_eh_lsda *lsda, dw_eh_ptr_t action_record, __cxa_exception *ex, unsigned long *selector, void *&adjustedPtr) { if (!action_record) { return handler_cleanup; } handler_type found = handler_none; while (action_record) { int filter = read_sleb128(&action_record); dw_eh_ptr_t action_record_offset_base = action_record; int displacement = read_sleb128(&action_record); action_record = displacement ? action_record_offset_base + displacement : 0; // We only check handler types for C++ exceptions - foreign exceptions // are only allowed for cleanups and catchalls. if (filter > 0) { std::type_info *handler_type = get_type_info_entry(context, lsda, filter); if (check_type_signature(ex, handler_type, adjustedPtr)) { *selector = filter; return handler_catch; } } else if (filter < 0 && 0 != ex) { bool matched = false; *selector = filter; #if defined(__arm__) && !defined(__ARM_DWARF_EH__) filter++; std::type_info *handler_type = get_type_info_entry(context, lsda, filter--); while (handler_type) { if (check_type_signature(ex, handler_type, adjustedPtr)) { matched = true; break; } handler_type = get_type_info_entry(context, lsda, filter--); } #else unsigned char *type_index = reinterpret_cast(lsda->type_table) - filter - 1; while (*type_index) { std::type_info *handler_type = get_type_info_entry(context, lsda, *(type_index++)); // If the exception spec matches a permitted throw type for // this function, don't report a handler - we are allowed to // propagate this exception out. if (check_type_signature(ex, handler_type, adjustedPtr)) { matched = true; break; } } #endif if (matched) { continue; } // If we don't find an allowed exception spec, we need to install // the context for this action. The landing pad will then call the // unexpected exception function. Treat this as a catch return handler_catch; } else if (filter == 0) { *selector = filter; found = handler_cleanup; } } return found; } static void pushCleanupException(_Unwind_Exception *exceptionObject, __cxa_exception *ex) { #if defined(__arm__) && !defined(__ARM_DWARF_EH__) __cxa_thread_info *info = thread_info_fast(); if (ex) { ex->cleanupCount++; if (ex->cleanupCount > 1) { assert(exceptionObject == info->currentCleanup); return; } ex->nextCleanup = info->currentCleanup; } info->currentCleanup = exceptionObject; #endif } /** * The exception personality function. This is referenced in the unwinding * DWARF metadata and is called by the unwind library for each C++ stack frame * containing catch or cleanup code. */ extern "C" BEGIN_PERSONALITY_FUNCTION(__gxx_personality_v0) // This personality function is for version 1 of the ABI. If you use it // with a future version of the ABI, it won't know what to do, so it // reports a fatal error and give up before it breaks anything. if (1 != version) { return _URC_FATAL_PHASE1_ERROR; } __cxa_exception *ex = 0; __cxa_exception *realEx = 0; // If this exception is throw by something else then we can't make any // assumptions about its layout beyond the fields declared in // _Unwind_Exception. bool foreignException = !isCXXException(exceptionClass); // If this isn't a foreign exception, then we have a C++ exception structure if (!foreignException) { ex = exceptionFromPointer(exceptionObject); realEx = realExceptionFromException(ex); } #if defined(__arm__) && !defined(__ARM_DWARF_EH__) unsigned char *lsda_addr = static_cast(_Unwind_GetLanguageSpecificData(context)); #else unsigned char *lsda_addr = reinterpret_cast(static_cast(_Unwind_GetLanguageSpecificData(context))); #endif // No LSDA implies no landing pads - try the next frame if (0 == lsda_addr) { return continueUnwinding(exceptionObject, context); } // These two variables define how the exception will be handled. dwarf_eh_action action = {0}; unsigned long selector = 0; // During the search phase, we do a complete lookup. If we return // _URC_HANDLER_FOUND, then the phase 2 unwind will call this function with // a _UA_HANDLER_FRAME action, telling us to install the handler frame. If // we return _URC_CONTINUE_UNWIND, we may be called again later with a // _UA_CLEANUP_PHASE action for this frame. // // The point of the two-stage unwind allows us to entirely avoid any stack // unwinding if there is no handler. If there are just cleanups found, // then we can just panic call an abort function. // // Matching a handler is much more expensive than matching a cleanup, // because we don't need to bother doing type comparisons (or looking at // the type table at all) for a cleanup. This means that there is no need // to cache the result of finding a cleanup, because it's (quite) quick to // look it up again from the action table. if (actions & _UA_SEARCH_PHASE) { struct dwarf_eh_lsda lsda = parse_lsda(context, lsda_addr); if (!dwarf_eh_find_callsite(context, &lsda, &action)) { // EH range not found. This happens if exception is thrown and not // caught inside a cleanup (destructor). We should call // terminate() in this case. The catchTemp (landing pad) field of // exception object will contain null when personality function is // called with _UA_HANDLER_FRAME action for phase 2 unwinding. return _URC_HANDLER_FOUND; } handler_type found_handler = check_action_record(context, &lsda, action.action_record, realEx, &selector, ex->adjustedPtr); // If there's no action record, we've only found a cleanup, so keep // searching for something real if (found_handler == handler_catch) { // Cache the results for the phase 2 unwind, if we found a handler // and this is not a foreign exception. if (ex) { saveLandingPad(context, exceptionObject, ex, selector, action.landing_pad); ex->languageSpecificData = reinterpret_cast(lsda_addr); ex->actionRecord = reinterpret_cast(action.action_record); // ex->adjustedPtr is set when finding the action record. } return _URC_HANDLER_FOUND; } return continueUnwinding(exceptionObject, context); } // If this is a foreign exception, we didn't have anywhere to cache the // lookup stuff, so we need to do it again. If this is either a forced // unwind, a foreign exception, or a cleanup, then we just install the // context for a cleanup. if (!(actions & _UA_HANDLER_FRAME)) { // cleanup struct dwarf_eh_lsda lsda = parse_lsda(context, lsda_addr); dwarf_eh_find_callsite(context, &lsda, &action); if (0 == action.landing_pad) { return continueUnwinding(exceptionObject, context); } handler_type found_handler = check_action_record(context, &lsda, action.action_record, realEx, &selector, ex->adjustedPtr); // Ignore handlers this time. if (found_handler != handler_cleanup) { return continueUnwinding(exceptionObject, context); } pushCleanupException(exceptionObject, ex); } else if (foreignException) { struct dwarf_eh_lsda lsda = parse_lsda(context, lsda_addr); dwarf_eh_find_callsite(context, &lsda, &action); check_action_record(context, &lsda, action.action_record, realEx, &selector, ex->adjustedPtr); } else if (ex->catchTemp == 0) { // Uncaught exception in cleanup, calling terminate std::terminate(); } else { // Restore the saved info if we saved some last time. loadLandingPad(context, exceptionObject, ex, &selector, &action.landing_pad); ex->catchTemp = 0; ex->handlerSwitchValue = 0; } _Unwind_SetIP(context, reinterpret_cast(action.landing_pad)); _Unwind_SetGR(context, __builtin_eh_return_data_regno(0), reinterpret_cast(exceptionObject)); _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), selector); return _URC_INSTALL_CONTEXT; } /** * ABI function called when entering a catch statement. The argument is the * pointer passed out of the personality function. This is always the start of * the _Unwind_Exception object. The return value for this function is the * pointer to the caught exception, which is either the adjusted pointer (for * C++ exceptions) of the unadjusted pointer (for foreign exceptions). */ #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) extern "C" void *__cxa_begin_catch(void *e) throw() #else extern "C" void *__cxa_begin_catch(void *e) #endif { // We can't call the fast version here, because if the first exception that // we see is a foreign exception then we won't have called it yet. __cxa_thread_info *ti = thread_info(); __cxa_eh_globals *globals = &ti->globals; _Unwind_Exception *exceptionObject = static_cast<_Unwind_Exception*>(e); if (isCXXException(exceptionObject->exception_class)) { // Only exceptions thrown with a C++ exception throwing function will // increment this, so don't decrement it here. globals->uncaughtExceptions--; __cxa_exception *ex = exceptionFromPointer(exceptionObject); if (ex->handlerCount == 0) { // Add this to the front of the list of exceptions being handled // and increment its handler count so that it won't be deleted // prematurely. ex->nextException = globals->caughtExceptions; globals->caughtExceptions = ex; } if (ex->handlerCount < 0) { // Rethrown exception is catched before end of catch block. // Clear the rethrow flag (make value positive) - we are allowed // to delete this exception at the end of the catch block, as long // as it isn't thrown again later. // Code pattern: // // try { // throw x; // } // catch() { // try { // throw; // } // catch() { // __cxa_begin_catch() <- we are here // } // } ex->handlerCount = -ex->handlerCount + 1; } else { ex->handlerCount++; } ti->foreign_exception_state = __cxa_thread_info::none; return ex->adjustedPtr; } else { // If this is a foreign exception, then we need to be able to // store it. We can't chain foreign exceptions, so we give up // if there are already some outstanding ones. if (globals->caughtExceptions != 0) { std::terminate(); } globals->caughtExceptions = reinterpret_cast<__cxa_exception*>(exceptionObject); ti->foreign_exception_state = __cxa_thread_info::caught; } // exceptionObject is the pointer to the _Unwind_Exception within the // __cxa_exception. The throw object is after this return (reinterpret_cast(exceptionObject) + sizeof(_Unwind_Exception)); } /** * ABI function called when exiting a catch block. This will free the current * exception if it is no longer referenced in other catch blocks. */ extern "C" void __cxa_end_catch() { // We can call the fast version here because the slow version is called in // __cxa_throw(), which must have been called before we end a catch block __cxa_thread_info *ti = thread_info_fast(); __cxa_eh_globals *globals = &ti->globals; __cxa_exception *ex = globals->caughtExceptions; assert(0 != ex && "Ending catch when no exception is on the stack!"); if (ti->foreign_exception_state != __cxa_thread_info::none) { if (ti->foreign_exception_state != __cxa_thread_info::rethrown) { _Unwind_Exception *e = reinterpret_cast<_Unwind_Exception*>(ti->globals.caughtExceptions); if (e->exception_cleanup) e->exception_cleanup(_URC_FOREIGN_EXCEPTION_CAUGHT, e); } globals->caughtExceptions = 0; ti->foreign_exception_state = __cxa_thread_info::none; return; } bool deleteException = true; if (ex->handlerCount < 0) { // exception was rethrown. Exception should not be deleted even if // handlerCount become zero. // Code pattern: // try { // throw x; // } // catch() { // { // throw; // } // cleanup { // __cxa_end_catch(); <- we are here // } // } // ex->handlerCount++; deleteException = false; } else { ex->handlerCount--; } if (ex->handlerCount == 0) { globals->caughtExceptions = ex->nextException; if (deleteException) { releaseException(ex); } } } /** * ABI function. Returns the type of the current exception. */ extern "C" std::type_info *__cxa_current_exception_type() { __cxa_eh_globals *globals = __cxa_get_globals(); __cxa_exception *ex = globals->caughtExceptions; return ex ? ex->exceptionType : 0; } /** * Cleanup, ensures that `__cxa_end_catch` is called to balance an explicit * `__cxa_begin_catch` call. */ static void end_catch(char *) { __cxa_end_catch(); } /** * ABI function, called when an exception specification is violated. * * This function does not return. */ extern "C" void __cxa_call_unexpected(void*exception) { _Unwind_Exception *exceptionObject = static_cast<_Unwind_Exception*>(exception); // Wrap the call to the unexpected handler in calls to `__cxa_begin_catch` // and `__cxa_end_catch` so that we correctly update exception counts if // the unexpected handler throws an exception. __cxa_begin_catch(exceptionObject); __attribute__((cleanup(end_catch))) char unused; if (exceptionObject->exception_class == exception_class) { __cxa_exception *ex = exceptionFromPointer(exceptionObject); if (ex->unexpectedHandler) { ex->unexpectedHandler(); // Should not be reached. abort(); } } std::unexpected(); // Should not be reached. abort(); } /** * ABI function, returns the adjusted pointer to the exception object. */ extern "C" void *__cxa_get_exception_ptr(void *exceptionObject) { return exceptionFromPointer(exceptionObject)->adjustedPtr; } /** * As an extension, we provide the ability for the unexpected and terminate * handlers to be thread-local. We default to the standards-compliant * behaviour where they are global. */ static bool thread_local_handlers = false; namespace pathscale { /** * Sets whether unexpected and terminate handlers should be thread-local. */ void set_use_thread_local_handlers(bool flag) throw() { thread_local_handlers = flag; } /** * Sets a thread-local unexpected handler. */ unexpected_handler set_unexpected(unexpected_handler f) throw() { static __cxa_thread_info *info = thread_info(); unexpected_handler old = info->unexpectedHandler; info->unexpectedHandler = f; return old; } /** * Sets a thread-local terminate handler. */ terminate_handler set_terminate(terminate_handler f) throw() { static __cxa_thread_info *info = thread_info(); terminate_handler old = info->terminateHandler; info->terminateHandler = f; return old; } } namespace std { /** * Sets the function that will be called when an exception specification is * violated. */ unexpected_handler set_unexpected(unexpected_handler f) throw() { if (thread_local_handlers) { return pathscale::set_unexpected(f); } return unexpectedHandler.exchange(f); } /** * Sets the function that is called to terminate the program. */ terminate_handler set_terminate(terminate_handler f) throw() { if (thread_local_handlers) { return pathscale::set_terminate(f); } return terminateHandler.exchange(f); } /** * Terminates the program, calling a custom terminate implementation if * required. */ void terminate() { static __cxa_thread_info *info = thread_info(); if (0 != info && 0 != info->terminateHandler) { info->terminateHandler(); // Should not be reached - a terminate handler is not expected to // return. abort(); } terminateHandler.load()(); } /** * Called when an unexpected exception is encountered (i.e. an exception * violates an exception specification). This calls abort() unless a * custom handler has been set.. */ void unexpected() { static __cxa_thread_info *info = thread_info(); if (0 != info && 0 != info->unexpectedHandler) { info->unexpectedHandler(); // Should not be reached - a terminate handler is not expected to // return. abort(); } unexpectedHandler.load()(); } /** * Returns whether there are any exceptions currently being thrown that * have not been caught. This can occur inside a nested catch statement. */ bool uncaught_exception() throw() { __cxa_thread_info *info = thread_info(); return info->globals.uncaughtExceptions != 0; } /** * Returns the number of exceptions currently being thrown that have not * been caught. This can occur inside a nested catch statement. */ int uncaught_exceptions() throw() { __cxa_thread_info *info = thread_info(); return info->globals.uncaughtExceptions; } /** * Returns the current unexpected handler. */ unexpected_handler get_unexpected() throw() { __cxa_thread_info *info = thread_info(); if (info->unexpectedHandler) { return info->unexpectedHandler; } return unexpectedHandler.load(); } /** * Returns the current terminate handler. */ terminate_handler get_terminate() throw() { __cxa_thread_info *info = thread_info(); if (info->terminateHandler) { return info->terminateHandler; } return terminateHandler.load(); } } #if defined(__arm__) && !defined(__ARM_DWARF_EH__) extern "C" _Unwind_Exception *__cxa_get_cleanup(void) { __cxa_thread_info *info = thread_info_fast(); _Unwind_Exception *exceptionObject = info->currentCleanup; if (isCXXException(exceptionObject->exception_class)) { __cxa_exception *ex = exceptionFromPointer(exceptionObject); ex->cleanupCount--; if (ex->cleanupCount == 0) { info->currentCleanup = ex->nextCleanup; ex->nextCleanup = 0; } } else { info->currentCleanup = 0; } return exceptionObject; } asm ( ".pushsection .text.__cxa_end_cleanup \n" ".global __cxa_end_cleanup \n" ".type __cxa_end_cleanup, \"function\" \n" "__cxa_end_cleanup: \n" " push {r1, r2, r3, r4} \n" " mov r4, lr \n" " bl __cxa_get_cleanup \n" " mov lr, r4 \n" " pop {r1, r2, r3, r4} \n" " b _Unwind_Resume \n" " bl abort \n" ".popsection \n" ); #endif diff --git a/lib/libcxxrt/Version.map b/lib/libcxxrt/Version.map index 0d2dccbe2670..a54b6a4daad5 100644 --- a/lib/libcxxrt/Version.map +++ b/lib/libcxxrt/Version.map @@ -1,394 +1,398 @@ # Define the same version as the libsupc++ from gcc 4.2.1 so that we can use # libcxxrt as a drop-in replacement. CXXABI_1.3 { global: # ABI functions with C linkage __cxa_allocate_exception; __cxa_bad_cast; __cxa_bad_typeid; __cxa_begin_catch; __cxa_begin_cleanup; __cxa_call_unexpected; __cxa_current_exception_type; __cxa_demangle; __cxa_end_catch; __cxa_end_cleanup; __cxa_free_exception; __cxa_get_globals; __cxa_get_globals_fast; __cxa_guard_abort; __cxa_guard_acquire; __cxa_guard_release; __cxa_pure_virtual; __cxa_rethrow; __cxa_throw; __cxa_throw_bad_array_new_length; __cxa_type_match; __cxa_vec_cctor; __cxa_vec_cleanup; __cxa_vec_ctor; __cxa_vec_delete2; __cxa_vec_delete3; __cxa_vec_delete; __cxa_vec_dtor; __cxa_vec_new2; __cxa_vec_new3; __cxa_vec_new; __dynamic_cast; __gxx_personality_sj0; __gxx_personality_v0; extern "C++" { # Type info classes and their destructors "__cxxabiv1::__array_type_info"; "__cxxabiv1::__array_type_info::~__array_type_info()"; "__cxxabiv1::__class_type_info"; "__cxxabiv1::__class_type_info::~__class_type_info()"; "__cxxabiv1::__enum_type_info"; "__cxxabiv1::__enum_type_info::~__enum_type_info()"; "__cxxabiv1::__function_type_info::"; "__cxxabiv1::__function_type_info::~__function_type_info()"; "__cxxabiv1::__fundamental_type_info"; "__cxxabiv1::__fundamental_type_info::~__fundamental_type_info()"; "__cxxabiv1::__pbase_type_info"; "__cxxabiv1::__pbase_type_info::~__pbase_type_info()"; "__cxxabiv1::__pointer_to_member_type_info"; "__cxxabiv1::__pointer_to_member_type_info::~__pointer_to_member_type_info()"; "__cxxabiv1::__pointer_type_info"; "__cxxabiv1::__pointer_type_info::~__pointer_type_info()"; "__cxxabiv1::__si_class_type_info"; "__cxxabiv1::__si_class_type_info::~__si_class_type_info()"; "__cxxabiv1::__vmi_class_type_info"; "__cxxabiv1::__vmi_class_type_info::~__vmi_class_type_info()"; # vtables typeinfo classes. "vtable for __cxxabiv1::__array_type_info"; "vtable for __cxxabiv1::__class_type_info"; "vtable for __cxxabiv1::__enum_type_info"; "vtable for __cxxabiv1::__function_type_info"; "vtable for __cxxabiv1::__fundamental_type_info"; "vtable for __cxxabiv1::__pbase_type_info"; "vtable for __cxxabiv1::__pointer_to_member_type_info"; "vtable for __cxxabiv1::__pointer_type_info"; "vtable for __cxxabiv1::__si_class_type_info"; "vtable for __cxxabiv1::__vmi_class_type_info"; # Type info for built-in types "typeinfo for bool const*"; "typeinfo for bool"; "typeinfo for char const*"; "typeinfo for char"; "typeinfo for double const*"; "typeinfo for double"; "typeinfo for float const*"; "typeinfo for float"; "typeinfo for int const*"; "typeinfo for int"; "typeinfo for long const*"; "typeinfo for long double const*"; "typeinfo for long double"; "typeinfo for long long const*"; "typeinfo for long long"; "typeinfo for long"; "typeinfo for short const*"; "typeinfo for short"; "typeinfo for signed char const*"; "typeinfo for signed char"; "typeinfo for unsigned char const*"; "typeinfo for unsigned char"; "typeinfo for unsigned int const*"; "typeinfo for unsigned int"; "typeinfo for unsigned long const*"; "typeinfo for unsigned long long const*"; "typeinfo for unsigned long long"; "typeinfo for unsigned long"; "typeinfo for unsigned short const*"; "typeinfo for unsigned short"; "typeinfo for void const*"; "typeinfo for void"; "typeinfo for wchar_t const*"; "typeinfo for wchar_t"; "typeinfo for bool*"; "typeinfo for wchar_t*"; "typeinfo for short*"; "typeinfo for char*"; "typeinfo for unsigned char*"; "typeinfo for long long*"; "typeinfo for unsigned short*"; "typeinfo for long*"; "typeinfo for double*"; "typeinfo for unsigned long*"; "typeinfo for unsigned long long*"; "typeinfo for int*"; "typeinfo for long double*"; "typeinfo for signed char*"; "typeinfo for void*"; "typeinfo for unsigned int*"; "typeinfo for float*"; "typeinfo for __cxxabiv1::__array_type_info"; "typeinfo for __cxxabiv1::__class_type_info"; "typeinfo for __cxxabiv1::__enum_type_info"; "typeinfo for __cxxabiv1::__function_type_info"; "typeinfo for __cxxabiv1::__fundamental_type_info"; "typeinfo for __cxxabiv1::__pbase_type_info"; "typeinfo for __cxxabiv1::__pointer_to_member_type_info"; "typeinfo for __cxxabiv1::__pointer_type_info"; "typeinfo for __cxxabiv1::__si_class_type_info"; "typeinfo for __cxxabiv1::__vmi_class_type_info"; # Typeinfo names. "typeinfo name for unsigned char const*"; "typeinfo name for long const*"; "typeinfo name for double const*"; "typeinfo name for unsigned long long const*"; "typeinfo name for unsigned short const*"; "typeinfo name for char const*"; "typeinfo name for long long const*"; "typeinfo name for short const*"; "typeinfo name for unsigned int const*"; "typeinfo name for float const*"; "typeinfo name for bool const*"; "typeinfo name for wchar_t const*"; "typeinfo name for int const*"; "typeinfo name for unsigned long const*"; "typeinfo name for void const*"; "typeinfo name for long double const*"; "typeinfo name for signed char const*"; "typeinfo name for wchar_t"; "typeinfo name for short"; "typeinfo name for char"; "typeinfo name for float"; "typeinfo name for void"; "typeinfo name for unsigned int"; "typeinfo name for bool"; "typeinfo name for signed char"; "typeinfo name for long double"; "typeinfo name for int"; "typeinfo name for unsigned long long"; "typeinfo name for unsigned long"; "typeinfo name for unsigned char"; "typeinfo name for long"; "typeinfo name for long long"; "typeinfo name for unsigned short"; "typeinfo name for double"; "typeinfo name for bool*"; "typeinfo name for wchar_t*"; "typeinfo name for short*"; "typeinfo name for char*"; "typeinfo name for unsigned char*"; "typeinfo name for long long*"; "typeinfo name for unsigned short*"; "typeinfo name for long*"; "typeinfo name for double*"; "typeinfo name for unsigned long*"; "typeinfo name for unsigned long long*"; "typeinfo name for int*"; "typeinfo name for long double*"; "typeinfo name for signed char*"; "typeinfo name for void*"; "typeinfo name for unsigned int*"; "typeinfo name for float*"; "typeinfo name for __cxxabiv1::__array_type_info"; "typeinfo name for __cxxabiv1::__class_type_info"; "typeinfo name for __cxxabiv1::__enum_type_info"; "typeinfo name for __cxxabiv1::__function_type_info"; "typeinfo name for __cxxabiv1::__fundamental_type_info"; "typeinfo name for __cxxabiv1::__pbase_type_info"; "typeinfo name for __cxxabiv1::__pointer_to_member_type_info"; "typeinfo name for __cxxabiv1::__pointer_type_info"; "typeinfo name for __cxxabiv1::__si_class_type_info"; "typeinfo name for __cxxabiv1::__vmi_class_type_info"; "std::type_info::type_info(std::type_info const&)"; "std::type_info::operator=(std::type_info const&)"; # Extensions "pathscale::set_terminate(void (*)())"; "pathscale::set_unexpected(void (*)())"; "pathscale::set_use_thread_local_handlers(bool)"; }; # C++11 typeinfo not understood by ld.bfd 2.17.50 # std::nullptr_t _ZTIDn;_ZTIPDn;_ZTIPKDn; # char16_t _ZTIDi;_ZTIPDi;_ZTIPKDi; # char32_t _ZTIDs;_ZTIPDs;_ZTIPKDs; # IEEE 754r decimal floating point _ZTIDd;_ZTIPDd;_ZTIPKDd; _ZTIDe;_ZTIPDe;_ZTIPKDe; _ZTIDf;_ZTIPDf;_ZTIPKDf; # IEEE 754r half-precision floating point _ZTIDh;_ZTIPDh;_ZTIPKDh; # C++11 typeinfo name not understood by ld.bfd 2.17.50 # std::nullptr_t _ZTSDn;_ZTSPDn;_ZTSPKDn; # char16_t _ZTSDi;_ZTSPDi;_ZTSPKDi; # char32_t _ZTSDs;_ZTSPDs;_ZTSPKDs; # IEEE 754r decimal floating point _ZTSDd;_ZTSPDd;_ZTSPKDd; _ZTSDe;_ZTSPDe;_ZTSPKDe; _ZTSDf;_ZTSPDf;_ZTSPKDf; # IEEE 754r half-precision floating point _ZTSDh;_ZTSPDh;_ZTSPKDh; local: *; }; CXXABI_1.3.1 { __cxa_get_exception_ptr; } CXXABI_1.3; CXXABI_1.3.5 { extern "C++" { "typeinfo for __int128 const*"; "typeinfo for __int128"; "typeinfo for __int128*"; "typeinfo for unsigned __int128 const*"; "typeinfo for unsigned __int128"; "typeinfo for unsigned __int128*"; }; } CXXABI_1.3.1; CXXABI_1.3.6 { __cxa_deleted_virtual; } CXXABI_1.3.5; CXXABI_1.3.9 { extern "C++" { "typeinfo name for __int128 const*"; "typeinfo name for __int128"; "typeinfo name for __int128*"; "typeinfo name for unsigned __int128 const*"; "typeinfo name for unsigned __int128"; "typeinfo name for unsigned __int128*"; "operator delete[](void*, unsigned int)"; "operator delete(void*, unsigned int)"; "operator delete[](void*, unsigned long)"; "operator delete(void*, unsigned long)"; }; } CXXABI_1.3.6; +CXXABI_1.3.11 { + __cxa_init_primary_exception; +} CXXABI_1.3.9; + CXXRT_1.0 { extern "C++" { "std::type_info::name() const"; "std::type_info::before(std::type_info const&) const"; "std::type_info::operator==(std::type_info const&) const"; "std::type_info::operator!=(std::type_info const&) const"; "std::bad_cast::bad_cast(std::bad_cast const&)"; "std::bad_cast::bad_cast()"; "std::bad_cast::operator=(std::bad_cast const&)"; "std::bad_typeid::bad_typeid(std::bad_typeid const&)"; "std::bad_typeid::bad_typeid()"; "std::bad_typeid::operator=(std::bad_typeid const&)"; "std::exception::exception(std::exception const&)"; "std::exception::exception()"; "std::exception::operator=(std::exception const&)"; "std::bad_alloc::bad_alloc(std::bad_alloc const&)"; "std::bad_alloc::bad_alloc()"; "std::bad_alloc::operator=(std::bad_alloc const&)"; "std::bad_array_new_length::bad_array_new_length(std::bad_array_new_length const&)"; "std::bad_array_new_length::bad_array_new_length()"; "std::bad_array_new_length::operator=(std::bad_array_new_length const&)"; }; __cxa_allocate_dependent_exception; __cxa_current_primary_exception; __cxa_decrement_exception_refcount; __cxa_free_dependent_exception; __cxa_increment_exception_refcount; __cxa_rethrow_primary_exception; } CXXABI_1.3.6; GLIBCXX_3.4 { extern "C++" { "operator delete[](void*)"; "operator delete(void*)"; "operator new[](unsigned int)"; "operator new(unsigned int)"; "operator new(unsigned int, std::nothrow_t const&)"; "operator new[](unsigned long)"; "operator new(unsigned long)"; "operator new(unsigned long, std::nothrow_t const&)"; "std::unexpected()"; "std::get_terminate()"; "std::get_unexpected()"; "std::uncaught_exception()"; "std::terminate()"; "std::type_info::~type_info()"; "std::bad_cast::~bad_cast()"; "std::bad_typeid::~bad_typeid()"; "std::exception::~exception()"; "std::bad_alloc::~bad_alloc()"; "std::bad_array_new_length::~bad_array_new_length()"; "std::exception::what() const"; std::set_new_handler*; std::set_terminate*; std::set_unexpected*; std::type_info::__*; "vtable for std::bad_alloc"; "vtable for std::bad_cast"; "vtable for std::bad_typeid"; "vtable for std::exception"; "vtable for std::type_info"; "vtable for std::bad_array_new_length"; "typeinfo for std::bad_alloc"; "typeinfo for std::bad_typeid"; "typeinfo for std::bad_cast"; "typeinfo for std::exception"; "typeinfo for std::type_info"; "typeinfo for std::bad_array_new_length"; "typeinfo name for std::bad_alloc"; "typeinfo name for std::bad_typeid"; "typeinfo name for std::bad_cast"; "typeinfo name for std::exception"; "typeinfo name for std::type_info"; "typeinfo name for std::bad_array_new_length"; }; }; GLIBCXX_3.4.9 { extern "C++" { "std::bad_typeid::what() const"; "std::bad_cast::what() const"; "std::bad_alloc::what() const"; "std::bad_array_new_length::what() const"; }; } GLIBCXX_3.4; GLIBCXX_3.4.20 { extern "C++" { "std::get_new_handler()"; }; } GLIBCXX_3.4.9; GLIBCXX_3.4.22 { extern "C++" { "std::uncaught_exceptions()"; }; } GLIBCXX_3.4.20;