intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

1 files changed, 1691 insertions, 0 deletions

diff --git a/contrib/libs/cxxsupp/libcxxrt/exception.cc b/contrib/libs/cxxsupp/libcxxrt/exception.cc
new file mode 100644
index 00000000000..6baf428eadf
--- /dev/null
+++ b/contrib/libs/cxxsupp/libcxxrt/exception.cc
@@ -0,0 +1,1691 @@
+/* 
+ * Copyright 2010-2011 PathScale, Inc. 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"
+#include "msan.h"
+
+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;
+};
+
+static_assert(sizeof(__cxa_dependent_exception) == sizeof(__cxa_exception));
+
+namespace std
+{
+	void unexpected();
+	class exception
+	{
+		public:
+			virtual ~exception();
+			virtual const char* what() const noexcept;
+	};
+
+}
+
+/**
+ * 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 =
+#ifdef _YNDX_LIBUNWIND_ENABLE_EXCEPTION_BACKTRACE
+    _YNDX_LIBUNWIND_EXCEPTION_BACKTRACE_PRIMARY_CLASS;
+#else
+	EXCEPTION_CLASS('G', 'N', 'U', 'C', 'C', '+', '+', '\0');
+#endif
+/**
+ * Class used for dependent exceptions.  
+ */
+static const uint64_t dependent_exception_class =
+#ifdef _YNDX_LIBUNWIND_ENABLE_EXCEPTION_BACKTRACE
+    _YNDX_LIBUNWIND_EXCEPTION_BACKTRACE_DEPENDENT_CLASS;
+#else
+	EXCEPTION_CLASS('G', 'N', 'U', 'C', 'C', '+', '+', '\x01');
+#endif
+/**
+ * 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) noexcept;
+}
+
+using namespace ABI_NAMESPACE;
+
+/**
+ * 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;
+}
+
+static void bt_terminate_handler() {
+    __cxa_eh_globals* globals = __cxa_get_globals();
+    __cxa_exception* thrown_exception = globals->caughtExceptions;
+
+    if (!thrown_exception) {
+        abort();
+    }
+
+    fprintf(stderr, "uncaught exception:\n    address -> %p\n", (void*)thrown_exception);
+    thrown_exception = realExceptionFromException(thrown_exception);
+
+    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) {
+        void* ptr = thrown_exception + 1;
+
+        if (throw_ti->__do_upcast(e_ti, &ptr)) {
+            std::exception* e = static_cast<std::exception*>(ptr);
+
+            if (e) {
+                fprintf(stderr, "    what() -> \"%s\"\n", 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, "    type -> %s\n", status == 0 ? demangled : mangled);
+    if (status == 0) { free(demangled); }
+    abort();
+}
+
+/** The global termination handler. */
+static terminate_handler terminateHandler = bt_terminate_handler;
+/** The global unexpected exception handler. */
+static 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);
+}
+
+#define fast_ti_size 100
+
+static long fast_ti_index;
+static __cxa_thread_info fast_ti[fast_ti_size];
+
+static inline __cxa_thread_info* alloc_thread_info() {
+    {
+        long cur_index;
+
+        __atomic_load(&fast_ti_index, &cur_index, __ATOMIC_SEQ_CST);
+
+        // exausted long time ago
+        if (cur_index >= fast_ti_size) {
+            return static_cast<__cxa_thread_info*>(calloc(1, sizeof(__cxa_thread_info)));
+        }
+    }
+
+    auto my_index = __sync_fetch_and_add(&fast_ti_index, 1);
+
+    // exausted
+    if (my_index >= fast_ti_size) {
+        return static_cast<__cxa_thread_info*>(calloc(1, sizeof(__cxa_thread_info)));
+    }
+
+    // fast path
+    auto& ret = fast_ti[my_index];
+
+    memset(&ret, 0, sizeof(ret));
+
+    return &ret;
+}
+
+static inline void free_thread_info(__cxa_thread_info* ti) {
+    if ((ti < fast_ti) || (ti >= (fast_ti + fast_ti_size))) {
+        free(ti);
+    }
+}
+
+/**
+ * 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(info);
+}
+
+/**
+ * Once control used to protect the key creation.
+ */
+static pthread_once_t once_control = PTHREAD_ONCE_INIT;
+
+/**
+ * Initialise eh_key.
+ */
+static void init_key(void)
+{
+	pthread_key_create(&eh_key, thread_cleanup);
+	pthread_setspecific(eh_key, reinterpret_cast<void *>(0x42));
+   if (pthread_getspecific(eh_key) != reinterpret_cast<void *>(0x42)) {
+       abort();
+   }
+	pthread_setspecific(eh_key, 0);
+}
+
+static __thread __cxa_thread_info* THR_INFO = nullptr;
+
+/**
+ * Returns the thread info structure, creating it if it is not already created.
+ */
+static __cxa_thread_info *thread_info()
+{
+	if (THR_INFO) {
+		return THR_INFO;
+   }
+   pthread_once(&once_control, init_key);
+	__cxa_thread_info *info = static_cast<__cxa_thread_info*>(pthread_getspecific(eh_key));
+	if (0 == info)
+	{
+       info = alloc_thread_info();
+		pthread_setspecific(eh_key, info);
+	}
+   THR_INFO = info;
+	return info;
+}
+
+// ensure main thread will allocate preallocated tls
+static struct InitMainTls {
+    inline InitMainTls() {
+        thread_info();
+    }
+} init_main_tls;
+
+/**
+ * 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 (THR_INFO) {
+   	return THR_INFO;
+   }
+	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);
+	}
+}
+
+static constexpr size_t align_to(size_t size, size_t alignment) noexcept {
+    return (size + alignment - 1) / alignment * alignment;
+}
+
+static_assert(align_to(15, 16) == 16);
+static_assert(align_to(16, 16) == 16);
+static_assert(align_to(17, 16) == 32);
+
+static constexpr size_t exception_size = align_to(sizeof(__cxa_exception), 16);
+static constexpr size_t dependent_exception_size = align_to(sizeof(__cxa_dependent_exception), 16);
+#ifdef _YNDX_LIBUNWIND_ENABLE_EXCEPTION_BACKTRACE
+static constexpr size_t backtrace_buffer_size = align_to(sizeof(_Unwind_Backtrace_Buffer), 16);
+
+static_assert(
+    _YNDX_LIBUNWIND_EXCEPTION_BACKTRACE_MAGIC_OFFSET ==
+    offsetof(__cxa_exception, unwindHeader) + backtrace_buffer_size - sizeof(_Unwind_Backtrace_Buffer));
+#else
+static constexpr size_t backtrace_buffer_size = 0;
+#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 + exception_size + backtrace_buffer_size;
+	char *buffer = alloc_or_die(size);
+#ifdef _YNDX_LIBUNWIND_ENABLE_EXCEPTION_BACKTRACE
+	((_Unwind_Backtrace_Buffer *)buffer)->size = 0;
+#endif
+	return buffer + exception_size + backtrace_buffer_size;
+}
+
+extern "C" void *__cxa_allocate_dependent_exception(void)
+{
+	size_t size = dependent_exception_size + backtrace_buffer_size;
+	char *buffer = alloc_or_die(size);
+	return buffer + dependent_exception_size + backtrace_buffer_size;
+}
+
+/**
+ * __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*>(thrown_exception) - exception_size - backtrace_buffer_size);
+}
+
+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*>(thrown_exception) - dependent_exception_size - backtrace_buffer_size);
+}
+
+/**
+ * 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) noexcept;
+#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, "uncaught exception:\n    address -> %p\n", 
+					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, " what() -> \"%s\"\n", 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, "    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
+			_Unwind_Backtrace(trace, 0);
+
+			// 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;
+	}
+	ex->terminateHandler  = info->terminateHandler;
+	if (0 == ex->terminateHandler)
+	{
+		ex->terminateHandler = terminateHandler;
+	}
+	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);
+}
+
+typedef void (*cxa_throw_hook_t)(void*, std::type_info*, void(*)(void*)) noexcept;
+
+__attribute__((weak)) cxa_throw_hook_t cxa_throw_hook = nullptr;
+
+/**
+ * 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*))
+{
+	if (cxa_throw_hook)
+	{
+		cxa_throw_hook(thrown_exception, tinfo, dest);
+	}
+
+	__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);
+}
+
+#ifdef _YNDX_LIBUNWIND_ENABLE_EXCEPTION_BACKTRACE
+static size_t __cxa_collect_backtrace(__cxa_exception* ex, void** dest, size_t size) {
+    if (!ex) {
+        return 0;
+    }
+    if (!isCXXException(ex->unwindHeader.exception_class)) {
+        return 0;
+    }
+    size_t i = 0;
+    if (isDependentException(ex->unwindHeader.exception_class)) {
+        i = __cxa_collect_backtrace(
+                (__cxa_exception *)((__cxa_dependent_exception *)ex)->primaryException - 1, dest, size);
+    }
+    _Unwind_Backtrace_Buffer* backtraceBuffer = (_Unwind_Backtrace_Buffer*)(
+            (char *)(ex + 1) - exception_size - backtrace_buffer_size);
+    for (size_t j = 0; i != size && j != backtraceBuffer->size; ++i, ++j) {
+        dest[i] = backtraceBuffer->backtrace[j];
+    }
+    return i;
+}
+
+extern "C" size_t __cxa_collect_current_exception_backtrace(void** dest, size_t size) {
+    return __cxa_collect_backtrace(__cxa_get_globals()->caughtExceptions, dest, size);
+}
+#endif
+
+/**
+ * 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)
+#if defined(__SANITIZE_MEMORY__)
+  __msan_unpoison(&version, sizeof(version));
+  __msan_unpoison(&actions, sizeof(actions));
+  __msan_unpoison(&exceptionClass, sizeof(exceptionClass));
+  __msan_unpoison(&exceptionObject, sizeof(exceptionObject));
+  __msan_unpoison(&context, sizeof(context));
+#endif
+	// 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) noexcept
+#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) noexcept
+	{
+		thread_local_handlers = flag;
+	}
+	/**
+	 * Sets a thread-local unexpected handler.  
+	 */
+	unexpected_handler set_unexpected(unexpected_handler f) noexcept
+	{
+		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) noexcept
+	{
+		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) noexcept
+	{
+		if (thread_local_handlers) { return pathscale::set_unexpected(f); }
+
+		return ATOMIC_SWAP(&unexpectedHandler, f);
+	}
+	/**
+	 * Sets the function that is called to terminate the program.
+	 */
+	terminate_handler set_terminate(terminate_handler f) noexcept
+	{
+		if (thread_local_handlers) { return pathscale::set_terminate(f); }
+
+		return ATOMIC_SWAP(&terminateHandler, f);
+	}
+	/**
+	 * Terminates the program, calling a custom terminate implementation if
+	 * required.
+	 */
+	void terminate() noexcept
+	{
+		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();
+	}
+	/**
+	 * 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();
+	}
+	/**
+	 * 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() noexcept
+	{
+		__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() noexcept
+	{
+		__cxa_thread_info *info = thread_info();
+		return info->globals.uncaughtExceptions;
+	}
+	/**
+	 * Returns the current unexpected handler.
+	 */
+	unexpected_handler get_unexpected() noexcept
+	{
+		__cxa_thread_info *info = thread_info();
+		if (info->unexpectedHandler)
+		{
+			return info->unexpectedHandler;
+		}
+		return ATOMIC_LOAD(&unexpectedHandler);
+	}
+	/**
+	 * Returns the current terminate handler.
+	 */
+	terminate_handler get_terminate() noexcept
+	{
+		__cxa_thread_info *info = thread_info();
+		if (info->terminateHandler)
+		{
+			return info->terminateHandler;
+		}
+		return ATOMIC_LOAD(&terminateHandler);
+	}
+}
+#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