/* 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);