Import libcxxrt / libc++ into a vendor branch.

Approved by:	dim (mentor)

CMakeLists.txt

@@ -0,0 +1,22 @@
+
+set(CXXRT_SOURCES
+    dynamic_cast.cc
+    exception.cc
+    guard.cc
+    stdexcept.cc
+    typeinfo.cc
+    memory.cc
+    auxhelper.cc
+    libelftc_dem_gnu3.c
+   )
+
+
+add_library(cxxrt-static STATIC ${CXXRT_SOURCES})
+add_library(cxxrt-shared SHARED ${CXXRT_SOURCES})
+
+set_target_properties(cxxrt-static cxxrt-shared PROPERTIES
+                      OUTPUT_NAME "cxxrt"
+                     )
+
+
+

abi_namespace.h

@@ -0,0 +1,5 @@
+/**
+ * The namespace used for the ABI declarations.  This is currently defined to
+ * be the same as GNU libsupc++, however this may change in the future.
+ */
+#define ABI_NAMESPACE __cxxabiv1

auxhelper.cc

@@ -0,0 +1,41 @@
+/**
+ * aux.cc - Compiler helper functions. 
+ *
+ * The functions declared in this file are intended to be called only by code
+ * that is automatically generated by C++ compilers for some common cases.  
+ */
+
+#include <stdlib.h>
+#include "stdexcept.h"
+
+/**
+ * Called to generate a bad cast exception.  This function is intended to allow
+ * compilers to insert code generating this exception without needing to
+ * duplicate the code for throwing the exception in every call site.
+ */
+extern "C" void __cxa_bad_cast()
+{
+    throw std::bad_cast();
+}
+
+/**
+ * Called to generate a bad typeid exception.  This function is intended to
+ * allow compilers to insert code generating this exception without needing to
+ * duplicate the code for throwing the exception in every call site.
+ */
+extern "C" void __cxa_bad_typeid()
+{
+    throw std::bad_typeid();
+}
+
+/**
+ * Compilers may (but are not required to) set any pure-virtual function's
+ * vtable entry to this function.  This makes debugging slightly easier, as
+ * users can add a breakpoint on this function to tell if they've accidentally
+ * called a pure-virtual function.
+ */
+extern "C" void __cxa_pure_virtual()
+{
+    abort();
+}
+

cxxabi.h

@@ -0,0 +1,207 @@
+#ifndef __CXXABI_H_
+#define __CXXABI_H_
+#include <stdint.h>
+#include <unwind.h>
+namespace std 
+{
+	class type_info;
+}
+/*
+ * The cxxabi.h header provides a set of public definitions for types and
+ * functions defined by the Itanium C++ ABI specification.  For reference, see
+ * the ABI specification here:
+ *
+ * http://sourcery.mentor.com/public/cxx-abi/abi.html
+ *
+ * All deviations from this specification, unless otherwise noted, are
+ * accidental.
+ */
+
+#ifdef __cplusplus
+namespace __cxxabiv1 {
+extern "C" {
+#endif
+/**
+ * Function type to call when an unexpected exception is encountered.
+ */
+typedef void (*unexpected_handler)();
+/**
+ * Function type to call when an unrecoverable condition is encountered.
+ */
+typedef void (*terminate_handler)();
+
+
+/**
+ * Structure used as a header on thrown exceptions.  This is the same layout as
+ * defined by the Itanium ABI spec, so should be interoperable with any other
+ * implementation of this spec, such as GNU libsupc++.
+ *
+ * This structure is allocated when an exception is thrown.  Unwinding happens
+ * in two phases, the first looks for a handler and the second installs the
+ * context.  This structure stores a cache of the handler location between
+ * phase 1 and phase 2.  Unfortunately, cleanup information is not cached, so
+ * must be looked up in both phases.  This happens for two reasons.  The first
+ * is that we don't know how many frames containing cleanups there will be, and
+ * we should avoid dynamic allocation during unwinding (the exception may be
+ * reporting that we've run out of memory).  The second is that finding
+ * cleanups is much cheaper than finding handlers, because we don't have to
+ * look at the type table at all.
+ *
+ * Note: Several fields of this structure have not-very-informative names.
+ * These are taken from the ABI spec and have not been changed to make it
+ * easier for people referring to to the spec while reading this code.
+ */
+struct __cxa_exception
+{
+#if __LP64__
+	/**
+	 * Reference count.  Used to support the C++11 exception_ptr class.  This
+	 * is prepended to the structure in 64-bit mode and squeezed in to the
+	 * padding left before the 64-bit aligned _Unwind_Exception at the end in
+	 * 32-bit mode.
+	 *
+	 * Note that it is safe to extend this structure at the beginning, rather
+	 * than the end, because the public API for creating it returns the address
+	 * of the end (where the exception object can be stored).
+	 */
+	uintptr_t referenceCount;
+#endif
+	/** Type info for the thrown object. */
+	std::type_info *exceptionType;
+	/** Destructor for the object, if one exists. */
+	void (*exceptionDestructor) (void *); 
+	/** Handler called when an exception specification is violated. */
+	unexpected_handler unexpectedHandler;
+	/** Hander called to terminate. */
+	terminate_handler terminateHandler;
+	/**
+	 * Next exception in the list.  If an exception is thrown inside a catch
+	 * block and caught in a nested catch, this points to the exception that
+	 * will be handled after the inner catch block completes.
+	 */
+	__cxa_exception *nextException;
+	/**
+	 * The number of handlers that currently have references to this
+	 * exception.  The top (non-sign) bit of this is used as a flag to indicate
+	 * that the exception is being rethrown, so should not be deleted when its
+	 * handler count reaches 0 (which it doesn't with the top bit set).
+	 */
+	int handlerCount;
+	/**
+	 * The selector value to be returned when installing the catch handler.
+	 * Used at the call site to determine which catch() block should execute.
+	 * This is found in phase 1 of unwinding then installed in phase 2.
+	 */
+	int handlerSwitchValue;
+	/**
+	 * The action record for the catch.  This is cached during phase 1
+	 * unwinding.
+	 */
+	const char *actionRecord;
+	/**
+	 * Pointer to the language-specific data area (LSDA) for the handler
+	 * frame.  This is unused in this implementation, but set for ABI
+	 * compatibility in case we want to mix code in very weird ways.
+	 */
+	const char *languageSpecificData;
+	/** The cached landing pad for the catch handler.*/
+	void *catchTemp;
+	/**
+	 * The pointer that will be returned as the pointer to the object.  When
+	 * throwing a class and catching a virtual superclass (for example), we
+	 * need to adjust the thrown pointer to make it all work correctly.
+	 */
+	void *adjustedPtr;
+#if !__LP64__
+	/**
+	 * Reference count.  Used to support the C++11 exception_ptr class.  This
+	 * is prepended to the structure in 64-bit mode and squeezed in to the
+	 * padding left before the 64-bit aligned _Unwind_Exception at the end in
+	 * 32-bit mode.
+	 *
+	 * Note that it is safe to extend this structure at the beginning, rather
+	 * than the end, because the public API for creating it returns the address
+	 * of the end (where the exception object can be stored) 
+	 */
+	uintptr_t referenceCount;
+#endif
+	/** The language-agnostic part of the exception header. */
+	_Unwind_Exception unwindHeader;
+};
+
+/**
+ * ABI-specified globals structure.  Returned by the __cxa_get_globals()
+ * function and its fast variant.  This is a per-thread structure - every
+ * thread will have one lazily allocated.
+ *
+ * This structure is defined by the ABI, so may be used outside of this
+ * library.
+ */
+struct __cxa_eh_globals
+{
+	/**
+	 * A linked list of exceptions that are currently caught.  There may be
+	 * several of these in nested catch() blocks.
+	 */
+	__cxa_exception *caughtExceptions;
+	/**
+	 * The number of uncaught exceptions.
+	 */
+	unsigned int uncaughtExceptions;
+};
+/**
+ * ABI function returning the __cxa_eh_globals structure.
+ */
+__cxa_eh_globals *__cxa_get_globals(void);
+/**
+ * Version of __cxa_get_globals() assuming that __cxa_get_globals() has already
+ * been called at least once by this thread.
+ */
+__cxa_eh_globals *__cxa_get_globals_fast(void);
+
+/**
+ * Throws an exception returned by __cxa_current_primary_exception().  This
+ * exception may have been caught in another thread.
+ */
+void __cxa_rethrow_primary_exception(void* thrown_exception);
+/**
+ * Returns the current exception in a form that can be stored in an
+ * exception_ptr object and then rethrown by a call to
+ * __cxa_rethrow_primary_exception().
+ */
+void *__cxa_current_primary_exception(void);
+/**
+ * Increments the reference count of an exception.  Called when an
+ * exception_ptr is copied.
+ */
+void __cxa_increment_exception_refcount(void* thrown_exception);
+/**
+ * Decrements the reference count of an exception.  Called when an
+ * exception_ptr is deleted.
+ */
+void __cxa_decrement_exception_refcount(void* thrown_exception);
+/**
+ * Demangles a C++ symbol or type name.  The buffer, if non-NULL, must be
+ * allocated with malloc() and must be *n bytes or more long.  This function
+ * may call realloc() on the value pointed to by buf, and will return the
+ * length of the string via *n.
+ *
+ * The value pointed to by status is set to one of the following:
+ *
+ * 0: success
+ * -1: memory allocation failure
+ * -2: invalid mangled name
+ * -3: invalid arguments
+ */
+char* __cxa_demangle(const char* mangled_name,
+                     char* buf,
+                     size_t* n,
+                     int* status);
+#ifdef __cplusplus
+} // extern "C"
+} // namespace
+
+namespace abi = __cxxabiv1;
+
+#endif /* __cplusplus */
+#endif /* __CXXABI_H_ */

dwarf_eh.h

@@ -0,0 +1,451 @@
+/**
+ * dwarf_eh.h - Defines some helper functions for parsing DWARF exception
+ * handling tables.
+ *
+ * This file contains various helper functions that are independent of the
+ * language-specific code.  It can be used in any personality function for the
+ * Itanium ABI.
+ */
+#include <assert.h>
+
+// TODO: Factor out Itanium / ARM differences.  We probably want an itanium.h
+// and arm.h that can be included by this file depending on the target ABI.
+
+// _GNU_SOURCE must be defined for unwind.h to expose some of the functions
+// that we want.  If it isn't, then we define it and undefine it to make sure
+// that it doesn't impact the rest of the program.
+#ifndef _GNU_SOURCE
+#	define _GNU_SOURCE 1
+#	include <unwind.h>
+#	undef _GNU_SOURCE
+#else
+#	include <unwind.h>
+#endif
+
+#include <stdint.h>
+
+/// Type used for pointers into DWARF data
+typedef unsigned char *dw_eh_ptr_t;
+
+// Flag indicating a signed quantity
+#define DW_EH_PE_signed 0x08
+/// DWARF data encoding types.  
+enum dwarf_data_encoding
+{
+	/// Unsigned, little-endian, base 128-encoded (variable length).
+	DW_EH_PE_uleb128 = 0x01,
+	/// Unsigned 16-bit integer.
+	DW_EH_PE_udata2  = 0x02,
+	/// Unsigned 32-bit integer.
+	DW_EH_PE_udata4  = 0x03,
+	/// Unsigned 64-bit integer.
+	DW_EH_PE_udata8  = 0x04,
+	/// Signed, little-endian, base 128-encoded (variable length)
+	DW_EH_PE_sleb128 = DW_EH_PE_uleb128 | DW_EH_PE_signed,
+	/// Signed 16-bit integer.
+	DW_EH_PE_sdata2  = DW_EH_PE_udata2 | DW_EH_PE_signed,
+	/// Signed 32-bit integer.
+	DW_EH_PE_sdata4  = DW_EH_PE_udata4 | DW_EH_PE_signed,
+	/// Signed 32-bit integer.
+	DW_EH_PE_sdata8  = DW_EH_PE_udata8 | DW_EH_PE_signed
+};
+
+/**
+ * Returns the encoding for a DWARF EH table entry.  The encoding is stored in
+ * the low four of an octet.  The high four bits store the addressing mode.
+ */
+static inline enum dwarf_data_encoding get_encoding(unsigned char x)
+{
+	return (enum dwarf_data_encoding)(x & 0xf);
+}
+
+/**
+ * DWARF addressing mode constants.  When reading a pointer value from a DWARF
+ * exception table, you must know how it is stored and what the addressing mode
+ * is.  The low four bits tell you the encoding, allowing you to decode a
+ * number.  The high four bits tell you the addressing mode, allowing you to
+ * turn that number into an address in memory.
+ */
+enum dwarf_data_relative
+{
+	/// Value is omitted
+	DW_EH_PE_omit     = 0xff,
+	/// Absolute pointer value
+	DW_EH_PE_absptr   = 0x00,
+	/// Value relative to program counter
+	DW_EH_PE_pcrel    = 0x10,
+	/// Value relative to the text segment
+	DW_EH_PE_textrel  = 0x20,
+	/// Value relative to the data segment
+	DW_EH_PE_datarel  = 0x30,
+	/// Value relative to the start of the function
+	DW_EH_PE_funcrel  = 0x40,
+	/// Aligned pointer (Not supported yet - are they actually used?)
+	DW_EH_PE_aligned  = 0x50,
+	/// Pointer points to address of real value
+	DW_EH_PE_indirect = 0x80
+};
+/**
+ * Returns the addressing mode component of this encoding.
+ */
+static inline enum dwarf_data_relative get_base(unsigned char x)
+{
+	return (enum dwarf_data_relative)(x & 0x70);
+}
+/**
+ * Returns whether an encoding represents an indirect address.
+ */
+static int is_indirect(unsigned char x)
+{
+	return ((x & DW_EH_PE_indirect) == DW_EH_PE_indirect);
+}
+
+/**
+ * Returns the size of a fixed-size encoding.  This function will abort if
+ * called with a value that is not a fixed-size encoding.
+ */
+static inline int dwarf_size_of_fixed_size_field(unsigned char type)
+{
+	switch (get_encoding(type))
+	{
+		default: abort();
+		case DW_EH_PE_sdata2: 
+		case DW_EH_PE_udata2: return 2;
+		case DW_EH_PE_sdata4:
+		case DW_EH_PE_udata4: return 4;
+		case DW_EH_PE_sdata8:
+		case DW_EH_PE_udata8: return 8;
+		case DW_EH_PE_absptr: return sizeof(void*);
+	}
+}
+
+/** 
+ * Read an unsigned, little-endian, base-128, DWARF value.  Updates *data to
+ * point to the end of the value.  Stores the number of bits read in the value
+ * pointed to by b, allowing you to determine the value of the highest bit, and
+ * therefore the sign of a signed value.
+ *
+ * This function is not intended to be called directly.  Use read_sleb128() or
+ * read_uleb128() for reading signed and unsigned versions, respectively.
+ */
+static uint64_t read_leb128(dw_eh_ptr_t *data, int *b)
+{
+	uint64_t uleb = 0;
+	unsigned int bit = 0;
+	unsigned char digit = 0;
+	// We have to read at least one octet, and keep reading until we get to one
+	// with the high bit unset
+	do
+	{
+		// This check is a bit too strict - we should also check the highest
+		// bit of the digit.
+		assert(bit < sizeof(uint64_t) * 8);
+		// Get the base 128 digit 
+		digit = (**data) & 0x7f;
+		// Add it to the current value
+		uleb += digit << bit;
+		// Increase the shift value
+		bit += 7;
+		// Proceed to the next octet
+		(*data)++;
+		// Terminate when we reach a value that does not have the high bit set
+		// (i.e. which was not modified when we mask it with 0x7f)
+	} while ((*(*data - 1)) != digit);
+	*b = bit;
+
+	return uleb;
+}
+
+/**
+ * Reads an unsigned little-endian base-128 value starting at the address
+ * pointed to by *data.  Updates *data to point to the next byte after the end
+ * of the variable-length value.
+ */
+static int64_t read_uleb128(dw_eh_ptr_t *data)
+{
+	int b;
+	return read_leb128(data, &b);
+}
+
+/**
+ * Reads a signed little-endian base-128 value starting at the address pointed
+ * to by *data.  Updates *data to point to the next byte after the end of the
+ * variable-length value.
+ */
+static int64_t read_sleb128(dw_eh_ptr_t *data)
+{
+	int bits;
+	// Read as if it's signed
+	uint64_t uleb = read_leb128(data, &bits);
+	// If the most significant bit read is 1, then we need to sign extend it
+	if ((uleb >> (bits-1)) == 1)
+	{
+		// Sign extend by setting all bits in front of it to 1
+		uleb |= ((int64_t)-1) << bits;
+	}
+	return (int64_t)uleb;
+}
+/**
+ * Reads a value using the specified encoding from the address pointed to by
+ * *data.  Updates the value of *data to point to the next byte after the end
+ * of the data.
+ */
+static uint64_t read_value(char encoding, dw_eh_ptr_t *data)
+{
+	enum dwarf_data_encoding type = get_encoding(encoding);
+	uint64_t v;
+	switch (type)
+	{
+		// Read fixed-length types
+#define READ(dwarf, type) \
+		case dwarf:\
+			v = (uint64_t)(*(type*)(*data));\
+			*data += sizeof(type);\
+			break;
+		READ(DW_EH_PE_udata2, uint16_t)
+		READ(DW_EH_PE_udata4, uint32_t)
+		READ(DW_EH_PE_udata8, uint64_t)
+		READ(DW_EH_PE_sdata2, int16_t)
+		READ(DW_EH_PE_sdata4, int32_t)
+		READ(DW_EH_PE_sdata8, int64_t)
+		READ(DW_EH_PE_absptr, intptr_t)
+#undef READ
+		// Read variable-length types
+		case DW_EH_PE_sleb128:
+			v = read_sleb128(data);
+			break;
+		case DW_EH_PE_uleb128:
+			v = read_uleb128(data);
+			break;
+		default: abort();
+	}
+
+	return v;
+}
+
+/**
+ * Resolves an indirect value.  This expects an unwind context, an encoding, a
+ * decoded value, and the start of the region as arguments.  The returned value
+ * is a pointer to the address identified by the encoded value.
+ *
+ * If the encoding does not specify an indirect value, then this returns v.
+ */
+static uint64_t resolve_indirect_value(_Unwind_Context *c,
+                                       unsigned char encoding,
+                                       int64_t v,
+                                       dw_eh_ptr_t start)
+{
+	switch (get_base(encoding))
+	{
+		case DW_EH_PE_pcrel:
+			v += (uint64_t)start;
+			break;
+		case DW_EH_PE_textrel:
+			v += (uint64_t)_Unwind_GetTextRelBase(c);
+			break;
+		case DW_EH_PE_datarel:
+			v += (uint64_t)_Unwind_GetDataRelBase(c);
+			break;
+		case DW_EH_PE_funcrel:
+			v += (uint64_t)_Unwind_GetRegionStart(c);
+		default:
+			break;
+	}
+	// If this is an indirect value, then it is really the address of the real
+	// value
+	// TODO: Check whether this should really always be a pointer - it seems to
+	// be a GCC extensions, so not properly documented...
+	if (is_indirect(encoding))
+	{
+		v = (uint64_t)(uintptr_t)*(void**)v;
+	}
+	return v;
+}
+
+
+/**
+ * Reads an encoding and a value, updating *data to point to the next byte.  
+ */
+static inline void read_value_with_encoding(_Unwind_Context *context,
+                                            dw_eh_ptr_t *data,
+                                            uint64_t *out)
+{
+	dw_eh_ptr_t start = *data;
+	unsigned char encoding = *((*data)++);
+	// If this value is omitted, skip it and don't touch the output value
+	if (encoding == DW_EH_PE_omit) { return; }
+
+	*out = read_value(encoding, data);
+	*out = resolve_indirect_value(context, encoding, *out, start);
+}
+
+/**
+ * Structure storing a decoded language-specific data area.  Use parse_lsda()
+ * to generate an instance of this structure from the address returned by the
+ * generic unwind library.  
+ *
+ * You should not need to inspect the fields of this structure directly if you
+ * are just using this header.  The structure stores the locations of the
+ * various tables used for unwinding exceptions and is used by the functions
+ * for reading values from these tables.
+ */
+struct dwarf_eh_lsda
+{
+	/// The start of the region.  This is a cache of the value returned by
+	/// _Unwind_GetRegionStart().
+	dw_eh_ptr_t region_start;
+	/// The start of the landing pads table.
+	dw_eh_ptr_t landing_pads;
+	/// The start of the type table.
+	dw_eh_ptr_t type_table;
+	/// The encoding used for entries in the type tables.
+	unsigned char type_table_encoding;
+	/// The location of the call-site table.
+	dw_eh_ptr_t call_site_table;
+	/// The location of the action table.
+	dw_eh_ptr_t action_table;
+	/// The encoding used for entries in the call-site table.
+	unsigned char callsite_encoding;
+};
+
+/**
+ * Parse the header on the language-specific data area and return a structure
+ * containing the addresses and encodings of the various tables.
+ */
+static inline struct dwarf_eh_lsda parse_lsda(_Unwind_Context *context,
+                                              unsigned char *data)
+{
+	struct dwarf_eh_lsda lsda;
+
+	lsda.region_start = (dw_eh_ptr_t)(uintptr_t)_Unwind_GetRegionStart(context);
+
+	// If the landing pads are relative to anything other than the start of
+	// this region, find out where.  This is @LPStart in the spec, although the
+	// encoding that GCC uses does not quite match the spec.
+	uint64_t v = (uint64_t)(uintptr_t)lsda.region_start;
+	read_value_with_encoding(context, &data, &v);
+	lsda.landing_pads = (dw_eh_ptr_t)(uintptr_t)v;
+
+	// If there is a type table, find out where it is.  This is @TTBase in the
+	// spec.  Note: we find whether there is a type table pointer by checking
+	// whether the leading byte is DW_EH_PE_omit (0xff), which is not what the
+	// spec says, but does seem to be how G++ indicates this.
+	lsda.type_table = 0;
+	lsda.type_table_encoding = *data++;
+	if (lsda.type_table_encoding != DW_EH_PE_omit)
+	{
+		v = read_uleb128(&data);
+		dw_eh_ptr_t type_table = data;
+		type_table += v;
+		lsda.type_table = type_table;
+		//lsda.type_table = (uintptr_t*)(data + v);
+	}
+
+	lsda.callsite_encoding = (enum dwarf_data_encoding)(*(data++));
+
+	// Action table is immediately after the call site table
+	lsda.action_table = data;
+	uintptr_t callsite_size = (uintptr_t)read_uleb128(&data);
+	lsda.action_table = data + callsite_size;
+	// Call site table is immediately after the header
+	lsda.call_site_table = (dw_eh_ptr_t)data;
+
+
+	return lsda;
+}
+
+/**
+ * Structure representing an action to be performed while unwinding.  This
+ * contains the address that should be unwound to and the action record that
+ * provoked this action.
+ */
+struct dwarf_eh_action
+{
+	/** 
+	 * The address that this action directs should be the new program counter
+	 * value after unwinding.
+	 */
+	dw_eh_ptr_t landing_pad;
+	/// The address of the action record.
+	dw_eh_ptr_t action_record;
+};
+
+/**
+ * Look up the landing pad that corresponds to the current invoke.
+ * Returns true if record exists.  The context is provided by the generic
+ * unwind library and the lsda should be the result of a call to parse_lsda().
+ *
+ * The action record is returned via the result parameter.  
+ */
+static bool dwarf_eh_find_callsite(struct _Unwind_Context *context,
+                                   struct dwarf_eh_lsda *lsda,
+                                   struct dwarf_eh_action *result)
+{
+	result->action_record = 0;
+	result->landing_pad = 0;
+	// The current instruction pointer offset within the region
+	uint64_t ip = _Unwind_GetIP(context) - _Unwind_GetRegionStart(context);
+	unsigned char *callsite_table = (unsigned char*)lsda->call_site_table;
+
+	while (callsite_table <= lsda->action_table)
+	{
+		// Once again, the layout deviates from the spec.
+		uint64_t call_site_start, call_site_size, landing_pad, action;
+		call_site_start = read_value(lsda->callsite_encoding, &callsite_table);
+		call_site_size = read_value(lsda->callsite_encoding, &callsite_table);
+
+		// Call site entries are sorted, so if we find a call site that's after
+		// the current instruction pointer then there is no action associated
+		// with this call and we should unwind straight through this frame
+		// without doing anything.
+		if (call_site_start > ip) { break; }
+
+		// Read the address of the landing pad and the action from the call
+		// site table.
+		landing_pad = read_value(lsda->callsite_encoding, &callsite_table);
+		action = read_uleb128(&callsite_table);
+
+		// We should not include the call_site_start (beginning of the region)
+		// address in the ip range. For each call site:
+		//
+		// address1: call proc
+		// address2: next instruction
+		//
+		// The call stack contains address2 and not address1, address1 can be
+		// at the end of another EH region.
+		if (call_site_start < ip && ip <= call_site_start + call_site_size)
+		{
+			if (action)
+			{
+				// Action records are 1-biased so both no-record and zeroth
+				// record can be stored.
+				result->action_record = lsda->action_table + action - 1;
+			}
+			// No landing pad means keep unwinding.
+			if (landing_pad)
+			{
+				// Landing pad is the offset from the value in the header
+				result->landing_pad = lsda->landing_pads + landing_pad;
+			}
+			return true;
+		}
+	}
+	return false;
+}
+
+/// Defines an exception class from 8 bytes (endian independent)
+#define EXCEPTION_CLASS(a,b,c,d,e,f,g,h) \
+	(((uint64_t)a << 56) +\
+	 ((uint64_t)b << 48) +\
+	 ((uint64_t)c << 40) +\
+	 ((uint64_t)d << 32) +\
+	 ((uint64_t)e << 24) +\
+	 ((uint64_t)f << 16) +\
+	 ((uint64_t)g << 8) +\
+	 ((uint64_t)h))
+
+#define GENERIC_EXCEPTION_CLASS(e,f,g,h) \
+	 ((uint32_t)e << 24) +\
+	 ((uint32_t)f << 16) +\
+	 ((uint32_t)g << 8) +\
+	 ((uint32_t)h)

dynamic_cast.cc

@@ -0,0 +1,133 @@
+#include "typeinfo.h"
+#include <stdio.h>
+
+using namespace ABI_NAMESPACE;
+
+/**
+ * Vtable header.
+ */
+struct vtable_header
+{
+	/** Offset of the leaf object. */
+	ptrdiff_t leaf_offset;
+	/** Type of the object. */
+	const __class_type_info *type;
+};
+
+/**
+ * Simple macro that does pointer arithmetic in bytes but returns a value of
+ * the same type as the original.
+ */
+#define ADD_TO_PTR(x, off) (__typeof__(x))(((char*)x) + off)
+
+bool __class_type_info::can_cast_to(const struct __class_type_info *other) const
+{
+    return this == other;
+}
+
+void *__class_type_info::cast_to(void *obj, const struct __class_type_info *other) const
+{
+	if (this == other)
+	{
+		return obj;
+	}
+	return 0;
+}
+
+
+bool __si_class_type_info::can_cast_to(const struct __class_type_info *other) const
+{
+    return this == other || __base_type->can_cast_to(other);
+}
+
+void *__si_class_type_info::cast_to(void *obj, const struct __class_type_info *other) const
+{
+	if (this == other)
+	{
+		return obj;
+	}
+	return __base_type->cast_to(obj, other);
+}
+
+
+bool __vmi_class_type_info::can_cast_to(const struct __class_type_info *other) const
+{
+	if (this == other)
+	{
+		return true;
+	}
+	for (unsigned int i=0 ; i<__base_count ; i++)
+	{
+		const __base_class_type_info *info = &__base_info[i];
+        if(info->isPublic() && info->__base_type->can_cast_to(other))
+        {
+            return true;
+        }
+	}
+	return false;
+}
+
+void *__vmi_class_type_info::cast_to(void *obj, const struct __class_type_info *other) const
+{
+	if (this == other)
+	{
+		return obj;
+	}
+	for (unsigned int i=0 ; i<__base_count ; i++)
+	{
+		const __base_class_type_info *info = &__base_info[i];
+		ptrdiff_t offset = info->offset();
+		// If this is a virtual superclass, the offset is stored in the
+		// object's vtable at the offset requested; 2.9.5.6.c:
+		//
+		// 'For a non-virtual base, this is the offset in the object of the
+		// base subobject. For a virtual base, this is the offset in the
+		// virtual table of the virtual base offset for the virtual base
+		// referenced (negative).'
+
+		if (info->isVirtual())
+		{
+			// Object's vtable
+			ptrdiff_t *off = *(ptrdiff_t**)obj;
+			// Offset location in vtable
+			off = ADD_TO_PTR(off, offset);
+			offset = *off;
+		}
+		void *cast = ADD_TO_PTR(obj, offset);
+
+		if (info->__base_type == other)
+		{
+			return cast;
+		}
+		if ((cast = info->__base_type->cast_to(cast, other)))
+		{
+			return cast;
+		}
+	}
+	return 0;
+}
+
+/**
+ * ABI function used to implement the dynamic_cast<> operator.  Some cases of
+ * this operator are implemented entirely in the compiler (e.g. to void*).
+ * This function implements the dynamic casts of the form dynamic_cast<T>(v).
+ * This will be translated to a call to this function with the value v as the
+ * first argument.  The type id of the static type of v is the second argument
+ * and the type id of the destination type (T) is the third argument.
+ *
+ * The third argument is a hint about the compiler's guess at the correct
+ * pointer offset.  If this value is negative, then -1 indicates no hint, -2
+ * that src is not a public base of dst, and -3 that src is a multiple public
+ * base type but never a virtual base type
+ */
+extern "C" void* __dynamic_cast(const void *sub,
+                                const __class_type_info *src,
+                                const __class_type_info *dst,
+                                ptrdiff_t src2dst_offset)
+{
+	char *vtable_location = *(char**)sub;
+	const vtable_header *header =
+		(const vtable_header*)(vtable_location - sizeof(vtable_header));
+	void *leaf = ADD_TO_PTR((void*)sub, header->leaf_offset);
+	return header->type->cast_to(leaf, dst);
+}

guard.cc

@@ -0,0 +1,80 @@
+/**
+ * guard.cc: Functions for thread-safe static initialisation.
+ *
+ * Static values in C++ can be initialised lazily their first use.  This file
+ * contains functions that are used to ensure that two threads attempting to
+ * initialize the same static do not call the constructor twice.  This is
+ * important because constructors can have side effects, so calling the
+ * constructor twice may be very bad.
+ *
+ * Statics that require initialisation are protected by a 64-bit value.  Any
+ * platform that can do 32-bit atomic test and set operations can use this
+ * value as a low-overhead lock.  Because statics (in most sane code) are
+ * accessed far more times than they are initialised, this lock implementation
+ * is heavily optimised towards the case where the static has already been
+ * initialised.  
+ */
+#include <stdint.h>
+#include <pthread.h>
+
+/**
+ * Returns a pointer to the low 32 bits in a 64-bit value, respecting the
+ * platform's byte order.
+ */
+static int32_t *low_32_bits(volatile int64_t *ptr)
+{
+	int32_t *low= (int32_t*)ptr;
+	// Test if the machine is big endian - constant propagation at compile time
+	// should eliminate this completely.
+	int one = 1;
+	if (*(char*)&one != 1)
+	{
+		low++;
+	}
+	return low;
+}
+
+/**
+ * Acquires a lock on a guard, returning 0 if the object has already been
+ * initialised, and 1 if it has not.  If the object is already constructed then
+ * this function just needs to read a byte from memory and return.
+ */
+extern "C" int __cxa_guard_acquire(volatile int64_t *guard_object)
+{
+	char first_byte = (*guard_object) >> 56;
+	if (1 == first_byte) { return 0; }
+	int32_t *lock = low_32_bits(guard_object);
+	// Simple spin lock using the low 32 bits.  We assume that concurrent
+	// attempts to initialize statics are very rare, so we don't need to
+	// optimise for the case where we have lots of threads trying to acquire
+	// the lock at the same time.
+	while (!__sync_bool_compare_and_swap_4(lock, 0, 1))
+	{
+		sched_yield();
+	}
+	// We have to test the guard again, in case another thread has performed
+	// the initialisation while we were trying to acquire the lock.
+	first_byte = (*guard_object) >> 56;
+	return (1 != first_byte);
+}
+
+/**
+ * Releases the lock without marking the object as initialised.  This function
+ * is called if initialising a static causes an exception to be thrown.
+ */
+extern "C" void __cxa_guard_abort(int64_t *guard_object)
+{
+	int32_t *lock = low_32_bits(guard_object);
+	*lock = 0;
+}
+/**
+ * Releases the guard and marks the object as initialised.  This function is
+ * called after successful initialisation of a static.
+ */
+extern "C" void __cxa_guard_release(int64_t *guard_object)
+{
+	// Set the first byte to 1
+	*guard_object |= ((int64_t)1) << 56;
+	__cxa_guard_abort(guard_object);
+}
+

memory.cc

@@ -0,0 +1,111 @@
+/**
+ * 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"
+
+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 __sync_lock_test_and_set(&new_handl, handler);
+	}
+}
+
+
+__attribute__((weak))
+void* operator new(size_t size)
+{
+	void * mem = malloc(size);
+	while (0 == mem)
+	{
+		if (0 != new_handl)
+		{
+			new_handl();
+		}
+		else
+		{
+			throw std::bad_alloc();
+		}
+		mem = malloc(size);
+	}
+
+	return mem;
+}
+
+__attribute__((weak))
+void* operator new(size_t size, const std::nothrow_t &) throw()
+{
+	void *mem = malloc(size);
+	while (0 == mem)
+	{
+		if (0 != new_handl)
+		{
+			try
+			{
+				new_handl();
+			}
+			catch (...)
+			{
+				// nothrow operator new should return NULL in case of
+				// std::bad_alloc exception in new handler
+				return NULL;
+			}
+		}
+		else
+		{
+			return NULL;
+		}
+		mem = malloc(size);
+	}
+
+	return mem;
+}
+
+
+__attribute__((weak))
+void operator delete(void * ptr)
+{
+	free(ptr);
+}
+
+
+__attribute__((weak))
+void * operator new[](size_t size)
+{
+	return ::operator new(size);
+}
+
+
+__attribute__((weak))
+void operator delete[](void * ptr)
+{
+	::operator delete(ptr);
+}
+
+

stdexcept.cc

@@ -0,0 +1,60 @@
+/**
+ * stdexcept.cc - provides stub implementations of the exceptions required by the runtime.
+ */
+#include "stdexcept.h"
+
+namespace std {
+
+exception::exception() throw() {}
+exception::~exception() {}
+exception::exception(const exception&) throw() {}
+exception& exception::operator=(const exception&) throw()
+{
+	return *this;
+}
+const char* exception::what() const throw()
+{
+	return "std::exception";
+}
+
+bad_alloc::bad_alloc() throw() {}
+bad_alloc::~bad_alloc() {}
+bad_alloc::bad_alloc(const bad_alloc&) throw() {}
+bad_alloc& bad_alloc::operator=(const bad_alloc&) throw()
+{
+	return *this;
+}
+const char* bad_alloc::what() const throw()
+{
+	return "cxxrt::bad_alloc";
+}
+
+
+
+bad_cast::bad_cast() throw() {}
+bad_cast::~bad_cast() {}
+bad_cast::bad_cast(const bad_cast&) throw() {}
+bad_cast& bad_cast::operator=(const bad_cast&) throw()
+{
+	return *this;
+}
+const char* bad_cast::what() const throw()
+{
+	return "std::bad_cast";
+}
+
+bad_typeid::bad_typeid() throw() {}
+bad_typeid::~bad_typeid() {}
+bad_typeid::bad_typeid(const bad_typeid &__rhs) throw() {}
+bad_typeid& bad_typeid::operator=(const bad_typeid &__rhs) throw()
+{
+	return *this;
+}
+
+const char* bad_typeid::what() const throw()
+{
+	return "std::bad_typeid";
+}
+
+} // namespace std
+

stdexcept.h

@@ -0,0 +1,61 @@
+/**
+ * stdexcept.h - provides a stub version of <stdexcept>, which defines enough
+ * of the exceptions for the runtime to use.  
+ */
+
+namespace std
+{
+
+	class exception
+	{
+	public:
+		exception() throw();
+		exception(const exception&) throw();
+		exception& operator=(const exception&) throw();
+		virtual ~exception();
+		virtual const char* what() const throw();
+	};
+
+
+	/**
+	 * Bad allocation exception.  Thrown by ::operator new() if it fails.
+	 */
+	class bad_alloc: public exception
+	{
+	public:
+		bad_alloc() throw();
+		bad_alloc(const bad_alloc&) throw();
+		bad_alloc& operator=(const bad_alloc&) throw();
+		~bad_alloc();
+		virtual const char* what() const throw();
+	};
+
+	/**
+	 * Bad cast exception.  Thrown by the __cxa_bad_cast() helper function.
+	 */
+	class bad_cast: public exception {
+	public:
+		bad_cast() throw();
+		bad_cast(const bad_cast&) throw();
+		bad_cast& operator=(const bad_cast&) throw();
+		virtual ~bad_cast();
+		virtual const char* what() const throw();
+	};
+
+	/**
+	 * Bad typeidexception.  Thrown by the __cxa_bad_typeid() helper function.
+	 */
+	class bad_typeid: public exception
+	{
+	public:
+		bad_typeid() throw();
+		bad_typeid(const bad_typeid &__rhs) throw();
+		virtual ~bad_typeid();
+		bad_typeid& operator=(const bad_typeid &__rhs) throw();
+		virtual const char* what() const throw();
+	};
+
+
+
+} // namespace std
+

terminate.cc

@@ -0,0 +1,14 @@
+#include <stdlib.h>
+
+namespace std
+{
+	/**
+	 * Stub implementation of std::terminate.  Used when the STL implementation
+	 * doesn't provide one.
+	 */
+	__attribute__((weak))
+	void terminate()
+	{
+		abort();
+	}
+}

typeinfo

@@ -0,0 +1,26 @@
+namespace std
+{
+	/**
+	  * Standard type info class.  The layout of this class is specified by the
+	  * ABI.
+	  */
+	class type_info
+	{
+		public:
+		/**
+		 * Virtual destructor.  This class must have one virtual function to
+		 * ensure that it has a vtable.
+		 */
+		virtual ~type_info();
+		bool operator==(const type_info &) const;
+		bool operator!=(const type_info &) const;
+		bool before(const type_info &) const;
+		const char* name() const;
+		type_info();
+		private:
+		type_info(const type_info& rhs);
+		type_info& operator= (const type_info& rhs);
+		const char *__type_name;
+	};
+}
+

typeinfo.cc

@@ -0,0 +1,83 @@
+#include "typeinfo.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+using std::type_info;
+
+type_info::~type_info() {}
+
+bool type_info::operator==(const type_info &other) const
+{
+	return __type_name == other.__type_name;
+}
+bool type_info::operator!=(const type_info &other) const
+{
+	return __type_name != other.__type_name;
+}
+bool type_info::before(const type_info &other) const
+{
+	return __type_name < other.__type_name;
+}
+const char* type_info::name() const
+{
+	return __type_name;
+}
+type_info::type_info (const type_info& rhs)
+{
+	__type_name = rhs.__type_name;
+}
+type_info& type_info::operator= (const type_info& rhs) 
+{
+	return *new type_info(rhs);
+}
+
+ABI_NAMESPACE::__fundamental_type_info::~__fundamental_type_info() {}
+ABI_NAMESPACE::__array_type_info::~__array_type_info() {}
+ABI_NAMESPACE::__function_type_info::~__function_type_info() {}
+ABI_NAMESPACE::__enum_type_info::~__enum_type_info() {}
+ABI_NAMESPACE::__class_type_info::~__class_type_info() {}
+ABI_NAMESPACE::__si_class_type_info::~__si_class_type_info() {}
+ABI_NAMESPACE::__vmi_class_type_info::~__vmi_class_type_info() {}
+ABI_NAMESPACE::__pbase_type_info::~__pbase_type_info() {}
+ABI_NAMESPACE::__pointer_type_info::~__pointer_type_info() {}
+ABI_NAMESPACE::__pointer_to_member_type_info::~__pointer_to_member_type_info() {}
+
+// From libelftc
+extern "C" char    *__cxa_demangle_gnu3(const char *);
+
+extern "C" char* __cxa_demangle(const char* mangled_name,
+                                char* buf,
+                                size_t* n,
+                                int* status)
+{
+	// TODO: We should probably just be linking against libelf-tc, rather than
+	// copying their code.  This requires them to do an actual release,
+	// however, and for our changes to be pushed upstream.  We also need to
+	// call a different demangling function here depending on the ABI (e.g.
+	// ARM).
+	char *demangled = __cxa_demangle_gnu3(mangled_name);
+	if (NULL != demangled)
+	{
+		size_t len = strlen(demangled);
+		buf = (char*)realloc(buf, len+1);
+		if (0 != buf)
+		{
+			memcpy(buf, demangled, len);
+			buf[len] = 0;
+			*n = len;
+			*status = 0;
+		}
+		else
+		{
+			*status = -1;
+		}
+		free(demangled);
+	}
+	else
+	{
+		*status = -2;
+		return NULL;
+	}
+	return buf;
+}

typeinfo.h

@@ -0,0 +1,200 @@
+#include <stddef.h>
+#include "abi_namespace.h"
+#include "typeinfo"
+
+namespace ABI_NAMESPACE
+{
+	/**
+	 * Primitive type info, for intrinsic types.
+	 */
+	struct __fundamental_type_info : public std::type_info
+	{
+		virtual ~__fundamental_type_info();
+	};
+	/**
+	 * Type info for arrays.  
+	 */
+	struct __array_type_info : public std::type_info
+	{
+		virtual ~__array_type_info();
+	};
+	/**
+	 * Type info for functions.
+	 */
+	struct __function_type_info : public std::type_info
+	{
+		virtual ~__function_type_info();
+	};
+	/**
+	 * Type info for enums.
+	 */
+	struct __enum_type_info : public std::type_info
+	{
+		virtual ~__enum_type_info();
+	};
+
+	/**
+	 * Base class for class type info.  Used only for tentative definitions.
+	 */
+	struct __class_type_info : public std::type_info
+	{
+		virtual ~__class_type_info();
+		/**
+		 * Function implementing dynamic casts.
+		 */
+		virtual void *cast_to(void *obj,
+		                      const struct __class_type_info *other) const;
+		/**
+		 * Function returning whether a cast from this type to another type is
+		 * possible.
+		 */
+		virtual bool can_cast_to(const struct __class_type_info *other) const;
+	};
+
+	/**
+	 * Single-inheritance class type info.  This is used for classes containing
+	 * a single non-virtual base class at offset 0.
+	 */
+	struct __si_class_type_info : public __class_type_info
+	{
+		virtual ~__si_class_type_info();
+		const __class_type_info *__base_type;
+		virtual void *cast_to(void *obj, const struct __class_type_info *other) const;
+        virtual bool can_cast_to(const struct __class_type_info *other) const;
+	};
+
+	/**
+	 * Type info for base classes.  Classes with multiple bases store an array
+	 * of these, one for each superclass.
+	 */
+	struct __base_class_type_info
+	{
+		const __class_type_info *__base_type;
+		private:
+			/**
+			 * The high __offset_shift bits of this store the (signed) offset
+			 * of the base class.  The low bits store flags from
+			 * __offset_flags_masks.
+			 */
+			long __offset_flags;
+			/**
+			 * Flags used in the low bits of __offset_flags.
+			 */
+			enum __offset_flags_masks
+			{
+				/** This base class is virtual. */
+				__virtual_mask = 0x1,
+				/** This base class is public. */
+				__public_mask = 0x2,
+				/** The number of bits reserved for flags. */
+				__offset_shift = 8
+			};
+		public:
+			/**
+			 * Returns the offset of the base class.
+			 */
+			long offset() const
+			{
+				return __offset_flags >> __offset_shift;
+			}
+			/**
+			 * Returns the flags.
+			 */
+			long flags() const
+			{
+				return __offset_flags & ((1 << __offset_shift) - 1);
+			}
+			/**
+			 * Returns whether this is a public base class.
+			 */
+			bool isPublic() const { return flags() & __public_mask; }
+			/**
+			 * Returns whether this is a virtual base class.
+			 */
+			bool isVirtual() const { return flags() & __virtual_mask; }
+	};
+
+	/**
+	 * Type info for classes with virtual bases or multiple superclasses.
+	 */
+	struct __vmi_class_type_info : public __class_type_info
+	{
+		virtual ~__vmi_class_type_info();
+		/** Flags describing this class.  Contains values from __flags_masks. */
+		unsigned int __flags;
+		/** The number of base classes. */
+		unsigned int __base_count;
+		/** 
+		 * Array of base classes - this actually has __base_count elements, not
+		 * 1.
+		 */
+		__base_class_type_info __base_info[1];
+
+		/**
+		 * Flags used in the __flags field.
+		 */
+		enum __flags_masks
+		{
+			/** The class has non-diamond repeated inheritance. */
+			__non_diamond_repeat_mask = 0x1,
+			/** The class is diamond shaped. */
+			__diamond_shaped_mask = 0x2
+		};
+		virtual void *cast_to(void *obj, const struct __class_type_info *other) const;
+        virtual bool can_cast_to(const struct __class_type_info *other) const;
+	};
+
+	/**
+	 * Base class used for both pointer and pointer-to-member type info.
+	 */
+	struct __pbase_type_info : public std::type_info
+	{
+		virtual ~__pbase_type_info();
+		/**
+		 * Flags.  Values from __masks.
+		 */
+		unsigned int __flags;
+		/**
+		 * The type info for the pointee.
+		 */
+		const std::type_info *__pointee;
+
+		/**
+		 * Masks used for qualifiers on the pointer.
+		 */
+		enum __masks
+		{
+			/** Pointer has const qualifier. */
+			__const_mask = 0x1,
+			/** Pointer has volatile qualifier. */
+			__volatile_mask = 0x2,
+			/** Pointer has restrict qualifier. */
+			__restrict_mask = 0x4,
+			/** Pointer points to an incomplete type. */
+			__incomplete_mask = 0x8,
+			/** Pointer is a pointer to a member of an incomplete class. */
+			__incomplete_class_mask = 0x10
+		};
+	};
+
+	/**
+	 * Pointer type info.
+	 */
+	struct __pointer_type_info : public __pbase_type_info
+	{
+		virtual ~__pointer_type_info();
+	};
+
+	/**
+	 * Pointer to member type info.
+	 */
+	struct __pointer_to_member_type_info : public __pbase_type_info
+	{
+		virtual ~__pointer_to_member_type_info();
+		/**
+		 * Pointer to the class containing this member.
+		 */
+		const __class_type_info *__context;
+	};
+
+}