Interesting fixes: 47661d0 Match libc++abi/libsupc++ when demangling array types e44a05c Fix unitialized variable in __cxa_demangle_gnu3 after #6 (#8) 5088b05 Remove some code duplication. fd484be Atomics cleanup (#11) MFC after: 2 weeks
1575 lines
48 KiB
C++
1575 lines
48 KiB
C++
/*
|
|
* 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 <stdlib.h>
|
|
#include <dlfcn.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <pthread.h>
|
|
#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<uint32_t>(selector);
|
|
ucb->barrier_cache.bitpattern[3] = reinterpret_cast<uint32_t>(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<dw_eh_ptr_t>(ucb->barrier_cache.bitpattern[3]);
|
|
return 1;
|
|
#else
|
|
if (ex)
|
|
{
|
|
*selector = ex->handlerSwitchValue;
|
|
*landingPad = reinterpret_cast<dw_eh_ptr_t>(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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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 *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;
|
|
};
|
|
|
|
|
|
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<char*>(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<terminate_handler> terminateHandler = abort;
|
|
/** The global unexpected exception handler. */
|
|
static atomic<unexpected_handler> 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<void*>(ex + 1));
|
|
}
|
|
static void dependent_exception_cleanup(_Unwind_Reason_Code reason,
|
|
struct _Unwind_Exception *ex)
|
|
{
|
|
|
|
__cxa_free_dependent_exception(static_cast<void*>(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<void *>(0x42));
|
|
fakeTLS = (pthread_getspecific(eh_key) != reinterpret_cast<void *>(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);
|
|
}
|
|
|
|
/**
|
|
* 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<char*>(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<void*>(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<char*>(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);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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<char*>(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<char*>(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<void *>(__cxa_current_exception_type), &myinfo);
|
|
void *ip = reinterpret_cast<void*>(_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<void*>(thrown_exception));
|
|
thrown_exception = realExceptionFromException(thrown_exception);
|
|
static const __class_type_info *e_ti =
|
|
static_cast<const __class_type_info*>(&typeid(std::exception));
|
|
const __class_type_info *throw_ti =
|
|
dynamic_cast<const __class_type_info*>(thrown_exception->exceptionType);
|
|
if (throw_ti)
|
|
{
|
|
std::exception *e =
|
|
static_cast<std::exception*>(e_ti->cast_to(static_cast<void*>(thrown_exception+1),
|
|
throw_ti));
|
|
if (e)
|
|
{
|
|
fprintf(stderr, " '%s'", e->what());
|
|
}
|
|
}
|
|
|
|
size_t bufferSize = 128;
|
|
char *demangled = static_cast<char*>(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);
|
|
}
|
|
|
|
|
|
/**
|
|
* 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;
|
|
|
|
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<std::type_info*>(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<void*>(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<void**>(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<unsigned char*>(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<unsigned char*>(_Unwind_GetLanguageSpecificData(context));
|
|
#else
|
|
unsigned char *lsda_addr =
|
|
reinterpret_cast<unsigned char*>(static_cast<uintptr_t>(_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<const char*>(lsda_addr);
|
|
ex->actionRecord = reinterpret_cast<const char*>(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<unsigned long>(action.landing_pad));
|
|
_Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
|
|
reinterpret_cast<unsigned long>(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<char*>(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"
|
|
" bl __cxa_get_cleanup \n"
|
|
" push {r1, r2, r3, r4} \n"
|
|
" b _Unwind_Resume \n"
|
|
" bl abort \n"
|
|
".popsection \n"
|
|
);
|
|
#endif
|