No OneTemporary
Actions

Size

74 KB

Referenced Files

None

Subscribers

None

View Options

	Index: head/contrib/libcxxrt/abi_namespace.h
	===================================================================
	--- head/contrib/libcxxrt/abi_namespace.h (revision 350359)
	+++ head/contrib/libcxxrt/abi_namespace.h (revision 350360)

	Property changes on: head/contrib/libcxxrt/abi_namespace.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/auxhelper.cc
	===================================================================
	--- head/contrib/libcxxrt/auxhelper.cc (revision 350359)
	+++ head/contrib/libcxxrt/auxhelper.cc (revision 350360)

	Property changes on: head/contrib/libcxxrt/auxhelper.cc
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/cxxabi.h
	===================================================================
	--- head/contrib/libcxxrt/cxxabi.h (revision 350359)
	+++ head/contrib/libcxxrt/cxxabi.h (revision 350360)

	Property changes on: head/contrib/libcxxrt/cxxabi.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/dwarf_eh.h
	===================================================================
	--- head/contrib/libcxxrt/dwarf_eh.h (revision 350359)
	+++ head/contrib/libcxxrt/dwarf_eh.h (revision 350360)

	Property changes on: head/contrib/libcxxrt/dwarf_eh.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/dynamic_cast.cc
	===================================================================
	--- head/contrib/libcxxrt/dynamic_cast.cc (revision 350359)
	+++ head/contrib/libcxxrt/dynamic_cast.cc (revision 350360)

	Property changes on: head/contrib/libcxxrt/dynamic_cast.cc
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/exception.cc
	===================================================================
	--- head/contrib/libcxxrt/exception.cc (revision 350359)
	+++ head/contrib/libcxxrt/exception.cc (revision 350360)
	@@ -1,1568 +1,1591 @@
	/*
	* Copyright 2010-2011 PathScale, Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
	* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <stdlib.h>
	#include <dlfcn.h>
	#include <stdio.h>
	#include <string.h>
	#include <stdint.h>
	#include <pthread.h>
	#include "typeinfo.h"
	#include "dwarf_eh.h"
	#include "atomic.h"
	#include "cxxabi.h"

	#pragma weak pthread_key_create
	#pragma weak pthread_setspecific
	#pragma weak pthread_getspecific
	#pragma weak pthread_once
	#ifdef LIBCXXRT_WEAK_LOCKS
	#pragma weak pthread_mutex_lock
	#define pthread_mutex_lock(mtx) do {\
	if (pthread_mutex_lock) pthread_mutex_lock(mtx);\
	} while(0)
	#pragma weak pthread_mutex_unlock
	#define pthread_mutex_unlock(mtx) do {\
	if (pthread_mutex_unlock) pthread_mutex_unlock(mtx);\
	} while(0)
	#pragma weak pthread_cond_signal
	#define pthread_cond_signal(cv) do {\
	if (pthread_cond_signal) pthread_cond_signal(cv);\
	} while(0)
	#pragma weak pthread_cond_wait
	#define pthread_cond_wait(cv, mtx) do {\
	if (pthread_cond_wait) pthread_cond_wait(cv, mtx);\
	} while(0)
	#endif

	using namespace ABI_NAMESPACE;

	/**
	* Saves the result of the landing pad that we have found. For ARM, this is
	* stored in the generic unwind structure, while on other platforms it is
	* stored in the C++ exception.
	*/
	static void saveLandingPad(struct _Unwind_Context *context,
	struct _Unwind_Exception *ucb,
	struct __cxa_exception *ex,
	int selector,
	dw_eh_ptr_t landingPad)
	{
	#if defined(__arm__) && !defined(__ARM_DWARF_EH__)
	// On ARM, we store the saved exception in the generic part of the structure
	ucb->barrier_cache.sp = _Unwind_GetGR(context, 13);
	ucb->barrier_cache.bitpattern[1] = static_cast<uint32_t>(selector);
	ucb->barrier_cache.bitpattern[3] = reinterpret_cast<uint32_t>(landingPad);
	#endif
	// Cache the results for the phase 2 unwind, if we found a handler
	// and this is not a foreign exception.
	if (ex)
	{
	ex->handlerSwitchValue = selector;
	ex->catchTemp = landingPad;
	}
	}

	/**
	* Loads the saved landing pad. Returns 1 on success, 0 on failure.
	*/
	static int loadLandingPad(struct _Unwind_Context *context,
	struct _Unwind_Exception *ucb,
	struct __cxa_exception *ex,
	unsigned long *selector,
	dw_eh_ptr_t *landingPad)
	{
	#if defined(__arm__) && !defined(__ARM_DWARF_EH__)
	*selector = ucb->barrier_cache.bitpattern[1];
	*landingPad = reinterpret_cast<dw_eh_ptr_t>(ucb->barrier_cache.bitpattern[3]);
	return 1;
	#else
	if (ex)
	{
	*selector = ex->handlerSwitchValue;
	*landingPad = reinterpret_cast<dw_eh_ptr_t>(ex->catchTemp);
	return 0;
	}
	return 0;
	#endif
	}

	static inline _Unwind_Reason_Code continueUnwinding(struct _Unwind_Exception *ex,
	struct _Unwind_Context *context)
	{
	#if defined(__arm__) && !defined(__ARM_DWARF_EH__)
	if (__gnu_unwind_frame(ex, context) != _URC_OK) { return _URC_FAILURE; }
	#endif
	return _URC_CONTINUE_UNWIND;
	}


	extern "C" void __cxa_free_exception(void *thrown_exception);
	extern "C" void __cxa_free_dependent_exception(void *thrown_exception);
	extern "C" void* __dynamic_cast(const void *sub,
	const __class_type_info *src,
	const __class_type_info *dst,
	ptrdiff_t src2dst_offset);

	/**
	* The type of a handler that has been found.
	*/
	typedef enum
	{
	/** No handler. */
	handler_none,
	/**
	* A cleanup - the exception will propagate through this frame, but code
	* must be run when this happens.
	*/
	handler_cleanup,
	/**
	* A catch statement. The exception will not propagate past this frame
	* (without an explicit rethrow).
	*/
	handler_catch
	} handler_type;

	/**
	* Per-thread info required by the runtime. We store a single structure
	* pointer in thread-local storage, because this tends to be a scarce resource
	* and it's impolite to steal all of it and not leave any for the rest of the
	* program.
	*
	* Instances of this structure are allocated lazily - at most one per thread -
	* and are destroyed on thread termination.
	*/
	struct __cxa_thread_info
	{
	/** The termination handler for this thread. */
	terminate_handler terminateHandler;
	/** The unexpected exception handler for this thread. */
	unexpected_handler unexpectedHandler;
	/**
	* The number of emergency buffers held by this thread. This is 0 in
	* normal operation - the emergency buffers are only used when malloc()
	* fails to return memory for allocating an exception. Threads are not
	* permitted to hold more than 4 emergency buffers (as per recommendation
	* in ABI spec [3.3.1]).
	*/
	int emergencyBuffersHeld;
	/**
	* The exception currently running in a cleanup.
	*/
	_Unwind_Exception *currentCleanup;
	/**
	* Our state with respect to foreign exceptions. Usually none, set to
	* caught if we have just caught an exception and rethrown if we are
	* rethrowing it.
	*/
	enum
	{
	none,
	caught,
	rethrown
	} foreign_exception_state;
	/**
	* The public part of this structure, accessible from outside of this
	* module.
	*/
	__cxa_eh_globals globals;
	};
	/**
	* Dependent exception. This
	*/
	struct __cxa_dependent_exception
	{
	#if __LP64__
	void *primaryException;
	#endif
	std::type_info *exceptionType;
	void (exceptionDestructor) (void );
	unexpected_handler unexpectedHandler;
	terminate_handler terminateHandler;
	__cxa_exception *nextException;
	int handlerCount;
	#if defined(__arm__) && !defined(__ARM_DWARF_EH__)
	_Unwind_Exception *nextCleanup;
	int cleanupCount;
	#endif
	int handlerSwitchValue;
	const char *actionRecord;
	const char *languageSpecificData;
	void *catchTemp;
	void *adjustedPtr;
	#if !__LP64__
	void *primaryException;
	#endif
	_Unwind_Exception unwindHeader;
	};


	namespace std
	{
	void unexpected();
	class exception
	{
	public:
	virtual ~exception() throw();
	virtual const char* what() const throw();
	};

	}

	/**
	* Class of exceptions to distinguish between this and other exception types.
	*
	* The first four characters are the vendor ID. Currently, we use GNUC,
	* because we aim for ABI-compatibility with the GNU implementation, and
	* various checks may test for equality of the class, which is incorrect.
	*/
	static const uint64_t exception_class =
	EXCEPTION_CLASS('G', 'N', 'U', 'C', 'C', '+', '+', '\0');
	/**
	* Class used for dependent exceptions.
	*/
	static const uint64_t dependent_exception_class =
	EXCEPTION_CLASS('G', 'N', 'U', 'C', 'C', '+', '+', '\x01');
	/**
	* The low four bytes of the exception class, indicating that we conform to the
	* Itanium C++ ABI. This is currently unused, but should be used in the future
	* if we change our exception class, to allow this library and libsupc++ to be
	* linked to the same executable and both to interoperate.
	*/
	static const uint32_t abi_exception_class =
	GENERIC_EXCEPTION_CLASS('C', '+', '+', '\0');

	static bool isCXXException(uint64_t cls)
	{
	return (cls == exception_class) \|\| (cls == dependent_exception_class);
	}

	static bool isDependentException(uint64_t cls)
	{
	return cls == dependent_exception_class;
	}

	static __cxa_exception exceptionFromPointer(void ex)
	{
	return reinterpret_cast<__cxa_exception>(static_cast<char>(ex) -
	offsetof(struct __cxa_exception, unwindHeader));
	}
	static __cxa_exception realExceptionFromException(__cxa_exception ex)
	{
	if (!isDependentException(ex->unwindHeader.exception_class)) { return ex; }
	return reinterpret_cast<__cxa_exception>((reinterpret_cast<__cxa_dependent_exception>(ex))->primaryException)-1;
	}


	namespace std
	{
	// Forward declaration of standard library terminate() function used to
	// abort execution.
	void terminate(void);
	}

	using namespace ABI_NAMESPACE;



	/** The global termination handler. */
	static terminate_handler terminateHandler = abort;
	/** The global unexpected exception handler. */
	static unexpected_handler unexpectedHandler = std::terminate;

	/** Key used for thread-local data. */
	static pthread_key_t eh_key;


	/**
	* Cleanup function, allowing foreign exception handlers to correctly destroy
	* this exception if they catch it.
	*/
	static void exception_cleanup(_Unwind_Reason_Code reason,
	struct _Unwind_Exception *ex)
	{
	// Exception layout:
	// [__cxa_exception [_Unwind_Exception]] [exception object]
	//
	// __cxa_free_exception expects a pointer to the exception object
	__cxa_free_exception(static_cast<void*>(ex + 1));
	}
	static void dependent_exception_cleanup(_Unwind_Reason_Code reason,
	struct _Unwind_Exception *ex)
	{

	__cxa_free_dependent_exception(static_cast<void*>(ex + 1));
	}

	/**
	* Recursively walk a list of exceptions and delete them all in post-order.
	*/
	static void free_exception_list(__cxa_exception *ex)
	{
	if (0 != ex->nextException)
	{
	free_exception_list(ex->nextException);
	}
	// __cxa_free_exception() expects to be passed the thrown object, which
	// immediately follows the exception, not the exception itself
	__cxa_free_exception(ex+1);
	}

	/**
	* Cleanup function called when a thread exists to make certain that all of the
	* per-thread data is deleted.
	*/
	static void thread_cleanup(void* thread_info)
	{
	__cxa_thread_info info = static_cast<__cxa_thread_info>(thread_info);
	if (info->globals.caughtExceptions)
	{
	// If this is a foreign exception, ask it to clean itself up.
	if (info->foreign_exception_state != __cxa_thread_info::none)
	{
	_Unwind_Exception e = reinterpret_cast<_Unwind_Exception>(info->globals.caughtExceptions);
	if (e->exception_cleanup)
	e->exception_cleanup(_URC_FOREIGN_EXCEPTION_CAUGHT, e);
	}
	else
	{
	free_exception_list(info->globals.caughtExceptions);
	}
	}
	free(thread_info);
	}


	/**
	* Once control used to protect the key creation.
	*/
	static pthread_once_t once_control = PTHREAD_ONCE_INIT;

	/**
	* We may not be linked against a full pthread implementation. If we're not,
	* then we need to fake the thread-local storage by storing 'thread-local'
	* things in a global.
	*/
	static bool fakeTLS;
	/**
	* Thread-local storage for a single-threaded program.
	*/
	static __cxa_thread_info singleThreadInfo;
	/**
	* Initialise eh_key.
	*/
	static void init_key(void)
	{
	if ((0 == pthread_key_create) \|\|
	(0 == pthread_setspecific) \|\|
	(0 == pthread_getspecific))
	{
	fakeTLS = true;
	return;
	}
	pthread_key_create(&eh_key, thread_cleanup);
	pthread_setspecific(eh_key, reinterpret_cast<void *>(0x42));
	fakeTLS = (pthread_getspecific(eh_key) != reinterpret_cast<void *>(0x42));
	pthread_setspecific(eh_key, 0);
	}

	/**
	* Returns the thread info structure, creating it if it is not already created.
	*/
	static __cxa_thread_info *thread_info()
	{
	if ((0 == pthread_once) \|\| pthread_once(&once_control, init_key))
	{
	fakeTLS = true;
	}
	if (fakeTLS) { return &singleThreadInfo; }
	__cxa_thread_info info = static_cast<__cxa_thread_info>(pthread_getspecific(eh_key));
	if (0 == info)
	{
	info = static_cast<__cxa_thread_info*>(calloc(1, sizeof(__cxa_thread_info)));
	pthread_setspecific(eh_key, info);
	}
	return info;
	}
	/**
	* Fast version of thread_info(). May fail if thread_info() is not called on
	* this thread at least once already.
	*/
	static __cxa_thread_info *thread_info_fast()
	{
	if (fakeTLS) { return &singleThreadInfo; }
	return static_cast<__cxa_thread_info*>(pthread_getspecific(eh_key));
	}
	/**
	* ABI function returning the __cxa_eh_globals structure.
	*/
	extern "C" __cxa_eh_globals *ABI_NAMESPACE::__cxa_get_globals(void)
	{
	return &(thread_info()->globals);
	}
	/**
	* Version of __cxa_get_globals() assuming that __cxa_get_globals() has already
	* been called at least once by this thread.
	*/
	extern "C" __cxa_eh_globals *ABI_NAMESPACE::__cxa_get_globals_fast(void)
	{
	return &(thread_info_fast()->globals);
	}

	/**
	* An emergency allocation reserved for when malloc fails. This is treated as
	* 16 buffers of 1KB each.
	*/
	static char emergency_buffer[16384];
	/**
	* Flag indicating whether each buffer is allocated.
	*/
	static bool buffer_allocated[16];
	/**
	* Lock used to protect emergency allocation.
	*/
	static pthread_mutex_t emergency_malloc_lock = PTHREAD_MUTEX_INITIALIZER;
	/**
	* Condition variable used to wait when two threads are both trying to use the
	* emergency malloc() buffer at once.
	*/
	static pthread_cond_t emergency_malloc_wait = PTHREAD_COND_INITIALIZER;

	/**
	* Allocates size bytes from the emergency allocation mechanism, if possible.
	* This function will fail if size is over 1KB or if this thread already has 4
	* emergency buffers. If all emergency buffers are allocated, it will sleep
	* until one becomes available.
	*/
	static char *emergency_malloc(size_t size)
	{
	if (size > 1024) { return 0; }

	__cxa_thread_info *info = thread_info();
	// Only 4 emergency buffers allowed per thread!
	if (info->emergencyBuffersHeld > 3) { return 0; }

	pthread_mutex_lock(&emergency_malloc_lock);
	int buffer = -1;
	while (buffer < 0)
	{
	// While we were sleeping on the lock, another thread might have free'd
	// enough memory for us to use, so try the allocation again - no point
	// using the emergency buffer if there is some real memory that we can
	// use...
	void *m = calloc(1, size);
	if (0 != m)
	{
	pthread_mutex_unlock(&emergency_malloc_lock);
	return static_cast<char*>(m);
	}
	for (int i=0 ; i<16 ; i++)
	{
	if (!buffer_allocated[i])
	{
	buffer = i;
	buffer_allocated[i] = true;
	break;
	}
	}
	// If there still isn't a buffer available, then sleep on the condition
	// variable. This will be signalled when another thread releases one
	// of the emergency buffers.
	if (buffer < 0)
	{
	pthread_cond_wait(&emergency_malloc_wait, &emergency_malloc_lock);
	}
	}
	pthread_mutex_unlock(&emergency_malloc_lock);
	info->emergencyBuffersHeld++;
	return emergency_buffer + (1024 * buffer);
	}

	/**
	* Frees a buffer returned by emergency_malloc().
	*
	* Note: Neither this nor emergency_malloc() is particularly efficient. This
	* should not matter, because neither will be called in normal operation - they
	* are only used when the program runs out of memory, which should not happen
	* often.
	*/
	static void emergency_malloc_free(char *ptr)
	{
	int buffer = -1;
	// Find the buffer corresponding to this pointer.
	for (int i=0 ; i<16 ; i++)
	{
	if (ptr == static_cast<void>(emergency_buffer + (1024 i)))
	{
	buffer = i;
	break;
	}
	}
	assert(buffer >= 0 &&
	"Trying to free something that is not an emergency buffer!");
	// emergency_malloc() is expected to return 0-initialized data. We don't
	// zero the buffer when allocating it, because the static buffers will
	// begin life containing 0 values.
	memset(ptr, 0, 1024);
	// Signal the condition variable to wake up any threads that are blocking
	// waiting for some space in the emergency buffer
	pthread_mutex_lock(&emergency_malloc_lock);
	// In theory, we don't need to do this with the lock held. In practice,
	// our array of bools will probably be updated using 32-bit or 64-bit
	// memory operations, so this update may clobber adjacent values.
	buffer_allocated[buffer] = false;
	pthread_cond_signal(&emergency_malloc_wait);
	pthread_mutex_unlock(&emergency_malloc_lock);
	}

	static char *alloc_or_die(size_t size)
	{
	char buffer = static_cast<char>(calloc(1, size));

	// If calloc() doesn't want to give us any memory, try using an emergency
	// buffer.
	if (0 == buffer)
	{
	buffer = emergency_malloc(size);
	// This is only reached if the allocation is greater than 1KB, and
	// anyone throwing objects that big really should know better.
	if (0 == buffer)
	{
	fprintf(stderr, "Out of memory attempting to allocate exception\n");
	std::terminate();
	}
	}
	return buffer;
	}
	static void free_exception(char *e)
	{
	// If this allocation is within the address range of the emergency buffer,
	// don't call free() because it was not allocated with malloc()
	if ((e >= emergency_buffer) &&
	(e < (emergency_buffer + sizeof(emergency_buffer))))
	{
	emergency_malloc_free(e);
	}
	else
	{
	free(e);
	}
	}

	#ifdef __LP64__
	/**
	* There's an ABI bug in __cxa_exception: unwindHeader requires 16-byte
	* alignment but it was broken by the addition of the referenceCount.
	* The unwindHeader is at offset 0x58 in __cxa_exception. In order to keep
	* compatibility with consumers of the broken __cxa_exception, explicitly add
	* padding on allocation (and account for it on free).
	*/
	static const int exception_alignment_padding = 8;
	#else
	static const int exception_alignment_padding = 0;
	#endif

	/**
	* Allocates an exception structure. Returns a pointer to the space that can
	* be used to store an object of thrown_size bytes. This function will use an
	* emergency buffer if malloc() fails, and may block if there are no such
	* buffers available.
	*/
	extern "C" void *__cxa_allocate_exception(size_t thrown_size)
	{
	size_t size = exception_alignment_padding + sizeof(__cxa_exception) +
	thrown_size;
	char *buffer = alloc_or_die(size);
	return buffer + exception_alignment_padding + sizeof(__cxa_exception);
	}

	extern "C" void *__cxa_allocate_dependent_exception(void)
	{
	size_t size = exception_alignment_padding +
	sizeof(__cxa_dependent_exception);
	char *buffer = alloc_or_die(size);
	return buffer + exception_alignment_padding +
	sizeof(__cxa_dependent_exception);
	}

	/**
	* __cxa_free_exception() is called when an exception was thrown in between
	* calling __cxa_allocate_exception() and actually throwing the exception.
	* This happens when the object's copy constructor throws an exception.
	*
	* In this implementation, it is also called by __cxa_end_catch() and during
	* thread cleanup.
	*/
	extern "C" void __cxa_free_exception(void *thrown_exception)
	{
	__cxa_exception ex = reinterpret_cast<__cxa_exception>(thrown_exception) - 1;
	// Free the object that was thrown, calling its destructor
	if (0 != ex->exceptionDestructor)
	{
	try
	{
	ex->exceptionDestructor(thrown_exception);
	}
	catch(...)
	{
	// FIXME: Check that this is really what the spec says to do.
	std::terminate();
	}
	}

	free_exception(reinterpret_cast<char*>(ex) -
	exception_alignment_padding);
	}

	static void releaseException(__cxa_exception *exception)
	{
	if (isDependentException(exception->unwindHeader.exception_class))
	{
	__cxa_free_dependent_exception(exception+1);
	return;
	}
	if (__sync_sub_and_fetch(&exception->referenceCount, 1) == 0)
	{
	// __cxa_free_exception() expects to be passed the thrown object,
	// which immediately follows the exception, not the exception
	// itself
	__cxa_free_exception(exception+1);
	}
	}

	void __cxa_free_dependent_exception(void *thrown_exception)
	{
	__cxa_dependent_exception ex = reinterpret_cast<__cxa_dependent_exception>(thrown_exception) - 1;
	assert(isDependentException(ex->unwindHeader.exception_class));
	if (ex->primaryException)
	{
	releaseException(realExceptionFromException(reinterpret_cast<__cxa_exception*>(ex)));
	}
	free_exception(reinterpret_cast<char*>(ex) -
	exception_alignment_padding);
	}

	/**
	* Callback function used with _Unwind_Backtrace().
	*
	* Prints a stack trace. Used only for debugging help.
	*
	* Note: As of FreeBSD 8.1, dladd() still doesn't work properly, so this only
	* correctly prints function names from public, relocatable, symbols.
	*/
	static _Unwind_Reason_Code trace(struct _Unwind_Context context, void c)
	{
	Dl_info myinfo;
	int mylookup =
	dladdr(reinterpret_cast<void *>(__cxa_current_exception_type), &myinfo);
	void ip = reinterpret_cast<void>(_Unwind_GetIP(context));
	Dl_info info;
	if (dladdr(ip, &info) != 0)
	{
	if (mylookup == 0 \|\| strcmp(info.dli_fname, myinfo.dli_fname) != 0)
	{
	printf("%p:%s() in %s\n", ip, info.dli_sname, info.dli_fname);
	}
	}
	return _URC_CONTINUE_UNWIND;
	}

	/**
	* Report a failure that occurred when attempting to throw an exception.
	*
	* If the failure happened by falling off the end of the stack without finding
	* a handler, prints a back trace before aborting.
	*/
	#if __GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
	extern "C" void __cxa_begin_catch(void e) throw();
	#else
	extern "C" void __cxa_begin_catch(void e);
	#endif
	static void report_failure(_Unwind_Reason_Code err, __cxa_exception *thrown_exception)
	{
	switch (err)
	{
	default: break;
	case _URC_FATAL_PHASE1_ERROR:
	fprintf(stderr, "Fatal error during phase 1 unwinding\n");
	break;
	#if !defined(__arm__) \|\| defined(__ARM_DWARF_EH__)
	case _URC_FATAL_PHASE2_ERROR:
	fprintf(stderr, "Fatal error during phase 2 unwinding\n");
	break;
	#endif
	case _URC_END_OF_STACK:
	__cxa_begin_catch (&(thrown_exception->unwindHeader));
	std::terminate();
	fprintf(stderr, "Terminating due to uncaught exception %p",
	static_cast<void*>(thrown_exception));
	thrown_exception = realExceptionFromException(thrown_exception);
	static const __class_type_info *e_ti =
	static_cast<const __class_type_info*>(&typeid(std::exception));
	const __class_type_info *throw_ti =
	dynamic_cast<const __class_type_info*>(thrown_exception->exceptionType);
	if (throw_ti)
	{
	std::exception *e =
	static_cast<std::exception>(e_ti->cast_to(static_cast<void>(thrown_exception+1),
	throw_ti));
	if (e)
	{
	fprintf(stderr, " '%s'", e->what());
	}
	}

	size_t bufferSize = 128;
	char demangled = static_cast<char>(malloc(bufferSize));
	const char *mangled = thrown_exception->exceptionType->name();
	int status;
	demangled = __cxa_demangle(mangled, demangled, &bufferSize, &status);
	fprintf(stderr, " of type %s\n",
	status == 0 ? demangled : mangled);
	if (status == 0) { free(demangled); }
	// Print a back trace if no handler is found.
	// TODO: Make this optional
	#ifndef __arm__
	_Unwind_Backtrace(trace, 0);
	#endif

	// Just abort. No need to call std::terminate for the second time
	abort();
	break;
	}
	std::terminate();
	}

	static void throw_exception(__cxa_exception *ex)
	{
	__cxa_thread_info *info = thread_info();
	ex->unexpectedHandler = info->unexpectedHandler;
	if (0 == ex->unexpectedHandler)
	{
	ex->unexpectedHandler = unexpectedHandler;
	}
	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);
	}


	/**
	* ABI function for throwing an exception. Takes the object to be thrown (the
	* pointer returned by __cxa_allocate_exception()), the type info for the
	* pointee, and the destructor (if there is one) as arguments.
	*/
	extern "C" void __cxa_throw(void *thrown_exception,
	std::type_info *tinfo,
	void(dest)(void))
	{
	__cxa_exception ex = reinterpret_cast<__cxa_exception>(thrown_exception) - 1;

	ex->referenceCount = 1;
	ex->exceptionType = tinfo;

	ex->exceptionDestructor = dest;

	ex->unwindHeader.exception_class = exception_class;
	ex->unwindHeader.exception_cleanup = exception_cleanup;

	throw_exception(ex);
	}

	extern "C" void __cxa_rethrow_primary_exception(void* thrown_exception)
	{
	if (NULL == thrown_exception) { return; }

	__cxa_exception *original = exceptionFromPointer(thrown_exception);
	__cxa_dependent_exception ex = reinterpret_cast<__cxa_dependent_exception>(__cxa_allocate_dependent_exception())-1;

	ex->primaryException = thrown_exception;
	__cxa_increment_exception_refcount(thrown_exception);

	ex->exceptionType = original->exceptionType;
	ex->unwindHeader.exception_class = dependent_exception_class;
	ex->unwindHeader.exception_cleanup = dependent_exception_cleanup;

	throw_exception(reinterpret_cast<__cxa_exception*>(ex));
	}

	extern "C" void *__cxa_current_primary_exception(void)
	{
	__cxa_eh_globals* globals = __cxa_get_globals();
	__cxa_exception *ex = globals->caughtExceptions;

	if (0 == ex) { return NULL; }
	ex = realExceptionFromException(ex);
	__sync_fetch_and_add(&ex->referenceCount, 1);
	return ex + 1;
	}

	extern "C" void __cxa_increment_exception_refcount(void* thrown_exception)
	{
	if (NULL == thrown_exception) { return; }
	__cxa_exception ex = static_cast<__cxa_exception>(thrown_exception) - 1;
	if (isDependentException(ex->unwindHeader.exception_class)) { return; }
	__sync_fetch_and_add(&ex->referenceCount, 1);
	}
	extern "C" void __cxa_decrement_exception_refcount(void* thrown_exception)
	{
	if (NULL == thrown_exception) { return; }
	__cxa_exception ex = static_cast<__cxa_exception>(thrown_exception) - 1;
	releaseException(ex);
	}

	/**
	* ABI function. Rethrows the current exception. Does not remove the
	* exception from the stack or decrement its handler count - the compiler is
	* expected to set the landing pad for this function to the end of the catch
	* block, and then call _Unwind_Resume() to continue unwinding once
	* __cxa_end_catch() has been called and any cleanup code has been run.
	*/
	extern "C" void __cxa_rethrow()
	{
	__cxa_thread_info *ti = thread_info();
	__cxa_eh_globals *globals = &ti->globals;
	// Note: We don't remove this from the caught list here, because
	// __cxa_end_catch will be called when we unwind out of the try block. We
	// could probably make this faster by providing an alternative rethrow
	// function and ensuring that all cleanup code is run before calling it, so
	// we can skip the top stack frame when unwinding.
	__cxa_exception *ex = globals->caughtExceptions;

	if (0 == ex)
	{
	fprintf(stderr,
	"Attempting to rethrow an exception that doesn't exist!\n");
	std::terminate();
	}

	if (ti->foreign_exception_state != __cxa_thread_info::none)
	{
	ti->foreign_exception_state = __cxa_thread_info::rethrown;
	_Unwind_Exception e = reinterpret_cast<_Unwind_Exception>(ex);
	_Unwind_Reason_Code err = _Unwind_Resume_or_Rethrow(e);
	report_failure(err, ex);
	return;
	}

	assert(ex->handlerCount > 0 && "Rethrowing uncaught exception!");

	+ // `globals->uncaughtExceptions` was decremented by `__cxa_begin_catch`.
	+ // It's normally incremented by `throw_exception`, but this path invokes
	+ // `_Unwind_Resume_or_Rethrow` directly to rethrow the exception.
	+ // This path is only reachable if we're rethrowing a C++ exception -
	+ // foreign exceptions don't adjust any of this state.
	+ globals->uncaughtExceptions++;
	+
	// ex->handlerCount will be decremented in __cxa_end_catch in enclosing
	// catch block

	// Make handler count negative. This will tell __cxa_end_catch that
	// exception was rethrown and exception object should not be destroyed
	// when handler count become zero
	ex->handlerCount = -ex->handlerCount;

	// Continue unwinding the stack with this exception. This should unwind to
	// the place in the caller where __cxa_end_catch() is called. The caller
	// will then run cleanup code and bounce the exception back with
	// _Unwind_Resume().
	_Unwind_Reason_Code err = _Unwind_Resume_or_Rethrow(&ex->unwindHeader);
	report_failure(err, ex);
	}

	/**
	* Returns the type_info object corresponding to the filter.
	*/
	static std::type_info get_type_info_entry(_Unwind_Context context,
	dwarf_eh_lsda *lsda,
	int filter)
	{
	// Get the address of the record in the table.
	dw_eh_ptr_t record = lsda->type_table -
	dwarf_size_of_fixed_size_field(lsda->type_table_encoding)*filter;
	//record -= 4;
	dw_eh_ptr_t start = record;
	// Read the value, but it's probably an indirect reference...
	int64_t offset = read_value(lsda->type_table_encoding, &record);

	// (If the entry is 0, don't try to dereference it. That would be bad.)
	if (offset == 0) { return 0; }

	// ...so we need to resolve it
	return reinterpret_cast<std::type_info*>(resolve_indirect_value(context,
	lsda->type_table_encoding, offset, start));
	}



	/**
	* Checks the type signature found in a handler against the type of the thrown
	* object. If ex is 0 then it is assumed to be a foreign exception and only
	* matches cleanups.
	*/
	static bool check_type_signature(__cxa_exception *ex,
	const std::type_info *type,
	void *&adjustedPtr)
	{
	void exception_ptr = static_cast<void>(ex+1);
	const std::type_info *ex_type = ex ? ex->exceptionType : 0;

	bool is_ptr = ex ? ex_type->__is_pointer_p() : false;
	if (is_ptr)
	{
	exception_ptr = static_cast<void*>(exception_ptr);
	}
	// Always match a catchall, even with a foreign exception
	//
	// Note: A 0 here is a catchall, not a cleanup, so we return true to
	// indicate that we found a catch.
	if (0 == type)
	{
	if (ex)
	{
	adjustedPtr = exception_ptr;
	}
	return true;
	}

	if (0 == ex) { return false; }

	// If the types are the same, no casting is needed.
	if (type == ex_type)
	{
	adjustedPtr = exception_ptr;
	return true;
	}


	if (type->__do_catch(ex_type, &exception_ptr, 1))
	{
	adjustedPtr = exception_ptr;
	return true;
	}

	return false;
	}
	/**
	* Checks whether the exception matches the type specifiers in this action
	* record. If the exception only matches cleanups, then this returns false.
	* If it matches a catch (including a catchall) then it returns true.
	*
	* The selector argument is used to return the selector that is passed in the
	* second exception register when installing the context.
	*/
	static handler_type check_action_record(_Unwind_Context *context,
	dwarf_eh_lsda *lsda,
	dw_eh_ptr_t action_record,
	__cxa_exception *ex,
	unsigned long *selector,
	void *&adjustedPtr)
	{
	if (!action_record) { return handler_cleanup; }
	handler_type found = handler_none;
	while (action_record)
	{
	int filter = read_sleb128(&action_record);
	dw_eh_ptr_t action_record_offset_base = action_record;
	int displacement = read_sleb128(&action_record);
	action_record = displacement ?
	action_record_offset_base + displacement : 0;
	// We only check handler types for C++ exceptions - foreign exceptions
	// are only allowed for cleanups and catchalls.
	if (filter > 0)
	{
	std::type_info *handler_type = get_type_info_entry(context, lsda, filter);
	if (check_type_signature(ex, handler_type, adjustedPtr))
	{
	*selector = filter;
	return handler_catch;
	}
	}
	else if (filter < 0 && 0 != ex)
	{
	bool matched = false;
	*selector = filter;
	#if defined(__arm__) && !defined(__ARM_DWARF_EH__)
	filter++;
	std::type_info *handler_type = get_type_info_entry(context, lsda, filter--);
	while (handler_type)
	{
	if (check_type_signature(ex, handler_type, adjustedPtr))
	{
	matched = true;
	break;
	}
	handler_type = get_type_info_entry(context, lsda, filter--);
	}
	#else
	unsigned char type_index = reinterpret_cast<unsigned char>(lsda->type_table) - filter - 1;
	while (*type_index)
	{
	std::type_info handler_type = get_type_info_entry(context, lsda, (type_index++));
	// If the exception spec matches a permitted throw type for
	// this function, don't report a handler - we are allowed to
	// propagate this exception out.
	if (check_type_signature(ex, handler_type, adjustedPtr))
	{
	matched = true;
	break;
	}
	}
	#endif
	if (matched) { continue; }
	// If we don't find an allowed exception spec, we need to install
	// the context for this action. The landing pad will then call the
	// unexpected exception function. Treat this as a catch
	return handler_catch;
	}
	else if (filter == 0)
	{
	*selector = filter;
	found = handler_cleanup;
	}
	}
	return found;
	}

	static void pushCleanupException(_Unwind_Exception *exceptionObject,
	__cxa_exception *ex)
	{
	#if defined(__arm__) && !defined(__ARM_DWARF_EH__)
	__cxa_thread_info *info = thread_info_fast();
	if (ex)
	{
	ex->cleanupCount++;
	if (ex->cleanupCount > 1)
	{
	assert(exceptionObject == info->currentCleanup);
	return;
	}
	ex->nextCleanup = info->currentCleanup;
	}
	info->currentCleanup = exceptionObject;
	#endif
	}

	/**
	* The exception personality function. This is referenced in the unwinding
	* DWARF metadata and is called by the unwind library for each C++ stack frame
	* containing catch or cleanup code.
	*/
	extern "C"
	BEGIN_PERSONALITY_FUNCTION(__gxx_personality_v0)
	// This personality function is for version 1 of the ABI. If you use it
	// with a future version of the ABI, it won't know what to do, so it
	// reports a fatal error and give up before it breaks anything.
	if (1 != version)
	{
	return _URC_FATAL_PHASE1_ERROR;
	}
	__cxa_exception *ex = 0;
	__cxa_exception *realEx = 0;

	// If this exception is throw by something else then we can't make any
	// assumptions about its layout beyond the fields declared in
	// _Unwind_Exception.
	bool foreignException = !isCXXException(exceptionClass);

	// If this isn't a foreign exception, then we have a C++ exception structure
	if (!foreignException)
	{
	ex = exceptionFromPointer(exceptionObject);
	realEx = realExceptionFromException(ex);
	}

	#if defined(__arm__) && !defined(__ARM_DWARF_EH__)
	unsigned char *lsda_addr =
	static_cast<unsigned char*>(_Unwind_GetLanguageSpecificData(context));
	#else
	unsigned char *lsda_addr =
	reinterpret_cast<unsigned char*>(static_cast<uintptr_t>(_Unwind_GetLanguageSpecificData(context)));
	#endif

	// No LSDA implies no landing pads - try the next frame
	if (0 == lsda_addr) { return continueUnwinding(exceptionObject, context); }

	// These two variables define how the exception will be handled.
	dwarf_eh_action action = {0};
	unsigned long selector = 0;

	// During the search phase, we do a complete lookup. If we return
	// _URC_HANDLER_FOUND, then the phase 2 unwind will call this function with
	// a _UA_HANDLER_FRAME action, telling us to install the handler frame. If
	// we return _URC_CONTINUE_UNWIND, we may be called again later with a
	// _UA_CLEANUP_PHASE action for this frame.
	//
	// The point of the two-stage unwind allows us to entirely avoid any stack
	// unwinding if there is no handler. If there are just cleanups found,
	// then we can just panic call an abort function.
	//
	// Matching a handler is much more expensive than matching a cleanup,
	// because we don't need to bother doing type comparisons (or looking at
	// the type table at all) for a cleanup. This means that there is no need
	// to cache the result of finding a cleanup, because it's (quite) quick to
	// look it up again from the action table.
	if (actions & _UA_SEARCH_PHASE)
	{
	struct dwarf_eh_lsda lsda = parse_lsda(context, lsda_addr);

	if (!dwarf_eh_find_callsite(context, &lsda, &action))
	{
	// EH range not found. This happens if exception is thrown and not
	// caught inside a cleanup (destructor). We should call
	// terminate() in this case. The catchTemp (landing pad) field of
	// exception object will contain null when personality function is
	// called with _UA_HANDLER_FRAME action for phase 2 unwinding.
	return _URC_HANDLER_FOUND;
	}

	handler_type found_handler = check_action_record(context, &lsda,
	action.action_record, realEx, &selector, ex->adjustedPtr);
	// If there's no action record, we've only found a cleanup, so keep
	// searching for something real
	if (found_handler == handler_catch)
	{
	// Cache the results for the phase 2 unwind, if we found a handler
	// and this is not a foreign exception.
	if (ex)
	{
	saveLandingPad(context, exceptionObject, ex, selector, action.landing_pad);
	ex->languageSpecificData = reinterpret_cast<const char*>(lsda_addr);
	ex->actionRecord = reinterpret_cast<const char*>(action.action_record);
	// ex->adjustedPtr is set when finding the action record.
	}
	return _URC_HANDLER_FOUND;
	}
	return continueUnwinding(exceptionObject, context);
	}


	// If this is a foreign exception, we didn't have anywhere to cache the
	// lookup stuff, so we need to do it again. If this is either a forced
	// unwind, a foreign exception, or a cleanup, then we just install the
	// context for a cleanup.
	if (!(actions & _UA_HANDLER_FRAME))
	{
	// cleanup
	struct dwarf_eh_lsda lsda = parse_lsda(context, lsda_addr);
	dwarf_eh_find_callsite(context, &lsda, &action);
	if (0 == action.landing_pad) { return continueUnwinding(exceptionObject, context); }
	handler_type found_handler = check_action_record(context, &lsda,
	action.action_record, realEx, &selector, ex->adjustedPtr);
	// Ignore handlers this time.
	if (found_handler != handler_cleanup) { return continueUnwinding(exceptionObject, context); }
	pushCleanupException(exceptionObject, ex);
	}
	else if (foreignException)
	{
	struct dwarf_eh_lsda lsda = parse_lsda(context, lsda_addr);
	dwarf_eh_find_callsite(context, &lsda, &action);
	check_action_record(context, &lsda, action.action_record, realEx,
	&selector, ex->adjustedPtr);
	}
	else if (ex->catchTemp == 0)
	{
	// Uncaught exception in cleanup, calling terminate
	std::terminate();
	}
	else
	{
	// Restore the saved info if we saved some last time.
	loadLandingPad(context, exceptionObject, ex, &selector, &action.landing_pad);
	ex->catchTemp = 0;
	ex->handlerSwitchValue = 0;
	}


	_Unwind_SetIP(context, reinterpret_cast<unsigned long>(action.landing_pad));
	_Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
	reinterpret_cast<unsigned long>(exceptionObject));
	_Unwind_SetGR(context, __builtin_eh_return_data_regno(1), selector);

	return _URC_INSTALL_CONTEXT;
	}

	/**
	* ABI function called when entering a catch statement. The argument is the
	* pointer passed out of the personality function. This is always the start of
	* the _Unwind_Exception object. The return value for this function is the
	* pointer to the caught exception, which is either the adjusted pointer (for
	* C++ exceptions) of the unadjusted pointer (for foreign exceptions).
	*/
	#if __GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
	extern "C" void __cxa_begin_catch(void e) throw()
	#else
	extern "C" void __cxa_begin_catch(void e)
	#endif
	{
	// We can't call the fast version here, because if the first exception that
	// we see is a foreign exception then we won't have called it yet.
	__cxa_thread_info *ti = thread_info();
	__cxa_eh_globals *globals = &ti->globals;
	- globals->uncaughtExceptions--;
	_Unwind_Exception exceptionObject = static_cast<_Unwind_Exception>(e);

	if (isCXXException(exceptionObject->exception_class))
	{
	+ // Only exceptions thrown with a C++ exception throwing function will
	+ // increment this, so don't decrement it here.
	+ globals->uncaughtExceptions--;
	__cxa_exception *ex = exceptionFromPointer(exceptionObject);

	if (ex->handlerCount == 0)
	{
	// Add this to the front of the list of exceptions being handled
	// and increment its handler count so that it won't be deleted
	// prematurely.
	ex->nextException = globals->caughtExceptions;
	globals->caughtExceptions = ex;
	}

	if (ex->handlerCount < 0)
	{
	// Rethrown exception is catched before end of catch block.
	// Clear the rethrow flag (make value positive) - we are allowed
	// to delete this exception at the end of the catch block, as long
	// as it isn't thrown again later.

	// Code pattern:
	//
	// try {
	// throw x;
	// }
	// catch() {
	// try {
	// throw;
	// }
	// catch() {
	// __cxa_begin_catch() <- we are here
	// }
	// }
	ex->handlerCount = -ex->handlerCount + 1;
	}
	else
	{
	ex->handlerCount++;
	}
	ti->foreign_exception_state = __cxa_thread_info::none;

	return ex->adjustedPtr;
	}
	else
	{
	// If this is a foreign exception, then we need to be able to
	// store it. We can't chain foreign exceptions, so we give up
	// if there are already some outstanding ones.
	if (globals->caughtExceptions != 0)
	{
	std::terminate();
	}
	globals->caughtExceptions = reinterpret_cast<__cxa_exception*>(exceptionObject);
	ti->foreign_exception_state = __cxa_thread_info::caught;
	}
	// exceptionObject is the pointer to the _Unwind_Exception within the
	// __cxa_exception. The throw object is after this
	return (reinterpret_cast<char*>(exceptionObject) + sizeof(_Unwind_Exception));
	}



	/**
	* ABI function called when exiting a catch block. This will free the current
	* exception if it is no longer referenced in other catch blocks.
	*/
	extern "C" void __cxa_end_catch()
	{
	// We can call the fast version here because the slow version is called in
	// __cxa_throw(), which must have been called before we end a catch block
	__cxa_thread_info *ti = thread_info_fast();
	__cxa_eh_globals *globals = &ti->globals;
	__cxa_exception *ex = globals->caughtExceptions;

	assert(0 != ex && "Ending catch when no exception is on the stack!");

	if (ti->foreign_exception_state != __cxa_thread_info::none)
	{
	if (ti->foreign_exception_state != __cxa_thread_info::rethrown)
	{
	_Unwind_Exception e = reinterpret_cast<_Unwind_Exception>(ti->globals.caughtExceptions);
	if (e->exception_cleanup)
	e->exception_cleanup(_URC_FOREIGN_EXCEPTION_CAUGHT, e);
	}
	globals->caughtExceptions = 0;
	ti->foreign_exception_state = __cxa_thread_info::none;
	return;
	}

	bool deleteException = true;

	if (ex->handlerCount < 0)
	{
	// exception was rethrown. Exception should not be deleted even if
	// handlerCount become zero.
	// Code pattern:
	// try {
	// throw x;
	// }
	// catch() {
	// {
	// throw;
	// }
	// cleanup {
	// __cxa_end_catch(); <- we are here
	// }
	// }
	//

	ex->handlerCount++;
	deleteException = false;
	}
	else
	{
	ex->handlerCount--;
	}

	if (ex->handlerCount == 0)
	{
	globals->caughtExceptions = ex->nextException;
	if (deleteException)
	{
	releaseException(ex);
	}
	}
	}

	/**
	* ABI function. Returns the type of the current exception.
	*/
	extern "C" std::type_info *__cxa_current_exception_type()
	{
	__cxa_eh_globals *globals = __cxa_get_globals();
	__cxa_exception *ex = globals->caughtExceptions;
	return ex ? ex->exceptionType : 0;
	}

	/**
	+ * Cleanup, ensures that `__cxa_end_catch` is called to balance an explicit
	+ * `__cxa_begin_catch` call.
	+ */
	+static void end_catch(char *)
	+{
	+ __cxa_end_catch();
	+}
	+/**
	* ABI function, called when an exception specification is violated.
	*
	* This function does not return.
	*/
	extern "C" void __cxa_call_unexpected(void*exception)
	{
	_Unwind_Exception exceptionObject = static_cast<_Unwind_Exception>(exception);
	+ // Wrap the call to the unexpected handler in calls to `__cxa_begin_catch`
	+ // and `__cxa_end_catch` so that we correctly update exception counts if
	+ // the unexpected handler throws an exception.
	+ __cxa_begin_catch(exceptionObject);
	+ __attribute__((cleanup(end_catch)))
	+ char unused;
	if (exceptionObject->exception_class == exception_class)
	{
	__cxa_exception *ex = exceptionFromPointer(exceptionObject);
	if (ex->unexpectedHandler)
	{
	ex->unexpectedHandler();
	// Should not be reached.
	abort();
	}
	}
	std::unexpected();
	// Should not be reached.
	abort();
	}

	/**
	* ABI function, returns the adjusted pointer to the exception object.
	*/
	extern "C" void __cxa_get_exception_ptr(void exceptionObject)
	{
	return exceptionFromPointer(exceptionObject)->adjustedPtr;
	}

	/**
	* As an extension, we provide the ability for the unexpected and terminate
	* handlers to be thread-local. We default to the standards-compliant
	* behaviour where they are global.
	*/
	static bool thread_local_handlers = false;


	namespace pathscale
	{
	/**
	* Sets whether unexpected and terminate handlers should be thread-local.
	*/
	void set_use_thread_local_handlers(bool flag) throw()
	{
	thread_local_handlers = flag;
	}
	/**
	* Sets a thread-local unexpected handler.
	*/
	unexpected_handler set_unexpected(unexpected_handler f) throw()
	{
	static __cxa_thread_info *info = thread_info();
	unexpected_handler old = info->unexpectedHandler;
	info->unexpectedHandler = f;
	return old;
	}
	/**
	* Sets a thread-local terminate handler.
	*/
	terminate_handler set_terminate(terminate_handler f) throw()
	{
	static __cxa_thread_info *info = thread_info();
	terminate_handler old = info->terminateHandler;
	info->terminateHandler = f;
	return old;
	}
	}

	namespace std
	{
	/**
	* Sets the function that will be called when an exception specification is
	* violated.
	*/
	unexpected_handler set_unexpected(unexpected_handler f) throw()
	{
	if (thread_local_handlers) { return pathscale::set_unexpected(f); }

	return ATOMIC_SWAP(&unexpectedHandler, f);
	}
	/**
	* Sets the function that is called to terminate the program.
	*/
	terminate_handler set_terminate(terminate_handler f) throw()
	{
	if (thread_local_handlers) { return pathscale::set_terminate(f); }

	return ATOMIC_SWAP(&terminateHandler, f);
	}
	/**
	* Terminates the program, calling a custom terminate implementation if
	* required.
	*/
	void terminate()
	{
	static __cxa_thread_info *info = thread_info();
	if (0 != info && 0 != info->terminateHandler)
	{
	info->terminateHandler();
	// Should not be reached - a terminate handler is not expected to
	// return.
	abort();
	}
	terminateHandler();
	}
	/**
	* 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() throw()
	{
	__cxa_thread_info *info = thread_info();
	return info->globals.uncaughtExceptions != 0;
	}
	/**
	* Returns the number of exceptions currently being thrown that have not
	* been caught. This can occur inside a nested catch statement.
	*/
	int uncaught_exceptions() throw()
	{
	__cxa_thread_info *info = thread_info();
	return info->globals.uncaughtExceptions;
	}
	/**
	* Returns the current unexpected handler.
	*/
	unexpected_handler get_unexpected() throw()
	{
	__cxa_thread_info *info = thread_info();
	if (info->unexpectedHandler)
	{
	return info->unexpectedHandler;
	}
	return ATOMIC_LOAD(&unexpectedHandler);
	}
	/**
	* Returns the current terminate handler.
	*/
	terminate_handler get_terminate() throw()
	{
	__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

	Property changes on: head/contrib/libcxxrt/exception.cc
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/guard.cc
	===================================================================
	--- head/contrib/libcxxrt/guard.cc (revision 350359)
	+++ head/contrib/libcxxrt/guard.cc (revision 350360)

	Property changes on: head/contrib/libcxxrt/guard.cc
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/libelftc_dem_gnu3.c
	===================================================================
	--- head/contrib/libcxxrt/libelftc_dem_gnu3.c (revision 350359)
	+++ head/contrib/libcxxrt/libelftc_dem_gnu3.c (revision 350360)

	Property changes on: head/contrib/libcxxrt/libelftc_dem_gnu3.c
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/memory.cc
	===================================================================
	--- head/contrib/libcxxrt/memory.cc (revision 350359)
	+++ head/contrib/libcxxrt/memory.cc (revision 350360)
	@@ -1,154 +1,171 @@
	/*
	* Copyright 2010-2011 PathScale, Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
	* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	/**
	* memory.cc - Contains stub definition of C++ new/delete operators.
	*
	* These definitions are intended to be used for testing and are weak symbols
	* to allow them to be replaced by definitions from a STL implementation.
	* These versions simply wrap malloc() and free(), they do not provide a
	* C++-specific allocator.
	*/

	#include <stddef.h>
	#include <stdlib.h>
	#include "stdexcept.h"
	#include "atomic.h"


	namespace std
	{
	struct nothrow_t {};
	}


	/// The type of the function called when allocation fails.
	typedef void (*new_handler)();
	/**
	* The function to call when allocation fails. By default, there is no
	* handler and a bad allocation exception is thrown if an allocation fails.
	*/
	static new_handler new_handl;

	namespace std
	{
	/**
	* Sets a function to be called when there is a failure in new.
	*/
	__attribute__((weak))
	new_handler set_new_handler(new_handler handler)
	{
	return ATOMIC_SWAP(&new_handl, handler);
	}
	__attribute__((weak))
	new_handler get_new_handler(void)
	{
	return ATOMIC_LOAD(&new_handl);
	}
	}


	#if __cplusplus < 201103L
	#define NOEXCEPT throw()
	#define BADALLOC throw(std::bad_alloc)
	#else
	#define NOEXCEPT noexcept
	#define BADALLOC
	#endif


	__attribute__((weak))
	void* operator new(size_t size) BADALLOC
	{
	if (0 == size)
	{
	size = 1;
	}
	void * mem = malloc(size);
	while (0 == mem)
	{
	new_handler h = std::get_new_handler();
	if (0 != h)
	{
	h();
	}
	else
	{
	throw std::bad_alloc();
	}
	mem = malloc(size);
	}

	return mem;
	}

	__attribute__((weak))
	void* operator new(size_t size, const std::nothrow_t &) NOEXCEPT
	{
	try {
	return :: operator new(size);
	} catch (...) {
	// nothrow operator new should return NULL in case of
	// std::bad_alloc exception in new handler
	return NULL;
	}
	}


	__attribute__((weak))
	void operator delete(void * ptr) NOEXCEPT
	{
	free(ptr);
	}


	__attribute__((weak))
	void * operator new[](size_t size) BADALLOC
	{
	return ::operator new(size);
	}


	__attribute__((weak))
	void * operator new[](size_t size, const std::nothrow_t &) NOEXCEPT
	{
	try {
	return ::operator new[](size);
	} catch (...) {
	// nothrow operator new should return NULL in case of
	// std::bad_alloc exception in new handler
	return NULL;
	}
	}


	__attribute__((weak))
	void operator delete[](void * ptr) NOEXCEPT
	{
	::operator delete(ptr);
	}

	+// C++14 additional delete operators

	+#if __cplusplus >= 201402L
	+
	+__attribute__((weak))
	+void operator delete(void * ptr, size_t) NOEXCEPT
	+{
	+ ::operator delete(ptr);
	+}
	+
	+
	+__attribute__((weak))
	+void operator delete[](void * ptr, size_t) NOEXCEPT
	+{
	+ ::operator delete(ptr);
	+}
	+
	+#endif

	Property changes on: head/contrib/libcxxrt/memory.cc
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/stdexcept.cc
	===================================================================
	--- head/contrib/libcxxrt/stdexcept.cc (revision 350359)
	+++ head/contrib/libcxxrt/stdexcept.cc (revision 350360)

	Property changes on: head/contrib/libcxxrt/stdexcept.cc
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/stdexcept.h
	===================================================================
	--- head/contrib/libcxxrt/stdexcept.h (revision 350359)
	+++ head/contrib/libcxxrt/stdexcept.h (revision 350360)

	Property changes on: head/contrib/libcxxrt/stdexcept.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/terminate.cc
	===================================================================
	--- head/contrib/libcxxrt/terminate.cc (revision 350359)
	+++ head/contrib/libcxxrt/terminate.cc (revision 350360)

	Property changes on: head/contrib/libcxxrt/terminate.cc
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/typeinfo.cc
	===================================================================
	--- head/contrib/libcxxrt/typeinfo.cc (revision 350359)
	+++ head/contrib/libcxxrt/typeinfo.cc (revision 350360)

	Property changes on: head/contrib/libcxxrt/typeinfo.cc
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt/typeinfo.h
	===================================================================
	--- head/contrib/libcxxrt/typeinfo.h (revision 350359)
	+++ head/contrib/libcxxrt/typeinfo.h (revision 350360)

	Property changes on: head/contrib/libcxxrt/typeinfo.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: head/contrib/libcxxrt
	===================================================================
	--- head/contrib/libcxxrt (revision 350359)
	+++ head/contrib/libcxxrt (revision 350360)

	Property changes on: head/contrib/libcxxrt
	___________________________________________________________________
	Modified: svn:mergeinfo
	## -0,0 +0,1 ##
	Merged /vendor/libcxxrt/dist:r315946-350348
	Index: head/lib/libcxxrt/Makefile
	===================================================================
	--- head/lib/libcxxrt/Makefile (revision 350359)
	+++ head/lib/libcxxrt/Makefile (revision 350360)
	@@ -1,28 +1,28 @@
	# $FreeBSD$

	PACKAGE= clibs
	SRCDIR= ${SRCTOP}/contrib/libcxxrt

	SHLIB_MAJOR= 1
	SHLIBDIR?= /lib

	.PATH: ${SRCDIR}

	LIB= cxxrt

	SRCS+= libelftc_dem_gnu3.c\
	terminate.cc\
	dynamic_cast.cc\
	memory.cc\
	auxhelper.cc\
	exception.cc\
	stdexcept.cc\
	typeinfo.cc\
	guard.cc

	WARNS= 0
	CFLAGS+= -isystem ${SRCDIR} -nostdinc++
	-CXXSTD?= c++11
	+CXXSTD?= c++14
	VERSION_MAP= ${.CURDIR}/Version.map

	.include <bsd.lib.mk>
	Index: head/lib/libcxxrt/Version.map
	===================================================================
	--- head/lib/libcxxrt/Version.map (revision 350359)
	+++ head/lib/libcxxrt/Version.map (revision 350360)
	@@ -1,391 +1,395 @@
	# $FreeBSD$
	# Define the same version as the libsupc++ from gcc 4.2.1 so that we can use
	# libcxxrt as a drop-in replacement.

	CXXABI_1.3 {

	global:

	# ABI functions with C linkage
	__cxa_allocate_exception;
	__cxa_bad_cast;
	__cxa_bad_typeid;
	__cxa_begin_catch;
	__cxa_begin_cleanup;
	__cxa_call_unexpected;
	__cxa_current_exception_type;
	__cxa_demangle;
	__cxa_end_catch;
	__cxa_end_cleanup;
	__cxa_free_exception;
	__cxa_get_globals;
	__cxa_get_globals_fast;
	__cxa_guard_abort;
	__cxa_guard_acquire;
	__cxa_guard_release;
	__cxa_pure_virtual;
	__cxa_rethrow;
	__cxa_throw;
	__cxa_throw_bad_array_new_length;
	__cxa_type_match;
	__cxa_vec_cctor;
	__cxa_vec_cleanup;
	__cxa_vec_ctor;
	__cxa_vec_delete2;
	__cxa_vec_delete3;
	__cxa_vec_delete;
	__cxa_vec_dtor;
	__cxa_vec_new2;
	__cxa_vec_new3;
	__cxa_vec_new;
	__dynamic_cast;
	__gxx_personality_sj0;
	__gxx_personality_v0;

	extern "C++" {
	# Type info classes and their destructors
	"__cxxabiv1::__array_type_info";
	"__cxxabiv1::__array_type_info::~__array_type_info()";
	"__cxxabiv1::__class_type_info";
	"__cxxabiv1::__class_type_info::~__class_type_info()";
	"__cxxabiv1::__enum_type_info";
	"__cxxabiv1::__enum_type_info::~__enum_type_info()";
	"__cxxabiv1::__function_type_info::";
	"__cxxabiv1::__function_type_info::~__function_type_info()";
	"__cxxabiv1::__fundamental_type_info";
	"__cxxabiv1::__fundamental_type_info::~__fundamental_type_info()";
	"__cxxabiv1::__pbase_type_info";
	"__cxxabiv1::__pbase_type_info::~__pbase_type_info()";
	"__cxxabiv1::__pointer_to_member_type_info";
	"__cxxabiv1::__pointer_to_member_type_info::~__pointer_to_member_type_info()";
	"__cxxabiv1::__pointer_type_info";
	"__cxxabiv1::__pointer_type_info::~__pointer_type_info()";
	"__cxxabiv1::__si_class_type_info";
	"__cxxabiv1::__si_class_type_info::~__si_class_type_info()";
	"__cxxabiv1::__vmi_class_type_info";
	"__cxxabiv1::__vmi_class_type_info::~__vmi_class_type_info()";

	# vtables typeinfo classes.
	"vtable for __cxxabiv1::__array_type_info";
	"vtable for __cxxabiv1::__class_type_info";
	"vtable for __cxxabiv1::__enum_type_info";
	"vtable for __cxxabiv1::__function_type_info";
	"vtable for __cxxabiv1::__fundamental_type_info";
	"vtable for __cxxabiv1::__pbase_type_info";
	"vtable for __cxxabiv1::__pointer_to_member_type_info";
	"vtable for __cxxabiv1::__pointer_type_info";
	"vtable for __cxxabiv1::__si_class_type_info";
	"vtable for __cxxabiv1::__vmi_class_type_info";

	# Type info for built-in types
	"typeinfo for bool const*";
	"typeinfo for bool";
	"typeinfo for char const*";
	"typeinfo for char";
	"typeinfo for double const*";
	"typeinfo for double";
	"typeinfo for float const*";
	"typeinfo for float";
	"typeinfo for int const*";
	"typeinfo for int";
	"typeinfo for long const*";
	"typeinfo for long double const*";
	"typeinfo for long double";
	"typeinfo for long long const*";
	"typeinfo for long long";
	"typeinfo for long";
	"typeinfo for short const*";
	"typeinfo for short";
	"typeinfo for signed char const*";
	"typeinfo for signed char";
	"typeinfo for unsigned char const*";
	"typeinfo for unsigned char";
	"typeinfo for unsigned int const*";
	"typeinfo for unsigned int";
	"typeinfo for unsigned long const*";
	"typeinfo for unsigned long long const*";
	"typeinfo for unsigned long long";
	"typeinfo for unsigned long";
	"typeinfo for unsigned short const*";
	"typeinfo for unsigned short";
	"typeinfo for void const*";
	"typeinfo for void";
	"typeinfo for wchar_t const*";
	"typeinfo for wchar_t";

	"typeinfo for bool*";
	"typeinfo for wchar_t*";
	"typeinfo for short*";
	"typeinfo for char*";
	"typeinfo for unsigned char*";
	"typeinfo for long long*";
	"typeinfo for unsigned short*";
	"typeinfo for long*";
	"typeinfo for double*";
	"typeinfo for unsigned long*";
	"typeinfo for unsigned long long*";
	"typeinfo for int*";
	"typeinfo for long double*";
	"typeinfo for signed char*";
	"typeinfo for void*";
	"typeinfo for unsigned int*";
	"typeinfo for float*";

	"typeinfo for __cxxabiv1::__array_type_info";
	"typeinfo for __cxxabiv1::__class_type_info";
	"typeinfo for __cxxabiv1::__enum_type_info";
	"typeinfo for __cxxabiv1::__function_type_info";
	"typeinfo for __cxxabiv1::__fundamental_type_info";
	"typeinfo for __cxxabiv1::__pbase_type_info";
	"typeinfo for __cxxabiv1::__pointer_to_member_type_info";
	"typeinfo for __cxxabiv1::__pointer_type_info";
	"typeinfo for __cxxabiv1::__si_class_type_info";
	"typeinfo for __cxxabiv1::__vmi_class_type_info";

	# Typeinfo names.

	"typeinfo name for unsigned char const*";
	"typeinfo name for long const*";
	"typeinfo name for double const*";
	"typeinfo name for unsigned long long const*";
	"typeinfo name for unsigned short const*";
	"typeinfo name for char const*";
	"typeinfo name for long long const*";
	"typeinfo name for short const*";
	"typeinfo name for unsigned int const*";
	"typeinfo name for float const*";
	"typeinfo name for bool const*";
	"typeinfo name for wchar_t const*";
	"typeinfo name for int const*";
	"typeinfo name for unsigned long const*";
	"typeinfo name for void const*";
	"typeinfo name for long double const*";
	"typeinfo name for signed char const*";
	"typeinfo name for wchar_t";
	"typeinfo name for short";
	"typeinfo name for char";
	"typeinfo name for float";
	"typeinfo name for void";
	"typeinfo name for unsigned int";
	"typeinfo name for bool";
	"typeinfo name for signed char";
	"typeinfo name for long double";
	"typeinfo name for int";
	"typeinfo name for unsigned long long";
	"typeinfo name for unsigned long";
	"typeinfo name for unsigned char";
	"typeinfo name for long";
	"typeinfo name for long long";
	"typeinfo name for unsigned short";
	"typeinfo name for double";

	"typeinfo name for bool*";
	"typeinfo name for wchar_t*";
	"typeinfo name for short*";
	"typeinfo name for char*";
	"typeinfo name for unsigned char*";
	"typeinfo name for long long*";
	"typeinfo name for unsigned short*";
	"typeinfo name for long*";
	"typeinfo name for double*";
	"typeinfo name for unsigned long*";
	"typeinfo name for unsigned long long*";
	"typeinfo name for int*";
	"typeinfo name for long double*";
	"typeinfo name for signed char*";
	"typeinfo name for void*";
	"typeinfo name for unsigned int*";
	"typeinfo name for float*";

	"typeinfo name for __cxxabiv1::__array_type_info";
	"typeinfo name for __cxxabiv1::__class_type_info";
	"typeinfo name for __cxxabiv1::__enum_type_info";
	"typeinfo name for __cxxabiv1::__function_type_info";
	"typeinfo name for __cxxabiv1::__fundamental_type_info";
	"typeinfo name for __cxxabiv1::__pbase_type_info";
	"typeinfo name for __cxxabiv1::__pointer_to_member_type_info";
	"typeinfo name for __cxxabiv1::__pointer_type_info";
	"typeinfo name for __cxxabiv1::__si_class_type_info";
	"typeinfo name for __cxxabiv1::__vmi_class_type_info";

	"std::type_info::type_info(std::type_info const&)";
	"std::type_info::operator=(std::type_info const&)";


	# Extensions
	"pathscale::set_terminate(void (*)())";
	"pathscale::set_unexpected(void (*)())";
	"pathscale::set_use_thread_local_handlers(bool)";
	};

	# C++11 typeinfo not understood by ld.bfd 2.17.50
	# std::nullptr_t
	_ZTIDn;_ZTIPDn;_ZTIPKDn;
	# char16_t
	_ZTIDi;_ZTIPDi;_ZTIPKDi;
	# char32_t
	_ZTIDs;_ZTIPDs;_ZTIPKDs;
	# IEEE 754r decimal floating point
	_ZTIDd;_ZTIPDd;_ZTIPKDd;
	_ZTIDe;_ZTIPDe;_ZTIPKDe;
	_ZTIDf;_ZTIPDf;_ZTIPKDf;
	# IEEE 754r half-precision floating point
	_ZTIDh;_ZTIPDh;_ZTIPKDh;

	# C++11 typeinfo name not understood by ld.bfd 2.17.50
	# std::nullptr_t
	_ZTSDn;_ZTSPDn;_ZTSPKDn;
	# char16_t
	_ZTSDi;_ZTSPDi;_ZTSPKDi;
	# char32_t
	_ZTSDs;_ZTSPDs;_ZTSPKDs;
	# IEEE 754r decimal floating point
	_ZTSDd;_ZTSPDd;_ZTSPKDd;
	_ZTSDe;_ZTSPDe;_ZTSPKDe;
	_ZTSDf;_ZTSPDf;_ZTSPKDf;
	# IEEE 754r half-precision floating point
	_ZTSDh;_ZTSPDh;_ZTSPKDh;

	local:
	*;
	};

	CXXABI_1.3.1 {
	__cxa_get_exception_ptr;
	} CXXABI_1.3;

	CXXABI_1.3.5 {
	extern "C++" {
	"typeinfo for __int128 const*";
	"typeinfo for __int128";
	"typeinfo for __int128*";
	"typeinfo for unsigned __int128 const*";
	"typeinfo for unsigned __int128";
	"typeinfo for unsigned __int128*";
	};
	} CXXABI_1.3.1;

	CXXABI_1.3.6 {
	__cxa_deleted_virtual;
	} CXXABI_1.3.5;

	CXXABI_1.3.9 {
	extern "C++" {
	"typeinfo name for __int128 const*";
	"typeinfo name for __int128";
	"typeinfo name for __int128*";
	"typeinfo name for unsigned __int128 const*";
	"typeinfo name for unsigned __int128";
	"typeinfo name for unsigned __int128*";
	+ "operator delete[](void*, unsigned int)";
	+ "operator delete(void*, unsigned int)";
	+ "operator delete[](void*, unsigned long)";
	+ "operator delete(void*, unsigned long)";
	};
	} CXXABI_1.3.6;

	CXXRT_1.0 {

	extern "C++" {
	"std::type_info::name() const";
	"std::type_info::before(std::type_info const&) const";
	"std::type_info::operator==(std::type_info const&) const";
	"std::type_info::operator!=(std::type_info const&) const";
	"std::bad_cast::bad_cast(std::bad_cast const&)";
	"std::bad_cast::bad_cast()";
	"std::bad_cast::operator=(std::bad_cast const&)";
	"std::bad_typeid::bad_typeid(std::bad_typeid const&)";
	"std::bad_typeid::bad_typeid()";
	"std::bad_typeid::operator=(std::bad_typeid const&)";
	"std::exception::exception(std::exception const&)";
	"std::exception::exception()";
	"std::exception::operator=(std::exception const&)";
	"std::bad_alloc::bad_alloc(std::bad_alloc const&)";
	"std::bad_alloc::bad_alloc()";
	"std::bad_alloc::operator=(std::bad_alloc const&)";
	"std::bad_array_new_length::bad_array_new_length(std::bad_array_new_length const&)";
	"std::bad_array_new_length::bad_array_new_length()";
	"std::bad_array_new_length::operator=(std::bad_array_new_length const&)";

	};
	__cxa_allocate_dependent_exception;
	__cxa_current_primary_exception;
	__cxa_decrement_exception_refcount;
	__cxa_free_dependent_exception;
	__cxa_increment_exception_refcount;
	__cxa_rethrow_primary_exception;

	} CXXABI_1.3.6;


	GLIBCXX_3.4 {
	extern "C++" {
	"operator delete[](void*)";
	"operator delete(void*)";
	"operator new[](unsigned int)";
	"operator new(unsigned int)";
	"operator new(unsigned int, std::nothrow_t const&)";
	"operator new[](unsigned long)";
	"operator new(unsigned long)";
	"operator new(unsigned long, std::nothrow_t const&)";

	"std::unexpected()";
	"std::get_terminate()";
	"std::get_unexpected()";
	"std::uncaught_exception()";
	"std::terminate()";

	"std::type_info::~type_info()";
	"std::bad_cast::~bad_cast()";
	"std::bad_typeid::~bad_typeid()";
	"std::exception::~exception()";
	"std::bad_alloc::~bad_alloc()";
	"std::bad_array_new_length::~bad_array_new_length()";

	"std::exception::what() const";

	std::set_new_handler*;
	std::set_terminate*;
	std::set_unexpected*;
	std::type_info::__*;

	"vtable for std::bad_alloc";
	"vtable for std::bad_cast";
	"vtable for std::bad_typeid";
	"vtable for std::exception";
	"vtable for std::type_info";
	"vtable for std::bad_array_new_length";

	"typeinfo for std::bad_alloc";
	"typeinfo for std::bad_typeid";
	"typeinfo for std::bad_cast";
	"typeinfo for std::exception";
	"typeinfo for std::type_info";
	"typeinfo for std::bad_array_new_length";
	"typeinfo name for std::bad_alloc";
	"typeinfo name for std::bad_typeid";
	"typeinfo name for std::bad_cast";
	"typeinfo name for std::exception";
	"typeinfo name for std::type_info";
	"typeinfo name for std::bad_array_new_length";

	};
	};

	GLIBCXX_3.4.9 {
	extern "C++" {
	"std::bad_typeid::what() const";
	"std::bad_cast::what() const";
	"std::bad_alloc::what() const";
	"std::bad_array_new_length::what() const";
	};
	} GLIBCXX_3.4;

	GLIBCXX_3.4.20 {
	extern "C++" {
	"std::get_new_handler()";
	};
	} GLIBCXX_3.4.9;

	GLIBCXX_3.4.22 {
	extern "C++" {
	"std::uncaught_exceptions()";
	};
	} GLIBCXX_3.4.20;

File Metadata

Mime Type: text/x-c
Expires: Sun, Apr 28, 2:18 PM (2 d)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 9013941
Default Alt Text: (74 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions