/* The C++ exceptions runtime support

 *

 * Copyright 2002-2003 ARM Limited.

 */

/*

  Licence

  1. Subject to the provisions of clause 2, ARM hereby grants to LICENSEE a

  perpetual, non-exclusive, nontransferable, royalty free, worldwide licence

  to use this Example Implementation of Exception Handling solely for the

  purpose of developing, having developed, manufacturing, having

  manufactured, offering to sell, selling, supplying or otherwise

  distributing products which comply with the Exception Handling ABI for the

  ARM Architecture specification. All other rights are reserved to ARM or its

  licensors.

  2. THIS EXAMPLE IMPLEMENTATION OF EXCEPTION HANDLING  IS PROVIDED "AS IS"

  WITH NO WARRANTIES EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT LIMITED

  TO ANY WARRANTY OF SATISFACTORY QUALITY, MERCHANTABILITY, NONINFRINGEMENT

  OR FITNESS FOR A PARTICULAR PURPOSE.

*/

/*

 * RCS $Revision: 1.29.2.1 $

 * Checkin $Date: 2004/01/20 15:11:16 $

 * 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_begincatch_c

 * arm_exceptions_endcatch_c

 * arm_exceptions_bad_typeid_c

 * arm_exceptions_bad_cast_c

 */

#include <string.h>

#include <typeinfo>

#include <exception>

#include <new>

// Environment:

#include "unwind_env.h"

// Language-independent unwinder declarations:

#include "unwinder.h"

/* 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 PRINTED_DIAGNOSTICS for printed diagnostics.

 */

#ifdef DEBUG

#define PRINTED_DIAGNOSTICS

#endif

#ifdef PRINTED_DIAGNOSTICS

extern "C" int printf(const char *, ...);

#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.

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

};

/* --------- 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.

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

};

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

  void *__cxa_allocate_exception(size_t size);

  void __cxa_free_exception(void *);

  WEAKDECL void __cxa_throw(void *, const type_info *, cppdtorptr);

  void __cxa_rethrow(void);

  void *__cxa_begin_catch(UCB *);

  void __cxa_end_catch(void);

  void __cxa_end_cleanup(void);

  const type_info *__cxa_current_exception_type(void);

  // Protocol routines usually called only by the personality routine(s).

  void __cxa_call_terminate(UCB *);

  void __cxa_call_unexpected(UCB *);

  bool __cxa_begin_cleanup(UCB *);

  bool __cxa_type_match(UCB *, const std::type_info *, void **);

  // Auxilliary routines

  __cxa_eh_globals *__cxa_get_globals(void);

  void __cxa_bad_typeid(void);

  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:

static void __default_terminate_handler(void) {

  abort();

}

// If std::unexpected() is in the image, include a default handler for it:

namespace NAMES { WEAKDECL void default_unexpected_handler(void); }

// If this symbol is present, allocate an emergency buffer.

// As we aren't allowed static data, make it a function

extern "C" WEAKDECL void __ARM_exceptions_buffer_required(void);

// __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.

__cxa_eh_globals *__cxa_get_globals(void)

{

  __cxa_eh_globals *this_thread_globals = (__cxa_eh_globals *)(EH_GLOBALS);

  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_required == NULL)

      this_thread_globals->emergency_buffer = NULL;

    else

      this_thread_globals->emergency_buffer = __ARM_exceptions_buffer_init();

  }

  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

struct emergency_eco {

  __cxa_exception ep;

  std::bad_alloc b;

};

struct emergency_buffer {

  bool inuse;

  struct emergency_eco eco;

};

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

}

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

}

#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.

 */

bool std::uncaught_exception(void)

{

   __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.

 */

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

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

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

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

}

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