Restoring authorship annotation for <neksard@yandex-team.ru>. Commit 1 of 2.

1 files changed, 1368 insertions, 1368 deletions

diff --git a/contrib/libs/cxxsupp/libcxxrt/exception.cc b/contrib/libs/cxxsupp/libcxxrt/exception.cc
index 6baf428ead..be7d1b0897 100644
--- a/contrib/libs/cxxsupp/libcxxrt/exception.cc
+++ b/contrib/libs/cxxsupp/libcxxrt/exception.cc
@@ -1,278 +1,278 @@
 /* 
- * 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.
+ * Copyright 2010-2011 PathScale, Inc. All rights reserved. 
  * 
- * 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"
+ * 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
+ 
+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.
-	 */
+	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;
-};
-/**
+	{ 
+		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;
+ */ 
+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;
-};
-
+	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:
+ 
+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 =
+} 
+ 
+/** 
+ * 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 =
+ */ 
+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');
+	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.
- */
+/** 
+ * 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.
+	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;
-
+} 
+ 
+using namespace ABI_NAMESPACE; 
+ 
 /**
  * Callback function used with _Unwind_Backtrace().
  *
@@ -297,11 +297,11 @@ static _Unwind_Reason_Code trace(struct _Unwind_Context *context, void *c)
 	}
 	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();
     }
@@ -334,49 +334,49 @@ static void bt_terminate_handler() {
     abort();
 }
 
-/** The global termination handler. */
+/** 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.
- */
+/** 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)
-{
+                              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)
-{
-
+                              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);
-}
-
+} 
+ 
+/** 
+ * 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;
@@ -415,68 +415,68 @@ static inline void free_thread_info(__cxa_thread_info* 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);
+/** 
+ * 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);
-		}
-	}
+		} 
+		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));
+} 
+ 
+/** 
+ * 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);
-}
-
+	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()
-{
+/** 
+ * 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));
+	__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);
-	}
+		pthread_setspecific(eh_key, info); 
+	} 
    THR_INFO = info;
-	return info;
-}
+	return info; 
+} 
 
 // ensure main thread will allocate preallocated tls
 static struct InitMainTls {
@@ -485,173 +485,173 @@ static struct InitMainTls {
     }
 } 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()
-{
+/** 
+ * 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;
-		}
-	}
+	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
+	       "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 (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);
-	}
-}
-
+	    (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;
 }
@@ -672,112 +672,112 @@ static_assert(
 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)
-{
+/** 
+ * 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);
+	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)
-{
+} 
+ 
+extern "C" void *__cxa_allocate_dependent_exception(void) 
+{ 
 	size_t size = dependent_exception_size + backtrace_buffer_size;
-	char *buffer = alloc_or_die(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();
-		}
-	}
-
+} 
+ 
+/** 
+ * __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)));
-	}
+} 
+ 
+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)
+} 
+ 
+/** 
+ * 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();
+#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);
@@ -808,108 +808,108 @@ static void report_failure(_Unwind_Reason_Code err, __cxa_exception *thrown_exce
 			// 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);
-}
-
+			// 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*))
-{
+/** 
+ * 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;
+	__cxa_exception *ex = reinterpret_cast<__cxa_exception*>(thrown_exception) - 1; 
+ 
+	ex->referenceCount = 1; 
+	ex->exceptionType = tinfo; 
 	
-	ex->exceptionDestructor = dest;
+	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);
-}
-
+	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) {
@@ -936,42 +936,42 @@ extern "C" size_t __cxa_collect_current_exception_backtrace(void** dest, size_t
 }
 #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!");
-
+/** 
+ * 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.
@@ -979,202 +979,202 @@ extern "C" void __cxa_rethrow()
 	// foreign exceptions don't adjust any of this state.
 	globals->uncaughtExceptions++;
 
-	// ex->handlerCount will be decremented in __cxa_end_catch in enclosing
-	// catch block
+	// 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.
+	// 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);
+		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)
+			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));
@@ -1182,298 +1182,298 @@ BEGIN_PERSONALITY_FUNCTION(__gxx_personality_v0)
   __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;
+	// 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
+	// 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)
+			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))
-	{
+#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.
+		__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;
+			// 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!");
+		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 (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
-		//     }
-		// }
-		//
+		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;
-}
-
-/**
+		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.
  */
@@ -1482,145 +1482,145 @@ static void end_catch(char *)
 	__cxa_end_catch();
 }
 /**
- * ABI function, called when an exception specification is violated.
- *
- * This function does not return.
- */
+ * 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);
+{ 
+	_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();
+	if (exceptionObject->exception_class == exception_class) 
+	{ 
+		__cxa_exception *ex =  exceptionFromPointer(exceptionObject); 
+		if (ex->unexpectedHandler) 
+		{ 
+			ex->unexpectedHandler(); 
 			// Should not be reached.  
-			abort();
-		}
-	}
-	std::unexpected();
+			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.
-	 */
+	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;
-	}
-	/**
+	{ 
+		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;
-	}
-	/**
+	{ 
+		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.
-	 */
+	{ 
+		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.
-	 */
+	{ 
+		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.
-	 */
+	{ 
+		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.
-	 */
+	{ 
+		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;
-	}
-	/**
+	{ 
+		__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.
 	 */
@@ -1630,62 +1630,62 @@ namespace std
 		return info->globals.uncaughtExceptions;
 	}
 	/**
-	 * Returns the current unexpected handler.
-	 */
+	 * 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.
-	 */
+	{ 
+		__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
+	{ 
+		__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