/* The C++ exceptions runtime support
*
* Copyright 2002-2005 ARM Limited. All rights reserved.
*
* Your rights to use this code are set out in the accompanying licence
* text file LICENCE.txt (ARM contract number LEC-ELA-00080 v1.0).
*/
/* Portions copyright Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). */
/*
* RCS $Revision: 92950 $
* Checkin $Date: 2005-10-12 11:08:47 +0100 (Wed, 12 Oct 2005) $
* Revising $Author: achapman $
*/
/* This source file is compiled automatically by ARM's make system into
* multiple object files. The source regions constituting object file
* xxx.o are delimited by ifdef xxx_c / endif directives.
*
* The source regions currently marked are:
* arm_exceptions_globs_c
* arm_exceptions_mem_c
* arm_exceptions_uncaught_c
* arm_exceptions_terminate_c
* arm_exceptions_setterminate_c
* arm_exceptions_unexpected_c
* arm_exceptions_setunexpected_c
* arm_exceptions_support_c
* arm_exceptions_callterm_c
* arm_exceptions_callunex_c
* arm_exceptions_currenttype_c
* arm_exceptions_alloc_c
* arm_exceptions_free_c
* arm_exceptions_throw_c
* arm_exceptions_rethrow_c
* arm_exceptions_foreign_c
* arm_exceptions_cleanup_c
* arm_exceptions_getexceptionptr_c
* arm_exceptions_begincatch_c
* arm_exceptions_endcatch_c
* arm_exceptions_bad_typeid_c
* arm_exceptions_bad_cast_c
*/
#include <string.h>
// Environment:
#include "unwind_env.h"
// Language-independent unwinder declarations:
#include "unwinder.h"
#ifdef __EPOC32__
/* Symbian specific support */
#include "symbian_support.h"
#endif
#include <new>
/* Barrier cache: */
/* Requirement imposed by C++ semantics module - pointer to match object in slot 0: */
#define BARRIER_HANDLEROBJECT (0)
/* Requirement imposed by C++ semantics module - function exception spec info */
#define BARRIER_FNSPECCOUNT (1)
#define BARRIER_FNSPECBASE (2)
#define BARRIER_FNSPECSTRIDE (3)
#define BARRIER_FNSPECARRAY (4)
/* By default, none of these routines are unwindable: */
#pragma noexceptions_unwind
/* For brevity: */
typedef _Unwind_Control_Block UCB;
using std::terminate_handler;
using std::unexpected_handler;
using std::terminate;
using std::unexpected;
using std::type_info;
/* Redeclare these interface routines as weak, so using them does not
* pull in the unwind library. We only want the unwind library if
* someone throws (or raises an exception from some other language).
*/
WEAKDECL NORETURNDECL void _Unwind_Resume(UCB *);
WEAKDECL void _Unwind_Complete(UCB *);
/* Diagnostics:
* Define DEBUG to get extra interfaces which assist debugging this functionality.
* Define CPP_DIAGNOSTICS for printed diagnostics.
*/
#ifdef DEBUG
#define CPP_DIAGNOSTICS
#endif
#ifdef CPP_DIAGNOSTICS
#ifndef __EPOC32__
extern "C" int printf(const char *, ...);
#endif
#endif
/* --------- "Exceptions_class" string for our implementation: --------- */
#define EXCEPTIONS_CLASS_SIZE 8
#define ARMCPP_EXCEPTIONS_CLASS "ARM\0C++\0"
/* --------- Exception control object: --------- */
// Type __cxa_exception is the combined C++ housekeeping (LEO) and UCB.
// It will be followed by the user exception object, hence must ensure
// the latter is aligned on an 8 byte boundary.
#ifndef __EPOC32__
struct __cxa_exception {
const type_info *exceptionType; // RTTI object describing the type of the exception
void *(*exceptionDestructor)(void *); // Destructor for the exception object (may be NULL)
unexpected_handler unexpectedHandler; // Handler in force after evaluating throw expr
terminate_handler terminateHandler; // Handler in force after evaluating throw expr
__cxa_exception *nextCaughtException; // Chain of "currently caught" c++ exception objects
uint32_t handlerCount; // Count of how many handlers this EO is "caught" in
__cxa_exception *nextPropagatingException; // Chain of objects saved over cleanup
uint32_t propagationCount; // Count of live propagations (throws) of this EO
UCB ucb; // Forces alignment of next item to 8-byte boundary
};
#endif
/* --------- Control "globals": --------- */
// We do this by putting all the thread-specific "globals" into a single
// area of store, which we allocate space for dynamically.
// We don't define a constructor for this; see comments with __cxa_get_globals.
#ifndef __EPOC32__
typedef void (*handler)(void);
struct __cxa_eh_globals {
uint32_t uncaughtExceptions; // counter
unexpected_handler unexpectedHandler; // per-thread handler
terminate_handler terminateHandler; // per-thread handler
bool implementation_ever_called_terminate; // true if it ever did
handler call_hook; // transient field to tell terminate/unexpected which hook to call
__cxa_exception *caughtExceptions; // chain of "caught" exceptions
__cxa_exception *propagatingExceptions; // chain of "propagating" (in cleanup) exceptions
void *emergency_buffer; // emergency buffer for when rest of heap full
};
#endif
/* ---------- Entry points: ---------- */
/* There is a little type-delicacy required here as __cxa_throw takes a
* function pointer. Setting aside the problem of not being able to form
* a pointer to a destructor in C++, if we simply say extern "C" here
* then the function pointer will also have C linkage and will be a
* pointer to a C function. This causes problems when __cxa_throw is
* defined (unless we repeat the extern "C" at the definition site) because
* the fnptr in the definition gets C++ linkage, hence that __cxa_throw has
* a different signature to the declared one, and so the function we wanted
* doesn't get defined at all.
* Maybe it should just take a void * but this seems more honest.
*/
typedef void *(*cppdtorptr)(void *);
extern "C" {
// Protocol routines called directly from application code
IMPORT_C void *__cxa_allocate_exception(size_t size);
IMPORT_C void __cxa_free_exception(void *);
WEAKDECL void __cxa_throw(void *, const type_info *, cppdtorptr);
IMPORT_C void __cxa_rethrow(void);
IMPORT_C void *__cxa_get_exception_ptr(UCB *);
void *__cxa_begin_catch(UCB *);
IMPORT_C void __cxa_end_catch(void);
IMPORT_C void __cxa_end_cleanup(void);
IMPORT_C const type_info *__cxa_current_exception_type(void);
// Protocol routines usually called only by the personality routine(s).
IMPORT_C void __cxa_call_terminate(UCB *);
IMPORT_C void __cxa_call_unexpected(UCB *);
IMPORT_C bool __cxa_begin_cleanup(UCB *);
typedef enum {
ctm_failed = 0,
ctm_succeeded = 1,
ctm_succeeded_with_ptr_to_base = 2
} __cxa_type_match_result;
IMPORT_C __cxa_type_match_result __cxa_type_match(UCB *, const std::type_info *,
bool is_reference_type, void **);
// Auxilliary routines
__cxa_eh_globals *__cxa_get_globals(void);
IMPORT_C void __cxa_bad_typeid(void);
IMPORT_C void __cxa_bad_cast(void);
// Emergency memory buffer management routines
void *__ARM_exceptions_buffer_init(void);
void *__ARM_exceptions_buffer_allocate(void *, size_t);
void *__ARM_exceptions_buffer_free(void *, void *);
}
// Support routines
#define NAMES __ARM
namespace NAMES {
void default_unexpected_handler(void);
void call_terminate_handler(UCB *);
void eh_catch_semantics(UCB *);
bool is_foreign_exception(UCB *);
bool same_exceptions_class(const void *, const void *);
__cxa_exception *get_foreign_intermediary(__cxa_exception *, UCB *);
}
// Macro: convert ucb pointer to __cxa_exception pointer
#define ucbp_to_ep(UCB_P) ((__cxa_exception *)((char *)(UCB_P) - offsetof(__cxa_exception, ucb)))
#ifdef arm_exceptions_globs_c
/* --------- Allocating and retrieving "globals": --------- */
// The exception-handling globals should be allocated per-thread.
// This is done here assuming the existance of a zero-initialised void*
// pointer location obtainable by the macro EH_GLOBALS.
// Default terminate handler:
#ifndef __EPOC32__
static void __default_terminate_handler(void) {
abort();
}
#endif
// If std::unexpected() is in the image, include a default handler for it:
namespace NAMES { WEAKDECL void default_unexpected_handler(void); }
// ARM's toolchain documentation states that if symbol
// __ARM_exceptions_buffer_required is present we should allocate
// an emergency buffer.
// As we aren't allowed static data in ARM library builds, reference the
// symbol by declaring it a function. This causes an additional problem when
// ARM libraries are built position-independent, namely that an absent
// function doesn't compare address-equal to NULL. So we have to get the
// "addresses" from two different compilation units and compare those.
// This is a known defect, to be fixed in the compiler.
extern "C" WEAKDECL void __ARM_exceptions_buffer_required(void);
extern void (*(__ARM_exceptions_buffer_required_address(void)))(void);
// The address comparison function only needs to be used when we are building
// position-independent. In other cases, comparing the address to NULL is more
// efficient.
#if 0
# define ARM_EXCEPTIONS_BUFFER_NOT_REQUIRED() (&__ARM_exceptions_buffer_required != __ARM_exceptions_buffer_required_address())
#else
# define ARM_EXCEPTIONS_BUFFER_NOT_REQUIRED() (&__ARM_exceptions_buffer_required == NULL)
#endif
// __cxa_eh_globals returns the per-thread memory. There are several complications,
// all of which relate to not touching the exceptions system while trying to
// initialise it:
// 1) We can't obtain memory by calling new or nothrow new as both of these use
// exceptions internally, so we must use malloc
// 2) We choose not to initialise the memory via placement new and a constructor,
// since placement new is declared with an empty function exception specification,
// which causes more of the exceptions system to always be pulled in.
// 3) We can't call terminate, as terminate looks in the memory we are trying to
// allocate.
EXPORT_C __cxa_eh_globals *__cxa_get_globals(void)
{
__cxa_eh_globals *this_thread_globals = (__cxa_eh_globals *)(EH_GLOBALS);
#ifndef __EPOC32__
/* The Symbian implementation allocates the required space on the threads stack
at thread creation and sets up thread local storage to point to the globals
which are also initialised
*/
if (this_thread_globals == NULL) {
// First call
// Obtain some memory: this is thread-safe provided malloc is.
this_thread_globals = (__cxa_eh_globals *)malloc(sizeof(__cxa_eh_globals));
if (this_thread_globals == NULL) abort(); // NOT terminate(), which calls this fn
// Save the pointer in the specially-provided location
EH_GLOBALS = this_thread_globals;
// Finally initialise the memory by hand
this_thread_globals->uncaughtExceptions = 0;
this_thread_globals->unexpectedHandler = NAMES::default_unexpected_handler;
this_thread_globals->terminateHandler = __default_terminate_handler;
this_thread_globals->implementation_ever_called_terminate = false;
this_thread_globals->call_hook = NULL;
this_thread_globals->caughtExceptions = NULL;
this_thread_globals->propagatingExceptions = NULL;
if (ARM_EXCEPTIONS_BUFFER_NOT_REQUIRED())
this_thread_globals->emergency_buffer = NULL;
else
this_thread_globals->emergency_buffer = __ARM_exceptions_buffer_init();
}
#endif
return this_thread_globals;
}
#endif /* arm_exceptions_globs_c */
#ifdef arm_exceptions_mem_c
/* --------- Emergency memory: --------- */
// It is possible to reserve memory for throwing bad_alloc when the heap
// is otherwise full. The ARM implementation provides hooks to do this.
// The default implementation reserves just enough space for a bad_alloc
// object, so if memory is later exhausted bad_alloc can still be thrown.
// Note there is no guarantee or requirement that the exception being
// thrown is actually bad_alloc.
// A usage flag and enough space for a bad_alloc exception control object
#ifndef __EPOC32__
struct emergency_eco {
__cxa_exception ep;
std::bad_alloc b;
};
struct emergency_buffer {
bool inuse;
struct emergency_eco eco;
};
#endif
#ifndef __EPOC32__
// The SymbianOS implementation allocates this space at thread creation
// Initialiser
void* __ARM_exceptions_buffer_init(void)
{
emergency_buffer *buffer = (emergency_buffer *)malloc(sizeof(emergency_buffer));
if (buffer == NULL) return NULL;
buffer->inuse = false;
return buffer;
}
#endif
// Allocator
void *__ARM_exceptions_buffer_allocate(void *buffer, size_t size)
{
emergency_buffer *b = (emergency_buffer *)buffer;
if (size > sizeof(emergency_eco) || b == NULL || b->inuse) return NULL;
b->inuse = true;
return &b->eco;
}
// Deallocator: Must return non-NULL if and only if it recognises
// and releases the supplied object
void *__ARM_exceptions_buffer_free(void *buffer, void *addr)
{
emergency_buffer *b = (emergency_buffer *)buffer;
if (b == NULL || addr != &b->eco) return NULL;
b->inuse = false;
return b;
}
# if 0
// Hook activation support - see comments earlier
extern "C" WEAKDECL void __ARM_exceptions_buffer_required(void);
void (*(__ARM_exceptions_buffer_required_address(void)))(void)
{
return &__ARM_exceptions_buffer_required;
}
# endif
#endif /* arm_exceptions_mem_c */
#ifdef arm_exceptions_uncaught_c
/* ---- uncaught_exception() ---- */
/* The EDG (and I think our) interpretation is that if the implementation
* ever called terminate(), uncaught_exception() should return true.
*/
#if __ARMCC_VERSION < 220000
bool std::uncaught_exception(void)
#else
EXPORT_C bool std::uncaught_exception(void)
#endif
{
__cxa_eh_globals *g = __cxa_get_globals();
return g->implementation_ever_called_terminate || g->uncaughtExceptions;
}
#endif /* arm_exceptions_uncaught_c */
#ifdef arm_exceptions_terminate_c
/* ---- terminate() etc ---- */
/* The behaviour of terminate() must differ between calls by the
* implementation and calls by the application. This is achieved by having the
* implementation set call_hook immediately before the call to terminate().
* The hook called by terminate() should terminate the program without
* returning to the caller. There is no requirement for terminate() itself to
* intercept throws.
*/
EXPORT_C void std::terminate(void)
{
__cxa_eh_globals *g = __cxa_get_globals();
if (g->call_hook != NULL) {
// Clear then call hook fn we were passed
handler call_hook = g->call_hook;
g->call_hook = NULL;
call_hook();
} else {
// Call global hook fn
g->terminateHandler();
}
// If hook fn returns:
abort();
}
#endif /* arm_exceptions_terminate_c */
#ifdef arm_exceptions_setterminate_c
EXPORT_C terminate_handler std::set_terminate(terminate_handler h) throw()
{
__cxa_eh_globals *g = __cxa_get_globals();
terminate_handler old = g->terminateHandler;
g->terminateHandler = h;
return old;
}
#endif /* arm_exceptions_setterminate_c */
#ifdef arm_exceptions_unexpected_c
/* ---- unexpected() etc ---- */
/* Comments as per terminate() */
void NAMES::default_unexpected_handler(void) {
terminate();
}
#pragma exceptions_unwind
EXPORT_C void std::unexpected(void)
{
__cxa_eh_globals *g = __cxa_get_globals();
if (g->call_hook != NULL) {
// Clear then call hook fn we were passed
handler call_hook = g->call_hook;
g->call_hook = NULL;
call_hook();
} else {
// Call global hook fn
g->unexpectedHandler();
}
// If hook fn returns:
abort();
}
#endif /* arm_exceptions_unexpected_c */
#ifdef arm_exceptions_setunexpected_c
EXPORT_C unexpected_handler std::set_unexpected(unexpected_handler h) throw()
{
__cxa_eh_globals *g = __cxa_get_globals();
unexpected_handler old = g->unexpectedHandler;
g->unexpectedHandler = h;
return old;
}
#endif /* arm_exceptions_setunexpected_c */
#ifdef arm_exceptions_support_c
/* ---------- Helper functions: ---------- */
/* Two routines to determine whether two exceptions objects share a layout.
* This is determined by checking whether the UCB exception_class members
* are identical.
* In principle we could use memcmp to perform this check (the code is
* given below) but the check is quite frequent and so that is costly.
* Therefore for efficiency we make use of the fact that the UCB is
* word aligned, that the exception_class member is consequently
* word aligned within it, and that we know the size of the member.
* We take care elsewhere to only ever call the routines with pointers
* to word-aligned addresses.
*/
#if 0
// Straightforward versions
bool NAMES::same_exceptions_class(const void *ec1, const void *ec2)
{
return memcmp(ec1, ec2, EXCEPTIONS_CLASS_SIZE) == 0; // identical
}
// One of our exception objects, or not?
bool NAMES::is_foreign_exception(UCB *ucbp)
{
return !NAMES::same_exceptions_class(&ucbp->exception_class, ARMCPP_EXCEPTIONS_CLASS);
}
#else
// Faster versions
bool NAMES::same_exceptions_class(const void *ec1, const void *ec2)
{
uint32_t *ip1 = (uint32_t *)ec1;
uint32_t *ip2 = (uint32_t *)ec2;
return ip1[0] == ip2[0] && ip1[1] == ip2[1];
}
// One of our exception objects, or not?
bool NAMES::is_foreign_exception(UCB *ucbp)
{
// Need a word-aligned copy of the string
static const union {
const char s[EXCEPTIONS_CLASS_SIZE+1]; int dummy;
} is_foreign_exception_static = {ARMCPP_EXCEPTIONS_CLASS};
return !NAMES::same_exceptions_class(&ucbp->exception_class, &is_foreign_exception_static.s);
}
#endif
#endif /* arm_exceptions_support_c */
#ifdef arm_exceptions_callterm_c
/* When the implementation wants to call terminate(), do the following:
* Mark the object as "caught" so it can be rethrown.
* Set the hook function for terminate() to call;
* Mark the fact that terminate() has been called by the implementation;
* We have to be careful - the implementation might encounter an error while
* unwinding a foreign exception, and also it is possible this might be
* called after failing to obtain a ucb.
*/
void NAMES::call_terminate_handler(UCB *ucbp)
{
__cxa_eh_globals *g = __cxa_get_globals();
if (ucbp == NULL) {
// Call global hook
g->call_hook = g->terminateHandler;
} else {
// Extract the hook to call
if (NAMES::is_foreign_exception(ucbp)) {
// Someone else's
g->call_hook = g->terminateHandler; // best we can do under the circumstances
} else {
// One of ours
__cxa_exception *ep = ucbp_to_ep(ucbp);
g->call_hook = ep->terminateHandler; // the one in force at the point of throw
}
}
g->implementation_ever_called_terminate = true;
terminate();
// never returns
}
EXPORT_C void __cxa_call_terminate(UCB *ucbp)
{
if (ucbp != NULL) // Record entry to (implicit) handler
__cxa_begin_catch(ucbp);
NAMES::call_terminate_handler(ucbp);
// never returns
}
#endif /* arm_exceptions_callterm_c */
#ifdef arm_exceptions_callunex_c
/* When the implementation wants to call unexpected(), do the following:
* Mark the object as "caught" so it can be rethrown.
* Set the hook function for unexpected() to call;
* Call unexpected and trap any throw to make sure it is acceptable.
* We have to be careful - the implementation might encounter an error while
* unwinding a foreign exception.
*/
#pragma exceptions_unwind
EXPORT_C void __cxa_call_unexpected(UCB *ucbp)
{
// Extract data we will need from the barrier cache before
// anyone has a chance to overwrite it
uint32_t rtti_count = ucbp->barrier_cache.bitpattern[BARRIER_FNSPECCOUNT];
uint32_t base = ucbp->barrier_cache.bitpattern[BARRIER_FNSPECBASE];
uint32_t stride = ucbp->barrier_cache.bitpattern[BARRIER_FNSPECSTRIDE];
uint32_t rtti_offset_array_addr = ucbp->barrier_cache.bitpattern[BARRIER_FNSPECARRAY];
// Also get the globals here and the eop
__cxa_eh_globals *g = __cxa_get_globals();
__cxa_exception *ep = ucbp_to_ep(ucbp);
#ifdef ARM_EXCEPTIONS_ENABLED
try {
#endif
// Record entry to (implicit) handler
__cxa_begin_catch(ucbp);
// Now extract the hook to call
if (NAMES::is_foreign_exception(ucbp)) {
// Someone else's
g->call_hook = g->unexpectedHandler; // best we can do under the circumstances
} else {
// One of ours
g->call_hook = ep->unexpectedHandler; // the one in force at the point of throw
}
unexpected(); // never returns normally, but might throw something
#ifdef ARM_EXCEPTIONS_ENABLED
} catch (...) {
// Unexpected() threw. This requires some delicacy.
// There are 2 possibilities:
// i) rethrow of the same object
// ii) throw of a new object
// Unexpected() is an implicit handler, and we manually called
// __cxa_begin_catch on the ingoing object. We need to call
// __cxa_end_catch on that object and, if the object is no longer
// being handled (possible in case ii), this will cause its destruction.
// The wrinkle is that in case ii the object is not on top of the catch
// stack because we just caught something else.
// Get hold of what was thrown (which we just caught).
__cxa_exception *epnew = g->caughtExceptions;
// Call __cxa_end_catch on the original object, taking care with the catch chain
if (epnew == ep) {
// rethrow - easy & safe - object is at top of chain and handlercount > 1
__cxa_end_catch();
} else {
// not rethrow - unchain the top (new) object, clean up the next one,
// and put the top object back
// unchain
g->caughtExceptions = epnew->nextCaughtException;
// assert g->caughtExceptions == ep now
// Decrement its handlercount (this might call a dtor if the count goes to 0,
// and the dtor might throw - if it does, just give up)
try {
__cxa_end_catch();
} catch(...) {
terminate();
}
// Chain back in
epnew->nextCaughtException = g->caughtExceptions;
g->caughtExceptions = epnew;
}
// See whether what was thrown is permitted, and in passing
// see if std::bad_exception is permitted
bool bad_exception_permitted = false;
uint32_t i;
for (i = 0; i < rtti_count; i++) {
void *matched_object;
type_info *fnspec;
if (EHABI_V2(ucbp))
fnspec = (type_info *)__ARM_resolve_target2((void *)rtti_offset_array_addr);
else
fnspec = (type_info *)(*(uint32_t *)rtti_offset_array_addr + base);
if (__cxa_type_match(&(epnew->ucb), fnspec, false, &matched_object)) {
#ifdef CPP_DIAGNOSTICS
printf("__cxa_call_unexpected: fnspec matched\n");
#endif
throw; // got a match - propagate it
}
if (typeid(std::bad_exception) == *fnspec)
bad_exception_permitted = true;
rtti_offset_array_addr += stride;
}
// There was no match...
if (bad_exception_permitted) throw std::bad_exception(); // transmute
// Otherwise call epnew's terminate handler
NAMES::call_terminate_handler(&epnew->ucb);
}
#endif
}
#endif /* arm_exceptions_callunex_c */
#ifdef arm_exceptions_currenttype_c
/* Yield the type of the currently handled exception, or null if none or the
* object is foreign.
*/
EXPORT_C const type_info *__cxa_current_exception_type(void)
{
__cxa_eh_globals *g = __cxa_get_globals();
__cxa_exception *ep = g->caughtExceptions;
if (ep == NULL || NAMES::is_foreign_exception(&ep->ucb)) return NULL;
return ep->exceptionType;
}
#endif /* arm_exceptions_currenttype_c */
#ifdef arm_exceptions_alloc_c
/* Allocate store for controlling an exception propagation */
EXPORT_C void *__cxa_allocate_exception(size_t size)
{
__cxa_eh_globals *g = __cxa_get_globals();
// Allocate store for a __cxa_exception header and the EO.
// Allocated store should be thread-safe and persistent, and must do
// something sensible if the allocation fails
size_t total_size = size + sizeof(__cxa_exception);
// coverity[alloc_fn]
__cxa_exception *ep = (__cxa_exception *)malloc(total_size);
if (ep == NULL) {
// Try the emergency memory pool
SYMBIAN_EH_SUPPORT_PRINTF("Trying emergency buffer: size %d\n", total_size);
ep = (__cxa_exception *)__ARM_exceptions_buffer_allocate(g->emergency_buffer, total_size);
if (ep == NULL) {
SYMBIAN_EH_SUPPORT_PRINTF("Emergency buffer allocation failed. Terminating\n");
NAMES::call_terminate_handler(NULL);
}
}
UCB *ucbp = &ep->ucb;
// Initialise the UCB
memcpy(ucbp->exception_class, ARMCPP_EXCEPTIONS_CLASS, EXCEPTIONS_CLASS_SIZE);
ucbp->exception_cleanup = NULL; /* initialise properly before throwing */
ucbp->unwinder_cache.reserved1 = 0; /* required to do this */
// Initialise parts of the LEO, in case copy-construction of the EO results
// in a need to call terminate (via __cxa_call_terminate)
ep->handlerCount = 0; // Not in any handlers
ep->nextCaughtException = NULL; // Not in any handlers
ep->nextPropagatingException = NULL; // Not saved over cleanup
ep->propagationCount = 0; // Not propagating
ep->terminateHandler = g->terminateHandler; // Cache current terminate handler
ep->unexpectedHandler = g->unexpectedHandler; // Cache current unexpected handler
// Return pointer to the EO
// coverity[memory_leak]
return ep + 1;
}
#endif /* arm_exceptions_alloc_c */
#ifdef arm_exceptions_free_c
/* Free store allocated by __cxa_allocate_exception */
EXPORT_C void __cxa_free_exception(void *eop)
{
__cxa_eh_globals *g = __cxa_get_globals();
char *ep = (char *)eop - sizeof(__cxa_exception);
if (__ARM_exceptions_buffer_free(g->emergency_buffer, ep)) return;
free(ep);
}
#endif /* arm_exceptions_free_c */
#ifdef arm_exceptions_throw_c
/* This routine is called when a foreign runtime catches one of our exception
* objects and then exits its catch by a means other than rethrow.
* We should clean it up as if we had caught it ourselves.
*/
static void external_exception_termination(_Unwind_Reason_Code c, UCB *ucbp)
{
NAMES::eh_catch_semantics(ucbp);
__cxa_end_catch();
}
/* Initiate a throw */
#pragma push
#pragma exceptions_unwind
EXPORT_C void __cxa_throw(void *eop, const type_info *t, cppdtorptr d)
{
__cxa_exception *ep = (__cxa_exception *)((char *)eop - sizeof(__cxa_exception));
UCB *ucbp = &ep->ucb;
// Initialise the remaining LEO and UCB fields not done by __cxa_allocate_exception
ucbp->exception_cleanup = external_exception_termination;
ep->exceptionType = t;
ep->exceptionDestructor = d;
ep->propagationCount = 1; // Propagating by 1 throw
// Increment the uncaught C++ exceptions count
__cxa_eh_globals *g = __cxa_get_globals();
g->uncaughtExceptions++;
// Tell debugger what's happening
DEBUGGER_BOTTLENECK(ucbp, _UASUBSYS_CPP, _UAACT_STARTING, t);
// Initiate unwinding - if we get control back, call C++ routine terminate()
_Unwind_RaiseException(ucbp);
#ifdef CPP_DIAGNOSTICS
printf("__cxa_throw: throw failed\n");
#endif
__cxa_call_terminate(ucbp);
}
#pragma pop
/* ----- Type matching: ----- */
/* This is located here so that (in ARM's implementation) it is only retained in
* an image if the application itself throws.
*/
/* Type matching functions.
* C++ DR126 says the matching rules for fnspecs are intended to be the same as
* those for catch:
* "A function is said to allow an exception of type E if its exception-specification
* contains a type T for which a handler of type T would be a match (15.3 except.handle)
* for an exception of type E."
* Thus we have a single type matching rule.
*/
/* Helper macros: */
#define CV_quals_of_pointee(P) (((const abi::__pbase_type_info *)(P))->__flags & \
(abi::__pbase_type_info::__const_mask | \
abi::__pbase_type_info::__volatile_mask))
#define is_const(QUALS) (((QUALS) & abi::__pbase_type_info::__const_mask) != 0)
#define any_qualifier_missing(TEST_QUALS, REF_QUALS) ((~(TEST_QUALS) & (REF_QUALS)) != 0)
/* A routine is required for derived class to base class conversion.
* This is obtained via a macro definition DERIVED_TO_BASE_CONVERSION
* in unwind_env.h.
*/
/* External entry point:
* Type check the c++ rtti object for compatibility against the type of
* the object containing the ucb. Return a pointer to the matched object
* (possibly a non-leftmost baseclass of the exception object)
*/
EXPORT_C __cxa_type_match_result __cxa_type_match(UCB *ucbp, const type_info *match_type,
bool is_reference_type, void **matched_objectpp)
{
if (NAMES::is_foreign_exception(ucbp))
return ctm_failed;
__cxa_exception *ep = ucbp_to_ep(ucbp);
const type_info *throw_type = ep->exceptionType;
bool previous_qualifiers_include_const = true; // for pointer qualification conversion
unsigned int pointer_depth = 0;
void *original_objectp = ep + 1;
void *current_objectp = original_objectp;
for (;;) {
// Match if identical
if (*throw_type == *match_type) {
*matched_objectpp = original_objectp;
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: success\n");
#endif
return ctm_succeeded;
}
// Fail if one is a pointer and the other isn't
const type_info &type_throw_type = typeid(*throw_type);
const type_info &type_match_type = typeid(*match_type);
if ((type_throw_type == typeid(abi::__pointer_type_info) ||
type_match_type == typeid(abi::__pointer_type_info)) &&
type_throw_type != type_match_type) {
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: failed (mixed ptr/non-ptr)\n");
#endif
return ctm_failed;
}
// Both are pointers or neither is
if (type_throw_type == typeid(abi::__pointer_type_info)) {
// Both are pointers
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: throwing a ptr\n");
#endif
pointer_depth++;
// Check match_type is at least as CV-qualified as throw_type
unsigned int match_quals = CV_quals_of_pointee(match_type);
unsigned int throw_quals = CV_quals_of_pointee(throw_type);
if (any_qualifier_missing(match_quals, throw_quals)) {
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: failed (missing qualifiers)\n");
#endif
return ctm_failed;
}
// If the match type has additional qualifiers not found in the
// throw type, any previous qualifiers must have included const
if (any_qualifier_missing(throw_quals, match_quals) &&
!previous_qualifiers_include_const) {
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: failed (not all qualifiers have const)\n");
#endif
return ctm_failed;
}
if (!is_const(match_quals))
previous_qualifiers_include_const = false;
throw_type = ((const abi::__pbase_type_info *)throw_type)->__pointee;
match_type = ((const abi::__pbase_type_info *)match_type)->__pointee;
if (current_objectp != NULL)
current_objectp = *(void **)current_objectp;
continue;
}
// Neither is a pointer now but qualification conversion has been done.
// See if pointer conversion on the original was possible.
// T* will match void*
if (pointer_depth == 1 && *match_type == typeid(void)) {
if (is_reference_type) {
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: failed (void *&)\n");
#endif
return ctm_failed;
} else {
*matched_objectpp = original_objectp;
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: success (conversion to void *)\n");
#endif
return ctm_succeeded;
}
}
// Else if we have 2 (different) class types, a derived class is matched by a
// non-ambiguous public base class (perhaps not a leftmost one) and a
// pointer to a derived class is matched by a non-reference pointer to
// non-ambiguous public base class (perhaps not a leftmost one).
// __si_class_type_info and __vmi_class_type_info are classes with bases.
void *matched_base_p;
if ((pointer_depth == 0 || (pointer_depth == 1 && !is_reference_type)) &&
(type_throw_type == typeid(abi::__si_class_type_info) ||
type_throw_type == typeid(abi::__vmi_class_type_info))) {
if (DERIVED_TO_BASE_CONVERSION(current_objectp, &matched_base_p,
throw_type, match_type)) {
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: success (matched base 0x%x of 0x%x%s, thrown object 0x%x)\n",
matched_base_p, current_objectp,
pointer_depth == 0 ? "" : " via ptr",
original_objectp);
#endif
*matched_objectpp = matched_base_p;
return pointer_depth == 0 ? ctm_succeeded : ctm_succeeded_with_ptr_to_base;
} else {
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: failed (derived to base failed or ref to base pointer)\n");
#endif
return ctm_failed;
}
}
#ifdef CPP_DIAGNOSTICS
printf("__cxa_type_match: failed (types simply differ)\n");
#endif
return ctm_failed;
} /* for */
}
/* For debugging purposes: */
#ifdef DEBUG
extern "C" bool debug__cxa_type_match(void *objptr,
const type_info *throw_type,
const type_info *catch_type,
void **matched_objectpp)
{
/* Create enough of an exception object that the type-matcher can run, then
* check the type. Objptr is expected to be the result of a call to
* __cxa_allocate_exception, which has then been copy-constructed.
*/
__cxa_exception *e = ((__cxa_exception *)objptr) - 1;
e->exceptionType = throw_type;
return __cxa_type_match(&e->ucb, catch_type, false, matched_objectpp);
}
#endif
#endif /* arm_exceptions_throw_c */
#ifdef arm_exceptions_rethrow_c
/* Redeclare _Unwind_RaiseException as weak (if WEAKDECL is defined
* appropriately) so the use from __cxa_rethrow does not on its own
* force the unwind library to be loaded.
*/
extern "C" WEAKDECL _Unwind_Reason_Code _Unwind_RaiseException(UCB *ucbp);
#pragma exceptions_unwind
EXPORT_C void __cxa_rethrow(void)
{
// Recover the exception object - it is the most recent caught exception object
__cxa_eh_globals *g = __cxa_get_globals();
__cxa_exception *ep = g->caughtExceptions;
bool foreign;
// Must call terminate here if no such exception
if (ep == NULL) NAMES::call_terminate_handler(NULL);
UCB *ucbp = &ep->ucb;
// Mark the object as being propagated by throw, preventing multiple
// propagation and also permitting __cxa_end_catch to do the right
// thing when it is called from the handler's cleanup.
ep->propagationCount++;
// Now reraise, taking care with foreign exceptions
foreign = NAMES::is_foreign_exception(ucbp);
if (foreign) {
// Indirect through the intermediate object to the foreign ucb
ucbp = (UCB *)ep->exceptionType;
} else {
// Increment the uncaught C++ exceptions count
g->uncaughtExceptions++;
}
// Tell debugger what's happening
DEBUGGER_BOTTLENECK(ucbp, _UASUBSYS_CPP, _UAACT_STARTING, foreign ? NULL : ep->exceptionType);
// Initiate unwinding - if we get control back, call C++ routine terminate()
_Unwind_RaiseException(ucbp);
#ifdef CPP_DIAGNOSTICS
printf("__cxa_rethrow: throw failed\n");
#endif
__cxa_call_terminate(ucbp);
}
#endif /* arm_exceptions_rethrow_c */
#ifdef arm_exceptions_foreign_c
/* During catch and cleanup, foreign exception objects are dealt with using
* an intermediate __cxa_exception block in the appropriate exceptions
* chain. This block has the same exception_class as the real foreign
* ucb, and points to the real ucb via the intermediate block's exceptionType
* field. This helper function checks whether it has been passed such an
* intermediate block and sets one up if not. Only call it when the UCB
* is known to belong to a foreign exception.
*/
__cxa_exception *NAMES::get_foreign_intermediary(__cxa_exception *head_ep, UCB *ucbp)
{
if (head_ep != NULL) {
UCB *head_ucbp = &head_ep->ucb;
if (NAMES::same_exceptions_class(&head_ucbp->exception_class, &ucbp->exception_class) &&
(UCB *)head_ep->exceptionType == ucbp)
return head_ep;
}
// Create an intermediate block. Only initialise as much as necessary
__cxa_exception *ep = ((__cxa_exception *)__cxa_allocate_exception(0)) - 1;
UCB *new_ucbp = &ep->ucb;
memcpy(new_ucbp->exception_class, ucbp->exception_class, EXCEPTIONS_CLASS_SIZE);
ep->propagationCount = 0; // Not propagating
ep->handlerCount = 0; // Not handled
ep->nextCaughtException = NULL; // Not in chain
ep->exceptionType = (const type_info *)ucbp; // The foreign UCB
return ep;
}
#endif /* arm_exceptions_foreign_c */
#ifdef arm_exceptions_cleanup_c
EXPORT_C bool __cxa_begin_cleanup(UCB *ucbp)
{
// Indicate that a cleanup is about to start.
// Save the exception pointer over the cleanup for recovery later, using a chain.
// If we allowed the exception to be rethrown in a cleanup, then
// the object might appear multiple times at the head of this chain,
// and the propagationCount could be used to track this - at this point,
// the object is logically in the chain propagationCount-1 times, and
// physically 0 or 1 times. Thus if propagationCount == 1 we should insert
// it physically. A similar rule is used for physical removal in
//__cxa_end_cleanup.
// Foreign exceptions are handled via an intermediate __cxa_exception object
// in a similar way as __cxa_begin_catch.
__cxa_eh_globals *g = __cxa_get_globals();
__cxa_exception *ep;
if (NAMES::is_foreign_exception(ucbp)) {
// coverity[alloc_fn] coverity[var_assign]
ep = NAMES::get_foreign_intermediary(g->propagatingExceptions, ucbp);
ep->propagationCount++; // Indicate one (or one additional) propagation
} else {
ep = ucbp_to_ep(ucbp);
}
if (ep->propagationCount == 1) {
// Insert into chain
ep->nextPropagatingException = g->propagatingExceptions;
g->propagatingExceptions = ep;
}
// coverity[leaked_storage]
return true;
}
// Helper function for __cxa_end_cleanup
extern "C" UCB * __ARM_cxa_end_cleanup(void)
{
// Recover and return the currently propagating exception (from the
// head of the propagatingExceptions chain).
// propagationCount at this moment is a logical count of how many times the
// item is in the chain so physically unchain it when this count is 1.
// Foreign exceptions use an intermediary.
__cxa_eh_globals *g = __cxa_get_globals();
__cxa_exception *ep = g->propagatingExceptions;
if (ep == NULL) terminate();
UCB *ucbp = &ep->ucb;
if (NAMES::is_foreign_exception(ucbp)) {
// Get the foreign ucb
ucbp = (UCB *)ep->exceptionType;
if (ep->propagationCount == 1) {
// Free the intermediate ucb (see description in __cxa_begin_catch)
void *eop = (void *)(ep + 1);
g->propagatingExceptions = ep->nextPropagatingException;
__cxa_free_exception(eop);
} else {
ep->propagationCount--;
}
} else {
// Not foreign
if (ep->propagationCount == 1) { // logically in chain once - so unchain
g->propagatingExceptions = ep->nextPropagatingException;
}
}
return ucbp;
}
// __cxa_end_cleanup is called at the end of a cleanup fragment.
// It must do the C++ housekeeping, then call _Unwind_Resume, but it must
// damage no significant registers in the process.
EXPORT_C __asm void __cxa_end_cleanup(void) {
extern __ARM_cxa_end_cleanup;
extern _Unwind_Resume WEAKASMDECL;
#ifdef __thumb
preserve8; // This is preserve8 (ARM assembler heuristics are inadequate)
push {r1-r7};
mov r2, r8;
mov r3, r9;
mov r4, r10;
mov r5, r11;
push {r1-r5};
bl __ARM_cxa_end_cleanup; // returns UCB address in r0
pop {r1-r5};
mov r8, r2;
mov r9, r3;
mov r10, r4;
mov r11, r5;
pop {r1-r7};
bl _Unwind_Resume; // won't return
#else
stmfd r13!, {r1-r12}
bl __ARM_cxa_end_cleanup; // returns UCB address in r0
ldmia r13!, {r1-r12};
b _Unwind_Resume; // won't return
#endif
}
#endif /* arm_exceptions_cleanup_c */
#ifdef arm_exceptions_catchsemantics_c
/* Update date structures as if catching an object.
* Call this from __cxa_begin_catch when actually catching an object,
* and from external_exception_termination when called by a foreign runtime
* after one of our objects was caught.
*/
void NAMES::eh_catch_semantics(UCB *ucbp)
{
__cxa_eh_globals *g = __cxa_get_globals();
__cxa_exception *ep;
if (NAMES::is_foreign_exception(ucbp)) {
// Foreign exception. Get the associated intermediary block or
// make one if there isn't one already.
// In the case of a rethrow, the foreign object may already be on
// the handled exceptions chain (it will be first).
// coverity[alloc_fn] coverity[var_assign]
ep = NAMES::get_foreign_intermediary(g->caughtExceptions, ucbp);
} else {
// Not foreign
ep = ucbp_to_ep(ucbp);
// Decrement the propagation count
ep->propagationCount--;
// Decrement the total uncaught C++ exceptions count
g->uncaughtExceptions--;
}
// Common code for our EO's, and foreign ones where we work on the intermediate EO
// Increment the handler count for this exception object
ep->handlerCount++;
// Push the ep onto the "handled exceptions" chain if it is not already there.
// (If catching a rethrow, it may already be there)
if (ep->nextCaughtException == NULL) {
ep->nextCaughtException = g->caughtExceptions;
g->caughtExceptions = ep;
}
// coverity[leaked_storage]
}
#endif /* arm_exceptions_catchsemantics_c */
#ifdef arm_exceptions_getexceptionptr_c
EXPORT_C void *__cxa_get_exception_ptr(UCB *ucbp)
{
return (void *)ucbp->barrier_cache.bitpattern[BARRIER_HANDLEROBJECT]; // The matched object, if any
}
#endif /* arm_exceptions_getexceptionptr_c */
#ifdef arm_exceptions_begincatch_c
void *__cxa_begin_catch(UCB *ucbp)
{
void *match = (void *)ucbp->barrier_cache.bitpattern[BARRIER_HANDLEROBJECT]; // The matched object, if any
// Update the data structures
NAMES::eh_catch_semantics(ucbp);
// Tell the unwinder the exception propagation has finished,
// and return the object pointer
_Unwind_Complete(ucbp);
return match;
}
#endif /* arm_exceptions_begincatch_c */
#ifdef arm_exceptions_endcatch_c
#pragma exceptions_unwind
EXPORT_C void __cxa_end_catch(void)
{
// Recover the exception object - it is the most recent caught exception object
__cxa_eh_globals *g = __cxa_get_globals();
__cxa_exception *ep = g->caughtExceptions;
if (ep == NULL) terminate();
// Rethrow in progress?
bool object_being_rethrown = ep->propagationCount != 0;
// Decrement the handler count for this exception object
ep->handlerCount--;
// Unstack the object if it is no longer being handled anywhere.
// Destroy and free the object if it is no longer alive -
// it is dead if its handler count becomes 0, unless it is
// about to be rethrown.
// If the dtor throws, allow its exception to propagate.
// Do different things if it is a foreign exception object.
if (ep->handlerCount == 0) {
void *eop = (void *)(ep + 1);
UCB *ucbp = &ep->ucb;
bool foreign = NAMES::is_foreign_exception(ucbp);
// Unstack it from the caught exceptions stack - it is guaranteed to be top item.
g->caughtExceptions = ep->nextCaughtException;
if (foreign) {
// Get the foreign ucb and free the intermediate ucb (see description in __cxa_begin_catch)
ucbp = (UCB *)ep->exceptionType;
__cxa_free_exception(eop);
} else {
ep->nextCaughtException = NULL; // So __cxa_begin_catch knows it isn't in the chain
}
// Now destroy the exception object if it's no longer needed
if (!object_being_rethrown) {
if (foreign) {
// Notify the foreign language, if it so requested
if (ucbp->exception_cleanup != NULL)
(ucbp->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT, ucbp);
} else {
// One of our objects: do C++-specific semantics
if (ep->exceptionDestructor != NULL) {
// Run the dtor. If it throws, free the memory anyway and
// propagate the new exception.
#ifdef ARM_EXCEPTIONS_ENABLED
try {
(ep->exceptionDestructor)(eop);
} catch(...) {
// Free the memory and reraise
__cxa_free_exception(eop);
throw;
}
#else
(ep->exceptionDestructor)(eop);
#endif
}
// Dtor (if there was one) didn't throw. Free the memory.
__cxa_free_exception(eop);
} // !foreign
} // !object_being_rethrown
} // ep->handlerCount == 0
}
#endif /* arm_exceptions_endcatch_c */
#ifdef arm_exceptions_bad_typeid_c
#pragma exceptions_unwind
EXPORT_C void __cxa_bad_typeid(void)
{
throw std::bad_typeid();
}
#endif /* arm_exceptions_bad_typeid_c */
#ifdef arm_exceptions_bad_cast_c
#pragma exceptions_unwind
EXPORT_C void __cxa_bad_cast(void)
{
throw std::bad_cast();
}
#endif /* arm_exceptions_bad_cast_c */